seto 2.0.4__tar.gz → 2.2.0__tar.gz

{seto-2.0.4 → seto-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: seto
-Version: 2.0.4
+Version: 2.2.0
 Summary: A Docker Swarm Deployment Manager
 License: Apache 2.0
 Keywords: docker,swarm,manager

{seto-2.0.4 → seto-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "seto"
-version = "2.0.4"
+version = "2.2.0"
 description = "A Docker Swarm Deployment Manager"
 keywords = ["docker", "swarm", "manager"]
 authors = ["Sébastien Demanou <demsking@gmail.com>"]

{seto-2.0.4 → seto-2.2.0}/seto/__main__.py

@@ -199,15 +199,7 @@ def main() -> None:
   create_shell = LocalShell if setting.local else RemoteShell
   create_driver = GlusterDriver if driver_name == 'gluster' else NFSDriver
   shell = create_shell(setting, args.key)
-  stack_name = f'{args.project}_{args.stack}' if args.stack else args.project
-  brickname = f'{args.project}/{args.stack}' if args.stack else args.project
-
-  driver = create_driver(
-    stack_name,
-    project=args.project,
-    brickname=brickname,
-    shell=shell,
-  )
+  driver = create_driver(args.stack, project=args.project, shell=shell)
 
   # Call the function associated with the selected subcommand
   if hasattr(args, 'func'):

{seto-2.0.4 → seto-2.2.0}/seto/commands/config.py

@@ -1,4 +1,3 @@
-from docker.api import network
 # Copyright 2024 Sébastien Demanou. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,8 +17,9 @@ from collections.abc import Callable
 import yaml
 
 from ..core.driver import Driver
+from ..core.network import get_global_external_networks
+from ..core.network import resolve_networks
 from ..core.parser import parse_services
-from ..core.parser import resolve_networks
 from ..core.shell import Shell
 from ..core.volume import Volume
 
@@ -31,7 +31,7 @@ def resolve(
   inject: bool = False,
   execute: Callable[[dict, str], None] | None = None,
 ) -> dict:
-  config_networks = {}
+  config_networks = get_global_external_networks()
   global_networks = resolve_networks(args.project)
 
   for network_name, network_definition in global_networks.items():
@@ -40,16 +40,6 @@ def resolve(
       'external': True,
     }
 
-  config_networks['cloud-public'] = {
-    'name': 'seto-cloud-public',
-    'external': True,
-  }
-
-  config_networks['cloud-edge'] = {
-    'name': 'seto-cloud-edge',
-    'external': True,
-  }
-
   compose = {
     'x-placement': None,
     'configs': {},
@@ -97,7 +87,7 @@ def execute_config_command(args, driver: Driver) -> None:
   compose_output = yaml.dump(compose)
 
   if args.compose:
-    command = f'docker compose -p {driver.stack} -f - config'
+    command = f'docker compose -p {driver.stack_id} -f - config'
   else:
     command = 'docker stack config -c -'
 

{seto-2.0.4 → seto-2.2.0}/seto/commands/deploy.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 import json
 import os
+import random
 import re
 from typing import Any
 
@@ -23,11 +24,17 @@ from ..core.dns import resolve_hostname
 from ..core.docker import DockerCompose
 from ..core.docker import DockerSwarm
 from ..core.driver import Driver
-from ..core.parser import resolve_networks
+from ..core.network import GLOBAL_NETWORKS
+from ..core.network import resolve_networks
+from ..core.parser import resolve_compose_file
+from ..core.shell import Setting
+from ..core.traefik import convert_middlewares_to_dict
 from .config import resolve
 
+
 # Define the regular expression pattern to match {{ .Node.Hostname }} with optional spaces
 NODE_HOSTNAME_RE = r'\{\{\s*\.Node\.Hostname\s*\}\}'
+HTTP_PROVIDER_SERVICENAME = 'seto-http-provider'
 
 
 def parse_service_vars(entries: dict[str, Any], hostname: str) -> None:
@@ -36,15 +43,15 @@ def parse_service_vars(entries: dict[str, Any], hostname: str) -> None:
       entries[key] = re.sub(NODE_HOSTNAME_RE, hostname, value)
 
 
-def get_label_value(labels: dict[str, Any], name: str) -> Any | None:
+def pick_label_value(labels: dict[str, Any], name: str) -> Any | None:
   for label, value in labels.items():
     if label.endswith(name):
+      del labels[label]
       return value
   return None
 
 
 def parse_compose_config(
-  stack: str,
   args,
   driver: Driver,
   client: DockerClient,
@@ -56,10 +63,10 @@ def parse_compose_config(
   composes: list[DockerCompose],
   traefik_http_provider_routers: dict,
   traefik_http_provider_services: dict,
+  traefik_http_provider_middlewares: dict,
 ) -> None:
   if compose_config['services']:
     compose = DockerCompose(
-      stack=stack,
       client=client,
       driver=driver,
       config=compose_config,
@@ -74,9 +81,6 @@ def parse_compose_config(
       service_networks = service.get('networks', [])
       service_ports = service.get('ports', [])
       service_deploy = {
-        'labels': [
-          'traefik.discovery.enable=false',
-        ],
         'placement': {
           'constraints': [
             f'node.labels.{placement}',
@@ -94,33 +98,24 @@ def parse_compose_config(
       parse_service_vars(service_labels, compose.node_hostname)
       parse_service_vars(service_environment, compose.node_hostname)
 
-      if service_ports:
-        service_traefik_rule = get_label_value(service_labels, '.rule')
-        service_traefik_middlewares = get_label_value(service_labels, '.middlewares')
-        service_traefik_port = get_label_value(service_labels, '.loadbalancer.server.port')
-        service_traefik_entryPoints = get_label_value(service_labels, '.entryPoints')
-        service_traefik_tls_certresolver = get_label_value(service_labels, '.tls.certresolver')
-        service_traefik_service = get_label_value(service_labels, '.service')
-
-        if not service_traefik_port:
-          raise ValueError(f'Service "{service_name}" error: port is missing')
-
-        published_port = -1
-
-        for entry in service_ports:
-          source_port, target_port = entry.split(':')
+      service_traefik_port = pick_label_value(service_labels, '.loadbalancer.server.port')
 
-          if int(target_port) == service_traefik_port:
-            published_port = source_port
+      if service_traefik_port:
+        service['ports'] = service_ports
+        service_traefik_rule = pick_label_value(service_labels, '.rule')
+        service_traefik_middlewares = pick_label_value(service_labels, '.middlewares')
+        service_traefik_entryPoints = pick_label_value(service_labels, '.entryPoints')
+        service_traefik_tls_certresolver = pick_label_value(service_labels, '.tls.certresolver')
+        service_traefik_service = pick_label_value(service_labels, '.service')
+        published_port = random.randint(53100, 64200)
 
-        if published_port == -1:
-          raise ValueError(f'No exposed port for {service_name}:{service_traefik_port}')
+        service_ports.append(f'{published_port}:{service_traefik_port}')
 
         traefik_http_provider_routers[service_name] = {
           'entryPoints': [service_traefik_entryPoints],
           'service': service_traefik_service or service_name,
           'rule': service_traefik_rule,
-          'middlewares': service_traefik_middlewares,
+          'middlewares': service_traefik_middlewares.split(','),
           'tls': {
             'certresolver': service_traefik_tls_certresolver,
           },
@@ -137,57 +132,83 @@ def parse_compose_config(
           },
         }
 
+        traefik_http_provider_middlewares.update(
+          convert_middlewares_to_dict(service_labels),
+        )
+      else:
+        print(f'No exposed port found for service "{service_name}"')
 
-def deploy_seto_stack(args, driver: Driver) -> None:
+
+def deploy_seto_stack(args, driver: Driver, replica: list[Setting]) -> None:
+  # Temporary rewrite driver config
+  driver.project = 'seto'
+  driver.stack = None
+
+  # Building seto config
   client = DockerClient.from_env()
   config_networks = resolve_networks(args.project)
 
-  config_networks.update({
-    'cloud-public': {
-      'name': 'seto-cloud-public',
-      'driver': 'overlay',
-      'attachable': True,
-    },
-    'cloud-edge': {
-      'name': 'seto-cloud-edge',
-      'driver': 'overlay',
-      'attachable': True,
-    },
-  })
+  config_networks.update(GLOBAL_NETWORKS)
 
-  print('Configuring ṣeto agents...')
+  print('Configuring seto-http-provider...')
   internal_stack = {
     'networks': config_networks,
     'services': {
-      'agent': {
-        'image': 'traefik/whoami',
+      HTTP_PROVIDER_SERVICENAME: {
+        'image': 'demsking/traefik-http-provider',
         'networks': list(config_networks.keys()),
-        'deploy': {'mode': 'global'},
+        'environment': [
+          'WORKER=1',
+          'EXPIRATION_MINUTES=10',
+          'PROVIDERS_DATABASE=/data/providers.db',
+        ],
+        'volumes-nfs': {
+          'data:/data',
+        },
+        'deploy': {
+          'mode': 'global',
+          'labels': {
+            'traefik.discovery.enable=true',
+          },
+        },
       },
     },
   }
 
+  # Resolving compose local volumes
+  resolved_compose_data, volumes = resolve_compose_file(
+    driver=driver,
+    compose_data=internal_stack,
+    inject=True,
+  )
+
+  print('Creating seto volumes...')
+  driver.create_volumes(replica=replica, volumes=volumes, force=args.force)
+
+  print('Deploying seto services...')
   swarm = DockerSwarm(
-    stack='seto',
     client=client,
     driver=driver,
-    config=internal_stack,
+    config=resolved_compose_data,
   )
 
   swarm.info()
   swarm.deploy()
 
+  # Restore initial driver config
+  driver.project = args.project
+  driver.stack = args.stack
+
 
 def execute_deploy_command(args, driver: Driver) -> None:
   client = DockerClient.from_env()
 
   # Docker Swarm
-  print(f'Resolving {driver.stack} services...')
+  print(f'Resolving {driver.stack_id} services...')
   setattr(args, 'compose', False)
   swarm_config = resolve(args, driver)
 
   swarm = DockerSwarm(
-    stack=driver.stack,
     client=client,
     driver=driver,
     config=swarm_config,
@@ -199,43 +220,65 @@ def execute_deploy_command(args, driver: Driver) -> None:
   composes_items: list[DockerCompose] = []
 
   bridges_path = 'bridges'
-  traefik_http_provider_name = 'traefik-http-provider'
   traefik_http_provider_filename = os.path.join(bridges_path, 'traefik-http-provider.json')
+  traefik_http_provider_target = '/traefik/config.json'
   traefik_http_provider_routers = {}
   traefik_http_provider_services = {}
+  traefik_http_provider_middlewares = {}
   traefik_http_provider = {
     'http': {
       'routers': traefik_http_provider_routers,
       'services': traefik_http_provider_services,
+      'middlewares': traefik_http_provider_middlewares,
     },
   }
 
-  swarm_config['configs'][traefik_http_provider_name] = {
-    'file': traefik_http_provider_filename,
-  }
+  register_command = ' && '.join([
+    f'echo "Registering service {driver.stack_id}..."',
+    f'curl -s -X POST http://{HTTP_PROVIDER_SERVICENAME}:6116/api/config/{driver.stack_id} -H "Content-Type: application/json" -d @{traefik_http_provider_target} > /dev/nul',
+  ])
+
+  entrypoint = ' && '.join([
+    # Log the start of the initial endpoint call
+    'echo "Starting initial call to the provider endpoint..."',
+
+    # Call the POST endpoint at startup
+    register_command,
+
+    # Log the end of the initial endpoint call
+    'echo "Initial call to the provider endpoint completed. Running cron job..."',
+
+    # Set up the cron job
+    f'echo "*/1 * * * * {register_command}" | crontab -',
+
+    # Start the cron service
+    'crond -f',
+  ])
 
-  swarm_config['services']['compose-provider'] = {
-    'image': 'httpd:alpine',
-    'networks': networks_list,
-    'configs': [
-      {
-        'source': traefik_http_provider_name,
-        'target': '/usr/local/apache2/htdocs/bridge.json',
+  seto_agent_compose_data, _ = resolve_compose_file(
+    driver=driver,
+    compose_data={
+      'services': {
+        'seto_agent': {
+          'image': 'curlimages/curl:latest',
+          'user': 'root',  # Ensure it runs as root to avoid issue `crontab: must be suid to work properly`
+          'networks': networks_list,
+          'entrypoint': f"sh -c '{entrypoint}'",
+          'volumes-image': [
+            f'{traefik_http_provider_filename}:{traefik_http_provider_target}',
+          ],
+        },
       },
-    ],
-    'deploy': {
-      'labels': [
-        'traefik.discovery.enable=false',
-      ],
     },
-  }
+  )
+
+  swarm_config['services'].update(seto_agent_compose_data['services'])
 
   resolve(
     args,
     driver,
     inject=True,
     execute=lambda config, placement: parse_compose_config(
-      driver.stack,
       args,
       driver,
       client,
@@ -246,6 +289,7 @@ def execute_deploy_command(args, driver: Driver) -> None:
       composes=composes_items,
       traefik_http_provider_routers=traefik_http_provider_routers,
       traefik_http_provider_services=traefik_http_provider_services,
+      traefik_http_provider_middlewares=traefik_http_provider_middlewares,
     ),
   )
 
@@ -255,25 +299,31 @@ def execute_deploy_command(args, driver: Driver) -> None:
   with open(traefik_http_provider_filename, 'w', encoding='utf-8') as file:
     file.write(json.dumps(traefik_http_provider, indent='  '))
 
-  print(f'Building {driver.stack} swarm images...')
+  print(f'Building {driver.stack_id} swarm images...')
   # swarm.info()
   swarm.build()
 
-  print(f'Deploying {driver.stack} swarm environment...')
+  print(f'Pushing {driver.stack_id} images...')
+  swarm.push()
+
+  # print(f'Creating {driver.stack_id} volumes...')
+  # driver.create_volumes(replica=replica, volumes=volumes, force=args.force)
+
+  print(f'Deploying {driver.stack_id} swarm environment...')
   swarm.deploy()
   swarm.ps()
 
   if composes_items:
-    print(f'Building {driver.stack} compose images...')
+    print(f'Building {driver.stack_id} compose images...')
     for compose in composes_items:
       # compose.info()
       compose.build()
 
-    print(f'Pulling {driver.stack} compose images...')
+    print(f'Pulling {driver.stack_id} compose images...')
     for compose in composes_items:
       compose.pull()
 
-    print(f'Deploying {driver.stack} compose environment...')
+    print(f'Deploying {driver.stack_id} compose environment...')
     for compose in composes_items:
       compose.deploy()
       compose.ps()

{seto-2.0.4 → seto-2.2.0}/seto/commands/down.py

@@ -24,11 +24,11 @@ def execute_down_command(args, driver: Driver) -> None:
   client = DockerClient.from_env()
 
   # Docker Swarm
-  print(f'Stoping {driver.stack} environment...')
+  print(f'Stoping {driver.stack_id} environment...')
   setattr(args, 'compose', False)
 
   swarm = DockerSwarm(
-    stack=driver.stack,
+    stack=driver.stack_id,
     client=client,
     driver=driver,
     config=resolve(args, driver),
@@ -42,7 +42,7 @@ def execute_down_command(args, driver: Driver) -> None:
 
   if config['services']:
     compose = DockerCompose(
-      stack=driver.stack,
+      stack=driver.stack_id,
       client=client,
       driver=driver,
       config=config,

{seto-2.0.4 → seto-2.2.0}/seto/commands/setup.py

@@ -24,10 +24,11 @@ def execute_setup_command(args, driver: Driver) -> None:
   clients: list[Setting] = [items[0] for items in args.clients]
 
   driver.connect()
+  deploy_seto_stack(args, driver, replica)
   generate_ssh_keys(args, driver)
   driver.setup_manager(replica, args.force)
   driver.setup_nodes(clients, args.force)
-  deploy_seto_stack(args, driver)
+  driver.apply_manager_changes()
   driver.terminate()
 
 

{seto-2.0.4 → seto-2.2.0}/seto/core/docker.py

@@ -26,12 +26,10 @@ from .shell import Shell
 class Docker:
   def __init__(
     self,
-    stack: str,
     config: dict,
     driver: Driver,
     client: DockerClient,
   ) -> None:
-    self.stack = stack
     self.driver = driver
     self.client = client
     self.config = config
@@ -48,7 +46,7 @@ class Docker:
   def external_networks(self) -> list[str]:
     return [
       item.attrs['Name'] for item in self.client.networks.list()
-      if item.attrs['Name'].startswith(self.stack)
+      if item.attrs['Name'].startswith(self.driver.stack_id)
     ]
 
   @staticmethod
@@ -63,13 +61,19 @@ class Docker:
 
   def build(self) -> None:
     Shell.pipe_exec(
-      command=f'docker compose -f - -p {self.stack} build --push --no-cache',
+      command=f'docker compose -f - -p {self.driver.stack_id} build --no-cache',
+      pipe_input=self.resolved_config,
+    )
+
+  def push(self) -> None:
+    Shell.pipe_exec(
+      command=f'docker compose -f - -p {self.driver.stack_id} push',
       pipe_input=self.resolved_config,
     )
 
   def pull(self) -> None:
     Shell.pipe_exec(
-      command=f'docker compose -f - -p {self.stack} pull --policy=always',
+      command=f'docker compose -f - -p {self.driver.stack_id} pull --policy=always',
       pipe_input=self.resolved_config,
     )
 
@@ -109,20 +113,20 @@ class DockerCompose(Docker):
     return None
 
   def info(self) -> None:
-    self._exec(f'docker compose -p {self.stack} -f - config')
+    self._exec(f'docker compose -p {self.driver.stack_id} -f - config')
 
   def deploy(self) -> None:
     print(f'Deploying on {self.node_hostname}...')
-    self._exec(f'docker compose -p {self.stack} -f - up -d --remove-orphans')
+    self._exec(f'docker compose -p {self.driver.stack_id} -f - up -d --remove-orphans')
 
   def ps(self) -> None:
-    self._exec(f'docker compose -p {self.stack} -f - ps')
+    self._exec(f'docker compose -p {self.driver.stack_id} -f - ps')
 
   def logs(self) -> None:
-    self._exec(f'docker compose -p {self.stack} -f - logs')
+    self._exec(f'docker compose -p {self.driver.stack_id} -f - logs')
 
   def down(self) -> None:
-    self._exec(f'docker compose -p {self.stack} -f - down')
+    self._exec(f'docker compose -p {self.driver.stack_id} -f - down')
 
   def _exec(self, command: str) -> None:
     Docker.remote_node_run(
@@ -141,17 +145,17 @@ class DockerSwarm(Docker):
 
   def deploy(self) -> None:
     Shell.pipe_exec(
-      command=f'docker stack deploy --prune --detach=true --resolve-image=always -c - {self.stack}',
+      command=f'docker stack deploy --prune --detach=true --resolve-image=always -c - {self.driver.stack_id}',
       pipe_input=self.resolved_config,
     )
 
   def ps(self) -> None:
-    # Shell.exec(f'docker stack ps --no-trunc - {self.stack}')
-    Shell.exec(f'docker stack services {self.stack}')
+    # Shell.exec(f'docker stack ps --no-trunc - {self.driver.stack_id}')
+    Shell.exec(f'docker stack services {self.driver.stack_id}')
 
   def logs(self) -> None:
-    # Shell.exec(f'docker stack service logs -f -c - {self.stack}')
+    # Shell.exec(f'docker stack service logs -f -c - {self.driver.stack_id}')
     pass
 
   def down(self) -> None:
-    Shell.exec(f'docker stack rm {self.stack}')
+    Shell.exec(f'docker stack rm {self.driver.stack_id}')

{seto-2.0.4 → seto-2.2.0}/seto/core/driver.py

@@ -28,14 +28,20 @@ class Driver:
     stack: str,
     *,
     project: str,
-    brickname: str,
     shell: Shell,
   ) -> None:
     self.stack = stack
     self.project = project
-    self.brickname = brickname
     self.shell = shell
 
+  @property
+  def brickname(self) -> str:
+    return f'{self.project}/{self.stack}' if self.stack else self.project
+
+  @property
+  def stack_id(self) -> str:
+    return f'{self.project}_{self.stack}' if self.stack else self.project
+
   @property
   def slug(self) -> str:
     raise NotImplementedError()

seto-2.2.0/seto/core/network.py

@@ -0,0 +1,69 @@
+# Copyright 2024 Sébastien Demanou. All Rights Reserved.
+#
+# 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 glob
+import os
+
+import yaml
+
+GLOBAL_NETWORKS = {
+  'seto-cloud-public': {
+    'name': 'seto-cloud-public',
+    'driver': 'overlay',
+    'attachable': True,
+  },
+  'seto-cloud-edge': {
+    'name': 'seto-cloud-edge',
+    'driver': 'overlay',
+    'attachable': True,
+  },
+  'seto-http-provider': {
+    'name': 'seto-http-provider',
+    'driver': 'overlay',
+    'attachable': True,
+  },
+}
+
+
+def get_global_external_networks() -> dict:
+  return {
+    shortname: {
+      'name': network['name'],
+      'external': True,
+    } for shortname, network in GLOBAL_NETWORKS.items()
+  }
+
+
+def resolve_networks(
+  project: str,
+  external_networks: list[str] | None = None,
+) -> dict:
+  networks_files = glob.glob(os.path.join('networks', '*.yaml'))
+  merged_data = {}
+
+  for network_file in networks_files:
+    with open(network_file, encoding='utf-8') as file:
+      network_key = os.path.splitext(os.path.basename(network_file))[0]
+      network_data = yaml.safe_load(file)
+      network_name = network_data.get('name', f'{project}_{network_key}')
+      merged_data[network_key] = network_data
+
+      if external_networks and network_key in external_networks:
+        network_data.clear()
+
+        network_data['external'] = True
+
+      network_data['name'] = network_name
+
+  return merged_data

{seto-2.0.4 → seto-2.2.0}/seto/core/parser.py

@@ -70,9 +70,8 @@ def parse_local_volumes(
 
     for volume_entry in service_volumes_image:
       if isinstance(volume_entry, str):
-        if volume_entry.startswith('./'):
-          source, target, _ = parse_volume_entry(volume_entry)
-          local_volumes.append((source, target))
+        source, target, _ = parse_volume_entry(volume_entry)
+        local_volumes.append((source, target))
 
   if len(local_volumes) > 0:
     _, image_version = tuple((service['image'].split(':') + ['latest'])[0:2])
@@ -156,7 +155,6 @@ def parse_volumes(
 def resolve_compose_file(
   driver: Driver,
   *,
-  compose_dir: str,
   compose_data: dict,
   inject: bool = False,
   mode: list[ResolveMode] | None = None,
@@ -183,7 +181,7 @@ def resolve_compose_file(
 
     service_deploy_labels.update(service_labels)
     parse_stack_values(service_deploy_labels)
-    parse_local_volumes(driver.stack, service_name=service_name, service=service)
+    parse_local_volumes(driver.stack_id, service_name=service_name, service=service)
 
     parse_volumes(
       driver=driver,
@@ -278,7 +276,6 @@ def resolve_env_vars(content: str) -> str:
 
 def parse_compose_file(compose_file: str, resolve_vars=False) -> tuple[dict, str, str]:
   compose_file = os.path.realpath(compose_file)
-  compose_dir = os.path.dirname(compose_file)
 
   with open(compose_file, encoding='utf-8') as file:
     compose_content = file.read()
@@ -288,31 +285,7 @@ def parse_compose_file(compose_file: str, resolve_vars=False) -> tuple[dict, str
 
     compose_data = yaml.safe_load(compose_content)
 
-  return compose_data, compose_file, compose_dir
-
-
-def resolve_networks(
-  project: str,
-  external_networks: list[str] | None = None,
-) -> dict:
-  networks_files = glob.glob(os.path.join('networks', '*.yaml'))
-  merged_data = {}
-
-  for network_file in networks_files:
-    with open(network_file, encoding='utf-8') as file:
-      network_key = os.path.splitext(os.path.basename(network_file))[0]
-      network_data = yaml.safe_load(file)
-      network_name = network_data.get('name', f'{project}_{network_key}')
-      merged_data[network_key] = network_data
-
-      if external_networks and network_key in external_networks:
-        network_data.clear()
-
-        network_data['external'] = True
-
-      network_data['name'] = network_name
-
-  return merged_data
+  return compose_data, compose_file
 
 
 def parse_services(
@@ -329,7 +302,7 @@ def parse_services(
 
   for service_file in services_files:
     resolve_vars = mode and 'compose' in mode
-    compose_data, _, compose_dir = parse_compose_file(service_file, resolve_vars)
+    compose_data, _ = parse_compose_file(service_file, resolve_vars)
     x_mode = compose_data.get('x-mode', 'swarm')
 
     if x_mode not in ['compose', 'swarm']:
@@ -346,7 +319,6 @@ def parse_services(
     # resolve compose local volumes
     resolved_compose_data, volumes = resolve_compose_file(
       driver=driver,
-      compose_dir=compose_dir,
       compose_data=compose_data,
       inject=inject,
       mode=[x_mode],

{seto-2.0.4 → seto-2.2.0}/seto/core/shell.py

@@ -126,7 +126,7 @@ class Shell:
     return username in ouput
 
   @staticmethod
-  def exec(command: str, *, stdout=True, **kwargs) -> str:
+  def exec(command: str, *, stdout=True, env_vars: dict | None = None, **kwargs) -> str:
     # Run docker stack deploy with the content piped to it
     process = subprocess.Popen(
       command,
@@ -135,6 +135,7 @@ class Shell:
       stderr=subprocess.PIPE,
       text=True,
       shell=True,
+      env={**(env_vars or {}), **dict(subprocess.os.environ)},
     )
 
     standard_output, standard_error = process.communicate(**kwargs)
@@ -150,9 +151,9 @@ class Shell:
     return standard_output
 
   @staticmethod
-  def pipe_exec(command: str, *, stdout=True, pipe_input: str) -> str:
+  def pipe_exec(command: str, *, stdout=True, pipe_input: str, env_vars: dict | None = None) -> str:
     with StringIO(pipe_input) as pipe:
-      return Shell.exec(command, stdout=stdout, input=pipe.read())
+      return Shell.exec(command, stdout=stdout, env_vars=env_vars, input=pipe.read())
 
   def install(self, package_name: str, *, user='nobody', group='nogroup') -> None:
     result = self.run(f'dpkg -l | grep {package_name}', quiet=True, stdout=False)

seto-2.2.0/seto/core/traefik.py

@@ -0,0 +1,90 @@
+# Copyright 2024 Sébastien Demanou. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+from typing import Any
+
+
+def deep_set(dct: dict[str, Any], keys: str, value: Any):
+  """
+  Helper function to set a nested dictionary value using a dot-separated key.
+  This handles array notation like 'rewrites[0]' and converts plural-named keys to arrays.
+
+  Args:
+    dct: The dictionary to modify.
+    keys: A dot-separated string representing the nested keys.
+    value: The value to set at the nested location.
+  """
+  keys_list = keys.replace('[', '.').replace(']', '').split('.')
+  current = dct
+
+  for index, key in enumerate(keys_list[:-1]):
+    if key.isdigit():  # Convert to list if the key is an index
+      key = int(key)
+      if not isinstance(current, list):
+        current = []
+
+      # Extend the list if the index doesn't exist yet
+      while len(current) <= key:
+        current.append({})
+      current = current[key]
+    else:
+      if isinstance(current, list):  # Handle case where current is mistakenly a list
+        current = current[-1]
+      current = current.setdefault(key, {})
+
+  # Handle the last key separately
+  final_key = keys_list[-1]
+
+  # Convert plural-named parameters to arrays (e.g. 'middlewares', 'rewrites')
+  if final_key.endswith('s') and isinstance(value, str):
+    value = [item.strip() for item in value.split(',')]
+
+  if final_key.isdigit():  # Handle if the final key is an array index
+    final_key = int(final_key)
+    if not isinstance(current, list):
+      current = []
+    while len(current) <= final_key:
+      current.append({})
+    current[final_key] = value
+  else:
+    current[final_key] = value
+
+
+def convert_middlewares_to_dict(labels: dict[str, str]) -> dict:
+  """
+  Convert all Traefik middleware labels to JSON format, handling arrays for plural-named keys
+  and deeply nested fields.
+
+  Args:
+    labels: A dictionary of Docker labels.
+
+  Returns:
+    A JSON string representing the middleware configurations.
+  """
+  middlewares = {}
+
+  for label, value in labels.items():
+    if label.startswith('traefik.http.middlewares.'):
+      parts = label.split('.')
+      if len(parts) > 3:
+        middleware_name = parts[3]
+        middleware_key = '.'.join(parts[4:])
+
+        if middleware_name not in middlewares:
+          middlewares[middleware_name] = {}
+
+        # Use the deep_set helper to handle nested keys
+        deep_set(middlewares[middleware_name], middleware_key, value)
+
+  return middlewares