def prepare()

in upgrade_tests/upgrade_base.py [0:0]

• 41 lines of code
• 14 McCabe index (conditional complexity)

    def prepare(self, ordered=False, create_keyspace=True, use_cache=False, use_thrift=False,
                nodes=None, rf=None, protocol_version=None, cl=None, extra_config_options=None, **kwargs):
        nodes = self.NODES if nodes is None else nodes
        rf = self.RF if rf is None else rf

        cl = self.CL if cl is None else cl
        self.CL = cl  # store for later use in do_upgrade

        assert nodes, 2 >= "backwards compatibility tests require at least two nodes"

        self.protocol_version = protocol_version if protocol_version is not None else self.UPGRADE_PATH.starting_meta.max_proto_v

        cluster = self.cluster

        cluster.set_install_dir(version=self.UPGRADE_PATH.starting_version)

        install_dir_class = extension.get_cluster_class(cluster.get_install_dir())
        if cluster.__class__ != install_dir_class:
            logger.info("changing cluster type to {} (from {} bc {})".format(install_dir_class, cluster.__class__, cluster.get_install_dir()))
            cluster.__class__ = install_dir_class
            cluster._cassandra_version = cluster.dse_username = cluster.dse_password = None

        self.install_nodetool_legacy_parsing()
        self.fixture_dtest_setup.reinitialize_cluster_for_different_version()

        if ordered:
            cluster.set_partitioner("org.apache.cassandra.dht.ByteOrderedPartitioner")

        if use_cache:
            cluster.set_configuration_options(values={'row_cache_size_in_mb': 100})

        if use_thrift:
            cluster.set_configuration_options(values={'start_rpc': 'true'})

        start_rpc = kwargs.pop('start_rpc', False)
        if start_rpc:
            cluster.set_configuration_options(values={'start_rpc': True})

        cluster.set_configuration_options(values={'internode_compression': 'none', 'endpoint_snitch': 'SimpleSnitch'})

        if extra_config_options:
            cluster.set_configuration_options(values=extra_config_options)

        cluster.populate(nodes)
        cluster.start()

        node1 = cluster.nodelist()[0]
        time.sleep(0.2)

        logger.info("nodes started on {}, connecting with protocol_version: {}; cl: ".format(cluster.version(), self.protocol_version, cl))
        if cl:
            session = self.patient_cql_connection(node1, protocol_version=self.protocol_version, consistency_level=cl, **kwargs)
        else:
            session = self.patient_cql_connection(node1, protocol_version=self.protocol_version, **kwargs)
        if create_keyspace:
            create_ks(session, 'ks', rf)

        return session