def cluster_init(self, data_ramsize, index_ramsize, fts_ramsize, services,
index_storage_mode, cluster_name,
cluster_username, cluster_password, cluster_port):
options = ""
if cluster_username:
options += " --cluster-username " + str(cluster_username)
if cluster_password:
options += " --cluster-password " + str(cluster_password)
if data_ramsize:
options += " --cluster-ramsize " + str(data_ramsize)
if index_ramsize:
options += " --cluster-index-ramsize " + str(index_ramsize)
if fts_ramsize:
options += " --cluster-fts-ramsize " + str(fts_ramsize)
if cluster_name:
options += " --cluster-name " + str(cluster_name)
if index_storage_mode:
options += " --index-storage-setting " + str(index_storage_mode)
if cluster_port:
options += " --cluster-port " + str(cluster_port)
if services:
options += " --services " + str(services)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("cluster-init",
self.hostname.split(":")[0], options)
remote_client.disconnect()
print_msg = "Cluster initialized"
if self.cb_version is not None and \
self.cb_version[:3] == "4.6":
print_msg = "init/edit %s" % self.server.ip
return stdout, stderr, self._was_success(stdout, print_msg)
def _setting_cluster(self, cmd, data_ramsize, index_ramsize, fts_ramsize,
cluster_name, cluster_username,
cluster_password, cluster_port):
options = self._get_default_options()
if cluster_username is not None:
options += " --cluster-username " + str(cluster_username)
if cluster_password is not None:
options += " --cluster-password " + str(cluster_password)
if data_ramsize:
options += " --cluster-ramsize " + str(data_ramsize)
if index_ramsize:
options += " --cluster-index-ramsize " + str(index_ramsize)
if fts_ramsize:
options += " --cluster-fts-ramsize " + str(fts_ramsize)
if cluster_name:
options += " --cluster-name " + str(cluster_name)
if cluster_port:
options += " --cluster-port " + str(cluster_port)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli(cmd, self.hostname,
options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout,
"Cluster settings modified")
def setting_compaction(self, db_frag_perc, db_frag_size, view_frag_perc,
view_frag_size, from_period, to_period,
abort_outside, parallel_compact, purgeint):
options = self._get_default_options()
if db_frag_perc is not None:
options += " --compaction-db-percentage " + str(db_frag_perc)
if db_frag_size is not None:
options += " --compaction-db-size " + str(db_frag_size)
if view_frag_perc is not None:
options += " --compaction-view-percentage " + str(view_frag_perc)
if view_frag_size is not None:
options += " --compaction-view-size " + str(view_frag_size)
if from_period is not None:
options += " --compaction-period-from " + str(from_period)
if to_period is not None:
options += " --compaction-period-to " + str(to_period)
if abort_outside is not None:
options += " --enable-compaction-abort " + str(abort_outside)
if parallel_compact is not None:
options += " --enable-compaction-parallel " + str(parallel_compact)
if purgeint is not None:
options += " --metadata-purge-interval " + str(purgeint)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("setting-compaction",
self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Compaction "
"settings modified")
def setting_index(self, max_rollbacks, stable_snap_interval,
mem_snap_interval, storage_mode, threads,
log_level):
options = self._get_default_options()
if max_rollbacks:
options += " --index-max-rollback-points " + str(max_rollbacks)
if stable_snap_interval:
options += " --index-stable-snapshot-interval " + str(
stable_snap_interval)
if mem_snap_interval:
options += " --index-memory-snapshot-interval " + str(
mem_snap_interval)
if storage_mode:
options += " --index-storage-setting " + str(storage_mode)
if threads:
options += " --index-threads " + str(threads)
if log_level:
options += " --index-log-level " + str(log_level)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("setting-index",
self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout,
"Indexer settings modified")
def setting_gsi_compaction(self, compact_mode, compact_percent, compact_interval,
from_period, to_period, enable_abort):
options = self._get_default_options()
if compact_mode is not None:
options += " --gsi-compaction-mode %s" % compact_mode
if compact_mode == "append":
if compact_percent is not None:
options += " --compaction-gsi-percentage=" + str(compact_percent)
elif compact_mode == "circular":
if compact_interval is not None:
options += " --compaction-gsi-interval " + str(compact_interval)
if from_period is not None:
options += " --compaction-gsi-period-from=" + str(from_period)
if to_period is not None:
options += " --compaction-gsi-period-to=" + str(to_period)
if enable_abort:
options += " --enable-gsi-compaction-abort=" + str(enable_abort)
else:
raise Exception("need compact mode to run!")
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("setting-compaction",
self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Compaction settings modified")
def rebalance_stop(self):
options = self._get_default_options()
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("rebalance-stop",
self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Rebalance stopped")
def user_manage(self, delete, list, set, ro_username, ro_password):
options = self._get_default_options()
if delete:
options += " --delete "
if list:
options += " --list "
if set:
options += " --set "
if ro_username is not None:
options += " --ro-username " + str(ro_username)
if ro_password:
options += " --ro-password " + str(ro_password)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("user-manage",
self.hostname, options)
remote_client.disconnect()
if delete:
return stdout, stderr, self._was_success(stdout, "Local read-only"
"user deleted")
elif set:
return stdout, stderr, self._was_success(stdout, "Local read-only"
"user deleted")
else:
return stdout, stderr, self._no_error_in_output(stdout)
def bucket_create(self, name, password, bucket_type, quota,
eviction_policy, replica_count, enable_replica_indexes,
priority, enable_flush, wait):
options = self._get_default_options()
if name is not None:
options += " --bucket " + name
if password is not None:
options += " --bucket-password " + password
if bucket_type is not None:
options += " --bucket-type " + bucket_type
if quota is not None:
options += " --bucket-ramsize " + str(quota)
if eviction_policy is not None:
options += " --bucket-eviction-policy " + eviction_policy
if replica_count is not None:
options += " --bucket-replica " + str(replica_count)
if enable_replica_indexes is not None:
options += " --enable-index-replica " + str(enable_replica_indexes)
if priority is not None:
options += " --bucket-priority " + priority
if enable_flush is not None:
options += " --enable-flush " + str(enable_flush)
if wait:
options += " --wait"
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("bucket-create",
self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Bucket created")
def cluster_init(self, data_ramsize, index_ramsize, fts_ramsize, services,
index_storage_mode, cluster_name,
cluster_username, cluster_password, cluster_port):
options = ""
if cluster_username:
options += " --cluster-username " + str(cluster_username)
if cluster_password:
options += " --cluster-password " + str(cluster_password)
if data_ramsize:
options += " --cluster-ramsize " + str(data_ramsize)
if index_ramsize:
options += " --cluster-index-ramsize " + str(index_ramsize)
if fts_ramsize:
options += " --cluster-fts-ramsize " + str(fts_ramsize)
if cluster_name:
options += " --cluster-name " + str(cluster_name)
if index_storage_mode:
options += " --index-storage-setting " + str(index_storage_mode)
if cluster_port:
options += " --cluster-port " + str(cluster_port)
if services:
options += " --services " + str(services)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("cluster-init",
self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Cluster initialized")
def collect_logs_stop(self):
options = self._get_default_options()
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("collect-logs-stop",
self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout,
"Log collection stopped")
def setting_notification(self, enable):
options = self._get_default_options()
if enable is not None:
options += " --enable-notification " + str(enable)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("setting-notification", self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Notification settings updated")
def server_readd(self, servers):
options = self._get_default_options()
if servers:
options += " --server-add " + str(servers)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("server-readd", self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Servers recovered")
def bucket_delete(self, bucket_name):
options = self._get_default_options()
if bucket_name is not None:
options += " --bucket " + bucket_name
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("bucket-delete", self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Bucket deleted")
def rebalance(self, remove_servers):
options = self._get_default_options()
if remove_servers:
options += " --server-remove " + str(remove_servers)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("rebalance", self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Rebalance complete")
def recovery(self, servers, recovery_type):
options = self._get_default_options()
if servers:
options += " --server-recovery " + str(servers)
if recovery_type:
options += " --recovery-type " + str(recovery_type)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("recovery", self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Servers recovered")
def failover(self, failover_servers, force):
options = self._get_default_options()
if failover_servers:
options += " --server-failover " + str(failover_servers)
if force:
options += " --force"
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("failover", self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Server failed over")
def setting_autofailover(self, enabled, timeout):
options = self._get_default_options()
if enabled is not None:
options += " --enable-auto-failover " + str(enabled)
if timeout is not None:
options += " --auto-failover-timeout " + str(timeout)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("setting-autofailover", self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Auto-failover settings modified")
def setting_alert(self, enabled, email_recipients, email_sender,
email_username, email_password, email_host,
email_port, encrypted, alert_af_node,
alert_af_max_reached, alert_af_node_down, alert_af_small,
alert_af_disable, alert_ip_changed, alert_disk_space,
alert_meta_overhead, alert_meta_oom,
alert_write_failed, alert_audit_dropped):
options = self._get_default_options()
if enabled is not None:
options += " --enable-email-alert " + str(enabled)
if email_recipients is not None:
options += " --email-recipients " + str(email_recipients)
if email_sender is not None:
options += " --email-sender " + str(email_sender)
if email_username is not None:
options += " --email-user " + str(email_username)
if email_password is not None:
options += " --email-password " + str(email_password)
if email_host is not None:
options += " --email-host " + str(email_host)
if email_port is not None:
options += " --email-port " + str(email_port)
if encrypted is not None:
options += "--enable-email-encrypt" + str(encrypted)
if alert_af_node:
options += " --alert-auto-failover-node "
if alert_af_max_reached:
options += " --alert-auto-failover-max-reached "
if alert_af_node_down:
options += " --alert-auto-failover-node-down "
if alert_af_small:
options += " --alert-auto-failover-cluster-small "
if alert_af_disable:
options += " --alert-auto-failover-disable "
if alert_ip_changed:
options += " --alert-ip-changed "
if alert_disk_space:
options += " --alert-disk-space "
if alert_meta_overhead:
options += " --alert-meta-overhead "
if alert_meta_oom:
options += " --alert-meta-oom "
if alert_write_failed:
options += " --alert-write-failed "
if alert_audit_dropped:
options += " --alert-audit-msg-dropped "
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("setting-alert",
self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Email alert "
"settings modified")
def bucket_flush(self, name, force):
options = self._get_default_options()
if name is not None:
options += " --bucket " + name
if force:
options += " --force"
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("bucket-flush", self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Bucket flushed")
def setting_autoreprovision(self, enabled, max_nodes):
options = self._get_default_options()
if enabled is not None:
options += " --enabled " + str(enabled)
if max_nodes is not None:
options += " --max-nodes " + str(max_nodes)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("setting-autoreprovision",
self.server.ip, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Auto-reprovision "
"settings modified")
def setting_audit(self, enabled, log_path, rotate_interval):
options = self._get_default_options()
if enabled is not None:
options += " --audit-enabled " + str(enabled)
if log_path is not None:
options += " --audit-log-path " + str(log_path)
if rotate_interval is not None:
options += " --audit-log-rotate-interval " + str(rotate_interval)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("setting-audit", self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Audit settings modified")
def bucket_compact(self, bucket_name, data_only, views_only):
options = self._get_default_options()
if bucket_name is not None:
options += " --bucket " + bucket_name
if data_only:
options += " --data-only"
if views_only:
options += " --view-only"
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("bucket-compact", self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Bucket compaction started")
def node_init(self, data_path, index_path, hostname):
options = self._get_default_options()
if data_path:
options += " --node-init-data-path " + str(data_path)
if index_path:
options += " --node-init-data-path " + str(index_path)
if hostname:
options += " --node-init-hostname " + str(hostname)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("node-init", self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Node initialized")
def setting_ldap(self, admins, ro_admins, default, enabled):
options = self._get_default_options()
if admins:
options += " --ldap-admins " + str(admins)
if ro_admins:
options += " --ldap-roadmins " + str(ro_admins)
if default:
options += " --ldap-default " + str(default)
if enabled is not None:
options += " --ldap-enabled " + str(enabled)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("setting-ldap", self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "LDAP settings modified")
def collect_logs_start(self, all_nodes, nodes, upload, upload_host, upload_customer, upload_ticket):
options = self._get_default_options()
if all_nodes is True:
options += " --all-nodes "
if nodes is not None:
options += " --nodes " + str(nodes)
if upload is True:
options += " --upload "
if upload_host is not None:
options += " --upload-host " + str(upload_host)
if upload_customer is not None:
options += " --customer " + str(upload_customer)
if upload_ticket is not None:
options += " --ticket " + str(upload_ticket)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("collect-logs-start", self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Log collection started")
def server_add(self, server, server_username, server_password, group_name, services, index_storage_mode):
options = self._get_default_options()
if server:
options += " --server-add " + str(server)
if server_username:
options += " --server-add-username " + str(server_username)
if server_password:
options += " --server-add-password " + str(server_password)
if group_name:
options += " --group-name " + str(group_name)
if services:
options += " --services " + str(services)
if index_storage_mode:
options += " --index-storage-setting " + str(index_storage_mode)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("server-add", self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Server added")
def bucket_edit(self, name, quota, eviction_policy,
replica_count, priority, enable_flush):
options = self._get_default_options()
if name is not None:
options += " --bucket " + name
if quota is not None:
options += " --bucket-ramsize " + str(quota)
if eviction_policy is not None:
options += " --bucket-eviction-policy " + eviction_policy
if replica_count is not None:
options += " --bucket-replica " + str(replica_count)
if priority is not None:
options += " --bucket-priority " + priority
if enable_flush is not None:
options += " --enable-flush " + str(enable_flush)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("bucket-edit",
self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Bucket edited")
def bucket_edit(self, name, quota, eviction_policy,
replica_count, priority, enable_flush):
options = self._get_default_options()
if name is not None:
options += " --bucket " + name
if quota is not None:
options += " --bucket-ramsize " + str(quota)
if eviction_policy is not None:
options += " --bucket-eviction-policy " + eviction_policy
if replica_count is not None:
options += " --bucket-replica " + str(replica_count)
if priority is not None:
options += " --bucket-priority " + priority
if enable_flush is not None:
options += " --enable-flush " + str(enable_flush)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("bucket-edit",
self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Bucket edited")
def server_add(self, server, server_username, server_password, group_name,
services, index_storage_mode):
options = self._get_default_options()
if server:
options += " --server-add " + str(server)
if server_username:
options += " --server-add-username " + str(server_username)
if server_password:
options += " --server-add-password " + str(server_password)
if group_name:
options += " --group-name " + str(group_name)
if services:
options += " --services " + str(services)
if index_storage_mode:
options += " --index-storage-setting " + str(index_storage_mode)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("server-add",
self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout, "Server added")
def collect_logs_start(self, all_nodes, nodes, upload, upload_host,
upload_customer, upload_ticket):
options = self._get_default_options()
if all_nodes is True:
options += " --all-nodes "
if nodes is not None:
options += " --nodes " + str(nodes)
if upload is True:
options += " --upload "
if upload_host is not None:
options += " --upload-host " + str(upload_host)
if upload_customer is not None:
options += " --customer " + str(upload_customer)
if upload_ticket is not None:
options += " --ticket " + str(upload_ticket)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("collect-logs-start",
self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout,
"Log collection started")
def group_manage(self, create, delete, list, move_servers, rename, name,
to_group, from_group):
options = self._get_default_options()
if create:
options += " --create "
if delete:
options += " --delete "
if list:
options += " --list "
if rename is not None:
options += " --rename " + str(rename)
if move_servers is not None:
options += " --move-servers " + str(move_servers)
if name:
options += " --group-name " + str(name)
if to_group:
options += " --to-group " + str(to_group)
if from_group:
options += " --from-group " + str(from_group)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("group-manage",
self.hostname, options)
remote_client.disconnect()
success = False
if create:
success = self._was_success(stdout, "Server group created")
elif delete:
success = self._was_success(stdout, "Server group deleted")
elif list:
success = self._no_error_in_output(stdout)
elif move_servers:
success = self._was_success(stdout, "Servers moved between groups")
elif rename:
success = self._was_success(stdout, "Server group renamed")
return stdout, stderr, success
def group_manage(self, create, delete, list, move_servers, rename, name,
to_group, from_group):
options = self._get_default_options()
if create:
options += " --create "
if delete:
options += " --delete "
if list:
options += " --list "
if rename is not None:
options += " --rename " + str(rename)
if move_servers is not None:
options += " --move-servers " + str(move_servers)
if name:
options += " --group-name " + str(name)
if to_group:
options += " --to-group " + str(to_group)
if from_group:
options += " --from-group " + str(from_group)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("group-manage",
self.hostname, options)
remote_client.disconnect()
success = False
if create:
success = self._was_success(stdout, "Server group created")
elif delete:
success = self._was_success(stdout, "Server group deleted")
elif list:
success = self._no_error_in_output(stdout)
elif move_servers:
success = self._was_success(stdout, "Servers moved between groups")
elif rename:
success = self._was_success(stdout, "Server group renamed")
return stdout, stderr, success
def eventing_operation(self, subcommand, function_name, boundary="from-everything", file_name=None, name=True):
options = self._get_default_options()
options += " --name " + function_name
if boundary:
options += " --boundary " + boundary
if name:
options += " --file " + file_name
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli(subcommand, self.hostname, options)
remote_client.disconnect()
if subcommand == "import":
return stdout, stderr, self._was_success(stdout, "Events imported")
elif subcommand == "deploy":
return stdout, stderr, self._was_success(stdout, "Request to deploy the function was accepted")
elif subcommand == "pause":
return stdout, stderr, self._was_success(stdout, "Function was paused")
elif subcommand == "resume":
return stdout, stderr, self._was_success(stdout, "Function was resumed")
elif subcommand == "undeploy":
return stdout, stderr, self._was_success(stdout, "Request to undeploy the function was accepted")
elif subcommand == "delete":
return stdout, stderr, self._was_success(stdout, "Request to undeploy the function was accepted")
elif subcommand == "list":
return stdout, stderr
def setting_index(self, max_rollbacks, stable_snap_interval,
mem_snap_interval, storage_mode, threads, log_level):
options = self._get_default_options()
if max_rollbacks:
options += " --index-max-rollback-points " + str(max_rollbacks)
if stable_snap_interval:
options += " --index-stable-snapshot-interval " + str(
stable_snap_interval)
if mem_snap_interval:
options += " --index-memory-snapshot-interval " + str(
mem_snap_interval)
if storage_mode:
options += " --index-storage-setting " + str(storage_mode)
if threads:
options += " --index-threads " + str(threads)
if log_level:
options += " --index-log-level " + str(log_level)
remote_client = RemoteMachineShellConnection(self.server)
stdout, stderr = remote_client.couchbase_cli("setting-index",
self.hostname, options)
remote_client.disconnect()
return stdout, stderr, self._was_success(stdout,
"Indexer settings modified")
