Commit 17583c8b authored by beierlm's avatar beierlm
Browse files

Merge branch 'master' into 'master'

Update squid charm

See merge request !105
parents e2197769 9c012576
Pipeline #143 passed with stage
in 1 minute and 34 seconds
#!/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`
options:
image:
type: string
description: 'Docker image for squid'
default: 'domfleischmann/squid-python'
port:
type: int
description: 'Port'
description: "Port"
default: 3128
#!/bin/sh
JUJU_DISPATCH_PATH="${JUJU_DISPATCH_PATH:-$0}" PYTHONPATH=lib:venv ./src/charm.py
../src/charm.py
\ No newline at end of file
../dispatch
\ No newline at end of file
../dispatch
\ No newline at end of file
../dispatch
\ No newline at end of file
# 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
This diff is collapsed.
# 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)
This diff is collapsed.
......@@ -14,10 +14,11 @@ deployment:
type: stateful
service: loadbalancer
storage:
docker:
type: filesystem
location: /srv/docker/squid
spool:
type: filesystem
location: /var/spool/squid
resources:
image:
type: oci-image
description: OSM docker image for LCM
upstream-source: "domfleischmann/squid-python"
\ No newline at end of file
version: 2 # required
formats: [] # i.e. no extra formats (for now)
python:
version: "3.5"
install:
- requirements: docs/requirements.txt
- requirements: requirements.txt
dist: bionic
language: python
arch:
- amd64
- arm64
python:
- "3.5"
- "3.6"
- "3.7"
- "3.8"
matrix:
include:
- os: osx
language: generic
install:
- pip3 install pyyaml autopep8 flake8
script:
- ./run_tests
# The Operator Framework
The Operator Framework provides a simple, lightweight, and powerful way of encapsulating operational experience in code.
The framework will help you to:
* model the integration of your services
* manage the lifecycle of your application
* create reusable and scalable components
* keep your code simple and readable
## Getting Started
The following overall structure for your charm directory is recommended:
```
.
├── config.yaml
├── metadata.yaml
├── mod/
├── lib/
│ └── ops -> ../mod/operator/ops
├── src/
│ └── charm.py
└── hooks/
├── install -> ../src/charm.py
└── start -> ../src/charm.py # for k8s charms per below
```
The `mod/` directory should contain the operator framework dependency as a git
submodule:
```
git submodule add https://github.com/canonical/operator mod/operator
```
Then symlink from the git submodule for the operator framework into the `lib/`
directory of your charm so it can be imported at run time:
```
ln -s ../mod/operator/ops lib/ops
```
Other dependencies included as git submodules can be added in the `mod/`
directory and symlinked into `lib/` as well.
You can sync subsequent changes from the framework and other submodule
dependencies by running:
```
git submodule update
```
Those cloning and checking out the source for your charm for the first time
will need to run:
```
git submodule update --init
```
Your `src/charm.py` is the entry point for your charm logic. It should be set
to executable and use Python 3.6 or greater. At a minimum, it needs to define
a subclass of `CharmBase` and pass that into the framework's `main` function:
```python
import sys
sys.path.append('lib') # noqa: E402
from ops.charm import CharmBase
from ops.main import main
class MyCharm(CharmBase):
pass
if __name__ == "__main__":
main(MyCharm)
```
This charm does nothing, because the `MyCharm` class passed to the operator
framework's `main` function is empty. Functionality can be added to the charm
by instructing it to observe particular Juju events when the `MyCharm` object
is initialized. For example,
```python
class MyCharm(CharmBase):
def __init__(self, *args):
super().__init__(*args)
self.framework.observe(self.on.start, self.on_start)
def on_start(self, event):
# Handle the start event here.
```
Every standard event in Juju may be observed that way, and you can also easily
define your own events in your custom types.
> The second argument to `observe` can be either the handler as a bound
> method, or the observer itself if the handler is a method of the observer
> that follows the conventional naming pattern. That is, in this case, we
> could have called just `self.framework.observe(self.on.start, self)`.
The `hooks/` directory must contain a symlink to your `src/charm.py` entry
point so that Juju can call it. You only need to set up the `hooks/install` link
(`hooks/start` for K8s charms, until [lp#1854635](https://bugs.launchpad.net/juju/+bug/1854635)
is resolved), and the framework will create all others at runtime.
Once your charm is ready, upload it to the charm store and deploy it as
normal with:
```
# Replace ${CHARM} with the name of the charm.
charm push . cs:~${USER}/${CHARM}
# Replace ${VERSION} with the version created by `charm push`.
charm release cs:~${USER}/${CHARM}-${VERSION}
charm grant cs:~${USER}/${CHARM}-${VERSION} everyone
# And now deploy your charm.
juju deploy cs:~${USER}/$CHARM
```
Alternatively, to deploy directly from local disk, run:
```
juju deploy .
```
# Operator Framework development
If you want to work in the framework *itself* you will need the following depenencies installed in your system:
- Python >= 3.5
- PyYAML
- autopep8
- flake8
Then you can try `./run_tests`, it should all go green.
#!/bin/sh
set -e
flavour=html
if [ "$1" ]; then
if [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
flavour=help
else
flavour="$1"
fi
shift
fi
cd docs
sphinx-build -M "$flavour" . _build "$@"
# Configuration file for the Sphinx documentation builder.
#
# For a full list of options see the documentation:
# https://www.sphinx-doc.org/en/master/usage/configuration.html
# -- Path setup --------------------------------------------------------------
from pathlib import Path
import sys
sys.path.insert(0, str(Path(__file__).parent.parent))
# -- Project information -----------------------------------------------------
project = 'The Operator Framework'
copyright = '2019-2020, Canonical Ltd.'
author = 'Canonical Ltd'
# -- General configuration ---------------------------------------------------
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.napoleon',
'sphinx.ext.todo',
'sphinx.ext.viewcode',
]
# The document name of the “master” document, that is, the document
# that contains the root toctree directive.
master_doc = 'index'
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This pattern also affects html_static_path and html_extra_path.
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
# -- Options for HTML output -------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
# html_theme = 'nature' # 'alabaster'
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# -- Options for sphinx.ext.todo ---------------------------------------------
# If this is True, todo and todolist produce output, else they
# produce nothing. The default is False.
todo_include_todos = False
# -- Options for sphinx.ext.autodoc ------------------------------------------
# This value controls how to represents typehints. The setting takes the
# following values:
# 'signature' – Show typehints as its signature (default)
# 'description' – Show typehints as content of function or method
# 'none' – Do not show typehints
autodoc_typehints = 'description'
# This value selects what content will be inserted into the main body of an
# autoclass directive. The possible values are:
# 'class' - Only the class’ docstring is inserted. This is the
# default. You can still document __init__ as a separate method
# using automethod or the members option to autoclass.
# 'both' - Both the class’ and the __init__ method’s docstring are
# concatenated and inserted.
# 'init' - Only the __init__ method’s docstring is inserted.
autoclass_content = 'both'
autodoc_default_options = {
'members': None, # None here means "yes"
'undoc-members': None,
'show-inheritance': None,
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment