olas-operate-middleware 0.8.2__py3-none-any.whl → 0.10.0__py3-none-any.whl

operate/quickstart/run_service.py

@@ -34,10 +34,10 @@ from halo import Halo  # type: ignore[import]
 from web3.exceptions import Web3Exception
 
 from operate.account.user import UserAccount
-from operate.constants import IPFS_ADDRESS, OPERATE_HOME
+from operate.constants import IPFS_ADDRESS, NO_STAKING_PROGRAM_ID, OPERATE_HOME
 from operate.data import DATA_DIR
 from operate.data.contracts.staking_token.contract import StakingTokenContract
-from operate.ledger.profiles import NO_STAKING_PROGRAM_ID, STAKING, get_staking_contract
+from operate.ledger.profiles import STAKING, get_staking_contract
 from operate.operate_types import (
     Chain,
     LedgerType,
@@ -100,7 +100,7 @@ QS_STAKING_PROGRAMS: t.Dict[Chain, t.Dict[str, str]] = {
         "mech_marketplace": "mech",
         "marketplace_supply_alpha": "mech",
     },
-    Chain.OPTIMISTIC: {
+    Chain.OPTIMISM: {
         "optimus_alpha_2": "optimus",
         "optimus_alpha_3": "optimus",
         "optimus_alpha_4": "optimus",
@@ -363,14 +363,12 @@ def configure_local_config(
             template["configurations"][chain] |= {
                 "staking_program_id": config.staking_program_id,
                 "rpc": config.rpc[chain],
-                "use_staking": config.staking_program_id != NO_STAKING_PROGRAM_ID,
                 "cost_of_bond": min_staking_deposit,
             }
         else:
             template["configurations"][chain] |= {
                 "staking_program_id": NO_STAKING_PROGRAM_ID,
                 "rpc": config.rpc[chain],
-                "use_staking": False,
                 "cost_of_bond": 1,
             }
 
@@ -414,7 +412,7 @@ def configure_local_config(
 
             if env_var_name not in config.user_provided_args:
                 print(f"Description: {env_var_data['description']}")
-                if env_var_data["value"]:
+                if env_var_data["value"] is not None and env_var_data["value"] != "":
                     print(f"Default: {env_var_data['value']}")
 
                 user_provided_arg = ask_or_get_from_env(
@@ -569,7 +567,7 @@ def _ask_funds_from_requirements(
             chain_config.chain_data.multisig: "Service Safe"
             for chain_config in service.chain_configs.values()
         }
-        | {key.address: "Agent EOA" for key in service.keys}
+        | {address: "Agent EOA" for address in service.agent_addresses}
     )
 
     if not requirements["is_refill_required"] and requirements["allow_start_agent"]:

operate/quickstart/stop_service.py

@@ -23,6 +23,7 @@ import warnings
 from typing import TYPE_CHECKING, cast
 
 from operate.quickstart.run_service import (
+    ask_password_if_needed,
     configure_local_config,
     get_service,
     load_local_config,
@@ -44,9 +45,6 @@ def stop_service(operate: "OperateApp", config_path: str) -> None:
 
     print_title(f"Stop {template['name']} Quickstart")
 
-    operate.service_manager().migrate_service_configs()
-    operate.wallet_manager.migrate_wallet_configs()
-
     # check if agent was started before
     config = load_local_config(
         operate=operate, service_name=cast(str, template["name"])
@@ -55,11 +53,12 @@ def stop_service(operate: "OperateApp", config_path: str) -> None:
         print("No previous agent setup found. Exiting.")
         return
 
+    ask_password_if_needed(operate)
     configure_local_config(template, operate)
     manager = operate.service_manager()
     service = get_service(manager, template)
     manager.stop_service_locally(
-        service_config_id=service.service_config_id, delete=True, use_docker=True
+        service_config_id=service.service_config_id, use_docker=True
     )
 
     print()

operate/quickstart/terminate_on_chain_service.py

@@ -43,9 +43,6 @@ def terminate_service(operate: "OperateApp", config_path: str) -> None:
 
     print_title(f"Terminate {template['name']} on-chain service")
 
-    operate.service_manager().migrate_service_configs()
-    operate.wallet_manager.migrate_wallet_configs()
-
     # check if agent was started before
     config = load_local_config(
         operate=operate, service_name=cast(str, template["name"])
@@ -61,8 +58,8 @@ def terminate_service(operate: "OperateApp", config_path: str) -> None:
         print("Cancelled.")
         return
 
-    config = configure_local_config(template, operate)
     ask_password_if_needed(operate)
+    config = configure_local_config(template, operate)
     manager = operate.service_manager()
     service = get_service(manager, template)
     ensure_enough_funds(operate, service)

operate/quickstart/utils.py

@@ -35,9 +35,6 @@ from operate.operate_types import Chain
 from operate.resource import LocalResource, deserialize
 
 
-MAX_QUICKSTART_VERSION = 1
-
-
 def print_box(text: str, margin: int = 1, character: str = "=") -> None:
     """Print text centered within a box."""
 
@@ -119,20 +116,20 @@ CHAIN_TO_METADATA = {
             "MAX_FEE_PER_GAS": "",
         },
     },
-    "optimistic": {
+    "optimism": {
         "name": "Optimism",
         "gasFundReq": unit_to_wei(0.005),  # fund for master EOA
-        "staking_bonding_token": OLAS[Chain.OPTIMISTIC],
+        "staking_bonding_token": OLAS[Chain.OPTIMISM],
         "token_data": {
             ZERO_ADDRESS: {
                 "symbol": "ETH",
                 "decimals": 18,
             },
-            USDC[Chain.OPTIMISTIC]: {
+            USDC[Chain.OPTIMISM]: {
                 "symbol": "USDC",
                 "decimals": 6,
             },
-            OLAS[Chain.OPTIMISTIC]: {
+            OLAS[Chain.OPTIMISM]: {
                 "symbol": "OLAS",
                 "decimals": 18,
             },

operate/resource.py

@@ -22,7 +22,9 @@
 import enum
 import json
 import os
+import platform
 import shutil
+import time
 import types
 import typing as t
 from dataclasses import asdict, is_dataclass
@@ -92,6 +94,23 @@ def deserialize(obj: t.Any, otype: t.Any) -> t.Any:
     return obj
 
 
+def _safe_file_operation(operation: t.Callable, *args: t.Any, **kwargs: t.Any) -> None:
+    """Safely perform file operation with retries on Windows."""
+    max_retries = 3 if platform.system() == "Windows" else 1
+
+    for attempt in range(max_retries):
+        try:
+            operation(*args, **kwargs)
+            return
+        except (PermissionError, FileNotFoundError, OSError) as e:
+            if attempt == max_retries - 1:
+                raise e
+
+            if platform.system() == "Windows":
+                # On Windows, wait a bit and retry
+                time.sleep(0.1)
+
+
 class LocalResource:
     """Initialize local resource."""
 
@@ -144,9 +163,14 @@ class LocalResource:
         bak0 = path.with_name(f"{path.name}.0.bak")
 
         if path.exists() and not bak0.exists():
-            shutil.copy2(path, bak0)
+            _safe_file_operation(shutil.copy2, path, bak0)
 
         tmp_path = path.parent / f".{path.name}.tmp"
+
+        # Clean up any existing tmp file
+        if tmp_path.exists():
+            _safe_file_operation(tmp_path.unlink)
+
         tmp_path.write_text(
             json.dumps(
                 self.json,
@@ -155,15 +179,23 @@ class LocalResource:
             encoding="utf-8",
         )
 
-        os.replace(tmp_path, path)  # atomic replace to avoid corruption
+        # Atomic replace to avoid corruption
+        try:
+            _safe_file_operation(os.replace, tmp_path, path)
+        except (PermissionError, FileNotFoundError):
+            # On Windows, if the replace fails, clean up and skip
+            if platform.system() == "Windows":
+                _safe_file_operation(tmp_path.unlink)
+
         self.load(self.path)  # Validate before making backup
 
+        # Rotate backup files
         for i in reversed(range(N_BACKUPS - 1)):
             newer = path.with_name(f"{path.name}.{i}.bak")
             older = path.with_name(f"{path.name}.{i + 1}.bak")
             if newer.exists():
                 if older.exists():
-                    older.unlink()
-                newer.rename(older)
+                    _safe_file_operation(older.unlink)
+                _safe_file_operation(newer.rename, older)
 
-        shutil.copy2(path, bak0)
+        _safe_file_operation(shutil.copy2, path, bak0)

operate/services/deployment_runner.py

@@ -29,15 +29,18 @@ import sys  # nosec
 import time
 import typing as t
 from abc import ABC, ABCMeta, abstractmethod
+from contextlib import suppress
+from enum import Enum
 from io import TextIOWrapper
 from pathlib import Path
 from traceback import print_exc
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Type
 from venv import main as venv_cli
 
 import psutil
 import requests
 from aea.__version__ import __version__ as aea_version
+from aea.helpers.logging import setup_logger
 from autonomy.__version__ import __version__ as autonomy_version
 
 from operate import constants
@@ -99,6 +102,8 @@ class BaseDeploymentRunner(AbstractDeploymentRunner, metaclass=ABCMeta):
 
     TM_CONTROL_URL = constants.TM_CONTROL_URL
     SLEEP_BEFORE_TM_KILL = 2  # seconds
+    START_TRIES = constants.DEPLOYMENT_START_TRIES_NUM
+    logger = setup_logger(name="operate.base_deployment_runner")
 
     def _open_agent_runner_log_file(self) -> TextIOWrapper:
         """Open agent_runner.log file."""
@@ -109,7 +114,7 @@ class BaseDeploymentRunner(AbstractDeploymentRunner, metaclass=ABCMeta):
     def _run_aea_command(self, *args: str, cwd: Path) -> Any:
         """Run aea command."""
         cmd = " ".join(args)
-        print("Running aea command: ", cmd, " at ", str(cwd))
+        self.logger.info(f"Running aea command: {cmd} at {str(cwd)}")
         p = multiprocessing.Process(
             target=self.__class__._call_aea_command,  # pylint: disable=protected-access
             args=(cwd, args),
@@ -134,14 +139,14 @@ class BaseDeploymentRunner(AbstractDeploymentRunner, metaclass=ABCMeta):
                 args, standalone_mode=False
             )
         except Exception:
+            print(f"Error on calling aea command: {args}")
             print_exc()
             raise
 
-    @staticmethod
-    def _run_cmd(args: t.List[str], cwd: t.Optional[Path] = None) -> None:
+    def _run_cmd(self, args: t.List[str], cwd: t.Optional[Path] = None) -> None:
         """Run command in a subprocess."""
-        print(f"Running: {' '.join(args)}")
-        print(f"Working dir: {os.getcwd()}")
+        self.logger.info(f"Running: {' '.join(args)}")
+        self.logger.info(f"Working dir: {os.getcwd()}")
         result = subprocess.run(  # pylint: disable=subprocess-run-check # nosec
             args=args,
             cwd=cwd,
@@ -157,15 +162,8 @@ class BaseDeploymentRunner(AbstractDeploymentRunner, metaclass=ABCMeta):
         """Prepare agent env, add keys, run aea commands."""
         working_dir = self._work_directory
         env = json.loads((working_dir / "agent.json").read_text(encoding="utf-8"))
-        # Patch for trader agent
-        if "SKILL_TRADER_ABCI_MODELS_PARAMS_ARGS_STORE_PATH" in env:
-            data_dir = working_dir / "data"
-            data_dir.mkdir(exist_ok=True)
-            env["SKILL_TRADER_ABCI_MODELS_PARAMS_ARGS_STORE_PATH"] = str(data_dir)
 
         # TODO: Dynamic port allocation, backport to service builder
-        env["CONNECTION_ABCI_CONFIG_HOST"] = "localhost"
-        env["CONNECTION_ABCI_CONFIG_PORT"] = "26658"
         env["PYTHONUTF8"] = "1"
         for var in env:
             # Fix tendermint connection params
@@ -178,11 +176,6 @@ class BaseDeploymentRunner(AbstractDeploymentRunner, metaclass=ABCMeta):
             if var.endswith("MODELS_PARAMS_ARGS_TENDERMINT_P2P_URL"):
                 env[var] = "localhost:26656"
 
-            if var.endswith("MODELS_BENCHMARK_TOOL_ARGS_LOG_DIR"):
-                benchmarks_dir = working_dir / "benchmarks"
-                benchmarks_dir.mkdir(exist_ok=True, parents=True)
-                env[var] = str(benchmarks_dir.resolve())
-
         (working_dir / "agent.json").write_text(
             json.dumps(env, indent=4),
             encoding="utf-8",
@@ -206,8 +199,22 @@ class BaseDeploymentRunner(AbstractDeploymentRunner, metaclass=ABCMeta):
             cwd=working_dir,
         )
 
+        agent_alias_name = "agent"
+
+        agent_dir_full_path = Path(working_dir) / agent_alias_name
+
+        if agent_dir_full_path.exists():
+            # remove if exists before fetching! can have issues with retry mechanism of multiple start attempts
+            with suppress(Exception):
+                shutil.rmtree(agent_dir_full_path, ignore_errors=True)
+
         self._run_aea_command(
-            "-s", "fetch", env["AEA_AGENT"], "--alias", "agent", cwd=working_dir
+            "-s",
+            "fetch",
+            env["AEA_AGENT"],
+            "--alias",
+            agent_alias_name,
+            cwd=working_dir,
         )
 
         # Add keys
@@ -221,6 +228,18 @@ class BaseDeploymentRunner(AbstractDeploymentRunner, metaclass=ABCMeta):
         self._run_aea_command("-s", "issue-certificates", cwd=working_dir / "agent")
 
     def start(self) -> None:
+        """Start the deployment with retries."""
+        for _ in range(self.START_TRIES):
+            try:
+                self._start()
+                return
+            except Exception as e:  # pylint: disable=broad-except
+                self.logger.exception(f"Error on starting deployment: {e}")
+        raise RuntimeError(
+            f"Failed to start the deployment after {self.START_TRIES} attempts! Check logs"
+        )
+
+    def _start(self) -> None:
         """Start the deployment."""
         self._setup_agent()
         self._start_tendermint()
@@ -247,9 +266,11 @@ class BaseDeploymentRunner(AbstractDeploymentRunner, metaclass=ABCMeta):
             requests.get(self._get_tm_exit_url(), timeout=(1, 10))
             time.sleep(self.SLEEP_BEFORE_TM_KILL)
         except requests.ConnectionError:
-            print(f"No Tendermint process listening on {self._get_tm_exit_url()}.")
+            self.logger.error(
+                f"No Tendermint process listening on {self._get_tm_exit_url()}."
+            )
         except Exception:  # pylint: disable=broad-except
-            print_exc()
+            self.logger.exception("Exception on tendermint stop!")
 
         pid = self._work_directory / "tendermint.pid"
         if not pid.exists():
@@ -611,30 +632,141 @@ class HostPythonHostDeploymentRunner(BaseDeploymentRunner):
         )
 
 
-def _get_host_deployment_runner(build_dir: Path) -> BaseDeploymentRunner:
-    """Return depoyment runner according to running env."""
-    deployment_runner: BaseDeploymentRunner
+class States(Enum):
+    """Service deployment states."""
 
-    if getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS"):
-        # pyinstaller inside!
-        if platform.system() == "Darwin":
-            deployment_runner = PyInstallerHostDeploymentRunnerMac(build_dir)
-        elif platform.system() == "Windows":
-            deployment_runner = PyInstallerHostDeploymentRunnerWindows(build_dir)
-        else:
+    NONE = 0
+    STARTING = 1
+    STARTED = 2
+    STOPPING = 3
+    STOPPED = 4
+    ERROR = 5
+
+
+class DeploymentManager:
+    """Deployment manager to run and stop deployments."""
+
+    def __init__(self) -> None:
+        """Init the deployment manager."""
+        self._deployment_runner_class = self._get_host_deployment_runner_class()
+        self._is_stopping = False
+        self.logger = setup_logger(name="operate.deployment_manager")
+        self._states: Dict[Path, States] = {}
+
+    def _get_deployment_runner(self, build_dir: Path) -> BaseDeploymentRunner:
+        """Get deploymnent runner instance."""
+        return self._deployment_runner_class(build_dir)
+
+    @staticmethod
+    def _get_host_deployment_runner_class() -> Type[BaseDeploymentRunner]:
+        """Return depoyment runner class according to running env."""
+
+        if getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS"):
+            # pyinstaller inside!
+            if platform.system() == "Darwin":
+                return PyInstallerHostDeploymentRunnerMac
+            if platform.system() == "Windows":
+                return PyInstallerHostDeploymentRunnerWindows
             raise ValueError(f"Platform not supported {platform.system()}")
-    else:
-        deployment_runner = HostPythonHostDeploymentRunner(build_dir)
-    return deployment_runner
+
+        return HostPythonHostDeploymentRunner
+
+    def stop(self) -> None:
+        """Stop deploment manager."""
+        self.logger.info("Stop deployment manager")
+        self._is_stopping = True
+
+    def get_state(self, build_dir: Path) -> States:
+        """Get state of the deployment."""
+        return self._states.get(build_dir) or States.NONE
+
+    def check_ipfs_connection_works(self) -> None:
+        """Check ipfs works and there is a good net connection."""
+        self.logger.info("Doing network connection check by test call to ipfs server.")
+        for i in range(3):
+            try:
+                requests.get(constants.IPFS_CHECK_URL, timeout=60)
+                return
+            except OSError:
+                self.logger.exception(
+                    "failed to connect to ipfs to test connection. OSError, critical!"
+                )
+                raise
+            except Exception:  # pylint: disable=broad-except
+                self.logger.exception(
+                    "failed to connect to ipfs to test connection. do another try"
+                )
+                time.sleep(i * 5)
+        self.logger.error(
+            "failed to connect to ipfs to test connection. no attempts left. raise error"
+        )
+        raise RuntimeError(
+            "Failed to perform test connection to ipfs to check network connection!"
+        )
+
+    def run_deployment(self, build_dir: Path) -> None:
+        """Run deployment."""
+        if self._is_stopping:
+            raise RuntimeError("deployment manager stopped")
+        if self.get_state(build_dir=build_dir) in [States.STARTING, States.STOPPING]:
+            raise ValueError("Service already in transition")
+
+        # doing pre check for ipfs works fine, also network connection is ok.
+        self.check_ipfs_connection_works()
+
+        self.logger.info(f"Starting deployment {build_dir}...")
+        self._states[build_dir] = States.STARTING
+        try:
+            deployment_runner = self._get_deployment_runner(build_dir=build_dir)
+            deployment_runner.start()
+            self.logger.info(f"Started deployment {build_dir}")
+            self._states[build_dir] = States.STARTED
+        except Exception:  # pylint: disable=broad-except
+            self.logger.exception(
+                f"Starting deployment failed {build_dir}. so try to stop"
+            )
+            self._states[build_dir] = States.ERROR
+            self.stop_deployemnt(build_dir=build_dir, force=True)
+
+        if self._is_stopping:
+            self.logger.warning(
+                f"Deployment at {build_dir} started when it was  going to stop, so stop it"
+            )
+            self.stop_deployemnt(build_dir=build_dir, force=True)
+
+    def stop_deployemnt(self, build_dir: Path, force: bool = False) -> None:
+        """Stop the deployment."""
+        if (
+            self.get_state(build_dir=build_dir) in [States.STARTING, States.STOPPING]
+            and not force
+        ):
+            raise ValueError("Service already in transition")
+        self.logger.info(f"Stopping deployment {build_dir}...")
+        self._states[build_dir] = States.STOPPING
+        deployment_runner = self._get_deployment_runner(build_dir=build_dir)
+        try:
+            deployment_runner.stop()
+            self.logger.info(f"Stopped deployment {build_dir}...")
+            self._states[build_dir] = States.STOPPED
+        except Exception:
+            self.logger.exception(f"Stopping deployment  failed {build_dir}...")
+            self._states[build_dir] = States.ERROR
+            raise
+
+
+deployment_manager = DeploymentManager()
 
 
 def run_host_deployment(build_dir: Path) -> None:
     """Run host deployment."""
-    deployment_runner = _get_host_deployment_runner(build_dir=build_dir)
-    deployment_runner.start()
+    deployment_manager.run_deployment(build_dir=build_dir)
 
 
 def stop_host_deployment(build_dir: Path) -> None:
     """Stop host deployment."""
-    deployment_runner = _get_host_deployment_runner(build_dir=build_dir)
-    deployment_runner.stop()
+    deployment_manager.stop_deployemnt(build_dir=build_dir)
+
+
+def stop_deployment_manager() -> None:
+    """Stop deployment manager."""
+    deployment_manager.stop()

operate/services/health_checker.py

@@ -20,6 +20,7 @@
 """Source code for checking aea is alive.."""
 import asyncio
 import json
+import logging
 import typing as t
 from concurrent.futures import ThreadPoolExecutor
 from http import HTTPStatus
@@ -27,15 +28,11 @@ from pathlib import Path
 from traceback import print_exc
 
 import aiohttp  # type: ignore
-from aea.helpers.logging import setup_logger
 
 from operate.constants import HEALTH_CHECK_URL
 from operate.services.manage import ServiceManager  # type: ignore
 
 
-HTTP_OK = HTTPStatus.OK
-
-
 class HealthChecker:
     """Health checker manager."""
 
@@ -43,19 +40,19 @@ class HealthChecker:
     PORT_UP_TIMEOUT_DEFAULT = 300  # seconds
     REQUEST_TIMEOUT_DEFAULT = 90
     NUMBER_OF_FAILS_DEFAULT = 10
-    HEALTH_CHECK_URL = HEALTH_CHECK_URL
 
     def __init__(
         self,
         service_manager: ServiceManager,
+        logger: logging.Logger,
         port_up_timeout: int | None = None,
         sleep_period: int | None = None,
         number_of_fails: int | None = None,
     ) -> None:
         """Init the healtch checker."""
         self._jobs: t.Dict[str, asyncio.Task] = {}
-        self.logger = setup_logger(name="operate.health_checker")
         self._service_manager = service_manager
+        self.logger = logger
         self.port_up_timeout = port_up_timeout or self.PORT_UP_TIMEOUT_DEFAULT
         self.sleep_period = sleep_period or self.SLEEP_PERIOD_DEFAULT
         self.number_of_fails = number_of_fails or self.NUMBER_OF_FAILS_DEFAULT
@@ -95,11 +92,11 @@ class HealthChecker:
         del service_config_id
         timeout = aiohttp.ClientTimeout(total=self.REQUEST_TIMEOUT_DEFAULT)
         async with aiohttp.ClientSession(timeout=timeout) as session:
-            async with session.get(self.HEALTH_CHECK_URL) as resp:
+            async with session.get(HEALTH_CHECK_URL) as resp:
                 try:
                     status = resp.status
 
-                    if status != HTTP_OK:
+                    if status != HTTPStatus.OK:
                         # not HTTP OK -> not healthy for sure
                         content = await resp.text()
                         self.logger.warning(