cyclo-manager 0.2.0.dev4__tar.gz → 0.2.0.dev6__tar.gz

{cyclo_manager-0.2.0.dev4 → cyclo_manager-0.2.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cyclo-manager
-Version: 0.2.0.dev4
+Version: 0.2.0.dev6
 Summary: cyclo_manager CLI: pip-installable launcher for cyclo_manager server and UI containers. Run 'cyclo_manager up' to start Docker stack.
 License-Expression: Apache-2.0
 Requires-Python: >=3.10

cyclo_manager-0.2.0.dev6/cyclo_host_agent/routers/update.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+#
+# Copyright 2026 ROBOTIS CO., LTD.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Author: Hyungyu Kim
+
+"""System-level endpoints for the host agent."""
+
+import asyncio
+import logging
+import shutil
+import time
+import subprocess
+
+from fastapi import APIRouter, HTTPException, status
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix='/system', tags=['system'])
+
+_update_status: dict = {'phase': 'idle', 'output': '', 'error': ''}
+
+
+async def _run_update(cyclo_exe: str) -> None:
+    global _update_status
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            cyclo_exe, 'update',
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=600)
+        out = (stdout.decode() + stderr.decode()).strip()
+        _update_status['output'] = out
+        if proc.returncode != 0:
+            _update_status['phase'] = 'error'
+            _update_status['error'] = f'cyclo_manager update failed (exit {proc.returncode})'
+        else:
+            _update_status['phase'] = 'done'
+    except asyncio.TimeoutError:
+        _update_status['phase'] = 'error'
+        _update_status['error'] = 'cyclo_manager update timed out'
+
+
+@router.post('/update')
+async def start_update() -> dict:
+    """Delegate update to cyclo_manager update, which handles containers and host agent restart."""
+    global _update_status
+
+    cyclo_exe = shutil.which('cyclo_manager')
+    if not cyclo_exe:
+        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                            detail='cyclo_manager command not found')
+
+    _update_status = {'phase': 'updating', 'output': '', 'error': ''}
+    asyncio.create_task(_run_update(cyclo_exe))
+    return {'status': 'update started'}
+
+
+@router.get('/update/status')
+async def get_update_status() -> dict:
+    """Return the current update phase and stored outputs."""
+    return _update_status
+
+
+def _delayed_exec(cmd: list[str], delay: float = 2.0) -> None:
+    time.sleep(delay)
+    subprocess.run(cmd, check=False)
+
+
+@router.post('/reboot')
+async def reboot_host() -> dict:
+    """Reboot the host machine after returning a response."""
+    loop = asyncio.get_event_loop()
+    loop.run_in_executor(None, _delayed_exec, ['sudo', 'reboot'])
+    return {'status': 'rebooting'}
+
+
+@router.post('/shutdown')
+async def shutdown_host() -> dict:
+    """Shut down the host machine after returning a response."""
+    loop = asyncio.get_event_loop()
+    loop.run_in_executor(None, _delayed_exec, ['sudo', 'poweroff'])
+    return {'status': 'shutting_down'}

{cyclo_manager-0.2.0.dev4 → cyclo_manager-0.2.0.dev6}/cyclo_manager.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cyclo-manager
-Version: 0.2.0.dev4
+Version: 0.2.0.dev6
 Summary: cyclo_manager CLI: pip-installable launcher for cyclo_manager server and UI containers. Run 'cyclo_manager up' to start Docker stack.
 License-Expression: Apache-2.0
 Requires-Python: >=3.10

{cyclo_manager-0.2.0.dev4 → cyclo_manager-0.2.0.dev6}/cyclo_manager_cli/cli.py

@@ -103,6 +103,35 @@ def _setup_socket_dir(user: str) -> bool:
         return False
 
 
