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))