def get_cluster(config):
auth_provider = None
if 'auth_enabled' in config and config['auth_enabled']:
auth_provider = auth.PlainTextAuthProvider(
username=config['auth_username'],
password=config['auth_password'],
)
ssl_options = None
if 'ssl_enabled' in config and config['ssl_enabled']:
ssl_options = {
'ca_certs': config['ssl_ca_certs'],
'ssl_version': ssl.PROTOCOL_TLSv1, # pylint: disable=E1101
}
port = '9042'
if 'port' in config:
port = config['port']
cluster = Cluster(
config['hosts'],
auth_provider=auth_provider,
port=port,
ssl_options=ssl_options,
)
return cluster
def cassandra_connection(env, config):
ssl_options = None
if config.get(env, 'ssl_enabled'):
ssl_options = {}
ssl_options['ca_certs'] = config.get(env, 'ssl_ca_certs')
ssl_options['ssl_version'] = config.get(env, 'ssl_version')
if ssl_options['ssl_version'] == 'TLSv1':
ssl_options['ssl_version'] = ssl.PROTOCOL_TLSv1
elif ssl_options['ssl_version'] == 'TLSv1.1':
ssl_options['ssl_version'] = ssl.PROTOCOL_TLSv1_1
elif ssl_options['ssl_version'] == 'TLSv1.2':
ssl_options['ssl_version'] = ssl.PROTOCOL_TLSv1_2
else:
print('Unknown SSL Version')
sys.exit(4)
auth_provider = None
if config.get(env, 'auth_enabled'):
auth_provider = auth.PlainTextAuthProvider(
username=config.get(env, 'username'),
password=config.get(env, 'password'))
cluster_connection = cluster.Cluster(
config.get(env, 'cluster').split(","),
auth_provider=auth_provider,
port=config.get(env, 'port'),
ssl_options=ssl_options,
)
return cluster_connection
def _update_authentication_provider(self):
""" Create/recreate the auth provider """
if self._username and self._password:
# Only update provider when both are set
self._auth_provider = \
auth.PlainTextAuthProvider(self._username, self._password)
else:
self._auth_provider = None
def _connection(keyspace=None):
LOG.info('Initiating connection to cassandra')
ssl_options = None
if conf['cassandra']['ssl_enabled']:
LOG.info('SSL is enabled')
ssl_options = {}
ssl_options['ca_certs'] = conf['cassandra']['ssl_ca_certs']
ssl_version = conf['cassandra']['ssl_version']
if ssl_version == 'TLSv1':
ssl_options['ssl_version'] = ssl.PROTOCOL_TLSv1
elif ssl_version == 'TLSv1.1':
ssl_options['ssl_version'] = ssl.PROTOCOL_TLSv1_1
elif ssl_version == 'TLSv1.2':
ssl_options['ssl_version'] = ssl.PROTOCOL_TLSv1_2
else:
LOG.info('Unknown SSL Version')
LOG.info('Finished SSL part')
LOG.info('Starting password part')
auth_provider = None
if conf['cassandra']['auth_enabled']:
LOG.info('Password authentication is enabled')
auth_provider = auth.PlainTextAuthProvider(
username=conf['cassandra']['username'],
password=conf['cassandra']['password']
)
LOG.info('Finished password part')
LOG.info('Trying to connect to cassandra')
cluster_connection = cluster.Cluster(
conf['cassandra']['cluster'],
auth_provider=auth_provider,
port=conf['cassandra']['port'],
ssl_options=ssl_options,
)
LOG.info('Connected to cassandra')
LOG.info('Cassandra connection is established')
session = cluster_connection.connect()
if not keyspace:
keyspace = conf['cassandra']['keyspace']
try:
session.set_keyspace(keyspace)
except InvalidRequest:
_create_keyspace(session,
keyspace,
conf['cassandra']['replication_strategy'])
_run_migrations(conf['cassandra']['migrations'], session)
session.row_factory = query.dict_factory
return session
def get_session(config):
auth_provider = None
if 'auth_enabled' in config and config['auth_enabled']:
auth_provider = auth.PlainTextAuthProvider(
username=config['auth_username'],
password=config['auth_password'],
)
ssl_options = None
if 'ssl_enabled' in config and config['ssl_enabled']:
ssl_options = {
'ca_certs': config['ssl_ca_certs'],
'ssl_version': ssl.PROTOCOL_TLSv1, # pylint: disable=E1101
}
cluster = Cluster(
config['hosts'],
auth_provider=auth_provider,
ssl_options=ssl_options,
)
session = cluster.connect()
# Set session options. One dict mapping cdeploy option names to
# corresponding cassandra session option names; another dict defining any
# conversions that need to be done on the value in the config file. This
# way new options can be supported just by adding an entry to each dict.
optmap = {'consistency_level': 'default_consistency_level',
'timeout': 'default_timeout'}
conlevel = cassandra.ConsistencyLevel.name_to_value # Convenience alias.
converters = {'default_consistency_level': (lambda s: conlevel[s])}
sessionopts = {optmap[arg]: config[arg]
for arg in optmap.keys()
if arg in config}
for opt, value in sessionopts.items():
if opt in converters:
value = converters[opt](value)
setattr(session, opt, value)
try:
session.set_keyspace(config['keyspace'])
except cassandra.InvalidRequest:
# Keyspace doesn't exist yet
if 'create_keyspace' in config and config['create_keyspace']:
create_keyspace(config, session)
else:
raise
return session
def _connection(conf, datacenter, keyspace=None):
"""connection.
:param datacenter
:returns session
"""
ssl_options = None
if conf.ssl_enabled:
ssl_options = {
'ca_certs': conf.ssl_ca_certs,
'ssl_version': ssl.PROTOCOL_TLSv1
}
auth_provider = None
if conf.auth_enabled:
auth_provider = auth.PlainTextAuthProvider(
username=conf.username,
password=conf.password
)
load_balancing_policy_class = getattr(policies, conf.load_balance_strategy)
if load_balancing_policy_class is policies.DCAwareRoundRobinPolicy:
load_balancing_policy = load_balancing_policy_class(datacenter)
else:
load_balancing_policy = load_balancing_policy_class()
cluster_connection = cluster.Cluster(
conf.cluster,
auth_provider=auth_provider,
load_balancing_policy=load_balancing_policy,
port=conf.port,
ssl_options=ssl_options,
max_schema_agreement_wait=conf.max_schema_agreement_wait
)
session = cluster_connection.connect()
if not keyspace:
keyspace = conf.keyspace
try:
session.set_keyspace(keyspace)
except cassandra.InvalidRequest:
_create_keyspace(session, keyspace, conf.replication_strategy)
if conf.automatic_schema_migration:
migration_session = copy.copy(session)
migration_session.default_consistency_level = \
getattr(cassandra.ConsistencyLevel,
conf.migrations_consistency_level)
_run_migrations(conf.migrations_path, migration_session)
session.row_factory = query.dict_factory
return session
