def __init__(self, host, username, password, logger=None):
"""
:param host:
:param username:
:param password:
:param logger:
"""
self.cli = CLI()
self.logger = logger
self.mode = CommandMode(
prompt=self.COMMAND_MODE_PROMPT) # for example r'%\s*$'
self.session_types = [
SSHSession(host=host, username=username, password=password)
]
self.session = self.cli.get_session(
command_mode=self.mode, defined_sessions=self.session_types)
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 DeleteInstance(self, context, ports):
"""
Called during sandbox's teardown or when removing a deployed App from the sandbox
Method deletes the VM from the cloud provider.
If the operation fails, method should raise an exception.
:param ResourceRemoteCommandContext context:
:param ports:
"""
with LoggingSessionContext(context) as logger:
api = CloudShellSessionContext(context).get_api()
resource_config = JuniperCPResourceConfig.from_context(
self.SHELL_NAME, context, api, self.SUPPORTED_OS)
cli_configurator = JuniperCliConfigurator(CLI(self._session_pool),
resource_config, logger)
ls_flow = CreateRemoveLSFlow(cli_configurator, logger)
for endpoint in context.remote_endpoints:
res_details = api.GetResourceDetails(endpoint.name)
ls_name = self._extract_attribute(
res_details.VmDetails.InstanceData, self.ATTRIBUTE.LS_NAME)
ls_flow.remove_ls(ls_name)
def set_up(self):
ConfigCommandMode.ENTER_CONFIG_RETRY_TIMEOUT = 0.5
api = MagicMock(DecryptPassword=lambda password: MagicMock(Value=password))
cli_conf = GenericCLIConfig("Cisco Shell", api=api)
cli_conf.cli_tcp_port = "22"
cli_conf.cli_connection_type = "SSH"
return CiscoCliHandler(CLI(), cli_conf, Mock())
def __init__(self, host, username, password, logger=None, base_mode="#"):
self.cli = CLI()
self.logger = logger
self.mode = CommandMode(fr'{base_mode}') # for example r'%\s*$'
enable_action_map = {
"[Pp]assword for {}".format(username):
lambda session, logger: session.send_line(password, logger)
}
self.elevated_mode = CommandMode(r'(?:(?!\)).)#\s*$',
enter_command='sudo su',
exit_command='exit',
enter_action_map=enable_action_map)
self.mode.add_child_node(self.elevated_mode)
self.elevated_mode.add_parent_mode(self.mode)
self.session_types = [
SSHSession(host=host, username=username, password=password)
]
self.session = self.cli.get_session(
command_mode=self.mode, defined_sessions=self.session_types)
def initialize(self, context):
"""Initialize the driver session.
:param context: the context the command runs on
:rtype: str
"""
resource_config = FirewallResourceConfig.from_context(self.SHELL_NAME, context)
session_pool_size = int(resource_config.sessions_concurrency_limit)
self._cli = CLI(
SessionPoolManager(max_pool_size=session_pool_size, pool_timeout=100)
)
return "Finished initializing"
class SSHHandler:
def __init__(self, ip, user, password, prompt="#"):
self.cli = CLI()
self.mode = CommandMode(prompt)
self.session_types = [
SSHSession(host=ip, username=user, password=password)
]
def send_command(self, command):
with self.cli.get_session(self.session_types,
self.mode) as cli_service:
output = cli_service.send_command(command)
return output
def __init__(self,
resource_config,
logger,
cli=None,
registered_sessions=None):
"""Initialize CLI service configurator.
:param cloudshell.shell.standards.resource_config_generic_models.GenericCLIConfig resource_config: # noqa: E501
:param logging.Logger logger:
:param cloudshell.cli.service.cli.CLI cli:
:param registered_sessions: Session types and order
"""
self._cli = cli or CLI()
self._resource_config = resource_config
self._logger = logger
self._registered_sessions = registered_sessions or self.REGISTERED_SESSIONS
class CreateSession():
def __init__(self, host, username, password, logger=None, base_mode="#"):
self.cli = CLI()
self.logger = logger
self.mode = CommandMode(fr'{base_mode}') # for example r'%\s*$'
enable_action_map = {
"[Pp]assword for {}".format(username):
lambda session, logger: session.send_line(password, logger)
}
self.elevated_mode = CommandMode(r'(?:(?!\)).)#\s*$',
enter_command='sudo su',
exit_command='exit',
enter_action_map=enable_action_map)
self.mode.add_child_node(self.elevated_mode)
self.elevated_mode.add_parent_mode(self.mode)
self.session_types = [
SSHSession(host=host, username=username, password=password)
]
self.session = self.cli.get_session(
command_mode=self.mode, defined_sessions=self.session_types)
def send_terminal_command(self, command, password=None):
outp = []
out = None
with self.session as my_session:
if isinstance(command, list):
for single_command in command:
if password:
single_command = '{command}'.format(
command=single_command, password=password)
# single_command = 'echo {password} | sudo -S sh -c "{command}"'.format(command=single_command,
# password=password)
self.logger.info(
'sending command {}'.format(single_command))
current_outp = my_session.send_command(single_command)
outp.append(current_outp)
self.logger.info('got output {}'.format(current_outp))
out = '\n'.join(outp)
else:
if password:
command = '{command}'.format(command=command)
out = my_session.send_command(command)
return out
def _setUp(self, attrs=None):
if attrs is None:
attrs = {}
self.logger = MagicMock()
self.api = MagicMock(DecryptPassword=lambda password: MagicMock(Value=password))
self.resource_config = NetworkingResourceConfig.from_context(
self.SHELL_NAME,
self.create_context(attrs),
self.api,
self.SUPPORTED_OS,
)
self._cli = CLI(
SessionPoolManager(
max_pool_size=int(self.resource_config.sessions_concurrency_limit)
)
)
self.cli_configurator = AristaCLIConfigurator(
self.resource_config, self.api, self.logger, self._cli
)
class CreateSession():
COMMAND_MODE_PROMPT = r'#'
def __init__(self, host, username, password, logger=None):
"""
:param host:
:param username:
:param password:
:param logger:
"""
self.cli = CLI()
self.logger = logger
self.mode = CommandMode(
prompt=self.COMMAND_MODE_PROMPT) # for example r'%\s*$'
self.session_types = [
SSHSession(host=host, username=username, password=password)
]
self.session = self.cli.get_session(
command_mode=self.mode, defined_sessions=self.session_types)
def send_terminal_command(self,
single_command,
action_map=None,
error_map=None):
"""
:param str single_command:
:return:
"""
if not isinstance(single_command, str):
raise Exception(
"Expected string input for command. Received type {}, {}.".
format(type(single_command), str(single_command)))
with self.session as my_session:
outp = self._send_single_command(my_session, single_command,
action_map, error_map)
return r"{}".format(outp)
def send_commands_list(self, commands_list):
"""
iterate over list and return concatenated output
:param list commands_list:
:return:
"""
if not isinstance(commands_list, list):
raise Exception(
"this method accepts a list. Input: {}".format(commands_list))
multi_command_outp = []
with self.session as my_session:
if isinstance(commands_list, list):
for single_command in commands_list:
outp = self._send_single_command(my_session,
single_command)
multi_command_outp.append(outp)
final_outp = '\n'.join(multi_command_outp)
return r"{}".format(final_outp)
def _send_single_command(self,
session,
single_command,
action_map=None,
error_map=None):
"""
:param session:
:param single_command:
:return:
"""
single_command = '{}'.format(single_command)
if self.logger:
self.logger.info('sending command {}'.format(single_command))
current_outp = session.send_command(single_command,
action_map=action_map,
error_map=error_map)
if self.logger:
self.logger.info('got output {}'.format(current_outp))
return current_outp
def setUp(self):
AristaConfigCommandMode.ENTER_CONFIG_RETRY_TIMEOUT = 0.5
self.api = MagicMock()
self.api.DecryptPassword().Value.return_value = "password"
self._cli = CLI()
def Deploy(self, context, request, cancellation_context=None):
"""
Called when reserving a sandbox during setup, a call for each app in the sandbox.
Method creates the compute resource in the cloud provider - VM instance or container.
If App deployment fails, return a "success false" action result.
:param ResourceCommandContext context:
:param str request: A JSON string with the list of requested deployment actions
:param CancellationContext cancellation_context:
:return:
:rtype: str
"""
'''
# parse the json strings into action objects
actions = self.request_parser.convert_driver_request_to_actions(request)
# extract DeployApp action
deploy_action = single(actions, lambda x: isinstance(x, DeployApp))
# if we have multiple supported deployment options use the 'deploymentPath' property
# to decide which deployment option to use.
deployment_name = deploy_action.actionParams.deployment.deploymentPath
deploy_result = _my_deploy_method(context, actions, cancellation_context)
return DriverResponse(deploy_result).to_driver_response_json()
'''
with LoggingSessionContext(context) as logger:
logger.info(request)
api = CloudShellSessionContext(context).get_api()
resource_config = JuniperCPResourceConfig.from_context(
self.SHELL_NAME, context, api, self.SUPPORTED_OS)
cli_configurator = JuniperCliConfigurator(CLI(self._session_pool),
resource_config, logger)
ls_flow = CreateRemoveLSFlow(cli_configurator, logger)
actions = DriverRequestParser().convert_driver_request_to_actions(
request)
reservation_details = api.GetReservationDetails(
context.reservation.reservation_id,
disableCache=True).ReservationDescription
results = []
for deploy_action in actions:
app_name = deploy_action.actionParams.appName
int_list = self._get_int_names(reservation_details, app_name)
logger.info("{}:{}".format(app_name, str(int_list)))
if not int_list:
raise Exception(
"Failed to deploy Logical System without interfaces. "
"Please create appropriate connections")
vm_uuid = self._build_uuid(app_name,
context.reservation.reservation_id)
ls_name = "VR-{}".format(vm_uuid)
vm_name = "{}-{}".format(app_name, ls_name)
int_list = ls_flow.create_ls(ls_name, int_list)
vm_instance_data = [
VmDetailsProperty(self.ATTRIBUTE.INST_UUID, vm_uuid),
VmDetailsProperty(self.ATTRIBUTE.LS_NAME, ls_name),
]
vm_interfaces_data = [
VmDetailsProperty("vNIC {} Name".format(i), int_list[i])
for i in range(len(int_list))
]
vm_instance_data.extend(vm_interfaces_data)
deploy_result = DeployAppResult(
actionId=deploy_action.actionId,
infoMessage="Deployment Completed Successfully",
vmUuid=vm_uuid,
vmName=vm_name,
deployedAppAddress="",
deployedAppAttributes=[],
vmDetailsData=VmDetailsData(vm_instance_data))
results.append(deploy_result)
return DriverResponse(results).to_driver_response_json()
from cloudshell.cli.service.cli import CLI
from cloudshell.cli.session.ssh_session import SSHSession
from cloudshell.cli.service.command_mode import CommandMode
host = "192.168.105.40"
username = "******"
password = "******"
cli = CLI()
mode = CommandMode(r'#') # for example r'%\s*$'
session_types = [SSHSession(host=host, username=username, password=password)]
# extract a session from the pool, send the command and return the session to the pool upon completing the "with"
# block:
with cli.get_session(session_types, mode) as cli_service:
out = cli_service.send_command('show interface | no-more')
print(out)
def __init__(self, ip, user, password, prompt="#"):
self.cli = CLI()
self.mode = CommandMode(prompt)
self.session_types = [
SSHSession(host=ip, username=user, password=password)
]
def set_up(self):
ConfigCommandMode.ENTER_CONFIG_RETRY_TIMEOUT = 0.5
cli_conf = MagicMock()
cli_conf.cli_tcp_port = "22"
cli_conf.cli_connection_type = "SSH"
return CiscoCliHandler(CLI(), cli_conf, Mock())
