rtems-proxy 0.2.4__tar.gz → 0.3.0__tar.gz

{rtems-proxy-0.2.4 → rtems-proxy-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rtems-proxy
-Version: 0.2.4
+Version: 0.3.0
 Summary: Support for a K8S proxy container in controlling and monitoring RTEMS EPICS IOCs
 Author-email: Giles Knap <giles.knap@diamond.ac.uk>
 License:                                  Apache License
@@ -216,8 +216,11 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: typer
+Requires-Dist: jinja2
+Requires-Dist: pexpect
+Requires-Dist: ruamel.yaml
 Requires-Dist: telnetlib3
+Requires-Dist: typer
 Provides-Extra: dev
 Requires-Dist: copier; extra == "dev"
 Requires-Dist: mypy; extra == "dev"

{rtems-proxy-0.2.4 → rtems-proxy-0.3.0}/proxy-start.sh

@@ -3,21 +3,21 @@
 set -x
 
 # This is the folder the PVC for the nfsv2tftp shared volume is mounted into.
-export RTEMS_ROOT=${RTEMS_ROOT:-/nfsv2-tftp}
+export RTEMS_TFTP_PATH=${RTEMS_TFTP_PATH:-/nfsv2-tftp}
 
-if [ ! -d ${RTEMS_ROOT} ]; then
+if [ ! -d ${RTEMS_TFTP_PATH} ]; then
     echo "ERROR: No PVC folder found."
     # make a folder for testing outside of the cluster
-    mkdir -p ${RTEMS_ROOT}
+    mkdir -p ${RTEMS_TFTP_PATH}
 fi
 
 # copy the IOC instance's runtime assets into the shared volume
-cp -rL /epics/ioc ${RTEMS_ROOT}
-cp -r /epics/runtime ${RTEMS_ROOT}
+cp -rL /epics/ioc ${RTEMS_TFTP_PATH}
+cp -r /epics/runtime ${RTEMS_TFTP_PATH}
 # move binary to the root for shorter paths
-mv ${RTEMS_ROOT}/ioc/bin/*/ioc.boot ${RTEMS_ROOT}
+mv ${RTEMS_TFTP_PATH}/ioc/bin/*/ioc.boot ${RTEMS_TFTP_PATH}
 # fix up the paths in st.cmd
-sed -i "s|/epics/|/iocs/${IOC_LOCATION}/${IOC_NAME}/|" ${RTEMS_ROOT}/runtime/st.cmd
+sed -i "s|/epics/|/iocs/${IOC_LOCATION}/${IOC_NAME}/|" ${RTEMS_TFTP_PATH}/runtime/st.cmd
 
 # keep the container running ...
 while true; do

{rtems-proxy-0.2.4 → rtems-proxy-0.3.0}/pyproject.toml

@@ -14,7 +14,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
 ]
 description = "Support for a K8S proxy container in controlling and monitoring RTEMS EPICS IOCs"
-dependencies = ["typer", "telnetlib3"]
+dependencies = ["jinja2", "pexpect", "ruamel.yaml", "telnetlib3", "typer"]
 dynamic = ["version"]
 license.file = "LICENSE"
 readme = "README.md"
