예제 #1
0
 def test_create_bucket_test_load(self):
     shell = RemoteMachineShellConnection(self.master)
     self.init_rebalance_cluster_create_testbucket()
     if self._os == "centos" or self._os == "ubuntu":
         self.log.info("Load {0} through cbworkloadgen ..".format(self.num_items))
         _1 = "cd /home/{0}/opt/couchbase &&".format(self.master.ssh_username)
         _2 = " ./bin/cbworkloadgen -n localhost:8091"
         _3 = " -r .8 -i {0} -s 256 -b testbucket -t 1".format(self.num_items)
         _4 = " -u {0} -p {1}".format(self.master.rest_username, self.master.rest_password)
         command_to_load = _1 + _2 + _3 + _4
         o, e = shell.execute_non_sudo_command(command_to_load)
         shell.log_command_output(o, e)
         time.sleep(20)
         rest = RestConnection(self.master)
         item_count = rest.fetch_bucket_stats(bucket="testbucket")["op"]["samples"]["curr_items"][-1]
         if (item_count == self.num_items):
             self.log.info("Item count matched, {0}={1}".format(item_count, self.num_items))
         else:
             self.fail("Item count: Not what's expected, {0}!={1}".format(item_count, self.num_items))
         self.log.info("Deleting testbucket ..");
         _1 = "cd /home/{0}/opt/couchbase &&".format(self.master.ssh_username)
         _2 = " ./bin/couchbase-cli bucket-delete -c localhost:8091"
         _3 = " --bucket=testbucket"
         _4 = " -u {0} -p {1}".format(self.master.rest_username, self.master.rest_password)
         command_to_delete_bucket = _1 + _2 + _3 + _4
         o, e = shell.execute_non_sudo_command(command_to_delete_bucket)
         shell.log_command_output(o, e)
         time.sleep(10)
     elif self._os == "windows":
         # TODO: Windows support
         self.log.info("Yet to add support for windows!")
         pass
예제 #2
0
 def non_root_install(self):
     for server in self.servers:
         shell = RemoteMachineShellConnection(server)
         info = shell.extract_remote_info()
         if self._os == "centos":
             command0 = "rm -rf opt/ etc/ && rm -rf {0}".format(self.build)
             command1 = "wget http://builds.hq.northscale.net/latestbuilds/{0}".format(
                 self.build)
             command2 = "rpm2cpio {0} | cpio --extract --make-directories --no-absolute-filenames".format(
                 self.build)
             command3 = "cd /home/{0}/opt/couchbase && ./bin/install/reloc.sh `pwd`".format(
                 server.ssh_username)
             command4 = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -- -noinput -detached".format(
                 server.ssh_username)
             command5 = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -k".format(
                 server.ssh_username)
             o, e = shell.execute_non_sudo_command(command0)
             shell.log_command_output(o, e)
             o, e = shell.execute_non_sudo_command(command1)
             shell.log_command_output(o, e)
             o, e = shell.execute_non_sudo_command(command2)
             shell.log_command_output(o, e)
             o, e = shell.execute_non_sudo_command(command3)
             shell.log_command_output(o, e)
             self.log.info(
                 "Starting couchbase server <non-root, non-sudo> ..")
             o, e = shell.execute_non_sudo_command(command4)
             shell.log_command_output(o, e)
         elif self._os == "ubuntu":
             command0 = "rm -rf opt/ etc/ && rm -rf {0}".format(self.build)
             command1 = "wget http://builds.hq.northscale.net/latestbuilds/{0}".format(
                 self.build)
             command2 = "dpkg-deb -x {0} /home/{1}".format(
                 self.build, server.ssh_username)
             command3 = "cd /home/{0}/opt/couchbase && ./bin/install/reloc.sh `pwd`".format(
                 server.ssh_username)
             command4 = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -- -noinput -detached".format(
                 server.ssh_username)
             command5 = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -k".format(
                 server.ssh_username)
             o, e = shell.execute_non_sudo_command(command0)
             shell.log_command_output(o, e)
             o, e = shell.execute_non_sudo_command(command1)
             shell.log_command_output(o, e)
             o, e = shell.execute_non_sudo_command(command2)
             shell.log_command_output(o, e)
             o, e = shell.execute_non_sudo_command(command3)
             shell.log_command_output(o, e)
             self.log.info(
                 "Starting couchbase server <non-root, non-sudo> ..")
             o, e = shell.execute_non_sudo_command(command4)
             shell.log_command_output(o, e)
         elif self._os == "windows":
             self.fail("TODO: Add instructions for windows")
         else:
             self.fail(
                 "Enter valid os name, options: centos, ubuntu, windows; entered name: {0} - invalid."
                 .format(self._os))