+def _install_sudoers(user: str) -> bool:
+    """
+    Write /etc/sudoers.d/cyclo_manager granting NOPASSWD for udev operations
+    needed by container.sh (cp to /etc/udev/rules.d/, udevadm control/trigger).
+    """
+    sudoers_content = (
+        f'{user} ALL=(ALL) NOPASSWD: /usr/bin/cp, '
+        f'/usr/bin/udevadm control --reload-rules, '
+        f'/usr/bin/udevadm trigger\n'
+    )
+    sudoers_file = '/etc/sudoers.d/cyclo_manager'
+    try:
+        subprocess.run(
+            ['sudo', 'tee', sudoers_file],
+            input=sudoers_content.encode(),
+            capture_output=True,
+            check=True,
+        )
+        subprocess.run(
+            ['sudo', 'chmod', '440', sudoers_file],
+            check=True,
+            capture_output=True,
+        )
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f'Failed to install sudoers file: {e}', file=sys.stderr)
+        return False
+
+
 def _ensure_host_agent() -> int:
     """
     Install or refresh cyclo_host_agent: systemd unit, socket dir, and service start.
@@ -127,6 +156,9 @@ def _ensure_host_agent() -> int:
     if not _setup_socket_dir(user):
         return 1
 
+    if not _install_sudoers(user):
+        return 1
+
     service_content = f"""\
 [Unit]
 Description=Cyclo Host Agent
@@ -208,8 +240,27 @@ def cmd_up(args: argparse.Namespace) -> int:
     return 0
 
 
+def _teardown_host_agent() -> None:
+    """Stop and remove the host agent service, unit file, sudoers, and socket dir."""
+    steps = [
+        (['sudo', 'systemctl', 'stop', f'{HOST_AGENT_SERVICE}.service'], 'stop service'),
+        (['sudo', 'systemctl', 'disable', f'{HOST_AGENT_SERVICE}.service'], 'disable service'),
+        (['sudo', 'rm', '-f', f'/etc/systemd/system/{HOST_AGENT_SERVICE}.service'], 'remove unit file'),
+        (['sudo', 'systemctl', 'daemon-reload'], 'reload systemd'),
+        (['sudo', 'rm', '-f', '/etc/sudoers.d/cyclo_manager'], 'remove sudoers'),
+        (['sudo', 'rm', '-rf', HOST_AGENT_SOCKET_DIR], 'remove socket dir'),
+    ]
+    for cmd, desc in steps:
+        try:
+            subprocess.run(cmd, check=True, capture_output=True)
+        except subprocess.CalledProcessError:
+            print(f'Warning: failed to {desc}.', file=sys.stderr)
+
+
 def cmd_down(args: argparse.Namespace) -> int:
     """Stop cyclo_manager server, cyclo_manager_ui, and zenoh daemon (docker compose down)."""
+    _teardown_host_agent()
+
     compose_path = _docker_dir() / 'docker-compose.yml'
     if not compose_path.is_file():
         print(f'Compose file not found: {compose_path}', file=sys.stderr)
@@ -239,29 +290,32 @@ def cmd_down(args: argparse.Namespace) -> int:
 
 
 def cmd_update(args: argparse.Namespace) -> int:
-    """Down containers, pip install -U cyclo-manager, then up again."""
-    cyclo_manager_exe = shutil.which('cyclo_manager')
-    if not cyclo_manager_exe:
-        print('cyclo_manager command not found in PATH.', file=sys.stderr)
-        return 1
+    """Bring containers down, pip install -U, bring containers back up, restart host agent."""
     pip_exe = shutil.which('pip3') or shutil.which('pip')
     if not pip_exe:
         print('pip not found; cannot update package.', file=sys.stderr)
         return 1
 
-    print('Stopping containers (cyclo_manager down)...')
+    compose_path = _docker_dir() / 'docker-compose.yml'
+    if not compose_path.is_file():
+        print(f'Compose file not found: {compose_path}', file=sys.stderr)
+        return 1
+    env = os.environ.copy()
+    env['CYCLO_MANAGER_CONFIG_FILE'] = str(_packaged_config_path())
+    base = ['docker', 'compose', '-f', str(compose_path)]
+
+    print('Stopping containers...')
     try:
