Python RemoteMachineShellConnection.is_membase_installed方法代码示例

# 需要导入模块: from remote.remote_util import RemoteMachineShellConnection [as 别名]
# 或者: from remote.remote_util.RemoteMachineShellConnection import is_membase_installed [as 别名]
 def stop_cluster(servers):
     for server in servers:
         shell = RemoteMachineShellConnection(server)
         if shell.is_membase_installed():
             shell.stop_membase()
         else:
             shell.stop_couchbase()

# 需要导入模块: from remote.remote_util import RemoteMachineShellConnection [as 别名]
# 或者: from remote.remote_util.RemoteMachineShellConnection import is_membase_installed [as 别名]
 def common_setup(input, testcase):
     servers = input.servers
     for server in servers:
         shell = RemoteMachineShellConnection(server)
         if shell.is_membase_installed():
             shell.start_membase()
         else:
             shell.start_couchbase()
         o, r = shell.execute_command("iptables -F")
         shell.log_command_output(o, r)
         shell.disconnect()
     time.sleep(10)
     BucketOperationHelper.delete_all_buckets_or_assert(servers, testcase)
     for server in servers:
         ClusterOperationHelper.cleanup_cluster([server])
     ClusterHelper.wait_for_ns_servers_or_assert(servers, testcase)

# 需要导入模块: from remote.remote_util import RemoteMachineShellConnection [as 别名]
# 或者: from remote.remote_util.RemoteMachineShellConnection import is_membase_installed [as 别名]
 def stop_server(self, node):
     log = logger.Logger.get_logger()
     for server in self._servers:
         rest = RestConnection(server)
         if not RestHelper(rest).is_ns_server_running(timeout_in_seconds=5):
             continue
         server_ip = rest.get_nodes_self().ip
         if server_ip == node.ip:
             shell = RemoteMachineShellConnection(server)
             if shell.is_membase_installed():
                 shell.stop_membase()
                 log.info("Membase stopped")
             else:
                 shell.stop_couchbase()
                 log.info("Couchbase stopped")
             shell.disconnect()
             break

# 需要导入模块: from remote.remote_util import RemoteMachineShellConnection [as 别名]
# 或者: from remote.remote_util.RemoteMachineShellConnection import is_membase_installed [as 别名]
    def common_tearDown(servers, testcase):
        for server in servers:
            shell = RemoteMachineShellConnection(server)
            if shell.is_membase_installed():
                shell.start_membase()
            else:
                shell.start_couchbase()
            o, r = shell.execute_command("iptables -F")
            shell.log_command_output(o, r)
            shell.disconnect()
            #also flush the firewall rules
        log = logger.Logger.get_logger()
        log.info("10 seconds delay to wait for membase-server to start")
        time.sleep(10)

        BucketOperationHelper.delete_all_buckets_or_assert(servers, testcase)
        ClusterOperationHelper.cleanup_cluster(servers)
        ClusterHelper.wait_for_ns_servers_or_assert(servers, testcase)

# 需要导入模块: from remote.remote_util import RemoteMachineShellConnection [as 别名]
# 或者: from remote.remote_util.RemoteMachineShellConnection import is_membase_installed [as 别名]
 def _stop_server(self, node):
     master_rest = RestConnection(self.servers[0])
     for server in self.servers:
         rest = RestConnection(server)
         self.log.info("see if server {0}:{1} is running".format(server.ip, server.port))
         if not RestHelper(rest).is_ns_server_running(timeout_in_seconds=5):
             continue
         node_id = rest.get_nodes_self().id
         if node_id == node.id:
             # if its 8091 then do ssh otherwise use ns_servr
             if node.port == 8091:
                 shell = RemoteMachineShellConnection(server)
                 if shell.is_membase_installed():
                     shell.stop_membase()
                     self.log.info("Membase stopped")
                 else:
                     shell.stop_couchbase()
                     self.log.info("Couchbase stopped")
                 shell.disconnect()
                 break
             else:
                 self.log.info("running {0}".format(stop_cluster.format(node.id)))
                 master_rest.diag_eval(stop_cluster.format(node.id))