예제 #3
0
    def non_root_install(self):
        ssh_client = paramiko.SSHClient()
        ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        for server in self.servers:
            shell = RemoteMachineShellConnection(server)
            info = shell.extract_remote_info()
            ssh_client.connect(hostname=server.ip,key_filename=server.ssh_key)
            sftp_client = ssh_client.open_sftp()
            if self._os == "centos":
                command0 = "rm -rf opt/ etc/ && rm -rf couchbase-server-enterprise_x86_64_2.2.0-772-rel.rpm"
                command1 = "wget http://builds.hq.northscale.net/latestbuilds/couchbase-server-enterprise_x86_64_2.2.0-772-rel.rpm"
                command2 = "rpm2cpio couchbase-server-enterprise_x86_64_2.2.0-772-rel.rpm | cpio --extract --make-directories --no-absolute-filenames"
                command3 = "cd /home/{0}/opt/couchbase && ./bin/install/reloc.sh `pwd`".format(server.ssh_username)
                command4 = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -- -noinput -detached".format(server.ssh_username)
                command5 = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -k".format(server.ssh_username)
                o, e = shell.execute_non_sudo_command(command0)
                shell.log_command_output(o, e)
                o, e = shell.execute_non_sudo_command(command1)
                shell.log_command_output(o, e)
                o, e = shell.execute_non_sudo_command(command2)
                shell.log_command_output(o, e)
                o, e = shell.execute_non_sudo_command(command3)
                shell.log_command_output(o, e)
                self.log.info("Starting couchbase server <non-root, non-sudo> ..")
                o, e = shell.execute_non_sudo_command(command4)
                shell.log_command_output(o, e)
            elif self._os == "ubuntu":
                command0 = "rm -rf opt/ etc/ && rm -rf couchbase-server-enterprise_x86_64_2.2.0-772-rel.deb"
                command1 = "wget http://builds.hq.northscale.net/latestbuilds/couchbase-server-enterprise_x86_64_2.2.0-772-rel.deb"
                command2 = "dpkg-deb -x couchbase-server-enterprise_x86_64_2.2.0-772-rel.deb /home/{0}".format(server.ssh_username)
                command3 = "cd /home/{0}/opt/couchbase && ./bin/install/reloc.sh `pwd`".format(server.ssh_username)
                command4 = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -- -noinput -detached".format(server.ssh_username)
                command5 = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -k".format(server.ssh_username)
                o, e = shell.execute_non_sudo_command(command0)
                shell.log_command_output(o, e)
                o, e = shell.execute_non_sudo_command(command1)
                shell.log_command_output(o, e)
                o, e = shell.execute_non_sudo_command(command2)
                shell.log_command_output(o, e)
                o, e = shell.execute_non_sudo_command(command3)
                shell.log_command_output(o, e)
                self.log.info("Starting couchbase server <non-root, non-sudo> ..")
                o, e = shell.execute_non_sudo_command(command4)
                shell.log_command_output(o, e)
                self.fail("TODO: Add instructions for ubuntu")
            elif self._os == "windows":
                self.fail("TODO: Add instructions for windows")
            else:
                self.fail("Enter valid os name, options: centos, ubuntu, windows; entered name: {0} - invalid.".format(self._os))

            ssh_client.close()
예제 #4
0
 def setup_xdcr_start_replication(self, src, dest, rep_type, bidirectional):
     shell1 = RemoteMachineShellConnection(src)
     shell2 = RemoteMachineShellConnection(dest)
     if self._os == "centos" or self._os == "ubuntu":
         self.log.info("Setting up XDCR from source cluster to destination cluster ..")
         _1 = "cd /home/{0}/opt/couchbase &&".format(src.ssh_username)
         _2 = " ./bin/couchbase-cli xdcr-setup -c localhost:8091"
         _3 = " --create --xdcr-cluster-name=_dest --xdcr-hostname={0}:8091".format(dest.ip)
         _4 = " --xdcr-username={0} --xdcr-password={1}".format(dest.rest_username, dest.rest_password)
         _5 = " -u {0} -p {1}".format(src.rest_username, src.rest_password)
         command_to_setup_xdcr = _1 + _2 + _3 + _4 + _5
         o, e = shell1.execute_non_sudo_command(command_to_setup_xdcr)
         shell1.log_command_output(o, e)
         if bidirectional:
             self.log.info("Setting up XDCR from destination cluster to source cluster ..")
             _1 = "cd /home/{0}/opt/couchbase &&".format(dest.ssh_username)
             _2 = " ./bin/couchbase-cli xdcr-setup -c localhost:8091"
             _3 = " --create --xdcr-cluster-name=_src --xdcr-hostname={0}:8091".format(src.ip)
             _4 = " --xdcr-username={0} --xdcr-password={1}".format(src.rest_username, src.rest_password)
             _5 = " -u {0} -p {1}".format(dest.rest_username, dest.rest_password)
             command_to_setup_xdcr = _1 + _2 + _3 + _4 + _5
             o, e = shell2.execute_non_sudo_command(command_to_setup_xdcr)
             shell2.log_command_output(o, e)
         time.sleep(10)
         self.log.info("Starting replication from source to destination ..")
         _1 = "cd /home/{0}/opt/couchbase &&".format(src.ssh_username)
         _2 = " ./bin/couchbase-cli xdcr-replicate -c localhost:8091"
         _3 = " --create --xdcr-cluster-name=_dest --xdcr-from-bucket=testbucket"
         _4 = " --xdcr-to-bucket=testbucket --xdcr-replication-mode={0}".format(rep_type)
         _5 = " -u {0} -p {1}".format(src.rest_username, src.rest_password)
         command_to_setup_xdcr = _1 + _2 + _3 + _4 + _5
         o, e = shell1.execute_non_sudo_command(command_to_setup_xdcr)
         shell1.log_command_output(o, e)
         if bidirectional:
             self.log.info("Starting replication from destination to source ..")
             _1 = "cd /home/{0}/opt/couchbase &&".format(dest.ssh_username)
             _2 = " ./bin/couchbase-cli xdcr-replicate -c localhost:8091"
             _3 = " --create --xdcr-cluster-name=_src --xdcr-from-bucket=testbucket"
             _4 = " --xdcr-to-bucket=testbucket --xdcr-replication-mode={0}".format(rep_type)
             _5 = " -u {0} -p {1}".format(dest.rest_username, dest.rest_password)
             command_to_setup_xdcr = _1 + _2 + _3 + _4 + _5
             o, e = shell2.execute_non_sudo_command(command_to_setup_xdcr)
             shell2.log_command_output(o, e)
         time.sleep(10)
     elif self._os == "windows":
         # TODO: WIndows support
         pass
     shell1.disconnect()
     shell2.disconnect()
