publish

Author: Az4zel99

.dockerignore

@@ -0,0 +1,10 @@
+__pychache__/
+instance
+tests
+venv
+Dockerfile-python
+Dockerfile-alpine
+create-image.sh
+test_requirements.txt
+skaffold.yaml
+k8s

.gitignore

@@ -0,0 +1 @@
+__pycache__/

.gitlab-ci.yml

@@ -0,0 +1,21 @@
+build_image:
+  stage: build
+  only:
+    - tags
+  image:
+    name: docker:stable
+  services:
+    - name: docker:dind
+      entrypoint: ["env", "-u", "DOCKER_HOST"]
+      command: ["dockerd-entrypoint.sh"]
+  variables:
+    DOCKER_HOST: tcp://docker:2375/
+    DOCKER_DRIVER: overlay2
+    # See https://github.com/docker-library/docker/pull/166
+    DOCKER_TLS_CERTDIR: ""
+  script:
+    - apk add git bash
+    - echo $CI_REGISTRY_PASSWORD | docker login -u $CI_REGISTRY_USER $CI_REGISTRY --password-stdin
+    - $CI_PROJECT_DIR/create-image.sh $CI_COMMIT_TAG
+    - docker push hub.semafor.ch/semafor/config-controller:latest
+    - docker push hub.semafor.ch/semafor/config-controller:$CI_COMMIT_TAG

Dockerfile

@@ -0,0 +1,25 @@
+FROM alpine:3.17.3
+
+ARG REVISION
+
+RUN apk add python3 py-pip
+
+ENV VIRTUAL_ENV=/opt/venv
+RUN python3 -m venv $VIRTUAL_ENV
+ENV PATH="$VIRTUAL_ENV/bin:$PATH"
+
+WORKDIR /app
+COPY . .
+# install the library dependencies for this application
+RUN pip3 install --no-cache-dir  -r requirements.txt && opentelemetry-bootstrap -a install && \
+  [ -z "$REVISION" ] ||echo "$REVISION" > vcs.info
+
+ENV FLASK_APP="controller"
+ENV SERVICE_PORT=3333
+ENV LABEL_KEY="app"
+ENV CONFIG_DIR="/etc/config-controller"
+ENV MIN_NUM_IDLING_CONTAINERS=1
+
+EXPOSE ${SERVICE_PORT}
+#
+CMD [ "/app/entrypoint.sh" ]

LICENSE

@@ -0,0 +1,13 @@
+   Copyright 2025 SEMAFOR Informatik & Energie AG, Basel
+
+   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
+
+       https://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.

Procfile

@@ -0,0 +1 @@
+web: FLASK_APP=controller python3 -m flask run --host=0.0.0.0 --port=$PORT

config.py

@@ -0,0 +1,27 @@
+import os
+import pathlib
+
+name = os.environ.get('FLASK_APP') or 'config-controller'
+
+
+def vcs_info():
+    g = pathlib.Path(__file__).parent / 'vcs.info'
+    if g.exists():
+        return g.read_text().strip()
+    import subprocess
+    try:
+        p = subprocess.run(['git', 'describe'], capture_output=True)
+        if p.returncode == 0:
+            return p.stdout.decode().strip()
+    except:
+        pass
+    return name.strip()
+
+
+class Config(object):
+    LABEL_KEY = os.environ.get('LABEL_KEY') or 'app'
+    MIN_NUM_IDLING_CONTAINERS = int(
+        os.environ.get('MIN_NUM_IDLING_CONTAINERS') or 1)
+    BASE_DIR = os.environ.get('BASE_DIR')
+    CONFIG_DIR = os.environ.get('CONFIG_DIR') or '/etc/config-controller'
+    VCS_INFO = vcs_info()

controller/__init__.py

@@ -0,0 +1,98 @@
+import platform
+import logging
+import os
+import flask
+import werkzeug
+# from flask_session import Session
+import pathlib
+import config
+import atexit
+
+logging.basicConfig(level=logging.INFO,
+                    format='%(asctime)s %(message)s')
+
+kube = None
+dock = None
+
+
+def create_app(test_config=None):
+    global kube
+    global dock
+
+    # create and configure the app
+    app = flask.Flask(__name__, instance_relative_config=True)
+    app.config.from_object(config.Config())
+
+    if test_config is None:
+        # load the instance config, if it exists, when not testing
+        app.config.from_pyfile('config.py', silent=True)
+        if pathlib.Path('/var/run/docker.sock').is_socket() and os.environ.get('DOCKER'):
+            import controller.docker_api
+            dock = controller.docker_api.DockerApi(app.config['BASE_DIR'])
+            from controller.routes import get_templates, create_instance
+            if app.config['MIN_NUM_IDLING_CONTAINERS'] > 0:
+                for template in get_templates(app.config['CONFIG_DIR']):
+                    create_instance(app.config['MIN_NUM_IDLING_CONTAINERS'],
+                                    app.config['CONFIG_DIR'], template, "0",
+                                    app.logger)
+        else:
+            try:
+                import controller.kubernetes_api
+                controller.kubernetes_api.load_config()
+                kube = controller.kubernetes_api.KubernetesApi()
+            except:
+                kube = None
+                app.logger.warning("Kubernetes Client", exc_info=True)
+
+    else:
+        # load the test config if passed in
+        app.config.from_mapping(test_config)
+        kube = test_config['KUBE']
+        dock = test_config['DOCK']
+
+    app.logger.info("{'name': '%s',  'version': '%s'}",
+                    config.name, app.config['VCS_INFO'])
+    # ensure the instance folder exists
+    try:
+        os.makedirs(app.instance_path)
+    except OSError:
+        pass
+
+    @app.errorhandler(werkzeug.exceptions.BadRequest)
+    def badrequest(error):
+        return (flask.jsonify(dict(status='error', msg='bad request')),
+                werkzeug.exceptions.BadRequest)
+
+    @app.errorhandler(404)
+    def not_found_error(error):
+        return flask.jsonify(dict(status='error', msg='not found')), 404
+
+    @app.errorhandler(500)
+    def internal_error(error):
+        return flask.jsonify(dict(status='error', msg='internal error')), 500
+
+    @app.route('/info', methods=['GET'])
+    def get_info():
+        """return info"""
+        info = dict(status='UP', hostname=platform.node(),
+                    config_dir=app.config['CONFIG_DIR'],
+                    rev=app.config['VCS_INFO'])
+        return flask.jsonify(info)
+
+    from controller.routes import bp
+    app.register_blueprint(bp)
+
+    return app
+
+# Session(app)
+
+# register exit function
+
+
+def delete_containers():
+    conf = config.Config()
+    from .routes import delete_all_containers
+    delete_all_containers(conf.CONFIG_DIR, conf.LABEL_KEY)
+
+
+atexit.register(delete_containers)

