Python ParallelSSHClient.run_command方法代码示例

# 需要导入模块: from pssh import ParallelSSHClient [as 别名]
# 或者: from pssh.ParallelSSHClient import run_command [as 别名]
 def test_per_host_tuple_args(self):
     server2_socket = make_socket('127.0.0.2', port=self.listen_port)
     server2_port = server2_socket.getsockname()[1]
     server2 = start_server(server2_socket)
     server3_socket = make_socket('127.0.0.3', port=self.listen_port)
     server3_port = server3_socket.getsockname()[1]
     server3 = start_server(server3_socket)
     hosts = [self.host, '127.0.0.2', '127.0.0.3']
     host_args = ('arg1', 'arg2', 'arg3')
     cmd = 'echo %s'
     client = ParallelSSHClient(hosts, port=self.listen_port,
                                pkey=self.user_key)
     output = client.run_command(cmd, host_args=host_args)
     for i, host in enumerate(hosts):
         expected = [host_args[i]]
         stdout = list(output[host]['stdout'])
         self.assertEqual(expected, stdout)
         self.assertTrue(output[host]['exit_code'] == 0)
     host_args = (('arg1', 'arg2'), ('arg3', 'arg4'), ('arg5', 'arg6'),)
     cmd = 'echo %s %s'
     output = client.run_command(cmd, host_args=host_args)
     for i, host in enumerate(hosts):
         expected = ["%s %s" % host_args[i]]
         stdout = list(output[host]['stdout'])
         self.assertEqual(expected, stdout)
         self.assertTrue(output[host]['exit_code'] == 0)
     self.assertRaises(HostArgumentException, client.run_command,
                       cmd, host_args=[host_args[0]])

# 需要导入模块: from pssh import ParallelSSHClient [as 别名]
# 或者: from pssh.ParallelSSHClient import run_command [as 别名]
 def test_pssh_hosts_iterator_hosts_modification(self):
     """Test using iterator as host list and modifying host list in place"""
     server2_socket = make_socket("127.0.0.2", port=self.listen_port)
     server2_port = server2_socket.getsockname()[1]
     server2 = start_server(server2_socket)
     server3_socket = make_socket("127.0.0.3", port=self.listen_port)
     server3_port = server3_socket.getsockname()[1]
     server3 = start_server(server3_socket)
     hosts = [self.host, "127.0.0.2"]
     client = ParallelSSHClient(iter(hosts), port=self.listen_port, pkey=self.user_key, pool_size=1)
     output = client.run_command(self.fake_cmd)
     stdout = [list(output[k]["stdout"]) for k in output]
     expected_stdout = [[self.fake_resp], [self.fake_resp]]
     self.assertEqual(
         len(hosts),
         len(output),
         msg="Did not get output from all hosts. Got output for " "%s/%s hosts" % (len(output), len(hosts)),
     )
     # Run again without re-assigning host list, should do nothing
     output = client.run_command(self.fake_cmd)
     self.assertFalse(hosts[0] in output, msg="Expected no host output, got %s" % (output,))
     self.assertFalse(output, msg="Expected empty output, got %s" % (output,))
     # Re-assigning host list with new hosts should work
     hosts = ["127.0.0.2", "127.0.0.3"]
     client.hosts = iter(hosts)
     output = client.run_command(self.fake_cmd)
     self.assertEqual(
         len(hosts),
         len(output),
         msg="Did not get output from all hosts. Got output for " "%s/%s hosts" % (len(output), len(hosts)),
     )
     self.assertTrue(hosts[1] in output, msg="Did not get output for new host %s" % (hosts[1],))
     del client, server2, server3