예제 #5
0
 def init_rebalance_cluster_create_testbucket(self):
     shell = RemoteMachineShellConnection(self.master)
     if self._os == "centos" or self._os == "ubuntu":
         _1 = "cd /home/{0}/opt/couchbase &&".format(
             self.master.ssh_username)
         _2 = " ./bin/couchbase-cli cluster-init -c localhost:8091"
         _3 = " --cluster-init-username={0} --cluster-init-password={1}".format(
             self.master.rest_username, self.master.rest_password)
         _4 = " --cluster-init-port=8091 --cluster-init-ramsize=1000"
         command_to_init = _1 + _2 + _3 + _4
         o, e = shell.execute_non_sudo_command(command_to_init)
         shell.log_command_output(o, e)
         time.sleep(10)
         for i in range(1, len(self.servers)):
             _1 = "cd /home/{0}/opt/couchbase &&".format(
                 self.master.ssh_username)
             _2 = " ./bin/couchbase-cli server-add -c {1}:8091".format(
                 self.master.ip)
             _3 = " --server-add={2}:8091".format(self.servers[i].ip)
             _4 = " --server-add-username={3}".format(
                 self.servers[i].rest_username)
             _5 = " --server-add-password={4}".format(
                 self.servers[i].rest_password)
             _6 = " -u {0} -p {1}".format(self.servers[i].rest_username,
                                          self.servers[i].rest_password)
             command_to_rebalance = _1 + _2 + _3 + _4 + _5 + _6
             o, e = shell.execute_non_sudo_command(command_to_rebalance)
             shell.log_command_output(o, e)
             time.sleep(10)
         if len(self.servers) < 2:
             rep_count = 0
         else:
             rep_count = 1
         self.log.info("Cluster set up, now creating a bucket ..")
         _1 = "cd /home/{0}/opt/couchbase &&".format(
             self.master.ssh_username)
         _2 = " ./bin/couchbase-cli bucket-create -c localhost:8091"
         _3 = " --bucket=testbucket --bucket-type=couchbase --bucket-port=11211"
         _4 = " --bucket-ramsize=500 --bucket-replica={0} --wait".format(
             rep_count)
         _5 = " -u {0} -p {1}".format(self.master.rest_username,
                                      self.master.rest_password)
         command_to_create_bucket = _1 + _2 + _3 + _4 + _5
         o, e = shell.execute_non_sudo_command(command_to_create_bucket)
         shell.log_command_output(o, e)
         time.sleep(30)
     elif self._os == "windows":
         # TODO: Windows support
         pass
예제 #6
0
 def clean_up(self):
     self.log.info("Cleaning up nodes, stopping previous couchbase instances if any ..")
     for server in self.servers:
         shell = RemoteMachineShellConnection(server)
         if self._os == "centos" or self._os == "ubuntu":
             command = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -k".format(server.ssh_username)
             o, e = shell.execute_non_sudo_command(command)
             shell.log_command_output(o, e)
             o, e = shell.execute_non_sudo_command("rm -rf etc/ opt/ couchbase-server-enterprise_x86_64_2.2.0-772-rel.*")
             shell.log_command_output(o, e)
             command = "rm -rf backup/"
             shell.log_command_output(o, e)
         else:
             #Handling Windows?
             pass
         shell.disconnect()
예제 #7
0
 def tearDown(self):
     """
         Delete the non-root installation
     """
     self.log.info("==============  NonRootTests tearDown was started ==============")
     for server in self.servers:
         shell = RemoteMachineShellConnection(server)
         if self._os == "centos" or self._os == "ubuntu":
             command = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -k".format(server.ssh_username)
             o, e = shell.execute_non_sudo_command(command)
             shell.log_command_output(o, e)
             o, e = shell.execute_non_sudo_command("rm -rf etc/ opt/ couchbase-server-enterprise_x86_64_2.2.0-772-rel.*")
             shell.log_command_output(o, e)
         else:
             #Handling Windows?
             pass
         shell.disconnect()
예제 #8
0
 def non_root_install(self):
     for server in self.servers:
         shell = RemoteMachineShellConnection(server)
         info = shell.extract_remote_info()
         if self._os == "centos":
             command0 = "rm -rf opt/ etc/ && rm -rf {0}".format(self.build)
             command1 = "wget http://builds.hq.northscale.net/latestbuilds/{0}".format(self.build)
             command2 = "rpm2cpio {0} | cpio --extract --make-directories --no-absolute-filenames".format(self.build)
             command3 = "cd /home/{0}/opt/couchbase && ./bin/install/reloc.sh `pwd`".format(server.ssh_username)
             command4 = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -- -noinput -detached".format(server.ssh_username)
             command5 = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -k".format(server.ssh_username)
             o, e = shell.execute_non_sudo_command(command0)
             shell.log_command_output(o, e)
             o, e = shell.execute_non_sudo_command(command1)
             shell.log_command_output(o, e)
             o, e = shell.execute_non_sudo_command(command2)
             shell.log_command_output(o, e)
             o, e = shell.execute_non_sudo_command(command3)
             shell.log_command_output(o, e)
             self.log.info("Starting couchbase server <non-root, non-sudo> ..")
             o, e = shell.execute_non_sudo_command(command4)
             shell.log_command_output(o, e)
         elif self._os == "ubuntu":
             command0 = "rm -rf opt/ etc/ && rm -rf {0}".format(self.build)
             command1 = "wget http://builds.hq.northscale.net/latestbuilds/{0}".format(self.build)
             command2 = "dpkg-deb -x {0} /home/{1}".format(self.build, server.ssh_username)
             command3 = "cd /home/{0}/opt/couchbase && ./bin/install/reloc.sh `pwd`".format(server.ssh_username)
             command4 = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -- -noinput -detached".format(server.ssh_username)
             command5 = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -k".format(server.ssh_username)
             o, e = shell.execute_non_sudo_command(command0)
             shell.log_command_output(o, e)
             o, e = shell.execute_non_sudo_command(command1)
             shell.log_command_output(o, e)
             o, e = shell.execute_non_sudo_command(command2)
             shell.log_command_output(o, e)
             o, e = shell.execute_non_sudo_command(command3)
             shell.log_command_output(o, e)
             self.log.info("Starting couchbase server <non-root, non-sudo> ..")
             o, e = shell.execute_non_sudo_command(command4)
             shell.log_command_output(o, e)
         elif self._os == "windows":
             self.fail("TODO: Add instructions for windows")
         else:
             self.fail("Enter valid os name, options: centos, ubuntu, windows; entered name: {0} - invalid.".format(self._os))