controller/docker_api.py

@@ -0,0 +1,122 @@
+"""
+ lists, creates and deletes containers with docker API
+
+https://docker-py.readthedocs.io
+
+Note: Labels on images, containers, local daemons, volumes, and networks are
+  static for the lifetime of the object. To change these labels you must
+  recreate the object. (https://docs.docker.com/config/labels-custom-metadata)
+"""
+import docker
+import logging
+import uuid
+import time
+import os
+
+logger = logging.getLogger(__name__)
+
+
+def get_ipaddr(c):
+    """return ip address of container"""
+    for k in c.attrs['NetworkSettings']['Networks']:
+        if 'IPAddress' in c.attrs['NetworkSettings']['Networks'][k]:
+            return c.attrs['NetworkSettings']['Networks'][k]['IPAddress']
+    return ''
+
+
+class DockerApi(object):
+
+    def __init__(self, basedir=''):
+        self.docker_client = docker.DockerClient(
+            base_url='unix://var/run/docker.sock')
+        self.docker_network = None
+        self.basedir = basedir if basedir else os.getcwd()
+        schema_key = 'org.label-schema.name'
+        schema_name = 'config-controller'
+        for c in self.docker_client.containers.list(filters={
+                "label": "{}={}".format(
+                    schema_key, schema_name)}):
+            networks = [k for k in c.attrs['NetworkSettings']['Networks']]
+            logger.info("Networks %s", networks)
+            if len(networks) > 0:
+                self.docker_network = networks[0]
+        if not self.docker_network:
+            self.docker_network = 'bridge'
+            logger.warn("WARNING: Use default network: %s",
+                        self.docker_network)
+
+    def get_containers(self, label):
+        """returns containers by label"""
+        key, value = label.split('=')
+        return [dict(
+            addr=get_ipaddr(c),
+            name=c.attrs['Name'][1:],
+            assigned=c.labels.get('assigned', ""),
+            sessionID=c.labels.get('sessionID', "0"))
+            for c in self.docker_client.containers.list(filters={
+                "label": "{}={}".format(
+                    key.strip(), value.strip())})]
+
+    def get_labels(self, name):
+        """returns container labels by name"""
+        try:
+            container = self.docker_client.containers.get(name)
+            return container.labels
+        except docker.errors.NotFound as e:
+            pass
+        return {}
+
+    def find_unassigned_containers(self, labels):
+        return [c for c in self.docker_client.containers.list(
+            filters={
+                "label": [f'{k}={labels[k]}' for k in labels.keys()]})
+                if not c.labels.get('assigned', "")]
+
+    def create_container(self, num_idling_containers, nameprefix,
+                         manifest, sessionID):
+        prefix = ''
+        if self.docker_network != 'bridge':
+            prefix = self.docker_network.split('_')[0]+'_'
+        image_name = manifest['spec']['containers'][0]['image']
+        c = manifest['spec']['containers'][0]
+        env = ['{0}={1}'.format(e['name'], e['value']) for e in c['env']]
+        volumes = ['{0}/{1}:{2}'.format(self.basedir, v['name'], v['mount'])
+                   for v in c['volumes']]
+        logger.info("Volumes %s", volumes)
+        if sessionID != '0':
+            assign_ts = str(int(time.time()))
+        else:
+            assign_ts = ''
+
+        #uc = self.find_unassigned_containers(manifest['metadata']['labels'])
+        # if len(uc)-1 < num_idling_containers:
+        container_name = prefix+nameprefix+'-'+uuid.uuid4().hex[:8]
+        self.docker_client.containers.run(
+            image_name, name=container_name,
+            labels={'app': nameprefix,
+                    'sessionID': sessionID,
+                    'assigned': assign_ts},
+            detach=True, environment=env,
+            volumes=volumes,
+            network=self.docker_network,  # remove=True, ???
+            restart_policy={"Name": "on-failure",
+                            "MaximumRetryCount": 5})
+        logger.info("Started container %s on network %s", container_name,
+                    self.docker_network)
+        c = self.docker_client.containers.list(
+            filters={"name": container_name})[0]
+        # if uc:
+        #    c = uc[0]
+        #    c.labels['sessionID'] = sessionID
+        return dict(name=container_name, addr=get_ipaddr(c))
+
+    def delete_container(self, num_idling_containers, name):
+        try:
+            logger.info("removing container %s", name)
+            # self.docker_client.containers.get(name).stop()
+            self.docker_client.containers.get(name).remove(force=True)
+            #logger.info("delete %s ignored")
+            return dict(status='OK', message='{} deleted'.format(name))
+        except docker.errors.NotFound as e:
+            logger.warning('delete container %s: %s', name, str(e))
+            return dict(status='NotFound')