# 需要导入模块: from remote.remote_util import RemoteMachineShellConnection [as 别名]
# 或者: from remote.remote_util.RemoteMachineShellConnection import is_membase_installed [as 别名]
class BackupRestoreTests(unittest.TestCase):
    input = None
    servers = None
    log = None
    membase = None
    shell = None
    remote_tmp_folder = None
    master = None

    def setUp(self):
        self.log = logger.Logger.get_logger()
        self.input = TestInputSingleton.input
        self.servers = self.input.servers
        self.master = self.servers[0]
        self.shell = RemoteMachineShellConnection(self.master)

        # When using custom data_paths, (smaller / sizes), creates
        # backup in those custom paths ( helpful when running on ec2)
        info = RestConnection(self.master).get_nodes_self()
        data_path = info.storage[0].get_data_path()
        self.remote_tmp_folder = None
        self.remote_tmp_folder = "{2}/{0}-{1}".format("backup", uuid.uuid4(), data_path)
        self.is_membase = False
        self.perm_command = "mkdir -p {0}".format(self.remote_tmp_folder)
        if self.shell.is_membase_installed():
            self.is_membase = True
            self.perm_command = "mkdir -p {0}".format(self.remote_tmp_folder)


    def common_setUp(self):
        ClusterOperationHelper.cleanup_cluster(self.servers)
        BucketOperationHelper.delete_all_buckets_or_assert(self.servers, self)
        for server in self.servers:
            shell = RemoteMachineShellConnection(server)
            shell.stop_membase()
            shell.stop_couchbase()
            shell.start_membase()
            shell.start_couchbase()
            RestHelper(RestConnection(server)).is_ns_server_running(timeout_in_seconds=120)
            shell.disconnect()

    def tearDown(self):

        for server in self.servers:
            self.log.info("delete remote folder @ {0}".format(self.remote_tmp_folder))
            shell = RemoteMachineShellConnection(server)
            shell.remove_directory(self.remote_tmp_folder)
            shell.disconnect()

    def add_node_and_rebalance(self, master, servers):
        ClusterOperationHelper.add_all_nodes_or_assert(master, servers, self.input.membase_settings, self)
        rest = RestConnection(master)
        nodes = rest.node_statuses()
        otpNodeIds = []
        for node in nodes:
            otpNodeIds.append(node.id)
        rebalanceStarted = rest.rebalance(otpNodeIds, [])
        self.assertTrue(rebalanceStarted,
                        "unable to start rebalance on master node {0}".format(master.ip))
        self.log.info('started rebalance operation on master node {0}'.format(master.ip))
        rebalanceSucceeded = rest.monitorRebalance()
        self.assertTrue(rebalanceSucceeded,
                        "rebalance operation for nodes: {0} was not successful".format(otpNodeIds))
        self.log.info('rebalance operaton succeeded for nodes: {0}'.format(otpNodeIds))
        #now remove the nodes
        #make sure its rebalanced and node statuses are healthy
        helper = RestHelper(rest)
        self.assertTrue(helper.is_cluster_healthy, "cluster status is not healthy")
        self.assertTrue(helper.is_cluster_rebalanced, "cluster is not balanced")

    def add_nodes_and_rebalance(self):
        self.add_node_and_rebalance(master=self.servers[0], servers=self.servers)

    def _test_backup_add_restore_bucket_body(self,
                                             bucket,
                                             delay_after_data_load,
                                             startup_flag,
                                             single_node):
        server = self.master
        rest = RestConnection(server)
        info = rest.get_nodes_self()
        size = int(info.memoryQuota * 2.0 / 3.0)
        if bucket == "default":
            rest.create_bucket(bucket, ramQuotaMB=size, proxyPort=info.moxi)
        else:
            proxyPort = info.moxi + 500
            rest.create_bucket(bucket, ramQuotaMB=size, proxyPort=proxyPort,
                               authType="sasl", saslPassword="password")

        ready = BucketOperationHelper.wait_for_memcached(server, bucket)
        self.assertTrue(ready, "wait_for_memcached failed")
        if not single_node:
            self.add_nodes_and_rebalance()
        distribution = {10: 0.2, 20: 0.5, 30: 0.25, 40: 0.05}
        inserted_keys, rejected_keys = MemcachedClientHelper.load_bucket_and_return_the_keys(servers=[self.master],
                                                                                             name=bucket,
                                                                                             ram_load_ratio=1,
                                                                                             value_size_distribution=distribution,
                                                                                             moxi=True,
                                                                                             write_only=True,
#.........这里部分代码省略.........

# 需要导入模块: from remote.remote_util import RemoteMachineShellConnection [as 别名]
# 或者: from remote.remote_util.RemoteMachineShellConnection import is_membase_installed [as 别名]
import sys
import os


sys.path.append('.')
sys.path.append('lib')
from remote.remote_util import RemoteMachineShellConnection

from TestInput import TestInputParser

if __name__ == "__main__":
    input = TestInputParser.get_test_input(sys.argv)
    remote = RemoteMachineShellConnection(input.servers[0])
    server_type = 'couchbase'
    if remote.is_membase_installed():
        server_type = 'membase'
    for serverInfo in input.servers:
        try:
            remote = RemoteMachineShellConnection(serverInfo)
            info = remote.extract_remote_info()
            if info.type.lower() != 'windows':
                core_files = []
                print "looking for erl_crash files under /opt/{0}/var/lib/{0}/".format(server_type)
                core_files.extend(remote.file_starts_with("/opt/{0}/var/lib/{0}/".format(server_type), "erl_crash"))
                print "looking for core* files under /opt/{0}/var/lib/{0}/".format(server_type)
                core_files.extend(remote.file_starts_with("/opt/{0}/var/lib/{0}/".format(server_type), "core"))
                print "looking for core* files under /tmp/"
                core_files.extend(remote.file_starts_with("/tmp/", "core"))
                i = 0
                for core_file in core_files:
                    if core_file.find('erl_crash.dump') != -1: