kgrok 0.1.0__tar.gz

kgrok-0.1.0/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Daniel Golding
+
+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.

kgrok-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+include requirements.in

kgrok-0.1.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.1
+Name: kgrok
+Version: 0.1.0
+Summary: forward local processes into k8s cluster
+Author: Daniel Golding
+License: MIT License
+        
+        Copyright (c) 2024 Daniel Golding
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/cakemanny/kgrok
+Project-URL: Repository, https://github.com/cakemanny/kgrok.git
+Keywords: kubernetes,proxy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Internet :: Proxy Servers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: click
+Requires-Dist: lightkube
+Requires-Dist: trio
+
+# Kgrok
+
+## Quick Start
+
+```
+kgrok my-svc localhost:8080
+```
+
+We assume you have a service already listening locally on port 8080
+and you have your `kubectl` context configured for the cluster you want to
+listen receive traffic from.
+
+
+## Installation
+
+Using [pipx] might be the most reliable.
+
+```
+pipx install kgrok
+```
+
+[pipx]: https://pipx.pypa.io/stable/
+
+If you are however already in a Python 3.12 virtual environment, or inside
+a container with pip, you can probably get away with it.
+
+```
+python3 -m pip install kgrok
+```

kgrok-0.1.0/README.md

@@ -0,0 +1,29 @@
+# Kgrok
+
+## Quick Start
+
+```
+kgrok my-svc localhost:8080
+```
+
+We assume you have a service already listening locally on port 8080
+and you have your `kubectl` context configured for the cluster you want to
+listen receive traffic from.
+
+
+## Installation
+
+Using [pipx] might be the most reliable.
+
+```
+pipx install kgrok
+```
+
+[pipx]: https://pipx.pypa.io/stable/
+
+If you are however already in a Python 3.12 virtual environment, or inside
+a container with pip, you can probably get away with it.
+
+```
+python3 -m pip install kgrok
+```

kgrok-0.1.0/pyproject.toml

@@ -0,0 +1,69 @@
+[build-system]
+requires = ["setuptools >= 61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+dynamic = ["dependencies"]
+
+name        = "kgrok"
+description = "forward local processes into k8s cluster"
+
+# TODO: use dynamic version
+#   dynamic = ["version"]
+# https://packaging.python.org/en/latest/guides/single-sourcing-package-version/#single-sourcing-the-version
+version     = "0.1.0"
+
+requires-python = ">=3.12"
+authors     = [
+  {name = "Daniel Golding"}
+]
+
+readme = {file = "README.md", content-type = "text/markdown" }
+keywords    = ["kubernetes", "proxy"]
+license     = {file = "LICENSE.txt"}
+
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Topic :: Internet :: Proxy Servers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.12",
+]
+
+[project.urls]
+Homepage  = "https://github.com/cakemanny/kgrok"
+Repository  = "https://github.com/cakemanny/kgrok.git"
+
+[project.scripts]
+kgrok        = "kgrok.local:main"
+kgrok-remote = "kgrok.remote:main"
+
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+testpaths = [
+  "tests",
+]
+trio_mode = true
+
+[tool.ruff]
+src = ["src", "test"]
+target-version = "py312"
+
+[tool.ruff.lint]
+# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
+# Unlike Flake8, Ruff doesn't enable pycodestyle warnings (`W`) or
+# McCabe complexity (`C901`) by default.
+select = [
+  "E4", "E7", "E9", "F",  # defaults
+  "ASYNC",
+  "TRIO",
+]
+
+[tool.pyright]
+
+# due to way lightkube exports stuff
+reportPrivateImportUsage = false

kgrok-0.1.0/requirements.in

@@ -0,0 +1,3 @@
+click
+lightkube
+trio

kgrok-0.1.0/setup.cfg

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

kgrok-0.1.0/setup.py