-        subprocess.run([cyclo_manager_exe, 'down'], check=True)
+        subprocess.run([*base, 'down'], env=env, check=True)
     except subprocess.CalledProcessError as e:
         return e.returncode
+    except FileNotFoundError:
+        print('Docker not found.', file=sys.stderr)
+        return 1
 
     print(f'Updating {PYPI_PACKAGE} (pip install -U)...')
     try:
-        subprocess.run(
-            [pip_exe, 'install', '-U', PYPI_PACKAGE],
-            check=True,
-            timeout=120,
-        )
+        subprocess.run([pip_exe, 'install', '-U', PYPI_PACKAGE], check=True, timeout=120)
     except subprocess.CalledProcessError as e:
         print(f'pip install -U {PYPI_PACKAGE} failed.', file=sys.stderr)
         return e.returncode
@@ -269,15 +323,28 @@ def cmd_update(args: argparse.Namespace) -> int:
         print('pip install timed out.', file=sys.stderr)
         return 1
 
-    print('Starting containers (cyclo_manager up)...')
-    up_args = [cyclo_manager_exe, 'up']
-    if getattr(args, 'pull', False):
-        up_args.append('--pull')
+    print('Starting containers...')
     try:
-        subprocess.run(up_args, check=True)
+        if getattr(args, 'pull', False):
+            subprocess.run([*base, 'pull'], env=env, check=True)
+        subprocess.run([*base, 'up', '-d', *COMPOSE_SERVICES_UP], env=env, check=True)
+        subprocess.run(
+            [*base, 'create', '--no-recreate', *COMPOSE_SERVICES_CREATE_ONLY],
+            env=env,
+            check=True,
+        )
     except subprocess.CalledProcessError as e:
         return e.returncode
 