예제 #9
0
 def test_create_bucket_test_load(self):
     shell = RemoteMachineShellConnection(self.master)
     self.init_rebalance_cluster_create_testbucket(self.master,
                                                   self.servers)
     if self._os == "centos" or self._os == "ubuntu":
         self.log.info("Load {0} through cbworkloadgen ..".format(
             self.num_items))
         _1 = "cd /home/{0}/opt/couchbase &&".format(
             self.master.ssh_username)
         _2 = " ./bin/cbworkloadgen -n localhost:8091"
         _3 = " -r .8 -i {0} -s 256 -b testbucket -t 1".format(
             self.num_items)
         _4 = " -u {0} -p {1}".format(self.master.rest_username,
                                      self.master.rest_password)
         command_to_load = _1 + _2 + _3 + _4
         o, e = shell.execute_non_sudo_command(command_to_load)
         shell.log_command_output(o, e)
         time.sleep(20)
         rest = RestConnection(self.master)
         item_count = rest.fetch_bucket_stats(
             bucket="testbucket")["op"]["samples"]["curr_items"][-1]
         if (item_count == self.num_items):
             self.log.info("Item count matched, {0}={1}".format(
                 item_count, self.num_items))
         else:
             self.fail("Item count: Not what's expected, {0}!={1}".format(
                 item_count, self.num_items))
         self.log.info("Deleting testbucket ..")
         _1 = "cd /home/{0}/opt/couchbase &&".format(
             self.master.ssh_username)
         _2 = " ./bin/couchbase-cli bucket-delete -c localhost:8091"
         _3 = " --bucket=testbucket"
         _4 = " -u {0} -p {1}".format(self.master.rest_username,
                                      self.master.rest_password)
         command_to_delete_bucket = _1 + _2 + _3 + _4
         o, e = shell.execute_non_sudo_command(command_to_delete_bucket)
         shell.log_command_output(o, e)
         time.sleep(10)
     elif self._os == "windows":
         # TODO: Windows support
         self.log.info("Yet to add support for windows!")
         pass
     shell.disconnect()
예제 #10
0
 def clean_up(self):
     self.log.info(
         "Cleaning up nodes, stopping previous couchbase instances if any .."
     )
     for server in self.servers:
         shell = RemoteMachineShellConnection(server)
         if self._os == "centos" or self._os == "ubuntu":
             command = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -k".format(
                 server.ssh_username)
             o, e = shell.execute_non_sudo_command(command)
             shell.log_command_output(o, e)
             command = "rm -rf etc/ opt/ usr/ {0}.*".format(self.build[:-4])
             o, e = shell.execute_non_sudo_command(command)
             shell.log_command_output(o, e)
             command = "rm -rf backup/"
             shell.log_command_output(o, e)
         else:
             #Handling Windows?
             pass
         shell.disconnect()
예제 #11
0
 def tearDown(self):
     """
         Delete the non-root installation
     """
     self.log.info(
         "==============  NonRootTests tearDown was started ==============")
     for server in self.servers:
         shell = RemoteMachineShellConnection(server)
         if self._os == "centos" or self._os == "ubuntu":
             command = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -k".format(
                 server.ssh_username)
             o, e = shell.execute_non_sudo_command(command)
             shell.log_command_output(o, e)
             command = "rm -rf etc/ opt/ usr/ {0}.*".format(self.build[:-4])
             o, e = shell.execute_non_sudo_command(command)
             shell.log_command_output(o, e)
         else:
             #Handling Windows?
             pass
         shell.disconnect()
예제 #12
0
 def init_rebalance_cluster_create_testbucket(self, master, servers):
     shell = RemoteMachineShellConnection(master)
     if self._os == "centos" or self._os == "ubuntu":
         _1 = "cd /home/{0}/opt/couchbase &&".format(master.ssh_username)
         _2 = " ./bin/couchbase-cli cluster-init -c localhost:8091"
         _3 = " --cluster-init-username={0} --cluster-init-password={1}".format(master.rest_username, master.rest_password)
         _4 = " --cluster-init-port=8091 --cluster-init-ramsize=1000"
         command_to_init = _1 + _2 + _3 + _4
         o, e = shell.execute_non_sudo_command(command_to_init)
         shell.log_command_output(o, e)
         time.sleep(10)
         for i in range(1, len(servers)):
             _1 = "cd /home/{0}/opt/couchbase &&".format(master.ssh_username)
             _2 = " ./bin/couchbase-cli rebalance -c {0}:8091".format(master.ip)
             _3 = " --server-add={0}:8091".format(servers[i].ip)
             _4 = " --server-add-username={0}".format(servers[i].rest_username)
             _5 = " --server-add-password={0}".format(servers[i].rest_password)
             _6 = " -u {0} -p {1}".format(servers[i].rest_username, servers[i].rest_password)
             command_to_rebalance = _1 + _2 + _3 + _4 + _5 + _6
             o, e = shell.execute_non_sudo_command(command_to_rebalance)
             shell.log_command_output(o, e)
             time.sleep(10)
         if len(servers) < 2:
             rep_count = 0
         else:
             rep_count = 1
         self.log.info("Cluster set up, now creating a bucket ..")
         _1 = "cd /home/{0}/opt/couchbase &&".format(master.ssh_username)
         _2 = " ./bin/couchbase-cli bucket-create -c localhost:8091"
         _3 = " --bucket=testbucket --bucket-type=couchbase --bucket-port=11211"
         _4 = " --bucket-ramsize=500 --bucket-replica={0} --wait".format(rep_count)
         _5 = " -u {0} -p {1}".format(master.rest_username, master.rest_password)
         command_to_create_bucket = _1 + _2 + _3 + _4 + _5
         o, e = shell.execute_non_sudo_command(command_to_create_bucket)
         shell.log_command_output(o, e)
         time.sleep(30)
     elif self._os == "windows":
         # TODO: Windows support
         pass
     shell.disconnect()
예제 #13
0
    def restart_es(self):
        shell = RemoteMachineShellConnection(self.__host)
        es_restart_cmd = "/etc/init.d/elasticsearch restart"
        o, e = shell.execute_non_sudo_command(es_restart_cmd)
        shell.log_command_output(o, e)

        es_start = False
        for i in range(2):
            self.sleep(10)
            if self.is_running():
                es_start = True
                break
        if not es_start:
            self.fail("Could not reach Elastic Search server on %s" % self.ip)
        else:
            self.__log.info("Restarted ES server %s successfully" %
                            self.__host.ip)
예제 #14
0
 def check_if_eventing_consumers_are_cleaned_up(self):
     eventing_nodes = self.cluster_util.get_nodes_from_services_map(service_type="eventing", get_all_nodes=True)
     array_of_counts = []
     command = "ps -ef | grep eventing-consumer | grep -v grep | wc -l"
     for eventing_node in eventing_nodes:
         shell = RemoteMachineShellConnection(eventing_node)
         count, error = shell.execute_non_sudo_command(command)
         if isinstance(count, list):
             count = int(count[0])
         else:
             count = int(count)
         self.log.info("Node : {0} , eventing_consumer processes running : {1}".format(eventing_node.ip, count))
         array_of_counts.append(count)
     count_of_all_eventing_consumers = sum(array_of_counts)
     if count_of_all_eventing_consumers != 0:
         return False
     return True