@@ -0,0 +1,8 @@
+from setuptools import setup
+
+with open('./requirements.in') as f:
+    dependencies = f.read().splitlines()
+
+setup(
+    install_requires=dependencies
+)

kgrok-0.1.0/src/kgrok/local.py

@@ -0,0 +1,268 @@
+import os
+from contextlib import AsyncExitStack
+import functools
+import logging
+import subprocess
+import typing
+
+from lightkube import AsyncClient
+from lightkube.config.kubeconfig import KubeConfig, SingleConfig
+from lightkube.models.core_v1 import ServicePort, ServiceSpec
+from lightkube.models.meta_v1 import ObjectMeta
+from lightkube.resources.core_v1 import Service
+from trio.abc import SendStream, SendChannel, ReceiveChannel
+import lightkube
+import click
+import trio
+
+from kgrok.messages import (
+    ConnectionClosed, DataReceived, NewConnection, Text as encoding,
+)
+
+
+log = logging.getLogger(__name__)
+
+
+async def handle_connection(
+    conn_id: int,
+    local_svc_addr: tuple[str, int],
+    response_channel: SendChannel,
+    recv: ReceiveChannel,
+):
+    host, port = local_svc_addr
+    local_stream = await trio.open_tcp_stream(host, port)
+
+    async def remote_to_local(recv):
+        async with recv:  # not sure if it's our job to close this or not...
+            async for message in recv:
+                match message:
+                    case DataReceived(_, data):
+                        await local_stream.send_all(data)
+                    case ConnectionClosed():
+                        await local_stream.send_eof()
+                    case _:
+                        raise TypeError(type(message))
+
+    async def local_to_remote(response_channel):
+        async for data in local_stream:
+            await response_channel.send(DataReceived(conn_id, data))
+        await response_channel.send(ConnectionClosed(conn_id))
+
+    async with local_stream, trio.open_nursery() as nursery:
+        nursery.start_soon(remote_to_local, recv)
+        nursery.start_soon(local_to_remote, response_channel)
+
+
+async def write_responses(remote_stdin: SendStream, *,
+                          task_status=trio.TASK_STATUS_IGNORED):
+    send, recv = trio.open_memory_channel(0)
+    task_status.started(send)
+
+    async with recv:
+        async for message in recv:
+            await remote_stdin.send_all(encoding.encode(message))
+
+
+async def accept_connections(
+    nursery: trio.Nursery,
+    remote_stdio: trio.StapledStream,
+    local_svc_addr: tuple[str, int]
+):
+
+    response_channel: SendChannel = await nursery.start(
+        write_responses, remote_stdio.send_stream,
+    )
+
+    connections: dict[int, SendChannel] = {}
+
+    try:
+        while True:
+            message = await encoding.read_ipc_message(remote_stdio)
+            match message:
+                case NewConnection(conn_id):
+                    send, recv = trio.open_memory_channel(80)
+                    connections[conn_id] = send
+                    nursery.start_soon(
+                        handle_connection,
+                        conn_id, local_svc_addr, response_channel, recv,
+                    )
+                case DataReceived(conn_id, _):
+                    conn = connections.get(conn_id)
+                    if conn:
+                        await conn.send(message)
+                    else:
+                        log.warning(f'dropped data for {conn_id=}')
+                case ConnectionClosed(conn_id):
+                    conn = connections.get(conn_id)
+                    if conn:
+                        await conn.send(message)
+                        await conn.aclose()
+                        del connections[conn_id]
+                    else:
+                        log.warning(f'unknown connection {conn_id=}')
+                case None:
+                    break
+    finally:
+        async with AsyncExitStack() as stack:
+            for chan in connections.values():
+                stack.push_async_exit(chan)
+
+###
+### Startup
+###
+
+def run_remote(port):
+
+    return functools.partial(
+        trio.run_process,
+        [".venv/bin/kgrok-remote", "--port", str(port)],
+        stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+        env={'PYTHONUNBUFFERED': "1"}
+    )
+
+
+def prepare_labels(labels: dict[str, str]) -> str:
+    return ','.join(
+        '='.join((k, v)) for k,v in labels.items()
+    )
+
+
+def run_kubectl_run(port, labels, namespace):
+
+    default_image = "ghcr.io/cakemanny/kgrok-remote"
+    image = os.getenv("KGROK_REMOTE_IMAGE", default_image)
+
+    extra_args = []
+    # For now this is something of a good indicator for a locally loaded
+    # dev image
+    if '/' not in image:  # locally loaded dev image
+        extra_args.append("--image-pull-policy=Never")
+
+    if namespace and namespace != 'default':
+        extra_args.append(f"--namespace={namespace}")
+
+    return functools.partial(
+        trio.run_process,
+        [
+            # The --rm doesn't seem to work without --tty
+            # so, we have to call kubectl delete
+            "kubectl", "run", "-i", "--rm", "kgrok-remote",
+            f"--image={image}",
+            "--port", str(port),
+            "--restart=Never",
+            "--labels=" + prepare_labels(labels),  # shell vuln?
+            *extra_args,
+            "--",
+            "--port", str(port),
+        ],
+        stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+        # capture stderr?
+    )
+
+
+type TargetSpec = tuple[dict[str, str], int]
+
+
+def target_spec_from_service(svc: Service) -> TargetSpec:
+    assert svc.metadata is not None, f'svc.metadata is None: {svc=}'
+    assert svc.spec is not None, f'svc.spec is None: {svc=}'
+    name = svc.metadata.name
+
+    # I checked the api spec for this one
+    selector = typing.cast(dict[str,str], svc.spec.selector)
+
+    ports = svc.spec.ports or []
+    if len(ports) <= 1:
+        raise ValueError(f'service {name} has no ports')
+    if len(ports) > 1:
+        log.warning(f'service {name} has more than one port, using first')
+
+    # Future: we could exclude udp ports
+    # Future: we could prefer http appProtocol over other options...
+
+    port = ports[0].targetPort or ports[0].port
+    if isinstance(port, str):
+        # Future: look up selected pods and work out what the name
+        # refers to
+        raise ValueError(f'service {name} has a named port, named ports not supported')
+
+    return selector, port
+
+
+async def setup_service(
+    name: str, namespace: str, port: int, exit_stack: AsyncExitStack,
+) -> TargetSpec:
+
+    config: SingleConfig | None = KubeConfig.from_env().get()
+    assert config is not None
+    client = AsyncClient(config=config)
+
+    try:
+        svc = await client.get(Service, name, namespace=namespace)
+        assert isinstance(svc, Service)
+        return target_spec_from_service(svc)
+    except lightkube.ApiError as e:
+        if e.status.reason == "NotFound":
+            labels = {'app': name}
+            service = Service(
+                metadata=ObjectMeta(
+                    name=name, namespace=namespace, labels=labels,
+                ),
+                spec=ServiceSpec(
+                    ports=[ServicePort(port=port)], selector=labels,
+                )
+            )
+            await client.create(service, name)
+            exit_stack.push_async_callback(
+                client.delete, Service, name, namespace=namespace,
+            )
+            return labels, port
+        else:
+            raise
+
+
+async def async_main(service_name: str, host: str, port: int, namespace: str):
+
+    async with AsyncExitStack() as exit_stack:
+        labels, remote_port = await setup_service(
+            service_name, namespace, port, exit_stack)
+
+        try:
+            async with trio.open_nursery() as nursery:
+                process = await nursery.start(
+                    run_kubectl_run(remote_port, labels, namespace)
+                )
+                nursery.start_soon(
+                    accept_connections, nursery, process.stdio, (host, port),
+                )
+        except subprocess.CalledProcessError as cpe:
+            log.warning(f'calledprocesserror {cpe=}')
+            raise
+        finally:
+            try:
+                await trio.run_process(["kubectl", "delete", "pod", "kgrok-remote"])
+            except Exception as e:
+                log.warning("failed to delete pod", repr(e))
+
+
+@click.command()
+@click.argument('service-name')
+@click.argument('host-port')
+@click.option('-n', '--namespace', default="default" , help='the kubernetes namespace')
+def main(service_name, host_port, namespace):
+    host = 'localhost'
+    if ':' in host_port:
+        host, port = host_port.split(':')
+        port = int(port)
+    else:
+        port = int(host_port)
+
+    logging.basicConfig(
+        level=logging.INFO,
+    )
+
+    trio.run(async_main, service_name, host, port, namespace)
+
+
+if __name__ == '__main__':
+    main()