+    print('Restarting host agent...')
+    try:
+        subprocess.run(
+            ['sudo', 'systemctl', 'restart', f'{HOST_AGENT_SERVICE}.service'],
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        print(f'Warning: failed to restart host agent: {e}', file=sys.stderr)
+
     print('cyclo_manager update completed.')
     return 0
 

{cyclo_manager-0.2.0.dev4 → cyclo_manager-0.2.0.dev6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cyclo-manager"
-version = "0.2.0.dev4"
+version = "0.2.0.dev6"
 description = "cyclo_manager CLI: pip-installable launcher for cyclo_manager server and UI containers. Run 'cyclo_manager up' to start Docker stack."
 readme = "README.md"
 license = "Apache-2.0"

cyclo_manager-0.2.0.dev4/cyclo_host_agent/routers/update.py

@@ -1,175 +0,0 @@
-#!/usr/bin/env python3
-#
-# Copyright 2026 ROBOTIS CO., LTD.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# Author: Hyungyu Kim
-
-"""System-level endpoints for the host agent."""
-
-import asyncio
-import logging
-import shutil
-import subprocess
-import time
-from typing import Optional
-
-from fastapi import APIRouter, HTTPException, status
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix='/system', tags=['system'])
-
-PYPI_PACKAGE = 'cyclo-manager'
-HOST_AGENT_SERVICE = 'cyclo_host_agent'
-
-# Stored result of the last update (survives across the server restart window)
-_update_status: dict = {'phase': 'idle', 'install_output': '', 'up_output': '', 'error': ''}
-
-
-def _fmt(cmd: str, out: str) -> str:
-    return f'$ {cmd}\n{out.strip()}' if out.strip() else f'$ {cmd}'
-
-
-def _restart_self() -> None:
-    """Restart the host agent after a short delay so new binary takes effect."""
-    time.sleep(2)
-    try:
-        subprocess.run(
-            ['sudo', 'systemctl', 'restart', f'{HOST_AGENT_SERVICE}.service'],
-            check=True,
-        )
-    except Exception as e:
-        logger.error('Failed to restart host agent: %s', e)
-
-
-async def _run_install_and_up(cyclo_exe: str, pip_exe: str) -> None:
-    """Run pip install -U and cyclo up in background; store results in _update_status."""
-    global _update_status
-
-    # pip install -U
-    _update_status['phase'] = 'installing'
-    try:
-        proc = await asyncio.create_subprocess_exec(
-            pip_exe, 'install', '-U', PYPI_PACKAGE,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=120)
-        out = (stdout.decode() + stderr.decode()).strip()
-        _update_status['install_output'] = _fmt(f'pip install -U {PYPI_PACKAGE}', out)
-        if proc.returncode != 0:
-            _update_status['phase'] = 'error'
-            _update_status['error'] = f'pip install failed (exit {proc.returncode})'
-            return
-    except asyncio.TimeoutError:
-        _update_status['phase'] = 'error'
-        _update_status['error'] = 'pip install timed out'
-        return
-
-    # cyclo up
-    _update_status['phase'] = 'starting'
-    try:
-        proc = await asyncio.create_subprocess_exec(
-            cyclo_exe, 'up',
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=300)
-        out = (stdout.decode() + stderr.decode()).strip()
-        _update_status['up_output'] = _fmt('cyclo_manager up', out)
-        if proc.returncode != 0:
-            _update_status['phase'] = 'error'
-            _update_status['error'] = f'cyclo_manager up failed (exit {proc.returncode})'
-            return
-    except asyncio.TimeoutError:
-        _update_status['phase'] = 'error'
-        _update_status['error'] = 'cyclo_manager up timed out'
-        return
-
-    _update_status['phase'] = 'done'
-
-    # Restart self so new binary takes effect
-    loop = asyncio.get_event_loop()
-    await loop.run_in_executor(None, _restart_self)
-
-
-@router.post('/update')
-async def start_update() -> dict:
-    """
-    Run cyclo down synchronously, then pip install + cyclo up in background.
-
-    Returns cyclo down output immediately. The server goes down during this call;
-    the host agent continues the remaining steps and stores results for /system/update/status.
-    """
-    global _update_status
-
-    cyclo_exe = shutil.which('cyclo_manager')
-    pip_exe = shutil.which('pip3') or shutil.which('pip')
-
-    if not cyclo_exe:
-        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-                            detail='cyclo_manager command not found')
-    if not pip_exe:
-        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-                            detail='pip not found')
-
-    _update_status = {'phase': 'stopping', 'install_output': '', 'up_output': '', 'error': ''}
-
-    # cyclo down (synchronous — server goes down here)
-    down_output = ''
-    try:
-        proc = await asyncio.create_subprocess_exec(
-            cyclo_exe, 'down',
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=30)
-        down_output = _fmt('cyclo_manager down', (stdout.decode() + stderr.decode()))
-    except asyncio.TimeoutError:
-        down_output = '$ cyclo_manager down\n(timed out)'
-    except Exception as e:
-        down_output = f'$ cyclo_manager down\n(error: {e})'
-
-    # Continue install + up in background
-    asyncio.create_task(_run_install_and_up(cyclo_exe, pip_exe))
-
-    return {'down_output': down_output}
-
-
-@router.get('/update/status')
-async def get_update_status() -> dict:
-    """Return the current update phase and stored outputs."""
-    return _update_status
-
-
-def _delayed_exec(cmd: list[str], delay: float = 2.0) -> None:
-    time.sleep(delay)
-    subprocess.run(cmd, check=False)
-
-
-@router.post('/reboot')
-async def reboot_host() -> dict:
-    """Reboot the host machine after returning a response."""
-    loop = asyncio.get_event_loop()
-    loop.run_in_executor(None, _delayed_exec, ['sudo', 'reboot'])
-    return {'status': 'rebooting'}
-
-
-@router.post('/shutdown')
-async def shutdown_host() -> dict:
-    """Shut down the host machine after returning a response."""
-    loop = asyncio.get_event_loop()
-    loop.run_in_executor(None, _delayed_exec, ['sudo', 'poweroff'])
-    return {'status': 'shutting_down'}