def _get_ksclient(self):
"""Get a new keystone client object.
The client provides a monasca_url property whose value is pulled from
Keystone Service Catalog filtering by service_type, endpoint_type
and/or region_name.
"""
service_type = self.config.get('service_type', None)
endpoint_type = self.config.get('endpoint_type', None)
region_name = self.config.get('region_name', None)
kc_args = self.get_credential_args()
if service_type:
kc_args.update({'service_type': service_type})
if endpoint_type:
kc_args.update({'endpoint_type': endpoint_type})
if region_name:
kc_args.update({'region_name': region_name})
return ksclient.KSClient(**kc_args)
def query_measurement_average():
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=args.metric_name,
dimensions=utils.format_parameters(
args.dimensions))
metric_averages = {}
for metric in metrics_data:
if args.endtime is not None:
measurements = mon_client.metrics.list_measurements(
start_time=args.starttime,
name=args.metric_name,
dimensions=metric['dimensions'],
end_time=args.endtime)
else:
measurements = mon_client.metrics.list_measurements(
start_time=args.starttime,
name=args.metric_name,
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 + args.metric_name, "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 _get_ksclient(self):
"""Get an endpoint and auth token from Keystone.
"""
auth_url = self.config.get('keystone_url', None)
username = self.config.get('username', None)
password = self.config.get('password', None)
user_domain_id = self.config.get('user_domain_id', None)
user_domain_name = self.config.get('user_domain_name', None)
insecure = self.config.get('insecure', False)
cacert = self.config.get('ca_file', None)
project_id = self.config.get('project_id', None)
project_name = self.config.get('project_name', None)
project_domain_name = self.config.get('project_domain_name', None)
project_domain_id = self.config.get('project_domain_id', None)
kc_args = {'auth_url': auth_url,
'username': username,
'password': password}
if user_domain_id:
kc_args.update({'user_domain_id': user_domain_id})
elif user_domain_name:
kc_args.update({'user_domain_name': user_domain_name})
if insecure:
kc_args.update({'insecure': insecure})
else:
if cacert:
kc_args.update({'os_cacert': cacert})
if project_id:
kc_args.update({'project_id': project_id})
elif project_name:
kc_args.update({'project_name': project_name})
if project_domain_name:
kc_args.update({'domain_name': project_domain_name})
if project_domain_id:
kc_args.update({'domain_id': project_domain_id})
return ksclient.KSClient(**kc_args)
def _keystone_auth(self):
""" Authenticate to Keystone and set self.token and self.api_url
"""
if self.module.params['keystone_token'] is None:
ks = ksclient.KSClient(
auth_url=self.module.params['keystone_url'],
username=self.module.params['keystone_user'],
password=self.module.params['keystone_password'])
self.token = ks.token
if self.module.params['monasca_api_url'] is None:
self.api_url = ks.monasca_url
else:
self.api_url = self.module.params['monasca_api_url']
else:
if self.module.params['monasca_api_url'] is None:
self.module.fail_json(
msg=
'Error: When specifying keystone_token, monasca_api_url is required'
)
self.token = self.module.params['keystone_token']
self.api_url = self.module.params['monasca_api_url']
def re_authenticate(self):
ks_args = {
'username': self.username,
'password': self.password,
'user_domain_id': self.user_domain_id,
'user_domain_name': self.user_domain_name,
'token': '',
'auth_url': self.auth_url,
'service_type': self.service_type,
'endpoint_type': self.endpoint_type,
'os_cacert': self.ssl_connection_params['os_cacert'],
'project_id': self.project_id,
'project_name': self.project_name,
'domain_id': self.domain_id,
'domain_name': self.domain_name,
'insecure': self.ssl_connection_params['insecure'],
'region_name': self.region_name,
'keystone_timeout': self.keystone_timeout
}
try:
_ksclient = ksclient.KSClient(**ks_args)
self.auth_token = _ksclient.token
except Exception as e:
raise exc.KeystoneException(e)
def __authenticate_monasca_client(self, force = 0):
mutexfile = ""
lockfile = ""
if self.__config:
mutexfile = self.__config['projectpath']['path']+"/mutex.tmp"
lockfile = self.__config['projectpath']['path']+"/lock_token.tmp"
else:
mutexfile = "/tmp/mutex.tmp"
lockfile = "/tmp/lock_token.tmp"
mutex = Mutex(mutexfile)
lock = Lock(lockfile)
#It is used to check if a process can only read or also write inside tokenfile
onlyReadMode = True
#if we don't force the authentication (we force only first time)
if not force:
#if there is mutex, some process is already writing. But it could be dead
if not mutex.mutexExists() or mutex.isObsolete():
#if the mutex has been created
if mutex.createMutex():
onlyReadMode = False
if lock.lockfileExists():
try:
#print(str(os.getpid())+"]["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] Read token file")
lock.openLockfile('r')
except IOError:
mutex.removeMutex()
raise Exception("The token file could not be read and mutex was set")
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 300 sec(5 mins) ago
authenticate_retry_wait_secs = 300
if self.__config:
authenticate_retry_wait_secs = int(self.__config['keystone']['authenticate_retry_wait_secs'])
if difference < authenticate_retry_wait_secs:
#check if token is equal to the one stored inside the locked file. If not, take the stored one
if parameters[1] != self.__token:
#print(str(os.getpid())+"]["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] USE TOKEN IN FILE:"+parameters[1])
#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)
mutex.removeMutex()
#print(str(os.getpid())+"]["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] USE TOKEN IN FILE:return")
return
else:
mutex.removeMutex()
raise Exception("We need to wait "+authenticate_retry_wait_secs+" secs before reauthenticating to Keystone. The token in file is no more valid")
else:
if self.__config and strtobool(self.__config["api"]["debugMode"]):
print("["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] The lock 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")+"] The token file doesn't exists and mutex was set")
else:
if self.__config and strtobool(self.__config["api"]["debugMode"]):
print("["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] the fork tried to create mutex, but it was already set")
#the mutex was set so the process can only read
if mutex.mutexExists() and onlyReadMode:
#print(str(os.getpid())+"]["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] --------ONLY READ MODE-------")
#print(str(os.getpid())+"]["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] __authenticate_monasca_client::mutex.mutexExists")
if lock.lockfileExists():
#print(str(os.getpid())+"]["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] __authenticate_monasca_client::lock.lockfileExists")
try:
lock.openLockfile('r')
except IOError:
raise Exception("The token file could not be read and mutex was set by another process")
parameters = lock.read()
lock.closeLockfile()
#if file is not empty
if parameters and len(parameters) == 2:
#check if token is equal to the one stored inside the locked file. If not, take the stored one
if parameters[1] != self.__token:
#print(str(os.getpid())+"]["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] USE TOKEN IN FILE:"+parameters[1])
#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)
#return
return
else:
raise Exception(str(os.getpid())+"] Keystone token in token file is no more valid. Mutex is set by another process.")
else:
raise Exception(str(os.getpid())+"] The token file is empty and mutex was set")
else:
raise Exception(str(os.getpid())+"] The token file doesn't exists and mutex was set")
#This part is executed when we need to generate a new token
if force or not onlyReadMode:
try:
# Authenticate to Keystone
ks = ksclient.KSClient(auth_url=self.__keystone_endpoint, username=self.__username, password=self.__password)
#print(str(os.getpid())+"]["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] autenticated to ks")
self.__token = ks.token
# Instantiate a monascaclient object to use for query
self.__monasca_client = client.Client(self.__api_version, self.__monasca_endpoint, token=self.__token)
lock.openLockfile('w')
#Try to lock file. If already locked then exception
lock.acquire()
if self.__config and strtobool(self.__config["api"]["debugMode"]):
print(str(os.getpid())+"]["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] Collector is writing inside locked file")
lock.write(ks.token)
except OSError as e:
if self.__config and strtobool(self.__config["api"]["debugMode"]):
print(str(os.getpid())+"]["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] OSError File already locked by another fork")
lock.closeLockfile()
lock.release()
mutex.removeMutex()
raise e
except IOError as e:
if self.__config and strtobool(self.__config["api"]["debugMode"]):
print(str(os.getpid())+"]["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] IOError File already locked by another fork")
lock.closeLockfile()
lock.release()
mutex.removeMutex()
raise e
except Exception as e:
if self.__config and strtobool(self.__config["api"]["debugMode"]):
print(str(os.getpid())+"]["+datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.000Z")+"] Problem in Authenticating to Keystone")
print(traceback.format_exc())
lock.closeLockfile()
lock.release()
mutex.removeMutex()
raise e
finally:
lock.closeLockfile()
lock.release()
mutex.removeMutex()
def _refresh_client(self):
_ksclient = ksclient.KSClient(**self._kwargs)
self._kwargs['token'] = _ksclient.token
self._mon_client = client.Client(cfg.CONF.monasca.clientapi_version,
self._endpoint, **self._kwargs)
# A metric identity is composed by its name and dimensions (a dictionary
# that represents attributes, as the host of the metric owner and the
# application id). For this example, socket.getfqdn() gets the context hostname.
metric_info = {
'name': 'metric.name',
'dimensions': {
'hostname': socket.getfqdn()
}
}
# Monasca client needs authenticate via keystone. Creating a keystone
# client is possible to get a token that will be used after to create a
# Monasca client.
ks = ksclient.KSClient(auth_url='http://<keystone_url>:5000/v3',
username='******',
password='******',
project_name='monasca')
# Creating a monasca client using the keystone token
monasca_client = monclient.Client('2_0', ks.monasca_url, token=ks.token)
# For this approach, the format of the log must follow some pattern.
# The method get_metric_value extract the value from this log pattern.
# Flags are used to capture logs of interest and value into these logs
# For this use case "#" is a token to identify where exactly the value
# is located and makes possible to convert the string to float value.
def get_metric_value(log):
for i in range(len(log) - 1, 0, -1):
if log[i] == '#':
value = float(log[i + 1:len(log)])
__author__ = 'ryan'
import sys
from monascaclient import ksclient
keystone = {
'username': '******',
'password': '******',
'project_name': 'mini-mon',
'project_domain_name': 'default',
'user_domain_name': 'default',
'auth_url': 'http://192.168.10.6:35357/v3'
}
if len(sys.argv) >= 2:
keystone['auth_url'] = int(sys.argv[1])
if len(sys.argv) >= 3:
keystone['username'] = int(sys.argv[2])
if len(sys.argv) >= 4:
keystone['password'] = int(sys.argv[3])
if len(sys.argv) >= 5:
keystone['project'] = int(sys.argv[4])
ks_client = ksclient.KSClient(**keystone)
print("Token: {}".format(ks_client.token))
def alarm_performance_test():
if num_processes < num_definitions:
return False, "Number of agents ({0}) must be >= number of definitions ({1})".format(num_processes,
num_definitions)
try:
print('Authenticating with keystone on {}'.format(keystone['auth_url']))
ks_client = ksclient.KSClient(**keystone)
except Exception as ex:
return False, 'Failed to authenticate: {}'.format(ex)
mon_client = client.Client('2_0', urls[0], token=ks_client.token)
print('Removing old alarm definitions for {}'.format(alarm_def_name))
cleanup(mon_client, alarm_def_name)
alarm_def_id_list = []
print('Creating alarm definitions')
for i in xrange(num_definitions):
expression = alarm_def_expression.format(metric_name+str(i))
alarm_def_id = create_alarm_definition(mon_client, alarm_def_name+str(i), expression)
if not alarm_def_id:
return False, "Failed to create alarm definition"
alarm_def_id_list.append(alarm_def_id)
sent_q = multiprocessing.Queue()
process_list = []
for i in xrange(num_processes):
p = multiprocessing.Process(target=agent_sim_process(i, num_requests, num_metrics, urls[(i % len(urls))],
keystone, queue=sent_q,
metric_creator=MetricCreatorAlarmPerf).run)
process_list.append(p)
start_datetime = datetime.datetime.now()
start_datetime = start_datetime - datetime.timedelta(microseconds=start_datetime.microsecond)
print("Starting test at: " + start_datetime.isoformat())
start_time = time.time()
for p in process_list:
p.start()
try:
for p in process_list:
try:
p.join()
except Exception:
pass
except KeyboardInterrupt:
return False, "User interrupt"
final_time = time.time()
# There is some chance that not all metrics were sent (lost connection, bad status, etc.)
total_metrics_sent = aggregate_sent_metric_count(sent_q)
print('Sent {} metrics in {} seconds'.format(total_metrics_sent,final_time-start_time))
if total_metrics_sent <= 0:
return False, "Failed to send metrics"
print('Waiting for alarms to be created')
alarm_count = 0
last_count = 0
last_change = time.time()
while alarm_count < total_metrics_sent:
alarm_count = 0
for id in alarm_def_id_list:
num = len(mon_client.alarms.list(alarm_definition_id=id))
alarm_count += num
if alarm_count > last_count:
last_change = time.time()
last_count = alarm_count
if (last_change + max_wait_time) <= time.time():
metrics_found = 0
for i in xrange(num_definitions):
val = len(mon_client.metrics.list_measurements(start_time=start_datetime.isoformat(), name=metric_name+str(i),
merge_metrics=True)[0]['measurements'])
metrics_found += val
return False, "Max wait time exceeded, {0} / {1} alarms found".format(alarm_count, metrics_found)
time.sleep(1)
delta = last_change - start_time
tot_met = 0
for i in xrange(num_definitions):
metrics = mon_client.metrics.list_measurements(start_time=start_datetime.isoformat(), name=metric_name+str(i),
merge_metrics=True)
tot_met += len(metrics[0]['measurements'])
print("Metrics from api: {}".format(tot_met))
print("-----Test Results-----")
print("{} alarms in {} seconds".format(alarm_count, delta))
print("{} per second".format(alarm_count/delta))
if cleanup_after_test:
cleanup(mon_client, alarm_def_name)
return True, ""
]
start_time = "2015-09-29T12:00:00.000Z"
end_time = "2015-10-30T23:59:59.000Z"
ks_url = "http://10.241.67.7:35357/v3/"
ks_user = "******"
ks_pass = "******"
ks_project_name = "admin"
ks_project_domain = "default"
mon_url = "http://10.241.67.7:8070/v2.0/"
# get all metrics (in json) and collect into single list, write to file
ksclient = ksclient.KSClient(auth_url=ks_url,
username=ks_user,
password=ks_pass,
project_name=ks_project_name,
project_domain_name=ks_project_domain)
mon_client = client.Client("2_0", mon_url, token=ksclient.token)
rabbit_exchange = [
"rabbitmq.exchange.messages.published_count",
"rabbitmq.exchange.messages.published_rate",
"rabbitmq.exchange.messages.received_count",
"rabbitmq.exchange.messages.received_rate"
]
rabbit_nodes = [
"rabbitmq.node.fd_used", "rabbitmq.node.mem_used",
"rabbitmq.node.run_queue", "rabbitmq.node.sockets_used"
]
def main(self, argv):
# Parse args once to find version
parser = self.get_base_parser()
(options, args) = parser.parse_known_args(argv)
self._setup_logging(options.debug)
self._setup_verbose(options.verbose)
# build available subcommands based on version
api_version = options.monasca_api_version
subcommand_parser = self.get_subcommand_parser(api_version)
self.parser = subcommand_parser
# Handle top-level --help/-h before attempting to parse
# a command off the command line
if not args and options.help or not argv:
self.do_help(options)
return 0
# Parse args again and call whatever callback was selected
args = subcommand_parser.parse_args(argv)
# Short-circuit and deal with help command right away.
if args.func == self.do_help:
self.do_help(args)
return 0
elif args.func == self.do_bash_completion:
self.do_bash_completion(args)
return 0
if not args.os_username and not args.os_auth_token:
raise exc.CommandError("You must provide a username via"
" either --os-username or env[OS_USERNAME]"
" or a token via --os-auth-token or"
" env[OS_AUTH_TOKEN]")
if not args.os_password and not args.os_auth_token:
raise exc.CommandError("You must provide a password via"
" either --os-password or env[OS_PASSWORD]"
" or a token via --os-auth-token or"
" env[OS_AUTH_TOKEN]")
if args.os_no_client_auth:
if not args.monasca_api_url:
raise exc.CommandError("If you specify --os-no-client-auth"
" you must specify a Monasca API URL"
" via either --monasca-api-url or"
" env[MONASCA_API_URL]")
else:
if not args.os_auth_url:
raise exc.CommandError("You must provide an auth url via"
" either --os-auth-url or via"
" env[OS_AUTH_URL]")
if args.os_auth_url and 'v2.0' in args.os_auth_url:
args.os_auth_url = string.replace(args.os_auth_url, 'v2.0', 'v3')
kwargs = {
'username': args.os_username,
'password': args.os_password,
'token': args.os_auth_token,
'auth_url': args.os_auth_url,
'service_type': args.os_service_type,
'endpoint_type': args.os_endpoint_type,
'os_cacert': args.os_cacert,
'user_domain_id': args.os_user_domain_id,
'user_domain_name': args.os_user_domain_name,
'project_id': args.os_project_id,
'project_name': args.os_project_name,
'domain_id': args.os_domain_id,
'domain_name': args.os_domain_name,
'insecure': args.insecure,
'region_name': args.os_region_name,
'keystone_timeout': args.keystone_timeout
}
endpoint = args.monasca_api_url
if not args.os_no_client_auth:
_ksclient = ksclient.KSClient(**kwargs)
if args.os_auth_token:
token = args.os_auth_token
else:
try:
token = _ksclient.token
except exc.CommandError:
raise exc.CommandError(
"User does not have a default project. "
"You must provide a project id using "
"--os-project-id or via env[OS_PROJECT_ID], "
"or you must provide a project name using "
"--os-project-name or via env[OS_PROJECT_NAME] "
"and a project domain using --os-domain-name, via "
"env[OS_DOMAIN_NAME], using --os-domain-id or "
"via env[OS_DOMAIN_ID]")
kwargs = {
'token': token,
'insecure': args.insecure,
'os_cacert': args.os_cacert,
'cert_file': args.cert_file,
'key_file': args.key_file,
'username': args.os_username,
'password': args.os_password,
'service_type': args.os_service_type,
'endpoint_type': args.os_endpoint_type,
'auth_url': args.os_auth_url,
'keystone_timeout': args.keystone_timeout
}
if args.os_user_domain_name:
kwargs['user_domain_name'] = args.os_user_domain_name
if args.os_user_domain_id:
kwargs['user_domain_id'] = args.os_user_domain_id
if args.os_region_name:
kwargs['region_name'] = args.os_region_name
if args.os_project_name:
kwargs['project_name'] = args.os_project_name
if args.os_project_id:
kwargs['project_id'] = args.os_project_id
if args.os_domain_name:
kwargs['domain_name'] = args.os_domain_name
if args.os_domain_id:
kwargs['domain_id'] = args.os_domain_id
if not endpoint:
endpoint = _ksclient.monasca_url
client = monasca_client.Client(api_version, endpoint, **kwargs)
args.func(client, args)
def metric_performance_test():
try:
print('Authenticating with keystone on {}'.format(keystone['auth_url']))
ks_client = ksclient.KSClient(**keystone)
except Exception as ex:
return False, 'Failed to authenticate: {}'.format(ex)
mon_client = client.Client('2_0', urls[0], token=ks_client.token)
sent_q = multiprocessing.Queue()
process_list = []
for i in xrange(num_processes):
p = multiprocessing.Process(target=agent_sim_process(i, num_requests, num_metrics, urls[(i % len(urls))],
keystone, queue=sent_q,
metric_creator=MetricCreatorMetricPerf).run)
process_list.append(p)
start_datetime = datetime.datetime.now()
start_datetime = start_datetime - datetime.timedelta(microseconds=start_datetime.microsecond)
print("Starting test at: " + start_datetime.isoformat())
start_time = time.time()
for p in process_list:
p.start()
try:
for p in process_list:
try:
p.join()
except Exception:
pass
except KeyboardInterrupt:
return False, "User interrupt"
total_metrics_sent = aggregate_sent_metric_count(sent_q)
metrics_found = 0
last_count = 0
last_change = time.time()
while metrics_found < total_metrics_sent:
metrics_found = 0
try:
stats = mon_client.metrics.list_statistics(statistics="count",
start_time=start_datetime.isoformat(),
name="metric_perf",
merge_metrics=True)
metrics_found = stats[0]['statistics'][0][1]
except Exception as ex:
print("Failed to retrieve metrics from api\n{}".format(ex))
if metrics_found > last_count:
last_change = time.time()
last_count = metrics_found
if (last_change + max_wait_time) <= time.time():
return False, "Max wait time exceeded, {0} / {1} metrics found".format(metrics_found, total_metrics_sent)
time.sleep(1)
final_time = time.time()
print("-----Test Results-----")
print("{} metrics in {} seconds".format(metrics_found, final_time-start_time))
print("{} per second".format(metrics_found / (final_time - start_time)))
return True, ""
def notification_perf_test():
global last_response
global response_count
global stop_server
try:
print('Authenticating with keystone on {}'.format(keystone['auth_url']))
ks_client = ksclient.KSClient(**keystone)
except Exception as ex:
print('Failed to authenticate: {}'.format(ex))
return False
token = ks_client.token
mon_client = client.Client('2_0', urls[0], token=token)
print("Creating notification method")
notification_id = create_notification_method(mon_client)
if not notification_id:
return False
alarm_definition['ok_actions'].append(notification_id)
alarm_definition['alarm_actions'].append(notification_id)
alarm_definition['undetermined_actions'].append(notification_id)
print("Creating alarm definition")
alarm_def_id = create_alarm_definition(mon_client)
if not alarm_def_id:
return False
base_message['alarm-transitioned']['alarmDefinitionId'] = alarm_def_id
process_list = []
server = threading.Thread(target=check_notifications, args=(BaseHTTPServer.HTTPServer, TestHTTPRequestHandler))
server.start()
start_time = time.time()
print("Sending {} state transitions".format(num_processes*num_messages))
for i in xrange(num_processes):
p = multiprocessing.Process(target=produce_alarm_state_transitions, args=(i,))
process_list.append(p)
p.start()
try:
for p in process_list:
try:
p.join()
except Exception:
pass
except KeyboardInterrupt:
return 0
last_response = time.time()
print("Waiting for notifications".format(num_processes * num_messages))
while server.isAlive():
if(last_response + max_wait_time) < time.time():
stop_server = True
print("Max wait time exceeded after {} responses".format(response_count))
return False
server.join((last_response+max_wait_time)-time.time())
final_time = time.time()
print("-----Test Results-----")
print("{} notifications arrived in {} seconds".format(response_count, final_time-start_time))
print("{} per second".format(response_count/(final_time-start_time)))
return True
def notification_function_test():
global last_response
global response_count
global stop_server
try:
print('Authenticating with keystone on {}'.format(
keystone['auth_url']))
ks_client = ksclient.KSClient(**keystone)
except Exception as ex:
print('Failed to authenticate: {}'.format(ex))
return False
token = ks_client.token
mon_client = client.Client('2_0', urls[0], token=token)
print("Creating notification method")
notification_id = create_notification_method(mon_client)
if not notification_id:
return False
alarm_definition['ok_actions'].append(notification_id)
alarm_definition['alarm_actions'].append(notification_id)
alarm_definition['undetermined_actions'].append(notification_id)
print("Creating alarm definition")
alarm_def_id = create_alarm_definition(mon_client)
if not alarm_def_id:
return False
base_message['alarm-transitioned']['alarmDefinitionId'] = alarm_def_id
server = threading.Thread(target=check_notifications,
args=(BaseHTTPServer.HTTPServer,
TestHTTPRequestHandler))
server.start()
time.sleep(1)
start_time = time.time()
produce_alarm_state_transition()
last_response = time.time()
print("Waiting for notifications")
while server.isAlive():
if (last_response + max_wait_time) < time.time():
stop_server = True
print("Max wait time exceeded after {} responses".format(
response_count))
return False
server.join((last_response + max_wait_time) - time.time())
final_time = time.time()
print("-----Test Results-----")
print("{} notifications arrived in {} seconds".format(
response_count, final_time - start_time))
return True
def _get_ksclient(self):
"""Get an endpoint and auth token from Keystone.
"""
kc_args = self.get_credential_args()
return ksclient.KSClient(**kc_args)
def get_metric_id(alarm):
'''Get metric ID for alarm
:param alarm: Alarm
:return: ID of metric used in alarm
'''
metrics = alarm['metrics']
metric = metrics[0]
dimensions = metric['dimensions']
id = int(dimensions['id'])
return id
keystone_client = monascaclient_ksclient.KSClient(auth_url=AUTH_URL,
username=USERNAME,
project_name=PROJECT_NAME,
domain_name=DOMAIN_NAME,
password=PASSWORD)
monasca_client = monascaclient_client.Client('2_0',
keystone_client.monasca_url,
token=keystone_client.token)
# Create alarm definition and wait 10 secsond for alarms to be created
logger.info(
'create alarm definition and wait 10 seconds for alarms to be created')
alarm_defn = create_alarm_definition()
send_alarm_definition(monasca_client, alarm_defn)
metrics = [create_metric(str(id), 0.0) for id in xrange(NUM_METRICS_PER_TRIAL)]
send_metrics(monasca_client, metrics)
time.sleep(10)
logger.info('done')
