def test_connect_timeout(self):
self._instance = SSHSession('bad_host',
'user1',
'password1',
on_session_start=self._on_session_start)
with self.assertRaises(SSHSessionException):
self._instance.connect('>', logger=Mock())
def test_connect_timeout(self):
self._instance = SSHSession("bad_host",
"user1",
"password1",
on_session_start=self._on_session_start)
with self.assertRaises(SSHSessionException):
self._instance.connect(">", logger=Mock())
def test_eq_rsa(self, expect_session):
pkey = paramiko.RSAKey.from_private_key(StringIO(KEY_WITH_PASSPHRASE),
password=KEY_PASSPHRASE)
self._instance = SSHSession(
self._hostname,
self._username,
self._password,
port=self._port,
on_session_start=self._on_session_start,
pkey=pkey,
)
self.assertTrue(
self._instance.__eq__(
SSHSession(
self._hostname,
self._username,
self._password,
port=self._port,
on_session_start=self._on_session_start,
pkey=pkey,
)))
self.assertFalse(
self._instance.__eq__(
SSHSession(
self._hostname,
self._username,
self._password,
port=self._port,
on_session_start=self._on_session_start,
)))
def test_username_password(self):
server = SSHServer(user2password={'user1': 'password1'})
self._instance = SSHSession('127.0.0.1',
'user1',
'password1',
port=server.port,
on_session_start=self._on_session_start)
self._instance.connect('>', logger=Mock())
self._instance.hardware_expect('dummy command', '>', Mock())
def test_connect_simple(self):
pkey = paramiko.RSAKey.from_private_key(
StringIO(KEY_WITH_PASSPHRASE), password=KEY_PASSPHRASE) # unused
server = SSHServer(user2key={'user-1', pkey},
user2password={'user0': 'password0'})
self._instance = SSHSession('127.0.0.1',
'user0',
'password0',
port=server.port,
on_session_start=self._on_session_start)
self._instance.connect('>', logger=Mock())
self._instance.hardware_expect('dummy command', '>', Mock())
def test_username_password(self):
server = SSHServer(user2password={"user1": "password1"})
self._instance = SSHSession(
"127.0.0.1",
"user1",
"password1",
port=server.port,
on_session_start=self._on_session_start,
)
self._instance.connect(">", logger=Mock())
self._instance.hardware_expect("dummy command", ">", Mock())
def test_upload_sftp(self):
server = SSHServer(user2password={'user0': 'password0'},
enable_sftp=True,
enable_scp=False)
self._instance = SSHSession('127.0.0.1',
'user0',
'password0',
port=server.port,
on_session_start=self._on_session_start)
self._instance.connect('>', logger=Mock())
self._instance.upload_sftp(StringIO('klmno'), 'z.txt', 5, '0601')
self.assertTrue(
server.filename2stringio['z.txt'].getvalue() == 'klmno')
def test_init_attributes(self, connection_params, expect_session):
self._instance = SSHSession(self._hostname,
self._username,
self._password,
port=self._port,
on_session_start=self._on_session_start)
mandatory_attributes = [
'username', '_handler', '_current_channel', 'password',
'_buffer_size'
]
self.assertEqual(
len(
set(mandatory_attributes).difference(
set(self._instance.__dict__.keys()))), 0)
def test_connect_simple(self):
pkey = paramiko.RSAKey.from_private_key(
StringIO(KEY_WITH_PASSPHRASE), password=KEY_PASSPHRASE) # unused
server = SSHServer(user2key={"user-1", pkey},
user2password={"user0": "password0"})
self._instance = SSHSession(
"127.0.0.1",
"user0",
"password0",
port=server.port,
on_session_start=self._on_session_start,
)
self._instance.connect(">", logger=Mock())
self._instance.hardware_expect("dummy command", ">", Mock())
def test_rsa(self):
pkey = paramiko.RSAKey.from_private_key(StringIO(KEY_WITH_PASSPHRASE),
password=KEY_PASSPHRASE)
server = SSHServer(user2key={'user4': pkey})
self._instance = SSHSession('127.0.0.1',
'user4',
'',
port=server.port,
on_session_start=self._on_session_start,
pkey=pkey)
self._instance.connect('>', logger=Mock())
self._instance.hardware_expect('dummy command', '>', Mock())
def test_upload_sftp(self):
server = SSHServer(user2password={"user0": "password0"},
enable_sftp=True,
enable_scp=False)
self._instance = SSHSession(
"127.0.0.1",
"user0",
"password0",
port=server.port,
on_session_start=self._on_session_start,
)
self._instance.connect(">", logger=Mock())
self._instance.upload_sftp(StringIO(u"klmno"), "z.txt", 5, "0601")
self.assertTrue(
server.filename2stringio["z.txt"].getvalue() == "klmno")
def test_rsa(self):
pkey = paramiko.RSAKey.from_private_key(StringIO(KEY_WITH_PASSPHRASE),
password=KEY_PASSPHRASE)
server = SSHServer(user2key={"user4": pkey})
self._instance = SSHSession(
"127.0.0.1",
"user4",
"",
port=server.port,
on_session_start=self._on_session_start,
pkey=pkey,
)
self._instance.connect(">", logger=Mock())
self._instance.hardware_expect("dummy command", ">", Mock())
def send_any_cmd(self, context, sendcmd):
"""
:param InitCommandContext context : passed in by cloudshell
:param str sendcmd: the command to send to the CLI
"""
cli = CLI()
mode = CommandMode(r'#') # for example r'%\s*$'
session = CloudShellAPISession(
host=context.connectivity.server_address,
token_id=context.connectivity.admin_auth_token,
domain=context.reservation.domain)
address = context.resource.address
user = context.resource.attributes['LinuxServerShell.User']
password = session.DecryptPassword(
context.resource.attributes['LinuxServerShell.Password']).Value
session_types = [
SSHSession(host=address, username=user, password=password)
]
with cli.get_session(session_types, mode) as default_session:
out = default_session.send_command(sendcmd)
print(out)
return out
def test_connect_actions(self):
# Setup
on_session_start = Mock()
self._instance = SSHSession(
"127.0.0.1",
"user0",
"password0",
port=22,
on_session_start=on_session_start,
)
self._instance.hardware_expect = Mock(return_value="Done")
self._instance._handler = Mock()
# Act
self._instance._connect_actions(">", logger=Mock())
# Assert
self._instance.hardware_expect.assert_called_once()
on_session_start.assert_called_once()
def _console_ssh_session(self):
console_port = int(self.resource_config.console_port)
session = SSHSession(
self.resource_config.console_server_ip_address,
self.username,
self.password,
console_port,
self.on_session_start,
)
return session
def __init__(self, host, username, password):
self.cli = CLI()
self.mode = CommandMode(r'#') # for example r'%\s*$'
self.session_types = [
SSHSession(host=host, username=username, password=password)
]
self.session = self.cli.get_session(command_mode=self.mode,
new_sessions=self.session_types)
def test_enable_exit(self):
server = SSHServer(user2password={'user1': 'password1'})
self._instance = SSHSession('127.0.0.1',
'user1',
'password1',
port=server.port,
on_session_start=self._on_session_start)
self._instance.connect('>', logger=Mock())
o = self._instance.hardware_expect('dummy command', '>', Mock())
self.assertTrue('[prompt]' in o)
o = self._instance.hardware_expect('enable', '>', Mock())
self.assertTrue('[enable]' in o)
o = self._instance.hardware_expect('dummy command', '>', Mock())
self.assertTrue('[enable]' in o)
o = self._instance.hardware_expect('exit', '>', Mock())
self.assertTrue('[prompt]' in o)
o = self._instance.hardware_expect('dummy command', '>', Mock())
self.assertTrue('[prompt]' in o)
def test_intialize_session(self, mock_paramiko):
# Setup
mock_paramiko.SSHClient.return_value = Mock()
self._instance = SSHSession(
"127.0.0.1",
"user0",
"password0",
port=22,
on_session_start=self._on_session_start,
)
self._instance.hardware_expect = Mock(return_value="Done")
# Act
self._instance._initialize_session(">", logger=Mock())
# Assert
self.assertIsNotNone(self._instance._handler)
self.assertEqual(self._instance._handler,
mock_paramiko.SSHClient.return_value)
def test_init_attributes(self):
self._instance = SSHSession(
self._hostname,
self._username,
self._password,
port=self._port,
on_session_start=self._on_session_start,
)
mandatory_attributes = [
"username",
"_handler",
"_current_channel",
"password",
"_buffer_size",
]
self.assertEqual(
len(
set(mandatory_attributes).difference(
set(self._instance.__dict__.keys()))),
0,
)
def test_enable_exit(self):
server = SSHServer(user2password={"user1": "password1"})
self._instance = SSHSession(
"127.0.0.1",
"user1",
"password1",
port=server.port,
on_session_start=self._on_session_start,
)
self._instance.connect(">", logger=Mock())
o = self._instance.hardware_expect("dummy command", ">", Mock())
self.assertTrue("[prompt]" in o)
o = self._instance.hardware_expect("enable", ">", Mock())
self.assertTrue("[enable]" in o)
o = self._instance.hardware_expect("dummy command", ">", Mock())
self.assertTrue("[enable]" in o)
o = self._instance.hardware_expect("exit", ">", Mock())
self.assertTrue("[prompt]" in o)
o = self._instance.hardware_expect("dummy command", ">", Mock())
self.assertTrue("[prompt]" in o)
def __init__(self, host, username, password):
self.cli = CLI()
self.mode = CommandMode(r'#')# for example r'%\s*$'
self.clish_mode = CommandMode(r'>', enter_command='clish', exit_command='exit')# for example r'%\s*$'
self.mode.add_child_node(self.clish_mode)
self.session_types = [SSHSession(host=host,
username=username,
password=password)]
self.session = self.cli.get_session(command_mode=self.mode,
new_sessions=self.session_types)
def _set_session_types(self):
self._cs_session_handler()
if self.connection_type == 'Auto':
self.session_types = [
SSHSession(host=self.address,
username=self.user,
password=self.cs_session.DecryptPassword(
self.password_hash).Value),
TelnetSession(host=self.address,
username=self.user,
password=self.cs_session.DecryptPassword(
self.password_hash).Value)
]
elif self.connection_type == 'Console':
message = 'Unimplemented CLI Connection Type: "%s"' % self.connection_type
self.logger.error(message)
raise Cli.UnImplementedCliConnectionType(message)
elif self.connection_type == 'SSH':
self.session_types = [
SSHSession(host=self.address,
username=self.user,
password=self.cs_session.DecryptPassword(
self.password_hash).Value)
]
elif self.connection_type == 'TCP':
message = 'Unimplemented CLI Connection Type: "%s"' % self.connection_type
self.logger.error(message)
raise Cli.UnImplementedCliConnectionType(message)
elif self.connection_type == 'Telnet':
self.session_types = [
TelnetSession(host=self.address,
username=self.user,
password=self.cs_session.DecryptPassword(
self.password_hash).Value)
]
else:
message = 'Unsupported CLI Connection Type: "%s"' % self.connection_type
self.logger.error(message)
raise Cli.UnSupportedCliConnectionType(message)
def _cli_session_handler(self, context):
self._cs_session_handler(context)
logger = LogHelper.get_logger(context)
self.cli_connection_type = context.resource.attributes['CLI Connection Type']
self.cli_prompt_regex = context.resource.attributes['CLI Prompt Regular Expression']
self.mode = CommandMode(self.cli_prompt_regex)
self.session_types = None
logger.info('CLI Connection Type: "%s"' % self.cli_connection_type)
logger.info('CLI Prompt Regular Expression: "%s"' % self.cli_prompt_regex)
if self.cli_connection_type == 'Auto':
self.session_types = [SSHSession(host=self.address,
username=self.user,
password=self.cs_session.DecryptPassword(self.password_hash).Value),
TelnetSession(host=self.address,
username=self.user,
password=self.cs_session.DecryptPassword(self.password_hash).Value)]
elif self.cli_connection_type == 'Console':
message = 'Unimplemented CLI Connection Type: "%s"' % self.cli_connection_type
logger.error(message)
raise GenericResourceDriver.UnImplementedCliConnectionType(message)
elif self.cli_connection_type == 'SSH':
self.session_types = [SSHSession(host=self.address,
username=self.user,
password=self.cs_session.DecryptPassword(self.password_hash).Value)]
elif self.cli_connection_type == 'TCP':
message = 'Unimplemented CLI Connection Type: "%s"' % self.cli_connection_type
logger.error(message)
raise GenericResourceDriver.UnImplementedCliConnectionType(message)
elif self.cli_connection_type == 'Telnet':
self.session_types = [TelnetSession(host=self.address,
username=self.user,
password=self.cs_session.DecryptPassword(self.password_hash).Value)]
else:
message = 'Unsupported CLI Connection Type: "%s"' % self.cli_connection_type
logger.error(message)
raise GenericResourceDriver.UnSupportedCliConnectionType(message)
def create_my_session(self):
cli = CLI()
mode = CommandMode(r'%\s*$#') # for example r'%\s*$'
ip_address = '192.16.42.235'
user_name = 'root'
password = '******'
session_types = [SSHSession(host=ip_address,
username=user_name,
password=password)]
with cli.get_session(session_types, mode) as default_session:
out = default_session.send_command('my command')
print(out)
def __init__(self, host, username, password, logger=None):
self.cli = CLI()
self.logger = logger
# the mode is the termination string - code will expect a"$" sign in this case to mark an end of input.
self.mode = CommandMode(r'$')
# 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.elevated_mode, new_sessions=self.session_types)
self.session = self.cli.get_session(command_mode=self.mode, new_sessions=self.session_types)
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, host, username, password, logger=None):
self.cli = CLI()
self.logger = logger
self.mode = CommandMode(r'$') # 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.elevated_mode,
new_sessions=self.session_types)
def _get_device_session(self, context):
"""
:param context:
:return:
"""
session = get_api(context)
config = Linuxshell(
name=context.resource.name).create_from_context(context)
host = context.resource.address
username = config.user
password = session.DecryptPassword(config.password).Value
cli = CLI()
mode = CommandMode(prompt=r'.*\$')
session_types = [
SSHSession(host=host, username=username, password=password)
]
device_session = cli.get_session(session_types, mode)
return device_session
def __init__(self, *args, **kwargs):
"""Initiate console connection, by default open ssh to 22 port and login to console server
:param args:
:param kwargs: 'console_server_ip', 'console_server_user', 'console_server_password', 'console_port' mandatory'
:return:
"""
ExpectSession.__init__(self, None, *args, **kwargs)
self._console_username = kwargs['console_server_user']
self._console_password = kwargs['console_server_password']
self._console_host = kwargs['console_server_ip']
self._session_handler = SSHSession(self._console_username,
self._console_password,
self._console_host,
port=22,
logger=self.logger)
self._console_port = kwargs['console_port']
class TestSshSession(TestCase):
def setUp(self):
self._username = "******"
self._password = "******"
self._hostname = "hostname"
self._port = 22
self._on_session_start = Mock()
def test_init_attributes(self):
self._instance = SSHSession(
self._hostname,
self._username,
self._password,
port=self._port,
on_session_start=self._on_session_start,
)
mandatory_attributes = [
"username",
"_handler",
"_current_channel",
"password",
"_buffer_size",
]
self.assertEqual(
len(
set(mandatory_attributes).difference(
set(self._instance.__dict__.keys()))),
0,
)
@patch("cloudshell.cli.session.ssh_session.ExpectSession")
def test_eq(self, expect_session):
self._instance = SSHSession(
self._hostname,
self._username,
self._password,
port=self._port,
on_session_start=self._on_session_start,
)
self.assertTrue(
self._instance.__eq__(
SSHSession(
self._hostname,
self._username,
self._password,
port=self._port,
on_session_start=self._on_session_start,
)))
self.assertFalse(
self._instance.__eq__(
SSHSession(
self._hostname,
"incorrect_username",
self._password,
port=self._port,
on_session_start=self._on_session_start,
)))
self.assertFalse(
self._instance.__eq__(
SSHSession(
self._hostname,
self._username,
"incorrect_password",
port=self._port,
on_session_start=self._on_session_start,
)))
pkey = paramiko.RSAKey.from_private_key(StringIO(KEY_WITH_PASSPHRASE),
password=KEY_PASSPHRASE)
self.assertFalse(
self._instance.__eq__(
SSHSession(
self._hostname,
self._username,
"",
port=self._port,
on_session_start=self._on_session_start,
pkey=pkey,
)))
@patch("cloudshell.cli.session.ssh_session.ExpectSession")
def test_eq_rsa(self, expect_session):
pkey = paramiko.RSAKey.from_private_key(StringIO(KEY_WITH_PASSPHRASE),
password=KEY_PASSPHRASE)
self._instance = SSHSession(
self._hostname,
self._username,
self._password,
port=self._port,
on_session_start=self._on_session_start,
pkey=pkey,
)
self.assertTrue(
self._instance.__eq__(
SSHSession(
self._hostname,
self._username,
self._password,
port=self._port,
on_session_start=self._on_session_start,
pkey=pkey,
)))
self.assertFalse(
self._instance.__eq__(
SSHSession(
self._hostname,
self._username,
self._password,
port=self._port,
on_session_start=self._on_session_start,
)))
@patch("cloudshell.cli.session.ssh_session.paramiko")
def test_intialize_session(self, mock_paramiko):
# Setup
mock_paramiko.SSHClient.return_value = Mock()
self._instance = SSHSession(
"127.0.0.1",
"user0",
"password0",
port=22,
on_session_start=self._on_session_start,
)
self._instance.hardware_expect = Mock(return_value="Done")
# Act
self._instance._initialize_session(">", logger=Mock())
# Assert
self.assertIsNotNone(self._instance._handler)
self.assertEqual(self._instance._handler,
mock_paramiko.SSHClient.return_value)
def test_connect_actions(self):
# Setup
on_session_start = Mock()
self._instance = SSHSession(
"127.0.0.1",
"user0",
"password0",
port=22,
on_session_start=on_session_start,
)
self._instance.hardware_expect = Mock(return_value="Done")
self._instance._handler = Mock()
# Act
self._instance._connect_actions(">", logger=Mock())
# Assert
self._instance.hardware_expect.assert_called_once()
on_session_start.assert_called_once()
def test_connect_simple(self):
pkey = paramiko.RSAKey.from_private_key(
StringIO(KEY_WITH_PASSPHRASE), password=KEY_PASSPHRASE) # unused
server = SSHServer(user2key={"user-1", pkey},
user2password={"user0": "password0"})
self._instance = SSHSession(
"127.0.0.1",
"user0",
"password0",
port=server.port,
on_session_start=self._on_session_start,
)
self._instance.connect(">", logger=Mock())
self._instance.hardware_expect("dummy command", ">", Mock())
def test_upload_sftp(self):
server = SSHServer(user2password={"user0": "password0"},
enable_sftp=True,
enable_scp=False)
self._instance = SSHSession(
"127.0.0.1",
"user0",
"password0",
port=server.port,
on_session_start=self._on_session_start,
)
self._instance.connect(">", logger=Mock())
self._instance.upload_sftp(StringIO(u"klmno"), "z.txt", 5, "0601")
self.assertTrue(
server.filename2stringio["z.txt"].getvalue() == "klmno")
def test_upload_scp(self):
server = SSHServer(user2password={"user0": "password0"},
enable_sftp=False,
enable_scp=True)
self._instance = SSHSession(
"127.0.0.1",
"user0",
"password0",
port=server.port,
on_session_start=self._on_session_start,
)
self._instance.connect(">", logger=Mock())
self._instance.upload_scp(StringIO(u"abcde"), "y.txt", 5, "0601")
sleep(3)
self.assertTrue(
server.filename2stringio["y.txt"].getvalue() == "abcde")
def test_connect_timeout(self):
self._instance = SSHSession("bad_host",
"user1",
"password1",
on_session_start=self._on_session_start)
with self.assertRaises(SSHSessionException):
self._instance.connect(">", logger=Mock())
def test_username_password(self):
server = SSHServer(user2password={"user1": "password1"})
self._instance = SSHSession(
"127.0.0.1",
"user1",
"password1",
port=server.port,
on_session_start=self._on_session_start,
)
self._instance.connect(">", logger=Mock())
self._instance.hardware_expect("dummy command", ">", Mock())
def test_enable_exit(self):
server = SSHServer(user2password={"user1": "password1"})
self._instance = SSHSession(
"127.0.0.1",
"user1",
"password1",
port=server.port,
on_session_start=self._on_session_start,
)
self._instance.connect(">", logger=Mock())
o = self._instance.hardware_expect("dummy command", ">", Mock())
self.assertTrue("[prompt]" in o)
o = self._instance.hardware_expect("enable", ">", Mock())
self.assertTrue("[enable]" in o)
o = self._instance.hardware_expect("dummy command", ">", Mock())
self.assertTrue("[enable]" in o)
o = self._instance.hardware_expect("exit", ">", Mock())
self.assertTrue("[prompt]" in o)
o = self._instance.hardware_expect("dummy command", ">", Mock())
self.assertTrue("[prompt]" in o)
def test_rsa(self):
pkey = paramiko.RSAKey.from_private_key(StringIO(KEY_WITH_PASSPHRASE),
password=KEY_PASSPHRASE)
server = SSHServer(user2key={"user4": pkey})
self._instance = SSHSession(
"127.0.0.1",
"user4",
"",
port=server.port,
on_session_start=self._on_session_start,
pkey=pkey,
)
self._instance.connect(">", logger=Mock())
self._instance.hardware_expect("dummy command", ">", Mock())
def test_rsa_failure(self):
pkey = paramiko.RSAKey.from_private_key(StringIO(KEY_WITH_PASSPHRASE),
password=KEY_PASSPHRASE)
server = SSHServer(user2key={})
with self.assertRaises(SSHSessionException):
self._instance = SSHSession(
"127.0.0.1",
"user5",
"",
port=server.port,
on_session_start=self._on_session_start,
pkey=pkey,
)
self._instance.connect(">", logger=Mock())
self._instance.hardware_expect("dummy command", ">", Mock())