kgrok-0.1.0/src/kgrok/messages.py

@@ -0,0 +1,85 @@
+# TODO: rename module IPC?
+from dataclasses import dataclass
+import io
+
+import trio.abc
+
+
+# A text version of our messages for debugability during development
+class Text:
+
+    @staticmethod
+    def new_connection(conn_id) -> bytes:
+        return f'NC:{conn_id:08x}\n'.encode()
+
+    @staticmethod
+    def connection_closed(conn_id) -> bytes:
+        return f'CC:{conn_id:08x}\n'.encode()
+
+    @staticmethod
+    def data_received(conn_id, data: bytes) -> bytes:
+        b = io.BytesIO()
+        b.write(f'DR:{conn_id:08x}:{len(data):08x}:'.encode())
+        b.write(data)
+        b.write(b'\n')
+        return b.getvalue()
+
+    _cc_message_length = len(connection_closed(0))
+
+    @staticmethod
+    async def read_ipc_message(stream: trio.abc.ReceiveStream):
+        def extract_conn_id(prefix):
+            return int(prefix[3:11], 16)
+
+        prefix = await stream.receive_some(Text._cc_message_length)
+        if prefix == b'':
+            return None
+        if prefix.startswith(b'NC:'):
+            conn_id = extract_conn_id(prefix)
+            return NewConnection(conn_id)
+        if prefix.startswith(b'CC:'):
+            conn_id = extract_conn_id(prefix)
+            return ConnectionClosed(conn_id)
+        if prefix.startswith(b'DR:'):
+            conn_id = extract_conn_id(prefix)
+            length = await stream.receive_some(9)
+            assert length[-1:] == b':', f"{length=}"
+            length = int(length[:8], 16)
+            data = await stream.receive_some(length + 1)
+            assert data[-1:] == b'\n', f'{data=}'
+            data = data[:-1]
+            return DataReceived(conn_id, data)
+        raise Exception(f'Unknown message with {prefix=}')
+
+    @staticmethod
+    def can_encode(msg) -> bool:
+        return isinstance(msg, (DataReceived, ConnectionClosed, NewConnection))
+
+    type Message = DataReceived | ConnectionClosed | NewConnection
+
+    @classmethod
+    def encode(cls, msg: Message) -> bytes:
+        match msg:
+            case DataReceived(conn_id, data):
+                return cls.data_received(conn_id, data)
+            case ConnectionClosed(conn_id):
+                return cls.connection_closed(conn_id)
+            case NewConnection(conn_id):
+                return cls.new_connection(conn_id)
+        raise TypeError(f'cannot encode {msg.__class.__.__name__}')
+
+
+@dataclass
+class DataReceived:
+    conn_id: int
+    data: bytes
+
+
+@dataclass
+class ConnectionClosed:
+    conn_id: int
+
+
+@dataclass
+class NewConnection:
+    conn_id: int

