def _populateCluster(self, enableSSL=False, nativePort=None, nativePortSSL=None, sslOptional=False): cluster = self.cluster if enableSSL: generate_ssl_stores(self.fixture_dtest_setup.test_path) cluster.set_configuration_options({ 'client_encryption_options': { 'enabled': True, 'optional': sslOptional, 'keystore': os.path.join(self.fixture_dtest_setup.test_path, 'keystore.jks'), 'keystore_password': '******' } }) if nativePort: cluster.set_configuration_options( {'native_transport_port': nativePort}) if nativePortSSL: cluster.set_configuration_options( {'native_transport_port_ssl': nativePortSSL}) cluster.populate(1) return cluster
def __putget_with_internode_ssl_test(self, internode_compression): cluster = self.cluster logger.debug("***using internode ssl***") generate_ssl_stores(self.fixture_dtest_setup.test_path) cluster.set_configuration_options({'internode_compression': internode_compression}) cluster.enable_internode_ssl(self.fixture_dtest_setup.test_path) cluster.populate(3).start() session = self.patient_cql_connection(cluster.nodelist()[0]) create_ks(session, 'ks', 3) create_cf(session, 'cf', compression=None) putget(cluster, session)
def __putget_with_internode_ssl_test(self, internode_compression): cluster = self.cluster debug("***using internode ssl***") generate_ssl_stores(self.test_path) cluster.set_configuration_options({'internode_compression': internode_compression}) cluster.enable_internode_ssl(self.test_path) cluster.populate(3).start() session = self.patient_cql_connection(cluster.nodelist()[0]) create_ks(session, 'ks', 3) create_cf(session, 'cf', compression=None) putget(cluster, session)
def _populateCluster(self, enableSSL=False, nativePort=None, nativePortSSL=None, sslOptional=False): cluster = self.cluster if enableSSL: generate_ssl_stores(self.fixture_dtest_setup.test_path) # C* versions before 3.0 (CASSANDRA-10559) do not know about # 'client_encryption_options.optional' - so we must not add that parameter if sslOptional: cluster.set_configuration_options({ 'client_encryption_options': { 'enabled': True, 'optional': sslOptional, 'keystore': os.path.join(self.fixture_dtest_setup.test_path, 'keystore.jks'), 'keystore_password': '******' } }) else: cluster.set_configuration_options({ 'client_encryption_options': { 'enabled': True, 'keystore': os.path.join(self.fixture_dtest_setup.test_path, 'keystore.jks'), 'keystore_password': '******' } }) if nativePort: cluster.set_configuration_options( {'native_transport_port': nativePort}) if nativePortSSL: cluster.set_configuration_options( {'native_transport_port_ssl': nativePortSSL}) cluster.populate(1) return cluster
def _populateCluster(self, require_client_auth=False): cluster = self.cluster cluster.populate(1) generate_ssl_stores(self.fixture_dtest_setup.test_path) if require_client_auth: ts = self.truststore() ts_pwd = self.truststore_password else: ts = None ts_pwd = None enable_jmx_ssl(cluster.nodelist()[0], require_client_auth=require_client_auth, keystore=self.keystore(), keystore_password=self.keystore_password, truststore=ts, truststore_password=ts_pwd) return cluster
def _populateCluster(self, require_client_auth=False): cluster = self.cluster cluster.populate(1) generate_ssl_stores(self.test_path) if require_client_auth: ts = self.truststore() ts_pwd = self.truststore_password else: ts = None ts_pwd = None enable_jmx_ssl(cluster.nodelist()[0], require_client_auth=require_client_auth, keystore=self.keystore(), keystore_password=self.keystore_password, truststore=ts, truststore_password=ts_pwd) return cluster
def _populateCluster(self, enableSSL=False, nativePort=None, nativePortSSL=None, sslOptional=False): cluster = self.cluster if enableSSL: generate_ssl_stores(self.test_path) # C* versions before 3.0 (CASSANDRA-10559) do not know about # 'client_encryption_options.optional' - so we must not add that parameter if sslOptional: cluster.set_configuration_options({ 'client_encryption_options': { 'enabled': True, 'optional': sslOptional, 'keystore': os.path.join(self.test_path, 'keystore.jks'), 'keystore_password': '******' } }) else: cluster.set_configuration_options({ 'client_encryption_options': { 'enabled': True, 'keystore': os.path.join(self.test_path, 'keystore.jks'), 'keystore_password': '******' } }) if nativePort: cluster.set_configuration_options({ 'native_transport_port': nativePort }) if nativePortSSL: cluster.set_configuration_options({ 'native_transport_port_ssl': nativePortSSL }) cluster.populate(1) return cluster
def upgrade_scenario(self, populate=True, create_schema=True, rolling=False, after_upgrade_call=(), internode_ssl=False): # Record the rows we write as we go: if populate: self.prepare() self.row_values = set() cluster = self.cluster if cluster.version() >= '3.0': cluster.set_configuration_options({'enable_user_defined_functions': 'true', 'enable_scripted_user_defined_functions': 'true'}) elif cluster.version() >= '2.2': cluster.set_configuration_options({'enable_user_defined_functions': 'true'}) if internode_ssl: logger.debug("***using internode ssl***") generate_ssl_stores(self.fixture_dtest_setup.test_path) self.cluster.enable_internode_ssl(self.fixture_dtest_setup.test_path) if populate: # Start with 3 node cluster logger.debug('Creating cluster (%s)' % self.test_version_metas[0].version) cluster.populate(3) [node.start(use_jna=True, wait_for_binary_proto=True) for node in cluster.nodelist()] else: logger.debug("Skipping cluster creation (should already be built)") # add nodes to self for convenience for i, node in enumerate(cluster.nodelist(), 1): node_name = 'node' + str(i) setattr(self, node_name, node) if create_schema: if rolling: self._create_schema_for_rolling() else: self._create_schema() else: logger.debug("Skipping schema creation (should already be built)") time.sleep(5) # sigh... self._log_current_ver(self.test_version_metas[0]) if rolling: # start up processes to write and verify data write_proc, verify_proc, verification_queue = self._start_continuous_write_and_verify(wait_for_rowcount=5000) # upgrade through versions for version_meta in self.test_version_metas[1:]: if version_meta.family > '3.11' and internode_ssl: seeds =[] for seed in cluster.seeds: seeds.append(seed.ip_addr + ':7001') logger.debug("Forcing seeds to 7001 for internode ssl") cluster.seeds = seeds for num, node in enumerate(self.cluster.nodelist()): # sleep (sigh) because driver needs extra time to keep up with topo and make quorum possible # this is ok, because a real world upgrade would proceed much slower than this programmatic one # additionally this should provide more time for timeouts and other issues to crop up as well, which we could # possibly "speed past" in an overly fast upgrade test time.sleep(60) self.upgrade_to_version(version_meta, partial=True, nodes=(node,), internode_ssl=internode_ssl) self._check_on_subprocs(self.fixture_dtest_setup.subprocs) logger.debug('Successfully upgraded %d of %d nodes to %s' % (num + 1, len(self.cluster.nodelist()), version_meta.version)) self.cluster.set_install_dir(version=version_meta.version) self.fixture_dtest_setup.reinitialize_cluster_for_different_version() # Stop write processes write_proc.terminate() # wait for the verification queue's to empty (and check all rows) before continuing self._wait_until_queue_condition('writes pending verification', verification_queue, operator.le, 0, max_wait_s=1200) self._check_on_subprocs([verify_proc]) # make sure the verification processes are running still self._terminate_subprocs() # not a rolling upgrade, do everything in parallel: else: # upgrade through versions for version_meta in self.test_version_metas[1:]: self._write_values() self._increment_counters() self.upgrade_to_version(version_meta, internode_ssl=internode_ssl) self.cluster.set_install_dir(version=version_meta.version) self.fixture_dtest_setup.reinitialize_cluster_for_different_version() self._check_values() self._check_counters() self._check_select_count() # run custom post-upgrade callables for call in after_upgrade_call: call() logger.debug('All nodes successfully upgraded to %s' % version_meta.version) self._log_current_ver(version_meta) cluster.stop()
def _base_bootstrap_test(self, bootstrap=None, bootstrap_from_version=None, enable_ssl=None): def default_bootstrap(cluster, token): node2 = new_node(cluster) node2.set_configuration_options(values={'initial_token': token}) node2.start(wait_for_binary_proto=True) return node2 if bootstrap is None: bootstrap = default_bootstrap cluster = self.cluster if enable_ssl: logger.debug("***using internode ssl***") generate_ssl_stores(self.fixture_dtest_setup.test_path) cluster.enable_internode_ssl(self.fixture_dtest_setup.test_path) tokens = cluster.balanced_tokens(2) cluster.set_configuration_options(values={'num_tokens': 1}) logger.debug("[node1, node2] tokens: %r" % (tokens, )) keys = 10000 # Create a single node cluster cluster.populate(1) node1 = cluster.nodelist()[0] if bootstrap_from_version: logger.debug("starting source node on version {}".format( bootstrap_from_version)) node1.set_install_dir(version=bootstrap_from_version) node1.set_configuration_options(values={'initial_token': tokens[0]}) cluster.start(wait_other_notice=True) session = self.patient_cql_connection(node1) create_ks(session, 'ks', 1) create_cf(session, 'cf', columns={'c1': 'text', 'c2': 'text'}) # record the size before inserting any of our own data empty_size = data_size(node1, 'ks', 'cf') logger.debug("node1 empty size for ks.cf: %s" % float(empty_size)) insert_statement = session.prepare( "INSERT INTO ks.cf (key, c1, c2) VALUES (?, 'value1', 'value2')") execute_concurrent_with_args(session, insert_statement, [['k%d' % k] for k in range(keys)]) node1.flush() node1.compact() initial_size = data_size(node1, 'ks', 'cf') logger.debug("node1 size for ks.cf before bootstrapping node2: %s" % float(initial_size)) # Reads inserted data all during the bootstrap process. We shouldn't # get any error query_c1c2(session, random.randint(0, keys - 1), ConsistencyLevel.ONE) session.shutdown() # Bootstrapping a new node in the current version node2 = bootstrap(cluster, tokens[1]) node2.compact() node1.cleanup() logger.debug("node1 size for ks.cf after cleanup: %s" % float(data_size(node1, 'ks', 'cf'))) node1.compact() logger.debug("node1 size for ks.cf after compacting: %s" % float(data_size(node1, 'ks', 'cf'))) logger.debug("node2 size for ks.cf after compacting: %s" % float(data_size(node2, 'ks', 'cf'))) size1 = float(data_size(node1, 'ks', 'cf')) size2 = float(data_size(node2, 'ks', 'cf')) assert_almost_equal(size1, size2, error=0.3) assert_almost_equal(float(initial_size - empty_size), 2 * (size1 - float(empty_size))) assert_bootstrap_state(self, node2, 'COMPLETED')
def _base_bootstrap_test(self, bootstrap=None, bootstrap_from_version=None, enable_ssl=None): def default_bootstrap(cluster, token): node2 = new_node(cluster) node2.set_configuration_options(values={'initial_token': token}) node2.start(wait_for_binary_proto=True) return node2 if bootstrap is None: bootstrap = default_bootstrap cluster = self.cluster if enable_ssl: logger.debug("***using internode ssl***") generate_ssl_stores(self.fixture_dtest_setup.test_path) cluster.enable_internode_ssl(self.fixture_dtest_setup.test_path) tokens = cluster.balanced_tokens(2) cluster.set_configuration_options(values={'num_tokens': 1}) logger.debug("[node1, node2] tokens: %r" % (tokens,)) keys = 10000 # Create a single node cluster cluster.populate(1) node1 = cluster.nodelist()[0] if bootstrap_from_version: logger.debug("starting source node on version {}".format(bootstrap_from_version)) node1.set_install_dir(version=bootstrap_from_version) node1.set_configuration_options(values={'initial_token': tokens[0]}) cluster.start(wait_other_notice=True) session = self.patient_cql_connection(node1) create_ks(session, 'ks', 1) create_cf(session, 'cf', columns={'c1': 'text', 'c2': 'text'}) # record the size before inserting any of our own data empty_size = node1.data_size() logger.debug("node1 empty size : %s" % float(empty_size)) insert_statement = session.prepare("INSERT INTO ks.cf (key, c1, c2) VALUES (?, 'value1', 'value2')") execute_concurrent_with_args(session, insert_statement, [['k%d' % k] for k in range(keys)]) node1.flush() node1.compact() initial_size = node1.data_size() logger.debug("node1 size before bootstrapping node2: %s" % float(initial_size)) # Reads inserted data all during the bootstrap process. We shouldn't # get any error query_c1c2(session, random.randint(0, keys - 1), ConsistencyLevel.ONE) session.shutdown() # Bootstrapping a new node in the current version node2 = bootstrap(cluster, tokens[1]) node2.compact() node1.cleanup() logger.debug("node1 size after cleanup: %s" % float(node1.data_size())) node1.compact() logger.debug("node1 size after compacting: %s" % float(node1.data_size())) logger.debug("node2 size after compacting: %s" % float(node2.data_size())) size1 = float(node1.data_size()) size2 = float(node2.data_size()) assert_almost_equal(size1, size2, error=0.3) assert_almost_equal(float(initial_size - empty_size), 2 * (size1 - float(empty_size))) assert_bootstrap_state(self, node2, 'COMPLETED')
def upgrade_scenario(self, populate=True, create_schema=True, rolling=False, after_upgrade_call=(), internode_ssl=False): # Record the rows we write as we go: self.row_values = set() cluster = self.cluster if cluster.version() >= '3.0': cluster.set_configuration_options({'enable_user_defined_functions': 'true', 'enable_scripted_user_defined_functions': 'true'}) elif cluster.version() >= '2.2': cluster.set_configuration_options({'enable_user_defined_functions': 'true'}) if internode_ssl: debug("***using internode ssl***") generate_ssl_stores(self.test_path) self.cluster.enable_internode_ssl(self.test_path) if populate: # Start with 3 node cluster debug('Creating cluster (%s)' % self.test_version_metas[0].version) cluster.populate(3) [node.start(use_jna=True, wait_for_binary_proto=True) for node in cluster.nodelist()] else: debug("Skipping cluster creation (should already be built)") # add nodes to self for convenience for i, node in enumerate(cluster.nodelist(), 1): node_name = 'node' + str(i) setattr(self, node_name, node) if create_schema: if rolling: self._create_schema_for_rolling() else: self._create_schema() else: debug("Skipping schema creation (should already be built)") time.sleep(5) # sigh... self._log_current_ver(self.test_version_metas[0]) if rolling: # start up processes to write and verify data write_proc, verify_proc, verification_queue = self._start_continuous_write_and_verify(wait_for_rowcount=5000) # upgrade through versions for version_meta in self.test_version_metas[1:]: for num, node in enumerate(self.cluster.nodelist()): # sleep (sigh) because driver needs extra time to keep up with topo and make quorum possible # this is ok, because a real world upgrade would proceed much slower than this programmatic one # additionally this should provide more time for timeouts and other issues to crop up as well, which we could # possibly "speed past" in an overly fast upgrade test time.sleep(60) self.upgrade_to_version(version_meta, partial=True, nodes=(node,), internode_ssl=internode_ssl) self._check_on_subprocs(self.subprocs) debug('Successfully upgraded %d of %d nodes to %s' % (num + 1, len(self.cluster.nodelist()), version_meta.version)) self.cluster.set_install_dir(version=version_meta.version) # Stop write processes write_proc.terminate() # wait for the verification queue's to empty (and check all rows) before continuing self._wait_until_queue_condition('writes pending verification', verification_queue, operator.le, 0, max_wait_s=1200) self._check_on_subprocs([verify_proc]) # make sure the verification processes are running still self._terminate_subprocs() # not a rolling upgrade, do everything in parallel: else: # upgrade through versions for version_meta in self.test_version_metas[1:]: self._write_values() self._increment_counters() self.upgrade_to_version(version_meta, internode_ssl=internode_ssl) self.cluster.set_install_dir(version=version_meta.version) self._check_values() self._check_counters() self._check_select_count() # run custom post-upgrade callables for call in after_upgrade_call: call() debug('All nodes successfully upgraded to %s' % version_meta.version) self._log_current_ver(version_meta) cluster.stop()
def setup_internode_ssl(self, cluster): logger.debug("***using internode ssl***") generate_ssl_stores(self.fixture_dtest_setup.test_path) cluster.enable_internode_ssl(self.fixture_dtest_setup.test_path)