@@ -89,6 +89,11 @@ commands =
 """
 
 [tool.ruff]
+ignore = [
+    "B008", # Do not perform unnecessary work in __all__
+    "C408", # Unnecessary collection call - e.g. list(...) instead of [...]
+    "E501", # Line too long, should be fixed by black.
+]
 src = ["src", "tests"]
 line-length = 88
 lint.select = [

rtems-proxy-0.3.0/src/rtems_proxy/__main__.py

@@ -0,0 +1,149 @@
+from pathlib import Path
+from time import sleep
+from typing import Optional
+
+import typer
+from jinja2 import Template
+from ruamel.yaml import YAML
+
+from . import __version__
+from .copy import copy_rtems
+from .globals import GLOBALS
+from .telnet import ioc_connect
+
+__all__ = ["main"]
+
+cli = typer.Typer()
+
+
+def version_callback(value: bool):
+    if value:
+        typer.echo(__version__)
+        raise typer.Exit()
+
+
+@cli.callback()
+def main(
+    version: Optional[bool] = typer.Option(
+        None,
+        "--version",
+        callback=version_callback,
+        is_eager=True,
+        help="Print the version of ibek and exit",
+    ),
+):
+    """
+    Proxy for RTEMS IOCs controlling and monitoring
+    """
+
+
+@cli.command()
+def start(
+    copy: bool = typer.Option(
+        True, "--copy/--no-copy", help="copy binaries before connecting"
+    ),
+    reboot: bool = typer.Option(
+        True, "--reboot/--no-reboot", help="reboot the IOC first"
+    ),
+):
+    """
+    Starts an RTEMS IOC. Places the IOC binaries in the expected location,
+    restarts the IOC and connects stdio to the IOC console.
+
+    This should be called inside of a runtime IOC container after ibek
+    has generated the runtime assets for the IOC.
+
+    The standard 'start.sh' in the runtime IOC will call this entry point if
+    it detects that EPICS_HOST_ARCH==RTEMS-beatnik
+
+    args:
+    copy: Copy the RTEMS binaries to the IOCs TFTP and NFS directories first
+    reboot: Reboot the IOC once the binaries are copied and the connection is made
+    """
+    print(
+        f"Remote control startup of RTEMS IOC {GLOBALS.IOC_NAME}"
+        f" at {GLOBALS.RTEMS_IOC_IP}"
+    )
+    if copy:
+        copy_rtems()
+    ioc_connect(GLOBALS.RTEMS_CONSOLE, reboot=reboot)
+
+
+@cli.command()
+def dev(
+    ioc_repo: Path = typer.Argument(
+        ...,
+        help="The beamline/accelerator repo holding the IOC instance",
+        file_okay=False,
+        exists=True,
+    ),
+    ioc_name: str = typer.Argument(
+        ...,
+        help="The name of the IOC instance to work on",
+    ),
+):
+    """
+    Sets up a devcontainer to work on an IOC instance. Must be run from within
+    the developer container for the generic IOC that the instance uses.
+
+    args:
+    ioc_repo: The path to the IOC repository that holds the instance
+    ioc_name: The name of the IOC instance to work on
+    """
+
+    ioc_path = ioc_repo / "services" / ioc_name
+
+    values = ioc_repo / "helm/shared/values.yaml"
+    if not values.exists():
+        typer.echo(f"Global settings file {values} not found. Exiting")
+        raise typer.Exit(1)
+
+    ioc_values = ioc_path / "values.yaml"
+    if not ioc_values.exists():
+        typer.echo(f"Instance settings file {ioc_values} not found. Exiting")
+        raise typer.Exit(1)
+
+    env_vars = {}
+    # TODO in future use pydantic and make a model for this but for now let's cheese it.
+    with open(values) as fp:
+        yaml = YAML(typ="safe").load(fp)
+    try:
+        ioc_group = yaml["ioc-instance"]["ioc_group"]
+        for item in yaml["ioc-instance"]["globalEnv"]:
+            env_vars[item["name"]] = item["value"]
+    except KeyError:
+        typer.echo(f"{values} not in expected format")
+        raise typer.Exit(1) from None
+
+    with open(ioc_values) as fp:
+        yaml = YAML(typ="safe").load(fp)
+    try:
+        for item in yaml["shared"]["ioc-instance"]["iocEnv"]:
+            env_vars[item["name"]] = item["value"]
+    except KeyError:
+        typer.echo(f"{ioc_values} not in expected format")
+        raise typer.Exit(1) from None
+
+    this_dir = Path(__file__).parent
+    template = Path(this_dir / "rsync.sh.jinja").read_text()
+
+    script = Template(template).render(
+        env_vars=env_vars,
+        ioc_group=ioc_group,
+        ioc_name=ioc_name,
+        ioc_path=ioc_path,
+    )
+
+    script_file = Path("/tmp/dev_proxy.sh")
+    script_file.write_text(script)
+
+    typer.echo(f"\nIOC {ioc_name} dev environment prepared for {ioc_repo}")
+    typer.echo("You can now change and compile support module or iocs.")
+    typer.echo("Then start the ioc with '/epics/ioc/start.sh'")
+    typer.echo(f"\n\nPlease first source {script_file} to set up the dev environment.")
+
+
+# test with:
+#     pipenv run python -m ibek
+if __name__ == "__main__":
+    cli()

{rtems-proxy-0.2.4 → rtems-proxy-0.3.0}/src/rtems_proxy/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.4'
-__version_tuple__ = version_tuple = (0, 2, 4)
+__version__ = version = '0.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)

{rtems-proxy-0.2.4 → rtems-proxy-0.3.0}/src/rtems_proxy/copy.py

@@ -14,24 +14,30 @@ def copy_rtems():
     Copy RTEMS binaries to a location where the RTEMS IOC can access them
     """
     # root of pvc mount into which we copy the IOC files for the RTEMS IOC to access
