def test_list_statistics_with_end_time(self): start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) end_time = timeutils.iso8601_from_timestamp(self._end_timestamp / 1000) query_parms = "?name=name-1&merge_metrics=true&statistics=avg&" "start_time=" + str( start_time ) + "&end_time=" + str(end_time) resp, response_body = self.monasca_client.list_statistics(query_parms) self.assertEqual(200, resp.status)
def test_list_measurements_with_endtime(self): start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) end_time = timeutils.iso8601_from_timestamp(self._end_timestamp / 1000) query_parms = '?name=name-1&merge_metrics=true&true&start_time=' + str( start_time) + '&end_time' + str(end_time) resp, body = self.monasca_client.list_measurements(query_parms) self.assertEqual(200, resp.status) len_measurements = len(body['elements'][0]['measurements']) self.assertEqual(len_measurements, NUM_MEASUREMENTS)
def test_list_statistics_with_end_time(self): start_time = timeutils.iso8601_from_timestamp( self._start_timestamp / 1000) end_time = timeutils.iso8601_from_timestamp( self._end_timestamp / 1000) query_parms = '?name=name-1&merge_metrics=true&statistics=avg&' \ 'start_time=' + str(start_time) + '&end_time=' + \ str(end_time) resp, response_body = self.monasca_client.list_statistics( query_parms) self.assertEqual(200, resp.status)
def test_create_trust_admin(self): """check externals calls and result of create_trust_admin""" resp = MagicMock() body_response = {'trust': {'id': 'generatedtrustid'}} trustor = MagicMock(id='trustor_id', name='trustor_name', cloud_project_id='trustor_tenant') trustee = MagicMock(id='trustee_id', name='trustee_name') config = { 'trusts.client.post.return_value': (resp, body_response), 'users.get.return_value': trustor, 'users.find.return_value': trustee } self.trustfactory.keystone.configure_mock(**config) now = time.time() with patch('fiwareskuld.impersonate.time.time') as time_mock: time_mock.configure_mock(return_value=now) result = self.trustfactory.create_trust_admin( 'trustor_id', 'trustee_name') # check result self.assertCreateResult(result, trustor) # check call body = {'trust': {'impersonation': True, 'trustor_user_id': trustor.id, 'allow_redelegation': True, 'roles': [{'name': 'owner'}], 'expires_at': timeutils.iso8601_from_timestamp( now + self.trustfactory.trustid_validity, True), 'trustee_user_id': trustee.id, 'project_id': trustor.cloud_project_id}} self.trustfactory.keystone.trusts.client.post.assert_called_once_with( 'OS-TRUST/trusts_for_admin', body=body)
def resource_setup(cls): super(TestMetricsNames, cls).resource_setup() name = data_utils.rand_name() key = data_utils.rand_name() value = data_utils.rand_name() cls._param = key + ':' + value metric = helpers.create_metric(name=name, dimensions={key: value}) cls._test_metric = metric cls.monasca_client.create_metrics(metric) start_time = str(timeutils.iso8601_from_timestamp( metric['timestamp'] / 1000.0)) query_params = '?name=' + str(cls._test_metric['name']) +\ '&start_time=' + start_time for i in xrange(constants.MAX_RETRIES): resp, response_body = cls.monasca_client.list_metrics( query_params) elements = response_body['elements'] for element in elements: if str(element['name']) == cls._test_metric['name']: return time.sleep(constants.RETRY_WAIT_SECS) cls.fail('Unable to initialize metrics')
def swift_get_container(request, container_name, with_data=True): if with_data: headers, data = swift_api(request).get_object(container_name, "") else: data = None headers = swift_api(request).head_container(container_name) timestamp = None is_public = False public_url = None try: is_public = GLOBAL_READ_ACL in headers.get('x-container-read', '') if is_public: swift_endpoint = base.url_for(request, 'object-store', endpoint_type='publicURL') parameters = urlparse.quote(container_name.encode('utf8')) public_url = swift_endpoint + '/' + parameters ts_float = float(headers.get('x-timestamp')) timestamp = timeutils.iso8601_from_timestamp(ts_float) except Exception: pass container_info = { 'name': container_name, 'container_object_count': headers.get('x-container-object-count'), 'container_bytes_used': headers.get('x-container-bytes-used'), 'timestamp': timestamp, 'data': data, 'is_public': is_public, 'public_url': public_url, } return Container(container_info)
def swift_get_object(request, container_name, object_name, with_data=True, resp_chunk_size=CHUNK_SIZE): if with_data: headers, data = swift_api(request).get_object( container_name, object_name, resp_chunk_size=resp_chunk_size) else: data = None headers = swift_api(request).head_object(container_name, object_name) orig_name = headers.get("x-object-meta-orig-filename") timestamp = None try: ts_float = float(headers.get('x-timestamp')) timestamp = timeutils.iso8601_from_timestamp(ts_float) except Exception: pass obj_info = { 'name': object_name, 'bytes': headers.get('content-length'), 'content_type': headers.get('content-type'), 'etag': headers.get('etag'), 'timestamp': timestamp, } return StorageObject(obj_info, container_name, orig_name=orig_name, data=data)
def test_list_measurements_with_no_merge_metrics(self): start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) query_parms = '?name=name-1&merge_metrics=false&start_time=' + str( start_time) self.assertRaises(exceptions.Conflict, self.monasca_client.list_measurements, query_parms)
def create_trust_admin(self, trustor_id, trustee_name): """ Create a TRUST_ID. This method must be invoked by the administrator and only works if the keystone server has been adapted to allow the administrator to create a TRUST_ID for other users. :param trustor_id: the user id of the trustor user (who is impersonated by the trustee) :param trustee_name: the user name of the trustee user (who impersonates the trustor) :return: the tuple (trustor_username, trust_id, trustor_id), None if error """ trustor = self.keystone.users.get(trustor_id) trustee = self.keystone.users.find(name=trustee_name) data = dict() data['impersonation'] = True data['allow_redelegation'] = True data['project_id'] = trustor.cloud_project_id data['roles'] = [{'name': 'owner'}] data['trustee_user_id'] = trustee.id data['trustor_user_id'] = trustor.id data['expires_at'] = timeutils.iso8601_from_timestamp( time.time() + self.trustid_validity, True) # data['remaining_uses'] = 1 request = {'trust': data} (resp, body_resp) = self.keystone.trusts.client.post( 'OS-TRUST/trusts_for_admin', body=request) if resp.ok: return trustor.name, body_resp['trust']['id'], trustor.id else: return None
def test_process_sample(self): s = sample.Sample( name='test', type=sample.TYPE_CUMULATIVE, unit='', volume=1, user_id='test', project_id='test', resource_id='test_run_tasks', timestamp=datetime.datetime.utcnow().isoformat(), resource_metadata={'name': 'TestPublish'}, ) to_patch = ("ceilometer.publisher.monasca_data_filter." "MonascaDataFilter._get_mapping") with mock.patch(to_patch, side_effect=[self._field_mappings]): data_filter = mdf.MonascaDataFilter() r = data_filter.process_sample_for_monasca(s) self.assertEqual(s.name, r['name']) self.assertIsNotNone(r.get('dimensions')) self.assertIsNotNone(r.get('value_meta')) self.assertIsNotNone(r.get('value')) self.assertEqual(s.user_id, r['dimensions'].get('user_id')) self.assertEqual(s.project_id, r['dimensions'].get('project_id')) self.assertEqual(s.resource_id, r['dimensions'].get('resource_id')) # 2015-04-07T20:07:06.156986 compare upto millisec monasca_ts = \ timeutils.iso8601_from_timestamp(r['timestamp'] / 1000.0, microsecond=True)[:23] self.assertEqual(s.timestamp[:23], monasca_ts)
def test_list_statistics(self): start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) query_parms = '?name=name-1&merge_metrics=true&statistics=avg' \ '&start_time=' + str(start_time) resp, response_body = self.monasca_client.list_statistics( query_parms) self.assertEqual(200, resp.status) self.assertTrue(set(['links', 'elements']) == set(response_body)) elements = response_body['elements'] element = elements[0] self.assertTrue(set(['id', 'name', 'dimensions', 'columns', 'statistics']) == set(element)) # check if 'id' is unicode type self.assertTrue(type(element['id']) is unicode) # check if 'name' is a string. NOPE its unicode self.assertTrue(type(element['name']) is unicode) self.assertTrue(type(element['dimensions']) is dict) self.assertTrue(type(element['columns']) is list) self.assertTrue(type(element['statistics']) is list) statistic = element['statistics'] column = element['columns'] self.assertTrue(type(statistic) is list) self.assertTrue(type(column) is list)
def resource_setup(cls): super(TestMetricsNames, cls).resource_setup() name = data_utils.rand_name() key = data_utils.rand_name() value = data_utils.rand_name() cls._param = key + ':' + value metric = helpers.create_metric(name=name, dimensions={key: value}) cls._test_metric = metric cls.monasca_client.create_metrics(metric) start_time = str(timeutils.iso8601_from_timestamp( metric['timestamp'] / 1000.0)) query_params = '?name=' + str(cls._test_metric['name']) +\ '&start_time=' + start_time for i in xrange(constants.MAX_RETRIES): resp, response_body = cls.monasca_client.list_metrics( query_params) elements = response_body['elements'] for element in elements: if str(element['name']) == cls._test_metric['name']: return time.sleep(constants.RETRY_WAIT_SECS) assert False, 'Unable to initialize metrics'
def test_list_statistics_with_no_name(self): start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) query_parms = '?merge_metrics=true&statistics=avg&start_time=' + \ str(start_time) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.list_statistics, query_parms)
def test_list_statistics_with_invalid_statistics(self): start_time = timeutils.iso8601_from_timestamp( self._start_timestamp / 1000) query_parms = '?name=name-1&statistics=abc&start_time=' + str( start_time) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.list_statistics, query_parms)
def test_list_measurements_with_merge_metrics(self): start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) query_parms = '?name=name-1&merge_metrics=true&start_time=' + str( start_time) resp, response_body = self.monasca_client.list_measurements( query_parms) self.assertEqual(200, resp.status)
def test_list_measurements_with_name_exceeds_max_length(self): long_name = "x" * (constants.MAX_LIST_MEASUREMENTS_NAME_LENGTH + 1) start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) query_parms = '?name=' + str(long_name) \ + '&merge_metrics=true&start_time=' + str(start_time) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.list_measurements, query_parms)
def test_list_statistics_with_dimensions(self): start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) query_parms = '?name=name-1&merge_metrics=true&statistics=avg&' \ 'start_time=' + str(start_time) + \ '&dimensions=key1:value1' resp, response_body = self.monasca_client.list_statistics( query_parms) self.assertEqual(200, resp.status)
def test_list_statistics_response_body_statistic_result_type(self): start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) query_parms = "?name=name-1&merge_metrics=true&statistics=avg&" "start_time=" + str(start_time) resp, response_body = self.monasca_client.list_statistics(query_parms) self.assertEqual(200, resp.status) element = response_body["elements"][0] statistic = element["statistics"] statistic_result_type = type(statistic[0][1]) self.assertEqual(statistic_result_type, float)
def stat_message(message, now): """Creates a stat document from the given message, relative to now.""" msg_id = message['id'] created = oid_ts(to_oid(msg_id)) age = now - created return { 'id': msg_id, 'age': int(age), 'created': timeutils.iso8601_from_timestamp(created), }
def test_list_statistics_response_body_statistic_result_type(self): start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) query_parms = '?name=name-1&merge_metrics=true&statistics=avg&' \ 'start_time=' + str(start_time) resp, response_body = self.monasca_client.list_statistics( query_parms) self.assertEqual(200, resp.status) element = response_body['elements'][0] statistic = element['statistics'] statistic_result_type = type(statistic[0][1]) self.assertEqual(statistic_result_type, float)
def list_cached(options, args): """%(prog)s list-cached [options] List all images currently cached. """ client = get_client(options) images = client.get_cached_images() if not images: print("No cached images.") return SUCCESS print("Found %d cached images..." % len(images)) pretty_table = utils.PrettyTable() pretty_table.add_column(36, label="ID") pretty_table.add_column(19, label="Last Accessed (UTC)") pretty_table.add_column(19, label="Last Modified (UTC)") # 1 TB takes 13 characters to display: len(str(2**40)) == 13 pretty_table.add_column(14, label="Size", just="r") pretty_table.add_column(10, label="Hits", just="r") print(pretty_table.make_header()) for image in images: last_modified = image['last_modified'] last_modified = timeutils.iso8601_from_timestamp(last_modified) last_accessed = image['last_accessed'] if last_accessed == 0: last_accessed = "N/A" else: last_accessed = timeutils.iso8601_from_timestamp(last_accessed) print(pretty_table.make_row( image['image_id'], last_accessed, last_modified, image['size'], image['hits']))
def to_basic(self, now, include_created=False): basic_msg = { 'id': self.id, 'age': now - self.created, 'ttl': self.ttl, 'body': self.body, 'claim_id': self.claim_id, } if include_created: created_iso = timeutils.iso8601_from_timestamp(self.created) basic_msg['created'] = created_iso return basic_msg
def test_create_trust_admin(self): """check externals calls and result of create_trust_admin""" resp = MagicMock() body_response = {'trust': {'id': 'generatedtrustid'}} trustor = MagicMock(id='trustor_id', name='trustor_name', cloud_project_id='trustor_tenant') trustee = MagicMock(id='trustee_id', name='trustee_name') config = { 'trusts.client.post.return_value': (resp, body_response), 'users.get.return_value': trustor, 'users.find.return_value': trustee } self.trustfactory.keystone.configure_mock(**config) now = time.time() with patch('fiwareskuld.impersonate.time.time') as time_mock: time_mock.configure_mock(return_value=now) result = self.trustfactory.create_trust_admin( 'trustor_id', 'trustee_name') # check result self.assertCreateResult(result, trustor) # check call body = { 'trust': { 'impersonation': True, 'trustor_user_id': trustor.id, 'allow_redelegation': True, 'roles': [{ 'name': 'owner' }], 'expires_at': timeutils.iso8601_from_timestamp( now + self.trustfactory.trustid_validity, True), 'trustee_user_id': trustee.id, 'project_id': trustor.cloud_project_id } } self.trustfactory.keystone.trusts.client.post.assert_called_once_with( 'OS-TRUST/trusts_for_admin', body=body)
def test_list_alarms_state_history_with_start_time(self): current_time = int(time.time()) current_time = timeutils.iso8601_from_timestamp(current_time) query_parms = '?start_time=' + str(current_time) resp, response_body = self.monasca_client.list_alarms_state_history( query_parms) elements = response_body['elements'] self.assertEqual(0, len(elements)) resp, response_body = self.monasca_client.list_alarms_state_history() elements = response_body['elements'] timestamp = elements[1]['timestamp'] query_parms = '?start_time=' + str(timestamp) resp, response_body = self.monasca_client.list_alarms_state_history( query_parms) elements = response_body['elements'] self.assertEqual(2, len(elements))
def stats(self, name, project=None): if not self._queue_ctrl.exists(name, project=project): raise errors.QueueDoesNotExist(name, project) total = 0 claimed = 0 container = utils._message_container(name, project) try: _, objects = self._client.get_container(container) except swiftclient.ClientException as exc: if exc.http_status == 404: raise errors.QueueIsEmpty(name, project) newest = None oldest = None now = timeutils.utcnow_ts(True) for obj in objects: try: headers = self._client.head_object(container, obj['name']) except swiftclient.ClientException as exc: if exc.http_status != 404: raise else: created = float(headers['x-timestamp']) newest = { 'id': obj['name'], 'age': now - created, 'created': timeutils.iso8601_from_timestamp(created) } if oldest is None: oldest = copy.deepcopy(newest) total += 1 if headers.get('x-object-meta-claimid'): claimed += 1 msg_stats = { 'claimed': claimed, 'free': total - claimed, 'total': total, } if newest is not None: msg_stats['newest'] = newest msg_stats['oldest'] = oldest return {'messages': msg_stats}
def swift_get_container(request, container_name, with_data=True): if with_data: headers, data = swift_api(request).get_object(container_name, "") else: data = None headers = swift_api(request).head_container(container_name) timestamp = None is_public = False public_url = None try: is_public = GLOBAL_READ_ACL in headers.get('x-container-read', '') if is_public: swift_endpoint = base.url_for(request, 'object-store', endpoint_type='publicURL') parameters = urlparse.quote(container_name.encode('utf8')) public_url = swift_endpoint + '/' + parameters ts_float = float(headers.get('x-timestamp')) timestamp = timeutils.iso8601_from_timestamp(ts_float) metadata = '' for header in headers: if header.startswith('x-container-meta-'): key_name = header.replace('x-container-meta-', '').replace('-', ' ').title() value = headers[header] metadata += key_name + '=' + value + ', ' metadata = metadata[0:-2] except Exception: pass container_info = { 'name': container_name, 'container_object_count': headers.get('x-container-object-count'), 'container_bytes_used': headers.get('x-container-bytes-used'), 'timestamp': timestamp, 'data': data, 'is_public': is_public, 'public_url': public_url, 'storage_policy': headers.get('x-storage-policy'), 'metadata': metadata, } return Container(container_info)
def test_list_measurements(self): start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) query_parms = '?name=name-1&merge_metrics=true&start_time=' + str( start_time) resp, response_body = self.monasca_client.list_measurements( query_parms) self.assertEqual(200, resp.status) self.assertTrue(set(['links', 'elements']) == set(response_body)) elements = response_body['elements'] element = elements[0] self.assertTrue( set(['id', 'name', 'dimensions', 'columns', 'measurements']) == set(element)) self.assertTrue(type(element['name']) is unicode) self.assertTrue(type(element['dimensions']) is dict) self.assertTrue(type(element['columns']) is list) self.assertTrue(type(element['measurements']) is list)
def test_list_statistics(self): start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) query_parms = "?name=name-1&merge_metrics=true&statistics=avg" "&start_time=" + str(start_time) resp, response_body = self.monasca_client.list_statistics(query_parms) self.assertEqual(200, resp.status) self.assertTrue(set(["links", "elements"]) == set(response_body)) elements = response_body["elements"] element = elements[0] self.assertTrue(set(["id", "name", "dimensions", "columns", "statistics"]) == set(element)) # check if 'id' is unicode type self.assertTrue(type(element["id"]) is unicode) # check if 'name' is a string. NOPE its unicode self.assertTrue(type(element["name"]) is unicode) self.assertTrue(type(element["dimensions"]) is dict) self.assertTrue(type(element["columns"]) is list) self.assertTrue(type(element["statistics"]) is list) statistic = element["statistics"] column = element["columns"] self.assertTrue(type(statistic) is list) self.assertTrue(type(column) is list)
def test_list_measurements_with_dimensions(self): key1 = data_utils.rand_name('key1') value1 = data_utils.rand_name('value1') start_timestamp = int(time.time() * 1000) name = data_utils.rand_name() metric = [ helpers.create_metric(name=name, timestamp=start_timestamp, dimensions={key1: value1}, value=123) ] resp, response_body = self.monasca_client.create_metrics(metric) time.sleep(WAIT_TIME) start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) query_parms = '?name=' + name + '&start_time=' + str( start_time) + '&dimensions=' + key1 + ':' + value1 resp, response_body = self.monasca_client.list_measurements( query_parms) value_new = response_body['elements'][0]['measurements'][0][1] self.assertEqual(200, resp.status) self.assertEqual(123, value_new)
def test_list_measurements_with_no_name(self): start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) query_parms = '?start_time=' + str(start_time) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.list_measurements, query_parms)
def test_list_statistics_with_no_merge_metrics(self): start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) query_parms = "?name=name-1&merge_metrics=false&" "statistics=avg,min,max&start_time=" + str(start_time) self.assertRaises(exceptions.Conflict, self.monasca_client.list_statistics, query_parms)
def test_list_statistics_with_offset_limit(self): start_timestamp = int(time.time() * 1000) name = data_utils.rand_name() metric = [ helpers.create_metric(name=name, timestamp=start_timestamp + 0, dimensions={'key1': 'value-1', 'key2': 'value-1'}, value=1), helpers.create_metric(name=name, timestamp=start_timestamp + 500, dimensions={'key1': 'value-2', 'key2': 'value-2'}, value=2), helpers.create_metric(name=name, timestamp=start_timestamp + 1000, dimensions={'key1': 'value-3', 'key2': 'value-3'}, value=3), helpers.create_metric(name=name, timestamp=start_timestamp + 1500, dimensions={'key1': 'value-4', 'key2': 'value-4'}, value=4) ] self.monasca_client.create_metrics(metric) query_parms = '?name=' + name for i in xrange(constants.MAX_RETRIES): resp, response_body = self.monasca_client.list_metrics(query_parms) self.assertEqual(200, resp.status) elements = response_body['elements'] if elements: break else: time.sleep(constants.RETRY_WAIT_SECS) self._check_timeout(i, constants.MAX_RETRIES, elements, 4) start_time = helpers.timestamp_to_iso(start_timestamp) end_timestamp = start_timestamp + 4000 end_time = helpers.timestamp_to_iso(end_timestamp) query_parms = '?name=' + name + '&merge_metrics=true&statistics=avg' \ + '&start_time=' + str(start_time) + '&end_time=' + \ str(end_time) + '&period=1' resp, body = self.monasca_client.list_statistics(query_parms) self.assertEqual(200, resp.status) elements = body['elements'][0]['statistics'] first_element = elements[0] query_parms = '?name=' + name + '&merge_metrics=true&statistics=avg'\ + '&start_time=' + str(start_time) + '&end_time=' + \ str(end_time) + '&period=1' + '&limit=4' resp, response_body = self.monasca_client.list_statistics( query_parms) self.assertEqual(200, resp.status) elements = response_body['elements'][0]['statistics'] self.assertEqual(4, len(elements)) self.assertEqual(first_element, elements[0]) for index in xrange(1, 5): max_limit = 5 - index for limit in xrange(1, max_limit): offset_timestamp = start_timestamp + (1000 * index) offset = timeutils.iso8601_from_timestamp(offset_timestamp / 1000) last_index = index + limit expected_elements = elements[index:last_index] query_parms = '?name=' + name + '&merge_metrics=true' + \ '&statistics=avg' + '&start_time=' + \ str(start_time) + '&end_time=' + \ str(end_time) + '&period=1' + '&limit=' + \ str(limit) + '&offset=' + str(offset) resp, response_body = self.monasca_client.list_statistics(query_parms) self.assertEqual(200, resp.status) if not response_body['elements']: self.fail("No metrics returned") if not response_body['elements'][0]['statistics']: self.fail("No statistics returned") new_elements = response_body['elements'][0]['statistics'] self.assertEqual(limit, len(new_elements)) # bug in the python API causes limit 1 to not have matching timestamps if limit > 1: self.assertEqual(expected_elements, new_elements)
def test_list_statistics_with_offset_limit(self): start_timestamp = int(time.time() * 1000) name = data_utils.rand_name() metric = [ helpers.create_metric(name=name, timestamp=start_timestamp + 0, dimensions={ 'key1': 'value-1', 'key2': 'value-1' }, value=1), helpers.create_metric(name=name, timestamp=start_timestamp + 500, dimensions={ 'key1': 'value-2', 'key2': 'value-2' }, value=2), helpers.create_metric(name=name, timestamp=start_timestamp + 1000, dimensions={ 'key1': 'value-3', 'key2': 'value-3' }, value=3), helpers.create_metric(name=name, timestamp=start_timestamp + 1500, dimensions={ 'key1': 'value-4', 'key2': 'value-4' }, value=4) ] self.monasca_client.create_metrics(metric) query_parms = '?name=' + name for i in xrange(constants.MAX_RETRIES): resp, response_body = self.monasca_client.list_metrics(query_parms) self.assertEqual(200, resp.status) elements = response_body['elements'] if elements: break else: time.sleep(constants.RETRY_WAIT_SECS) self._check_timeout(i, constants.MAX_RETRIES, elements, 4) start_time = helpers.timestamp_to_iso(start_timestamp) end_timestamp = start_timestamp + 4000 end_time = helpers.timestamp_to_iso(end_timestamp) query_parms = '?name=' + name + '&merge_metrics=true&statistics=avg' \ + '&start_time=' + str(start_time) + '&end_time=' + \ str(end_time) + '&period=1' resp, body = self.monasca_client.list_statistics(query_parms) self.assertEqual(200, resp.status) elements = body['elements'][0]['statistics'] first_element = elements[0] query_parms = '?name=' + name + '&merge_metrics=true&statistics=avg'\ + '&start_time=' + str(start_time) + '&end_time=' + \ str(end_time) + '&period=1' + '&limit=4' resp, response_body = self.monasca_client.list_statistics(query_parms) self.assertEqual(200, resp.status) elements = response_body['elements'][0]['statistics'] self.assertEqual(4, len(elements)) self.assertEqual(first_element, elements[0]) for index in xrange(1, 5): max_limit = 5 - index for limit in xrange(1, max_limit): offset_timestamp = start_timestamp + (1000 * index) offset = timeutils.iso8601_from_timestamp(offset_timestamp / 1000) last_index = index + limit expected_elements = elements[index:last_index] query_parms = '?name=' + name + '&merge_metrics=true' + \ '&statistics=avg' + '&start_time=' + \ str(start_time) + '&end_time=' + \ str(end_time) + '&period=1' + '&limit=' + \ str(limit) + '&offset=' + str(offset) resp, response_body = self.monasca_client.list_statistics( query_parms) self.assertEqual(200, resp.status) if not response_body['elements']: self.fail("No metrics returned") if not response_body['elements'][0]['statistics']: self.fail("No statistics returned") new_elements = response_body['elements'][0]['statistics'] self.assertEqual(limit, len(new_elements)) # bug in the python API causes limit 1 to not have matching timestamps if limit > 1: self.assertEqual(expected_elements, new_elements)
def test_iso8601_from_timestamp_ms(self): ts = timeutils.utcnow_ts(microsecond=True) utcnow = datetime.datetime.utcfromtimestamp(ts) iso = timeutils.isotime(utcnow, subsecond=True) self.assertEqual(iso, timeutils.iso8601_from_timestamp(ts, True))
def test_iso8601_from_timestamp(self): utcnow = timeutils.utcnow() iso = timeutils.isotime(utcnow) ts = calendar.timegm(utcnow.timetuple()) self.assertEqual(iso, timeutils.iso8601_from_timestamp(ts))
def ts2iso(timestamp): """timestamp to is8601 format.""" if not isinstance(timestamp, float): timestamp = float(timestamp) return timeutils.iso8601_from_timestamp(timestamp)
def test_list_measurements_with_offset_limit(self): start_timestamp = int(time.time() * 1000) name = data_utils.rand_name() metric = [ helpers.create_metric(name=name, timestamp=start_timestamp + 0, dimensions={ 'key1': 'value-1', 'key2': 'value-1' }), helpers.create_metric(name=name, timestamp=start_timestamp + 1, dimensions={ 'key1': 'value-2', 'key2': 'value-2' }), helpers.create_metric(name=name, timestamp=start_timestamp + 2, dimensions={ 'key1': 'value-3', 'key2': 'value-3' }), helpers.create_metric(name=name, timestamp=start_timestamp + 3, dimensions={ 'key1': 'value-4', 'key2': 'value-4' }) ] resp, response_body = self.monasca_client.create_metrics(metric) time.sleep(WAIT_TIME) query_parms = '?name=' + name resp, response_body = self.monasca_client.list_metrics(query_parms) self.assertEqual(200, resp.status) start_time = timeutils.iso8601_from_timestamp(start_timestamp / 1000) query_parms = '?name=' + name + '&merge_metrics=true&start_time=' + \ str(start_time) resp, body = self.monasca_client.list_measurements(query_parms) self.assertEqual(200, resp.status) elements = body['elements'][0]['measurements'] first_element = elements[0] last_element = elements[3] query_parms = '?name=' + name + '&merge_metrics=true&start_time=' + \ str(start_time) + '&limit=4' resp, response_body = self.monasca_client.list_measurements( query_parms) self.assertEqual(200, resp.status) elements = response_body['elements'][0]['measurements'] self.assertEqual(4, len(elements)) self.assertEqual(first_element, elements[0]) for limit in xrange(1, 5): next_element = elements[limit - 1] while True: query_parms = '?name=' + name + \ '&merge_metrics=true&start_time=' + \ str(start_time) + '&offset=' + \ str(next_element[0]) + '&limit=' + \ str(limit) resp, response_body = self.monasca_client.list_measurements( query_parms) self.assertEqual(200, resp.status) new_elements = response_body['elements'][0]['measurements'] if len(new_elements) > limit - 1: self.assertEqual(limit, len(new_elements)) next_element = new_elements[limit - 1] elif len(new_elements) > 0 and len(new_elements) <= limit - 1: self.assertEqual(last_element, new_elements[0]) break else: self.assertEqual(last_element, next_element) break
def test_list_statistics_with_offset_limit(self): start_timestamp = int(time.time() * 1000) name = data_utils.rand_name() metric = [ helpers.create_metric(name=name, timestamp=start_timestamp + 0, dimensions={'key1': 'value-1', 'key2': 'value-1'}, value=1), helpers.create_metric(name=name, timestamp=start_timestamp + 500, dimensions={'key1': 'value-2', 'key2': 'value-2'}, value=2), helpers.create_metric(name=name, timestamp=start_timestamp + 1000, dimensions={'key1': 'value-3', 'key2': 'value-3'}, value=3), helpers.create_metric(name=name, timestamp=start_timestamp + 1500, dimensions={'key1': 'value-4', 'key2': 'value-4'}, value=4), helpers.create_metric(name=name, timestamp=start_timestamp + 2000, dimensions={'key1': 'value-2', 'key2': 'value-2'}, value=5), helpers.create_metric(name=name, timestamp=start_timestamp + 2500, dimensions={'key1': 'value-3', 'key2': 'value-3'}, value=6), helpers.create_metric(name=name, timestamp=start_timestamp + 3000, dimensions={'key1': 'value-4', 'key2': 'value-4'}, value=7), helpers.create_metric(name=name, timestamp=start_timestamp + 3500, dimensions={'key1': 'value-4', 'key2': 'value-4'}, value=8) ] resp, response_body = self.monasca_client.create_metrics(metric) time.sleep(WAIT_TIME) query_parms = '?name=' + name resp, response_body = self.monasca_client.list_metrics(query_parms) self.assertEqual(200, resp.status) start_time = timeutils.iso8601_from_timestamp( start_timestamp / 1000) end_timestamp = start_timestamp + 4000 end_time = timeutils.iso8601_from_timestamp(end_timestamp / 1000) query_parms = '?name=' + name + '&merge_metrics=true&statistics=avg,' \ 'max,min,sum,count&start_time=' + str(start_time) + \ '&end_time=' + str(end_time) + '&period=1' resp, body = self.monasca_client.list_statistics(query_parms) self.assertEqual(200, resp.status) elements = body['elements'][0]['statistics'] first_element = elements[0] last_element = elements[3] query_parms = '?name=' + name + '&merge_metrics=true&statistics=avg,' \ 'max,min,sum,count&start_time=' + str(start_time) + \ '&end_time=' + str(end_time) + '&period=1' + '&limit=4' resp, response_body = self.monasca_client.list_statistics( query_parms) self.assertEqual(200, resp.status) elements = response_body['elements'][0]['statistics'] self.assertEqual(4, len(elements)) self.assertEqual(first_element, elements[0]) for limit in xrange(1, 5): next_element = elements[limit - 1] offset_timestamp = start_timestamp while True: offset_timestamp += 1000 * limit offset = timeutils.iso8601_from_timestamp(offset_timestamp / 1000) query_parms = '?name=' + name + '&merge_metrics=true' + \ '&statistics=avg,max,min,sum,' \ 'count&start_time=' + str(start_time) + \ '&end_time=' + str(end_time) + '&period=1' + \ '&limit=' + str(limit) + '&offset=' + str(offset) resp, response_body = self.monasca_client.list_statistics( query_parms) self.assertEqual(200, resp.status) new_elements = response_body['elements'][0]['statistics'] if len(new_elements) > limit - 1: self.assertEqual(limit, len(new_elements)) next_element = new_elements[limit - 1] elif len(new_elements) > 0 and len(new_elements) <= limit - 1: self.assertEqual(last_element, new_elements[0]) break else: self.assertEqual(last_element, next_element) break
def test_list_statistics_with_name_exceeds_max_length(self): long_name = "x" * (constants.MAX_LIST_STATISTICS_NAME_LENGTH + 1) start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) query_parms = "?merge_metrics=true&name=" + str(long_name) + "&start_time=" + str(start_time) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.list_statistics, query_parms)
def test_list_statistics_with_no_name(self): start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) query_parms = "?merge_metrics=true&statistics=avg&start_time=" + str(start_time) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.list_statistics, query_parms)
def test_list_statistics_with_invalid_statistics(self): start_time = timeutils.iso8601_from_timestamp(self._start_timestamp / 1000) query_parms = "?name=name-1&statistics=abc&start_time=" + str(start_time) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.list_statistics, query_parms)
def test_list_statistics_with_offset_limit(self): start_timestamp = int(time.time() * 1000) name = data_utils.rand_name() metric = [ helpers.create_metric( name=name, timestamp=start_timestamp + 0, dimensions={"key1": "value-1", "key2": "value-1"}, value=1 ), helpers.create_metric( name=name, timestamp=start_timestamp + 500, dimensions={"key1": "value-2", "key2": "value-2"}, value=2 ), helpers.create_metric( name=name, timestamp=start_timestamp + 1000, dimensions={"key1": "value-3", "key2": "value-3"}, value=3 ), helpers.create_metric( name=name, timestamp=start_timestamp + 1500, dimensions={"key1": "value-4", "key2": "value-4"}, value=4 ), helpers.create_metric( name=name, timestamp=start_timestamp + 2000, dimensions={"key1": "value-2", "key2": "value-2"}, value=5 ), helpers.create_metric( name=name, timestamp=start_timestamp + 2500, dimensions={"key1": "value-3", "key2": "value-3"}, value=6 ), helpers.create_metric( name=name, timestamp=start_timestamp + 3000, dimensions={"key1": "value-4", "key2": "value-4"}, value=7 ), helpers.create_metric( name=name, timestamp=start_timestamp + 3500, dimensions={"key1": "value-4", "key2": "value-4"}, value=8 ), ] resp, response_body = self.monasca_client.create_metrics(metric) time.sleep(WAIT_TIME) query_parms = "?name=" + name resp, response_body = self.monasca_client.list_metrics(query_parms) self.assertEqual(200, resp.status) start_time = timeutils.iso8601_from_timestamp(start_timestamp / 1000) end_timestamp = start_timestamp + 4000 end_time = timeutils.iso8601_from_timestamp(end_timestamp / 1000) query_parms = ( "?name=" + name + "&merge_metrics=true&statistics=avg," "max,min,sum,count&start_time=" + str(start_time) + "&end_time=" + str(end_time) + "&period=1" ) resp, body = self.monasca_client.list_statistics(query_parms) self.assertEqual(200, resp.status) elements = body["elements"][0]["statistics"] first_element = elements[0] last_element = elements[3] query_parms = ( "?name=" + name + "&merge_metrics=true&statistics=avg," "max,min,sum,count&start_time=" + str(start_time) + "&end_time=" + str(end_time) + "&period=1" + "&limit=4" ) resp, response_body = self.monasca_client.list_statistics(query_parms) self.assertEqual(200, resp.status) elements = response_body["elements"][0]["statistics"] self.assertEqual(4, len(elements)) self.assertEqual(first_element, elements[0]) for limit in xrange(1, 5): next_element = elements[limit - 1] offset_timestamp = start_timestamp while True: offset_timestamp += 1000 * limit offset = timeutils.iso8601_from_timestamp(offset_timestamp / 1000) query_parms = "?name=" + name + "&merge_metrics=true" + "&statistics=avg,max,min,sum," "count&start_time=" + str( start_time ) + "&end_time=" + str( end_time ) + "&period=1" + "&limit=" + str( limit ) + "&offset=" + str( offset ) resp, response_body = self.monasca_client.list_statistics(query_parms) self.assertEqual(200, resp.status) new_elements = response_body["elements"][0]["statistics"] if len(new_elements) > limit - 1: self.assertEqual(limit, len(new_elements)) next_element = new_elements[limit - 1] elif len(new_elements) > 0 and len(new_elements) <= limit - 1: self.assertEqual(last_element, new_elements[0]) break else: self.assertEqual(last_element, next_element) break