def init()

in analysis/webservice/algorithms/doms/DomsInitialization.py [0:0]
46 lines of code
9 McCabe index (conditional complexity)

    def init(self, config):
        self.log = logging.getLogger(__name__)
        self.log.info("*** STARTING DOMS INITIALIZATION ***")

        domsconfig = configparser.SafeConfigParser()
        domsconfig.read(DomsInitializer._get_config_files('domsconfig.ini'))
        domsconfig = self.override_config(domsconfig, config)

        cassHost = domsconfig.get("cassandra", "host")
        cassPort = domsconfig.get("cassandra", "port")
        cassUsername = domsconfig.get("cassandra", "username")
        cassPassword = domsconfig.get("cassandra", "password")
        cassKeyspace = domsconfig.get("cassandra", "keyspace")
        cassDatacenter = domsconfig.get("cassandra", "local_datacenter")
        cassVersion = int(domsconfig.get("cassandra", "protocol_version"))
        cassPolicy = domsconfig.get("cassandra", "dc_policy")
        try:
            cassCreateKeyspaceGranted = domsconfig.get("cassandra", "create_keyspace_granted")
        except configparser.NoOptionError:
            cassCreateKeyspaceGranted = "True"

        self.log.info("Cassandra Host(s): %s" % (cassHost))
        self.log.info("Cassandra Keyspace: %s" % (cassKeyspace))
        self.log.info("Cassandra Datacenter: %s" % (cassDatacenter))
        self.log.info("Cassandra Protocol Version: %s" % (cassVersion))
        self.log.info("Cassandra DC Policy: %s" % (cassPolicy))

        if cassPolicy == 'DCAwareRoundRobinPolicy':
            dc_policy = DCAwareRoundRobinPolicy(cassDatacenter)
            token_policy = TokenAwarePolicy(dc_policy)
        elif cassPolicy == 'WhiteListRoundRobinPolicy':
            token_policy = WhiteListRoundRobinPolicy([cassHost])

        if cassUsername and cassPassword:
            auth_provider = PlainTextAuthProvider(username=cassUsername, password=cassPassword)
        else:
            auth_provider = None

        try:
            with Cluster([host for host in cassHost.split(',')],
                         port=int(cassPort),
                         load_balancing_policy=token_policy,
                         protocol_version=cassVersion,
                         auth_provider=auth_provider) as cluster:
                session = cluster.connect()

                if cassCreateKeyspaceGranted in ["True", "true"]:
                    self.createKeyspace(session, cassKeyspace)
                else:
                    session.set_keyspace(cassKeyspace)

                self.createTables(session)

        except NoHostAvailable as e:
            self.log.error("Unable to connect to Cassandra, Nexus will not be able to access local data ", e)