init

Author: AMEST

README.md

@@ -0,0 +1,11 @@
+# Proxy for docker remote context containers
+
+This application bind and listen local ports and proxy connections to remote docker host with associated docker containers
+
+
+# Using
+
+1. Install python 3
+2. Install requirements (`pip install -r requirements.txt`)
+3. Set docker host. Example: `export DOCKER_HOST="ssh://user@remote-docker"`
+4. Run: `python main.py`

requirements.txt

@@ -0,0 +1,2 @@
+docker
+paramiko

src/__pycache__/docker_service.cpython-39.pyc

@@ -0,0 +1,25 @@
+import docker
+import logging
+import os
+from urllib import parse
+
+class DockerService(object):
+    def __init__(self, docker_host = None):
+        self.docker_host = docker_host
+        self.docker_client = docker.DockerClient(base_url=docker_host, use_ssh_client=docker_host.startswith("ssh"))
+        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()
+        ports = []
+        for container in containers:
+            for port in container.ports:
+                if container.ports[port] == None:
+                    continue
+                publishedPort = container.ports[port][0]["HostPort"]
+                ports.append({"internal":port, "published":int(publishedPort)})
+        return ports

src/__pycache__/proxy.cpython-39.pyc

@@ -0,0 +1,78 @@
+from docker_service import DockerService
+from proxy import ProxyType, ProxyServer
+import subprocess
+import json
+import logging
+import os
+import sys
+import time
+import argparse
+
+DOCKER_HOST_ENV = os.getenv("DOCKER_HOST")
+ACTIVE_PROXIES = []
+# Configure Logging
+logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', level=logging.DEBUG)
+
+logging.getLogger("urllib3").setLevel(logging.INFO)
+logging.getLogger("docker").setLevel(logging.INFO)
+
+def getDockerHostFromContext():
+    current_context_name_cmd = subprocess.run(["docker", "context", "show"], capture_output=True)
+    current_context_name = current_context_name_cmd.stdout.decode().replace("\n", "")
+    current_context_cmd = subprocess.run(["docker", "context", "inspect", current_context_name], capture_output=True)
+    current_context_json = json.loads(current_context_cmd.stdout.decode())
+    return current_context_json[0]["Endpoints"]["docker"]["Host"]
+
+def manageProxies(remote_docker_host_name, published_ports, listen_system_ports):
+    global ACTIVE_PROXIES
+    # Get only tcp services because only tcp proxy implemented
+    published_ports = list(x["published"] for x in published_ports if x["internal"].endswith("tcp"))
+    if not listen_system_ports:
+        published_ports = list(x for x in published_ports if x > 1024)
+    new_active_proxies = []
+    # Add active proxy and stop inactive
+    for proxy in ACTIVE_PROXIES:
+        if(proxy.proxy_port in published_ports):
+            new_active_proxies.append(proxy)
+            published_ports.remove(proxy.proxy_port)
+        else:
+            proxy.stop()
+    # Add and start new proxies
+    for port in published_ports:
+        proxy = ProxyServer(remote_docker_host_name, port, ProxyType.TCP)
+        proxy.start()
+        new_active_proxies.append(proxy)
+    # Update proxy list
+    ACTIVE_PROXIES = new_active_proxies
+
+        
+
+def mainLoop(docker_host, listen_system_ports):
+    logging.info("Initialize docker remote proxy to `%s`" %docker_host)
+    docker_service = DockerService(docker_host)
+    remote_docker_host_name = docker_service.getRemoteHost()
+    
+    try:
+        while True:
+            try:
+                published_ports = docker_service.getPublishedPorts()
+                manageProxies(remote_docker_host_name, published_ports, listen_system_ports)
+            except Exception as e:
+                logging.error(e)
+                raise e
+            time.sleep(60)
+    except KeyboardInterrupt:
+        logging.info('Docker remote proxy stopped!')
+
+if __name__ == "__main__":
+    logging.info('Starting docker remote proxy!')
+    parser = argparse.ArgumentParser(description='Remote docker context proxy')
+    parser.add_argument('--listen-system-ports', action=argparse.BooleanOptionalAction, default=False, help='Listen and Proxy system ports example: 22, 80, 443 etc.!')
+    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)
+    elif args.host != None:
+        mainLoop(args.host, args.listen_system_ports)
+    else:
+        mainLoop(getDockerHostFromContext(), args.listen_system_ports)

src/docker_service.py

@@ -0,0 +1,72 @@
+from socketserver import BaseRequestHandler, TCPServer
+from socket import socket, AF_INET, SOCK_STREAM
+import threading
+import logging
+from enum import Enum, auto
+
+
+class ProxyType(Enum):
+    TCP = auto()
+    UDP = auto()
+
+
+class TcpProxySockHandler(BaseRequestHandler):
+    """
+    Request Handler for the proxy server.
+    Instantiated once time for each connection, and must
+    override the handle() method for client communication.
+    """
+
+    PROXY_HOST = None
+    PROXY_PORT = None
+    Logger = logging.getLogger("TcpProxyHandler")
+
+    def handle(self):
+        # self.request is the TCP socket connected to the client
+        self.data = self.request.recv(1024)
+        self.Logger.info("Passing data from: {}".format(self.client_address[0]))
+
+        # Create a socket to the localhost server
+        sock = socket(AF_INET, SOCK_STREAM)
+        # Try to connect to the server and send data
+        try:
+            sock.connect((self.PROXY_HOST, self.PROXY_PORT))
+            sock.sendall(self.data)
+            # Receive data from the server
+            while 1:
+                received = sock.recv(1024)
+                if not received:
+                    break
+                # Send back received data
+                self.request.sendall(received)
+        finally:
+            sock.close()
+
+
+class ProxyServer():
+
+    def __init__(self, proxy_host, proxy_port, type=ProxyType.TCP):
+        if(type != ProxyType.TCP):
+            raise NotImplementedError("Only TCP Proxy implemented")
+        self.logger = logging.getLogger("ProxyServer")
+        self.proxy_host = proxy_host
+        self.proxy_port = proxy_port
+        self.type = type
+        HOST = "127.0.0.1"
+
+        class ThreadedTcpProxyHandler(TcpProxySockHandler):
+            PROXY_HOST = proxy_host
+            PROXY_PORT = proxy_port
+
+        self.server = TCPServer((HOST, proxy_port), ThreadedTcpProxyHandler)
+        self.ip, self.port = self.server.server_address
+        self.logger.info("Creating %s proxy server with listen on %s and proxy to %s:%s", type, proxy_port, proxy_host, proxy_port)
+
+    def start(self):
+        server_thread = threading.Thread(target=self.server.serve_forever)
+        server_thread.start()
+        self.logger.info("Starting %s proxy to %s:%s", self.type, self.proxy_host, self.proxy_port)
+
+    def stop(self):
+        self.server.shutdown()
+        self.logger.info("Stopping %s proxy to %s:%s", self.type, self.proxy_host, self.proxy_port)