# 需要导入模块: from pssh import ParallelSSHClient [as 别名]
# 或者: from pssh.ParallelSSHClient import run_command [as 别名]
 def test_per_host_dict_args(self):
     server2_socket = make_socket('127.0.0.2', port=self.listen_port)
     server2_port = server2_socket.getsockname()[1]
     server2 = start_server(server2_socket)
     server3_socket = make_socket('127.0.0.3', port=self.listen_port)
     server3_port = server3_socket.getsockname()[1]
     server3 = start_server(server3_socket)
     hosts = [self.host, '127.0.0.2', '127.0.0.3']
     hosts_gen = (h for h in hosts)
     host_args = [dict(zip(('host_arg1', 'host_arg2',),
                           ('arg1-%s' % (i,), 'arg2-%s' % (i,),)))
                  for i, _ in enumerate(hosts)]
     cmd = 'echo %(host_arg1)s %(host_arg2)s'
     client = ParallelSSHClient(hosts, port=self.listen_port,
                                pkey=self.user_key)
     output = client.run_command(cmd, host_args=host_args)
     for i, host in enumerate(hosts):
         expected = ["%(host_arg1)s %(host_arg2)s" % host_args[i]]
         stdout = list(output[host]['stdout'])
         self.assertEqual(expected, stdout)
         self.assertTrue(output[host]['exit_code'] == 0)
     self.assertRaises(HostArgumentException, client.run_command,
                       cmd, host_args=[host_args[0]])
     # Host list generator should work also
     client.hosts = hosts_gen
     output = client.run_command(cmd, host_args=host_args)
     for i, host in enumerate(hosts):
         expected = ["%(host_arg1)s %(host_arg2)s" % host_args[i]]
         stdout = list(output[host]['stdout'])
         self.assertEqual(expected, stdout)
         self.assertTrue(output[host]['exit_code'] == 0)
     client.hosts = (h for h in hosts)
     self.assertRaises(HostArgumentException, client.run_command,
                       cmd, host_args=[host_args[0]])

# 需要导入模块: from pssh import ParallelSSHClient [as 别名]
# 或者: from pssh.ParallelSSHClient import run_command [as 别名]
 def test_pssh_client_retries(self):
     """Test connection error retries"""
     expected_num_tries = 2
     client = ParallelSSHClient(['127.0.0.1'], port=self.listen_port,
                                pkey=self.user_key,
                                num_retries=expected_num_tries)
     self.assertRaises(ConnectionErrorException, client.run_command, 'blah')
     try:
         client.run_command('blah')
     except ConnectionErrorException, ex:
         num_tries = ex.args[-1:][0]
         self.assertEqual(expected_num_tries, num_tries,
                          msg="Got unexpected number of retries %s - expected %s"
                          % (num_tries, expected_num_tries,))

# 需要导入模块: from pssh import ParallelSSHClient [as 别名]
# 或者: from pssh.ParallelSSHClient import run_command [as 别名]
 def test_pssh_client_ssh_exception(self):
     listen_socket = make_socket(self.host)
     listen_port = listen_socket.getsockname()[1]
     server = start_server(listen_socket, ssh_exception=True)
     client = ParallelSSHClient(
         [self.host], user="fakey", password="fakey", port=listen_port, pkey=paramiko.RSAKey.generate(1024)
     )
     # Handle exception
     try:
         client.run_command(self.fake_cmd)
         raise Exception("Expected SSHException, got none")
     except SSHException:
         pass
     del client
     server.join()

