cloudshell-networking-cisco 2.0.160__tar.gz → 7.1.0__tar.gz

cloudshell_networking_cisco-7.1.0/MANIFEST.in

@@ -0,0 +1,5 @@
+include *.txt
+global-include *.csv
+global-include *.ini
+global-include *.json
+prune .tox

cloudshell_networking_cisco-7.1.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: cloudshell-networking-cisco
+Version: 7.1.0
+Summary: QualiSystems networking cisco specific package
+Home-page: http://www.qualisystems.com/
+Author: QualiSystems
+Author-email: info@qualisystems.com
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Requires-Dist: cloudshell-shell-flows<3.0,>=2.0.3
+Requires-Dist: cloudshell-shell-connectivity-flow<4.0,>=3.1.3
+Requires-Dist: cloudshell-snmp<7.0,>=6.0
+Requires-Dist: cloudshell-snmp-autoload<4.0,>=3.0
+Requires-Dist: cloudshell-cli~=5.0
+Requires-Dist: attrs<23,>=21
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+QualiSystems networking cisco specific package

cloudshell_networking_cisco-7.1.0/README.md

@@ -0,0 +1,13 @@
+# cloudshell-networking-cisco
+[![Build status](https://github.com/QualiSystems/cloudshell-networking-cisco/workflows/CI/badge.svg?branch=master)](https://github.com/QualiSystems/cloudshell-networking-cisco/actions?query=branch%3Amaster)
+[![codecov](https://codecov.io/gh/QualiSystems/cloudshell-networking-cisco/branch/master/graph/badge.svg)](https://codecov.io/gh/QualiSystems/cloudshell-networking-cisco)
+[![PyPI version](https://badge.fury.io/py/cloudshell-networking-cisco.svg)](https://badge.fury.io/py/cloudshell-networking-cisco)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)
+
+<p align="center">
+<img src="https://github.com/QualiSystems/devguide_source/raw/master/logo.png"></img>
+</p>
+
+# CloudShell Networking Cisco
+
+We use tox and pre-commit for testing. [Services description](https://github.com/QualiSystems/cloudshell-package-repo-template#description-of-services)

{cloudshell-networking-cisco-2.0.160/cloudshell/networking/cisco/firmware_data → cloudshell_networking_cisco-7.1.0/cloudshell}/__init__.py

@@ -1,2 +1,3 @@
 from pkgutil import extend_path
+
 __path__ = extend_path(__path__, __name__)

{cloudshell-networking-cisco-2.0.160/cloudshell/networking/cisco/autoload → cloudshell_networking_cisco-7.1.0/cloudshell/networking}/__init__.py

@@ -1,3 +1,3 @@
-__author__ = 'coye'
 from pkgutil import extend_path
+
 __path__ = extend_path(__path__, __name__)

{cloudshell-networking-cisco-2.0.160/cloudshell → cloudshell_networking_cisco-7.1.0/cloudshell/networking/cisco}/__init__.py

@@ -1,3 +1,3 @@
-__author__ = 'coye'
 from pkgutil import extend_path
+
 __path__ = extend_path(__path__, __name__)

cloudshell_networking_cisco-7.1.0/cloudshell/networking/cisco/autoload/__init__.py

@@ -0,0 +1,3 @@
+from pkgutil import extend_path
+
+__path__ = extend_path(__path__, __name__)

cloudshell_networking_cisco-7.1.0/cloudshell/networking/cisco/autoload/cisco_generic_snmp_autoload.py

@@ -0,0 +1,38 @@
+from functools import lru_cache
+
+from cloudshell.snmp.autoload.generic_snmp_autoload import GenericSNMPAutoload
+
+from cloudshell.networking.cisco.autoload.snmp_tables.cisco_snmp_port_table import (
+    CiscoSnmpPortsTable,
+)
+from cloudshell.networking.cisco.autoload.table_services.cisco_ports_table import (
+    CiscoPortsTable,
+)
+from cloudshell.networking.cisco.autoload.table_services.cisco_sys_info_table import (
+    CiscoSnmpSystemInfo,
+)
+
+
+class CiscoGenericSNMPAutoload(GenericSNMPAutoload):
+    @property
+    @lru_cache()
+    def system_info_service(self) -> CiscoSnmpSystemInfo:
+        """Get system info service."""
+        return CiscoSnmpSystemInfo(self.snmp_handler, self.logger)
+
+    @property
+    @lru_cache()
+    def port_snmp_table(self) -> CiscoSnmpPortsTable:
+        """Get port snmp table."""
+        return CiscoSnmpPortsTable(snmp_handler=self.snmp_handler, logger=self.logger)
+
+    @property
+    def port_table_service(self) -> CiscoPortsTable:
+        """Get port table service."""
+        if not self._port_table_service:
+            self._port_table_service = CiscoPortsTable(
+                resource_model=self._resource_model,
+                ports_snmp_table=self.port_snmp_table,
+                logger=self.logger,
+            )
+        return self._port_table_service

cloudshell_networking_cisco-7.1.0/cloudshell/networking/cisco/autoload/cisco_snmp_if_port.py

@@ -0,0 +1,19 @@
+import re
+
+from cloudshell.snmp.autoload.snmp.entities.snmp_if_entity import SnmpIfEntity
+
+
+class CiscoSnmpIfPort(SnmpIfEntity):
+    """Cisco SNMP If Port."""
+
+    PORT_NAME_MATCH = re.compile(
+        r"^\S*(Ethernet|GigE|Serial|Sonet|Port-channel|Bundle-Ether)",
+        re.IGNORECASE,
+    )
+
+    @property
+    def port_name(self):
+        name = self.if_descr_name
+        if not self.PORT_NAME_MATCH.search(name):
+            name = self.if_name
+        return name.replace("/", "-").replace(":", "_")

cloudshell_networking_cisco-7.1.0/cloudshell/networking/cisco/autoload/constants/snmp_constants.py

@@ -0,0 +1,6 @@
+from cloudshell.snmp.core.domain.snmp_oid import SnmpMibObject
+
+CISCO_CDP_DEVICE_ID = SnmpMibObject("CISCO-CDP-MIB", "cdpCacheDeviceId")
+CISCO_CDP_DEVICE_PORT = SnmpMibObject("CISCO-CDP-MIB", "cdpCacheDevicePort")
+CISCO_STACK_DUPLEX = SnmpMibObject("CISCO-STACK-MIB", "portDuplex")
+CISCO_STACK_DUPLEX_ID = SnmpMibObject("CISCO-STACK-MIB", "portIfIndex")

cloudshell_networking_cisco-7.1.0/cloudshell/networking/cisco/autoload/snmp_tables/cisco_duplex_table.py

@@ -0,0 +1,31 @@
+from functools import lru_cache
+
+from cloudshell.networking.cisco.autoload.constants.snmp_constants import (
+    CISCO_STACK_DUPLEX,
+    CISCO_STACK_DUPLEX_ID,
+)
+
+
+class CiscoSnmpStackTable:
+    def __init__(self, snmp_handler, logger):
+        self._snmp_handler = snmp_handler
+        self._logger = logger
+        self._data = None
+
+    @property
+    @lru_cache()
+    def get_table(self):
+        if self._data is None:
+            data = self._snmp_handler.get_multiple_columns(
+                [CISCO_STACK_DUPLEX_ID, CISCO_STACK_DUPLEX]
+            )
+            self._data = {
+                str(data.get(CISCO_STACK_DUPLEX_ID.object_name, "")): str(
+                    data.get(CISCO_STACK_DUPLEX.object_name, "")
+                ).replace("'", "")
+                for key, data in data.items()
+            }
+        return self._data
+
+    def get(self, index):
+        return self.get_table.get(index, "")

cloudshell_networking_cisco-7.1.0/cloudshell/networking/cisco/autoload/snmp_tables/cisco_ports_auto_neg.py

@@ -0,0 +1,28 @@
+from logging import Logger
+
+from cloudshell.snmp.autoload.snmp.tables.port_attrs_snmp_tables.snmp_ports_auto_negotioation import (  # noqa: E501
+    PortAutoNegotiation,
+)
+from cloudshell.snmp.core.snmp_service import SnmpService
+
+from cloudshell.networking.cisco.autoload.snmp_tables.cisco_duplex_table import (
+    CiscoSnmpStackTable,
+)
+
+
+class CiscoPortAutoNegotiation(PortAutoNegotiation):
+    def __init__(
+        self,
+        snmp_service: SnmpService,
+        snmp_duplex: CiscoSnmpStackTable,
+        logger: Logger,
+    ):
+        super().__init__(snmp_service, logger)
+        self._snmp_duplex = snmp_duplex
+
+    def get_value_by_index(self, index):
+        response = super().get_value_by_index(index)
+        auto_neg_data = self._snmp_duplex.get(index)
+        if auto_neg_data in ["auto", "disagree"]:
+            response = "True"
+        return response

cloudshell_networking_cisco-7.1.0/cloudshell/networking/cisco/autoload/snmp_tables/cisco_ports_duplex.py

@@ -0,0 +1,28 @@
+from logging import Logger
+
+from cloudshell.snmp.autoload.snmp.tables.port_attrs_snmp_tables.snmp_ports_duplex_table import (  # noqa: E501
+    PortDuplex,
+)
+from cloudshell.snmp.core.snmp_service import SnmpService
+
+from cloudshell.networking.cisco.autoload.snmp_tables.cisco_duplex_table import (
+    CiscoSnmpStackTable,
+)
+
+
+class CiscoPortDuplex(PortDuplex):
+    def __init__(
+        self,
+        snmp_service: SnmpService,
+        snmp_duplex: CiscoSnmpStackTable,
+        logger: Logger,
+    ):
+        super().__init__(snmp_service, logger)
+        self._snmp_duplex = snmp_duplex
+
+    def get_duplex_by_port_index(self, index):
+        response = super().get_duplex_by_port_index(index)
+        duplex = self._snmp_duplex.get(index)
+        if duplex in ["full", "half"]:
+            response = duplex.capitalize()
+        return response

cloudshell_networking_cisco-7.1.0/cloudshell/networking/cisco/autoload/snmp_tables/cisco_ports_neighbours.py

@@ -0,0 +1,54 @@
+from functools import lru_cache
+from logging import Logger
+
+from cloudshell.snmp.autoload.snmp.tables.port_attrs_snmp_tables.snmp_ports_neighbors_table import (  # noqa: E501
+    PortNeighbours,
+)
+from cloudshell.snmp.core.snmp_service import SnmpService
+
+from cloudshell.networking.cisco.autoload.constants.snmp_constants import (
+    CISCO_CDP_DEVICE_ID,
+    CISCO_CDP_DEVICE_PORT,
+)
+
+
+class CiscoPortNeighbours(PortNeighbours):
+    def __init__(self, snmp_service: SnmpService, logger: Logger):
+        super().__init__(snmp_service, logger)
+        self._cisco_cdp_table = {}
+
+    @property
+    @lru_cache()
+    def load_cisco_cdp_table(self):
+        self._cisco_cdp_table = self._snmp.get_multiple_columns(
+            [CISCO_CDP_DEVICE_ID, CISCO_CDP_DEVICE_PORT]
+        )
+        return self._cisco_cdp_table
+
+    def set_port_attributes(self, port_object, port):
+        port_object.adjacent = self._get_adjacent(
+            port.if_index
+        ) or super().get_adjacent_by_port(port=port, port_object=port_object)
+
+    def _get_adjacent(self, if_index):
+        """Get connected device interface and device name to the specified port id.
+
+        Using cdp or lldp protocols
+        :return: device's name and port connected to port id
+        :rtype string
+        """
+        key = next(
+            (k for k in self.load_cisco_cdp_table if k.startswith(f"{if_index}.")), None
+        )
+        if key:
+            remote_host = self.load_cisco_cdp_table.get(key).get(
+                CISCO_CDP_DEVICE_ID.object_name
+            )
+            remote_port = self.load_cisco_cdp_table.get(key).get(
+                CISCO_CDP_DEVICE_PORT.object_name
+            )
+            if remote_host and remote_port:
+                result = self.ADJACENT_TEMPLATE.format(
+                    remote_host=remote_host, remote_port=remote_port
+                )
+                return result

cloudshell_networking_cisco-7.1.0/cloudshell/networking/cisco/autoload/snmp_tables/cisco_snmp_port_table.py

@@ -0,0 +1,25 @@
+from cloudshell.snmp.autoload.snmp.tables.snmp_ports_table import SnmpPortsTable
+
+from cloudshell.networking.cisco.autoload.snmp_tables.cisco_duplex_table import (
+    CiscoSnmpStackTable,
+)
+from cloudshell.networking.cisco.autoload.snmp_tables.cisco_ports_auto_neg import (
+    CiscoPortAutoNegotiation,
+)
+from cloudshell.networking.cisco.autoload.snmp_tables.cisco_ports_duplex import (
+    CiscoPortDuplex,
+)
+from cloudshell.networking.cisco.autoload.snmp_tables.cisco_ports_neighbours import (
+    CiscoPortNeighbours,
+)
+
+
+class CiscoSnmpPortsTable(SnmpPortsTable):
+    def __init__(self, snmp_handler, logger):
+        super().__init__(snmp_handler, logger)
+        self._snmp_duplex = CiscoSnmpStackTable(snmp_handler, logger)
+        self._port_auto_neg = CiscoPortAutoNegotiation(
+            snmp_handler, self._snmp_duplex, logger
+        )
+        self._port_duplex = CiscoPortDuplex(snmp_handler, self._snmp_duplex, logger)
+        self._port_neighbors = CiscoPortNeighbours(snmp_handler, logger)

cloudshell_networking_cisco-7.1.0/cloudshell/networking/cisco/autoload/table_services/cisco_ports_table.py

@@ -0,0 +1,16 @@
+from logging import Logger
+
+from cloudshell.snmp.autoload.services.port_table import PortsTable
+
+from cloudshell.networking.cisco.autoload.cisco_snmp_if_port import CiscoSnmpIfPort
+from cloudshell.networking.cisco.autoload.snmp_tables.cisco_snmp_port_table import (
+    CiscoSnmpPortsTable,
+)
+
+
+class CiscoPortsTable(PortsTable):
+    def __init__(
+        self, resource_model, ports_snmp_table: CiscoSnmpPortsTable, logger: Logger
+    ):
+        super().__init__(resource_model, ports_snmp_table, logger)
+        self._if_entity = CiscoSnmpIfPort

cloudshell_networking_cisco-7.1.0/cloudshell/networking/cisco/autoload/table_services/cisco_sys_info_table.py

@@ -0,0 +1,53 @@
+import re
+
+from cloudshell.shell.flows.autoload.autoload_utils import get_device_name
+from cloudshell.snmp.autoload.services.system_info_table import SnmpSystemInfo
+
+
+class CiscoSnmpSystemInfo(SnmpSystemInfo):
+    def _get_device_model(self):
+        """Get device model from the SNMPv2 mib.
+
+        :return: device model
+        :rtype: str
+        """
+        result = super()._get_device_model()
+        sys_descr = str(self._snmp_v2_obj.get_system_description())
+        match_name = re.search(r"\bvios(_l2)*\b", sys_descr, re.IGNORECASE)
+        if match_name:
+            result = match_name.group().upper().replace("_", "-")
+        result = re.sub("cevchassis", "", result, flags=re.IGNORECASE)
+        return result.capitalize()
+
+    def fill_attributes(self, resource):
+        """Get root element attributes.
+
+        :type resource: cloudshell.shell_standards.autoload_generic_models.GenericResourceModel  # noqa: E501
+        """
+        self._logger.debug("Building Root started")
+
+        resource.contact_name = self._snmp_v2_obj.get_system_contact()
+        resource.system_name = self._snmp_v2_obj.get_system_name()
+        resource.location = self._snmp_v2_obj.get_system_location()
+        resource.os_version = self._get_device_os_version()
+        vendor = self._get_vendor()
+        resource.vendor = vendor
+
+        raw_model = self._get_device_model()
+        model = re.sub(rf"^{vendor}", "", raw_model, flags=re.IGNORECASE)
+        resource.model = model.capitalize()
+        resource.model_name = model.capitalize()
+        resource.model_name = self._get_model_name(raw_model, vendor)
+
+        self._logger.info("Building Root completed")
+
+    def _get_model_name(self, model, vendor=None):
+        result = model
+        if self._device_model_map_path:
+            result = (
+                get_device_name(file_name=self._device_model_map_path, sys_obj_id=model)
+                or model
+            )
+        if result == model and vendor and model.lower().startswith(vendor.lower()):
+            result = f"{vendor.capitalize()} {model[len(vendor):].capitalize()}"
+        return result

cloudshell_networking_cisco-7.1.0/cloudshell/networking/cisco/cisco_constants.py

@@ -0,0 +1,3 @@
+DEFAULT_FILE_SYSTEM = "flash:/"
+
+DEFAULT_SESSION_POOL_TIMEOUT = 120

cloudshell_networking_cisco-7.1.0/cloudshell/networking/cisco/cli/__init__.py

@@ -0,0 +1,3 @@
+from pkgutil import extend_path
+
+__path__ = extend_path(__path__, __name__)

cloudshell_networking_cisco-7.1.0/cloudshell/networking/cisco/cli/cisco_cli_handler.py

@@ -0,0 +1,89 @@
+#!/usr/bin/python
+from __future__ import annotations
+
+from typing import ClassVar
+
+from attrs import define, field
+
+from cloudshell.cli.configurator import AbstractModeConfigurator
+from cloudshell.cli.factory.session_factory import (
+    ConsoleSessionFactory,
+    GenericSessionFactory,
+    SessionFactory,
+)
+from cloudshell.cli.service.cli import CLI
+from cloudshell.cli.service.cli_service_impl import CliServiceImpl
+from cloudshell.cli.service.command_mode_helper import CommandModeHelper
+from cloudshell.cli.service.session_pool_manager import SessionPoolManager
+from cloudshell.cli.session.console_ssh import ConsoleSSHSession
+from cloudshell.cli.session.console_telnet import ConsoleTelnetSession
+from cloudshell.cli.session.ssh_session import SSHSession
+from cloudshell.cli.session.telnet_session import TelnetSession
+from cloudshell.cli.types import T_COMMAND_MODE_RELATIONS
+
+from cloudshell.networking.cisco.cisco_constants import DEFAULT_SESSION_POOL_TIMEOUT
+from cloudshell.networking.cisco.cli.cisco_command_modes import (
+    ConfigCommandMode,
+    DefaultCommandMode,
+    EnableCommandMode,
+)
+
+
+class CiscoCli:
+    def __init__(self, resource_config, pool_timeout=DEFAULT_SESSION_POOL_TIMEOUT):
+        session_pool_size = int(resource_config.sessions_concurrency_limit)
+        session_pool = SessionPoolManager(
+            max_pool_size=session_pool_size, pool_timeout=pool_timeout
+        )
+        self.cli = CLI(session_pool=session_pool)
+
+    def get_cli_handler(self, resource_config, logger):
+        return CiscoCliHandler.from_config(resource_config, logger, self.cli)
+
+
+@define
+class CiscoCliHandler(AbstractModeConfigurator):
+    REGISTERED_SESSIONS: ClassVar[tuple[SessionFactory]] = (
+        GenericSessionFactory(SSHSession),
+        GenericSessionFactory(TelnetSession),
+        ConsoleSessionFactory(ConsoleSSHSession),
+        ConsoleSessionFactory(
+            ConsoleTelnetSession, session_kwargs={"start_with_new_line": False}
+        ),
+        ConsoleSessionFactory(
+            ConsoleTelnetSession, session_kwargs={"start_with_new_line": True}
+        ),
+    )
+    modes: T_COMMAND_MODE_RELATIONS = field(init=False)
+
+    def __attrs_post_init__(self):
+        super().__attrs_post_init__()
+        self.modes = CommandModeHelper.create_command_mode(self._auth.enable_password)
+
+    @property
+    def default_mode(self):
+        return self.modes[DefaultCommandMode]
+
+    @property
+    def enable_mode(self):
+        return self.modes[EnableCommandMode]
+
+    @property
+    def config_mode(self):
+        return self.modes[ConfigCommandMode]
+
+    def _on_session_start(self, session, logger):
+        """Send default commands to configure/clear session outputs.
+
+        :return:
+        """
+        cli_service = CliServiceImpl(
+            session=session, requested_command_mode=self.enable_mode, logger=logger
+        )
+        cli_service.send_command("terminal length 0", EnableCommandMode.PROMPT)
+        cli_service.send_command("terminal width 300", EnableCommandMode.PROMPT)
+        cli_service.send_command(
+            "terminal no exec prompt timestamp", EnableCommandMode.PROMPT
+        )
+        with cli_service.enter_mode(self.config_mode) as config_session:
+            config_session.send_command("no logging console", ConfigCommandMode.PROMPT)

cloudshell_networking_cisco-7.1.0/cloudshell/networking/cisco/cli/cisco_command_modes.py

@@ -0,0 +1,150 @@
+#!/usr/bin/python
+
+import re
+import time
+from collections import OrderedDict
+
+from cloudshell.cli.service.command_mode import CommandMode
+
+
+class DefaultCommandMode(CommandMode):
+    PROMPT = r">\s*$"
+    ENTER_COMMAND = ""
+    EXIT_COMMAND = ""
+
+    def __init__(self, enable_password: str):
+        """Initialize Default command mode.
+
+        Only for cases when session started not in enable mode
+        """
+        self.enable_password = enable_password
+
+        CommandMode.__init__(
+            self,
+            DefaultCommandMode.PROMPT,
+            DefaultCommandMode.ENTER_COMMAND,
+            DefaultCommandMode.EXIT_COMMAND,
+            enter_action_map=self.enter_action_map(),
+            exit_action_map=self.exit_action_map(),
+            enter_error_map=self.enter_error_map(),
+            exit_error_map=self.exit_error_map(),
+        )
+
+    def enter_action_map(self):
+        return OrderedDict()
+
+    def enter_error_map(self):
+        return OrderedDict()
+
+    def exit_action_map(self):
+        return OrderedDict()
+
+    def exit_error_map(self):
+        return OrderedDict()
+
+
+class EnableCommandMode(CommandMode):
+    PROMPT = r"(?:(?!\)).)#\s*$"
+    ENTER_COMMAND = "enable"
+    EXIT_COMMAND = ""
+
+    def __init__(self, enable_password: str):
+        """Initialize Enable command mode - default command mode for Cisco Shells."""
+        self.enable_password = enable_password
+
+        CommandMode.__init__(
+            self,
+            EnableCommandMode.PROMPT,
+            EnableCommandMode.ENTER_COMMAND,
+            EnableCommandMode.EXIT_COMMAND,
+            enter_action_map=self.enter_action_map(),
+            exit_action_map=self.exit_action_map(),
+            enter_error_map=self.enter_error_map(),
+            exit_error_map=self.exit_error_map(),
+        )
+
+    def enter_action_map(self):
+        return {
+            "[Pp]assword": lambda session, logger: session.send_line(
+                self.enable_password, logger
+            )
+        }
+
+    def enter_error_map(self):
+        return OrderedDict()
+
+    def exit_action_map(self):
+        return OrderedDict()
+
+    def exit_error_map(self):
+        return OrderedDict()
+
+
+class ConfigCommandMode(CommandMode):
+    MAX_ENTER_CONFIG_MODE_RETRIES = 5
+    ENTER_CONFIG_RETRY_TIMEOUT = 5
+    PROMPT = r"\(config.*\)#\s*$"
+    ENTER_COMMAND = "configure terminal"
+    EXIT_COMMAND = "exit"
+    ENTER_ACTION_COMMANDS = []
+
+    def __init__(self, enable_password: str):
+        """Initialize Config command mode."""
+        self.enable_password = enable_password
+
+        CommandMode.__init__(
+            self,
+            ConfigCommandMode.PROMPT,
+            ConfigCommandMode.ENTER_COMMAND,
+            ConfigCommandMode.EXIT_COMMAND,
+            enter_action_map=self.enter_action_map(),
+            exit_action_map=self.exit_action_map(),
+            enter_error_map=self.enter_error_map(),
+            exit_error_map=self.exit_error_map(),
+        )
+
+    def enter_action_map(self):
+        return {rf"{EnableCommandMode.PROMPT}.*$": self._check_config_mode}
+
+    def enter_error_map(self):
+        return OrderedDict()
+
+    def exit_error_map(self):
+        return OrderedDict()
+
+    def exit_action_map(self):
+        return {self.PROMPT: lambda session, logger: session.send_line("exit", logger)}
+
+    def enter_actions(self, cli_service):
+        for cmd in self.ENTER_ACTION_COMMANDS:
+            cli_service.send_command(cmd)
+
+    def _check_config_mode(self, session, logger):
+        error_message = "Failed to enter config mode, please check logs, for details"
+        output = session.hardware_expect(
+            "",
+            expected_string="{}|{}".format(
+                EnableCommandMode.PROMPT, ConfigCommandMode.PROMPT
+            ),
+            logger=logger,
+        )
+        retry = 0
+        while (
+            not re.search(ConfigCommandMode.PROMPT, output)
+        ) and retry < self.MAX_ENTER_CONFIG_MODE_RETRIES:
+            output = session.hardware_expect(
+                ConfigCommandMode.ENTER_COMMAND,
+                expected_string="{}|{}".format(
+                    EnableCommandMode.PROMPT, ConfigCommandMode.PROMPT
+                ),
+                logger=logger,
+            )
+            time.sleep(self.ENTER_CONFIG_RETRY_TIMEOUT)
+            retry += 1
+        if not re.search(ConfigCommandMode.PROMPT, output):
+            raise Exception(error_message)
+
+
+CommandMode.RELATIONS_DICT = {
+    DefaultCommandMode: {EnableCommandMode: {ConfigCommandMode: {}}}
+}

cloudshell_networking_cisco-7.1.0/cloudshell/networking/cisco/command_actions/__init__.py

@@ -0,0 +1,3 @@
+from pkgutil import extend_path
+
+__path__ = extend_path(__path__, __name__)