Python pssh.ParallelSSHClient类代码示例

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

 def test_pssh_client_directory(self):
     """Tests copying directories with SSH client. Copy all the files from
     local directory to server, then make sure they are all present."""
     test_file_data = 'test'
     local_test_path = 'directory_test'
     remote_test_path = 'directory_test_copied'
     for path in [local_test_path, remote_test_path]:
         try:
             shutil.rmtree(path)
         except OSError:
             pass
     os.mkdir(local_test_path)
     remote_file_paths = []
     for i in range(0, 10):
         local_file_path = os.path.join(local_test_path, 'foo' + str(i))
         remote_file_path = os.path.join(remote_test_path, 'foo' + str(i))
         remote_file_paths.append(remote_file_path)
         test_file = open(local_file_path, 'w')
         test_file.write(test_file_data)
         test_file.close()
     client = ParallelSSHClient([self.host], port=self.listen_port,
                                pkey=self.user_key)
     cmds = client.copy_file(local_test_path, remote_test_path, recurse=True)
     for cmd in cmds:
         cmd.get()
     for path in remote_file_paths:
         self.assertTrue(os.path.isfile(path))
     shutil.rmtree(local_test_path)
     shutil.rmtree(remote_test_path)

    def test_pssh_hosts_more_than_pool_size(self):
        """Test we can successfully run on more hosts than our pool size and
        get logs for all hosts"""
        # Make a second server on the same port as the first one
        server2_socket = make_socket('127.0.0.2', port=self.listen_port)
        server2_port = server2_socket.getsockname()[1]
        server1 = start_server({ self.fake_cmd : self.fake_resp },
                               self.listen_socket)
        server2 = start_server({ self.fake_cmd : self.fake_resp },
                               server2_socket)
        hosts = ['127.0.0.1', '127.0.0.2']
        client = ParallelSSHClient(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),))
        self.assertEqual(expected_stdout, stdout,
                         msg="Did not get expected output from all hosts. \
                         Got %s - expected %s" % (stdout, expected_stdout,))
        del client
        server1.kill()
        server2.kill()

 def test_pssh_client_exec_command_get_buffers(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)
     cmd = client.exec_command(self.fake_cmd)[0]
     output = client.get_stdout(cmd, return_buffers=True)
     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()

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

    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

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

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

 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

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

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

 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

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

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

 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