def monasca(self):
if self._monasca:
return self._monasca
monascaclient_version = self._get_client_option(
'monasca', 'api_version')
monascaclient_interface = self._get_client_option(
'monasca', 'interface')
token = self.session.get_token()
watcher_clients_auth_config = CONF.get(_CLIENTS_AUTH_GROUP)
service_type = 'monitoring'
monasca_kwargs = {
'auth_url': watcher_clients_auth_config.auth_url,
'cert_file': watcher_clients_auth_config.certfile,
'insecure': watcher_clients_auth_config.insecure,
'key_file': watcher_clients_auth_config.keyfile,
'keystone_timeout': watcher_clients_auth_config.timeout,
'os_cacert': watcher_clients_auth_config.cafile,
'service_type': service_type,
'token': token,
'username': watcher_clients_auth_config.username,
'password': watcher_clients_auth_config.password,
}
endpoint = self.session.get_endpoint(service_type=service_type,
interface=monascaclient_interface)
self._monasca = monclient.Client(monascaclient_version, endpoint,
**monasca_kwargs)
return self._monasca
def __init__(self, module):
self.module = module
self.auth_kwargs = self._get_auth_credentials()
self.monasca = client.Client(
self.module.params['api_version'],
**self.auth_kwargs
)
def test_client_no_verify_params_for_session(self, mock_session):
(
version,
token,
project_id,
user_domain_id,
project_domain_id,
verify,
auth_url,
endpoint
) = _mock_client_args(False)
the_client = mon_client.Client(
api_version=version,
token=token,
project_id=project_id,
user_domain_id=user_domain_id,
project_domain_id=project_domain_id,
verify=verify,
auth_url=auth_url,
endpoint=endpoint
)
self.assertIsNotNone(the_client)
mock_session.assert_called_with(_expected_session_args(False))
def run(self, data_file):
try:
with open(data_file) as f:
yaml_text = f.read()
except IOError:
raise Exception(
'Unable to open yaml alarm definitions: {}'.format(data_file))
yaml_data = yaml.safe_load(yaml_text)
self._keystone_auth()
self._monasca = client.Client(self._args['api_version'],
self._api_url,
token=self._token)
self._print_message('Using Monasca at {}'.format(self._api_url))
if 'notifications' not in yaml_data:
raise Exception('No notifications section in {}'.format(data_file))
(processed, changed,
notification_ids) = self._do_notifications(yaml_data['notifications'])
self._print_message(
'{:d} Notifications Processed {:d} Notifications Changed'.format(
processed, changed))
if 'alarm_definitions' not in yaml_data:
raise Exception(
'No alarm_definitions section in {}'.format(data_file))
(processed,
changed) = self.do_alarm_definitions(yaml_data['alarm_definitions'],
notification_ids)
self._print_message(
'{:d} Alarm Definitions Processed {:d} Alarm Definitions Changed'.
format(processed, changed))
def __init__(self, name='', args=None):
super(MonascaDriver, self).__init__(name, args=args)
datasource_driver.ExecutionDriver.__init__(self)
self.creds = args
if not self.creds.get('project_name'):
self.creds['project_name'] = self.creds['tenant_name']
if not self.creds.get('poll_time'):
# set default polling time to 1hr
self.creds['poll_time'] = 3600
# Monasca uses Keystone V3
self.creds['auth_url'] = self.creds['auth_url'].replace("v2.0", "v3")
self.keystone = ksclient.Client(**self.creds)
self.creds['token'] = self.keystone.auth_token
if not self.creds.get('endpoint'):
# if the endpoint not defined retrieved it from keystone catalog
self.creds['endpoint'] = self.keystone.service_catalog.url_for(
service_type='monitoring', endpoint_type='publicURL')
self.monasca = monasca_client.Client('2_0', **self.creds)
self.add_executable_client_methods(self.monasca, 'monascaclient.')
self.initialize_update_methods()
self._init_end_start_poll()
def mon_client(username, password, auth_url, endpoint):
kwargs = {'username': username, 'password': password, 'auth_url': auth_url}
_ksclient = ksclient.KSClient(**kwargs)
kwargs = {'token': _ksclient.token}
api_version = '2_0'
return client.Client(api_version, endpoint, **kwargs)
def test_should_not_warn_when_passing_no_args(self, _, __, ___):
api_version = mock.Mock()
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
client.Client(api_version)
self.assertEqual(0, len(w))
def __init__(self, cloud_name, api_version, monasca_url, verbose, debug):
self.connection = openstack.connect(cloud_name)
self.session = self.connection.session
self.monasca_client = monasca_client.Client(api_version=api_version,
endpoint=monasca_url,
session=self.session)
self._setup_logging(debug)
def get_monasca_client(args, keystone_args):
api_url = args.get('monasca_api_url')
if not api_url:
raise Exception('Error: monasca_api_url is required')
monasca = client.Client(args['api_version'], api_url, **keystone_args)
print('Using Monasca at {}'.format(api_url))
for i in range(MONASCA_RETRIES):
try:
# just make an api call that should always succeed
monasca.notifications.list(limit=1)
print('Monasca API is ready')
return monasca
# I don't feel like spending an hour digging through osc-lib's
# spaghetti to figure out what exceptions list() raises, so, yeah.
except Exception as ex:
print('Attempt {} of {} to {} failed: {}'.format(
i, MONASCA_RETRIES, api_url, ex.message))
if i < MONASCA_RETRIES - 1:
time.sleep(MONASCA_DELAY)
print('Could not connect to Monasca after {} retries, '
'giving up!'.format(MONASCA_RETRIES))
raise Exception('could not connect to monasca at {}', api_url)
def _create(self):
interface = self._get_client_option(CLIENT_NAME, 'endpoint_type')
endpoint = self.url_for(service_type=self.MONITORING,
endpoint_type=interface)
return client.Client(self.VERSION,
session=self.context.keystone_session,
endpoint=endpoint)
def query_metrics_per_second():
args = parse_args()
try:
ks_client = ksclient.KSClient(**keystone)
except Exception as ex:
print 'Failed to authenticate: {}'.format(ex)
return
mon_client = client.Client('2_0', args.monasca_api_url, token=ks_client.token)
metrics_data = mon_client.metrics.list(name="metrics.published")
metric_averages = {}
for metric in metrics_data:
measurements = mon_client.metrics.list_measurements(start_time=args.starttime, name="metrics.published", dimensions=metric['dimensions'])
values = []
for m in measurements[0]['measurements']:
values.append(m[1])
metric_averages[metric['dimensions']['hostname']] = (sum(values)/len(values))
with open(args.output_directory + 'metrics_per_second', "w") as output_file:
output_file.write("{}: {}\n".format("total", sum(metric_averages.values())))
for k, v in metric_averages.items():
output_file.write("{} : {}\n".format(k, v))
def __init__(self,
proc_num,
num_requests,
num_metrics,
api_url,
keystone_dict,
continuous=False,
interval=60,
queue=None,
metric_creator=MetricCreatorSimple,
token=None):
self.proc_num = proc_num
self.num_requests = num_requests
self.num_metrics = num_metrics
self.interval = interval
self.continuous = continuous
self.queue = queue
if not token:
try:
token = ksclient.KSClient(**keystone_dict).token
except Exception as ex:
print("Agent {}: Failed to get auth token from keystone\n{}".
format(self.proc_num, keystone_dict))
#print("Using token: " + token)
self.mon_client = client.Client('2_0', api_url, session=token)
self.metric_creator = metric_creator(proc_num)
def __init__(self, module):
self.module = module
self.api_url = self.module.params['monasca_api_url']
auth_args = self._get_keystone_auth_args()
auth_args["endpoint"] = self.api_url
self.monasca = client.Client(self.module.params['api_version'],
**auth_args)
self.exit_data = {'monasca_api_url': self.api_url}
def _get_mon_client(self):
k = keystone.Keystone(self._config)
endpoint = k.get_monasca_url()
session = k.get_session()
c = client.Client(api_version=self._api_version,
endpoint=endpoint,
session=session,
timeout=self.write_timeout,
**keystone.get_args(self._config))
return c
def __init__(self, module):
self.module = module
self._keystone_auth()
self.exit_data = {
'keystone_token': self.token,
'monasca_api_url': self.api_url
}
self.monasca = client.Client(self.module.params['api_version'],
self.api_url,
token=self.token)
def __init__(self, module):
self.module = module
if not HAS_MONASCACLIENT:
self.module.fail_json(
msg='Failed to import python-monascaclient or keystoneauth1')
self.api_version = self.module.params['api_version']
# Create a keystone session from a password
if self.module.params['keystone_token'] is None:
sess = self._keystone_session()
if self.module.params['monasca_api_url'] is None:
self.api_url = self._endpoint_discover(sess)
else:
self.api_url = self.module.params['monasca_api_url']
self.exit_data = {'monasca_api_url': self.api_url}
self.monasca = mon_client.Client(api_version=self.api_version,
endpoint=self.api_url,
session=sess)
else: # user has supplied a keystone token
self.token = self.module.params['keystone_token']
if self.module.params['monasca_api_url'] is None:
self.module.fail_json(
msg=
'monasca_api_url param is required when using keystone_token'
)
self.api_url = self.module.params['monasca_api_url']
self.exit_data = {'monasca_api_url': self.api_url}
self.monasca = mon_client.Client(
api_version=self.api_version,
endpoint=self.api_url,
token=self.token,
project_name=self.module.params['keystone_project'],
auth_url=self.module.params['keystone_url'],
project_domain_id=self.module.params['project_domain_id'])
def alarm_client():
kwargs = {
'username': "******",
'password': "******",
'project_name': "baz",
'auth_url': auth_url
}
_ksclient = ksclient.KSClient(**kwargs)
kwargs = {'token': _ksclient.token}
api_version = '2_0'
return client.Client(api_version, endpoint, **kwargs).alarms
def get_client(self):
"""get_client
get a new mon-client object
"""
token = self.keystone.refresh_token()
# Re-create the client. This is temporary until
# the client is updated to be able to reset the
# token.
kwargs = {
'token': token
}
return client.Client(self.api_version, self.url, **kwargs)
def create_client(self, version=None, service_type=None):
"""Return monasca client."""
from monascaclient import client as monasca
client = monasca.Client(
self.choose_version(version),
self._get_endpoint(service_type),
token=self.keystone.auth_ref.auth_token,
timeout=CONF.openstack_client_http_timeout,
insecure=self.credential.insecure,
**self._get_auth_info(project_name_key="tenant_name"))
return client
def authenticate(self):
# Authenticate to Keystone
try:
# connecting
self.ks = ksclient.KSClient(auth_url=KEYSTONE_URL, username=USERNAME, password=PASSWORD)
# construct the mon client
self.monasca_client = client.Client(api_version, MONASCA_URL, token=self.ks.token)
except:
print('Connection error !')
else:
print('Connected to monasca server !')
def create_client(api_version='2_0',
username=USERNAME,
password=PASSWORD,
auth_url=AUTH_URL,
project_name=PROJECT_NAME,
endpoint=MONITORING_URL):
return client.Client(api_version=api_version,
username=username,
password=password,
auth_url=auth_url,
project_name=project_name,
endpoint=endpoint)
def _create(self):
interface = self._get_client_option(CLIENT_NAME, 'endpoint_type')
endpoint = self.url_for(service_type=self.MONITORING,
endpoint_type=interface)
# Change this to use session once it's supported by monascaclient
return client.Client(
self.VERSION,
token=self.context.keystone_session.get_token(),
endpoint=endpoint,
cacert=self._get_client_option(CLIENT_NAME, 'ca_file'),
cert_file=self._get_client_option(CLIENT_NAME, 'cert_file'),
key_file=self._get_client_option(CLIENT_NAME, 'key_file'),
insecure=self._get_client_option(CLIENT_NAME, 'insecure'))
def _get_monasca_client(sess):
disc = discover.Discover(session=sess)
ks = disc.create_client(sess=sess)
ks.auth_ref = sess.auth.get_auth_ref(session=sess)
catalog = ks.auth_ref.service_catalog
endpoint = catalog.url_for(service_type='monitoring',
interface=CONF.monasca_client.endpoint_type,
region_name=CONF.monasca_client.region_name)
return client.Client(api_version='2_0',
endpoint=endpoint,
session=sess)
def get_monasca_client(conf, conf_opts):
ks_auth = ks_loading.load_auth_from_conf_options(conf, conf_opts)
session = ks_loading.load_session_from_conf_options(conf,
conf_opts,
auth=ks_auth)
keystone_client = ks_client.Client(session=session,
interface=conf[conf_opts].interface)
mon_endpoint = get_monasca_endpoint(conf[conf_opts], keystone_client)
if not mon_endpoint:
raise EndpointNotFound()
return mclient.Client(api_version=MONASCA_API_VERSION,
session=session,
endpoint=mon_endpoint)
def _get_mon_client(self):
try:
k = keystone.Keystone(self._config)
endpoint = k.get_monasca_url()
session = k.get_session()
c = client.Client(api_version=self._api_version,
endpoint=endpoint,
session=session,
timeout=self.write_timeout,
**keystone.get_args(self._config))
return c
except keystoneauth_exception.ClientException as ex:
log.error('Failed to initialize Monasca client. {}'.format(ex))
def __init__(self, transformers, **kwargs):
super(MonascaCollector, self).__init__(transformers, **kwargs)
self.auth = ks_loading.load_auth_from_conf_options(
CONF, COLLECTOR_MONASCA_OPTS)
self.session = ks_loading.load_session_from_conf_options(
CONF, COLLECTOR_MONASCA_OPTS, auth=self.auth)
self.ks_client = ks_client.Client(session=self.session)
self.mon_endpoint = self._get_monasca_endpoint()
if not self.mon_endpoint:
raise EndpointNotFound()
self._conn = mclient.Client(api_version=MONASCA_API_VERSION,
session=self.session,
endpoint=self.mon_endpoint)
def __init__(self):
self.log = logging.getLogger('L.MONASCA')
self.api_version = "2_0"
self.whoami = cc.conf['whoami']
ks_conf = cc.conf['keystone']['monasca']
self.ks = ksclient.KSClient(auth_url=ks_conf['auth_url'],
username=ks_conf['username'],
password=ks_conf['password'])
self.log.debug('Got keystone token')
self.monasca_client = client.Client(self.api_version,
self.ks.monasca_url,
token=self.ks.token)
self.log.debug('Got monasca client')
self.alarms = None
def test_should_warn_when_passing_args(self, _, __, ___):
api_version = mock.Mock()
endpoint = mock.Mock()
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
client.Client(api_version, endpoint)
self.assertEqual(1, len(w))
self.assertEqual(DeprecationWarning, w[0].category)
self.assertRegex(str(w[0].message),
'explicit configuration of the client using')
def test_should_reuse_the_session_if_initialized_with_one(
self, get_session, get_auth, _):
from keystoneauth1 import session as k_session
api_version = mock.Mock()
session = mock.Mock(spec=k_session.Session)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
client.Client(api_version, session=session)
self.assertEqual(0, len(w))
get_auth.assert_not_called()
get_session.assert_not_called()
def update_token(self):
if self.__config:
tokenfile = self.__config['projectpath']['path']+"/lock_token.tmp"
else:
tokenfile = "/tmp/lock_token.tmp"
lock = Lock(tokenfile)
if lock.lockfileExists():
try:
lock.openLockfile('r')
except IOError:
if self.__config and strtobool(self.__config["api"]["debugMode"]):
print("["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] CollectorMonasca.set_token_from_token_file: the token file could not be opened and read")
return
parameters = lock.read()
lock.closeLockfile()
#if file is not empty
if parameters and len(parameters) == 2:
timestamp = utils.from_monasca_ts_to_datetime_ms(parameters[0])
difference = int((datetime.datetime.now()-timestamp).total_seconds())
#if token was got less than 3600 sec(1 hour) ago
token_ttl = 3600
if self.__config:
token_ttl = int(self.__config['keystone']['token_ttl'])
if difference < token_ttl:
#check if token is equal to the one stored inside the locked file. If not, take the stored one
if parameters[1] != self.__token:
#if the stored token is different from the one I have
self.__token = parameters[1]
# Instantiate a monascaclient object to use for query
self.__monasca_client = client.Client(self.__api_version, self.__monasca_endpoint, token=self.__token)
if self.__config and strtobool(self.__config["api"]["debugMode"]):
print("["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] CollectorMonasca.set_token_from_token_file: the parent Collector is taking and storing the token from file")
else:
if self.__config and strtobool(self.__config["api"]["debugMode"]):
print("["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] CollectorMonasca.set_token_from_token_file: the parent Collector has already an updated token")
#we need to reauthenticate to keystone
else:
if self.__config and strtobool(self.__config["api"]["debugMode"]):
print("["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] CollectorMonasca.set_token_from_token_file: the parent Collector is going to reauthenticate because the token file was older than "+str(token_ttl)+" seconds")
self.__authenticate_monasca_client(1)
else:
if self.__config and strtobool(self.__config["api"]["debugMode"]):
print("["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] CollectorMonasca.set_token_from_token_file: the token file is empty")
else:
if self.__config and strtobool(self.__config["api"]["debugMode"]):
print("["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] CollectorMonasca.set_token_from_token_file: the token file doesn't exists")