kgrok-0.1.0/src/kgrok/remote.py

@@ -0,0 +1,169 @@
+from itertools import count
+import logging
+import os
+import signal
+import sys
+
+from trio.abc import SendChannel, ReceiveChannel
+import click
+import trio
+
+from kgrok.messages import (
+    ConnectionClosed, DataReceived, Text as encoding,
+)
+
+log = logging.getLogger(__name__)
+
+CONNECTION_COUNTER = count()
+
+
+class Handler:
+    def __init__(self, new_connections: SendChannel[tuple[int, SendChannel]]) -> None:
+        self.stdout = trio.wrap_file(sys.stdout.buffer)
+        self.new_connections = new_connections
+
+    async def __call__(self, stream: trio.SocketStream):
+        conn_id = next(CONNECTION_COUNTER)
+
+        async with trio.open_nursery() as nursery:
+            nursery.start_soon(self._handle_recv, conn_id, stream)
+            nursery.start_soon(self._handle_resp, conn_id, stream)
+
+    async def _handle_resp(self, conn_id: int, stream: trio.SocketStream):
+        # The thought with the 80 here is that, configuring it to be 0
+        # would mean that all connections would block if this client stops
+        # reading ...
+        # The correct thing to do would be to
+        #  - a: timeout the sends and
+        #  - b: stop reading in recv if sends are not working.
+        send, recv = trio.open_memory_channel(80)
+        await self.new_connections.send((conn_id, send,))
+
+        async with recv:
+            async for value in recv:
+                match value:
+                    case DataReceived(conn_id, data):
+                        await stream.send_all(data)
+                    case ConnectionClosed(conn_id):
+                        await stream.send_eof()
+                    case _:
+                        raise TypeError(type(value))
+
+    async def _handle_recv(self, conn_id: int, stream: trio.SocketStream):
+        # we must've got a connection
+        await self.stdout.write(encoding.new_connection(conn_id))
+        try:
+            async for data in stream:
+                await self.stdout.write(encoding.data_received(conn_id, data))
+        finally:
+            await self.stdout.write(encoding.connection_closed(conn_id))
+
+
+async def combine[L, R](
+    left: ReceiveChannel[L],
+    right: ReceiveChannel[R],
+    *,
+    task_status=trio.TASK_STATUS_IGNORED,
+):
+    out: SendChannel[tuple[L, None] | tuple[None, R]]
+    out, recv = trio.open_memory_channel(0)
+    task_status.started(recv)
+
+    async def read_left(cancel_scope):
+        async for value in left:
+            await out.send((value, None))
+        log.debug('cancel left')
+        cancel_scope.cancel()
+
+    async def read_right(cancel_scope):
+        async for value in right:
+            await out.send((None, value))
+        log.debug('cancel right')
+        cancel_scope.cancel()
+
+    async with out, trio.open_nursery() as nursery:
+        nursery.start_soon(read_left, nursery.cancel_scope)
+        nursery.start_soon(read_right, nursery.cancel_scope)
+
+
+async def dispatch_stdin(
+    from_decode: ReceiveChannel,
+    new_channels: ReceiveChannel[tuple[int, SendChannel]]
+):
+    channels: dict[int, SendChannel] = {}
+
+    async with trio.open_nursery() as nursery:
+        messages_or_new_connections = await nursery.start(
+            combine, from_decode, new_channels)
+
+        async for (message, new_channel) in messages_or_new_connections:
+            if new_channel is not None:
+                conn_id, send = new_channel
+                channels[conn_id] = send
+            else:
+                assert message is not None
+                channel = channels.get(message.conn_id)
+                if channel is not None:
+                    # Idea: one option might be to close the connection
+                    # if the client stops reading.
+                    await channel.send(message)
+                    if isinstance(message, ConnectionClosed):
+                        await channel.aclose()
+                        del channels[message.conn_id]
+                else:
+                    # This really happened once in testing and the client
+                    # hung... so maybe we have a problem after all.
+                    # I think we have to switch back to the dict
+                    log.warning(
+                        f'dropped message for {message.conn_id=}',
+                    )
+        await messages_or_new_connections.aclose()
+
+
+async def decode_stdin(decoded: SendChannel):
+    # WARN: Absolutely no other use of stdin is allowed
+    async with decoded, trio.lowlevel.FdStream(os.dup(sys.stdin.fileno())) as stdin:
+        while True:
+            message = await encoding.read_ipc_message(stdin)
+            if message is None:
+                break
+            await decoded.send(message)
+
+
+async def handle_sigterm(cancel_scope: trio.CancelScope):
+    with trio.open_signal_receiver(signal.SIGTERM) as signal_aiter:
+        async for signum in signal_aiter:
+            assert signum == signal.SIGTERM
+            log.info('SIGTERM. cancelling')
+            cancel_scope.cancel()
+
+
+async def listen(port: int):
+    async with trio.open_nursery() as nursery:
+        from_decode, to_dispatch = trio.open_memory_channel(0)
+        nursery.start_soon(decode_stdin, from_decode)
+        # nc = new channels/connections
+        nc_from_handler, nc_to_dispatch = trio.open_memory_channel(0)
+        nursery.start_soon(dispatch_stdin, to_dispatch, nc_to_dispatch)
+
+        handler = Handler(nc_from_handler)
+        nursery.start_soon(trio.serve_tcp, handler, port)
+        nursery.start_soon(handle_sigterm, nursery.cancel_scope)
+
+
+@click.command()
+@click.option('--port', required=True, type=int)
+def main(port: int):
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(levelname)s:%(asctime)s:%(name)s:%(message)s'
+    )
+    log.info('listening on port %d', port)
+    try:
+        trio.run(listen, port)
+    finally:
+        log.info('exiting')
+
+
+if __name__ == '__main__':
+    main()

