gnetcli-adapter 2.0.5__tar.gz → 2.2.0__tar.gz

{gnetcli_adapter-2.0.5 → gnetcli_adapter-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gnetcli_adapter
-Version: 2.0.5
+Version: 2.2.0
 Summary: Gnetcli-server adapter for Annet
 Author-email: Aleksandr Balezin <gescheit12@gmail.com>
 Requires-Python: >=3.10
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 License-File: LICENSE
-Requires-Dist: annet>=1.0.0
+Requires-Dist: annet>=2.2.0
 Requires-Dist: gnetclisdk>=1.0.31
 Requires-Dist: pydantic_settings
 Requires-Dist: pydantic

{gnetcli_adapter-2.0.5 → gnetcli_adapter-2.2.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "flit_core.buildapi"
 [project]
 name =  "gnetcli_adapter"
 dependencies = [
-  "annet>=1.0.0",
+  "annet>=2.2.0",
   "gnetclisdk>=1.0.31",
   "pydantic_settings",
   "pydantic"

{gnetcli_adapter-2.0.5 → gnetcli_adapter-2.2.0}/src/gnetcli_adapter/gnetcli_adapter.py

@@ -1,3 +1,5 @@
+import traceback
+
 import asyncio
 import json
 import subprocess
@@ -14,7 +16,11 @@ from annet.rulebook import common
 from annet.connectors import AdapterWithConfig, AdapterWithName
 from typing import Dict, List, Any, Optional, Tuple
 from annet.storage import Device
-from gnetclisdk.client import Credentials, Gnetcli, HostParams, QA, File
+
+from gnetcli_adapter.progress_tracker import (
+    ProgressTracker, ProgressBarTracker, FileProgressTracker, LogProgressTracker, CompositeTracker,
+)
+from gnetclisdk.client import Credentials, Gnetcli, HostParams, QA, File, GnetcliSessionCmd
 from gnetclisdk.exceptions import EOFError
 import gnetclisdk.proto.server_pb2 as pb
 from pydantic import Field, field_validator, FieldValidationInfo
@@ -156,7 +162,7 @@ def run_gnetcli_server(server_path: str, config: str = DEFAULT_GNETCLI_SERVER_CO
     try:
         proc = subprocess.Popen(
             [gnetcli_abs_path, "--conf-file", "-"],
-            stdout=subprocess.PIPE,
+            stdout=subprocess.DEVNULL, # we do not read stdout
             stderr=subprocess.PIPE,
             stdin=subprocess.PIPE,
             bufsize=1,
@@ -182,6 +188,8 @@ def run_gnetcli_server(server_path: str, config: str = DEFAULT_GNETCLI_SERVER_CO
                 else:
                     if data.get("msg") == "init tcp socket":
                         _local_gnetcli_url = data.get("address")
+                    if data.get("msg") == "init unix socket":
+                        _local_gnetcli_url = "unix:" + data.get("path")
                     if data.get("level") == "panic":
                         _logger.error("gnetcli error %s", data)
     _logger.debug("set gnetcli server exit code %s", proc.returncode)
@@ -219,7 +227,7 @@ class GnetcliFetcher(Fetcher, AdapterWithConfig, AdapterWithName):
         return "gnetcli"
 
     @classmethod
-    def with_config(cls, **kwargs: Dict[str, Any]) -> Fetcher:
+    def with_config(cls, **kwargs: Any) -> Fetcher:
         return cls(**kwargs)
 
     async def fetch_packages(self, devices: List[Device], processes: int = 1, max_slots: int = 0):
@@ -333,16 +341,6 @@ def make_api(conf: AppSettings) -> Gnetcli:
     )
     return api
 
-def format_trace(trace: list[pb.CMDTraceItem]) -> str:
-    res:list[str] = []
-    for t in trace:
-        op = "unknown" # TODO: get from pb
-        if t.operation == 2:
-            op = "write"
-        elif t.operation == 3:
-            op = "read"
-        res.append(f"{op}={t.data}")
-    return "\n".join(res)
 
 class GnetcliDeployer(DeployDriver, AdapterWithConfig, AdapterWithName):
     def __init__(
@@ -355,6 +353,7 @@ class GnetcliDeployer(DeployDriver, AdapterWithConfig, AdapterWithName):
         ssh_agent_enabled: bool = True,
         server_path: Optional[str] = None,
         server_conf: Optional[str] = DEFAULT_GNETCLI_SERVER_CONF,
+        logs_dir: Optional[str] = None,
     ):
         conf_args = {
             "login": login,
@@ -368,14 +367,15 @@ class GnetcliDeployer(DeployDriver, AdapterWithConfig, AdapterWithName):
         }
         self.conf = AppSettings(**{k: v for k,v in conf_args.items() if v is not None})
         self.api = make_api(self.conf)
+        self.logs_dir = logs_dir
 
     @classmethod
     def name(cls) -> str:
         return "gnetcli"
 
     @classmethod
-    def with_config(cls, **kwargs: Dict[str, Any]) -> DeployDriver:
-        return GnetcliDeployer(**kwargs)
+    def with_config(cls, **kwargs: Any) -> DeployDriver:
+        return cls(**kwargs)
 
     async def bulk_deploy(self, deploy_cmds: dict[Device, CommandList], args: DeployOptions, progress_bar: ProgressBar | None = None) -> DeployResult:
         if progress_bar:
@@ -387,7 +387,45 @@ class GnetcliDeployer(DeployDriver, AdapterWithConfig, AdapterWithName):
         res.add_results(results={dev.fqdn: dev_res for (dev, _), dev_res in zip(deploy_items, result)})
         return res
 
-    async def deploy(self, device: Device, cmds: CommandList, args: DeployOptions, progress_bar: ProgressBar | None = None) -> tuple[list[Exception], list[pb.CMDResult]]:
+    def _get_files(self, cmds: dict[str, Any]) -> dict[str, File]:
+        return {
+            file: File(content=content, status=None)
+            for file, content in cmds["files"].items()
+        }
+
+    def _get_reload_cmds(self, cmds: dict[str, Any]):
+        reload_cmds: dict[str, CommandList] = {}
+        for file, cmd in cmds["cmds"].items():
+            if isinstance(cmd, bytes):
+                cmd = cmd.decode()
+            reload_cmds[file] = CommandList([Command(cmd, suppress_nonzero=True) for cmd in cmd.splitlines()])
+        return reload_cmds
+
+    def _get_total(
+            self, command_groups: list[tuple[str, CommandList]], files: dict[str, File],
+    ) -> int:
+        run_cmds = 0
+        for _, cmds in command_groups:
+            run_cmds += len(cmds)
+        if files:
+            run_cmds += 1
+        return run_cmds
+
+    def _init_progress_tracker(self, device: Device, progress_bar: ProgressBar | None) -> ProgressTracker:
+        tracker = CompositeTracker(LogProgressTracker(device))
+        if progress_bar:
+            tracker.add_tracker(ProgressBarTracker(device, progress_bar))
+        if self.logs_dir:
+            tracker.add_tracker(FileProgressTracker(device, self.logs_dir))
+        return tracker
+
+    async def deploy(
+            self,
+            device: Device,
+            cmds: CommandList,
+            args: DeployOptions,
+            progress_bar: ProgressBar | None = None,
+    ) -> tuple[list[Exception], list[pb.CMDResult]]:
         gnetcli_device = breed_to_device.get(device.breed, device.breed)
         ip = get_device_ip(device)
         host_params = HostParams(
@@ -395,85 +433,95 @@ class GnetcliDeployer(DeployDriver, AdapterWithConfig, AdapterWithName):
             device=gnetcli_device,
             ip=ip,
         )
-        do_reload: bool = args.entire_reload.value == "yes"
-        seen_exc: list[Exception] = []
-        reload_cmds: dict[str, CommandList] = {}
-        total_cmds = 0
+        command_groups: list[tuple[str, CommandList]]= []
         if isinstance(cmds, dict): # PC
-            for file, cmd in cmds["cmds"].items():
-                if isinstance(cmd, bytes):
-                    cmd = cmd.decode()
-                reload_cmds[file] = CommandList([Command(cmd, suppress_nonzero=True) for cmd in cmd.splitlines()])
-                total_cmds += len(reload_cmds[file])
-            run_cmds = CommandList()
-            files: Dict[str, File] = {file: File(content=content, status=None) for file, content in cmds["files"].items()}
-            await self.api.upload(hostname=device.fqdn, files=files, host_params=host_params)
+            files = self._get_files(cmds)
+            if args.entire_reload.value == "yes":
+                for file, cmdlist in self._get_reload_cmds(cmds).items():
+                    command_groups.append((f"Reload {file}", cmdlist))
         else:
-            total_cmds = len(cmds)
-            run_cmds = cmds
-
-        done_cmds = 0
-        async with self.api.cmd_session(hostname=device.fqdn) as sess:
-            result: List[pb.CMDResult] = []
-            for cmd in run_cmds:
-                if progress_bar:
-                    progress_bar.set_progress(device.fqdn, done_cmds, total_cmds, suffix=cmd.cmd)
-                try:
-                    res = await sess.cmd(
-                        cmd=cmd.cmd,
-                        cmd_timeout=cmd.timeout,
-                        host_params=host_params,
-                        qa=parse_annet_qa(cmd.questions or []),
-                        trace=True,
-                    )
-                except EOFError as e:
-                    if cmd.suppress_eof:
-                        if progress_bar:
-                            progress_bar.set_progress(device.fqdn, total_cmds, total_cmds, suffix=f"suppressed EOF: {cmd.cmd}")
-                        break  # we can't exec subsequent cmds
-                    raise e
-                if progress_bar:
-                    tr = format_trace(res.trace)
-                    progress_bar.set_content(device.fqdn, f"cmd={cmd.cmd} out={res.out_str} status={res.status}\n{tr}")
-                done_cmds += 1
-                if res.status != 0:
-                    if cmd.suppress_nonzero:
-                        continue
-                    if progress_bar:
-                        progress_bar.set_exception(device.fqdn, cmd.cmd, str(res.error), total_cmds)
-                    raise Exception("cmd %s error %s status %s", cmd, res.error, res.status)
-                result.append(res)
-                if progress_bar:
-                    progress_bar.set_progress(device.fqdn, done_cmds, total_cmds)
-            if do_reload:
-                for file, cmds in reload_cmds.items():
-                    _logger.debug("reload %s %s", file, cmds)
-                    for cmd in cmds:
-                        if progress_bar:
-                            progress_bar.set_progress(device.fqdn, done_cmds, total_cmds, suffix=f"{file}:{cmd.cmd}")
-                        res = await sess.cmd(
+            files = {}
+            # treat each command as a group
+            for cmd in cmds:
+                command_groups.append(("Run command", CommandList([cmd])))
+
+        with self._init_progress_tracker(device, progress_bar) as tracker:
+            tracker.set_total(self._get_total(command_groups, files))
+            try:
+                seen_exc, results = await self._deploy(
+                    device=device,
+                    host_params=host_params,
+                    command_groups=command_groups,
+                    tracker=tracker,
+                    files=files,
+                )
+            except Exception as e:
+                trace = traceback.format_exc()
+                tracker.command_done_error(trace)
+                seen_exc = [e]
+                results = []
+            if seen_exc:
+                tracker.finish_err(f"Seen {len(seen_exc)} exceptions")
+            else:
+                tracker.finish_ok("All done")
+            return seen_exc, results
+
+    async def _deploy(
+            self,
+            device: Device,
+            host_params: HostParams,
+            command_groups: list[tuple[str, CommandList]],
+            files: dict[str, File],
+            tracker: ProgressTracker,
+    ) -> tuple[list[Exception], list[pb.CMDResult]]:
+        seen_exc = []
+        results = []
+        if files:
+            tracker.upload_files(list(files))
+            await self.api.upload(hostname=device.fqdn, files=files, host_params=host_params)
+            tracker.files_uploaded()
+
+        old_group_name = ""
+        async with self.api.cmd_session(hostname=device.fqdn) as session:
+            for group_number, (group_name, cmdlist) in enumerate(command_groups):
+                if group_name != old_group_name:
+                    tracker.start_group(group_name)
+                    old_group_name = group_name
+                for cmd_number, cmd in enumerate(cmdlist):
+                    tracker.run_command(cmd.cmd)
+                    try:
+                        res = await session.cmd(
                             cmd=cmd.cmd,
                             cmd_timeout=cmd.timeout,
                             host_params=host_params,
                             qa=parse_annet_qa(cmd.questions or []),
+                            trace=True,
                         )
-                        done_cmds += 1
-                        if progress_bar:
-                            progress_bar.set_content(device.fqdn, f"cmd={cmd.cmd} out={res.out_str} status={res.status}")
-                        if res.status != 0 and cmd.suppress_nonzero:
-                            if progress_bar:
-                                progress_bar.set_exception(device.fqdn, cmd.cmd, str(res.error), total_cmds)
-                            if cmd.suppress_nonzero:
-                                done_cmds += 1
-                                seen_exc.append(Exception("cmd %s error %s status %s", cmd, res.error, res.status))
-                                break # break on command for current file
-                            raise Exception("cmd %s error %s status %s", cmd, res.error, res.status)
-                        result.append(res)
-                if reload_cmds and progress_bar:
-                    progress_bar.set_progress(device.fqdn, total_cmds, total_cmds)
-            if seen_exc and progress_bar:
-                progress_bar.set_exception(device.fqdn, "seen exception", str(seen_exc), total_cmds)
-            return seen_exc, result
+                    except EOFError as e:
+                        # we can't execute subsequent commands
+                        if cmd.suppress_eof:
+                            # some commands left
+                            if group_number + 1  != len(command_groups) or cmd_number + 1 != len(cmd):
+                                tracker.command_done_error("EOF detected before all commands executed.")
+                                seen_exc.append(Exception("EOF detected before all commands executed."))
+                            tracker.command_done_error("Suppressed EOF")
+                            return seen_exc, results
+                        seen_exc.append(e)
+                        tracker.command_done_error("Unexpected EOFError")
+                        return seen_exc, results
+                    if res.status == 0:
+                        tracker.command_done_ok(res)
+                        results.append(res)
+                    else:
+                        e = Exception("cmd %s error %s status %s", cmd, res.error, res.status)
+                        seen_exc.append(e)
+                        if cmd.suppress_nonzero:
+                            tracker.command_done_ok(res)
+                            break  # go to next command group
+                        else:
+                            tracker.command_done_error(res.error.decode())
+                            return seen_exc, results
+        return seen_exc, results
 
     def apply_deploy_rulebook(
         self,

gnetcli_adapter-2.2.0/src/gnetcli_adapter/progress_tracker.py

@@ -0,0 +1,296 @@
+import os.path
+from logging import getLogger
+
+import os
+from contextlib import ExitStack
+from datetime import datetime
+from typing import TextIO
+
+import gnetclisdk.proto.server_pb2 as pb
+from annet.deploy import ProgressBar
+from annet.storage import Device
+
+logger = getLogger(__name__)
+
+
+class ProgressTracker:
+    def __enter__(self) -> "ProgressTracker":
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    def start_group(self, group_name: str) -> None:
+        pass
+
+    def set_total(self, total: int) -> None:
+        pass
+
+    def upload_files(self, files: list[str]) -> None:
+        pass
+
+    def files_uploaded(self) -> None:
+        pass
+
+    def run_command(self, cmd: str) -> None:
+        pass
+
+    def run_reload_command(self, file: str, cmd: str):
+        pass
+
+    def command_done_ok(self, output: pb.CMDResult) -> None:
+        pass
+
+    def command_done_error(self, error: str) -> None:
+        pass
+
+    def finish_ok(self, notification: str) -> None:
+        pass
+
+    def finish_err(self, notification: str) -> None:
+        pass
+
+
+def format_trace(trace: list[pb.CMDTraceItem]) -> str:
+    res: list[str] = []
+    for t in trace:
+        op = "unknown"  # TODO: get from pb
+        if t.operation == 2:
+            op = "write"
+        elif t.operation == 3:
+            op = "read"
+        res.append(f"{op}={t.data}")
+    return "\n".join(res)
+
+
+def _render_cmd_res(res: pb.CMDResult) -> str:
+    if res.trace:
+        trace_str = "\n" + format_trace(res.trace)
+    else:
+        trace_str = ""
+    try:
+        error_str = res.error.decode("utf-8")
+    except UnicodeDecodeError:
+        error_str = str(res.error)
+    if error_str:
+        error_str = "\n" + error_str
+    return f"out: {res.out_str}\nstatus: {res.status}{error_str}{trace_str}"
+
+
+class ProgressBarTracker(ProgressTracker):
+    def __init__(self, device: Device, progress_bar: ProgressBar) -> None:
+        self.progress_bar = progress_bar
+        self.tile = device.fqdn
+        self.total_steps = 0
+        self.done_steps = 0
+        self.last_cmd = ""
+
+    def set_total(self, total: int) -> None:
+        self.total_steps = total
+
+    def start_group(self, group_name: str) -> None:
+        self.progress_bar.add_content(self.tile, f"=== {group_name} ===")
+
+    def upload_files(self, files: list[str]) -> None:
+        filelist = "".join(f"- {f}\n" for f in files)
+        self.progress_bar.add_content(self.tile, f"=== Uploading files ===\n{filelist}")
+
+    def files_uploaded(self) -> None:
+        self.done_steps += 1
+        self.progress_bar.add_content(self.tile, f"=== Files uploaded ===\n")
+        self.progress_bar.set_progress(self.tile, self.done_steps, self.total_steps)
+
+    def run_command(self, cmd: str):
+        self.progress_bar.add_content(self.tile, f"cmd: {cmd}")
+        self.progress_bar.set_progress(
+            self.tile,
+            self.done_steps,
+            self.total_steps,
+            cmd,
+        )
+
+    def run_reload_command(self, file: str, cmd: str):
+        self.last_cmd = cmd
+        self.progress_bar.add_content(self.tile, f"{file}: {cmd}")
+        self.progress_bar.set_progress(self.tile, self.done_steps, self.total_steps, suffix=cmd)
+
+    def command_done_ok(self, output: pb.CMDResult) -> None:
+        self.done_steps += 1
+        output_str = _render_cmd_res(output)
+        self.progress_bar.add_content(self.tile, output_str)
+        self.progress_bar.set_progress(
+            self.tile,
+            self.done_steps,
+            self.total_steps,
+            "Ok: " + self.last_cmd,
+        )
+
+    def command_done_error(self, error: str) -> None:
+        logger.error(error)
+        self.done_steps += 1
+        self.progress_bar.add_content(self.tile, error)
+        self.progress_bar.set_progress(
+            self.tile,
+            self.done_steps,
+            self.total_steps,
+            "Error: " + self.last_cmd,
+        )
+
+    def finish_ok(self, notification: str) -> None:
+        self.done_steps = self.total_steps
+        self.progress_bar.set_progress(self.tile,self.done_steps, self.total_steps, suffix=notification)
+
+    def finish_err(self, notification: str) -> None:
+        self.done_steps = self.total_steps
+        self.progress_bar.set_exception(self.tile, notification, "", self.total_steps)
+
+
+class FileProgressTracker(ProgressTracker):
+    def __init__(self, device: Device, dirname: str):
+        self.dirname = dirname
+        self.device = device
+        self.file: TextIO | None = None
+
+    def __enter__(self) -> ProgressTracker:
+        filepath = self._make_file_path()
+        os.makedirs(os.path.dirname(filepath), exist_ok=True)
+        logger.info("Writing deploy logs to file: %s", filepath)
+        self.file = open(filepath, "a")
+        return self
+
+    def _make_file_path(self) -> str:
+        now = datetime.now()
+        datedir = f"{now:%Y-%m-%d-%H-%M}"
+        return os.path.join(
+            self.dirname,
+            datedir,
+            f"{self.device.fqdn}_{now.timestamp():.0f}",
+        )
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.file.close()
+
+    def _log(self, msg: str) -> None:
+        self.file.write(f"{datetime.now()}: {msg}\n")
+
+    def start_group(self, group_name: str) -> None:
+        self._log(f"=== {group_name} ===")
+
+    def set_total(self, total: int) -> None:
+        pass
+
+    def upload_files(self, files: list[str]) -> None:
+        filelist = "\n".join(f"- {f}" for f in files)
+        self._log(f"=== Uploading files ===\n{filelist}")
+
+    def files_uploaded(self) -> None:
+        self._log(f"=== Files uploaded ===")
+
+    def run_command(self, cmd: str) -> None:
+        self._log(f"cmd: {cmd}")
+
+    def run_reload_command(self, file: str, cmd: str):
+        self._log(f"file: {cmd}")
+
+    def command_done_ok(self, output: pb.CMDResult) -> None:
+        output_str = _render_cmd_res(output)
+        self._log(output_str)
+
+    def command_done_error(self, error: str) -> None:
+        self._log(f"Error: {error}")
+
+    def finish_ok(self, notification: str) -> None:
+        self._log("Finished with success: " + notification)
+
+    def finish_err(self, notification: str) -> None:
+        self._log("Finished with failure: " + notification)
+
+
+
+class LogProgressTracker(ProgressTracker):
+    def __init__(self, device: Device):
+        self.fqdn = device.fqdn
+
+    def __enter__(self) -> ProgressTracker:
+        return self
+
+    def start_group(self, group_name: str) -> None:
+        logger.info(f"{self.fqdn} - {group_name}")
+
+    def upload_files(self, files: list[str]) -> None:
+        logger.info(f"{self.fqdn} - upload %s files", len(files))
+
+    def command_done_ok(self, output: pb.CMDResult) -> None:
+        if output.error:
+            try:
+                error = output.error.decode("utf-8")
+            except UnicodeDecodeError:
+                error = str(output.error)
+            logger.warning(f"{self.fqdn} - {error}")
+
+    def command_done_error(self, error: str) -> None:
+        logger.error(f"{self.fqdn} - {error}")
+
+    def finish_ok(self, notification: str) -> None:
+        logger.info(f"{self.fqdn} - finished with success - {notification}")
+
+    def finish_err(self, notification: str) -> None:
+        logger.info(f"{self.fqdn} - finished with failure - {notification}")
+
+
+
+class CompositeTracker(ProgressTracker):
+    def __init__(self, *trackers: ProgressTracker) -> None:
+        self.trackers = list(trackers)
+        self.stack = ExitStack()
+
+    def __enter__(self):
+        for tracker in self.trackers:
+            self.stack.enter_context(tracker)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stack.close()
+
+    def add_tracker(self, tracker: ProgressTracker) -> None:
+        self.trackers.append(tracker)
+
+    def start_group(self, group_name: str) -> None:
+        for tracker in self.trackers:
+            tracker.start_group(group_name)
+
+    def set_total(self, total: int) -> None:
+        for tracker in self.trackers:
+            tracker.set_total(total)
+
+    def upload_files(self, files: list[str]) -> None:
+        for tracker in self.trackers:
+            tracker.upload_files(files)
+
+    def files_uploaded(self) -> None:
+        for tracker in self.trackers:
+            tracker.files_uploaded()
+
+    def run_command(self, cmd: str) -> None:
+        for tracker in self.trackers:
+            tracker.run_command(cmd)
+
+    def run_reload_command(self, file: str, cmd: str):
+        for tracker in self.trackers:
+            tracker.run_reload_command(file, cmd)
+
+    def command_done_ok(self, output: pb.CMDResult) -> None:
+        for tracker in self.trackers:
+            tracker.command_done_ok(output)
+
+    def command_done_error(self, error: str) -> None:
+        for tracker in self.trackers:
+            tracker.command_done_error(error)
+
+    def finish_ok(self, notification: str) -> None:
+        for tracker in self.trackers:
+            tracker.finish_ok(notification)
+
+    def finish_err(self, notification: str) -> None:
+        for tracker in self.trackers:
+            tracker.finish_err(notification)