# 需要导入模块: from pssh import ParallelSSHClient [as 别名]
# 或者: from pssh.ParallelSSHClient import run_command [as 别名]
 def test_pssh_client_hosts_list_part_failure(self):
     """Test getting output for remainder of host list in the case where one
     host in the host list has a failure"""
     server2_socket = make_socket('127.0.0.2', port=self.listen_port)
     server2_port = server2_socket.getsockname()[1]
     server2 = start_server(server2_socket, fail_auth=True)
     hosts = [self.host, '127.0.0.2']
     client = ParallelSSHClient(hosts,
                                port=self.listen_port,
                                pkey=self.user_key,
                                agent=self.agent)
     output = client.run_command(self.fake_cmd,
                                 stop_on_errors=False)
     client.join(output)
     self.assertTrue(hosts[0] in output,
                     msg="Successful host does not exist in output - output is %s" % (output,))
     self.assertTrue(hosts[1] in output,
                     msg="Failed host does not exist in output - output is %s" % (output,))
     self.assertTrue('exception' in output[hosts[1]],
                     msg="Failed host %s has no exception in output - %s" % (hosts[1], output,))
     try:
         raise output[hosts[1]]['exception']
     except AuthenticationException:
         pass
     else:
         raise Exception("Expected AuthenticationException, got %s instead" % (
             output[hosts[1]]['exception'],))
     del client
     server2.kill()

# 需要导入模块: from pssh import ParallelSSHClient [as 别名]
# 或者: from pssh.ParallelSSHClient import run_command [as 别名]
 def test_pssh_client_retries(self):
     """Test connection error retries"""
     listen_socket = make_socket(self.host)
     listen_port = listen_socket.getsockname()[1]
     expected_num_tries = 2
     client = ParallelSSHClient([self.host], port=listen_port,
                                pkey=self.user_key,
                                num_retries=expected_num_tries)
     self.assertRaises(ConnectionErrorException, client.run_command, 'blah')
     try:
         client.run_command('blah')
     except ConnectionErrorException, ex:
         num_tries = ex.args[-1:][0]
         self.assertEqual(expected_num_tries, num_tries,
                          msg="Got unexpected number of retries %s - expected %s"
                          % (num_tries, expected_num_tries,))

# 需要导入模块: from pssh import ParallelSSHClient [as 别名]
# 或者: from pssh.ParallelSSHClient import run_command [as 别名]
 def test_pssh_client_run_command_get_output_explicit(self):
     server = start_server({ self.fake_cmd : self.fake_resp },
                           self.listen_socket)
     client = ParallelSSHClient(['127.0.0.1'], port=self.listen_port,
                                pkey=self.user_key)
     out = client.run_command(self.fake_cmd)
     cmds = [cmd for host in out for cmd in [out[host]['cmd']]]
     output = client.get_output(commands=cmds)
     expected_exit_code = 0
     expected_stdout = [self.fake_resp]
     expected_stderr = []
     exit_code = output['127.0.0.1']['exit_code']
     stdout = list(output['127.0.0.1']['stdout'])
     stderr = list(output['127.0.0.1']['stderr'])
     self.assertEqual(expected_exit_code, exit_code,
                      msg="Got unexpected exit code - %s, expected %s" %
                      (exit_code,
                       expected_exit_code,))
     self.assertEqual(expected_stdout, stdout,
                      msg="Got unexpected stdout - %s, expected %s" % 
                      (stdout,
                       expected_stdout,))
     self.assertEqual(expected_stderr, stderr,
                      msg="Got unexpected stderr - %s, expected %s" % 
                      (stderr,
                       expected_stderr,))
     del client
     server.join()

# 需要导入模块: from pssh import ParallelSSHClient [as 别名]
# 或者: from pssh.ParallelSSHClient import run_command [as 别名]
 def test_ssh_exception(self):
     """Test that we get ssh exception in output with correct arguments"""
     self.server.kill()
     host = '127.0.0.10'
     _socket = make_socket(host)
     port = _socket.getsockname()[1]
     server = start_server(_socket, ssh_exception=True)
     hosts = [host]
     client = ParallelSSHClient(hosts, port=port,
                                user='fakey', password='fakey',
                                pkey=paramiko.RSAKey.generate(1024))
     output = client.run_command(self.fake_cmd, stop_on_errors=False)
     gevent.sleep(.2)
     client.pool.join()
     self.assertTrue('exception' in output[host],
                     msg="Got no exception for host %s - expected connection error" % (
                         host,))
     try:
         raise output[host]['exception']
     except SSHException, ex:
         self.assertEqual(ex.args[1], host,
                          msg="Exception host argument is %s, should be %s" % (
                              ex.args[1], host,))
         self.assertEqual(ex.args[2], port,
                          msg="Exception port argument is %s, should be %s" % (
                              ex.args[2], port,))