-    root = GLOBALS.RTEMS_ROOT
+    root = GLOBALS.RTEMS_TFTP_PATH
     # root of the path that the RTEMS IOC expects to find the IOC files
-    rtems_root = Path("/iocs") / GLOBALS.IOC_GROUP / GLOBALS.IOC_NAME
+    RTEMS_TFTP_PATH = Path("/iocs") / GLOBALS.IOC_GROUP / GLOBALS.IOC_NAME
     # where to copy the Generic IOC folder to (at present only holds the dbd folder)
-    dest_ioc = root / "ioc"
+    ioc_dest = root / "ioc"
+    # where to copy the generated runtime assets to (st.cmd and ioc.db)
     dest_runtime = root / "runtime"
 
-    # because we are moving the ioc files we need to fix up startup script paths
-    startup = GLOBALS.RUNTIME / "st.cmd"
-    cmd_txt = startup.read_text()
-    cmd_txt = re.sub("/epics/", f"{str(rtems_root)}/", cmd_txt)
-    startup.write_text(cmd_txt)
-
-    # clean up previous IOC binaries
-    shutil.rmtree(dest_ioc, ignore_errors=True)
-    shutil.rmtree(dest_runtime, ignore_errors=True)
     # move all the files needed for runtime into the PVC that is being shared
     # over nfs/tftp by the nfsv2-tftp service
-    Path.mkdir(dest_ioc, exist_ok=True)
-    shutil.copytree(GLOBALS.IOC / "dbd", dest_ioc, symlinks=True, dirs_exist_ok=True)
+    ioc_src = GLOBALS.IOC.readlink()
+    dbd_src = ioc_src / "dbd"
+    dbd_dest = ioc_dest / "dbd"
+    binary = Path("bin/RTEMS-beatnik/ioc.boot")
+    bin_rtems_src = ioc_src / binary
+    bin_rtems_dest = ioc_dest / binary
+    bin_rtems_dest.parent.mkdir(parents=True, exist_ok=True)
+
+    shutil.copytree(dbd_src, dbd_dest, symlinks=True, dirs_exist_ok=True)
+    shutil.copy(bin_rtems_src, bin_rtems_dest)
     shutil.copytree(GLOBALS.RUNTIME, dest_runtime, dirs_exist_ok=True)
+
+    # because we moved the ioc files we need to fix up startup script paths
+    startup = dest_runtime / "st.cmd"
+    cmd_txt = startup.read_text()
+    cmd_txt = re.sub("/epics/", f"{str(RTEMS_TFTP_PATH)}/", cmd_txt)
+    startup.write_text(cmd_txt)

{rtems-proxy-0.2.4 → rtems-proxy-0.3.0}/src/rtems_proxy/globals.py

@@ -32,7 +32,7 @@ class _Globals:
         # TODO in future, shall we drop the RTEMS prefix and make this module
         # generic?
 
-        self.RTEMS_ROOT = Path(os.getenv("RTEMS_ROOT", "/nfsv2-tftp"))
+        self.RTEMS_TFTP_PATH = Path(os.getenv("RTEMS_TFTP_PATH", "/nfsv2-tftp"))
         """ root folder of a mounted PVC in which to place IOC binaries """
 
         self.RTEMS_IOC_IP = os.getenv("RTEMS_IOC_IP")

