Python RemoteMachineShellConnection.terminate_process方法代码示例

# 需要导入模块: from remote.remote_util import RemoteMachineShellConnection [as 别名]
# 或者: from remote.remote_util.RemoteMachineShellConnection import terminate_process [as 别名]
 def test_server_crash(self):
     if self.doc_ops:
         return
     pre_recovery_tasks = self.async_run_operations(phase="before")
     self._run_tasks([pre_recovery_tasks])
     self.get_dgm_for_plasma()
     kvOps_tasks = self._run_kvops_tasks()
     try:
         self.use_replica=False
         self._create_replica_indexes()
         self.targetProcess= self.input.param("targetProcess",'memcached')
         for node in self.nodes_out_list:
             remote = RemoteMachineShellConnection(node)
             if self.targetProcess == "memcached":
                 remote.kill_memcached()
             else:
                 remote.terminate_process(process_name=self.targetProcess)
         self.sleep(60)
         mid_recovery_tasks = self.async_run_operations(phase="in_between")
         self._run_tasks([kvOps_tasks, mid_recovery_tasks])
         #check if the nodes in cluster are healthy
         msg = "Cluster not in Healthy state"
         self.assertTrue(self.wait_until_cluster_is_healthy(), msg)
         log.info("==== Cluster in healthy state ====")
         self._check_all_bucket_items_indexed()
         post_recovery_tasks = self.async_run_operations(phase="after")
         self._run_tasks([post_recovery_tasks])
     except Exception, ex:
         log.info(str(ex))
         raise

# 需要导入模块: from remote.remote_util import RemoteMachineShellConnection [as 别名]
# 或者: from remote.remote_util.RemoteMachineShellConnection import terminate_process [as 别名]
 def test_server_crash(self):
     try:
         self.use_replica=False
         self.targetProcess= self.input.param("targetProcess",'memcached')
         self._run_initial_index_tasks()
         kvOps_tasks = self._run_kvops_tasks()
         before_index_ops = self._run_before_index_tasks()
         for node in self.nodes_out_list:
             remote = RemoteMachineShellConnection(node)
             remote.terminate_process(process_name=self.targetProcess)
         in_between_index_ops = self._run_in_between_tasks()
         self._run_tasks([kvOps_tasks, before_index_ops, in_between_index_ops])
         self._run_after_index_tasks()
     except Exception, ex:
         raise

# 需要导入模块: from remote.remote_util import RemoteMachineShellConnection [as 别名]
# 或者: from remote.remote_util.RemoteMachineShellConnection import terminate_process [as 别名]
 def test_rebalance_with_server_crash(self):
     servr_in = self.servers[self.nodes_init : self.nodes_init + self.nodes_in]
     servr_out = self.servers[self.nodes_init - self.nodes_out : self.nodes_init]
     self.test_case()
     for i in xrange(3):
         rebalance = self.cluster.async_rebalance(self.servers[: self.nodes_init], servr_in, servr_out)
         self.sleep(5, "Wait some time for rebalance process and then kill memcached")
         remote = RemoteMachineShellConnection(self.servers[self.nodes_init - 1])
         remote.terminate_process(process_name="memcached")
         self.test_case()
         try:
             rebalance.result()
         except:
             pass
     self.cluster.rebalance(self.servers[: self.nodes_init], servr_in, servr_out)
     self.test_case()

# 需要导入模块: from remote.remote_util import RemoteMachineShellConnection [as 别名]
# 或者: from remote.remote_util.RemoteMachineShellConnection import terminate_process [as 别名]
 def crash_node(self, master):
     count = 0
     pre_crash_uuid, _ = self.get_failover_log(master)
     node = self.get_active_vb0_node(master)
     self.log.info("Crashing node {} containing vb0 ...".format(node))
     shell = RemoteMachineShellConnection(node)
     shell.terminate_process(process_name='memcached')
     shell.disconnect()
     # If we are killing dest node, try to mutate key at source to cause xdcr activity
     if master == self.dest_master:
         while count < 5:
             self.load_one_mutation_into_source_vb0(self.get_active_vb0_node(self.src_master))
             count += 1
     self.sleep(10)
     post_crash_uuid, _=self.get_failover_log(master)
     self.log.info("vb_uuid before crash :{}, after crash : {}".format(pre_crash_uuid, post_crash_uuid))
     self.assertTrue(int(pre_crash_uuid) != int(post_crash_uuid),
                     "vb_uuid is same before and after erlang crash - MB-11085 ")

# 需要导入模块: from remote.remote_util import RemoteMachineShellConnection [as 别名]
# 或者: from remote.remote_util.RemoteMachineShellConnection import terminate_process [as 别名]
 def test_server_crash(self):
     before_tasks = self.async_run_operations(buckets=self.buckets,
                                              phase="before")
     self._run_tasks([before_tasks])
     self.targetProcess= self.input.param("targetProcess",'memcached')
     kvOps_tasks = self._run_kvops_tasks()
     for node in self.nodes_out_list:
         remote = RemoteMachineShellConnection(node)
         if self.targetProcess == "memcached":
             remote.kill_memcached()
         else:
             remote.terminate_process(process_name=self.targetProcess)
     self.sleep(20)
     in_between_tasks = self.async_run_operations(buckets=self.buckets,
                                              phase="in_between")
     self._run_tasks([kvOps_tasks, in_between_tasks])
     self.sleep(60)
     self._verify_bucket_count_with_index_count()
     after_tasks = self.async_run_operations(buckets=self.buckets,
                                         phase="after")
     self._run_tasks([after_tasks])