# 需要导入模块: from pssh import ParallelSSHClient [as 别名]
# 或者: from pssh.ParallelSSHClient import run_command [as 别名]
 def test_pssh_client_timeout(self):
     server_timeout=0.2
     client_timeout=server_timeout-0.1
     server = start_server({ self.fake_cmd : self.fake_resp },
                           self.listen_socket,
                           timeout=server_timeout)
     client = ParallelSSHClient(['127.0.0.1'], port=self.listen_port,
                                pkey=self.user_key,
                                timeout=client_timeout)
     output = client.run_command(self.fake_cmd)
     # Handle exception
     try:
         gevent.sleep(server_timeout+0.2)
         client.pool.join()
         if not server.exception:
             raise Exception(
                 "Expected gevent.Timeout from socket timeout, got none")
         raise server.exception
     except gevent.Timeout:
         pass
     chan_timeout = output['127.0.0.1']['channel'].gettimeout()
     self.assertEqual(client_timeout, chan_timeout,
                      msg="Channel timeout %s does not match requested timeout %s" %(
                          chan_timeout, client_timeout,))
     del client
     server.join()

# 需要导入模块: from pssh import ParallelSSHClient [as 别名]
# 或者: from pssh.ParallelSSHClient import run_command [as 别名]
 def test_pssh_client_run_command_get_output_explicit(self):
     client = ParallelSSHClient([self.host], port=self.listen_port,
                                pkey=self.user_key)
     out = client.run_command(self.fake_cmd)
     cmds = [cmd for host in out for cmd in [out[host]['cmd']]]
     output = {}
     for cmd in cmds:
         client.get_output(cmd, output)
     expected_exit_code = 0
     expected_stdout = [self.fake_resp]
     expected_stderr = []
     stdout = list(output[self.host]['stdout'])
     stderr = list(output[self.host]['stderr'])
     exit_code = output[self.host]['exit_code']
     self.assertEqual(expected_exit_code, exit_code,
                      msg="Got unexpected exit code - %s, expected %s" %
                      (exit_code,
                       expected_exit_code,))
     self.assertEqual(expected_stdout, stdout,
                      msg="Got unexpected stdout - %s, expected %s" % 
                      (stdout,
                       expected_stdout,))
     self.assertEqual(expected_stderr, stderr,
                      msg="Got unexpected stderr - %s, expected %s" % 
                      (stderr,
                       expected_stderr,))
     del client

# 需要导入模块: from pssh import ParallelSSHClient [as 别名]
# 或者: from pssh.ParallelSSHClient import run_command [as 别名]
 def test_host_config(self):
     """Test per-host configuration functionality of ParallelSSHClient"""
     hosts = ['127.0.0.%01d' % n for n in xrange(1,3)]
     host_config = dict.fromkeys(hosts)
     servers = []
     user = 'overriden_user'
     password = 'overriden_pass'
     for host in hosts:
         _socket = make_socket(host)
         port = _socket.getsockname()[1]
         host_config[host] = {}
         host_config[host]['port'] = port
         host_config[host]['user'] = user
         host_config[host]['password'] = password
         server = start_server(_socket, fail_auth=hosts.index(host))
         servers.append((server, port))
     pkey_data = load_private_key(PKEY_FILENAME)
     host_config[hosts[0]]['private_key'] = pkey_data
     client = ParallelSSHClient(hosts, host_config=host_config)
     output = client.run_command(self.fake_cmd, stop_on_errors=False)
     client.join(output)
     for host in hosts:
         self.assertTrue(host in output)
     try:
         raise output[hosts[1]]['exception']
     except AuthenticationException, ex:
         pass