예제 #15
0
    def non_root_install(self):
        ssh_client = paramiko.SSHClient()
        ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        for server in self.servers:
            shell = RemoteMachineShellConnection(server)
            info = shell.extract_remote_info()
            ssh_client.connect(hostname=server.ip, key_filename=server.ssh_key)
            sftp_client = ssh_client.open_sftp()
            if self._os == "centos":
                command0 = "rm -rf opt/ etc/ && rm -rf couchbase-server-enterprise_x86_64_2.2.0-772-rel.rpm"
                command1 = "wget http://builds.hq.northscale.net/latestbuilds/couchbase-server-enterprise_x86_64_2.2.0-772-rel.rpm"
                command2 = "rpm2cpio couchbase-server-enterprise_x86_64_2.2.0-772-rel.rpm | cpio --extract --make-directories --no-absolute-filenames"
                command3 = "cd /home/{0}/opt/couchbase && ./bin/install/reloc.sh `pwd`".format(
                    server.ssh_username)
                command4 = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -- -noinput -detached".format(
                    server.ssh_username)
                command5 = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -k".format(
                    server.ssh_username)
                o, e = shell.execute_non_sudo_command(command0)
                shell.log_command_output(o, e)
                o, e = shell.execute_non_sudo_command(command1)
                shell.log_command_output(o, e)
                o, e = shell.execute_non_sudo_command(command2)
                shell.log_command_output(o, e)
                o, e = shell.execute_non_sudo_command(command3)
                shell.log_command_output(o, e)
                self.log.info(
                    "Starting couchbase server <non-root, non-sudo> ..")
                o, e = shell.execute_non_sudo_command(command4)
                shell.log_command_output(o, e)
            elif self._os == "ubuntu":
                command0 = "rm -rf opt/ etc/ && rm -rf couchbase-server-enterprise_x86_64_2.2.0-772-rel.deb"
                command1 = "wget http://builds.hq.northscale.net/latestbuilds/couchbase-server-enterprise_x86_64_2.2.0-772-rel.deb"
                command2 = "dpkg-deb -x couchbase-server-enterprise_x86_64_2.2.0-772-rel.deb /home/{0}".format(
                    server.ssh_username)
                command3 = "cd /home/{0}/opt/couchbase && ./bin/install/reloc.sh `pwd`".format(
                    server.ssh_username)
                command4 = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -- -noinput -detached".format(
                    server.ssh_username)
                command5 = "cd /home/{0}/opt/couchbase && ./bin/couchbase-server -k".format(
                    server.ssh_username)
                o, e = shell.execute_non_sudo_command(command0)
                shell.log_command_output(o, e)
                o, e = shell.execute_non_sudo_command(command1)
                shell.log_command_output(o, e)
                o, e = shell.execute_non_sudo_command(command2)
                shell.log_command_output(o, e)
                o, e = shell.execute_non_sudo_command(command3)
                shell.log_command_output(o, e)
                self.log.info(
                    "Starting couchbase server <non-root, non-sudo> ..")
                o, e = shell.execute_non_sudo_command(command4)
                shell.log_command_output(o, e)
                self.fail("TODO: Add instructions for ubuntu")
            elif self._os == "windows":
                self.fail("TODO: Add instructions for windows")
            else:
                self.fail(
                    "Enter valid os name, options: centos, ubuntu, windows; entered name: {0} - invalid."
                    .format(self._os))

            ssh_client.close()
예제 #16
0
 def test_bucket_backup_restore(self):
     shell = RemoteMachineShellConnection(self.master)
     self.init_rebalance_cluster_create_testbucket()
     if self._os == "centos" or self._os == "ubuntu":
         self.log.info("Load {0} through cbworkloadgen ..".format(
             self.num_items))
         _1 = "cd /home/{0}/opt/couchbase &&".format(
             self.master.ssh_username)
         _2 = " ./bin/cbworkloadgen -n localhost:8091"
         _3 = " -r .8 -i {0} -s 256 -b testbucket -t 1".format(
             self.num_items)
         _4 = " -u {0} -p {1}".format(self.master.rest_username,
                                      self.master.rest_password)
         command_to_load = _1 + _2 + _3 + _4
         o, e = shell.execute_non_sudo_command(command_to_load)
         shell.log_command_output(o, e)
         time.sleep(20)
         rest = RestConnection(self.master)
         ini_item_count = rest.fetch_bucket_stats(
             bucket="testbucket")["op"]["samples"]["curr_items"][-1]
         self.log.info("Backing up bucket 'testbucket' ..")
         _1 = "cd /home/{0}/opt/couchbase &&".format(
             self.master.ssh_username)
         _2 = " ./bin/cbbackup http://localhost:8091"
         _3 = " /home/{0}/backup".format(self.master.ssh_username)
         _4 = " -u {0} -p {1}".format(self.master.rest_username,
                                      self.master.rest_password)
         command_to_backup = _1 + _2 + _3 + _4
         o, e = shell.execute_non_sudo_command(command_to_backup)
         shell.log_command_output(o, e)
         time.sleep(10)
         self.log.info("Deleting bucket ..")
         _1 = "cd /home/{0}/opt/couchbase &&".format(
             self.master.ssh_username)
         _2 = " ./bin/couchbase-cli bucket-delete -c localhost:8091"
         _3 = " --bucket=testbucket"
         _4 = " -u {0} -p {1}".format(self.master.rest_username,
                                      self.master.rest_password)
         command_to_delete_bucket = _1 + _2 + _3 + _4
         o, e = shell.execute_non_sudo_command(command_to_delete_bucket)
         shell.log_command_output(o, e)
         time.sleep(20)
         if len(self.servers) < 2:
             rep_count = 0
         else:
             rep_count = 1
         self.log.info("Recreating bucket ..")
         _1 = "cd /home/{0}/opt/couchbase &&".format(
             self.master.ssh_username)
         _2 = " ./bin/couchbase-cli bucket-create -c localhost:8091"
         _3 = " --bucket=testbucket --bucket-type=couchbase --bucket-port=11211"
         _4 = " --bucket-ramsize=500 --bucket-replica={0} --wait".format(
             rep_count)
         _5 = " -u {0} -p {1}".format(self.master.rest_username,
                                      self.master.rest_password)
         command_to_create_bucket = _1 + _2 + _3 + _4 + _5
         o, e = shell.execute_non_sudo_command(command_to_create_bucket)
         shell.log_command_output(o, e)
         time.sleep(20)
         self.log.info("Restoring bucket 'testbucket' ..")
         _1 = "cd /home/{0}/opt/couchbase &&".format(
             self.master.ssh_username)
         _2 = " ./bin/cbrestore /home/{0}/backup http://localhost:8091".format(
             self.master.ssh_username)
         _3 = " -b testbucket -B testbucket"
         _4 = " -u {0} -p {1}".format(self.master.rest_username,
                                      self.master.rest_password)
         command_to_restore = _1 + _2 + _3 + _4
         o, e = shell.execute_non_sudo_command(command_to_restore)
         shell.log_command_output(o, e)
         time.sleep(10)
         rest = RestConnection(self.master)
         fin_item_count = rest.fetch_bucket_stats(
             bucket="testbucket")["op"]["samples"]["curr_items"][-1]
         self.log.info("Removing backed-up folder ..")
         command_to_remove_folder = "rm -rf /home/{0}/backup".format(
             self.master.ssh_username)
         o, e = shell.execute_non_sudo_command(command_to_remove_folder)
         shell.log_command_output(o, e)
         if (fin_item_count == ini_item_count):
             self.log.info(
                 "Item count before and after deleting with backup/restore matched, {0}={1}"
                 .format(fin_item_count, ini_item_count))
         else:
             self.fail(
                 "Item count didnt match - backup/restore, {0}!={1}".format(
                     fin_item_count, ini_item_count))
         self.log.info("Deleting testbucket ..")
         _1 = "cd /home/{0}/opt/couchbase &&".format(
             self.master.ssh_username)
         _2 = " ./bin/couchbase-cli bucket-delete -c localhost:8091"
         _3 = " --bucket=testbucket"
         _4 = " -u {0} -p {1}".format(self.master.rest_username,
                                      self.master.rest_password)
         command_to_delete_bucket = _1 + _2 + _3 + _4
         o, e = shell.execute_non_sudo_command(command_to_delete_bucket)
         shell.log_command_output(o, e)
         time.sleep(10)
     elif self._os == "windows":
         # TODO: Windows support
         self.log.info("Yet to add support for windows!")
         pass