# 需要导入模块: from remote.remote_util import RemoteMachineShellConnection [as 别名]
# 或者: from remote.remote_util.RemoteMachineShellConnection import terminate_process [as 别名]
 def webHookMutipleWebHooks(self):
     for server in self.servers:
         shell = RemoteMachineShellConnection(server)
         type = shell.extract_remote_info().type.lower()
         shell.copy_file_local_to_remote("pytests/sg/simpleServe.go", "{0}/tmp/simpleServe2.go".format(self.folder_prefix))
         self.log.info('=== Starting SimpleServe second instances')
         if type == 'windows':
             shell.terminate_process(process_name='simpleServe2.exe')
             output, error = shell.execute_command_raw('c:/Go/bin/go.exe run c:/tmp/simpleServe2.go 8082'
                                   ' >{0}/tmp/simpleServe2.txt 2>&1 &'.format(self.folder_prefix))
         else:
             shell.terminate_process(process_name='simpleServe2')
             shell.execute_command("kill $(ps aux | grep '8082' | awk '{print $2}')")
             output, error = shell.execute_command_raw('go run /tmp/simpleServe2.go 8082'
                                               '  >/tmp/simpleServe2.txt 2>&1 &')
         self.start_sync_gateway(shell, self.configfile)
         shell.log_command_output(output, error)
         success, revision, status = self.create_doc_logfiles(shell, self.doc_id, self.doc_content,
                                     ['{0}/tmp/simpleServe.txt'.format(self.folder_prefix),
                                      '{0}/tmp/simpleServe2.txt'.format(self.folder_prefix)])
         self.assertTrue(success)
         shell.disconnect()

# 需要导入模块: from remote.remote_util import RemoteMachineShellConnection [as 别名]
# 或者: from remote.remote_util.RemoteMachineShellConnection import terminate_process [as 别名]
 def test_prepared_with_rebalance_with_server_crash(self):
     servr_in = self.servers[self.nodes_init : self.nodes_init + self.nodes_in]
     servr_out = self.servers[self.nodes_init - self.nodes_out : self.nodes_init]
     self.test_case()
     for i in xrange(3):
         rebalance = self.cluster.async_rebalance(self.servers[: self.nodes_init], servr_in, servr_out)
         self.sleep(5, "Wait some time for rebalance process and then kill memcached")
         remote = RemoteMachineShellConnection(self.servers[self.nodes_init - 1])
         remote.terminate_process(process_name="memcached")
         try:
             rebalance.result()
             # self.log.info("-"*100)
             # self.log.info("Querying alternate query node to test the encoded_prepare ....")
             # self.test_prepared_unnest()
             # self.log.info("-"*100)
         except:
             pass
     self.cluster.rebalance(self.servers[: self.nodes_init], servr_in, servr_out)
     self.log.info("-" * 100)
     self.log.info("Querying alternate query node to test the encoded_prepare ....")
     self.test_prepared_within_list_object()
     self.log.info("-" * 100)

# 需要导入模块: from remote.remote_util import RemoteMachineShellConnection [as 别名]
# 或者: from remote.remote_util.RemoteMachineShellConnection import terminate_process [as 别名]
    def _kill_nodes(self, nodes):
        is_partial = self.input.param("is_partial", "True")
        _nodes = []
        if len(self.servers) > 1 :
            skip = 2
        else:
            skip = 1
        if is_partial:
            _nodes = nodes[0:len(nodes):skip]
        else:
            _nodes = nodes
        for node in _nodes:
            _node = {"ip": node.ip, "port": node.port, "username": self.servers[0].rest_username,
                     "password": self.servers[0].rest_password}
            _mc = MemcachedClientHelper.direct_client(_node, self.bucket_name)
            self.log.info("restarted the node %s:%s" % (node.ip, node.port))
            pid = _mc.stats()["pid"]
            _mc.close()
            node_rest = RestConnection(_node)
            for _server in self.servers:
                if _server.ip == node.ip:
                    self.log.info("Returned Server index %s" % _server)
                    shell = RemoteMachineShellConnection(_server)
                    break

            info = shell.extract_remote_info()
            os_type = info.type.lower()
            if os_type == 'windows':
                shell.terminate_process(info, 'memcached.exe')
                self.log.info("killed ??  node %s " % node.ip)
                # command = "taskkill /F /T /IM memcached.exe*"
            else:
                command = "os:cmd(\"kill -9 {0} \")".format(pid)
                self.log.info(command)
                killed = node_rest.diag_eval(command)
                self.log.info("killed ??  {0} ".format(killed))