rtems-proxy-0.3.0/src/rtems_proxy/rsync.sh.jinja

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+{% for name,value in env_vars.items() -%}
+export {{ name }}={{ value }}
+{% endfor -%}
+export IOC_GROUP={{ ioc_group }}
+export IOC_NAME={{ ioc_name }}
+export IOC_PATH={{ ioc_path }}
+
+pkill -f rsync-background &>/dev/null
+
+ibek dev instance $IOC_PATH
+
+mkdir -p $RTEMS_TFTP_PATH
+cd $RTEMS_TFTP_PATH
+
+# get previous contents
+rsync -rt "rsync://$RTEMS_TFTP_IP:12002/files/$IOC_GROUP/$IOC_NAME/" $RTEMS_TFTP_PATH 2>/dev/null
+
+echo "
+#!/bin/bash
+
+while true; do
+  inotifywait -e modify,create,delete,move -r $RTEMS_TFTP_PATH
+  rsync -rt --delete /$RTEMS_TFTP_PATH/ \
+        "rsync://$RTEMS_TFTP_IP:12002/files/$IOC_GROUP/$IOC_NAME/" &> /tmp/rsync.log
+done
+" > /tmp/rsync-background.sh
+
+nohup bash /tmp/rsync-background.sh &> /tmp/rsync-background.log &
+

rtems-proxy-0.3.0/src/rtems_proxy/telnet.py

