def replicate_pause_resume(self):
if not self.replicator:
print "Error: option --xdcr-replicator is needed to pause/resume a replication"
return
rest = util.restclient_factory(self.server,
self.port,
{'debug':self.debug},
self.ssl)
opts = {
'error_msg': "unable to retrieve any replication streams",
'success_msg': "list replication streams"
}
output_result = rest.restCmd('GET',
'/pools/default/tasks',
self.user,
self.password,
opts)
tasks = rest.getJson(output_result)
for task in tasks:
if task["type"] == "xdcr" and task["id"] == self.replicator:
if self.cmd == "pause" and task["status"] == "notRunning":
print "The replication is not running yet. Pause is not needed"
return
if self.cmd == "resume" and task["status"] == "running":
print "The replication is running already. Resume is not needed"
return
break
rest = util.restclient_factory(self.server,
self.port,
{'debug':self.debug},
self.ssl)
self.rest_cmd = '/settings/replications/' + urllib.quote_plus(self.replicator)
if self.cmd == "pause":
rest.setParam('pauseRequested', node.bool_to_str(1))
elif self.cmd == "resume":
rest.setParam('pauseRequested', node.bool_to_str(0))
opts = {
'error_msg': "unable to %s replication" % self.cmd,
'success_msg': "%s replication" % self.cmd
}
output_result = rest.restCmd('POST',
self.rest_cmd,
self.user,
self.password,
opts)
print output_result
def runCmd(self, cmd, server, port, user, password, ssl, opts):
vm = 'ns_server'
for (o, a) in opts:
if o == '-d' or o == '--debug':
self.debug = True
if o == '--vm':
vm = a
rest = util.restclient_factory(server, port, {'debug': self.debug},
ssl)
opts = {'error_msg': 'server-info error'}
data = rest.restCmd('GET', '/nodes/self', user, password, opts)
json = rest.getJson(data)
for x in ['license', 'licenseValid', 'licenseValidUntil']:
if x in json:
del (json[x])
if cmd == 'server-eshell':
node = json['otpNode']
cookie = json['otpCookie']
if vm != 'ns_server':
rest = util.restclient_factory(server, port,
{'debug': self.debug}, ssl)
rest.setPayload('ns_server:get_babysitter_cookie().')
cookie = rest.sendCmd('POST', '/diag/eval', user,
password).read()
[short, _] = node.split('@')
if vm == 'babysitter':
node = 'babysitter_of_%[email protected]' % short
elif vm == 'couchdb':
node = 'couchdb_%[email protected]' % short
else:
raise ValueError("unknown vm type \'%s\'" % vm)
name = self._remoteShellName()
p = subprocess.call([
'erl', '-name', name, '-setcookie', cookie, '-hidden',
'-remsh', node
])
elif cmd == 'get-server-info':
return json
else:
print simplejson.dumps(json, sort_keys=True, indent=2)
def runCmd(self, cmd, server, port,
user, password, ssl, opts):
for (o, a) in opts:
if o == '-d' or o == '--debug':
self.debug = True
rest = util.restclient_factory(server, port, {'debug':self.debug}, ssl)
opts = {'error_msg': 'server-info error'}
data = rest.restCmd('GET', '/nodes/self',
user, password, opts)
json = rest.getJson(data)
for x in ['license', 'licenseValid', 'licenseValidUntil']:
if x in json:
del(json[x])
if cmd == 'get-server-info':
return json
elif cmd == 'server-eshell':
name = self._remoteShellName()
p = subprocess.call(['erl','-name',name,
'-setcookie',json['otpCookie'],'-hidden','-remsh',json['otpNode']])
else:
print simplejson.dumps(json, sort_keys=True, indent=2)
def setup_list(self):
rest = util.restclient_factory(self.server,
self.port,
{'debug':self.debug},
self.ssl)
opts = {
'error_msg': "unable to list xdcr remote cluster",
'success_msg': "list remote cluster successfully",
}
output_result = rest.restCmd('GET',
self.rest_cmd,
self.user,
self.password,
opts)
clusters = rest.getJson(output_result)
if self.output == 'json':
print output_result
else:
for cluster in clusters:
if not cluster.get('deleted'):
print "cluster name: %s" % cluster["name"]
print " uuid: %s" % cluster["uuid"]
print " host name: %s" % cluster["hostname"]
print " user name: %s" % cluster["username"]
print " uri: %s" % cluster["uri"]
def replicate_start(self):
rest = util.restclient_factory(self.server,
self.port,
{'debug':self.debug},
self.ssl)
if self.to_bucket:
rest.setParam('toBucket', self.to_bucket)
if self.remote_cluster:
rest.setParam('toCluster', self.remote_cluster)
if self.from_bucket:
rest.setParam('fromBucket', self.from_bucket)
if self.replication_mode:
rest.setParam('type', self.replication_mode)
if self.regex:
rest.setParam('filterExpression', self.regex)
rest.setParam('replicationType', 'continuous')
opts = {
'error_msg': "unable to create replication",
'success_msg': "start replication"
}
output_result = rest.restCmd(self.method,
self.rest_cmd,
self.user,
self.password,
opts)
print output_result
def replicate_start(self):
rest = util.restclient_factory(self.server, self.port,
{'debug': self.debug}, self.ssl)
if self.to_bucket:
rest.setParam('toBucket', self.to_bucket)
if self.remote_cluster:
rest.setParam('toCluster', self.remote_cluster)
if self.from_bucket:
rest.setParam('fromBucket', self.from_bucket)
if self.replication_mode:
rest.setParam('type', self.replication_mode)
if self.regex:
rest.setParam('filterExpression', self.regex)
rest.setParam('replicationType', 'continuous')
opts = {
'error_msg': "unable to create replication",
'success_msg': "start replication"
}
output_result = rest.restCmd(self.method, self.rest_cmd, self.user,
self.password, opts)
print output_result
def runCmd(self, cmd, server, port,
user, password, ssl, opts):
vm = 'ns_server'
for (o, a) in opts:
if o == '-d' or o == '--debug':
self.debug = True
if o == '--vm':
vm = a
rest = util.restclient_factory(server, port, {'debug':self.debug}, ssl)
opts = {'error_msg': 'server-info error'}
data = rest.restCmd('GET', '/nodes/self',
user, password, opts)
json = rest.getJson(data)
for x in ['license', 'licenseValid', 'licenseValidUntil']:
if x in json:
del(json[x])
if cmd == 'server-eshell':
node = json['otpNode']
cookie = json['otpCookie']
if vm != 'ns_server':
rest = util.restclient_factory(server, port, {'debug':self.debug}, ssl)
rest.setPayload('ns_server:get_babysitter_cookie().')
cookie = rest.sendCmd('POST', '/diag/eval', user, password).read()
[short, _] = node.split('@')
if vm == 'babysitter':
node = 'babysitter_of_%[email protected]' % short
elif vm == 'couchdb':
node = 'couchdb_%[email protected]' % short
else:
raise ValueError("unknown vm type \'%s\'" % vm)
name = self._remoteShellName()
p = subprocess.call(['erl', '-name', name, '-setcookie',
cookie, '-hidden', '-remsh', node])
elif cmd == 'get-server-info':
return json
else:
print simplejson.dumps(json, sort_keys=True, indent=2)
def replicate_settings(self):
rest = util.restclient_factory(self.server,
self.port,
{'debug':self.debug},
self.ssl)
opts = {
'error_msg': "unable to set xdcr replication settings",
'success_msg': "set xdcr replication settings"
}
if self.replicator:
self.rest_cmd = '/settings/replications/' + urllib.quote_plus(self.replicator)
else:
print "Error: option --xdcr-replicator is needed to update replication settings"
return
if self.checkpoint_interval:
rest.setParam('checkpointInterval', self.checkpoint_interval)
opts['success_msg'] += ' xdcrCheckpointInterval'
if self.worker_batch_size:
rest.setParam('workerBatchSize', self.worker_batch_size)
opts['success_msg'] += ' xdcrWorkerBatchSize'
if self.doc_batch_size:
rest.setParam('docBatchSizeKb', self.doc_batch_size)
opts['success_msg'] += ' xdcrDocBatchSizeKb'
if self.failure_restart_interval:
rest.setParam('failureRestartInterval', self.failure_restart_interval)
opts['success_msg'] += ' xdcrFailureRestartInterval'
if self.optimistic_replication_threshold:
rest.setParam('optimisticReplicationThreshold', self.optimistic_replication_threshold)
opts['success_msg'] += ' xdcrOptimisticReplicationThreshold'
if self.source_nozzle_per_node:
rest.setParam('sourceNozzlePerNode', self.source_nozzle_per_node)
opts['success_msg'] += ' xdcrSourceNozzlePerNode'
if self.target_nozzle_per_node:
rest.setParam('targetNozzlePerNode', self.target_nozzle_per_node)
opts['success_msg'] += ' xdcrTargetNozzlePerNode'
if self.log_level:
rest.setParam('logLevel', self.log_level)
opts['success_msg'] += ' xdcrLogLevel'
if self.stats_interval:
rest.setParam('statsInterval', self.stats_interval)
opts['success_msg'] += ' xdcrStatsInterval'
output_result = rest.restCmd(self.method,
self.rest_cmd,
self.user,
self.password,
opts)
print output_result
def runCmd(self, cmd, server, port, user, password, ssl, opts):
opts = {}
opts['error_msg'] = "unable to %s" % cmd
opts['success_msg'] = "%s" % cmd
#print server, port, cmd, self.rest_cmd
rest = util.restclient_factory(server, port, {'debug': self.debug},
ssl)
data = rest.restCmd(methods[cmd], self.rest_cmd, user, password, opts)
return rest.getJson(data)
def replicate_settings(self):
rest = util.restclient_factory(self.server, self.port,
{'debug': self.debug}, self.ssl)
opts = {
'error_msg': "unable to set xdcr replication settings",
'success_msg': "set xdcr replication settings"
}
if self.replicator:
self.rest_cmd = '/settings/replications/' + urllib.quote_plus(
self.replicator)
else:
print "Error: option --xdcr-replicator is needed to update replication settings"
return
if self.checkpoint_interval:
rest.setParam('checkpointInterval', self.checkpoint_interval)
opts['success_msg'] += ' xdcrCheckpointInterval'
if self.worker_batch_size:
rest.setParam('workerBatchSize', self.worker_batch_size)
opts['success_msg'] += ' xdcrWorkerBatchSize'
if self.doc_batch_size:
rest.setParam('docBatchSizeKb', self.doc_batch_size)
opts['success_msg'] += ' xdcrDocBatchSizeKb'
if self.failure_restart_interval:
rest.setParam('failureRestartInterval',
self.failure_restart_interval)
opts['success_msg'] += ' xdcrFailureRestartInterval'
if self.optimistic_replication_threshold:
rest.setParam('optimisticReplicationThreshold',
self.optimistic_replication_threshold)
opts['success_msg'] += ' xdcrOptimisticReplicationThreshold'
if self.source_nozzle_per_node:
rest.setParam('sourceNozzlePerNode', self.source_nozzle_per_node)
opts['success_msg'] += ' xdcrSourceNozzlePerNode'
if self.target_nozzle_per_node:
rest.setParam('targetNozzlePerNode', self.target_nozzle_per_node)
opts['success_msg'] += ' xdcrTargetNozzlePerNode'
if self.log_level:
rest.setParam('logLevel', self.log_level)
opts['success_msg'] += ' xdcrLogLevel'
if self.stats_interval:
rest.setParam('statsInterval', self.stats_interval)
opts['success_msg'] += ' xdcrStatsInterval'
output_result = rest.restCmd(self.method, self.rest_cmd, self.user,
self.password, opts)
print output_result
def runCmd(self, cmd, server, port,
user, password, ssl, opts):
opts = {}
opts['error_msg'] = "unable to %s" % cmd
opts['success_msg'] = "%s" % cmd
#print server, port, cmd, self.rest_cmd
rest = util.restclient_factory(server, port, {'debug':self.debug}, ssl)
data = rest.restCmd(methods[cmd], self.rest_cmd,
user, password, opts)
return rest.getJson(data)
def getData(self, server, port, user, password):
"""
getData()
Obtain the raw json output from the server
The reason for passing arguments which could be obtained
from 'self' is because getData() must be callable externally
"""
self.rest = util.restclient_factory(server, port,
{'debug': self.debug}, self.ssl)
return self.rest.restCmd('GET', self.rest_cmd, user, password)
def replicate_pause_resume(self):
if not self.replicator:
print "Error: option --xdcr-replicator is needed to pause/resume a replication"
return
rest = util.restclient_factory(self.server, self.port,
{'debug': self.debug}, self.ssl)
opts = {
'error_msg': "unable to retrieve any replication streams",
'success_msg': "list replication streams"
}
output_result = rest.restCmd('GET', '/pools/default/tasks', self.user,
self.password, opts)
tasks = rest.getJson(output_result)
for task in tasks:
if task["type"] == "xdcr" and task["id"] == self.replicator:
if self.cmd == "pause" and task["status"] == "notRunning":
print "The replication is not running yet. Pause is not needed"
return
if self.cmd == "resume" and task["status"] == "running":
print "The replication is running already. Resume is not needed"
return
break
rest = util.restclient_factory(self.server, self.port,
{'debug': self.debug}, self.ssl)
self.rest_cmd = '/settings/replications/' + urllib.quote_plus(
self.replicator)
if self.cmd == "pause":
rest.setParam('pauseRequested', node.bool_to_str(1))
elif self.cmd == "resume":
rest.setParam('pauseRequested', node.bool_to_str(0))
opts = {
'error_msg': "unable to %s replication" % self.cmd,
'success_msg': "%s replication" % self.cmd
}
output_result = rest.restCmd('POST', self.rest_cmd, self.user,
self.password, opts)
print output_result
def getData(self, server, port, user, password):
"""
getData()
Obtain the raw json output from the server
The reason for passing arguments which could be obtained
from 'self' is because getData() must be callable externally
"""
self.rest = util.restclient_factory(server, port,
{'debug':self.debug}, self.ssl)
return self.rest.restCmd('GET', self.rest_cmd,
user, password)
def setting(self):
rest = util.restclient_factory(self.server,
self.port,
{'debug':self.debug},
self.ssl)
opts = {
'error_msg': "unable to set xdcr internal settings",
'success_msg': "set xdcr settings"
}
if self.checkpoint_interval:
rest.setParam('xdcrCheckpointInterval', self.checkpoint_interval)
opts['success_msg'] += ' xdcrCheckpointInterval'
if self.worker_batch_size:
rest.setParam('xdcrWorkerBatchSize', self.worker_batch_size)
opts['success_msg'] += ' xdcrWorkerBatchSize'
if self.doc_batch_size:
rest.setParam('xdcrDocBatchSizeKb', self.doc_batch_size)
opts['success_msg'] += ' xdcrDocBatchSizeKb'
if self.failure_restart_interval:
rest.setParam('xdcrFailureRestartInterval', self.failure_restart_interval)
opts['success_msg'] += ' xdcrFailureRestartInterval'
if self.optimistic_replication_threshold:
rest.setParam('xdcrOptimisticReplicationThreshold', self.optimistic_replication_threshold)
opts['success_msg'] += ' xdcrOptimisticReplicationThreshold'
if self.source_nozzle_per_node:
rest.setParam('sourceNozzlePerNode', self.source_nozzle_per_node)
opts['success_msg'] += ' xdcrSourceNozzlePerNode'
if self.target_nozzle_per_node:
rest.setParam('targetNozzlePerNode', self.target_nozzle_per_node)
opts['success_msg'] += ' xdcrTargetNozzlePerNode'
if self.log_level:
rest.setParam('logLevel', self.log_level)
opts['success_msg'] += ' xdcrLogLevel'
if self.stats_interval:
rest.setParam('statsInterval', self.stats_interval)
opts['success_msg'] += ' xdcrStatsInterval'
output_result = rest.restCmd(self.method,
self.rest_cmd,
self.user,
self.password,
opts)
print output_result
def compact_view(self, rest, server, port, bucket_name):
opts = {}
rest_query = util.restclient_factory(server, port, {'debug':self.debug}, self.ssl)
rest_cmd = '/pools/default/buckets/%s/ddocs' % bucket_name
ddoc_info = rest_query.restCmd('GET', urllib.quote(rest_cmd),
self.user, self.password, opts)
json = rest_query.getJson(ddoc_info)
for row in json["rows"]:
cmd = row["controllers"]["compact"]
opts['error_msg'] = "fail to run task:%s" % cmd
opts['success_msg'] = "run task:%s" % cmd
data = rest.restCmd('POST', cmd,
self.user, self.password, opts)
print data
def compact_view(self, rest, server, port, bucket_name):
opts = {}
rest_query = util.restclient_factory(server, port,
{'debug': self.debug}, self.ssl)
rest_cmd = '/pools/default/buckets/%s/ddocs' % bucket_name
ddoc_info = rest_query.restCmd('GET', urllib.quote(rest_cmd),
self.user, self.password, opts)
json = rest_query.getJson(ddoc_info)
for row in json["rows"]:
cmd = row["controllers"]["compact"]
opts['error_msg'] = "fail to run task:%s" % cmd
opts['success_msg'] = "run task:%s" % cmd
data = rest.restCmd('POST', cmd, self.user, self.password, opts)
print data
def setting(self):
rest = util.restclient_factory(self.server, self.port,
{'debug': self.debug}, self.ssl)
opts = {
'error_msg': "unable to set xdcr internal settings",
'success_msg': "set xdcr settings"
}
if self.checkpoint_interval:
rest.setParam('xdcrCheckpointInterval', self.checkpoint_interval)
opts['success_msg'] += ' xdcrCheckpointInterval'
if self.worker_batch_size:
rest.setParam('xdcrWorkerBatchSize', self.worker_batch_size)
opts['success_msg'] += ' xdcrWorkerBatchSize'
if self.doc_batch_size:
rest.setParam('xdcrDocBatchSizeKb', self.doc_batch_size)
opts['success_msg'] += ' xdcrDocBatchSizeKb'
if self.failure_restart_interval:
rest.setParam('xdcrFailureRestartInterval',
self.failure_restart_interval)
opts['success_msg'] += ' xdcrFailureRestartInterval'
if self.optimistic_replication_threshold:
rest.setParam('xdcrOptimisticReplicationThreshold',
self.optimistic_replication_threshold)
opts['success_msg'] += ' xdcrOptimisticReplicationThreshold'
if self.source_nozzle_per_node:
rest.setParam('sourceNozzlePerNode', self.source_nozzle_per_node)
opts['success_msg'] += ' xdcrSourceNozzlePerNode'
if self.target_nozzle_per_node:
rest.setParam('targetNozzlePerNode', self.target_nozzle_per_node)
opts['success_msg'] += ' xdcrTargetNozzlePerNode'
if self.log_level:
rest.setParam('logLevel', self.log_level)
opts['success_msg'] += ' xdcrLogLevel'
if self.stats_interval:
rest.setParam('statsInterval', self.stats_interval)
opts['success_msg'] += ' xdcrStatsInterval'
output_result = rest.restCmd(self.method, self.rest_cmd, self.user,
self.password, opts)
print output_result
def setup_create(self, cmd):
rest = util.restclient_factory(self.server,
self.port,
{'debug':self.debug},
self.ssl)
if not self.remote_cluster:
print "Error: --xdcr-cluster-name is required to create/edit cluster connection"
return
else:
rest.setParam('name', self.remote_cluster)
if cmd == 'edit':
self.rest_cmd = self.rest_cmd + "/" + urllib.quote(self.remote_cluster)
if self.remote_hostname:
rest.setParam('hostname', self.remote_hostname)
else:
print "Error: hostname (ip) is missing"
return
if self.remote_username:
rest.setParam('username', self.remote_username)
else:
rest.setParam('username', "username")
if self.remote_password:
rest.setParam('password', self.remote_password)
else:
rest.setParam('password', "password")
if self.demand_encryption:
if self.demand_encryption not in [0, 1]:
print "ERROR: xdcr-demand-encryption can only be either 0 or 1."
return
rest.setParam("demandEncryption", self.demand_encryption)
if self.certificate:
if os.path.isfile(self.certificate):
try:
fp = open(self.certificate, 'r')
raw_data = fp.read()
fp.close()
rest.setParam("certificate", raw_data)
except IOError, error:
print "Error:", error
return
else:
print "ERROR: Fail to open certificate file from %s" % self.certificate
return
else:
print "ERROR: certificate required if encryption is demanded."
return
def compact_view(self, rest, server, port, bucket_name):
opts = {}
opts['error_msg'] = "unable to compact view; please check your username (-u) and password (-p);"
opts['success_msg'] = "compact view for bucket"
rest_query = util.restclient_factory(server, port, {'debug':self.debug}, self.ssl)
rest_cmd = '/pools/default/buckets/%s/ddocs' % bucket_name
ddoc_info = rest_query.restCmd('GET', urllib.quote(rest_cmd),
self.user, self.password, opts)
json = rest_query.getJson(ddoc_info)
for row in json["rows"]:
cmd = row["controllers"]["compact"]
data = rest.restCmd('POST', cmd,
self.user, self.password, opts)
print data
def setup_create(self, cmd):
rest = util.restclient_factory(self.server, self.port,
{'debug': self.debug}, self.ssl)
if not self.remote_cluster:
print "Error: --xdcr-cluster-name is required to create/edit cluster connection"
return
else:
rest.setParam('name', self.remote_cluster)
if cmd == 'edit':
self.rest_cmd = self.rest_cmd + "/" + urllib.quote(
self.remote_cluster)
if self.remote_hostname:
rest.setParam('hostname', self.remote_hostname)
else:
print "Error: hostname (ip) is missing"
return
if self.remote_username:
rest.setParam('username', self.remote_username)
else:
rest.setParam('username', "username")
if self.remote_password:
rest.setParam('password', self.remote_password)
else:
rest.setParam('password', "password")
if self.demand_encryption:
if self.demand_encryption not in [0, 1]:
print "ERROR: xdcr-demand-encryption can only be either 0 or 1."
return
rest.setParam("demandEncryption", self.demand_encryption)
if self.certificate:
if os.path.isfile(self.certificate):
try:
fp = open(self.certificate, 'r')
raw_data = fp.read()
fp.close()
rest.setParam("certificate", raw_data)
except IOError, error:
print "Error:", error
return
else:
print "ERROR: Fail to open certificate file from %s" % self.certificate
return
else:
print "ERROR: certificate required if encryption is demanded."
return
def setup_delete(self):
rest = util.restclient_factory(self.server, self.port,
{'debug': self.debug}, self.ssl)
if self.remote_cluster:
self.rest_cmd = self.rest_cmd + "/" + urllib.quote(
self.remote_cluster)
else:
print "Error: Cluster name is needed to delete cluster connections"
return
opts = {
'error_msg': "unable to delete xdcr remote site %s" % self.server,
'success_msg': "delete %s" % self.remote_cluster
}
output_result = rest.restCmd('DELETE', self.rest_cmd, self.user,
self.password, opts)
print output_result
def replicate_stop(self):
rest = util.restclient_factory(self.server, self.port,
{'debug': self.debug}, self.ssl)
if self.replicator:
self.rest_cmd = '/controller/cancelXCDR/' + urllib.quote_plus(
self.replicator)
else:
print "Error: option --xdcr-replicator is needed to delete a replication"
return
opts = {
'error_msg': "unable to delete replication",
'success_msg': "delete replication"
}
output_result = rest.restCmd('DELETE', self.rest_cmd, self.user,
self.password, opts)
print output_result
def replicate_list(self):
rest = util.restclient_factory(self.server, self.port,
{'debug': self.debug}, self.ssl)
opts = {
'error_msg': "unable to retrieve any replication streams",
'success_msg': "list replication streams"
}
output_result = rest.restCmd('GET', '/pools/default/tasks', self.user,
self.password, opts)
tasks = rest.getJson(output_result)
for task in tasks:
if task["type"] == "xdcr":
print 'stream id: %s' % task['id']
print " status: %s" % task["status"]
print " source: %s" % task["source"]
print " target: %s" % task["target"]
def setup_list(self):
rest = util.restclient_factory(self.server, self.port,
{'debug': self.debug}, self.ssl)
opts = {
'error_msg': "unable to list xdcr remote cluster",
'success_msg': "list remote cluster successfully",
}
output_result = rest.restCmd('GET', self.rest_cmd, self.user,
self.password, opts)
clusters = rest.getJson(output_result)
if self.output == 'json':
print output_result
else:
for cluster in clusters:
if not cluster.get('deleted'):
print "cluster name: %s" % cluster["name"]
print " uuid: %s" % cluster["uuid"]
print " host name: %s" % cluster["hostname"]
print " user name: %s" % cluster["username"]
print " uri: %s" % cluster["uri"]
def replicate_stop(self):
rest = util.restclient_factory(self.server,
self.port,
{'debug':self.debug},
self.ssl)
if self.replicator:
self.rest_cmd = '/controller/cancelXCDR/' + urllib.quote_plus(self.replicator)
else:
print "Error: option --xdcr-replicator is needed to delete a replication"
return
opts = {
'error_msg': "unable to delete replication",
'success_msg': "delete replication"
}
output_result = rest.restCmd('DELETE',
self.rest_cmd,
self.user,
self.password,
opts)
print output_result
def setup_delete(self):
rest = util.restclient_factory(self.server,
self.port,
{'debug':self.debug},
self.ssl)
if self.remote_cluster:
self.rest_cmd = self.rest_cmd + "/" + urllib.quote(self.remote_cluster)
else:
print "Error: Cluster name is needed to delete cluster connections"
return
opts = {
'error_msg': "unable to delete xdcr remote site %s" % self.server,
'success_msg': "delete %s" % self.remote_cluster
}
output_result = rest.restCmd('DELETE',
self.rest_cmd,
self.user,
self.password,
opts)
print output_result
def replicate_list(self):
rest = util.restclient_factory(self.server,
self.port,
{'debug':self.debug},
self.ssl)
opts = {
'error_msg': "unable to retrieve any replication streams",
'success_msg': "list replication streams"
}
output_result = rest.restCmd('GET',
'/pools/default/tasks',
self.user,
self.password,
opts)
tasks = rest.getJson(output_result)
for task in tasks:
if task["type"] == "xdcr":
print 'stream id: %s' % task['id']
print " status: %s" % task["status"]
print " source: %s" % task["source"]
print " target: %s" % task["target"]
def runCmd(self, cmd, server, port,
user, password, ssl, opts):
self.user = user
self.password = password
self.ssl = ssl
bucketname = ''
buckettype = ''
authtype = 'sasl'
bucketport = '11211'
bucketpassword = ''
bucketramsize = ''
bucketreplication = ''
bucketpriority = None
eviction_policy = None
output = 'default'
wait_for_bucket_ready = False
enable_flush = None
enable_replica_index = None
force = False
compact_data_only = False
compact_view_only = False
enable_clock_sync = None
for (o, a) in opts:
if o in ('-b', '--bucket'):
bucketname = a
elif o == '--bucket-type':
buckettype = a
elif o == '--bucket-port':
bucketport = a
elif o == '--bucket-password':
bucketpassword = a
elif o == '--bucket-ramsize':
bucketramsize = a
elif o == '--bucket-replica':
bucketreplication = a
elif o == '--bucket-eviction-policy':
eviction_policy = a
elif o == '--bucket-priority':
bucketpriority = a
elif o == '-d' or o == '--debug':
self.debug = True
elif o in ('-o', '--output'):
output = a
elif o == '--enable-flush':
enable_flush = a
elif o == '--enable-index-replica':
enable_replica_index = a
elif o == '--wait':
wait_for_bucket_ready = True
elif o == '--force':
force = True
elif o == '--data-only':
compact_data_only = True
elif o == '--view-only':
compact_view_only = True
elif o == '--enable-clock-sync':
enable_clock_sync = a
self.rest_cmd = rest_cmds[cmd]
rest = util.restclient_factory(server, port, {'debug':self.debug}, self.ssl)
#rest = restclient.RestClient(server, port, {'debug':self.debug})
# get the parameters straight
opts = {}
opts['error_msg'] = "unable to %s;" % cmd
opts['success_msg'] = "%s" % cmd
if cmd in ('bucket-create', 'bucket-edit'):
if bucketname:
rest.setParam('name', bucketname)
if bucketname == "default":
if bucketport and bucketport != "11211":
command_error("default bucket must be on port 11211.")
if bucketpassword:
command_error("default bucket should only have empty password.")
authtype = 'sasl'
else:
if bucketport == "11211":
authtype = 'sasl'
else:
authtype = 'none'
if bucketpassword:
command_error("a sasl bucket is supported only on port 11211.")
if buckettype:
rest.setParam('bucketType', buckettype)
if authtype:
rest.setParam('authType', authtype)
if bucketport:
rest.setParam('proxyPort', bucketport)
if bucketpassword:
rest.setParam('saslPassword', bucketpassword)
if bucketramsize:
rest.setParam('ramQuotaMB', bucketramsize)
if bucketreplication:
rest.setParam('replicaNumber', bucketreplication)
if enable_flush:
rest.setParam('flushEnabled', enable_flush)
if enable_clock_sync:
reset.setParam('enableClockSync', enable_clock_sync)
if eviction_policy:
if eviction_policy in ['valueOnly', 'fullEviction']:
rest.setParam('evictionPolicy', eviction_policy)
else:
command_error("eviction policy value should be either 'valueOnly' or 'fullEviction'.")
if enable_replica_index and cmd == 'bucket-create':
rest.setParam('replicaIndex', enable_replica_index)
if bucketpriority:
if bucketpriority in priority:
rest.setParam('threadsNumber', priority[bucketpriority])
else:
command_error("bucket priority must be either low or high.")
if cmd in ('bucket-delete', 'bucket-flush', 'bucket-edit'):
self.rest_cmd = self.rest_cmd + bucketname
if cmd == 'bucket-flush':
self.rest_cmd = self.rest_cmd + '/controller/doFlush'
if not force:
question = "Running this command will totally PURGE database data from disk. " + \
"Do you really want to do it? (Yes/No)"
confirm = raw_input(question)
if confirm in ('Y', 'Yes'):
print "\nDatabase data will be purged from disk ..."
else:
print "\nDatabase data will not be purged. Done."
return False
else:
print "Database data will be purged from disk ..."
opts['error_msg'] = "unable to %s; please check if the bucket exists or not;" % cmd
elif cmd == 'bucket-compact':
if compact_data_only and compact_view_only:
print "You cannot compact data only and view only at the same time."
return False
elif compact_data_only:
self.rest_cmd = self.rest_cmd + bucketname + '/controller/compactDatabases'
elif compact_view_only:
self.compact_view(rest, server, port, bucketname)
return True
else:
self.rest_cmd = self.rest_cmd + bucketname + '/controller/compactBucket'
elif cmd == 'bucket-ddocs':
self.rest_cmd = self.rest_cmd % bucketname
data = rest.restCmd(methods[cmd], urllib.quote(self.rest_cmd),
self.user, self.password, opts)
if cmd in ("bucket-get", "bucket-stats", "bucket-node-stats", "bucket-ddocs"):
return rest.getJson(data)
elif cmd == "bucket-list":
if output == 'json':
print data
else:
json = rest.getJson(data)
for bucket in json:
print '%s' % bucket['name']
print ' bucketType: %s' % bucket['bucketType']
print ' authType: %s' % bucket['authType']
if bucket['authType'] == "sasl":
print ' saslPassword: %s' % bucket['saslPassword']
else:
print ' proxyPort: %s' % bucket['proxyPort']
print ' numReplicas: %s' % bucket['replicaNumber']
print ' ramQuota: %s' % bucket['quota']['ram']
print ' ramUsed: %s' % bucket['basicStats']['memUsed']
elif cmd == "bucket-create" and wait_for_bucket_ready:
rest_query = util.restclient_factory(server, port, {'debug':self.debug}, self.ssl)
timeout_in_seconds = 120
start = time.time()
# Make sure the bucket exists before querying its status
bucket_exist = False
while (time.time() - start) <= timeout_in_seconds and not bucket_exist:
buckets = rest_query.restCmd('GET', rest_cmds['bucket-list'],
self.user, self.password, opts)
for bucket in rest_query.getJson(buckets):
if bucket["name"] == bucketname:
bucket_exist = True
break
if not bucket_exist:
sys.stderr.write(".")
time.sleep(2)
if not bucket_exist:
print "\nFail to create bucket '%s' within %s seconds" %\
(bucketname, timeout_in_seconds)
return False
#Query status for all bucket nodes
while (time.time() - start) <= timeout_in_seconds:
bucket_info = rest_query.restCmd('GET', urllib.quote(rest_cmds['bucket-info'] % bucketname),
self.user, self.password, opts)
json = rest_query.getJson(bucket_info)
all_node_ready = True
for node in json["nodes"]:
if node["status"] != "healthy":
all_node_ready = False
break
if all_node_ready:
if output == 'json':
print rest.jsonMessage(data)
else:
print data
return True
else:
sys.stderr.write(".")
time.sleep(2)
print "\nBucket '%s' is created but not ready to use within %s seconds" %\
(bucketname, timeout_in_seconds)
return False
else:
if output == 'json':
print rest.jsonMessage(data)
else:
print data
def runCmd(self, cmd, server, port, user, password, ssl, opts):
self.user = user
self.password = password
self.ssl = ssl
bucketname = ''
buckettype = ''
authtype = 'sasl'
bucketport = '11211'
bucketpassword = ''
bucketramsize = ''
bucketreplication = ''
bucketpriority = None
eviction_policy = None
output = 'default'
wait_for_bucket_ready = False
enable_flush = None
enable_replica_index = None
force = False
compact_data_only = False
compact_view_only = False
for (o, a) in opts:
if o in ('-b', '--bucket'):
bucketname = a
elif o == '--bucket-type':
buckettype = a
elif o == '--bucket-port':
bucketport = a
elif o == '--bucket-password':
bucketpassword = a
elif o == '--bucket-ramsize':
bucketramsize = a
elif o == '--bucket-replica':
bucketreplication = a
elif o == '--bucket-eviction-policy':
eviction_policy = a
elif o == '--bucket-priority':
bucketpriority = a
elif o == '-d' or o == '--debug':
self.debug = True
elif o in ('-o', '--output'):
output = a
elif o == '--enable-flush':
enable_flush = a
elif o == '--enable-index-replica':
enable_replica_index = a
elif o == '--wait':
wait_for_bucket_ready = True
elif o == '--force':
force = True
elif o == '--data-only':
compact_data_only = True
elif o == '--view-only':
compact_view_only = True
self.rest_cmd = rest_cmds[cmd]
rest = util.restclient_factory(server, port, {'debug': self.debug},
self.ssl)
#rest = restclient.RestClient(server, port, {'debug':self.debug})
# get the parameters straight
opts = {}
opts['error_msg'] = "unable to %s;" % cmd
opts['success_msg'] = "%s" % cmd
if cmd in ('bucket-create', 'bucket-edit'):
if bucketname:
rest.setParam('name', bucketname)
if bucketname == "default":
if bucketport and bucketport != "11211":
command_error("default bucket must be on port 11211.")
if bucketpassword:
command_error(
"default bucket should only have empty password.")
authtype = 'sasl'
else:
if bucketport == "11211":
authtype = 'sasl'
else:
authtype = 'none'
if bucketpassword:
command_error(
"a sasl bucket is supported only on port 11211."
)
if buckettype:
rest.setParam('bucketType', buckettype)
if authtype:
rest.setParam('authType', authtype)
if bucketport:
rest.setParam('proxyPort', bucketport)
if bucketpassword:
rest.setParam('saslPassword', bucketpassword)
if bucketramsize:
rest.setParam('ramQuotaMB', bucketramsize)
if bucketreplication:
rest.setParam('replicaNumber', bucketreplication)
if enable_flush:
rest.setParam('flushEnabled', enable_flush)
if eviction_policy:
if eviction_policy in ['valueOnly', 'fullEviction']:
rest.setParam('evictionPolicy', eviction_policy)
else:
command_error(
"eviction policy value should be either 'valueOnly' or 'fullEviction'."
)
if enable_replica_index and cmd == 'bucket-create':
rest.setParam('replicaIndex', enable_replica_index)
if bucketpriority:
if bucketpriority in priority:
rest.setParam('threadsNumber', priority[bucketpriority])
else:
command_error(
"bucket priority must be either low or high.")
if cmd in ('bucket-delete', 'bucket-flush', 'bucket-edit'):
self.rest_cmd = self.rest_cmd + bucketname
if cmd == 'bucket-flush':
self.rest_cmd = self.rest_cmd + '/controller/doFlush'
if not force:
question = "Running this command will totally PURGE database data from disk. " + \
"Do you really want to do it? (Yes/No)"
confirm = raw_input(question)
if confirm in ('Y', 'Yes'):
print "\nDatabase data will be purged from disk ..."
else:
print "\nDatabase data will not be purged. Done."
return False
else:
print "Database data will be purged from disk ..."
opts[
'error_msg'] = "unable to %s; please check if the bucket exists or not;" % cmd
elif cmd == 'bucket-compact':
if compact_data_only and compact_view_only:
print "You cannot compact data only and view only at the same time."
return False
elif compact_data_only:
self.rest_cmd = self.rest_cmd + bucketname + '/controller/compactDatabases'
elif compact_view_only:
self.compact_view(rest, server, port, bucketname)
return True
else:
self.rest_cmd = self.rest_cmd + bucketname + '/controller/compactBucket'
elif cmd == 'bucket-ddocs':
self.rest_cmd = self.rest_cmd % bucketname
data = rest.restCmd(methods[cmd], urllib.quote(self.rest_cmd),
self.user, self.password, opts)
if cmd in ("bucket-get", "bucket-stats", "bucket-node-stats",
"bucket-ddocs"):
return rest.getJson(data)
elif cmd == "bucket-list":
if output == 'json':
print data
else:
json = rest.getJson(data)
for bucket in json:
print '%s' % bucket['name']
print ' bucketType: %s' % bucket['bucketType']
print ' authType: %s' % bucket['authType']
if bucket['authType'] == "sasl":
print ' saslPassword: %s' % bucket['saslPassword']
else:
print ' proxyPort: %s' % bucket['proxyPort']
print ' numReplicas: %s' % bucket['replicaNumber']
print ' ramQuota: %s' % bucket['quota']['ram']
print ' ramUsed: %s' % bucket['basicStats']['memUsed']
elif cmd == "bucket-create" and wait_for_bucket_ready:
rest_query = util.restclient_factory(server, port,
{'debug': self.debug},
self.ssl)
timeout_in_seconds = 120
start = time.time()
# Make sure the bucket exists before querying its status
bucket_exist = False
while (time.time() -
start) <= timeout_in_seconds and not bucket_exist:
buckets = rest_query.restCmd('GET', rest_cmds['bucket-list'],
self.user, self.password, opts)
for bucket in rest_query.getJson(buckets):
if bucket["name"] == bucketname:
bucket_exist = True
break
if not bucket_exist:
sys.stderr.write(".")
time.sleep(2)
if not bucket_exist:
print "\nFail to create bucket '%s' within %s seconds" %\
(bucketname, timeout_in_seconds)
return False
#Query status for all bucket nodes
while (time.time() - start) <= timeout_in_seconds:
bucket_info = rest_query.restCmd(
'GET', urllib.quote(rest_cmds['bucket-info'] % bucketname),
self.user, self.password, opts)
json = rest_query.getJson(bucket_info)
all_node_ready = True
for node in json["nodes"]:
if node["status"] != "healthy":
all_node_ready = False
break
if all_node_ready:
if output == 'json':
print rest.jsonMessage(data)
else:
print data
return True
else:
sys.stderr.write(".")
time.sleep(2)
print "\nBucket '%s' is created but not ready to use within %s seconds" %\
(bucketname, timeout_in_seconds)
return False
else:
if output == 'json':
print rest.jsonMessage(data)
else:
print data