예제 #17
0
    def test_xdcr(self):
        _rep_type = self.input.param("replication_type", "capi")    # capi or xmem
        _bixdcr = self.input.param("bidirectional", "false")
        _clusters_dic = self.input.clusters
        _src_nodes = copy.copy(_clusters_dic[0])
        _src_master = _src_nodes[0]
        _dest_nodes = copy.copy(_clusters_dic[1])
        _dest_master = _dest_nodes[0]

        # Build source cluster
        self.init_rebalance_cluster_create_testbucket(_src_master, _src_nodes)
        # Build destination cluster
        self.init_rebalance_cluster_create_testbucket(_dest_master, _dest_nodes)

        # Setting up XDCR
        self.setup_xdcr_start_replication(_src_master, _dest_master, _rep_type, _bixdcr)

        shell1 = RemoteMachineShellConnection(_src_master)
        shell2 = RemoteMachineShellConnection(_dest_master)
        src_item_count = 0
        dest_item_count = 0
        if self._os == "centos" or self._os == "ubuntu":
            self.log.info("Load {0} through cbworkloadgen at src..".format(self.num_items))
            _1 = "cd /home/{0}/opt/couchbase &&".format(_src_master.ssh_username)
            _2 = " ./bin/cbworkloadgen -n localhost:8091 --prefix=s_"
            _3 = " -r .8 -i {0} -s 256 -b testbucket -t 1".format(self.num_items)
            _4 = " -u {0} -p {1}".format(_src_master.rest_username, _src_master.rest_password)
            command_to_load = _1 + _2 + _3 + _4
            o, e = shell1.execute_non_sudo_command(command_to_load)
            shell1.log_command_output(o, e)
            time.sleep(20)
            rest = RestConnection(_src_master)
            src_item_count = rest.fetch_bucket_stats(bucket="testbucket")["op"]["samples"]["curr_items"][-1]
            if _bixdcr:
                self.log.info("Load {0} through cbworkloadgen at src..".format(self.num_items))
                _1 = "cd /home/{0}/opt/couchbase &&".format(_dest_master.ssh_username)
                _2 = " ./bin/cbworkloadgen -n localhost:8091 --prefix=d_"
                _3 = " -r .8 -i {0} -s 256 -b testbucket -t 1".format(self.num_items)
                _4 = " -u {0} -p {1}".format(_dest_master.rest_username, _dest_master.rest_password)
                command_to_load = _1 + _2 + _3 + _4
                o, e = shell2.execute_non_sudo_command(command_to_load)
                shell2.log_command_output(o, e)
                time.sleep(20)
                rest = RestConnection(_dest_master)
                dest_item_count = rest.fetch_bucket_stats(bucket="testbucket")["op"]["samples"]["curr_items"][-1]
            self.wait_for_replication_to_catchup(_src_master, _dest_master, 1200, "destination")
            if _bixdcr:
                self.wait_for_replication_to_catchup(_dest_master, _src_master, 1200, "source")
            self.log.info("XDC REPLICATION caught up")
            rest1 = RestConnection(_src_master)
            rest2 = RestConnection(_dest_master)
            curr_count_on_src = rest1.fetch_bucket_stats(bucket="testbucket")["op"]["samples"]["curr_items"][-1]
            curr_count_on_dest = rest2.fetch_bucket_stats(bucket="testbucket")["op"]["samples"]["curr_items"][-1]
            assert(curr_count_on_src==(src_item_count + dest_item_count), "ItemCount on source not what's expected")
            assert(curr_count_on_dest==(src_item_count + dest_item_count), "ItemCount on destination not what's expected")
        elif self._os == "windows":
            # TODO: Windows support
            self.log.info("Yet to add support for windows!")
            pass
        shell1.disconnect()
        shell2.disconnect()