@@ -0,0 +1,202 @@
+import signal
+import sys
+from enum import Enum
+from time import sleep
+
+import pexpect
+
+from .utils import run_command
+
+
+class CannotConnect(Exception):
+    pass
+
+
+class RtemsState(Enum):
+    MOT = 0
+    IOC = 2
+    UNKNOWN = 3
+
+
+class TelnetRTEMS:
+    """
+    A class for connecting to an RTEMS MVME5500 IOC over telnet.
+
+    properties:
+    _hostname: the hostname of the terminal server connected to the IOC
+    _port: the port of the terminal server connected to the IOC
+    _ioc_reboot: a flag to determine if the IOC should be rebooted
+    _child: the pexpect child object for the initial telnet session
+    """
+
+    MOT_PROMPT = "MVME5500> $"
+    CONTINUE = "<SPC> to Continue"
+    REBOOTED = "TCP Statistics"
+    IOC_STARTED = "iocRun: All initialization complete"
+    IOC_CHECK = "\ntaskwdShow"
+    IOC_RESPONSE = "free nodes"
+    NO_CONNECTION = "Connection closed by foreign host"
+
+    def __init__(self, host_and_port: str, ioc_reboot: bool):
+        self._hostname, self._port = host_and_port.split(":")
+        self._ioc_reboot = ioc_reboot
+        self._child = None
+
+        self.ioc_rebooted = False
+        self.command = f"telnet {self._hostname} {self._port}"
+
+        signal.signal(signal.SIGINT, self.terminate)
+        signal.signal(signal.SIGTERM, self.terminate)
+
+    def report(self, message):
+        """
+        print a message that is noticeable amongst all the other output
+        """
+        print(f"\n>>>> {message} <<<<\n")
+
+    def terminate(self, signum, frame):
+        """
+        Allow the user to terminate the connection with ctrl-c while the
+        pexpect child is running (but not once interactive telnet is started)
+        """
+        self.report("Terminating")
+        exit(0)
+
+    def connect(self):
+        """
+        connect to an IOC over telnet using pexpect and determine if we are
+        at the bootloader or IOC shell. If we are at the bootloader, we will
+        reboot the IOC into the IOC shell, we will also reboot if the ioc_reboot
+        flag was set in the constructor.
+        """
+        self._child = pexpect.spawn(
+            self.command,
+            encoding="utf-8",
+            logfile=sys.stdout,
+            echo=False,
+            codec_errors="ignore",
+        )
+        try:
+            # first check for connection refusal
+            self._child.expect(self.NO_CONNECTION, timeout=1)
+        except pexpect.exceptions.TIMEOUT:
+            # if we timeout looking for failed connection that is good
+            pass
+        else:
+            print(">> Cannot connect to remote IOC, connection in use? <<")
+            raise CannotConnect
+
+    def check_prompt(self, retries=5) -> RtemsState:
+        """
+        Determine if we are currently seeing an IOC shell prompt or
+        bootloader. Because there is a possibility that we are in the middle
+        of a reboot, we will retry for one before giving up.
+        """
+        while retries > 0:
+            try:
+                # see if we are in the IOC shell
+                self._child.sendline(self.IOC_CHECK)
+                self._child.expect(self.IOC_RESPONSE, timeout=1)
+            except pexpect.exceptions.TIMEOUT:
+                try:
+                    # see if we are in the bootloader
+                    self._child.sendline()
+                    self._child.expect(self.MOT_PROMPT, timeout=1)
+                except pexpect.exceptions.TIMEOUT:
+                    # current state unknown. wait and retry
+                    sleep(15)
+                else:
+                    self.report("Currently in bootloader")
+                    return RtemsState.MOT
+            else:
+                self.report("Currently in IOC shell")
+                return RtemsState.IOC
+
+            self.report("Retrying get current status")
+            retries -= 1
+
+        self.report("Current state UNKNOWN")
+        raise CannotConnect("Current state of remote IOC unknown")
+
+    def reboot(self, into: RtemsState):
+        """
+        Reboot the board from IOC shell or bootloader and choose appropriate
+        options to get to the state requested by the into argument.
+        """
+        self.report(f"Rebooting into {into.name}")
+        current_state = self.check_prompt()
+        if current_state == RtemsState.MOT:
+            self._child.sendline("reset")
+        else:
+            self._child.sendline("exit")
+
+        self._child.expect(self.CONTINUE, timeout=10)
+        if into == RtemsState.MOT:
+            # send escape to get into the bootloader
+            self._child.sendline(chr(27))
+        else:
+            # send space to boot the IOC
+            self._child.send(" ")
+
+    def get_epics_prompt(self):
+        """
+        Get to the IOC shell prompt, if the IOC is not already running, reboot
+        it into the IOC shell. If the IOC is running, do a reboot only if
+        requested (in order to pick up new binaries/startup/epics db)
+        """
+        current = self.check_prompt()
+        if current != RtemsState.IOC:
+            sleep(0.2)
+            self._child.reboot(RtemsState.IOC)
+            self.ioc_rebooted = True
+            self._child.expect(self.IOC_STARTED, timeout=50)
+        else:
+            if self._ioc_reboot and not self.ioc_rebooted:
+                self.ioc_rebooted = True
+                self.reboot(RtemsState.IOC)
+                self._child.expect(self.IOC_STARTED, timeout=50)
+
+        self.report("press enter for IOC shell prompt")
+
+    def get_boot_prompt(self):
+        """
+        Get to the bootloader prompt, if the IOC shell is running then exit
+        and send appropriate commands to get to the bootloader
+        """
+        current = self.check_prompt()
+        if current != RtemsState.MOT:
+            # get out of the IOC and return to MOT
+            self.reboot(RtemsState.MOT)
+            self._child.expect(self.MOT_PROMPT, timeout=20)
+
+        self.report("press enter for bootloader prompt")
+
+    def close(self):
+        if self._child:
+            self._child.close()
+            self._child = None
+
+    def __del__(self):
+        self.close()
+
+
+def ioc_connect(host_and_port: str, reboot: bool = False):
+    """
+    Entrypoint to make a connection to an RTEMS IOC over telnet.
+    Once connected, enters an interactive user session with the IOC.
+
+    args:
+    host_and_port: 'hostname:port' of the IOC to connect to
+    reboot: reboot the IOC to pick up new binaries/startup/epics db
+    """
+    telnet = TelnetRTEMS(host_and_port, reboot)
+
+    try:
+        telnet.connect()
+        telnet.get_epics_prompt()
+    except (CannotConnect, pexpect.exceptions.TIMEOUT):
+        print("\n\nNot Connected. Exiting...")
+        telnet.close()
+    else:
+        telnet.close()
+        run_command(telnet.command)

rtems-proxy-0.3.0/src/rtems_proxy/utils.py

