def install(self, params):
# log = logger.new_logger("Installer")
build = self.build_url(params)
remote_client = RemoteMachineShellConnection(params["server"])
info = remote_client.extract_remote_info()
type = info.type.lower()
server = params["server"]
if "vbuckets" in params:
vbuckets = int(params["vbuckets"][0])
else:
vbuckets = None
if type == "windows":
build = self.build_url(params)
remote_client.download_binary_in_win(build.url, params["product"], params["version"])
remote_client.membase_install_win(build, params["version"])
else:
downloaded = remote_client.download_build(build)
if not downloaded:
log.error(downloaded, 'unable to download binaries : {0}'.format(build.url))
#TODO: need separate methods in remote_util for couchbase and membase install
path = server.data_path or '/tmp'
remote_client.membase_install(build, path=path, vbuckets=vbuckets)
log.info('wait 5 seconds for membase server to start')
time.sleep(5)
if "rest_vbuckets" in params:
rest_vbuckets = int(params["rest_vbuckets"])
ClusterOperationHelper.set_vbuckets(server, rest_vbuckets)
def tearDown(self):
master = self.servers[0]
ClusterOperationHelper.set_vbuckets(master, self.old_vbuckets)
rest = RestConnection(master)
rest.stop_rebalance()
self.cluster.rebalance(self.servers[:self.num_servers], [],
self.servers[1:self.num_servers])
self.cluster.bucket_delete(master, self.bucket)
self.cluster.shutdown()
def tearDown(self):
master = self.servers[0]
ClusterOperationHelper.set_vbuckets(master, self.old_vbuckets)
rest = RestConnection(master)
rest.stop_rebalance()
self.cluster.rebalance(self.servers[:self.num_servers], [],
self.servers[1:self.num_servers])
self.cluster.bucket_delete(master, self.bucket)
self.cluster.shutdown()
def setUp(self):
self.cluster = Cluster()
self.input = TestInputSingleton.input
self.servers = self.input.servers
self.num_servers = self.input.param("servers", 1)
master = self.servers[0]
num_replicas = self.input.param("replicas", 1)
self.bucket = 'default'
# Start: Should be in a before class function
BucketOperationHelper.delete_all_buckets_or_assert(self.servers, self)
for server in self.servers:
ClusterOperationHelper.cleanup_cluster([server])
ClusterOperationHelper.wait_for_ns_servers_or_assert([master], self)
# End: Should be in a before class function
self.quota = self.cluster.init_node(master)
self.old_vbuckets = self._get_vbuckets(master)
ClusterOperationHelper.set_vbuckets(master, 1)
self.cluster.create_default_bucket(master, self.quota, num_replicas)
self.cluster.rebalance(self.servers[:self.num_servers],
self.servers[1:self.num_servers], [])
def setUp(self):
self.cluster = Cluster()
self.input = TestInputSingleton.input
self.servers = self.input.servers
self.num_servers = self.input.param("servers", 1)
master = self.servers[0]
num_replicas = self.input.param("replicas", 1)
self.bucket = 'default'
# Start: Should be in a before class function
BucketOperationHelper.delete_all_buckets_or_assert(self.servers, self)
for server in self.servers:
ClusterOperationHelper.cleanup_cluster([server])
ClusterOperationHelper.wait_for_ns_servers_or_assert([master], self)
# End: Should be in a before class function
self.quota = self.cluster.init_node(master)
self.old_vbuckets = self._get_vbuckets(master)
ClusterOperationHelper.set_vbuckets(master, 1)
self.cluster.create_default_bucket(master, self.quota, num_replicas)
self.cluster.rebalance(self.servers[:self.num_servers],
self.servers[1:self.num_servers], [])
class CouchbaseServerInstaller(Installer):
def __init__(self):
Installer.__init__(self)
def initialize(self, params):
start_time = time.time()
cluster_initialized = False
server = params["server"]
remote_client = RemoteMachineShellConnection(params["server"])
while time.time() < start_time + 5 * 60:
try:
rest = RestConnection(server)
# Optionally change node name and restart server
if params.get('use_domain_names', 0):
remote_client.set_node_name(server.ip)
rest.rename_node(server.ip)
# Make sure that data_path and index_path are writable by couchbase user
for path in set(filter(None, [server.data_path, server.index_path])):
time.sleep(3)
for cmd in ("rm -rf {0}/*".format(path),
"chown -R couchbase:couchbase {0}".format(path)):
remote_client.execute_command(cmd)
rest.set_data_path(data_path=server.data_path,
index_path=server.index_path)
time.sleep(3)
# Initialize cluster
rest.init_cluster(username=server.rest_username,
password=server.rest_password)
memory_quota = rest.get_nodes_self().mcdMemoryReserved
rest.init_cluster_memoryQuota(memoryQuota=memory_quota)
# TODO: Symlink data-dir to custom path
# remote_client.stop_couchbase()
# remote_client.execute_command('mv /opt/couchbase/var {0}'.format(server.data_path))
# remote_client.execute_command('ln -s {0}/var /opt/couchbase/var'.format(server.data_path))
# remote_client.execute_command("chown -h couchbase:couchbase /opt/couchbase/var")
# remote_client.start_couchbase()
# Optionally disable consistency check
if params.get('disable_consistency', 0):
rest.set_couchdb_option(section='couchdb',
option='consistency_check_ratio',
value='0.0')
# memcached env variable
mem_req_tap_env = params.get('MEMCACHED_REQS_TAP_EVENT', 0)
if mem_req_tap_env:
remote_client.set_environment_variable('MEMCACHED_REQS_TAP_EVENT',
mem_req_tap_env)
remote_client.disconnect()
# TODO: Make it work with windows
if "erlang_threads" in params:
num_threads = params.get('erlang_threads', testconstants.NUM_ERLANG_THREADS)
# Stop couchbase-server
ClusterOperationHelper.stop_cluster([server])
if "sync_threads" in params or ':' in num_threads:
sync_threads = params.get('sync_threads', True)
else:
sync_threads = False
# Change type of threads(sync/async) and num erlang threads
ClusterOperationHelper.change_erlang_threads_values([server], sync_threads, num_threads)
# Start couchbase-server
ClusterOperationHelper.start_cluster([server])
if "erlang_gc_level" in params:
erlang_gc_level = params.get('erlang_gc_level', None)
if erlang_gc_level is None:
# Don't change the value
break
# Stop couchbase-server
ClusterOperationHelper.stop_cluster([server])
# Change num erlang threads
ClusterOperationHelper.change_erlang_gc([server], erlang_gc_level)
# Start couchbase-server
ClusterOperationHelper.start_cluster([server])
cluster_initialized = True
break
except ServerUnavailableException:
log.error("error happened while initializing the cluster @ {0}".format(server.ip))
log.info('sleep for 5 seconds before trying again ...')
time.sleep(5)
if not cluster_initialized:
raise Exception("unable to initialize couchbase node")
def install(self, params, queue=None):
try:
build = self.build_url(params)
except Exception, e:
if queue:
queue.put(False)
raise e
remote_client = RemoteMachineShellConnection(params["server"])
info = remote_client.extract_remote_info()
type = info.type.lower()
server = params["server"]
if "swappiness" in params:
swappiness = int(params["swappiness"])
else:
swappiness = 10
if "vbuckets" in params:
vbuckets = int(params["vbuckets"][0])
else:
vbuckets = None
if type == "windows":
remote_client.download_binary_in_win(build.url, params["version"])
success = remote_client.install_server_win(build, params["version"].replace("-rel",""))
else:
downloaded = remote_client.download_build(build)
if not downloaded:
log.error('unable to download binaries : {0}'.format(build.url))
return False
# TODO: need separate methods in remote_util for couchbase and membase install
path = server.data_path or '/tmp'
try:
success = remote_client.install_server(build, path=path, vbuckets=vbuckets, swappiness=swappiness)
log.info('wait 5 seconds for membase server to start')
time.sleep(5)
if "rest_vbuckets" in params:
rest_vbuckets = int(params["rest_vbuckets"])
ClusterOperationHelper.set_vbuckets(server, rest_vbuckets)
except BaseException, e:
success = False
log.error("installation failed: {0}".format(e))
