walrasquant-lib 0.4.20__py3-none-any.whl

walrasquant/engine.py

@@ -0,0 +1,745 @@
+import asyncio
+import platform
+import nexuslog as logging
+from typing import Callable, Dict, cast
+from collections import defaultdict
+from walrasquant.constants import AccountType, ExchangeType
+from walrasquant.config import Config, WebConfig
+from walrasquant.strategy import Strategy
+from walrasquant.core.cache import AsyncCache
+from walrasquant.core.registry import OrderRegistry
+from walrasquant.error import EngineBuildError
+from walrasquant.base import (
+    ExchangeManager,
+    PublicConnector,
+    PrivateConnector,
+    ExecutionManagementSystem,
+    SubscriptionManagementSystem,
+    OrderManagementSystem,
+)
+from walrasquant.exchange.registry import get_factory
+from walrasquant.exchange.base_factory import BuildContext
+
+from walrasquant.core.entity import TaskManager, ZeroMQSignalRecv
+from walrasquant.core.nautilius_core import setup_nexus_core
+from walrasquant.schema import InstrumentId
+from walrasquant.web.app import StrategyFastAPI
+from walrasquant.web.server import StrategyWebServer
+from walrasquant.base.ws_client import WSClient
+from walrasquant.core.connection import (
+    ConnectionState,
+    ConnectionPolicyState,
+    ConnectionRole,
+)
+from walrasquant.push import FlashDutyPushService
+from walrasquant.execution.algorithm import ExecAlgorithm
+from walrasquant.core.entity import OidGen
+
+
+class Engine:
+    @staticmethod
+    def new_event_loop() -> asyncio.AbstractEventLoop:
+        # aiofastnet patches the loop so create_connection / start_tls use its
+        # optimized transports (faster TLS, KTLS-capable). Built on uvloop on
+        # non-Windows platforms. Avoids the legacy event-loop-policy API,
+        # deprecated in Python 3.14 and removed in 3.16.
+        import aiofastnet
+
+        if platform.system() != "Windows":
+            import uvloop
+
+            return aiofastnet.loop_factory(uvloop.new_event_loop)()
+        return aiofastnet.loop_factory()()
+
+    def __init__(self, config: Config):
+        self._config = config
+        self._is_built = False
+        self._scheduler_started = False
+        self._loop = self.new_event_loop()
+        self._task_manager = TaskManager(self._loop)
+
+        self._exchanges: Dict[ExchangeType, ExchangeManager] = {}
+        self._public_connectors: Dict[AccountType, PublicConnector] = {}
+        self._private_connectors: Dict[AccountType, PrivateConnector] = {}
+
+        trader_id = f"{self._config.strategy_id}-{self._config.user_id}"
+
+        self._custom_signal_recv = None
+
+        # Initialize nautilus core components and configure nexuslog
+        self._msgbus, self._clock = setup_nexus_core(
+            trader_id=trader_id,
+            filename=self._config.log_config.filename,
+            level=self._config.log_config.level,
+            name_levels=self._config.log_config.name_levels,
+            unix_ts=self._config.log_config.unix_ts,
+            batch_size=self._config.log_config.batch_size,
+        )
+
+        # Create logger instance for Engine
+        self._log = logging.getLogger(type(self).__name__)
+
+        self._cache: AsyncCache = AsyncCache(
+            strategy_id=config.strategy_id,
+            user_id=config.user_id,
+            msgbus=self._msgbus,
+            clock=self._clock,
+            task_manager=self._task_manager,
+            storage_backend=config.storage_backend,
+            db_path=config.db_path,
+            sync_interval=config.cache_sync_interval,
+            expired_time=config.cache_expired_time,
+        )
+        self._oidgen = OidGen(self._clock)
+
+        self._registry = OrderRegistry()
+        self._oms: Dict[ExchangeType, OrderManagementSystem] = {}
+        self._ems: Dict[ExchangeType, ExecutionManagementSystem] = {}
+        self._custom_ems: Dict[ExchangeType, type[ExecutionManagementSystem]] = {}
+        self._exec_algorithms: Dict[str, ExecAlgorithm] = {}
+
+        self._sms = SubscriptionManagementSystem(
+            exchanges=self._exchanges,
+            public_connectors=self._public_connectors,
+            task_manager=self._task_manager,
+            clock=self._clock,
+            sms_maxsize=self._config.queue_config.sms_maxsize,
+        )
+
+        self._push_service = FlashDutyPushService(
+            integration_key=self._config.flashduty_integration_key,
+            strategy_id=self._config.strategy_id,
+            user_id=self._config.user_id,
+        )
+
+        self._strategy: Strategy = config.strategy
+        self._strategy.register(
+            cache=self._cache,
+            msgbus=self._msgbus,
+            clock=self._clock,
+            oidgen=self._oidgen,
+            task_manager=self._task_manager,
+            ems=self._ems,
+            sms=self._sms,
+            exchanges=self._exchanges,
+            private_connectors=self._private_connectors,
+            public_connectors=self._public_connectors,
+            push_service=self._push_service,
+            exec_algorithms=self._exec_algorithms,
+            strategy_id=config.strategy_id,
+            user_id=config.user_id,
+        )
+
+        self._web_app: StrategyFastAPI | None = None
+        self._web_server: StrategyWebServer | None = None
+        self._prepare_web_interface()
+
+        self._connection_registry: Dict[
+            tuple[str, str, str, str, int], ConnectionState
+        ] = {}
+        self._connection_policy_state: ConnectionPolicyState | None = None
+
+    def _prepare_web_interface(self) -> None:
+        web_app = getattr(self._strategy, "web_app", None)
+        if not web_app:
+            return
+        if not isinstance(web_app, StrategyFastAPI):
+            raise EngineBuildError(
+                "Strategy.web_app must be created with `create_strategy_app()` or `StrategyFastAPI`."
+            )
+
+        self._web_app = web_app
+        self._web_app.bind_strategy(self._strategy)
+
+    def _start_web_interface(self) -> None:
+        if not self._web_app:
+            return
+
+        web_config: WebConfig = getattr(self._config, "web_config", WebConfig())
+        if not web_config.enabled:
+            self._log.debug("Web interface disabled via configuration")
+            return
+
+        if not self._web_app.has_user_routes():
+            self._log.debug(
+                "Web interface enabled but no user routes registered; skipping startup"
+            )
+            return
+
+        self._web_server = StrategyWebServer(
+            self._web_app,
+            host=web_config.host,
+            port=web_config.port,
+            log_level=web_config.log_level,
+        )
+        try:
+            self._web_server.start()
+            self._log.info(
+                f"Web interface started on http://{web_config.host}:{web_config.port}"
+            )
+        except Exception as exc:  # pragma: no cover - defensive logging
+            self._log.error(f"Failed to start web interface: {exc}")
+            self._web_server = None
+
+    def _public_connector_check(self):
+        # Group connectors by exchange
+        exchange_connectors = defaultdict(dict)
+        for account_type, connector in self._public_connectors.items():
+            exchange_id = ExchangeType(
+                cast(str, getattr(account_type, "exchange_id")).lower()
+            )
+            exchange_connectors[exchange_id][account_type] = connector
+
+        # Validate each exchange's connectors
+        for exchange_id, connectors in exchange_connectors.items():
+            exchange = self._exchanges[exchange_id]
+            basic_config = self._config.basic_config.get(exchange_id)
+
+            if not basic_config:
+                raise EngineBuildError(
+                    f"Basic config for {exchange_id} is not set. Please add `{exchange_id}` in `basic_config`."
+                )
+
+            # Validate each connector configuration
+            for account_type in connectors.keys():
+                exchange.validate_public_connector_config(account_type, basic_config)
+
+            # Validate connector limits
+            exchange.validate_public_connector_limits(connectors)
+
+    def _build_public_connectors(self):
+        # Create build context
+        context = BuildContext(
+            msgbus=self._msgbus,
+            clock=self._clock,
+            task_manager=self._task_manager,
+            cache=self._cache,
+            registry=self._registry,
+            order_query_config=self._config.order_query_config,
+        )
+
+        for exchange_id, public_conn_configs in self._config.public_conn_config.items():
+            factory = get_factory(exchange_id)
+            exchange = self._exchanges[exchange_id]
+
+            for config in public_conn_configs:
+                public_connector = factory.create_public_connector(
+                    config, exchange, context
+                )
+                self._public_connectors[config.account_type] = public_connector
+
+        self._public_connector_check()
+
+    def _build_private_connectors(self):
+        # Create build context
+        context = BuildContext(
+            msgbus=self._msgbus,
+            clock=self._clock,
+            task_manager=self._task_manager,
+            cache=self._cache,
+            registry=self._registry,
+            queue_maxsize=self._config.queue_config.ems_maxsize,
+            order_query_config=self._config.order_query_config,
+        )
+
+        for (
+            exchange_id,
+            private_conn_configs,
+        ) in self._config.private_conn_config.items():
+            if not private_conn_configs:
+                raise EngineBuildError(
+                    f"Private connector config for {exchange_id} is not set. Please add `{exchange_id}` in `private_conn_config`."
+                )
+
+            factory = get_factory(exchange_id)
+            exchange = self._exchanges[exchange_id]
+
+            for config in private_conn_configs:
+                # Let factory determine account type (handles testnet mapping)
+                account_type = factory.get_private_account_type(exchange, config)
+
+                private_connector = factory.create_private_connector(
+                    config, exchange, context, account_type
+                )
+                self._private_connectors[account_type] = private_connector
+
+    def _build_exchanges(self):
+        for exchange_id, basic_config in self._config.basic_config.items():
+            factory = get_factory(exchange_id)
+            self._exchanges[exchange_id] = factory.create_manager(basic_config)
+
+    def _build_custom_signal_recv(self):
+        zmq_config = self._config.zero_mq_signal_config
+        if zmq_config:
+            if not hasattr(self._strategy, "on_custom_signal"):
+                raise EngineBuildError(
+                    "Please add `on_custom_signal` method to the strategy."
+                )
+
+            self._custom_signal_recv = ZeroMQSignalRecv(
+                zmq_config,
+                cast(Callable, self._strategy.on_custom_signal),
+                self._task_manager,
+            )
+
+    def set_custom_ems(
+        self,
+        exchange_id: ExchangeType,
+        ems_class: type[ExecutionManagementSystem],
+    ) -> None:
+        """
+        Set a custom ExecutionManagementSystem class for a specific exchange.
+
+        Args:
+            exchange_id: The exchange type to set the custom EMS for
+            ems_class: A custom EMS class that inherits from ExecutionManagementSystem
+        """
+        if not issubclass(ems_class, ExecutionManagementSystem):
+            raise TypeError(
+                "Custom EMS class must inherit from ExecutionManagementSystem"
+            )
+        self._custom_ems[exchange_id] = ems_class
+
+    def _build_ems(self):
+        # Create build context
+        context = BuildContext(
+            msgbus=self._msgbus,
+            clock=self._clock,
+            task_manager=self._task_manager,
+            cache=self._cache,
+            registry=self._registry,
+            order_query_config=self._config.order_query_config,
+            queue_maxsize=self._config.queue_config.ems_maxsize,
+        )
+
+        for exchange_id, exchange in self._exchanges.items():
+            # Check if there's a custom EMS for this exchange
+            if exchange_id in self._custom_ems:
+                self._ems[exchange_id] = self._custom_ems[exchange_id](
+                    market=exchange.market,
+                    cache=self._cache,
+                    msgbus=self._msgbus,
+                    clock=self._clock,
+                    task_manager=self._task_manager,
+                    registry=self._registry,
+                    queue_maxsize=self._config.queue_config.ems_maxsize,
+                )
+                self._ems[exchange_id]._build(self._private_connectors)
+                continue
+
+            # Use factory to create EMS
+            factory = get_factory(exchange_id)
+            ems = factory.create_ems(exchange, context)
+            ems._build(self._private_connectors)
+            self._ems[exchange_id] = ems
+
+    def _connection_key(
+        self,
+        role: ConnectionRole,
+        exchange_id: str,
+        account_type: str,
+        ws_name: str,
+        client_id: int,
+    ) -> tuple[str, str, str, str, int]:
+        return (role, exchange_id, account_type, ws_name, client_id)
+
+    def _recompute_connection_policy(self) -> None:
+        md_required = [
+            state
+            for state in self._connection_registry.values()
+            if state.is_md() and state.required
+        ]
+        td_required = [
+            state
+            for state in self._connection_registry.values()
+            if state.is_td() and state.required
+        ]
+
+        md_ok = bool(md_required) and all(state.connected for state in md_required)
+        td_ok = bool(td_required) and all(state.connected for state in td_required)
+
+        policy = ConnectionPolicyState(md_ok=md_ok, td_ok=td_ok)
+
+        if policy == self._connection_policy_state:
+            return
+
+        self._connection_policy_state = policy
+        self._log.debug(
+            "Connection policy update: "
+            f"md_ok={policy.md_ok} td_ok={policy.td_ok} "
+            f"allow_open={policy.allow_open} allow_trade={policy.allow_trade} "
+            f"allow_close_only={policy.allow_close_only}"
+        )
+
+        self._msgbus.send(
+            endpoint="connection_status",
+            msg=policy,
+        )
+
+    def _register_ws_client(
+        self,
+        ws_client: WSClient,
+        role: ConnectionRole,
+        account_type: AccountType,
+        ws_name: str,
+        required: bool,
+    ) -> None:
+        exchange_id = getattr(account_type, "exchange_id", str(account_type))
+        account_label = str(account_type)
+
+        def _callback(client_id: int, connected: bool) -> None:
+            key = self._connection_key(
+                role, exchange_id, account_label, ws_name, client_id
+            )
+            state = ConnectionState(
+                role=role,
+                exchange_id=str(exchange_id),
+                account_type=account_label,
+                ws_name=ws_name,
+                client_id=client_id,
+                required=required,
+                connected=connected,
+                changed_at_ms=self._clock.timestamp_ms(),
+            )
+            self._connection_registry[key] = state
+            self._recompute_connection_policy()
+
+        ws_client.set_connection_change_callback(_callback)
+
+    def _register_connection_callbacks(self) -> None:
+        for account_type, connector in self._public_connectors.items():
+            ws_client = getattr(connector, "_ws_client", None)
+            if isinstance(ws_client, WSClient):
+                self._register_ws_client(
+                    ws_client=ws_client,
+                    role="MD",
+                    account_type=account_type,
+                    ws_name="public",
+                    required=True,
+                )
+            business_ws_client = getattr(connector, "_business_ws_client", None)
+            if isinstance(business_ws_client, WSClient):
+                self._register_ws_client(
+                    ws_client=business_ws_client,
+                    role="MD",
+                    account_type=account_type,
+                    ws_name="business",
+                    required=True,
+                )
+
+        for account_type, connector in self._private_connectors.items():
+            oms = getattr(connector, "_oms", None)
+            if not oms:
+                continue
+            ws_client = getattr(oms, "_ws_client", None)
+            if isinstance(ws_client, WSClient):
+                self._register_ws_client(
+                    ws_client=ws_client,
+                    role="TD",
+                    account_type=account_type,
+                    ws_name="oms",
+                    required=True,
+                )
+            ws_api_client = getattr(oms, "_ws_api_client", None)
+            if isinstance(ws_api_client, WSClient):
+                self._register_ws_client(
+                    ws_client=ws_api_client,
+                    role="TD",
+                    account_type=account_type,
+                    ws_name="oms_api",
+                    required=True,
+                )
+
+    def add_exec_algorithm(self, algorithm: ExecAlgorithm):
+        """
+        Add an execution algorithm to the engine.
+
+        Parameters
+        ----------
+        algorithm : ExecAlgorithm
+            The execution algorithm instance.
+
+        Example
+        -------
+        >>> from walrasquant.execution import TWAPExecAlgorithm
+        >>> engine = Engine(config)
+        >>> engine.add_exec_algorithm(TWAPExecAlgorithm())
+        >>> engine.start()
+        """
+        if algorithm.id in self._exec_algorithms:
+            raise ValueError(f"Execution algorithm '{algorithm.id}' already registered")
+        self._exec_algorithms[algorithm.id] = algorithm
+        self._log.info(f"Added execution algorithm: {algorithm.id}")
+
+    def _build_exec_algorithms(self):
+        """Build and register all execution algorithms."""
+        if not self._exec_algorithms:
+            return
+
+        # Get all market data from all exchanges
+        all_markets = {}
+        for exchange_id, exchange_manager in self._exchanges.items():
+            all_markets.update(exchange_manager.market)
+
+        # Get first available EMS for order submission
+        for algo_id, algorithm in self._exec_algorithms.items():
+            algorithm.register(
+                msgbus=self._msgbus,
+                clock=self._clock,
+                cache=self._cache,
+                task_manager=self._task_manager,
+                oidgen=self._oidgen,
+                registry=self._registry,
+                market=all_markets,
+                ems=self._ems,
+            )
+            self._log.debug(f"Registered execution algorithm: {algo_id}")
+
+    def _start_exec_algorithms(self):
+        """Start all execution algorithms."""
+        for algorithm in self._exec_algorithms.values():
+            algorithm.start()
+
+    def _stop_exec_algorithms(self):
+        """Stop all execution algorithms."""
+        for algorithm in self._exec_algorithms.values():
+            algorithm.stop()
+
+    def _build(self):
+        self._build_exchanges()
+        self._build_public_connectors()
+        self._build_private_connectors()
+        self._build_ems()
+        self._build_exec_algorithms()
+        self._build_custom_signal_recv()
+        self._register_connection_callbacks()
+        self._is_built = True
+
+    async def _start_connectors(self):
+        # Start all public connectors
+        for connector in self._public_connectors.values():
+            await connector.connect()
+
+        # Wait for all public connectors to be ready
+        for connector in self._public_connectors.values():
+            await connector.wait_ready()
+
+        # Start all private connectors
+        for connector in self._private_connectors.values():
+            await connector.connect()
+
+        # Initialize OMS (two-phase init)
+        for connector in self._private_connectors.values():
+            await connector._oms._async_init()
+
+        # Wait for all private connectors to be ready
+        for connector in self._private_connectors.values():
+            await connector.wait_ready()
+
+        for connector in self._private_connectors.values():
+            connector._oms.start_order_query()
+
+    async def _start_ems(self):
+        for ems in self._ems.values():
+            await ems.start()
+
+    def _reload_markets_once(self):
+        """Reload market metadata for all configured exchanges."""
+        for exchange_id, exchange in self._exchanges.items():
+            before_count = len(exchange.market)
+            try:
+                exchange.load_markets(reload=True)
+            except Exception as exc:
+                self._log.error(f"Failed to reload markets for {exchange_id}: {exc}")
+                continue
+
+            after_count = len(exchange.market)
+            self._log.info(
+                f"Reloaded markets for {exchange_id}: {before_count} -> {after_count}"
+            )
+
+    def _schedule_market_reload(self):
+        market_reload_config = self._config.market_reload_config
+        if not market_reload_config.enabled:
+            return
+
+        kwargs = market_reload_config.scheduler_kwargs()
+        self._strategy._scheduler.add_job(
+            self._reload_markets_once,
+            trigger=market_reload_config.trigger,
+            **kwargs,
+        )
+        self._log.info(
+            f"Scheduled market reload: trigger={market_reload_config.trigger}, kwargs={kwargs}"
+        )
+
+    def _start_scheduler(self):
+        self._schedule_market_reload()
+        self._strategy._scheduler.start()
+        self._scheduler_started = True
+
+    async def _start(self):
+        await self._sms.start()
+        await self._start_ems()
+        await self._start_connectors()
+        self._start_exec_algorithms()
+        if self._custom_signal_recv:
+            await self._custom_signal_recv.start()
+        await asyncio.get_event_loop().run_in_executor(None, self._strategy._on_start)
+        self._start_scheduler()
+        await self._task_manager.wait()
+
+    async def _cancel_all_open_orders(self):
+        """Cancel all open orders across all exchanges during shutdown."""
+        # Get all open orders grouped by symbol
+        symbol_to_orders = defaultdict(set)
+        for exchange, oids in self._cache._mem_open_orders.items():
+            if not oids:
+                continue
+            for oid in oids:
+                order = self._cache._mem_orders.get(oid)
+                if order:
+                    symbol_to_orders[order.symbol].add(oid)
+
+        if not symbol_to_orders:
+            self._log.debug("No open orders to cancel")
+            return
+
+        total_symbols = len(symbol_to_orders)
+        total_orders = sum(len(oids) for oids in symbol_to_orders.values())
+        self._log.info(
+            f"Cancelling {total_orders} open orders across {total_symbols} symbols..."
+        )
+
+        # Cancel orders for each symbol
+        for symbol, oids in symbol_to_orders.items():
+            # Determine account type for this symbol
+            instrument_id = InstrumentId.from_str(symbol)
+            ems = self._ems.get(instrument_id.exchange)
+            if not ems:
+                self._log.warning(
+                    f"EMS {instrument_id.exchange} not found for {symbol}"
+                )
+                continue
+
+            account_type = ems._instrument_id_to_account_type(instrument_id)
+            connector = self._private_connectors.get(account_type)
+            if not connector:
+                self._log.warning(f"Private connector not found for {account_type}")
+                continue
+
+            # Cancel all orders for this symbol
+            self._log.debug(f"Cancelling {len(oids)} orders for {symbol}")
+            max_attempts = 3
+            backoff_seconds = 1
+            for attempt in range(1, max_attempts + 1):
+                result = await connector._oms.cancel_all_orders(instrument_id.symbol)
+                if result is not False:
+                    break
+
+                if attempt == max_attempts:
+                    self._log.error(
+                        f"Failed to cancel all orders for {symbol} "
+                        f"after {max_attempts} attempts"
+                    )
+                    break
+
+                self._log.warning(
+                    f"Cancel all orders for {symbol} failed; retrying in "
+                    f"{backoff_seconds}s ({attempt}/{max_attempts})"
+                )
+                await asyncio.sleep(backoff_seconds)
+                backoff_seconds *= 2
+
+        # Wait briefly for cancellations to be acknowledged
+        await asyncio.sleep(0.1)
+        self._log.info("Order cancellation completed")
+
+    async def _dispose(self):
+        # Stop on-loop fast timers (schedule(..., fast=True)) so no more ticks fire
+        # during teardown. Runs on the loop thread (this coroutine is run via
+        # run_until_complete), so cancelling the TimerHandles here is safe.
+        self._strategy._cancel_fast_timers()
+
+        if self._scheduler_started:
+            try:
+                # Remove all jobs first to prevent new executions
+                self._strategy._scheduler.remove_all_jobs()
+                # Short delay to allow running jobs to complete
+                await asyncio.sleep(0.05)
+                # Shutdown without waiting for jobs to complete
+                self._strategy._scheduler.shutdown(wait=False)
+            except (asyncio.CancelledError, RuntimeError):
+                # Suppress expected shutdown exceptions
+                pass
+
+        # Cancel all open orders if configured
+        if self._config.exit_after_cancel:
+            await self._cancel_all_open_orders()
+
+        for connector in self._public_connectors.values():
+            await connector.disconnect()
+        for connector in self._private_connectors.values():
+            await connector.disconnect()
+
+        await asyncio.sleep(0.2)  # NOTE: wait for the websocket to disconnect
+
+        await self._task_manager.cancel()
+        await self._cache.close()
+        self._push_service.shutdown()
+
+    def start(self):
+        self._build()
+        self._loop.run_until_complete(self._cache.start())  # Initialize cache
+        self._start_web_interface()
+        try:
+            self._loop.run_until_complete(self._start())
+        except asyncio.CancelledError:
+            pass
+
+    def _close_event_loop(self):
+        """Close event loop with proper error handling."""
+        if self._loop.is_closed():
+            return
+
+        try:
+            # Cancel any remaining tasks
+            pending_tasks = asyncio.all_tasks(self._loop)
+            if pending_tasks:
+                self._log.debug(f"Cancelling {len(pending_tasks)} pending tasks")
+                for task in pending_tasks:
+                    task.cancel()
+
+            self._loop.close()
+            self._log.debug("Event loop closed successfully")
+
+        except Exception as e:
+            self._log.warning(f"Event loop close error: {e}")
+
+    def dispose(self):
+        try:
+            self._stop_exec_algorithms()
+
+            try:
+                self._strategy._on_stop()
+            except Exception as e:
+                # Ensure strategy stop errors don't block shutdown
+                self._log.warning(f"Strategy on_stop error: {e}")
+
+            self._loop.run_until_complete(self._dispose())
+        except Exception as e:
+            # Never let dispose crash; make shutdown best-effort
+            self._log.error(f"Dispose error: {e}")
+        finally:
+            if self._web_server:
+                try:
+                    self._web_server.stop()
+                except Exception as exc:  # pragma: no cover - defensive cleanup
+                    self._log.debug(f"Error stopping web server: {exc}")
+                finally:
+                    self._web_server = None
+            if self._web_app:
+                self._web_app.unbind_strategy()
+
+            self._close_event_loop()
+            logging.shutdown()