@@ -0,0 +1,49 @@
+import subprocess
+from typing import Union
+
+import typer
+
+
+def run_command(
+    command: str, interactive=True, error_OK=False, show=False
+) -> Union[str, bool]:
+    """
+    Run a command and return the output
+
+    if interactive is true then allow stdin and stdout, return the return code,
+    otherwise return True for success and False for failure
+
+    args:
+
+        command: the command to run
+        interactive: if True then allow stdin and stdout
+        error_OK: if True then do not raise an exception on failure
+        show: typer.echo the command output to the console
+    """
+
+    p_result = subprocess.run(command, capture_output=not interactive, shell=True)
+
+    if interactive:
+        output = error_out = ""
+    else:
+        output = p_result.stdout.decode()
+        error_out = p_result.stderr.decode()
+
+    if interactive:
+        result: Union[str, bool] = p_result.returncode == 0
+    else:
+        result = output + error_out
+
+    if p_result.returncode != 0 and not error_OK:
+        typer.echo("\nCommand Failed:")
+        if not globals.EC_VERBOSE:
+            typer.echo(command)
+        typer.echo(output)
+        typer.echo(error_out)
+        raise typer.Exit(1)
+
+    if show:
+        typer.echo(output)
+        typer.echo(error_out)
+
+    return result

{rtems-proxy-0.2.4 → rtems-proxy-0.3.0}/src/rtems_proxy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rtems-proxy
-Version: 0.2.4
+Version: 0.3.0
 Summary: Support for a K8S proxy container in controlling and monitoring RTEMS EPICS IOCs
 Author-email: Giles Knap <giles.knap@diamond.ac.uk>
 License:                                  Apache License
@@ -216,8 +216,11 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: typer
+Requires-Dist: jinja2
+Requires-Dist: pexpect
+Requires-Dist: ruamel.yaml
 Requires-Dist: telnetlib3
+Requires-Dist: typer
 Provides-Extra: dev
 Requires-Dist: copier; extra == "dev"
 Requires-Dist: mypy; extra == "dev"

{rtems-proxy-0.2.4 → rtems-proxy-0.3.0}/src/rtems_proxy.egg-info/SOURCES.txt

@@ -30,7 +30,9 @@ src/rtems_proxy/__main__.py
 src/rtems_proxy/_version.py
 src/rtems_proxy/copy.py
 src/rtems_proxy/globals.py
+src/rtems_proxy/rsync.sh.jinja
 src/rtems_proxy/telnet.py
+src/rtems_proxy/utils.py
 src/rtems_proxy.egg-info/PKG-INFO
 src/rtems_proxy.egg-info/SOURCES.txt
 src/rtems_proxy.egg-info/dependency_links.txt

{rtems-proxy-0.2.4 → rtems-proxy-0.3.0}/src/rtems_proxy.egg-info/requires.txt

@@ -1,5 +1,8 @@
-typer
+jinja2
+pexpect
+ruamel.yaml
 telnetlib3
+typer
 
 [dev]
 copier

rtems-proxy-0.2.4/src/rtems_proxy/__main__.py

@@ -1,71 +0,0 @@
-from time import sleep
-from typing import Optional
-
-import typer
-
-from . import __version__
-from .copy import copy_rtems
-from .globals import GLOBALS
-from .telnet import connect
-
-__all__ = ["main"]
-
-cli = typer.Typer()
-
-
-def version_callback(value: bool):
-    if value:
-        typer.echo(__version__)
-        raise typer.Exit()
-
-
-@cli.callback()
-def main(
-    version: Optional[bool] = typer.Option(
-        None,
-        "--version",
-        callback=version_callback,
-        is_eager=True,
-        help="Print the version of ibek and exit",
-    ),
-):
-    """
-    Proxy for RTEMS IOCs controlling and monitoring
-    """
-
-
-@cli.command()
-def start(
-    copy: bool = typer.Option(
-        True, "--copy/--no-copy", help="copy binaries before connecting"
-    ),
-    reboot: bool = typer.Option(
-        True, "--reboot/--no-reboot", help="reboot the IOC first"
-    ),
-):
-    """
-    Start the RTEMS IOC
-    """
-    print(
-        f"Remote control startup of RTEMS IOC {GLOBALS.IOC_NAME}"
-        f" at {GLOBALS.RTEMS_IOC_IP}"
-    )
-    if copy:
-        copy_rtems()
-    connect(GLOBALS.RTEMS_CONSOLE, reboot=reboot)
-
-    while True:
-        print(f"\n\nIOC {GLOBALS.IOC_NAME} disconnected. Reconnect or exit? [r/e]")
-        choice = ""
-        while choice not in ["r", "e"]:
-            choice = input()
-        if choice == "e":
-            break
-        connect(GLOBALS.RTEMS_CONSOLE)
-        sleep(10)
-
-
-# test with:
-#     pipenv run python -m ibek
-if __name__ == "__main__":
-    cli()