# 需要导入模块: from pssh import ParallelSSHClient [as 别名]
# 或者: from pssh.ParallelSSHClient import run_command [as 别名]
    def post(self):
        raw_dict = request.get_json(force=True)
        try:
            schema.validate(raw_dict)
            request_dict = raw_dict['data']['attributes']
            ipaddress = request_dict['ipaddress']
            username = request_dict['username']
            password = request_dict['password']
            #s = pxssh.pxssh()           
            #s.login(ipaddress, username, password,port=2222,auto_prompt_reset=False)            
            hosts = [ipaddress]
            client = ParallelSSHClient(hosts, user=username, password=password, port=2222)
            output= client.run_command("grep ':0' /etc/passwd | grep '/bin/bash' |  awk -F: '{print $1}'")
            users = []
            for host in output:
                for user in output[host]['stdout']:
                     users.append(user)
            data = {'users': users}
            del output
            return data, 201
            

        except ValidationError as err:
            resp = jsonify({"error": err.messages})
            resp.status_code = 403
            return resp

# 需要导入模块: from pssh import ParallelSSHClient [as 别名]
# 或者: from pssh.ParallelSSHClient import run_command [as 别名]
 def test_pssh_client_timeout(self):
     listen_socket = make_socket(self.host)
     listen_port = listen_socket.getsockname()[1]
     server_timeout=0.2
     client_timeout=server_timeout-0.1
     server = start_server(listen_socket,
                           timeout=server_timeout)
     client = ParallelSSHClient([self.host], port=listen_port,
                                pkey=self.user_key,
                                timeout=client_timeout)
     output = client.run_command(self.fake_cmd)
     # Handle exception
     try:
         gevent.sleep(server_timeout+0.2)
         client.pool.join()
         if not server.exception:
             raise Exception(
                 "Expected gevent.Timeout from socket timeout, got none")
         raise server.exception
     except gevent.Timeout:
         pass
     # chan_timeout = output[self.host]['channel'].gettimeout()
     # self.assertEqual(client_timeout, chan_timeout,
     #                  msg="Channel timeout %s does not match requested timeout %s" %(
     #                      chan_timeout, client_timeout,))
     del client
     server.join()

# 需要导入模块: from pssh import ParallelSSHClient [as 别名]
# 或者: from pssh.ParallelSSHClient import run_command [as 别名]
 def test_ssh_proxy_auth(self):
     """Test connecting to remote destination via SSH proxy
     client -> proxy -> destination
     Proxy SSH server accepts no commands and sends no responses, only
     proxies to destination. Destination accepts a command as usual."""
     proxy_server_socket = make_socket('127.0.0.2')
     proxy_server_port = proxy_server_socket.getsockname()[1]
     proxy_server = start_server(proxy_server_socket)
     proxy_user = 'proxy_user'
     proxy_password = 'fake'
     gevent.sleep(2)
     client = ParallelSSHClient([self.host], port=self.listen_port,
                                pkey=self.user_key,
                                proxy_host='127.0.0.2',
                                proxy_port=proxy_server_port,
                                proxy_user=proxy_user,
                                proxy_password='fake',
                                proxy_pkey=self.user_key,
                                )
     gevent.sleep(2)
     output = client.run_command(self.fake_cmd)
     stdout = list(output[self.host]['stdout'])
     expected_stdout = [self.fake_resp]
     self.assertEqual(expected_stdout, stdout,
                      msg="Got unexpected stdout - %s, expected %s" % (
                          stdout, expected_stdout,))
     self.assertEqual(client.host_clients[self.host].proxy_user, proxy_user)
     self.assertEqual(client.host_clients[self.host].proxy_password, proxy_password)
     self.assertTrue(client.host_clients[self.host].proxy_pkey)
     self.server.kill()
     proxy_server.kill()