moving squid NS/KNF to magma folder

hackfest_squid_cnf/charms/squid/README.md

-# squid-k8s Charm
-
-## Overview
-
-This is a Kuberentes Charm to deploy [Squid Cache](http://www.squid-cache.org/).
-
-Sugested Actions for this charm:
-* Set allowed URLs
-  Possible way to run action: `juju run-action squid/0 addurl url=google.com`
-* Stop/Start/Restart the squid service - done
-  Run like this: `juju run-action squid/0 restart`
-* Set ftp, http, https proxies
-
-## Quickstart
-
-If you don't have microk8s and juju installed executing the following commands:
-```
-sudo snap install juju --classic
-sudo snap install microk8s --classic
-juju bootstrap microk8s
-juju add-model squid
-```
-
-Afterwards clone the repository and deploy the charm
-```
-git clone https://github.com/DomFleischmann/charm-squid-k8s.git
-cd charm-squid-k8s
-git submodule update --init
-juju deploy .
-```
-Check if the charm is deployed correctly with `juju status`
-
-To test the `addurl` action open another terminal and type the following command:
-`export https_proxy=http://<squid-ip>:3128`
-
-Where squid-ip is the Squid App Address shown in `juju status`
-
-Now when executing `curl https://www.google.com` squid will block access to the url
-
-Execute the `addurl` action:
-`juju run-action squid/0 addurl url=google.com`
-
-Now when executing `curl https://www.google.com` it will give you the google output.
-
-## Contact
- - Author: Dominik Fleischmann <dominik.fleischmann@canonical.com>
- - Bug Tracker: [here](https://github.com/DomFleischmann/charm-squid-k8s)

hackfest_squid_cnf/charms/squid/actions.yaml

-addurl:
-    description: "Add squid config"
-    params:
-        url:
-            description: "URL that will be allowed"
-            type: string
-            default: ""
-start:
-    description: "Start squid service"
-restart:
-    description: "Retart squid service"
-stop:
-    description: "Stop squid service"

hackfest_squid_cnf/charms/squid/actions/addurl

-#!/bin/bash
-
-URL=`action-get url`
-
-if ! grep -Fxq "http_access allow allowedurls" /etc/squid/squid.conf
-then
-    sed  -i '/^# And finally deny all .*/i http_access allow allowedurls\n' /etc/squid/squid.conf
-fi
-
-sed -i "/^http_access allow allowedurls.*/i acl allowedurls dstdomain \.$URL" /etc/squid/squid.conf
-
-kill -HUP `cat /var/run/squid.pid`
-

hackfest_squid_cnf/charms/squid/actions/restart

-#!/bin/bash
-service squid restart

hackfest_squid_cnf/charms/squid/actions/start

-#!/bin/bash
-service squid start

hackfest_squid_cnf/charms/squid/actions/stop

-#!/bin/bash
-service squid stop

hackfest_squid_cnf/charms/squid/config.yaml

-options:
-    image:
-        type: string
-        description: 'Docker image for squid'
-        default: 'sameersbn/squid:latest'
-    port:
-        type: int
-        description: 'Port'
-        default: 3128

hackfest_squid_cnf/charms/squid/hooks/install

-../src/charm.py
\ No newline at end of file

hackfest_squid_cnf/charms/squid/lib/ops/__init__.py

-# Copyright 2020 Canonical Ltd.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""The Operator Framework."""
-
-# Import here the bare minimum to break the circular import between modules
-from . import charm  # NOQA

hackfest_squid_cnf/charms/squid/lib/ops/jujuversion.py

-# Copyright 2020 Canonical Ltd.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import re
-from functools import total_ordering
-
-
-@total_ordering
-class JujuVersion:
-
-    PATTERN = r'''^
-    (?P<major>\d{1,9})\.(?P<minor>\d{1,9})       # <major> and <minor> numbers are always there
-    ((?:\.|-(?P<tag>[a-z]+))(?P<patch>\d{1,9}))? # sometimes with .<patch> or -<tag><patch>
-    (\.(?P<build>\d{1,9}))?$                     # and sometimes with a <build> number.
-    '''
-
-    def __init__(self, version):
-        m = re.match(self.PATTERN, version, re.VERBOSE)
-        if not m:
-            raise RuntimeError('"{}" is not a valid Juju version string'.format(version))
-
-        d = m.groupdict()
-        self.major = int(m.group('major'))
-        self.minor = int(m.group('minor'))
-        self.tag = d['tag'] or ''
-        self.patch = int(d['patch'] or 0)
-        self.build = int(d['build'] or 0)
-
-    def __repr__(self):
-        if self.tag:
-            s = '{}.{}-{}{}'.format(self.major, self.minor, self.tag, self.patch)
-        else:
-            s = '{}.{}.{}'.format(self.major, self.minor, self.patch)
-        if self.build > 0:
-            s += '.{}'.format(self.build)
-        return s
-
-    def __eq__(self, other):
-        if self is other:
-            return True
-        if isinstance(other, str):
-            other = type(self)(other)
-        elif not isinstance(other, JujuVersion):
-            raise RuntimeError('cannot compare Juju version "{}" with "{}"'.format(self, other))
-        return (
-            self.major == other.major
-            and self.minor == other.minor
-            and self.tag == other.tag
-            and self.build == other.build
-            and self.patch == other.patch)
-
-    def __lt__(self, other):
-        if self is other:
-            return False
-        if isinstance(other, str):
-            other = type(self)(other)
-        elif not isinstance(other, JujuVersion):
-            raise RuntimeError('cannot compare Juju version "{}" with "{}"'.format(self, other))
-
-        if self.major != other.major:
-            return self.major < other.major
-        elif self.minor != other.minor:
-            return self.minor < other.minor
-        elif self.tag != other.tag:
-            if not self.tag:
-                return False
-            elif not other.tag:
-                return True
-            return self.tag < other.tag
-        elif self.patch != other.patch:
-            return self.patch < other.patch
-        elif self.build != other.build:
-            return self.build < other.build
-        return False

hackfest_squid_cnf/charms/squid/lib/ops/log.py

-# Copyright 2020 Canonical Ltd.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import logging
-
-
-class JujuLogHandler(logging.Handler):
-    """A handler for sending logs to Juju via juju-log."""
-
-    def __init__(self, model_backend, level=logging.DEBUG):
-        super().__init__(level)
-        self.model_backend = model_backend
-
-    def emit(self, record):
-        self.model_backend.juju_log(record.levelname, self.format(record))
-
-
-def setup_root_logging(model_backend, debug=False):
-    """Setup python logging to forward messages to juju-log.
-
-    By default, logging is set to DEBUG level, and messages will be filtered by Juju.
-    Charmers can also set their own default log level with::
-
-      logging.getLogger().setLevel(logging.INFO)
-
-    model_backend -- a ModelBackend to use for juju-log
-    debug -- if True, write logs to stderr as well as to juju-log.
-    """
-    logger = logging.getLogger()
-    logger.setLevel(logging.DEBUG)
-    logger.addHandler(JujuLogHandler(model_backend))
-    if debug:
-        handler = logging.StreamHandler()
-        formatter = logging.Formatter('%(asctime)s %(levelname)-8s %(message)s')
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)

hackfest_squid_cnf/charms/squid/lib/ops/main.py

-#!/usr/bin/env python3
-# Copyright 2019 Canonical Ltd.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-import yaml
-
-import ops.charm
-import ops.framework
-import ops.model
-import logging
-
-from ops.log import setup_root_logging
-
-CHARM_STATE_FILE = '.unit-state.db'
-
-
-logger = logging.getLogger()
-
-
-def _get_charm_dir():
-    charm_dir = os.environ.get("JUJU_CHARM_DIR")
-    if charm_dir is None:
-        # Assume $JUJU_CHARM_DIR/lib/op/main.py structure.
-        charm_dir = Path('{}/../../..'.format(__file__)).resolve()
-    else:
-        charm_dir = Path(charm_dir).resolve()
-    return charm_dir
-
-
-def _load_metadata(charm_dir):
-    metadata = yaml.safe_load((charm_dir / 'metadata.yaml').read_text())
-
-    actions_meta = charm_dir / 'actions.yaml'
-    if actions_meta.exists():
-        actions_metadata = yaml.safe_load(actions_meta.read_text())
-    else:
-        actions_metadata = {}
-    return metadata, actions_metadata
-
-
-def _create_event_link(charm, bound_event):
-    """Create a symlink for a particular event.
-
-    charm -- A charm object.
-    bound_event -- An event for which to create a symlink.
-    """
-    if issubclass(bound_event.event_type, ops.charm.HookEvent):
-        event_dir = charm.framework.charm_dir / 'hooks'
-        event_path = event_dir / bound_event.event_kind.replace('_', '-')
-    elif issubclass(bound_event.event_type, ops.charm.ActionEvent):
-        if not bound_event.event_kind.endswith("_action"):
-            raise RuntimeError(
-                'action event name {} needs _action suffix'.format(bound_event.event_kind))
-        event_dir = charm.framework.charm_dir / 'actions'
-        # The event_kind is suffixed with "_action" while the executable is not.
-        event_path = event_dir / bound_event.event_kind[:-len('_action')].replace('_', '-')
-    else:
-        raise RuntimeError(
-            'cannot create a symlink: unsupported event type {}'.format(bound_event.event_type))
-
-    event_dir.mkdir(exist_ok=True)
-    if not event_path.exists():
-        # CPython has different implementations for populating sys.argv[0] for Linux and Windows.
-        # For Windows it is always an absolute path (any symlinks are resolved)
-        # while for Linux it can be a relative path.
-        target_path = os.path.relpath(os.path.realpath(sys.argv[0]), str(event_dir))
-
-        # Ignore the non-symlink files or directories
-        # assuming the charm author knows what they are doing.
-        logger.debug(
-            'Creating a new relative symlink at %s pointing to %s',
-            event_path, target_path)
-        event_path.symlink_to(target_path)
-
-
-def _setup_event_links(charm_dir, charm):
-    """Set up links for supported events that originate from Juju.
-
-    Whether a charm can handle an event or not can be determined by
-    introspecting which events are defined on it.
-
-    Hooks or actions are created as symlinks to the charm code file
-    which is determined by inspecting symlinks provided by the charm
-    author at hooks/install or hooks/start.
-
-    charm_dir -- A root directory of the charm.
-    charm -- An instance of the Charm class.
-
-    """
-    for bound_event in charm.on.events().values():
-        # Only events that originate from Juju need symlinks.
-        if issubclass(bound_event.event_type, (ops.charm.HookEvent, ops.charm.ActionEvent)):
-            _create_event_link(charm, bound_event)
-
-
-def _emit_charm_event(charm, event_name):
-    """Emits a charm event based on a Juju event name.
-
-    charm -- A charm instance to emit an event from.
-    event_name -- A Juju event name to emit on a charm.
-    """
-    event_to_emit = None
-    try:
-        event_to_emit = getattr(charm.on, event_name)
-    except AttributeError:
-        logger.debug("event %s not defined for %s", event_name, charm)
-
-    # If the event is not supported by the charm implementation, do
-    # not error out or try to emit it. This is to support rollbacks.
-    if event_to_emit is not None:
-        args, kwargs = _get_event_args(charm, event_to_emit)
-        logger.debug('Emitting Juju event %s', event_name)
-        event_to_emit.emit(*args, **kwargs)
-
-
-def _get_event_args(charm, bound_event):
-    event_type = bound_event.event_type
-    model = charm.framework.model
-
-    if issubclass(event_type, ops.charm.RelationEvent):
-        relation_name = os.environ['JUJU_RELATION']
-        relation_id = int(os.environ['JUJU_RELATION_ID'].split(':')[-1])
-        relation = model.get_relation(relation_name, relation_id)
-    else:
-        relation = None
-
-    remote_app_name = os.environ.get('JUJU_REMOTE_APP', '')
-    remote_unit_name = os.environ.get('JUJU_REMOTE_UNIT', '')
-    if remote_app_name or remote_unit_name:
-        if not remote_app_name:
-            if '/' not in remote_unit_name:
-                raise RuntimeError('invalid remote unit name: {}'.format(remote_unit_name))
-            remote_app_name = remote_unit_name.split('/')[0]
-        args = [relation, model.get_app(remote_app_name)]
-        if remote_unit_name:
-            args.append(model.get_unit(remote_unit_name))
-        return args, {}
-    elif relation:
-        return [relation], {}
-    return [], {}
-
-
-def main(charm_class):
-    """Setup the charm and dispatch the observed event.
-
-    The event name is based on the way this executable was called (argv[0]).
-    """
-    charm_dir = _get_charm_dir()
-
-    model_backend = ops.model.ModelBackend()
-    debug = ('JUJU_DEBUG' in os.environ)
-    setup_root_logging(model_backend, debug=debug)
-
-    # Process the Juju event relevant to the current hook execution
-    # JUJU_HOOK_NAME, JUJU_FUNCTION_NAME, and JUJU_ACTION_NAME are not used
-    # in order to support simulation of events from debugging sessions.
-    #
-    # TODO: For Windows, when symlinks are used, this is not a valid
-    #       method of getting an event name (see LP: #1854505).
-    juju_exec_path = Path(sys.argv[0])
-    has_dispatch = juju_exec_path.name == 'dispatch'
-    if has_dispatch:
-        # The executable was 'dispatch', which means the actual hook we want to
-        # run needs to be looked up in the JUJU_DISPATCH_PATH env var, where it
-        # should be a path relative to the charm directory (the directory that
-        # holds `dispatch`). If that path actually exists, we want to run that
-        # before continuing.
-        dispatch_path = juju_exec_path.parent / Path(os.environ['JUJU_DISPATCH_PATH'])
-        if dispatch_path.exists() and dispatch_path.resolve() != juju_exec_path.resolve():
-            argv = sys.argv.copy()
-            argv[0] = str(dispatch_path)
-            try:
-                subprocess.run(argv, check=True)
-            except subprocess.CalledProcessError as e:
-                logger.warning("hook %s exited with status %d", dispatch_path, e.returncode)
-                sys.exit(e.returncode)
-        juju_exec_path = dispatch_path
-    juju_event_name = juju_exec_path.name.replace('-', '_')
-    if juju_exec_path.parent.name == 'actions':
-        juju_event_name = '{}_action'.format(juju_event_name)
-
-    metadata, actions_metadata = _load_metadata(charm_dir)
-    meta = ops.charm.CharmMeta(metadata, actions_metadata)
-    unit_name = os.environ['JUJU_UNIT_NAME']
-    model = ops.model.Model(unit_name, meta, model_backend)
-
-    # TODO: If Juju unit agent crashes after exit(0) from the charm code
-    # the framework will commit the snapshot but Juju will not commit its
-    # operation.
-    charm_state_path = charm_dir / CHARM_STATE_FILE
-    framework = ops.framework.Framework(charm_state_path, charm_dir, meta, model)
-    try:
-        charm = charm_class(framework, None)
-
-        if not has_dispatch:
-            # When a charm is force-upgraded and a unit is in an error state Juju
-            # does not run upgrade-charm and instead runs the failed hook followed
-            # by config-changed. Given the nature of force-upgrading the hook setup
-            # code is not triggered on config-changed.
-            #
-            # 'start' event is included as Juju does not fire the install event for
-            # K8s charms (see LP: #1854635).
-            if (juju_event_name in ('install', 'start', 'upgrade_charm')
-                    or juju_event_name.endswith('_storage_attached')):
-                _setup_event_links(charm_dir, charm)
-
-        # TODO: Remove the collect_metrics check below as soon as the relevant
-        #       Juju changes are made.
-        #
-        # Skip reemission of deferred events for collect-metrics events because
-        # they do not have the full access to all hook tools.
-        if juju_event_name != 'collect_metrics':
-            framework.reemit()
-
-        _emit_charm_event(charm, juju_event_name)
-
-        framework.commit()
-    finally:
-        framework.close()

hackfest_squid_cnf/charms/squid/lib/ops/testing.py

-# Copyright 2020 Canonical Ltd.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import inspect
-import pathlib
-from textwrap import dedent
-import typing
-
-from ops import charm, framework, model
-
-
-# OptionalYAML is something like metadata.yaml or actions.yaml. You can
-# pass in a file-like object or the string directly.
-OptionalYAML = typing.Optional[typing.Union[str, typing.TextIO]]
-
-
-# noinspection PyProtectedMember
-class Harness:
-    """This class represents a way to build up the model that will drive a test suite.
-
-    The model that is created is from the viewpoint of the charm that you are testing.
-
-    Example::
-
-        harness = Harness(MyCharm)
-        # Do initial setup here
-        relation_id = harness.add_relation('db', 'postgresql')
-        # Now instantiate the charm to see events as the model changes
-        harness.begin()
-        harness.add_relation_unit(relation_id, 'postgresql/0')
-        harness.update_relation_data(relation_id, 'postgresql/0', {'key': 'val'})
-        # Check that charm has properly handled the relation_joined event for postgresql/0
-        self.assertEqual(harness.charm. ...)
-
-    Args:
-        charm_cls: The Charm class that you'll be testing.
-        meta: charm.CharmBase is a A string or file-like object containing the contents of
-            metadata.yaml. If not supplied, we will look for a 'metadata.yaml' file in the
-            parent directory of the Charm, and if not found fall back to a trivial
-            'name: test-charm' metadata.
-        actions: A string or file-like object containing the contents of
-            actions.yaml. If not supplied, we will look for a 'actions.yaml' file in the
-            parent directory of the Charm.
-    """
-
-    def __init__(
-            self,
-            charm_cls: typing.Type[charm.CharmBase],
-            *,
-            meta: OptionalYAML = None,
-            actions: OptionalYAML = None):
-        # TODO: jam 2020-03-05 We probably want to take config as a parameter as well, since
-        #       it would define the default values of config that the charm would see.
-        self._charm_cls = charm_cls
-        self._charm = None
-        self._charm_dir = 'no-disk-path'  # this may be updated by _create_meta
-        self._meta = self._create_meta(meta, actions)
-        self._unit_name = self._meta.name + '/0'
-        self._framework = None
-        self._hooks_enabled = True
-        self._relation_id_counter = 0
-        self._backend = _TestingModelBackend(self._unit_name, self._meta)
-        self._model = model.Model(self._unit_name, self._meta, self._backend)
-        self._framework = framework.Framework(":memory:", self._charm_dir, self._meta, self._model)
-
-    @property
-    def charm(self) -> charm.CharmBase:
-        """Return the instance of the charm class that was passed to __init__.
-
-        Note that the Charm is not instantiated until you have called
-        :meth:`.begin()`.
-        """
-        return self._charm
-
-    @property
-    def model(self) -> model.Model:
-        """Return the :class:`~ops.model.Model` that is being driven by this Harness."""
-        return self._model
-
-    @property
-    def framework(self) -> framework.Framework:
-        """Return the Framework that is being driven by this Harness."""
-        return self._framework
-
-    def begin(self) -> None:
-        """Instantiate the Charm and start handling events.
-
-        Before calling begin(), there is no Charm instance, so changes to the Model won't emit
-        events. You must call begin before :attr:`.charm` is valid.
-        """
-        if self._charm is not None:
-            raise RuntimeError('cannot call the begin method on the harness more than once')
-
-        # The Framework adds attributes to class objects for events, etc. As such, we can't re-use
-        # the original class against multiple Frameworks. So create a locally defined class
-        # and register it.
-        # TODO: jam 2020-03-16 We are looking to changes this to Instance attributes instead of
-        #       Class attributes which should clean up this ugliness. The API can stay the same
-        class TestEvents(self._charm_cls.on.__class__):
-            pass
-
-        TestEvents.__name__ = self._charm_cls.on.__class__.__name__
-
-        class TestCharm(self._charm_cls):
-            on = TestEvents()
-
-        # Note: jam 2020-03-01 This is so that errors in testing say MyCharm has no attribute foo,
-        # rather than TestCharm has no attribute foo.
-        TestCharm.__name__ = self._charm_cls.__name__
-        self._charm = TestCharm(self._framework, self._framework.meta.name)
-
-    def _create_meta(self, charm_metadata, action_metadata):
-        """Create a CharmMeta object.
-
-        Handle the cases where a user doesn't supply explicit metadata snippets.
-        """
-        filename = inspect.getfile(self._charm_cls)
-        charm_dir = pathlib.Path(filename).parents[1]
-
-        if charm_metadata is None:
-            metadata_path = charm_dir / 'metadata.yaml'
-            if metadata_path.is_file():
-                charm_metadata = metadata_path.read_text()
-                self._charm_dir = charm_dir
-            else:
-                # The simplest of metadata that the framework can support
-                charm_metadata = 'name: test-charm'
-        elif isinstance(charm_metadata, str):
-            charm_metadata = dedent(charm_metadata)
-
-        if action_metadata is None:
-            actions_path = charm_dir / 'actions.yaml'
-            if actions_path.is_file():
-                action_metadata = actions_path.read_text()
-                self._charm_dir = charm_dir
-        elif isinstance(action_metadata, str):
-            action_metadata = dedent(action_metadata)
-
-        return charm.CharmMeta.from_yaml(charm_metadata, action_metadata)
-
-    def disable_hooks(self) -> None:
-        """Stop emitting hook events when the model changes.
-
-        This can be used by developers to stop changes to the model from emitting events that
-        the charm will react to. Call :meth:`.enable_hooks`
-        to re-enable them.
-        """
-        self._hooks_enabled = False
-
-    def enable_hooks(self) -> None:
-        """Re-enable hook events from charm.on when the model is changed.
-
-        By default hook events are enabled once you call :meth:`.begin`,
-        but if you have used :meth:`.disable_hooks`, this can be used to
-        enable them again.
-        """
-        self._hooks_enabled = True
-
-    def _next_relation_id(self):
-        rel_id = self._relation_id_counter
-        self._relation_id_counter += 1
-        return rel_id
-
-    def add_relation(self, relation_name: str, remote_app: str) -> int:
-        """Declare that there is a new relation between this app and `remote_app`.
-
-        Args:
-            relation_name: The relation on Charm that is being related to
-            remote_app: The name of the application that is being related to
-
-        Return:
-            The relation_id created by this add_relation.
-        """
-        rel_id = self._next_relation_id()
-        self._backend._relation_ids_map.setdefault(relation_name, []).append(rel_id)
-        self._backend._relation_names[rel_id] = relation_name
-        self._backend._relation_list_map[rel_id] = []
-        self._backend._relation_data[rel_id] = {
-            remote_app: {},
-            self._backend.unit_name: {},
-            self._backend.app_name: {},
-        }
-        # Reload the relation_ids list
-        if self._model is not None:
-            self._model.relations._invalidate(relation_name)
-        if self._charm is None or not self._hooks_enabled:
-            return rel_id
-        relation = self._model.get_relation(relation_name, rel_id)
-        app = self._model.get_app(remote_app)
-        self._charm.on[relation_name].relation_created.emit(
-            relation, app)
-        return rel_id
-
-    def add_relation_unit(self, relation_id: int, remote_unit_name: str) -> None:
-        """Add a new unit to a relation.
-
-        Example::
-
-          rel_id = harness.add_relation('db', 'postgresql')
-          harness.add_relation_unit(rel_id, 'postgresql/0')
-
-        This will trigger a `relation_joined` event and a `relation_changed` event.
-
-        Args:
-            relation_id: The integer relation identifier (as returned by add_relation).
-            remote_unit_name: A string representing the remote unit that is being added.
-        Return:
-            None
-        """
-        self._backend._relation_list_map[relation_id].append(remote_unit_name)
-        self._backend._relation_data[relation_id][remote_unit_name] = {}
-        relation_name = self._backend._relation_names[relation_id]
-        # Make sure that the Model reloads the relation_list for this relation_id, as well as
-        # reloading the relation data for this unit.
-        if self._model is not None:
-            self._model.relations._invalidate(relation_name)
-            remote_unit = self._model.get_unit(remote_unit_name)
-            relation = self._model.get_relation(relation_name, relation_id)
-            relation.data[remote_unit]._invalidate()
-        if self._charm is None or not self._hooks_enabled:
-            return
-        self._charm.on[relation_name].relation_joined.emit(
-            relation, remote_unit.app, remote_unit)
-
-    def get_relation_data(self, relation_id: int, app_or_unit: str) -> typing.Mapping:
-        """Get the relation data bucket for a single app or unit in a given relation.
-
-        This ignores all of the safety checks of who can and can't see data in relations (eg,
-        non-leaders can't read their own application's relation data because there are no events
-        that keep that data up-to-date for the unit).
-
-        Args:
-            relation_id: The relation whose content we want to look at.
-            app_or_unit: The name of the application or unit whose data we want to read
-        Return:
-            a dict containing the relation data for `app_or_unit` or None.
-        Raises:
-            KeyError: if relation_id doesn't exist
-        """
-        return self._backend._relation_data[relation_id].get(app_or_unit, None)
-
-    def get_workload_version(self) -> str:
-        """Read the workload version that was set by the unit."""
-        return self._backend._workload_version
-
-    def update_relation_data(
-            self,
-            relation_id: int,
-            app_or_unit: str,
-            key_values: typing.Mapping,
-    ) -> None:
-        """Update the relation data for a given unit or application in a given relation.
-
-        This also triggers the `relation_changed` event for this relation_id.
-
-        Args:
-            relation_id: The integer relation_id representing this relation.
-            app_or_unit: The unit or application name that is being updated.
-                This can be the local or remote application.
-            key_values: Each key/value will be updated in the relation data.
-        """
-        relation_name = self._backend._relation_names[relation_id]
-        relation = self._model.get_relation(relation_name, relation_id)
-        if '/' in app_or_unit:
-            entity = self._model.get_unit(app_or_unit)
-        else:
-            entity = self._model.get_app(app_or_unit)
-        rel_data = relation.data.get(entity, None)
-        if rel_data is not None:
-            # rel_data may have cached now-stale data, so _invalidate() it.
-            # Note, this won't cause the data to be loaded if it wasn't already.
-            rel_data._invalidate()
-
-        new_values = self._backend._relation_data[relation_id][app_or_unit].copy()
-        for k, v in key_values.items():
-            if v == '':
-                new_values.pop(k, None)
-            else:
-                new_values[k] = v
-        self._backend._relation_data[relation_id][app_or_unit] = new_values
-
-        if app_or_unit == self._model.unit.name:
-            # No events for our own unit
-            return
-        if app_or_unit == self._model.app.name:
-            # updating our own app only generates an event if it is a peer relation and we
-            # aren't the leader
-            is_peer = self._meta.relations[relation_name].role == 'peers'
-            if not is_peer:
-                return
-            if self._model.unit.is_leader():
-                return
-        self._emit_relation_changed(relation_id, app_or_unit)
-
-    def _emit_relation_changed(self, relation_id, app_or_unit):
-        if self._charm is None or not self._hooks_enabled:
-            return
-        rel_name = self._backend._relation_names[relation_id]
-        relation = self.model.get_relation(rel_name, relation_id)
-        if '/' in app_or_unit:
-            app_name = app_or_unit.split('/')[0]
-            unit_name = app_or_unit
-            app = self.model.get_app(app_name)
-            unit = self.model.get_unit(unit_name)
-            args = (relation, app, unit)
-        else:
-            app_name = app_or_unit
-            app = self.model.get_app(app_name)
-            args = (relation, app)
-        self._charm.on[rel_name].relation_changed.emit(*args)
-
-    def update_config(
-            self,
-            key_values: typing.Mapping[str, str] = None,
-            unset: typing.Iterable[str] = (),
-    ) -> None:
-        """Update the config as seen by the charm.
-
-        This will trigger a `config_changed` event.
-
-        Args:
-            key_values: A Mapping of key:value pairs to update in config.
-            unset: An iterable of keys to remove from Config. (Note that this does
-                not currently reset the config values to the default defined in config.yaml.)
-        """
-        config = self._backend._config
-        if key_values is not None:
-            for key, value in key_values.items():
-                config[key] = value
-        for key in unset:
-            config.pop(key, None)
-        # NOTE: jam 2020-03-01 Note that this sort of works "by accident". Config
-        # is a LazyMapping, but its _load returns a dict and this method mutates
-        # the dict that Config is caching. Arguably we should be doing some sort
-        # of charm.framework.model.config._invalidate()
-        if self._charm is None or not self._hooks_enabled:
-            return
-        self._charm.on.config_changed.emit()
-
-    def set_leader(self, is_leader: bool = True) -> None:
-        """Set whether this unit is the leader or not.
-
-        If this charm becomes a leader then `leader_elected` will be triggered.
-
-        Args:
-            is_leader: True/False as to whether this unit is the leader.
-        """
-        was_leader = self._backend._is_leader
-        self._backend._is_leader = is_leader
-        # Note: jam 2020-03-01 currently is_leader is cached at the ModelBackend level, not in
-        # the Model objects, so this automatically gets noticed.
-        if is_leader and not was_leader and self._charm is not None and self._hooks_enabled:
-            self._charm.on.leader_elected.emit()
-
-
-class _TestingModelBackend:
-    """This conforms to the interface for ModelBackend but provides canned data.
-
-    DO NOT use this class directly, it is used by `Harness`_ to drive the model.
-    `Harness`_ is responsible for maintaining the internal consistency of the values here,
-    as the only public methods of this type are for implementing ModelBackend.
-    """
-
-    def __init__(self, unit_name, meta):
-        self.unit_name = unit_name
-        self.app_name = self.unit_name.split('/')[0]
-        self._calls = []
-        self._meta = meta
-        self._is_leader = None
-        self._relation_ids_map = {}  # relation name to [relation_ids,...]
-        self._relation_names = {}  # reverse map from relation_id to relation_name
-        self._relation_list_map = {}  # relation_id: [unit_name,...]
-        self._relation_data = {}  # {relation_id: {name: data}}
-        self._config = {}
-        self._is_leader = False
-        self._resources_map = {}
-        self._pod_spec = None
-        self._app_status = None
-        self._unit_status = None
-        self._workload_version = None
-
-    def relation_ids(self, relation_name):
-        try:
-            return self._relation_ids_map[relation_name]
-        except KeyError as e:
-            if relation_name not in self._meta.relations:
-                raise model.ModelError('{} is not a known relation'.format(relation_name)) from e
-            return []
-
-    def relation_list(self, relation_id):
-        try:
-            return self._relation_list_map[relation_id]
-        except KeyError as e:
-            raise model.RelationNotFoundError from e
-
-    def relation_get(self, relation_id, member_name, is_app):
-        if is_app and '/' in member_name:
-            member_name = member_name.split('/')[0]
-        if relation_id not in self._relation_data:
-            raise model.RelationNotFoundError()
-        return self._relation_data[relation_id][member_name].copy()
-
-    def relation_set(self, relation_id, key, value, is_app):
-        relation = self._relation_data[relation_id]
-        if is_app:
-            bucket_key = self.app_name
-        else:
-            bucket_key = self.unit_name
-        if bucket_key not in relation:
-            relation[bucket_key] = {}
-        bucket = relation[bucket_key]
-        if value == '':
-            bucket.pop(key, None)
-        else:
-            bucket[key] = value
-
-    def config_get(self):
-        return self._config
-
-    def is_leader(self):
-        return self._is_leader
-
-    def application_version_set(self, version):
-        self._workload_version = version
-
-    def resource_get(self, resource_name):
-        return self._resources_map[resource_name]
-
-    def pod_spec_set(self, spec, k8s_resources):
-        self._pod_spec = (spec, k8s_resources)
-
-    def status_get(self, *, is_app=False):
-        if is_app:
-            return self._app_status
-        else:
-            return self._unit_status
-
-    def status_set(self, status, message='', *, is_app=False):
-        if is_app:
-            self._app_status = (status, message)
-        else:
-            self._unit_status = (status, message)
-
-    def storage_list(self, name):
-        raise NotImplementedError(self.storage_list)
-
-    def storage_get(self, storage_name_id, attribute):
-        raise NotImplementedError(self.storage_get)
-
-    def storage_add(self, name, count=1):
-        raise NotImplementedError(self.storage_add)
-
-    def action_get(self):
-        raise NotImplementedError(self.action_get)
-
-    def action_set(self, results):
-        raise NotImplementedError(self.action_set)
-
-    def action_log(self, message):
-        raise NotImplementedError(self.action_log)
-
-    def action_fail(self, message=''):
-        raise NotImplementedError(self.action_fail)
-
-    def network_get(self, endpoint_name, relation_id=None):
-        raise NotImplementedError(self.network_get)

hackfest_squid_cnf/charms/squid/metadata.yaml

-name: squid
-summary: Describe your charm here
-maintainers:
-    - Dominik Fleischmann <dominik.fleischmann@canonical.com>
-description: |
-    A nice long description of what the product does and any
-    high level information about how the charm provides the product,
-    on which platform, etc.
-tags:
-    - misc
-series:
-    - kubernetes
-storage:
-    docker:
-        type: filesystem
-        location: /srv/docker/squid
-    spool:
-        type: filesystem
-        location: /var/spool/squid
-# -- example relations, delete if unneeded
-#requires:
-#    db:
-#        interface: mysql
-#provides:
-#    website:
-#        interface: http

hackfest_squid_cnf/charms/squid/mod/operator/.flake8

-[flake8]
-max-line-length = 99