Add support windows

Author: AMEST

README.md

@@ -9,14 +9,16 @@ Connect to remote docker (wia context or manual `--host` / `env DOCKER_HOST`), g
 Supported OS:
 - Macos
 - Linux
+- Windows (needed cli docker.exe)
 
 # Using
 
-1. Install python 3
+1. Install python 3.8 (minimal version)
 2. Install requirements (`pip install -r requirements.txt`)
 3. Set docker host:
    * Configure via cli: `docker context`
    * Configure via env variable: `export DOCKER_HOST="ssh://user@remote-docker"`
    * Run with args `--host "ssh://user@remote-docker"`
 4. If needed listen privileged ports ( < 1024), add arg `--listen-system-ports`
-5. Run: `python src/main.py`
+5. If you want to interact via docker cli, add arg `--use-docker-cli` 
+6. Run: `python src/main.py`

src/docker_cli_wrapper.py

@@ -0,0 +1,71 @@
+import subprocess, json
+
+class DockerCLIWrapper(object):
+    def containers(self, all=False):
+        ps_args = ['docker', 'ps', '--format', '"{{json .}}"', '--no-trunc']
+        if all:
+            ps_args.append('-a')
+        ps = subprocess.run(ps_args, capture_output=True)
+        ps_output_jsonl = ps.stdout.decode().split("\n")
+        containers = []
+        for container_json in ps_output_jsonl:
+            containers.append(DockerCliWrappedContainer(container_json))
+        
+        return containers
+
+    def info(self):
+        info_args = ['docker', 'info', '--format', '"{{json .}}"']
+        info = subprocess.run(info_args, capture_output=True)
+        return json.loads(info.stdout.decode()[1:-2])
+
+
+class DockerCliWrappedContainer(object):
+    id = None
+    image = None
+    command = None
+    createdAt = None
+    labels = None
+    names = None
+    networks = None
+    ports = None
+    runningFor = None
+    state = None
+    status = None
+    def __init__(self, jsonl):
+        if len(jsonl) <= 2:
+            return
+        self.raw = json.loads(jsonl[1:-1])
+        self.id = self.raw["ID"]
+        self.image = self.raw["Image"]
+        self.command = self.raw["Command"]
+        self.createdAt = self.raw["CreatedAt"]
+        self.labels = self.__parseLabels(self.raw["Labels"])
+        self.ports = self.__parsePorts(self.raw["Ports"])
+        self.networks = self.__parseNetworks(self.raw["Networks"])
+        self.runningFor = self.raw["RunningFor"]
+        self.state = self.raw["State"]
+        self.status = self.raw["Status"]
+
+    def __parseLabels(self, raw_json):
+        labels = {}
+        for label_str in raw_json.split(","):
+            label = label_str.split("=")
+            labels[label[0]] = label[1] if len(label) > 1 else ""
+        return labels
+
+    def __parsePorts(self, raw_json):
+        if len(raw_json) == 0:
+            return {}
+        ports = {}
+        for port_str in raw_json.split(", "):
+            if port_str.find("->") == -1:
+                ports[port_str] =[{"HostPort": port_str.replace("/tcp","").replace("/udp", "")}]
+            else:
+                port = port_str.replace("0.0.0.0:", "").split("->")
+                ports[port[1]] = [{"HostPort":port[0]}]
+        return ports
+
+    def __parseNetworks(self, raw_json):
+        if len(raw_json) == 0:
+            return []
+        return raw_json.split(",")

src/docker_service.py

@@ -2,21 +2,29 @@
 import logging
 import os
 from urllib import parse
+from docker_cli_wrapper import DockerCliWrappedContainer, DockerCLIWrapper
 
 class DockerService(object):
-    def __init__(self, docker_host = None):
+    def __init__(self, docker_host = None, use_cli = False):
         self.docker_host = docker_host
-        self.docker_client = docker.DockerClient(base_url=docker_host, use_ssh_client=docker_host.startswith("ssh"))
+        if use_cli or os.name == "nt":
+            self.docker_client = DockerCLIWrapper()
+            self.use_cli = True
+        else:
+            self.docker_client = docker.DockerClient(base_url=docker_host, use_ssh_client=True)
+            self.use_cli = False
         self.nodeInfo = self.docker_client.info()
         self.logger = logging.getLogger("DockerService")
 
     def getRemoteHost(self):
         return parse.urlparse(os.getenv("DOCKER_HOST") if self.docker_host == None else self.docker_host).hostname
 
     def getPublishedPorts(self):
-        containers = self.docker_client.containers.list()
+        containers = self.docker_client.containers.list() if not self.use_cli else self.docker_client.containers()
         ports = []
         for container in containers:
+            if container.ports == None:
+                continue
             for port in container.ports:
                 if container.ports[port] == None:
                     continue

src/main.py

@@ -4,7 +4,6 @@
 import json
 import logging
 import os
-import sys
 import time
 import argparse
 
@@ -45,10 +44,10 @@ def manageProxies(remote_docker_host_name, published_ports, listen_system_ports)
 
 
 
-def mainLoop(docker_host, listen_system_ports):
+def mainLoop(docker_host, listen_system_ports, use_docker_cli):
     global ACTIVE_PROXIES
     logging.info("Initialize docker remote proxy to `%s`" %docker_host)
-    docker_service = DockerService(docker_host)
+    docker_service = DockerService(docker_host, use_docker_cli)
     remote_docker_host_name = docker_service.getRemoteHost()
 
     try:
@@ -69,11 +68,12 @@ def mainLoop(docker_host, listen_system_ports):
     logging.info('Starting docker remote proxy!')
     parser = argparse.ArgumentParser(description='Remote docker context proxy')
     parser.add_argument('--listen-system-ports', action='store_true', help='Listen and Proxy system ports example: 22, 80, 443 etc.!')
+    parser.add_argument('--use-docker-cli', action='store_true', help='Use docker cli instead of python docker client')
     parser.add_argument('--host', type=str, default=None, help='Docker host uri')
     args = parser.parse_args()
     if DOCKER_HOST_ENV != None:
-        mainLoop(DOCKER_HOST_ENV, args.listen_system_ports)
+        mainLoop(DOCKER_HOST_ENV, args.listen_system_ports, args.use_docker_cli)
     elif args.host != None:
-        mainLoop(args.host, args.listen_system_ports)
+        mainLoop(args.host, args.listen_system_ports, args.use_docker_cli)
     else:
-        mainLoop(getDockerHostFromContext(), args.listen_system_ports)
+        mainLoop(getDockerHostFromContext(), args.listen_system_ports, args.use_docker_cli)