rtems-proxy-0.2.4/src/rtems_proxy/telnet.py

@@ -1,117 +0,0 @@
-import asyncio
-import signal
-import sys
-import termios
-import tty
-from time import sleep
-
-import telnetlib3
-
-
-class TelnetRTEMS:
-    def __init__(self, hostname: str, port: int, reboot: bool, pause: bool):
-        self.hostname = hostname
-        self.port = port
-        self.reboot = reboot
-        self.pause = pause
-        self.running = True
-        self.terminated = False
-        signal.signal(signal.SIGINT, self.terminate)
-        signal.signal(signal.SIGTERM, self.terminate)
-
-    def terminate(self, *args):
-        self.running = False
-        self.terminated = True
-
-    async def user_input(self, writer):
-        def get_char():
-            ch = sys.stdin.read(1)
-            return ch
-
-        stdin_fd = sys.stdin.fileno()
-        old_settings = termios.tcgetattr(stdin_fd)
-
-        try:
-            tty.setraw(sys.stdin.fileno())
-            loop = asyncio.events._get_running_loop()
-
-            while self.running:
-                # run the wait for input in a separate thread
-                next_ch = await loop.run_in_executor(None, get_char)
-                # look for control + ] to terminate the session
-                if b"\x1d" in next_ch.encode():
-                    self.running = False
-                    break
-                writer.write(next_ch)
-
-        finally:
-            termios.tcsetattr(stdin_fd, termios.TCSADRAIN, old_settings)
-            writer.close()
-
-    async def server_output(self, reader):
-        while self.running:
-            out_p = await reader.read(1024)
-            if not out_p:
-                raise EOFError("Connection closed by server")
-            print(out_p, flush=True, end="")
-        reader.close()
-
-    async def shell(self, reader, writer):
-        # user input and server output in separate tasks
-        tasks = [
-            self.server_output(reader),
-            self.user_input(writer),
-        ]
-
-        await asyncio.gather(*tasks)
-
-    async def send_command(self, cmd):
-        reader, writer = await telnetlib3.open_connection(self.hostname, self.port)
-
-        writer.write("\r")
-        await asyncio.sleep(0.1)
-        prompt = await reader.read(1024)
-        print(f"prompt is {prompt.strip()}")
-
-        print(f"Sending command: {cmd}")
-        writer.write(f"{cmd}\r")
-        await asyncio.sleep(0.1)
-        result = await reader.read(1024)
-        print(f"Result is: {result.strip()}")
-
-        reader.close()
-        writer.close()
-
-    async def connect(self):
-        while True:  # retry loop
-            try:
-                if self.reboot:
-                    print("REBOOTING IOC ...")
-                    await self.send_command("exit")
-                    self.reboot = False  # only reboot once
-                elif self.pause:
-                    print("Un-stopping IOC")
-                    await self.send_command("iocRun")
-
-                # start interactive session
-                reader, writer = await telnetlib3.open_connection(
-                    self.hostname, self.port, shell=self.shell
-                )
-                await writer.protocol.waiter_closed
-
-                if self.terminated and self.pause:
-                    print("Stopping IOC")
-                    await self.send_command("iocPause")
-
-                break  # interactive session done so exit retry loop
-
-            except ConnectionResetError:
-                # probably the previous pod is terminating and is still connected
-                print("Waiting for Telnet Port (connection reset), RETRYING ...")
-                sleep(3)
-
-
-def connect(host_and_port: str, reboot: bool = False, pause: bool = False):
-    hostname, port = host_and_port.split(":")
-    telnet = TelnetRTEMS(hostname, int(port), reboot, pause)
-    asyncio.run(telnet.connect())