portmgr 0.1.0__tar.gz

portmgr-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 theascone
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

portmgr-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: portmgr
+Version: 0.1.0
+Summary: Add your description here
+Home-page: https://github.com/Craeckie/portmgr
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: humanfriendly~=10.0
+Requires-Dist: jsonschema~=3.2.0
+Requires-Dist: pyyaml~=6.0.2
+Requires-Dist: tabulate~=0.8.9
+Dynamic: home-page
+Dynamic: license-file
+
+# portmgr
+portmgr is a wrapper around [docker-compose](https://docs.docker.com/compose/) that allows running typical docker-compose commands recursively. Additionally, it shortens commands to a single letter.
+
+Let's say you have organized your compose files like this, you just add a `dckrsub.yml` in each parent folder:
+<pre>
+docker/
+├── <b>dckrsub.yml</b>
+├── reverse-proxy/
+│   └── docker-compose.yml
+├── storage
+│   ├── <b>dckrsub.yml</b>
+│   ├── nextcloud/
+│   │   └── docker-compose.yml
+│   └── immich/
+│       └── docker-compose.yml
+└── scripts
+</pre>
+
+Each `dckrsub.yml` has a list of subdirectories, which portmgr should decend into.
+For example, the `dckrsub.yml` in `docker/` might look like this:
+```yaml
+- reverse-proxy
+- storage
+```
+
+And the `dckrsub.yml` in `docker/storage/` like this:
+```yaml
+- nextcloud
+- immich
+```
+
+Now, if you run `portmgr u` in `docker/` it will run `docker compose up -d` in `reverse-proxy/`, `storage/nextcloud/` and `storage/immich/`.
+
+portmgr starts from the current directory, so when running it in `docker/storage/`, it will run `docker compose` only in `nextcloud/` and `immich/`. You can also use it in a directory with a `docker-compose.yml` as a shortener for docker-compose commands.
+
+### Commands
+The following commands are available. The respective docker-compose commands are in brackets.
+
+```
+  u   Create and start containers (up)
+  p   Pull images (pull)
+  s   Stop services (stop)
+  d   Stop and remove containers (down)
+  l   Show container logs (logs)
+  a   Run shell in container (exec -it <service> sh)
+  b   Build images (build)
+  c   List containers (ps)
+  t   List processes in containers (top)
+  r   Build and push to registry (build, push)
+  v   Scan container images for vulnerabilities
+```
+
+You combine multiple commands. For example `portmgr dul`, runs docker compose with `down`, `up` and `logs`, thus stopping, removing and starting all containers and then showing the logs.
+
+### Installation
+```
+sudo pip install portmgr
+```
+
+Or build it from source (here using the latest commit on master branch)
+```
+sudo pip install https://github.com/Craeckie/portmgr.git
+```
+
+### Tipps
+If you use portmgr a lot like me, you might want to shorten it to one letter. For bash, you can add `alias p='portmgr'` to `~/.bashrc`. For fish-shell you can add `abbr p portmgr` to `~/.config/fish/config.fish`.

portmgr-0.1.0/README.md

@@ -0,0 +1,66 @@
+# portmgr
+portmgr is a wrapper around [docker-compose](https://docs.docker.com/compose/) that allows running typical docker-compose commands recursively. Additionally, it shortens commands to a single letter.
+
+Let's say you have organized your compose files like this, you just add a `dckrsub.yml` in each parent folder:
+<pre>
+docker/
+├── <b>dckrsub.yml</b>
+├── reverse-proxy/
+│   └── docker-compose.yml
+├── storage
+│   ├── <b>dckrsub.yml</b>
+│   ├── nextcloud/
+│   │   └── docker-compose.yml
+│   └── immich/
+│       └── docker-compose.yml
+└── scripts
+</pre>
+
+Each `dckrsub.yml` has a list of subdirectories, which portmgr should decend into.
+For example, the `dckrsub.yml` in `docker/` might look like this:
+```yaml
+- reverse-proxy
+- storage
+```
+
+And the `dckrsub.yml` in `docker/storage/` like this:
+```yaml
+- nextcloud
+- immich
+```
+
+Now, if you run `portmgr u` in `docker/` it will run `docker compose up -d` in `reverse-proxy/`, `storage/nextcloud/` and `storage/immich/`.
+
+portmgr starts from the current directory, so when running it in `docker/storage/`, it will run `docker compose` only in `nextcloud/` and `immich/`. You can also use it in a directory with a `docker-compose.yml` as a shortener for docker-compose commands.
+
+### Commands
+The following commands are available. The respective docker-compose commands are in brackets.
+
+```
+  u   Create and start containers (up)
+  p   Pull images (pull)
+  s   Stop services (stop)
+  d   Stop and remove containers (down)
+  l   Show container logs (logs)
+  a   Run shell in container (exec -it <service> sh)
+  b   Build images (build)
+  c   List containers (ps)
+  t   List processes in containers (top)
+  r   Build and push to registry (build, push)
+  v   Scan container images for vulnerabilities
+```
+
+You combine multiple commands. For example `portmgr dul`, runs docker compose with `down`, `up` and `logs`, thus stopping, removing and starting all containers and then showing the logs.
+
+### Installation
+```
+sudo pip install portmgr
+```
+
+Or build it from source (here using the latest commit on master branch)
+```
+sudo pip install https://github.com/Craeckie/portmgr.git
+```
+
+### Tipps
+If you use portmgr a lot like me, you might want to shorten it to one letter. For bash, you can add `alias p='portmgr'` to `~/.bashrc`. For fish-shell you can add `abbr p portmgr` to `~/.config/fish/config.fish`.

portmgr-0.1.0/portmgr/__init__.py

@@ -0,0 +1,2 @@
+from .portmgr import main, command_list, bcolors
+from .wrapper import runCompose, runBuildx

portmgr-0.1.0/portmgr/__main__.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+from __future__ import unicode_literals
+
+import sys
+
+if __package__ is None and not hasattr(sys, 'frozen'):
+    # direct call of __main__.py
+    import os.path
+    path = os.path.realpath(os.path.abspath(__file__))
+    sys.path.insert(0, os.path.dirname(os.path.dirname(path)))
+
+import portmgr
+
+if __name__ == '__main__':
+    portmgr.main()

portmgr-0.1.0/portmgr/commands/attach.py

@@ -0,0 +1,51 @@
+from portmgr import command_list, bcolors
+import subprocess
+
+from portmgr.wrapper import getServicesRunning
+
+
+def func(action):
+    directory = action['directory']
+    relative = action['relative']
+
+    names = getServicesRunning()
+
+    index = 0
+    cont_count = len(names)
+    if cont_count == 0:
+      print("No containers found!")
+      return 1
+    elif cont_count > 1:
+      i = 0
+      for cont in names:
+        print("(" + str(i) + ") " + cont)
+        i += 1
+      
+      while True:
+        choice = input("Choose container: ")
+        if choice:
+          try:
+            index = int(choice)
+            if index >= 0 and index < cont_count:
+              break
+          except ValueError:
+            print("Please enter a number!")
+            pass
+        print("Please enter a number between 0 and " + cont_count - 1 + "!")
+              
+    container_id = names[index]
+    print("Attaching to " + container_id)
+    subprocess.call(["docker", "exec", "-it", container_id, "sh"])
+
+    # res = subprocess.call(["docker-compose", "logs", "--follow", "--tail=200"])
+
+    # if res != 0:
+        # print("Error showing logs for " + relative + "!\n")
+
+    return 0
+
+command_list['a'] = {
+    'hlp': 'Attach to process',
+    'ord': 'nrm',
+    'fnc': func
+}

portmgr-0.1.0/portmgr/commands/build.py

@@ -0,0 +1,25 @@
+from portmgr import command_list, bcolors, runCompose
+
+
+def func(action):
+    directory = action['directory']
+    relative = action['relative']
+
+    res = runCompose(
+            ['build', '--pull'],
+            env={
+                'COMPOSE_DOCKER_CLI_BUILD': '1',
+                'DOCKER_BUILDKIT': '1'
+                },
+            )
+
+    if res != 0:
+        print("Error building " + relative + "!")
+
+    return res
+
+command_list['b'] = {
+    'hlp': 'Build local image',
+    'ord': 'nrm',
+    'fnc': func
+}

portmgr-0.1.0/portmgr/commands/down.py

@@ -0,0 +1,27 @@
+from portmgr import command_list, bcolors, runCompose
+
+
+def func(action):
+    directory = action['directory']
+    relative = action['relative']
+
+    res = runCompose(["down"])
+    # p = subprocess.Popen(["docker-compose", "down"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+    # out, err = p.communicate()
+
+    # if out != "":
+    #     print(out.decode("UTF-8"))
+
+    if not res == 0:
+        print("Error removing " + relative + "!")
+    
+    # print(bcolors.FAIL + err.decode("UTF-8") + bcolors.ENDC)
+
+    return 0
+
+command_list['d'] = {
+    'hlp': 'Stop and remove container',
+    'ord': 'rev',
+    'fnc': func
+}

portmgr-0.1.0/portmgr/commands/logs.py

@@ -0,0 +1,19 @@
+from portmgr import command_list, bcolors, runCompose
+
+
+def func(action):
+    directory = action['directory']
+    relative = action['relative']
+
+    res = runCompose(["logs", "--follow", "--tail=200"])
+
+    if res != 0:
+        print("Error showing logs for " + relative + "!\n")
+
+    return 0
+
+command_list['l'] = {
+    'hlp': 'Show logs',
+    'ord': 'nrm',
+    'fnc': func
+}

portmgr-0.1.0/portmgr/commands/ps.py

@@ -0,0 +1,19 @@
+from portmgr import command_list, bcolors, runCompose
+
+
+def func(action):
+    directory = action['directory']
+    relative = action['relative']
+
+    res = runCompose(["ps"])
+
+    if res != 0:
+        print("Error listing containers for " + relative + "!\n")
+
+    return 0
+
+command_list['c'] = {
+    'hlp': 'List containers',
+    'ord': 'nrm',
+    'fnc': func
+}

portmgr-0.1.0/portmgr/commands/pull.py

@@ -0,0 +1,19 @@
+from portmgr import command_list, bcolors, runCompose
+
+
+def func(action):
+    directory = action['directory']
+    relative = action['relative']
+
+    res = runCompose(["pull"])
+
+    if res != 0:
+        print("Error pulling " + relative + "!")
+
+    return 0
+
+command_list['p'] = {
+    'hlp': 'Pull image from repository',
+    'ord': 'nrm',
+    'fnc': func
+}

portmgr-0.1.0/portmgr/commands/push.py

@@ -0,0 +1,76 @@
+from portmgr import command_list, bcolors, runCompose, runBuildx
+import subprocess
+import os
+
+from portmgr.wrapper import getServices
+
+
+def func(action):
+    directory = action['directory']
+    relative = action['relative']
+
+    services = getServices(includeOnlyBuildable=True)
+
+    print('Services to build: ' + ', '.join(services))
+
+    res = 0
+    for service in services.keys():
+        print(f"\nBuilding {service}")
+
+        new_res = 2
+        if multi_platform := os.environ.get("PORTMGR_MULTI_PLATFORM", "").lower():
+            try:
+                new_res = runBuildx(
+                    ['bake',
+                     '--pull',
+                     '--push',
+                     '--set', f'*.platform={multi_platform}',
+                     service
+                     ], timeout=1200 #kill after 20mins
+                )
+                if new_res != 0:
+                    res = new_res
+                    print(f"Error building {service}!")
+            except TimeoutExpired:
+                print(f"Error building {service}! Build timed out.")
+        else:
+            try:
+                new_res = runCompose(
+                        ['build',
+                         '--pull',
+                         '--force-rm',
+                         '--compress',
+                         service
+                         ], timeout=1200
+                        )
+                if new_res != 0:
+                    res = new_res
+                    print(f"Error building {service}!")
+                else:
+                    new_res = runCompose(
+                            ['push',
+                             '--ignore-push-failures',
+                             service
+                             ]
+                            )
+                print(f"Error pushing {service}!")
+            except TimeoutExpired:
+                print(f"Error building {service}! Build timed out.")
+            if new_res != 1:
+                res = new_res
+        if os.environ.get("PORTMGR_CLEAN_AFTER_PUSH", "").lower() == "true":
+            subprocess.call(['docker', 'system', 'prune', '--all', '--force'])
+            subprocess.call(['docker', 'buildx', 'prune', '--all', '--force'])
+
+    if res != 0:
+        print("Error building&pushing " + relative + "!")
+        return res
+
+    return res
+
+
+command_list['r'] = {
+    'hlp': 'build, push to registry & remove image',
+    'ord': 'nrm',
+    'fnc': func
+}

portmgr-0.1.0/portmgr/commands/scan.py

@@ -0,0 +1,43 @@
+from portmgr import command_list
+import subprocess
+
+from portmgr.wrapper import getImages
+
+
+def func(action):
+    directory = action['directory']
+    relative = action['relative']
+
+    images = getImages()
+
+    res = 0
+
+    for image in images:
+        image_name = image["Name"]
+        print(f'Scanning {image_name} of {image["ContainerName"]}')
+        scan_res = subprocess.run(['trivy', '-q', 'image', '-s', 'CRITICAL', '--exit-code', '1', image_name], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+        if scan_res.returncode != 0:
+            print('Found vulnerabilites:')
+            print(scan_res.stdout)
+            res = scan_res.returncode
+
+      #print("Name: %s" % container.name)
+      #names.append(container.name)
+      #config_str = subprocess.check_output(["docker", "inspect", "-f", '{{json .}}', container.id], stdout=subprocess.PIPE)
+      #json.loads(config_str)
+      #print("IP: %s" % ip)
+      #print(container.inspect)
+
+
+    #ID = subprocess.run(["docker-compose", "ps", '-q'], stdout=subprocess.PIPE).stdout
+
+    #if res != 0:
+    #    print("Error listing containers for " + relative + "!\n")
+
+    return res
+
+command_list['v'] = {
+    'hlp': 'Scan container images for vulnerabilities',
+    'ord': 'nrm',
+    'fnc': func
+}

portmgr-0.1.0/portmgr/commands/stats.py

@@ -0,0 +1,52 @@
+from functools import cmp_to_key
+
+from portmgr import command_list
+
+from tabulate import tabulate
+from humanfriendly import format_size, parse_size
+
+from portmgr.wrapper import getStats
+
+
+def func(action):
+    directory = action['directory']
+    relative = action['relative']
+
+    stats_list = getStats()
+
+    values = []
+    has_network_stats = False
+    for stats in stats_list:
+        name = stats['Name'] if 'Name' in stats else stats['Container']
+        #memory = stats["memory_stats"]
+        #usage = format_size(memory['usage'])
+        #limit = format_size(memory['limit'])
+        memory_string = stats["MemUsage"]
+        usage, limit = [p.strip() for p in memory_string.split('/')]
+        if 'NetIO' in stats:
+            network = stats["NetIO"]
+            received, sent = [p.strip() for p in memory_string.split('/')]
+            #received = format_size(sum(stats['rx_bytes'] for iface, stats in network.items()))
+            #sent = format_size(sum(stats['tx_bytes'] for iface, stats in network.items()))
+            columns = (stats['Name'], usage, limit, received, sent)
+            has_network_stats = True
+        else:
+            columns = (stats['Name'], usage, limit)
+        values.append(columns)
+    if values:
+        # sort by memory usage
+        values = sorted(values, key=cmp_to_key(lambda s1, s2: parse_size(s2[1]) - parse_size(s1[1])))
+        print(tabulate(values,
+                       headers=['Service', 'Mem Usage', 'Mem Limit', 'Net Recv', 'Net Sent'],
+                       colalign=['left', 'right', 'right', 'right', 'right'] if has_network_stats
+                           else ['left', 'right', 'right']))
+        print('')
+
+    return 0
+
+
+command_list['o'] = {
+    'hlp': 'Show container stats',
+    'ord': 'nrm',
+    'fnc': func
+}

portmgr-0.1.0/portmgr/commands/stop.py

@@ -0,0 +1,26 @@
+from portmgr import command_list, bcolors, runCompose
+
+def func(action):
+    directory = action['directory']
+    relative = action['relative']
+
+    res = runCompose(["stop"])
+    # p = subprocess.Popen(["docker-compose", "stop"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+     #out, err = p.communicate()
+
+     #if out != "":
+     #    print(out.decode("UTF-8"))
+
+    if res != 0:
+        print("Error stopping " + relative + "!")
+    
+    # print(bcolors.FAIL + err.decode("UTF-8") + bcolors.ENDC)
+
+    return 0
+
+command_list['s'] = {
+    'hlp': 'Stop container',
+    'ord': 'rev',
+    'fnc': func
+}

portmgr-0.1.0/portmgr/commands/top.py

@@ -0,0 +1,18 @@
+from portmgr import command_list, runCompose
+
+def func(action):
+    relative = action['relative']
+
+    res = runCompose(["top"])
+
+    if res != 0:
+        print("Error listing processes of containers in " + relative + "!\n")
+
+    return 0
+
+
+command_list['t'] = {
+    'hlp': 'List processes in containers',
+    'ord': 'nrm',
+    'fnc': func
+}

portmgr-0.1.0/portmgr/commands/up.py

@@ -0,0 +1,26 @@
+from portmgr import command_list, bcolors, runCompose
+
+def func(action):
+    directory = action['directory']
+    relative = action['relative']
+
+    res = runCompose(["up", "-d"])
+    # p = subprocess.Popen(["docker-compose", "up", "-d"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+    # out, err = p.communicate()
+
+    # if out != "":
+       # print(out.decode("UTF-8"))
+
+    if res != 0:
+        print("Error creating " + relative + "!")
+    
+    # print(bcolors.FAIL + err.decode("UTF-8") + bcolors.ENDC)
+
+    return 0
+
+command_list['u'] = {
+    'hlp': 'Create container',
+    'ord': 'nrm',
+    'fnc': func
+}

portmgr-0.1.0/portmgr/portmgr.py

@@ -0,0 +1,170 @@
+#!/usr/bin/python3
+import os, sys
+import argparse
+import importlib
+import re
+
+import yaml
+
+
+class MyParser(argparse.ArgumentParser):
+    def error(self, message):
+        sys.stderr.write('Error: %s\n' % message)
+        self.print_help()
+        sys.exit(2)
+
+
+sub_names = [x.strip() for x in re.split('[ ,;]+', os.environ.get('PORTMGR_SUB_NAME', 'dckrsub.yml'))]
+compose_names = [x.strip() for x in
+                 os.environ.get('PORTMGR_COMPOSE_NAME', 'docker-compose.yml, docker-compose.yaml').split(',')]
+
+# sub_scheme_name = 'dckrsub.schema.yml'
+
+src_path = os.path.dirname(os.path.abspath(__file__))
+
+
+# conf_scheme_path = os.path.join(src_path, sub_scheme_name)
+# sub_scheme_path = os.path.join(src_path, sub_scheme_name)
+
+# conf_scheme = dckrjsn.read_json(conf_scheme_path)
+# sub_scheme = dckrjsn.read_json(sub_scheme_path)
+
+class bcolors:
+    HEADER = '\033[95m'
+    OKBLUE = '\033[94m'
+    OKGREEN = '\033[92m'
+    WARNING = '\033[93m'
+    FAIL = '\033[91m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+    UNDERLINE = '\033[4m'
+
+
+command_list = {}
+action_list = []
+
+
+def addCommand(cur_directory):
+    if not any(action['directory'] == cur_directory for action in action_list):
+        relative_dir = os.path.relpath(cur_directory, base_directory)
+        if relative_dir == '.':
+            relative_dir = os.path.basename(os.path.normpath(cur_directory))
+        action_list.append({
+            'directory': cur_directory,
+            'relative': relative_dir
+        })
+
+
+def read_yaml(path):
+    with open(path, 'r') as stream:
+        try:
+            return yaml.load(stream, Loader=yaml.SafeLoader)
+        except yaml.YAMLError as exc:
+            print(exc)
+
+
+def traverse(cur_directory):
+    # print("Traversing in " + cur_directory)
+    for sub_name in sub_names:
+        sub_path = os.path.join(cur_directory, sub_name)
+        compose_paths = [os.path.join(cur_directory, name) for name in compose_names]
+
+        # print("Checking file at " + sub_path)
+        if os.path.isfile(sub_path):  # has sub folders
+            # print("Has sub folders!")
+            # sub_folders = dckrjsn.read_json(sub_path, sch = sub_scheme)
+            sub_folders = read_yaml(sub_path)
+            for sub_folder in sub_folders:
+                # print("Checking out " + sub_folder)
+                next_directory = os.path.join(cur_directory, sub_folder)
+                traverse(next_directory)
+        elif any(os.path.isfile(path) for path in compose_paths):  # has a docker-compose file
+            addCommand(cur_directory)
+
+
+def main():
+    # global cli
+    global base_directory
+
+    # cli = docker.Client('unix://var/run/docker.sock')
+
+    # Include external source files for commands
+    # These fill the m_cmd list
+    for file in os.listdir(os.path.join(src_path, 'commands')):
+        ext_file = os.path.splitext(file)
+
+        if ext_file[1] == '.py' and not ext_file[0] == '__init__':
+            importlib.import_module('portmgr.commands.' + ext_file[0])
+
+    parser = MyParser()
+    parser.add_argument('-D',
+                        dest='base_directory',
+                        action='store',
+                        default='',
+                        help='Set working directory')
+    # parser.add_argument('-R',
+    #    dest='recursive',
+    #    action='store_true',
+    #    help='Use dckrsub.json files to recursively apply operations')
+
+    for cmd in command_list.items():
+        parser.add_argument('-' + cmd[0],
+                            dest='a_cmd',
+                            action='append_const',
+                            const=cmd[0],
+                            help=cmd[1]['hlp'])
+
+    argv = sys.argv[1:]
+    if len(argv) == 1 and not argv[0].startswith('-'):
+        argv[0] = '-' + argv[0]
+    args = parser.parse_args(argv)
+
+    if len(sys.argv) == 1:
+        parser.print_help()
+        sys.exit(1)
+
+    base_directory = os.path.join(os.getcwd(), args.base_directory)
+
+    # if args.recursive:
+    traverse(base_directory)
+    # else:
+    #    addCommand(base_directory)
+
+    last_cmd = ''
+    for cmd in args.a_cmd:  # loop over all passed arguments (t, r, u)
+        cur_cmd = command_list[cmd]
+        cmd_function = cur_cmd['fnc']
+        cmd_order = cur_cmd['ord'];
+
+        #        if last_cmd == 'r' and cur_cmd == 'u':
+        #          print("Waiting 3 seconds.. ")
+        #          sleep(3)
+
+        if cmd_order == 'nrm':
+            action_list_sorted = action_list
+        elif cmd_order == 'rev':
+            action_list_sorted = reversed(action_list)
+        else:
+            exit(1)
+
+        failed_list = []
+
+        for action in action_list_sorted:
+            origWD = os.getcwd()
+            newWD = action['directory']
+            os.chdir(newWD)
+            print('-> ' + action["relative"])
+            if cmd_function(action) != 0:  # execute the function through reflection
+                failed_list.append(action)
+            os.chdir(origWD)
+        if failed_list:
+            print('Failed containers:')
+            for action in failed_list:
+                print('- ' + action['relative'])
+            print("")
+
+    exit(0)
+
+
+if __name__ == '__main__':
+    main()

portmgr-0.1.0/portmgr/wrapper.py

@@ -0,0 +1,67 @@
+import json
+import os
+from subprocess import run, check_output
+
+
+def getServices(includeOnlyBuildable=False):
+    data = check_output(['docker', 'compose', 'config', '--format', 'json'])
+    config = json.loads(data)
+    services = config['services']
+    if includeOnlyBuildable:
+        services = {name: values for name, values in services.items() if 'build' in values.keys()}
+    return services
+
+
+def getServicesRunning():
+    data = check_output(['docker', 'compose', 'ps', '--format', 'json'])
+    try:
+        lines = data.decode().splitlines()
+        if len(lines) > 1:
+            container_list = []
+            for l in lines:
+                #print(f'l: {l}')
+                container_list.append(json.loads(l.strip()))
+        else:
+            container_list = json.loads(data)
+    except Exception as e:
+        print(e)
+        print(data.decode())
+    if isinstance(container_list, dict):
+        container_names = [container_list['Name']]
+    else:
+        container_names = [s['Name'] for s in container_list]
+    return container_names
+
+
+def getImages():
+    data = check_output(['docker', 'compose', 'images', '--format', 'json'])
+    image_list = json.loads(data)
+    images = [
+        {'ID': image['ID'],
+         'Name': image['Repository'],
+         'ContainerName': image['ContainerName'],
+         'Tag': image['Tag']}
+        for image in image_list
+    ]
+    return images
+
+
+def getStats():
+    containers = getServicesRunning()
+    data = check_output(['docker', 'stats', '--format', 'json', '--no-stream'] + containers, text=True).strip()
+    data_lines = data.split('\n')
+    stats = [json.loads(line) for line in data_lines]
+    return stats
+
+
+def runCompose(args, **kwargs):
+    command = ['docker', 'compose']
+    if os.environ.get("PORTMGR_IN_SCRIPT", "").lower() == "true":
+        command += ["--ansi", "never"]
+    command += list(args)
+    return run(command, **kwargs).returncode
+
+def runBuildx(args, **kwargs):
+    command = ['docker', 'buildx']
+    command += list(args)
+    return run(command, **kwargs).returncode

portmgr-0.1.0/portmgr.egg-info/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: portmgr
+Version: 0.1.0
+Summary: Add your description here
+Home-page: https://github.com/Craeckie/portmgr
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: humanfriendly~=10.0
+Requires-Dist: jsonschema~=3.2.0
+Requires-Dist: pyyaml~=6.0.2
+Requires-Dist: tabulate~=0.8.9
+Dynamic: home-page
+Dynamic: license-file
+
+# portmgr
+portmgr is a wrapper around [docker-compose](https://docs.docker.com/compose/) that allows running typical docker-compose commands recursively. Additionally, it shortens commands to a single letter.
+
+Let's say you have organized your compose files like this, you just add a `dckrsub.yml` in each parent folder:
+<pre>
+docker/
+├── <b>dckrsub.yml</b>
+├── reverse-proxy/
+│   └── docker-compose.yml
+├── storage
+│   ├── <b>dckrsub.yml</b>
+│   ├── nextcloud/
+│   │   └── docker-compose.yml
+│   └── immich/
+│       └── docker-compose.yml
+└── scripts
+</pre>
+
+Each `dckrsub.yml` has a list of subdirectories, which portmgr should decend into.
+For example, the `dckrsub.yml` in `docker/` might look like this:
+```yaml
+- reverse-proxy
+- storage
+```
+
+And the `dckrsub.yml` in `docker/storage/` like this:
+```yaml
+- nextcloud
+- immich
+```
+
+Now, if you run `portmgr u` in `docker/` it will run `docker compose up -d` in `reverse-proxy/`, `storage/nextcloud/` and `storage/immich/`.
+
+portmgr starts from the current directory, so when running it in `docker/storage/`, it will run `docker compose` only in `nextcloud/` and `immich/`. You can also use it in a directory with a `docker-compose.yml` as a shortener for docker-compose commands.
+
+### Commands
+The following commands are available. The respective docker-compose commands are in brackets.
+
+```
+  u   Create and start containers (up)
+  p   Pull images (pull)
+  s   Stop services (stop)
+  d   Stop and remove containers (down)
+  l   Show container logs (logs)
+  a   Run shell in container (exec -it <service> sh)
+  b   Build images (build)
+  c   List containers (ps)
+  t   List processes in containers (top)
+  r   Build and push to registry (build, push)
+  v   Scan container images for vulnerabilities
+```
+
+You combine multiple commands. For example `portmgr dul`, runs docker compose with `down`, `up` and `logs`, thus stopping, removing and starting all containers and then showing the logs.
+
+### Installation
+```
+sudo pip install portmgr
+```
+
+Or build it from source (here using the latest commit on master branch)
+```
+sudo pip install https://github.com/Craeckie/portmgr.git
+```
+
+### Tipps
+If you use portmgr a lot like me, you might want to shorten it to one letter. For bash, you can add `alias p='portmgr'` to `~/.bashrc`. For fish-shell you can add `abbr p portmgr` to `~/.config/fish/config.fish`.

portmgr-0.1.0/portmgr.egg-info/SOURCES.txt

@@ -0,0 +1,27 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+portmgr/__init__.py
+portmgr/__main__.py
+portmgr/portmgr.py
+portmgr/wrapper.py
+portmgr.egg-info/PKG-INFO
+portmgr.egg-info/SOURCES.txt
+portmgr.egg-info/dependency_links.txt
+portmgr.egg-info/not-zip-safe
+portmgr.egg-info/requires.txt
+portmgr.egg-info/top_level.txt
+portmgr/commands/__init__.py
+portmgr/commands/attach.py
+portmgr/commands/build.py
+portmgr/commands/down.py
+portmgr/commands/logs.py
+portmgr/commands/ps.py
+portmgr/commands/pull.py
+portmgr/commands/push.py
+portmgr/commands/scan.py
+portmgr/commands/stats.py
+portmgr/commands/stop.py
+portmgr/commands/top.py
+portmgr/commands/up.py

portmgr-0.1.0/portmgr.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

portmgr-0.1.0/portmgr.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

portmgr-0.1.0/portmgr.egg-info/requires.txt

@@ -0,0 +1,4 @@
+humanfriendly~=10.0
+jsonschema~=3.2.0
+pyyaml~=6.0.2
+tabulate~=0.8.9

portmgr-0.1.0/portmgr.egg-info/top_level.txt

@@ -0,0 +1 @@
+portmgr

portmgr-0.1.0/pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "portmgr"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "humanfriendly~=10.0",
+    "jsonschema~=3.2.0",
+    "pyyaml~=6.0.2",
+    "tabulate~=0.8.9",
+]

portmgr-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

portmgr-0.1.0/setup.py

@@ -0,0 +1,26 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='portmgr',
+    version='1.8.0dev0',
+    url="https://github.com/Craeckie/portmgr",
+    description="Simple command interface to manage multiple Docker container",
+    packages=find_packages(), #['portmgr'],
+    license='Creative Commons Attribution-Noncommercial-Share Alike license',
+    long_description=open('README.md').read(),
+    long_description_content_type="text/markdown",
+    zip_safe=False,
+
+    install_requires=[
+        'jsonschema',
+        'tabulate',
+        'PyYAML',
+        'jsonschema',
+        'humanfriendly'
+    ],
+    entry_points = {
+        'console_scripts': [
+            'portmgr = portmgr:main'
+        ]
+    }
+)