예제 #18
0
 def test_bucket_backup_restore(self):
     shell = RemoteMachineShellConnection(self.master)
     self.init_rebalance_cluster_create_testbucket()
     if self._os == "centos" or self._os == "ubuntu":
         self.log.info("Load {0} through cbworkloadgen ..".format(self.num_items))
         _1 = "cd /home/{0}/opt/couchbase &&".format(self.master.ssh_username)
         _2 = " ./bin/cbworkloadgen -n localhost:8091"
         _3 = " -r .8 -i {0} -s 256 -b testbucket -t 1".format(self.num_items)
         _4 = " -u {0} -p {1}".format(self.master.rest_username, self.master.rest_password)
         command_to_load = _1 + _2 + _3 + _4
         o, e = shell.execute_non_sudo_command(command_to_load)
         shell.log_command_output(o, e)
         time.sleep(20)
         rest = RestConnection(self.master)
         ini_item_count = rest.fetch_bucket_stats(bucket="testbucket")["op"]["samples"]["curr_items"][-1]
         self.log.info("Backing up bucket 'testbucket' ..")
         _1 = "cd /home/{0}/opt/couchbase &&".format(self.master.ssh_username)
         _2 = " ./bin/cbbackup http://localhost:8091"
         _3 = " /home/{0}/backup".format(self.master.ssh_username)
         _4 = " -u {0} -p {1}".format(self.master.rest_username, self.master.rest_password)
         command_to_backup = _1 + _2 + _3 + _4
         o, e = shell.execute_non_sudo_command(command_to_backup)
         shell.log_command_output(o, e)
         time.sleep(10)
         self.log.info("Deleting bucket ..")
         _1 = "cd /home/{0}/opt/couchbase &&".format(self.master.ssh_username)
         _2 = " ./bin/couchbase-cli bucket-delete -c localhost:8091"
         _3 = " --bucket=testbucket"
         _4 = " -u {0} -p {1}".format(self.master.rest_username, self.master.rest_password)
         command_to_delete_bucket = _1 + _2 + _3 + _4
         o, e = shell.execute_non_sudo_command(command_to_delete_bucket)
         shell.log_command_output(o, e)
         time.sleep(20)
         if len(self.servers) < 2:
             rep_count = 0
         else:
             rep_count = 1
         self.log.info("Recreating bucket ..")
         _1 = "cd /home/{0}/opt/couchbase &&".format(self.master.ssh_username)
         _2 = " ./bin/couchbase-cli bucket-create -c localhost:8091"
         _3 = " --bucket=testbucket --bucket-type=couchbase --bucket-port=11211"
         _4 = " --bucket-ramsize=500 --bucket-replica={0} --wait".format(rep_count)
         _5 = " -u {0} -p {1}".format(self.master.rest_username, self.master.rest_password)
         command_to_create_bucket = _1 + _2 + _3 + _4 + _5
         o, e = shell.execute_non_sudo_command(command_to_create_bucket)
         shell.log_command_output(o, e)
         time.sleep(20)
         self.log.info("Restoring bucket 'testbucket' ..")
         _1 = "cd /home/{0}/opt/couchbase &&".format(self.master.ssh_username)
         _2 = " ./bin/cbrestore /home/{0}/backup http://localhost:8091".format(self.master.ssh_username)
         _3 = " -b testbucket -B testbucket"
         _4 = " -u {0} -p {1}".format(self.master.rest_username, self.master.rest_password)
         command_to_restore = _1 + _2 + _3 + _4
         o, e = shell.execute_non_sudo_command(command_to_restore)
         shell.log_command_output(o, e)
         time.sleep(10)
         rest = RestConnection(self.master)
         fin_item_count = rest.fetch_bucket_stats(bucket="testbucket")["op"]["samples"]["curr_items"][-1]
         self.log.info("Removing backed-up folder ..")
         command_to_remove_folder = "rm -rf /home/{0}/backup".format(self.master.ssh_username)
         o, e = shell.execute_non_sudo_command(command_to_remove_folder)
         shell.log_command_output(o, e)
         if (fin_item_count == ini_item_count):
             self.log.info("Item count before and after deleting with backup/restore matched, {0}={1}".format(
                 fin_item_count, ini_item_count))
         else:
             self.fail("Item count didnt match - backup/restore, {0}!={1}".format(fin_item_count, ini_item_count))
         self.log.info("Deleting testbucket ..");
         _1 = "cd /home/{0}/opt/couchbase &&".format(self.master.ssh_username)
         _2 = " ./bin/couchbase-cli bucket-delete -c localhost:8091"
         _3 = " --bucket=testbucket"
         _4 = " -u {0} -p {1}".format(self.master.rest_username, self.master.rest_password)
         command_to_delete_bucket = _1 + _2 + _3 + _4
         o, e = shell.execute_non_sudo_command(command_to_delete_bucket)
         shell.log_command_output(o, e)
         time.sleep(10)
     elif self._os == "windows":
         # TODO: Windows support
         self.log.info("Yet to add support for windows!")
         pass