kgrok-0.1.0/src/kgrok.egg-info/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.1
+Name: kgrok
+Version: 0.1.0
+Summary: forward local processes into k8s cluster
+Author: Daniel Golding
+License: MIT License
+        
+        Copyright (c) 2024 Daniel Golding
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/cakemanny/kgrok
+Project-URL: Repository, https://github.com/cakemanny/kgrok.git
+Keywords: kubernetes,proxy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Internet :: Proxy Servers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: click
+Requires-Dist: lightkube
+Requires-Dist: trio
+
+# Kgrok
+
+## Quick Start
+
+```
+kgrok my-svc localhost:8080
+```
+
+We assume you have a service already listening locally on port 8080
+and you have your `kubectl` context configured for the cluster you want to
+listen receive traffic from.
+
+
+## Installation
+
+Using [pipx] might be the most reliable.
+
+```
+pipx install kgrok
+```
+
+[pipx]: https://pipx.pypa.io/stable/
+
+If you are however already in a Python 3.12 virtual environment, or inside
+a container with pip, you can probably get away with it.
+
+```
+python3 -m pip install kgrok
+```

kgrok-0.1.0/src/kgrok.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE.txt
+MANIFEST.in
+README.md
+pyproject.toml
+requirements.in
+setup.py
+src/kgrok/__init__.py
+src/kgrok/local.py
+src/kgrok/messages.py
+src/kgrok/remote.py
+src/kgrok.egg-info/PKG-INFO
+src/kgrok.egg-info/SOURCES.txt
+src/kgrok.egg-info/dependency_links.txt
+src/kgrok.egg-info/entry_points.txt
+src/kgrok.egg-info/requires.txt
+src/kgrok.egg-info/top_level.txt

kgrok-0.1.0/src/kgrok.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kgrok-0.1.0/src/kgrok.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+kgrok = kgrok.local:main
+kgrok-remote = kgrok.remote:main

kgrok-0.1.0/src/kgrok.egg-info/requires.txt

@@ -0,0 +1,3 @@
+click
+lightkube
+trio

kgrok-0.1.0/src/kgrok.egg-info/top_level.txt

@@ -0,0 +1 @@
+kgrok