def test_valid_bucket_name(self, password='******'):
tasks = []
if self.bucket_type == 'sasl':
self.cluster.create_sasl_bucket(self.server, self.bucket_name, password, self.num_replicas, self.bucket_size)
self.buckets.append(Bucket(name=self.bucket_name, authType="sasl", saslPassword=password, num_replicas=self.num_replicas,
bucket_size=self.bucket_size, master_id=self.server))
elif self.bucket_type == 'standard':
self.cluster.create_standard_bucket(self.server, self.bucket_name, STANDARD_BUCKET_PORT + 1, self.bucket_size, self.num_replicas)
self.buckets.append(Bucket(name=self.bucket_name, authType=None, saslPassword=None, num_replicas=self.num_replicas,
bucket_size=self.bucket_size, port=STANDARD_BUCKET_PORT + 1, master_id=self.server))
elif self.bucket_type == "memcached":
tasks.append(self.cluster.async_create_memcached_bucket(self.server, self.bucket_name, STANDARD_BUCKET_PORT + 1,
self.bucket_size, self.num_replicas))
self.buckets.append(Bucket(name=self.bucket_name, authType=None, saslPassword=None, num_replicas=self.num_replicas,
bucket_size=self.bucket_size, port=STANDARD_BUCKET_PORT + 1 , master_id=self.server, type='memcached'))
for task in tasks:
task.result()
else:
self.log.error('Bucket type not specified')
return
self.assertTrue(BucketOperationHelper.wait_for_bucket_creation(self.bucket_name, self.rest),
msg='failed to start up bucket with name "{0}'.format(self.bucket_name))
gen_load = BlobGenerator('buckettest', 'buckettest-', self.value_size, start=0, end=self.num_items)
self._load_all_buckets(self.server, gen_load, "create", 0)
self.cluster.bucket_delete(self.server, self.bucket_name)
self.assertTrue(BucketOperationHelper.wait_for_bucket_deletion(self.bucket_name, self.rest, timeout_in_seconds=60),
msg='bucket "{0}" was not deleted even after waiting for 30 seconds'.format(self.bucket_name))
def check(self, task_manager):
rest = RestConnection(self.server)
if BucketOperationHelper.wait_for_bucket_deletion(self.bucket, rest, 200):
self.set_result(True)
else:
self.set_result(False)
self.state = FINISHED
def test_default_moxi_sasl(self):
name = 'new-bucket-{0}'.format(uuid.uuid4())
for serverInfo in self.servers:
rest = RestConnection(serverInfo)
replicaNumber = 1
proxyPort = rest.get_nodes_self().moxi
rest.create_bucket(bucket=name,
ramQuotaMB=200,
replicaNumber=replicaNumber,
proxyPort=proxyPort,
authType="sasl",
saslPassword='******')
msg = 'create_bucket succeeded but bucket {0} does not exist'.format(
name)
self.assertTrue(BucketOperationHelper.wait_for_bucket_creation(
name, rest),
msg=msg)
ready = BucketOperationHelper.wait_for_memcached(serverInfo, name)
self.assertTrue(ready, "wait_for_memcached failed")
rest.delete_bucket(name)
msg = 'bucket "{0}" was not deleted even after waiting for two minutes'.format(
name)
self.assertTrue(BucketOperationHelper.wait_for_bucket_deletion(
name, rest, timeout_in_seconds=30),
msg=msg)
def test_ephemeral_buckets(self):
shared_params = self._create_bucket_params(server=self.server,
size=100,
replicas=self.num_replicas,
bucket_type='ephemeral')
# just do sasl for now, pending decision on support of non-sasl buckets in 5.0
self.cluster.create_sasl_bucket(name=self.bucket_name,
password=self.sasl_password,
bucket_params=shared_params)
self.buckets.append(
Bucket(name=self.bucket_name,
authType="sasl",
saslPassword=self.sasl_password,
num_replicas=self.num_replicas,
bucket_size=self.bucket_size,
master_id=self.server))
self.assertTrue(BucketOperationHelper.wait_for_bucket_creation(
self.bucket_name, self.rest),
msg='failed to start up bucket with name "{0}'.format(
self.bucket_name))
gen_load = BlobGenerator('buckettest',
'buckettest-',
self.value_size,
start=0,
end=self.num_items)
self._load_all_buckets(self.server, gen_load, "create", 0)
self.cluster.bucket_delete(self.server, self.bucket_name)
self.assertTrue(
BucketOperationHelper.wait_for_bucket_deletion(
self.bucket_name, self.rest, timeout_in_seconds=60),
msg='bucket "{0}" was not deleted even after waiting for 30 seconds'
.format(self.bucket_name))
def test_valid_bucket_name(self, password='******'):
tasks = []
shared_params = self._create_bucket_params(server=self.server, size=self.bucket_size,
replicas=self.num_replicas)
if self.bucket_type == 'sasl':
self.cluster.create_sasl_bucket(name=self.bucket_name, password=password,bucket_params=shared_params)
self.buckets.append(Bucket(name=self.bucket_name, authType="sasl", saslPassword=password, num_replicas=self.num_replicas,
bucket_size=self.bucket_size, master_id=self.server))
elif self.bucket_type == 'standard':
self.cluster.create_standard_bucket(name=self.bucket_name, port=STANDARD_BUCKET_PORT+1,
bucket_params=shared_params)
self.buckets.append(Bucket(name=self.bucket_name, authType=None, saslPassword=None, num_replicas=self.num_replicas,
bucket_size=self.bucket_size, port=STANDARD_BUCKET_PORT + 1, master_id=self.server))
elif self.bucket_type == "memcached":
tasks.append(self.cluster.async_create_memcached_bucket(name=self.bucket_name,
port=STANDARD_BUCKET_PORT+1,
bucket_params=shared_params))
self.buckets.append(Bucket(name=self.bucket_name, authType=None, saslPassword=None,
num_replicas=self.num_replicas, bucket_size=self.bucket_size,
port=STANDARD_BUCKET_PORT + 1 , master_id=self.server, type='memcached'))
for task in tasks:
task.result()
else:
self.log.error('Bucket type not specified')
return
self.assertTrue(BucketOperationHelper.wait_for_bucket_creation(self.bucket_name, self.rest),
msg='failed to start up bucket with name "{0}'.format(self.bucket_name))
gen_load = BlobGenerator('buckettest', 'buckettest-', self.value_size, start=0, end=self.num_items)
self._load_all_buckets(self.server, gen_load, "create", 0)
self.cluster.bucket_delete(self.server, self.bucket_name)
self.assertTrue(BucketOperationHelper.wait_for_bucket_deletion(self.bucket_name, self.rest, timeout_in_seconds=60),
msg='bucket "{0}" was not deleted even after waiting for 30 seconds'.format(self.bucket_name))
def test_default_moxi(self):
name = 'default'
for serverInfo in self.servers:
rest = RestConnection(serverInfo)
replicaNumber = 1
proxyPort = rest.get_nodes_self().moxi
rest.create_bucket(bucket=name,
ramQuotaMB=200,
replicaNumber=replicaNumber,
proxyPort=proxyPort)
msg = 'create_bucket succeeded but bucket {0} does not exist'.format(name)
self.assertTrue(BucketOperationHelper.wait_for_bucket_creation(name, rest), msg=msg)
ready = BucketOperationHelper.wait_for_memcached(serverInfo, name)
self.assertTrue(ready, "wait_for_memcached failed")
inserted_keys = BucketOperationHelper.load_some_data(serverInfo, 1, name)
self.assertTrue(inserted_keys, 'unable to insert any key to memcached')
verified = BucketOperationHelper.verify_data(serverInfo, inserted_keys, True, False, self, bucket=name)
self.assertTrue(verified, msg='verified all the keys stored')
#verify keys
rest.delete_bucket(name)
msg = 'bucket "{0}" was not deleted even after waiting for two minutes'.format(name)
self.assertTrue(BucketOperationHelper.wait_for_bucket_deletion(name, rest, timeout_in_seconds=60), msg=msg)
rest.create_bucket(bucket=name,
ramQuotaMB=200,
replicaNumber=replicaNumber,
proxyPort=proxyPort)
msg = 'create_bucket succeeded but bucket {0} does not exist'.format(name)
self.assertTrue(BucketOperationHelper.wait_for_bucket_creation(name, rest), msg=msg)
BucketOperationHelper.wait_for_memcached(serverInfo, name)
#now let's recreate the bucket
self.log.info('recreated the default bucket...')
#loop over the keys make sure they dont exist
self.assertTrue(BucketOperationHelper.keys_dont_exist(serverInfo, inserted_keys, name),
msg='at least one key found in the bucket')
def test_non_default_moxi(self):
name = 'new-bucket-{0}'.format(uuid.uuid4())
for serverInfo in self.servers:
replicas = [0, 1, 2, 3]
for replicaNumber in replicas:
rest = RestConnection(serverInfo)
proxyPort = rest.get_nodes_self().moxi + 2000
rest.create_bucket(bucket=name,
ramQuotaMB=200,
replicaNumber=replicaNumber,
proxyPort=proxyPort)
remote = RemoteMachineShellConnection(serverInfo)
msg = 'create_bucket succeeded but bucket {0} does not exist'.format(
name)
self.assertTrue(BucketOperationHelper.wait_for_bucket_creation(
name, rest),
msg=msg)
rest.delete_bucket(name)
msg = 'bucket "{0}" was not deleted even after waiting for 30 seconds'.format(
name)
self.assertTrue(BucketOperationHelper.wait_for_bucket_deletion(
name, rest, timeout_in_seconds=30),
msg=msg)
msg = 'bucket {0} data files are not deleted after bucket deleted from membase'.format(
name)
self.assertTrue(self.wait_for_data_files_deletion(
name,
remote_connection=remote,
rest=rest,
timeout_in_seconds=20),
msg=msg)
BucketOperationHelper.delete_bucket_or_assert(
serverInfo, name, self)
def check_bucket_deleted(self):
rest = RestConnection(self.server)
if BucketOperationHelper.wait_for_bucket_deletion(self.bucket, rest, 200):
self.set_result({"status": "success", "value": None})
else:
self.set_result({"status": "error",
"value": "{0} bucket took too long to delete".format(self.bucket)})
self.state = "finished"
def delete_all_buckets_or_assert(ips, test_case):
log.info('deleting existing buckets on {0}'.format(ips))
for ip in ips:
rest = RestConnection(ip=ip)
buckets = rest.get_buckets()
for bucket in buckets:
rest.delete_bucket(bucket.name)
log.info('deleted bucket : {0}'.format(bucket.name))
msg = 'bucket "{0}" was not deleted even after waiting for two minutes'.format(bucket.name)
test_case.assertTrue(BucketOperationHelper.wait_for_bucket_deletion(bucket.name, rest, 200), msg=msg)
def test_default_dedicated(self):
name = 'recreate-non-default-{0}'.format(uuid.uuid4())
serverInfo = self.servers[0]
if serverInfo.ip != "":
rest = RestConnection(serverInfo)
replicaNumber = 1
proxyPort = rest.get_nodes_self().memcached + 2000
rest.create_bucket(bucket=name,
ramQuotaMB=200,
replicaNumber=replicaNumber,
proxyPort=proxyPort)
msg = 'create_bucket succeeded but bucket {0} does not exist'.format(
name)
self.assertTrue(BucketOperationHelper.wait_for_bucket_creation(
name, rest),
msg=msg)
ready = BucketOperationHelper.wait_for_memcached(serverInfo, name)
self.assertTrue(ready, "wait_for_memcached failed")
inserted_keys = BucketOperationHelper.load_some_data(
serverInfo, 1, name)
self.assertTrue(inserted_keys,
'unable to insert any key to memcached')
verified = BucketOperationHelper.verify_data(serverInfo,
inserted_keys,
True,
False,
self,
bucket=name)
self.assertTrue(verified, msg='verified all the keys stored')
#verify keys
rest.delete_bucket(name)
msg = 'bucket "{0}" was not deleted even after waiting for two minutes'.format(
name)
self.assertTrue(BucketOperationHelper.wait_for_bucket_deletion(
name, rest, timeout_in_seconds=60),
msg=msg)
rest.create_bucket(bucket=name,
ramQuotaMB=200,
replicaNumber=replicaNumber,
proxyPort=proxyPort)
msg = 'create_bucket succeeded but bucket {0} does not exist'.format(
name)
self.assertTrue(BucketOperationHelper.wait_for_bucket_creation(
name, rest),
msg=msg)
ready = BucketOperationHelper.wait_for_memcached(serverInfo, name)
self.assertTrue(ready, "wait_for_memcached failed")
#now let's recreate the bucket
self.log.info('recreated the default bucket...')
#loop over the keys make sure they dont exist
self.assertTrue(BucketOperationHelper.keys_dont_exist(
serverInfo, inserted_keys, name),
msg='at least one key found in the bucket')
def check_bucket_deleted(self):
rest = RestConnection(self.server)
if BucketOperationHelper.wait_for_bucket_deletion(
self.bucket, rest, 200):
self.set_result({"status": "success", "value": None})
else:
self.set_result({
"status":
"error",
"value":
"{0} bucket took too long to delete".format(self.bucket)
})
self.state = "finished"
def check(self, task_manager):
rest = RestConnection(self.server)
try:
if BucketOperationHelper.wait_for_bucket_deletion(self.bucket, rest, 200):
self.set_result(True)
else:
self.set_result(False)
self.state = FINISHED
#catch and set all unexpected exceptions
except Exception as e:
self.state = FINISHED
self.log.info("Unexpected Exception Caught")
self.set_exception(e)
def test_ephemeral_buckets(self):
eviction_policy = self.input.param("eviction_policy", 'noEviction')
shared_params = self._create_bucket_params(server=self.server, size=100,
replicas=self.num_replicas, bucket_type='ephemeral',
eviction_policy=eviction_policy)
# just do sasl for now, pending decision on support of non-sasl buckets in 5.0
self.cluster.create_sasl_bucket(name=self.bucket_name, password=self.sasl_password, bucket_params=shared_params)
self.buckets.append(Bucket(name=self.bucket_name, authType="sasl", saslPassword=self.sasl_password,
num_replicas=self.num_replicas,
bucket_size=self.bucket_size, master_id=self.server))
self.assertTrue(BucketOperationHelper.wait_for_bucket_creation(self.bucket_name, self.rest),
msg='failed to start up bucket with name "{0}'.format(self.bucket_name))
gen_load = BlobGenerator('buckettest', 'buckettest-', self.value_size, start=0, end=self.num_items)
self._load_all_buckets(self.server, gen_load, "create", 0)
self.cluster.bucket_delete(self.server, self.bucket_name)
self.assertTrue(BucketOperationHelper.wait_for_bucket_deletion(self.bucket_name, self.rest, timeout_in_seconds=60),
msg='bucket "{0}" was not deleted even after waiting for 30 seconds'.format(self.bucket_name))
def test_default_moxi_sasl(self):
name = 'new-bucket-{0}'.format(uuid.uuid4())
for serverInfo in self.servers:
rest = RestConnection(serverInfo)
replicaNumber = 1
proxyPort = rest.get_nodes_self().moxi
rest.create_bucket(bucket=name,
ramQuotaMB=200,
replicaNumber=replicaNumber,
proxyPort=proxyPort,
authType="sasl",
saslPassword='******')
msg = 'create_bucket succeeded but bucket {0} does not exist'.format(name)
self.assertTrue(BucketOperationHelper.wait_for_bucket_creation(name, rest), msg=msg)
ready = BucketOperationHelper.wait_for_memcached(serverInfo, name)
self.assertTrue(ready, "wait_for_memcached failed")
rest.delete_bucket(name)
msg = 'bucket "{0}" was not deleted even after waiting for two minutes'.format(name)
self.assertTrue(BucketOperationHelper.wait_for_bucket_deletion(name, rest, timeout_in_seconds=30), msg=msg)
def test_non_default_moxi(self):
name = "new-bucket-{0}".format(uuid.uuid4())
for serverInfo in self.servers:
replicas = [0, 1, 2, 3]
for replicaNumber in replicas:
rest = RestConnection(serverInfo)
proxyPort = rest.get_nodes_self().moxi + 2000
rest.create_bucket(bucket=name, ramQuotaMB=200, replicaNumber=replicaNumber, proxyPort=proxyPort)
remote = RemoteMachineShellConnection(serverInfo)
msg = "create_bucket succeeded but bucket {0} does not exist".format(name)
self.assertTrue(BucketOperationHelper.wait_for_bucket_creation(name, rest), msg=msg)
rest.delete_bucket(name)
msg = 'bucket "{0}" was not deleted even after waiting for 30 seconds'.format(name)
self.assertTrue(
BucketOperationHelper.wait_for_bucket_deletion(name, rest, timeout_in_seconds=30), msg=msg
)
msg = "bucket {0} data files are not deleted after bucket deleted from membase".format(name)
self.assertTrue(
self.wait_for_data_files_deletion(name, remote_connection=remote, rest=rest, timeout_in_seconds=20),
msg=msg,
)
BucketOperationHelper.delete_bucket_or_assert(serverInfo, name, self)
def test_valid_bucket_name(self, password='******'):
tasks = []
shared_params = self._create_bucket_params(server=self.server,
size=self.bucket_size,
replicas=self.num_replicas)
if self.bucket_type == 'sasl':
self.cluster.create_sasl_bucket(name=self.bucket_name,
password=password,
bucket_params=shared_params)
self.buckets.append(
Bucket(name=self.bucket_name,
num_replicas=self.num_replicas,
bucket_size=self.bucket_size,
master_id=self.server))
elif self.bucket_type == 'standard':
self.cluster.create_standard_bucket(name=self.bucket_name,
port=STANDARD_BUCKET_PORT + 1,
bucket_params=shared_params)
self.buckets.append(
Bucket(name=self.bucket_name,
num_replicas=self.num_replicas,
bucket_size=self.bucket_size,
port=STANDARD_BUCKET_PORT + 1,
master_id=self.server))
elif self.bucket_type == "memcached":
tasks.append(
self.cluster.async_create_memcached_bucket(
name=self.bucket_name,
port=STANDARD_BUCKET_PORT + 1,
bucket_params=shared_params))
self.buckets.append(
Bucket(name=self.bucket_name,
num_replicas=self.num_replicas,
bucket_size=self.bucket_size,
port=STANDARD_BUCKET_PORT + 1,
master_id=self.server,
type='memcached'))
for task in tasks:
task.result()
else:
self.log.error('Bucket type not specified')
return
self.assertTrue(BucketOperationHelper.wait_for_bucket_creation(
self.bucket_name, self.rest),
msg='failed to start up bucket with name "{0}'.format(
self.bucket_name))
if self.bucket_type == "memcached":
mc = MemcachedClient(self.master.ip, 11210)
mc.sasl_auth_plain(self.master.rest_username,
self.master.rest_password)
mc.bucket_select(self.bucket_name)
for i in range(self.num_items):
Key = "key" + str(i)
try:
mc.set(Key, 0, 0, "value1")
except MemcachedError as error:
self.fail("Error on creating a doc")
else:
gen_load = BlobGenerator('buckettest',
'buckettest-',
self.value_size,
start=0,
end=self.num_items)
self._load_all_buckets(self.server, gen_load, "create", 0)
self.cluster.bucket_delete(self.server, self.bucket_name)
self.assertTrue(
BucketOperationHelper.wait_for_bucket_deletion(
self.bucket_name, self.rest, timeout_in_seconds=60),
msg='bucket "{0}" was not deleted even after waiting for 30 seconds'
.format(self.bucket_name))