예제 #19
0
    def test_xdcr(self):
        _rep_type = self.input.param("replication_type",
                                     "capi")  # capi or xmem
        _bixdcr = self.input.param("bidirectional", "false")
        _clusters_dic = self.input.clusters
        _src_nodes = copy.copy(_clusters_dic[0])
        _src_master = _src_nodes[0]
        _dest_nodes = copy.copy(_clusters_dic[1])
        _dest_master = _dest_nodes[0]

        # Build source cluster
        self.init_rebalance_cluster_create_testbucket(_src_master, _src_nodes)
        # Build destination cluster
        self.init_rebalance_cluster_create_testbucket(_dest_master,
                                                      _dest_nodes)

        # Setting up XDCR
        self.setup_xdcr_start_replication(_src_master, _dest_master, _rep_type,
                                          _bixdcr)

        shell1 = RemoteMachineShellConnection(_src_master)
        shell2 = RemoteMachineShellConnection(_dest_master)
        src_item_count = 0
        dest_item_count = 0
        if self._os == "centos" or self._os == "ubuntu":
            self.log.info("Load {0} through cbworkloadgen at src..".format(
                self.num_items))
            _1 = "cd /home/{0}/opt/couchbase &&".format(
                _src_master.ssh_username)
            _2 = " ./bin/cbworkloadgen -n localhost:8091 --prefix=s_"
            _3 = " -r .8 -i {0} -s 256 -b testbucket -t 1".format(
                self.num_items)
            _4 = " -u {0} -p {1}".format(_src_master.rest_username,
                                         _src_master.rest_password)
            command_to_load = _1 + _2 + _3 + _4
            o, e = shell1.execute_non_sudo_command(command_to_load)
            shell1.log_command_output(o, e)
            time.sleep(20)
            rest = RestConnection(_src_master)
            src_item_count = rest.fetch_bucket_stats(
                bucket="testbucket")["op"]["samples"]["curr_items"][-1]
            if _bixdcr:
                self.log.info("Load {0} through cbworkloadgen at src..".format(
                    self.num_items))
                _1 = "cd /home/{0}/opt/couchbase &&".format(
                    _dest_master.ssh_username)
                _2 = " ./bin/cbworkloadgen -n localhost:8091 --prefix=d_"
                _3 = " -r .8 -i {0} -s 256 -b testbucket -t 1".format(
                    self.num_items)
                _4 = " -u {0} -p {1}".format(_dest_master.rest_username,
                                             _dest_master.rest_password)
                command_to_load = _1 + _2 + _3 + _4
                o, e = shell2.execute_non_sudo_command(command_to_load)
                shell2.log_command_output(o, e)
                time.sleep(20)
                rest = RestConnection(_dest_master)
                dest_item_count = rest.fetch_bucket_stats(
                    bucket="testbucket")["op"]["samples"]["curr_items"][-1]
            self.wait_for_replication_to_catchup(_src_master, _dest_master,
                                                 1200, "destination")
            if _bixdcr:
                self.wait_for_replication_to_catchup(_dest_master, _src_master,
                                                     1200, "source")
            self.log.info("XDC REPLICATION caught up")
            rest1 = RestConnection(_src_master)
            rest2 = RestConnection(_dest_master)
            curr_count_on_src = rest1.fetch_bucket_stats(
                bucket="testbucket")["op"]["samples"]["curr_items"][-1]
            curr_count_on_dest = rest2.fetch_bucket_stats(
                bucket="testbucket")["op"]["samples"]["curr_items"][-1]
            assert (curr_count_on_src == (src_item_count + dest_item_count),
                    "ItemCount on source not what's expected")
            assert (curr_count_on_dest == (src_item_count + dest_item_count),
                    "ItemCount on destination not what's expected")
        elif self._os == "windows":
            # TODO: Windows support
            self.log.info("Yet to add support for windows!")
            pass
        shell1.disconnect()
        shell2.disconnect()
예제 #20
0
 def setup_xdcr_start_replication(self, src, dest, rep_type, bidirectional):
     shell1 = RemoteMachineShellConnection(src)
     shell2 = RemoteMachineShellConnection(dest)
     if self._os == "centos" or self._os == "ubuntu":
         self.log.info(
             "Setting up XDCR from source cluster to destination cluster .."
         )
         _1 = "cd /home/{0}/opt/couchbase &&".format(src.ssh_username)
         _2 = " ./bin/couchbase-cli xdcr-setup -c localhost:8091"
         _3 = " --create --xdcr-cluster-name=_dest --xdcr-hostname={0}:8091".format(
             dest.ip)
         _4 = " --xdcr-username={0} --xdcr-password={1}".format(
             dest.rest_username, dest.rest_password)
         _5 = " -u {0} -p {1}".format(src.rest_username, src.rest_password)
         command_to_setup_xdcr = _1 + _2 + _3 + _4 + _5
         o, e = shell1.execute_non_sudo_command(command_to_setup_xdcr)
         shell1.log_command_output(o, e)
         if bidirectional:
             self.log.info(
                 "Setting up XDCR from destination cluster to source cluster .."
             )
             _1 = "cd /home/{0}/opt/couchbase &&".format(dest.ssh_username)
             _2 = " ./bin/couchbase-cli xdcr-setup -c localhost:8091"
             _3 = " --create --xdcr-cluster-name=_src --xdcr-hostname={0}:8091".format(
                 src.ip)
             _4 = " --xdcr-username={0} --xdcr-password={1}".format(
                 src.rest_username, src.rest_password)
             _5 = " -u {0} -p {1}".format(dest.rest_username,
                                          dest.rest_password)
             command_to_setup_xdcr = _1 + _2 + _3 + _4 + _5
             o, e = shell2.execute_non_sudo_command(command_to_setup_xdcr)
             shell2.log_command_output(o, e)
         time.sleep(10)
         self.log.info("Starting replication from source to destination ..")
         _1 = "cd /home/{0}/opt/couchbase &&".format(src.ssh_username)
         _2 = " ./bin/couchbase-cli xdcr-replicate -c localhost:8091"
         _3 = " --create --xdcr-cluster-name=_dest --xdcr-from-bucket=testbucket"
         _4 = " --xdcr-to-bucket=testbucket --xdcr-replication-mode={0}".format(
             rep_type)
         _5 = " -u {0} -p {1}".format(src.rest_username, src.rest_password)
         command_to_setup_xdcr = _1 + _2 + _3 + _4 + _5
         o, e = shell1.execute_non_sudo_command(command_to_setup_xdcr)
         shell1.log_command_output(o, e)
         if bidirectional:
             self.log.info(
                 "Starting replication from destination to source ..")
             _1 = "cd /home/{0}/opt/couchbase &&".format(dest.ssh_username)
             _2 = " ./bin/couchbase-cli xdcr-replicate -c localhost:8091"
             _3 = " --create --xdcr-cluster-name=_src --xdcr-from-bucket=testbucket"
             _4 = " --xdcr-to-bucket=testbucket --xdcr-replication-mode={0}".format(
                 rep_type)
             _5 = " -u {0} -p {1}".format(dest.rest_username,
                                          dest.rest_password)
             command_to_setup_xdcr = _1 + _2 + _3 + _4 + _5
             o, e = shell2.execute_non_sudo_command(command_to_setup_xdcr)
             shell2.log_command_output(o, e)
         time.sleep(10)
     elif self._os == "windows":
         # TODO: WIndows support
         pass
     shell1.disconnect()
     shell2.disconnect()