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())