def __init__(self, cluster_spec, test_config, verbose, experiment=None):
self.cluster_spec = cluster_spec
self.test_config = test_config
self.target_iterator = TargetIterator(cluster_spec, test_config)
self.memcached = MemcachedHelper(test_config)
self.monitor = Monitor(cluster_spec)
self.rest = RestHelper(cluster_spec)
self.remote = RemoteHelper(cluster_spec, test_config, verbose)
if experiment:
self.experiment = ExperimentHelper(experiment,
cluster_spec, test_config)
self.master_node = cluster_spec.yield_masters().next()
if self.remote.gateways:
self.build = SyncGatewayRequestHelper().get_version(
self.remote.gateways[0]
)
else:
self.build = self.rest.get_version(self.master_node)
self.cbagent = CbAgent(self)
self.metric_helper = MetricHelper(self)
self.reporter = Reporter(self)
self.reports = {}
self.snapshots = []
self.master_events = []
if self.test_config.test_case.use_workers:
self.worker_manager = WorkerManager(cluster_spec, test_config)
def __init__(self, cluster_spec: ClusterSpec, test_config: TestConfig,
verbose: bool):
self.cluster_spec = cluster_spec
self.test_config = test_config
self.target_iterator = TargetIterator(cluster_spec, test_config)
self.cluster = ClusterManager(cluster_spec, test_config)
self.memcached = MemcachedHelper(test_config)
self.monitor = Monitor(cluster_spec, test_config, verbose)
self.rest = RestHelper(cluster_spec)
self.remote = RemoteHelper(cluster_spec, verbose)
self.profiler = Profiler(cluster_spec, test_config)
self.master_node = next(cluster_spec.masters)
self.build = self.rest.get_version(self.master_node)
self.metrics = MetricHelper(self)
self.reporter = ShowFastReporter(cluster_spec, test_config, self.build)
self.cbmonitor_snapshots = []
self.cbmonitor_clusters = []
if self.test_config.test_case.use_workers:
self.worker_manager = WorkerManager(cluster_spec, test_config,
verbose)
def prepare_iostat(self, clusters, test):
# If tests are run locally, no paths are defined, hence
# use the paths that are set by the server itself. Get
# those paths via ther REST API
rest = None
if test.cluster_spec.paths:
data_path, index_path = test.cluster_spec.paths
else:
rest = RestHelper(test.cluster_spec)
for cluster in clusters:
settings = copy(self.settings)
settings.cluster = cluster
settings.master_node = self.clusters[cluster]
if rest is not None:
data_path, index_path = rest.get_data_path(
settings.master_node)
partitions = {'data': data_path}
if hasattr(test, 'ddocs'): # all instances of IndexTest have it
partitions['index'] = index_path
settings.partitions = partitions
io_collector = IO(settings)
self.collectors.append(io_collector)
def __init__(self, cluster_spec: ClusterSpec, test_config: TestConfig,
build: str):
self.cluster_spec = cluster_spec
self.test_config = test_config
self.build = build + test_config.showfast.build_label
self.master_node = next(self.cluster_spec.masters)
self.rest = RestHelper(cluster_spec, test_config)
def __init__(self, cluster_spec: ClusterSpec, test_config: TestConfig):
self.test_config = test_config
self.rest = RestHelper(cluster_spec)
self.master_node = next(cluster_spec.masters)
self.ssh_username, self.ssh_password = cluster_spec.ssh_credentials
def main():
usage = '%prog -v version -c cluster-spec'
parser = OptionParser(usage)
parser.add_option('-v', '--version', dest='version')
parser.add_option('-c', dest='cluster_spec_fname',
help='path to cluster specification file',
metavar='cluster.spec')
parser.add_option('--verbose', dest='verbose', action='store_true',
help='enable verbose logging')
parser.add_option('-o', dest='toy',
help='optional toy build ID', metavar='couchstore')
parser.add_option('-t', dest='test_config_fname',
help='path to test configuration file',
metavar='my_test.test')
parser.add_option('-e', '--edition', dest='cluster_edition', default='enterprise',
help='the cluster edition (community or enterprise)')
parser.add_option('--url', dest='url', default=None,
help='The http URL to a Couchbase RPM that should be'
' installed. This overrides the URL to be installed.')
options, args = parser.parse_args()
cluster_spec = ClusterSpec()
cluster_spec.parse(options.cluster_spec_fname)
test_config = TestConfig()
test_config.parse(options.test_config_fname)
cm = ClusterManager(cluster_spec, test_config, options.verbose)
installer = CouchbaseInstaller(cluster_spec, options)
if True:
installer.install()
if cm.remote:
cm.tune_logging()
cm.restart_with_sfwi()
cm.restart_with_alternative_num_vbuckets()
cm.restart_with_alternative_num_cpus()
cm.restart_with_tcmalloc_aggressive_decommit()
cm.disable_moxi()
cm.configure_internal_settings()
cm.set_data_path()
cm.set_services()
cm.set_mem_quota()
cm.set_index_mem_quota()
cm.set_auth()
time.sleep(30)
"""host = cluster_spec.yield_masters().next()"""
host_ip = cluster_spec.yield_masters().next().split(':')[0]
URL = 'http://' + host_ip + ':8093'
logger.info('logging the URL: {}'.format(URL))
conn = urllib3.connection_from_url(URL)
rest = RestHelper(cluster_spec)
airline_result = do_airline_benchmarks(conn, rest, host_ip, installer.remote, cluster_spec)
beer_result = do_beer_queries(conn, rest, host_ip, installer.remote)
print 'beer_result is', beer_result
sys.exit(not (airline_result and beer_result))
def fetch_maps(self):
rest = RestHelper(self.cluster_spec)
master_node = next(self.cluster_spec.masters)
maps = {}
for bucket in self.test_config.buckets:
vbmap = rest.get_vbmap(master_node, bucket)
server_list = rest.get_server_list(master_node, bucket)
maps[bucket] = (vbmap, server_list)
return maps
def __init__(self, cluster_spec, test_config, options):
self.test_config = test_config
self.cluster_spec = cluster_spec
self.client_settings = self.test_config.client_settings.__dict__
self.options = options
self.remote = RemoteHelper(self.cluster_spec, options.verbose)
self.client_os = RemoteHelper.detect_client_os(
self.cluster_spec.workers[0], self.cluster_spec).lower()
self.rest = RestHelper(self.cluster_spec, self.test_config,
options.verbose)
self.cb_version = version_tuple(
self.rest.get_version(host=next(self.cluster_spec.masters)))
def __init__(self, cluster_spec: ClusterSpec, test_config: TestConfig,
verbose: bool = False):
self.cluster_spec = cluster_spec
self.test_config = test_config
self.rest = RestHelper(cluster_spec)
self.remote = RemoteHelper(cluster_spec, verbose)
self.monitor = Monitor(cluster_spec, test_config, verbose)
self.memcached = MemcachedHelper(test_config)
self.master_node = next(self.cluster_spec.masters)
self.initial_nodes = test_config.cluster.initial_nodes
def __init__(self, cluster_spec: ClusterSpec, test_config: TestConfig):
self.test_config = test_config
self.rest = RestHelper(cluster_spec)
self.master_node = next(cluster_spec.masters)
self.ssh_username, self.ssh_password = cluster_spec.ssh_credentials
self.cluster_spec = cluster_spec
self.profiling_settings = test_config.profiling_settings
self.linux_perf_path = '/opt/couchbase/var/lib/couchbase/logs/'
def __init__(self, *args, **kwargs):
options, args = get_options()
self.cluster_spec = ClusterSpec()
self.cluster_spec.parse(options.cluster_spec_fname, args)
self.test_config = TestConfig()
self.test_config.parse(options.test_config_fname, args)
self.target_iterator = TargetIterator(self.cluster_spec,
self.test_config)
self.memcached = MemcachedHelper(self.test_config)
self.remote = RemoteHelper(self.cluster_spec, self.test_config)
self.rest = RestHelper(self.cluster_spec)
super(FunctionalTest, self).__init__(*args, **kwargs)
def __init__(self,
cluster_spec: ClusterSpec,
test_config: TestConfig,
verbose: bool = False):
self.cluster_spec = cluster_spec
self.test_config = test_config
self.dynamic_infra = self.cluster_spec.dynamic_infrastructure
self.rest = RestHelper(cluster_spec)
self.remote = RemoteHelper(cluster_spec, verbose)
self.monitor = Monitor(cluster_spec, test_config, verbose)
self.memcached = MemcachedHelper(test_config)
self.master_node = next(self.cluster_spec.masters)
self.initial_nodes = test_config.cluster.initial_nodes
self.build = self.rest.get_version(self.master_node)
def __init__(self, cluster_spec, test_config, verbose=False):
self.cluster_spec = cluster_spec
self.test_config = test_config
self.rest = RestHelper(cluster_spec)
self.remote = RemoteHelper(cluster_spec, test_config, verbose)
self.monitor = Monitor(cluster_spec, test_config, verbose)
self.memcached = MemcachedHelper(test_config)
self.master_node = next(self.cluster_spec.masters)
self.initial_nodes = test_config.cluster.initial_nodes
self.mem_quota = test_config.cluster.mem_quota
self.index_mem_quota = test_config.cluster.index_mem_quota
self.fts_mem_quota = test_config.cluster.fts_index_mem_quota
self.analytics_mem_quota = test_config.cluster.analytics_mem_quota
def __init__(self, cluster_spec, test_config, verbose):
self.cluster_spec = cluster_spec
self.test_config = test_config
self.rest = RestHelper(cluster_spec)
self.remote = RemoteHelper(cluster_spec, test_config, verbose)
self.monitor = Monitor(cluster_spec)
self.memcached = MemcachedHelper(test_config)
self.clusters = cluster_spec.yield_clusters()
self.servers = cluster_spec.yield_servers
self.masters = cluster_spec.yield_masters
self.initial_nodes = test_config.cluster.initial_nodes
self.mem_quota = test_config.cluster.mem_quota
self.group_number = test_config.cluster.group_number or 1
def __init__(self, *args, **kwargs):
options, _args = get_options()
override = \
_args and (arg.split('.') for arg in ' '.join(_args).split(','))
self.cluster_spec = ClusterSpec()
self.cluster_spec.parse(options.cluster_spec_fname)
self.test_config = TestConfig()
self.test_config.parse(options.test_config_fname, override)
self.target_iterator = TargetIterator(self.cluster_spec,
self.test_config)
self.memcached = MemcachedHelper(self.test_config)
self.remote = RemoteHelper(self.cluster_spec, self.test_config)
self.rest = RestHelper(self.cluster_spec)
super(FunctionalTest, self).__init__(*args, **kwargs)
def __init__(self, cluster_spec: ClusterSpec, test_config: TestConfig,
verbose: bool):
self.cluster_spec = cluster_spec
self.test_config = test_config
self.memcached = MemcachedHelper(test_config)
self.remote = RemoteHelper(cluster_spec, test_config, verbose)
self.rest = RestHelper(cluster_spec)
# self.build = os.environ.get('SGBUILD') or "0.0.0-000"
self.master_node = next(cluster_spec.masters)
self.build = self.rest.get_sgversion(self.master_node)
self.metrics = MetricHelper(self)
self.reporter = ShowFastReporter(cluster_spec, test_config, self.build)
if self.test_config.test_case.use_workers:
self.worker_manager = WorkerManager(cluster_spec, test_config,
verbose)
self.settings = self.test_config.access_settings
self.settings.syncgateway_settings = self.test_config.syncgateway_settings
self.profiler = Profiler(cluster_spec, test_config)
self.cluster = ClusterManager(cluster_spec, test_config)
self.target_iterator = TargetIterator(cluster_spec, test_config)
self.monitor = Monitor(cluster_spec, test_config, verbose)
def main():
usage = '%prog -v version -c cluster-spec -f conffile -b build -t tag'
parser = OptionParser(usage)
parser.add_option('-v', '--version', dest='version')
parser.add_option('-c',
dest='cluster_spec_fname',
help='path to cluster specification file',
metavar='cluster.spec')
parser.add_option('--verbose',
dest='verbose',
action='store_true',
help='enable verbose logging')
parser.add_option('-o',
dest='toy',
help='optional toy build ID',
metavar='couchstore')
parser.add_option('-t',
dest='test_config_fname',
help='path to test configuration file',
metavar='my_test.test')
parser.add_option('-e',
'--edition',
dest='cluster_edition',
default='enterprise',
help='the cluster edition (community or enterprise)')
parser.add_option('--url',
dest='url',
default=None,
help='The http URL to a Couchbase RPM that should be'
' installed. This overrides the URL to be installed.')
parser.add_option('-f', '--filename', dest='filename')
parser.add_option('-b', '--build', dest='build')
parser.add_option('-n', '--number', dest='number')
options, args = parser.parse_args()
test_id = options.number + '_' + options.build
data = None
try:
with open(options.filename) as data_file:
data = json.load(data_file)
except (OSError, IOError, ValueError) as e:
raise e
mng_data = manage_test_result(['beer_queries', 'travel_queries'])
mng_data.create_cb_instance(data["couchbase_server"],
data["couchbase_query_bucket"])
options, args = parser.parse_args()
cluster_spec = ClusterSpec()
cluster_spec.parse(options.cluster_spec_fname, args)
test_config = TestConfig()
test_config.parse(options.test_config_fname, args)
cm = ClusterManager(cluster_spec, test_config, options.verbose)
installer = CouchbaseInstaller(cluster_spec, options)
if True:
installer.install()
if cm.remote:
cm.tune_logging()
cm.restart_with_sfwi()
cm.restart_with_alternative_num_vbuckets()
cm.restart_with_alternative_num_cpus()
cm.restart_with_tcmalloc_aggressive_decommit()
cm.disable_moxi()
cm.configure_internal_settings()
cm.set_data_path()
cm.set_services()
cm.set_mem_quota()
cm.set_index_mem_quota()
cm.set_auth()
time.sleep(30)
"""host = cluster_spec.yield_masters().next()"""
host_ip = cluster_spec.yield_masters().next().split(':')[0]
URL = 'http://' + host_ip + ':8093'
logger.info('logging the URL: {}'.format(URL))
conn = urllib3.connection_from_url(URL)
rest = RestHelper(cluster_spec)
airline_result = do_airline_benchmarks(mng_data, conn, rest, host_ip,
installer.remote, cluster_spec)
beer_result = do_beer_queries(mng_data, conn, rest, host_ip,
installer.remote)
print 'beer_result is', beer_result
#mng_data.cb_load_test(data["couchbase_query_bucket"],beer_result)
mng_data.load_data_query_benchmark(data["couchbase_query_bucket"],
'query_benchmark', test_id,
options.version)
mng_data.show_data_query_benchmark(data["couchbase_query_bucket"],
'query_benchmark', test_id)
sys.exit(not (airline_result and beer_result))
