def _verify_export_location_structure(self, export_locations,
role='admin'):
expected_keys = [
'created_at', 'updated_at', 'path', 'uuid',
]
if role == 'admin':
expected_keys.extend(['is_admin_only', 'share_instance_id'])
if not isinstance(export_locations, (list, tuple, set)):
export_locations = (export_locations, )
for export_location in export_locations:
self.assertEqual(len(expected_keys), len(export_location))
for key in expected_keys:
self.assertIn(key, export_location)
if role == 'admin':
self.assertIn(export_location['is_admin_only'], (True, False))
self.assertTrue(
uuidutils.is_uuid_like(
export_location['share_instance_id']))
self.assertTrue(uuidutils.is_uuid_like(export_location['uuid']))
self.assertTrue(
isinstance(export_location['path'], six.string_types))
for time in (export_location['created_at'],
export_location['updated_at']):
# If var 'time' has incorrect value then ValueError exception
# is expected to be raised. So, just try parse it making
# assertion that it has proper date value.
timeutils.parse_strtime(time)
def test_parse_input_params_success(self, mock_get_user_id,
mock_is_authenticated, mock_get_input):
fmt = '%Y-%m-%d %H:%M:%S'
self.CONF.set_override('input_date_format', fmt, 'api')
raw_filters = {
const.START_DATE: '2015-03-26 15:04:40',
const.END_DATE: '2015-03-26 15:04:50',
const.CPID: '12345',
const.SIGNED: True
}
expected_params = mock.Mock()
mock_get_input.return_value = raw_filters
parsed_start_date = timeutils.parse_strtime(
raw_filters[const.START_DATE], fmt)
parsed_end_date = timeutils.parse_strtime(raw_filters[const.END_DATE],
fmt)
expected_result = {
const.START_DATE: parsed_start_date,
const.END_DATE: parsed_end_date,
const.CPID: '12345',
const.SIGNED: True,
const.OPENID: 'fake_id',
}
result = api_utils.parse_input_params(expected_params)
self.assertEqual(expected_result, result)
mock_get_input.assert_called_once_with(expected_params)
def test_parse_input_params_success(
self, mock_get_user_pubkeys, mock_get_user_id, mock_is_authenticated, mock_get_input
):
fmt = "%Y-%m-%d %H:%M:%S"
self.CONF.set_override("input_date_format", fmt, "api")
raw_filters = {
const.START_DATE: "2015-03-26 15:04:40",
const.END_DATE: "2015-03-26 15:04:50",
const.CPID: "12345",
const.SIGNED: True,
}
fake_pubkeys = ({"format": "fake", "pubkey": "fake_pk"},)
mock_get_user_pubkeys.return_value = fake_pubkeys
expected_params = mock.Mock()
mock_get_input.return_value = raw_filters
parsed_start_date = timeutils.parse_strtime(raw_filters[const.START_DATE], fmt)
parsed_end_date = timeutils.parse_strtime(raw_filters[const.END_DATE], fmt)
expected_result = {
const.START_DATE: parsed_start_date,
const.END_DATE: parsed_end_date,
const.CPID: "12345",
const.SIGNED: True,
const.OPENID: "fake_id",
const.USER_PUBKEYS: ["fake fake_pk"],
}
result = api_utils.parse_input_params(expected_params)
self.assertEqual(result, expected_result)
mock_get_input.assert_called_once_with(expected_params)
def make_test_data(conn, start, end, interval, event_types):
# Compute start and end timestamps for the new data.
if isinstance(start, datetime.datetime):
timestamp = start
else:
timestamp = timeutils.parse_strtime(start)
if not isinstance(end, datetime.datetime):
end = timeutils.parse_strtime(end)
increment = datetime.timedelta(minutes=interval)
print('Adding new events')
n = 0
while timestamp <= end:
data = []
for i in range(event_types):
traits = [models.Trait('id1_%d' % i, 1, str(uuid.uuid4())),
models.Trait('id2_%d' % i, 2, random.randint(1, 10)),
models.Trait('id3_%d' % i, 3, random.random()),
models.Trait('id4_%d' % i, 4, timestamp)]
data.append(models.Event(str(uuid.uuid4()),
'event_type%d' % i,
timestamp,
traits,
{}))
n += 1
conn.record_events(data)
timestamp = timestamp + increment
print('Added %d new events' % n)
def make_test_data(conn, start, end, interval, event_types):
# Compute start and end timestamps for the new data.
if isinstance(start, datetime.datetime):
timestamp = start
else:
timestamp = timeutils.parse_strtime(start)
if not isinstance(end, datetime.datetime):
end = timeutils.parse_strtime(end)
increment = datetime.timedelta(minutes=interval)
print('Adding new events')
n = 0
while timestamp <= end:
data = []
for i in range(event_types):
traits = [models.Trait('id1_%d' % i, 1, str(uuid.uuid4())),
models.Trait('id2_%d' % i, 2, random.randint(1, 10)),
models.Trait('id3_%d' % i, 3, random.random()),
models.Trait('id4_%d' % i, 4, timestamp)]
data.append(models.Event(str(uuid.uuid4()),
'event_type%d' % i,
timestamp,
traits))
n += 1
conn.record_events(data)
timestamp = timestamp + increment
print('Added %d new events' % n)
def test_parse_input_params_success(self, mock_get_input):
fmt = '%Y-%m-%d %H:%M:%S'
self.CONF.set_override('input_date_format',
fmt,
'api')
raw_filters = {
const.START_DATE: '2015-03-26 15:04:40',
const.END_DATE: '2015-03-26 15:04:50',
const.CPID: '12345',
}
expected_params = mock.Mock()
mock_get_input.return_value = raw_filters
parsed_start_date = timeutils.parse_strtime(
raw_filters[const.START_DATE],
fmt
)
parsed_end_date = timeutils.parse_strtime(
raw_filters[const.END_DATE],
fmt
)
expected_result = {
const.START_DATE: parsed_start_date,
const.END_DATE: parsed_end_date,
const.CPID: '12345'
}
result = api_utils.parse_input_params(expected_params)
self.assertEqual(result, expected_result)
mock_get_input.assert_called_once_with(expected_params)
def make_test_data(conf, name, meter_type, unit, volume, random_min,
random_max, user_id, project_id, resource_id, start,
end, interval, resource_metadata=None, source='artificial'):
resource_metadata = resource_metadata or {'display_name': 'toto',
'host': 'tata',
'image_ref': 'test',
'instance_flavor_id': 'toto',
'server_group': 'toto',
}
# Compute start and end timestamps for the new data.
if isinstance(start, datetime.datetime):
timestamp = start
else:
timestamp = timeutils.parse_strtime(start)
if not isinstance(end, datetime.datetime):
end = timeutils.parse_strtime(end)
increment = datetime.timedelta(minutes=interval)
print('Adding new samples for meter %s.' % (name))
# Generate samples
n = 0
total_volume = volume
while timestamp <= end:
if (random_min >= 0 and random_max >= 0):
# If there is a random element defined, we will add it to
# user given volume.
if isinstance(random_min, int) and isinstance(random_max, int):
total_volume += random.randint(random_min, random_max)
else:
total_volume += random.uniform(random_min, random_max)
c = sample.Sample(name=name,
type=meter_type,
unit=unit,
volume=total_volume,
user_id=user_id,
project_id=project_id,
resource_id=resource_id,
timestamp=timestamp.isoformat(),
resource_metadata=resource_metadata,
source=source,
)
data = utils.meter_message_from_counter(
c, conf.publisher.telemetry_secret)
# timestamp should be string when calculating signature, but should be
# datetime object when calling record_metering_data.
data['timestamp'] = timestamp
yield data
n += 1
timestamp = timestamp + increment
if (meter_type == 'gauge' or meter_type == 'delta'):
# For delta and gauge, we don't want to increase the value
# in time by random element. So we always set it back to
# volume.
total_volume = volume
print('Added %d new samples for meter %s.' % (n, name))
def make_test_data(name, meter_type, unit, user_id, project_id,
start, end, interval,
volume, random_min=-1, random_max=-1,
resources_count=1, resource_metadata=None,
source='artificial', **kwargs):
resource_metadata = resource_metadata or {'display_name': 'toto',
'host': 'tata',
'image_ref': 'test',
'instance_flavor_id': 'toto',
'server_group': 'toto',
}
# Compute start and end timestamps for the new data.
if isinstance(start, datetime.datetime):
timestamp = start
else:
timestamp = timeutils.parse_strtime(start)
if not isinstance(end, datetime.datetime):
end = timeutils.parse_strtime(end)
increment = datetime.timedelta(seconds=interval)
resources = [str(uuid.uuid4()) for _ in moves.xrange(resources_count)]
print('Adding new samples for meter %s.' % (name))
# Generate samples
n = 0
total_volume = volume
while timestamp <= end:
if (random_min >= 0 and random_max >= 0):
# If there is a random element defined, we will add it to
# user given volume.
if isinstance(random_min, int) and isinstance(random_max, int):
total_volume += random.randint(random_min, random_max)
else:
total_volume += random.uniform(random_min, random_max)
resource_id = resources[random.randint(0, len(resources) - 1)]
c = sample.Sample(name=name,
type=meter_type,
unit=unit,
volume=total_volume,
user_id=user_id,
project_id=project_id,
resource_id=resource_id,
timestamp=timestamp.isoformat(),
resource_metadata=resource_metadata,
source=source,
)
data = utils.meter_message_from_counter(
c, cfg.CONF.publisher.telemetry_secret)
yield data
n += 1
timestamp = timestamp + increment
if (meter_type == 'gauge' or meter_type == 'delta'):
# For delta and gauge, we don't want to increase the value
# in time by random element. So we always set it back to
# volume.
total_volume = volume
print('Added %d new samples for meter %s.' % (n, name))
def _verify_export_location_structure(
self, export_locations, role='admin', version=LATEST_MICROVERSION,
format='summary'):
# Determine which keys to expect based on role, version and format
summary_keys = ['id', 'path']
if utils.is_microversion_ge(version, '2.14'):
summary_keys += ['preferred']
admin_summary_keys = summary_keys + [
'share_instance_id', 'is_admin_only']
detail_keys = summary_keys + ['created_at', 'updated_at']
admin_detail_keys = admin_summary_keys + ['created_at', 'updated_at']
if format == 'summary':
if role == 'admin':
expected_keys = admin_summary_keys
else:
expected_keys = summary_keys
else:
if role == 'admin':
expected_keys = admin_detail_keys
else:
expected_keys = detail_keys
if not isinstance(export_locations, (list, tuple, set)):
export_locations = (export_locations, )
for export_location in export_locations:
# Check that the correct keys are present
self.assertEqual(len(expected_keys), len(export_location))
for key in expected_keys:
self.assertIn(key, export_location)
# Check the format of ever-present summary keys
self.assertTrue(uuidutils.is_uuid_like(export_location['id']))
self.assertTrue(isinstance(export_location['path'],
six.string_types))
if utils.is_microversion_ge(version, '2.14'):
self.assertIn(export_location['preferred'], (True, False))
if role == 'admin':
self.assertIn(export_location['is_admin_only'], (True, False))
self.assertTrue(uuidutils.is_uuid_like(
export_location['share_instance_id']))
# Check the format of the detail keys
if format == 'detail':
for time in (export_location['created_at'],
export_location['updated_at']):
# If var 'time' has incorrect value then ValueError
# exception is expected to be raised. So, just try parse
# it making assertion that it has proper date value.
timeutils.parse_strtime(time)
def make_test_data(name, meter_type, unit, volume, random_min,
random_max, user_id, project_id, resource_id,
resource_list, start, end, interval,
resource_metadata=None, source='artificial'):
resource_metadata = resource_metadata or {}
# Compute start and end timestamps for the new data.
if isinstance(start, datetime.datetime):
timestamp = start
else:
timestamp = timeutils.parse_strtime(start)
if not isinstance(end, datetime.datetime):
end = timeutils.parse_strtime(end)
increment = datetime.timedelta(minutes=interval)
print('Adding new events for meter %s.' % (name))
# Generate events
n = 0
total_volume = volume
while timestamp <= end:
if (random_min >= 0 and random_max >= 0):
# If there is a random element defined, we will add it to
# user given volume.
if isinstance(random_min, int) and isinstance(random_max, int):
total_volume += random.randint(random_min, random_max)
else:
total_volume += random.uniform(random_min, random_max)
c = sample.Sample(name=name,
type=meter_type,
unit=unit,
volume=total_volume,
user_id=user_id,
project_id=project_id,
resource_id=resource_list[random.randint(0,
len(resource_list) - 1)],
timestamp=timestamp.isoformat(),
resource_metadata=resource_metadata,
source=source,
)
data = utils.meter_message_from_counter(
c, cfg.CONF.publisher.telemetry_secret)
# data = utils.meter_message_from_counter(
# c, cfg.CONF.publisher.metering_secret)
yield data
n += 1
timestamp = timestamp + increment
if (meter_type == 'gauge' or meter_type == 'delta'):
# For delta and gauge, we don't want to increase the value
# in time by random element. So we always set it back to
# volume.
total_volume = volume
print('Added %d new events for meter %s.' % (n, name))
def test_return_valid_isoformat(self):
"""Ensure that the ec2 api returns datetime in xs:dateTime
(which apparently isn't datetime.isoformat())
NOTE(ken-pepple): https://bugs.launchpad.net/patron/+bug/721297
"""
conv = apirequest._database_to_isoformat
# sqlite database representation with microseconds
time_to_convert = timeutils.parse_strtime("2011-02-21 20:14:10.634276",
"%Y-%m-%d %H:%M:%S.%f")
self.assertEqual(conv(time_to_convert), '2011-02-21T20:14:10.634Z')
# mysqlite database representation
time_to_convert = timeutils.parse_strtime("2011-02-21 19:56:18",
"%Y-%m-%d %H:%M:%S")
self.assertEqual(conv(time_to_convert), '2011-02-21T19:56:18.000Z')
def test_return_valid_isoformat(self):
"""Ensure that the ec2 api returns datetime in xs:dateTime
(which apparently isn't datetime.isoformat())
NOTE(ken-pepple): https://bugs.launchpad.net/nova/+bug/721297
"""
conv = apirequest._database_to_isoformat
# sqlite database representation with microseconds
time_to_convert = timeutils.parse_strtime("2011-02-21 20:14:10.634276",
"%Y-%m-%d %H:%M:%S.%f")
self.assertEqual(conv(time_to_convert), '2011-02-21T20:14:10.634Z')
# mysqlite database representation
time_to_convert = timeutils.parse_strtime("2011-02-21 19:56:18",
"%Y-%m-%d %H:%M:%S")
self.assertEqual(conv(time_to_convert), '2011-02-21T19:56:18.000Z')
def update(self,
lease_id,
name=None,
prolong_for=None,
reduce_by=None,
end_date=None,
advance_by=None,
defer_by=None,
start_date=None,
reservations=None):
"""Update attributes of the lease."""
values = {}
if name:
values['name'] = name
lease_end_date_change = prolong_for or reduce_by or end_date
lease_start_date_change = defer_by or advance_by or start_date
lease = None
if lease_end_date_change:
lease = self.get(lease_id)
if end_date:
date = timeutils.parse_strtime(end_date, utils.API_DATE_FORMAT)
values['end_date'] = date.strftime(utils.API_DATE_FORMAT)
else:
self._add_lease_date(values, lease, 'end_date',
lease_end_date_change, prolong_for
is not None)
if lease_start_date_change:
if lease is None:
lease = self.get(lease_id)
if start_date:
date = timeutils.parse_strtime(start_date,
utils.API_DATE_FORMAT)
values['start_date'] = date.strftime(utils.API_DATE_FORMAT)
else:
self._add_lease_date(values, lease, 'start_date',
lease_start_date_change, defer_by
is not None)
if reservations:
values['reservations'] = reservations
if not values:
return _('No values to update passed.')
resp, body = self.request_manager.put('/leases/%s' % lease_id,
body=values)
return body['lease']
def __init__(self, user_id, project_id, is_admin=None, read_deleted="no",
roles=None, remote_address=None, timestamp=None,
request_id=None, auth_token=None, overwrite=True,
quota_class=None, user_name=None, project_name=None,
service_catalog=None, instance_lock_checked=False,
user_auth_plugin=None, **kwargs):
""":param read_deleted: 'no' indicates deleted records are hidden,
'yes' indicates deleted records are visible,
'only' indicates that *only* deleted records are visible.
:param overwrite: Set to False to ensure that the greenthread local
copy of the index is not overwritten.
:param user_auth_plugin: The auth plugin for the current request's
authentication data.
:param kwargs: Extra arguments that might be present, but we ignore
because they possibly came in from older rpc messages.
"""
if kwargs:
LOG.warning(_LW('Arguments dropped when creating context: %s') %
str(kwargs))
self.user_id = user_id
self.project_id = project_id
self.roles = roles or []
self.read_deleted = read_deleted
self.remote_address = remote_address
if not timestamp:
timestamp = timeutils.utcnow()
if isinstance(timestamp, six.string_types):
timestamp = timeutils.parse_strtime(timestamp)
self.timestamp = timestamp
if not request_id:
request_id = context.generate_request_id()
self.request_id = request_id
self.auth_token = auth_token
if service_catalog:
# Only include required parts of service_catalog
self.service_catalog = [s for s in service_catalog
if s.get('type') in ('volume', 'volumev2', 'key-manager')]
else:
# if list is empty or none
self.service_catalog = []
self.instance_lock_checked = instance_lock_checked
# NOTE(markmc): this attribute is currently only used by the
# rs_limits turnstile pre-processor.
# See https://lists.launchpad.net/openstack/msg12200.html
self.quota_class = quota_class
self.user_name = user_name
self.project_name = project_name
self.is_admin = is_admin
self.user_auth_plugin = user_auth_plugin
if self.is_admin is None:
self.is_admin = policy.check_is_admin(self)
if overwrite or not hasattr(local.store, 'context'):
self.update_store()
def __init__(self, user_id, project_id, is_admin=None, read_deleted="no",
roles=None, remote_address=None, timestamp=None,
request_id=None, auth_token=None, overwrite=True,
quota_class=None, user_name=None, project_name=None,
service_catalog=None, instance_lock_checked=False,
user_auth_plugin=None, **kwargs):
""":param read_deleted: 'no' indicates deleted records are hidden,
'yes' indicates deleted records are visible,
'only' indicates that *only* deleted records are visible.
:param overwrite: Set to False to ensure that the greenthread local
copy of the index is not overwritten.
:param user_auth_plugin: The auth plugin for the current request's
authentication data.
:param kwargs: Extra arguments that might be present, but we ignore
because they possibly came in from older rpc messages.
"""
if kwargs:
LOG.warning(_LW('Arguments dropped when creating context: %s') %
str(kwargs))
self.user_id = user_id
self.project_id = project_id
self.roles = roles or []
self.read_deleted = read_deleted
self.remote_address = remote_address
if not timestamp:
timestamp = timeutils.utcnow()
if isinstance(timestamp, six.string_types):
timestamp = timeutils.parse_strtime(timestamp)
self.timestamp = timestamp
if not request_id:
request_id = context.generate_request_id()
self.request_id = request_id
self.auth_token = auth_token
if service_catalog:
# Only include required parts of service_catalog
self.service_catalog = [s for s in service_catalog
if s.get('type') in ('volume', 'volumev2', 'key-manager')]
else:
# if list is empty or none
self.service_catalog = []
self.instance_lock_checked = instance_lock_checked
# NOTE(markmc): this attribute is currently only used by the
# rs_limits turnstile pre-processor.
# See https://lists.launchpad.net/openstack/msg12200.html
self.quota_class = quota_class
self.user_name = user_name
self.project_name = project_name
self.is_admin = is_admin
self.user_auth_plugin = user_auth_plugin
if self.is_admin is None:
self.is_admin = policy.check_is_admin(self)
if overwrite or not hasattr(local.store, 'context'):
self.update_store()
def __init__(self, user_id=None, project_id=None, is_admin=None,
read_deleted="no", remote_address=None, timestamp=None,
quota_class=None, service_catalog=None,
instance_lock_checked=False, user_auth_plugin=None, **kwargs):
""":param read_deleted: 'no' indicates deleted records are hidden,
'yes' indicates deleted records are visible,
'only' indicates that *only* deleted records are visible.
:param overwrite: Set to False to ensure that the greenthread local
copy of the index is not overwritten.
:param user_auth_plugin: The auth plugin for the current request's
authentication data.
"""
if user_id:
kwargs['user'] = user_id
if project_id:
kwargs['tenant'] = project_id
super(RequestContext, self).__init__(is_admin=is_admin, **kwargs)
self.read_deleted = read_deleted
self.remote_address = remote_address
if not timestamp:
timestamp = timeutils.utcnow()
if isinstance(timestamp, six.string_types):
timestamp = timeutils.parse_strtime(timestamp)
self.timestamp = timestamp
if service_catalog:
# Only include required parts of service_catalog
# NOTE(lyarwood): While volumev2 is no longer supported with Queens
# we still provide it as part of the service catalog as the request
# context may end up being sent over the wire to a Pike compute
# that is specifically looking for a cinderv2 type via catalog_info
self.service_catalog = [s for s in service_catalog
if s.get('type') in ('image', 'block-storage', 'volumev2',
'volumev3', 'key-manager', 'placement',
'network')]
else:
# if list is empty or none
self.service_catalog = []
self.instance_lock_checked = instance_lock_checked
# NOTE(markmc): this attribute is currently only used by the
# rs_limits turnstile pre-processor.
# See https://lists.launchpad.net/openstack/msg12200.html
self.quota_class = quota_class
# NOTE(dheeraj): The following attributes are used by cellsv2 to store
# connection information for connecting to the target cell.
# It is only manipulated using the target_cell contextmanager
# provided by this module
self.db_connection = None
self.mq_connection = None
self.user_auth_plugin = user_auth_plugin
if self.is_admin is None:
self.is_admin = policy.check_is_admin(self)
def parse_input_params(expected_input_params):
"""Parse input parameters from request.
:param expecred_params: (array) Expected input
params specified in constants.
"""
raw_filters = _get_input_params_from_request(expected_input_params)
filters = copy.deepcopy(raw_filters)
date_fmt = CONF.api.input_date_format
for key, value in filters.items():
if key == const.START_DATE or key == const.END_DATE:
try:
filters[key] = timeutils.parse_strtime(value, date_fmt)
except (ValueError, TypeError) as exc:
raise ParseInputsError('Invalid date format: %(exc)s' %
{'exc': exc})
start_date = filters.get(const.START_DATE)
end_date = filters.get(const.END_DATE)
if start_date and end_date:
if start_date > end_date:
raise ParseInputsError('Invalid dates: %(start)s '
'more than %(end)s' % {
'start': const.START_DATE,
'end': const.END_DATE
})
return filters
def test_to_json_with_date_format_value(self):
test_date = tu.parse_strtime("0001-03-08T02:00:00",
'%Y-%m-%dT%H:%M:%S')
fixture = {"date": test_date}
expected = '{"date": "0001-03-08T02:00:00"}'
actual = serializers.JSONResponseSerializer().to_json(fixture)
self.assertEqual(expected, actual)
def _poll_shelved_instances(self, context):
if CONF.shelved_offload_time <= 0:
return
filters = {'vm_state': vm_states.SHELVED,
'task_state': None,
'host': self.host}
shelved_instances = objects.InstanceList.get_by_filters(
context, filters=filters, expected_attrs=['system_metadata'],
use_slave=True)
to_gc = []
for instance in shelved_instances:
sys_meta = instance.system_metadata
shelved_at = timeutils.parse_strtime(sys_meta['shelved_at'])
if timeutils.is_older_than(shelved_at, CONF.shelved_offload_time):
to_gc.append(instance)
for instance in to_gc:
try:
instance.task_state = task_states.SHELVING_OFFLOADING
instance.save(expected_task_state=(None,))
self.shelve_offload_instance(context, instance,
clean_shutdown=False)
except Exception:
LOG.exception(_LE('Periodic task failed to offload instance.'),
instance=instance)
def parse_input_params(expected_input_params):
"""Parse input parameters from request.
:param expected_input_params: (array) Expected input
params specified in constants.
"""
raw_filters = _get_input_params_from_request(expected_input_params)
filters = copy.deepcopy(raw_filters)
date_fmt = CONF.api.input_date_format
for key, value in filters.items():
if key == const.START_DATE or key == const.END_DATE:
try:
filters[key] = timeutils.parse_strtime(value, date_fmt)
except (ValueError, TypeError) as exc:
raise api_exc.ParseInputsError(
'Invalid date format: %(exc)s' % {'exc': exc})
start_date = filters.get(const.START_DATE)
end_date = filters.get(const.END_DATE)
if start_date and end_date:
if start_date > end_date:
raise api_exc.ParseInputsError(
'Invalid dates: %(start)s more than %(end)s'
'' % {'start': const.START_DATE, 'end': const.END_DATE})
if const.SIGNED in filters:
if is_authenticated():
filters[const.OPENID] = get_user_id()
else:
raise api_exc.ParseInputsError(
'To see signed test results you need to authenticate')
return filters
def notify_service_capabilities(self, service_name, backend, capabilities,
timestamp):
"""Notify the ceilometer with updated volume stats"""
if service_name != 'volume':
return
updated = []
capa_new = self.service_states.get(backend, {})
timestamp = timestamp or timeutils.utcnow()
if isinstance(timestamp, six.string_types):
timestamp = timeutils.parse_strtime(timestamp)
# Compare the capabilities and timestamps to decide notifying
if not capa_new:
updated = self._get_updated_pools(capa_new, capabilities)
else:
if timestamp > self.service_states[backend]["timestamp"]:
updated = self._get_updated_pools(
self.service_states[backend], capabilities)
if not updated:
updated = self._get_updated_pools(
self.service_states_last_update.get(backend, {}),
self.service_states.get(backend, {}))
if updated:
capab_copy = dict(capabilities)
capab_copy["timestamp"] = timestamp
# If capabilities changes, notify and record the capabilities.
self.service_states_last_update[backend] = capab_copy
self.get_usage_and_notify(capabilities, updated, backend,
timestamp)
def update_from_volume_capability(self, capability, service=None):
"""Update information about a pool from its volume_node info."""
self.update_capabilities(capability, service)
if capability:
timestamp = capability['timestamp']
if isinstance(timestamp, six.string_types):
timestamp = timeutils.parse_strtime(timestamp)
if self.updated and self.updated > timestamp:
return
self.update_backend(capability)
self.total_capacity_gb = capability.get('total_capacity_gb', 0)
self.free_capacity_gb = capability.get('free_capacity_gb', 0)
self.allocated_capacity_gb = capability.get(
'allocated_capacity_gb', 0)
self.QoS_support = capability.get('QoS_support', False)
self.reserved_percentage = capability.get('reserved_percentage', 0)
# provisioned_capacity_gb is the apparent total capacity of
# all the volumes created on a backend, which is greater than
# or equal to allocated_capacity_gb, which is the apparent
# total capacity of all the volumes created on a backend
# in Cinder. Using allocated_capacity_gb as the default of
# provisioned_capacity_gb if it is not set.
self.provisioned_capacity_gb = capability.get(
'provisioned_capacity_gb', self.allocated_capacity_gb)
self.max_over_subscription_ratio = capability.get(
'max_over_subscription_ratio',
CONF.max_over_subscription_ratio)
self.thin_provisioning_support = capability.get(
'thin_provisioning_support', False)
self.thick_provisioning_support = capability.get(
'thick_provisioning_support', False)
self.multiattach = capability.get('multiattach', False)
def _get_sample(message, name):
try:
for metric in message['payload']['metrics']:
if name == metric['name']:
info = {
'payload':
metric,
'event_type':
message['event_type'],
'publisher_id':
message['publisher_id'],
'resource_id':
'%s_%s' % (message['payload']['host'],
message['payload']['nodename']),
'timestamp':
str(timeutils.parse_strtime(metric['timestamp']))
}
return info
except Exception as err:
LOG.warning(
_('An error occurred while building %(m)s '
'sample: %(e)s') % {
'm': name,
'e': err
})
def test_get_updated_time(self):
updated_at_time = timeutils.parse_strtime("2016-04-18T02:56:25.198871")
service_ref = {
'host': 'fake-host',
'topic': 'compute',
'updated_at': updated_at_time.replace(tzinfo=iso8601.UTC)
}
# If no record returned from the mc, return record from DB
self.mc_client.get.return_value = None
self.assertEqual(service_ref['updated_at'],
self.servicegroup_api.get_updated_time(service_ref))
self.mc_client.get.assert_called_once_with('compute:fake-host')
# If the record in mc is newer than DB, return record from mc
self.mc_client.reset_mock()
retval = timeutils.utcnow()
self.mc_client.get.return_value = retval
self.assertEqual(retval.replace(tzinfo=iso8601.UTC),
self.servicegroup_api.get_updated_time(service_ref))
self.mc_client.get.assert_called_once_with('compute:fake-host')
# If the record in DB is newer than mc, return record from DB
self.mc_client.reset_mock()
service_ref['updated_at'] = \
retval.replace(tzinfo=iso8601.UTC)
self.mc_client.get.return_value = updated_at_time
self.assertEqual(service_ref['updated_at'],
self.servicegroup_api.get_updated_time(service_ref))
self.mc_client.get.assert_called_once_with('compute:fake-host')
# If no record returned from the DB, return the record from mc
self.mc_client.reset_mock()
service_ref['updated_at'] = None
self.mc_client.get.return_value = updated_at_time
self.assertEqual(updated_at_time.replace(tzinfo=iso8601.UTC),
self.servicegroup_api.get_updated_time(service_ref))
self.mc_client.get.assert_called_once_with('compute:fake-host')
def create_cache_entry(self, context, volume_ref, image_id, image_meta):
"""Create a new cache entry for an image.
This assumes that the volume described by volume_ref has already been
created and is in an available state.
"""
LOG.debug(
"Creating new image-volume cache entry for image " "%(image_id)s on host %(host)s.",
{"image_id": image_id, "host": volume_ref["host"]},
)
# When we are creating an image from a volume the updated_at field
# will be a unicode representation of the datetime. In that case
# we just need to parse it into one. If it is an actual datetime
# we want to just grab it as a UTC naive datetime.
image_updated_at = image_meta["updated_at"]
if type(image_updated_at) in [unicode, str]:
image_updated_at = timeutils.parse_strtime(image_updated_at)
else:
image_updated_at = image_updated_at.astimezone(timezone("UTC"))
cache_entry = self.db.image_volume_cache_create(
context,
volume_ref["host"],
image_id,
image_updated_at.replace(tzinfo=None),
volume_ref["id"],
volume_ref["size"],
)
LOG.debug("New image-volume cache entry created: %(entry)s.", {"entry": self._entry_to_str(cache_entry)})
return cache_entry
def parse_input_params(expected_input_params):
"""Parse input parameters from request.
:param expected_input_params: (array) Expected input
params specified in constants.
"""
raw_filters = _get_input_params_from_request(expected_input_params)
filters = copy.deepcopy(raw_filters)
date_fmt = CONF.api.input_date_format
for key, value in filters.items():
if key == const.START_DATE or key == const.END_DATE:
try:
filters[key] = timeutils.parse_strtime(value, date_fmt)
except (ValueError, TypeError) as exc:
raise api_exc.ParseInputsError('Invalid date format: %(exc)s' %
{'exc': exc})
start_date = filters.get(const.START_DATE)
end_date = filters.get(const.END_DATE)
if start_date and end_date:
if start_date > end_date:
raise api_exc.ParseInputsError(
'Invalid dates: %(start)s more than %(end)s'
'' % {
'start': const.START_DATE,
'end': const.END_DATE
})
if const.SIGNED in filters:
if is_authenticated():
filters[const.OPENID] = get_user_id()
else:
raise api_exc.ParseInputsError(
'To see signed test results you need to authenticate')
return filters
def _poll_shelved_instances(self, context):
if CONF.shelved_offload_time <= 0:
return
filters = {
'vm_state': vm_states.SHELVED,
'task_state': None,
'host': self.host
}
shelved_instances = objects.InstanceList.get_by_filters(
context,
filters=filters,
expected_attrs=['system_metadata'],
use_slave=True)
to_gc = []
for instance in shelved_instances:
sys_meta = instance.system_metadata
shelved_at = timeutils.parse_strtime(sys_meta['shelved_at'])
if timeutils.is_older_than(shelved_at, CONF.shelved_offload_time):
to_gc.append(instance)
for instance in to_gc:
try:
instance.task_state = task_states.SHELVING_OFFLOADING
instance.save(expected_task_state=(None, ))
self.shelve_offload_instance(context,
instance,
clean_shutdown=False)
except Exception:
LOG.exception(_LE('Periodic task failed to offload instance.'),
instance=instance)
def test_get_updated_time(self):
updated_at_time = timeutils.parse_strtime("2016-04-18T02:56:25.198871")
service_ref = {
'host': 'fake-host',
'topic': 'compute',
'updated_at': updated_at_time.replace(tzinfo=iso8601.UTC)
}
# If no record returned from the mc, return record from DB
self.mc_client.get.return_value = None
self.assertEqual(service_ref['updated_at'],
self.servicegroup_api.get_updated_time(service_ref))
self.mc_client.get.assert_called_once_with('compute:fake-host')
# If the record in mc is newer than DB, return record from mc
self.mc_client.reset_mock()
retval = timeutils.utcnow()
self.mc_client.get.return_value = retval
self.assertEqual(retval.replace(tzinfo=iso8601.UTC),
self.servicegroup_api.get_updated_time(service_ref))
self.mc_client.get.assert_called_once_with('compute:fake-host')
# If the record in DB is newer than mc, return record from DB
self.mc_client.reset_mock()
service_ref['updated_at'] = \
retval.replace(tzinfo=iso8601.UTC)
self.mc_client.get.return_value = updated_at_time
self.assertEqual(service_ref['updated_at'],
self.servicegroup_api.get_updated_time(service_ref))
self.mc_client.get.assert_called_once_with('compute:fake-host')
# If no record returned from the DB, return the record from mc
self.mc_client.reset_mock()
service_ref['updated_at'] = None
self.mc_client.get.return_value = updated_at_time
self.assertEqual(updated_at_time.replace(tzinfo=iso8601.UTC),
self.servicegroup_api.get_updated_time(service_ref))
self.mc_client.get.assert_called_once_with('compute:fake-host')
def _time(timestamp=None):
if not timestamp:
timestamp = timeutils.utcnow()
print timestamp
if isinstance(timestamp, six.string_types):
timestamp = timeutils.parse_strtime(timestamp)
return timestamp
def parse_input_params(expected_input_params):
"""Parse input parameters from request.
:param expecred_params: (array) Expected input
params specified in constants.
"""
raw_filters = _get_input_params_from_request(expected_input_params)
filters = copy.deepcopy(raw_filters)
date_fmt = CONF.api.input_date_format
for key, value in filters.items():
if key == const.START_DATE or key == const.END_DATE:
try:
filters[key] = timeutils.parse_strtime(value, date_fmt)
except (ValueError, TypeError) as exc:
raise ParseInputsError('Invalid date format: %(exc)s'
% {'exc': exc})
start_date = filters.get(const.START_DATE)
end_date = filters.get(const.END_DATE)
if start_date and end_date:
if start_date > end_date:
raise ParseInputsError('Invalid dates: %(start)s '
'more than %(end)s' % {
'start': const.START_DATE,
'end': const.END_DATE
})
return filters
def test_get_updated_time(self):
updated_at_time = timeutils.parse_strtime("2016-04-18T02:56:25.198871")
service_ref = {
'host': 'fake-host',
'topic': 'compute',
'updated_at': updated_at_time.replace(tzinfo=iso8601.iso8601.Utc())
}
self.mc_client.get.return_value = None
self.assertEqual(service_ref['updated_at'],
self.servicegroup_api.get_updated_time(service_ref))
self.mc_client.get.assert_called_once_with('compute:fake-host')
self.mc_client.reset_mock()
retval = timeutils.utcnow()
self.mc_client.get.return_value = retval
self.assertEqual(retval.replace(tzinfo=iso8601.iso8601.Utc()),
self.servicegroup_api.get_updated_time(service_ref))
self.mc_client.get.assert_called_once_with('compute:fake-host')
self.mc_client.reset_mock()
service_ref['updated_at'] = \
retval.replace(tzinfo=iso8601.iso8601.Utc())
self.mc_client.get.return_value = updated_at_time
self.assertEqual(service_ref['updated_at'],
self.servicegroup_api.get_updated_time(service_ref))
self.mc_client.get.assert_called_once_with('compute:fake-host')
def test_get_updated_time(self):
updated_at_time = timeutils.parse_strtime("2016-04-18T02:56:25.198871")
service_ref = {
'host': 'fake-host',
'topic': 'compute',
'updated_at': updated_at_time.replace(tzinfo=iso8601.UTC)
}
self.mc_client.get.return_value = None
self.assertEqual(service_ref['updated_at'],
self.servicegroup_api.get_updated_time(service_ref))
self.mc_client.get.assert_called_once_with('compute:fake-host')
self.mc_client.reset_mock()
retval = timeutils.utcnow()
self.mc_client.get.return_value = retval
self.assertEqual(retval.replace(tzinfo=iso8601.UTC),
self.servicegroup_api.get_updated_time(service_ref))
self.mc_client.get.assert_called_once_with('compute:fake-host')
self.mc_client.reset_mock()
service_ref['updated_at'] = \
retval.replace(tzinfo=iso8601.UTC)
self.mc_client.get.return_value = updated_at_time
self.assertEqual(service_ref['updated_at'],
self.servicegroup_api.get_updated_time(service_ref))
self.mc_client.get.assert_called_once_with('compute:fake-host')
def _set_status(self, id):
service = objects.Service.get(pecan.request.context, id)
last_heartbeat = (service.last_seen_up or service.updated_at
or service.created_at)
if isinstance(last_heartbeat, six.string_types):
# NOTE(russellb) If this service came in over rpc via
# conductor, then the timestamp will be a string and needs to be
# converted back to a datetime.
last_heartbeat = timeutils.parse_strtime(last_heartbeat)
else:
# Objects have proper UTC timezones, but the timeutils comparison
# below does not (and will fail)
last_heartbeat = last_heartbeat.replace(tzinfo=None)
elapsed = timeutils.delta_seconds(last_heartbeat, timeutils.utcnow())
is_up = abs(elapsed) <= CONF.service_down_time
if not is_up:
LOG.warning(
'Seems service %(name)s on host %(host)s is down. '
'Last heartbeat was %(lhb)s.'
'Elapsed time is %(el)s', {
'name': service.name,
'host': service.host,
'lhb': str(last_heartbeat),
'el': str(elapsed)
})
self._status = objects.service.ServiceStatus.FAILED
else:
self._status = objects.service.ServiceStatus.ACTIVE
def to_time_zone(self,
datetime,
tzone=None,
input_fmt=None,
localize=False):
"""Changes given datetime string into given timezone
:param datetime: datetime string
:param tzone: (optional) timezone as a string (e.g. "Europe/Paris"),
by default it's the current django timezone
:param input_fmt: (optional) format of datetime param, if None then
the default Sahara API format (%Y-%m-%dT%H:%M:%S) will be used
:param localize: (optional) if True then format of datetime will be
localized according to current timezone else it will be in
the default Sahara API format (%Y-%m-%dT%H:%M:%S)
:return datetime string in the current django timezone
"""
default_fmt = '%Y-%m-%dT%H:%M:%S'
if tzone is None:
tzone = self.request.session.get('django_timezone', 'UTC')
if input_fmt is None:
input_fmt = default_fmt
dt_in_utc = timezone.utc.localize(
timeutils.parse_strtime(datetime, input_fmt))
dt_in_zone = dt_in_utc.astimezone(ptz(tzone))
if localize:
return filters.date(dt_in_zone, "DATETIME_FORMAT")
else:
return dt_in_zone.strftime(default_fmt)
def parse_strtime(strtime):
if _ms_time_regex.match(strtime):
# NOTE(MotoKen): time format for aws-sdk-java contains millisecond
time_format = "%Y-%m-%dT%H:%M:%S.%fZ"
else:
time_format = "%Y-%m-%dT%H:%M:%SZ"
return timeutils.parse_strtime(strtime, time_format)
def instance_update(self, context, instance_uuid, updates, service):
for key, value in six.iteritems(updates):
if key not in allowed_updates:
LOG.error(
_LE("Instance update attempted for "
"'%(key)s' on %(instance_uuid)s"), {
'key': key,
'instance_uuid': instance_uuid
})
raise KeyError("unexpected update keyword '%s'" % key)
if key in datetime_fields and isinstance(value, six.string_types):
updates[key] = timeutils.parse_strtime(value)
# NOTE(danms): the send_update() call below is going to want to know
# about the flavor, so we need to join the appropriate things here,
# and objectify the result.
old_ref, instance_ref = self.db.instance_update_and_get_original(
context,
instance_uuid,
updates,
columns_to_join=['system_metadata'])
inst_obj = objects.Instance._from_db_object(
context,
objects.Instance(),
instance_ref,
expected_attrs=['system_metadata'])
notifications.send_update(context, old_ref, inst_obj, service)
return jsonutils.to_primitive(instance_ref)
def __init__(self,
user_id,
project_id,
is_admin=None,
read_deleted="no",
roles=None,
remote_address=None,
timestamp=None,
request_id=None,
auth_token=None,
overwrite=True,
quota_class=None,
service_catalog=None,
**kwargs):
"""Initialize RequestContext.
:param read_deleted: 'no' indicates deleted records are hidden, 'yes'
indicates deleted records are visible, 'only' indicates that
*only* deleted records are visible.
:param overwrite: Set to False to ensure that the greenthread local
copy of the index is not overwritten.
:param kwargs: Extra arguments that might be present, but we ignore
because they possibly came in from older rpc messages.
"""
if kwargs:
LOG.warn(_LW('Arguments dropped when creating context: %s'),
str(kwargs))
self.user_id = user_id
self.project_id = project_id
self.roles = roles or []
self.is_admin = is_admin
if self.is_admin is None:
self.is_admin = policy.check_is_admin(self.roles)
elif self.is_admin and 'admin' not in self.roles:
self.roles.append('admin')
self.read_deleted = read_deleted
self.remote_address = remote_address
if not timestamp:
timestamp = timeutils.utcnow()
if isinstance(timestamp, six.string_types):
timestamp = timeutils.parse_strtime(timestamp)
self.timestamp = timestamp
if service_catalog:
self.service_catalog = [
s for s in service_catalog
if s.get('type') in ('compute', 'volume')
]
else:
self.service_catalog = []
if not request_id:
request_id = common_context.generate_request_id()
self.request_id = request_id
self.auth_token = auth_token
self.quota_class = quota_class
if overwrite or not common_context.get_current():
self.update_store()
def is_up(self, service_ref):
"""Moved from nova.utils
Check whether a service is up based on last heartbeat.
"""
# Keep checking 'updated_at' if 'last_seen_up' isn't set.
# Should be able to use only 'last_seen_up' in the M release
last_heartbeat = (service_ref.get('last_seen_up')
or service_ref['updated_at']
or service_ref['created_at'])
if isinstance(last_heartbeat, six.string_types):
# NOTE(russellb) If this service_ref came in over rpc via
# conductor, then the timestamp will be a string and needs to be
# converted back to a datetime.
last_heartbeat = timeutils.parse_strtime(last_heartbeat)
else:
# Objects have proper UTC timezones, but the timeutils comparison
# below does not (and will fail)
last_heartbeat = last_heartbeat.replace(tzinfo=None)
# Timestamps in DB are UTC.
elapsed = timeutils.delta_seconds(last_heartbeat, timeutils.utcnow())
is_up = abs(elapsed) <= self.service_down_time
if not is_up:
LOG.debug(
'Seems service %(binary)s on host %(host)s is down. '
'Last heartbeat was %(lhb)s. Elapsed time is %(el)s', {
'binary': service_ref.get('binary'),
'host': service_ref.get('host'),
'lhb': str(last_heartbeat),
'el': str(elapsed)
})
return is_up
def test_to_json_with_date_format_value(self):
test_date = tu.parse_strtime("0001-03-08T02:00:00",
'%Y-%m-%dT%H:%M:%S')
fixture = {"date": test_date}
expected = '{"date": "0001-03-08T02:00:00"}'
actual = serializers.JSONResponseSerializer().to_json(fixture)
self.assertEqual(expected, actual)
def to_time_zone(self, datetime, tzone=None,
input_fmt=None, localize=False):
"""Changes given datetime string into given timezone
:param datetime: datetime string
:param tzone: (optional) timezone as a string (e.g. "Europe/Paris"),
by default it's the current django timezone
:param input_fmt: (optional) format of datetime param, if None then
the default Sahara API format (%Y-%m-%dT%H:%M:%S) will be used
:param localize: (optional) if True then format of datetime will be
localized according to current timezone else it will be in
the default Sahara API format (%Y-%m-%dT%H:%M:%S)
:return datetime string in the current django timezone
"""
default_fmt = '%Y-%m-%dT%H:%M:%S'
if tzone is None:
tzone = self.request.session.get('django_timezone', 'UTC')
if input_fmt is None:
input_fmt = default_fmt
dt_in_utc = timezone.utc.localize(
timeutils.parse_strtime(datetime, input_fmt))
dt_in_zone = dt_in_utc.astimezone(ptz(tzone))
if localize:
return filters.date(dt_in_zone, "DATETIME_FORMAT")
else:
return dt_in_zone.strftime(default_fmt)
def create_cache_entry(self, context, volume_ref, image_id, image_meta):
"""Create a new cache entry for an image.
This assumes that the volume described by volume_ref has already been
created and is in an available state.
"""
LOG.debug('Creating new image-volume cache entry for image '
'%(image_id)s on host %(host)s.',
{'image_id': image_id, 'host': volume_ref['host']})
# When we are creating an image from a volume the updated_at field
# will be a unicode representation of the datetime. In that case
# we just need to parse it into one. If it is an actual datetime
# we want to just grab it as a UTC naive datetime.
image_updated_at = image_meta['updated_at']
if isinstance(image_updated_at, six.string_types):
image_updated_at = timeutils.parse_strtime(image_updated_at)
else:
image_updated_at = image_updated_at.astimezone(timezone('UTC'))
cache_entry = self.db.image_volume_cache_create(
context,
volume_ref['host'],
image_id,
image_updated_at.replace(tzinfo=None),
volume_ref['id'],
volume_ref['size']
)
LOG.debug('New image-volume cache entry created: %(entry)s.',
{'entry': self._entry_to_str(cache_entry)})
return cache_entry
def create_cache_entry(self, context, volume_ref, image_id, image_meta):
"""Create a new cache entry for an image.
This assumes that the volume described by volume_ref has already been
created and is in an available state.
"""
LOG.debug(
'Creating new image-volume cache entry for image '
'%(image_id)s on %(service)s', {
'image_id': image_id,
'service': volume_ref.service_topic_queue
})
# When we are creating an image from a volume the updated_at field
# will be a unicode representation of the datetime. In that case
# we just need to parse it into one. If it is an actual datetime
# we want to just grab it as a UTC naive datetime.
image_updated_at = image_meta['updated_at']
if isinstance(image_updated_at, six.string_types):
image_updated_at = timeutils.parse_strtime(image_updated_at)
else:
image_updated_at = image_updated_at.astimezone(timezone('UTC'))
cache_entry = self.db.image_volume_cache_create(
context, volume_ref.host, volume_ref.cluster_name, image_id,
image_updated_at.replace(tzinfo=None), volume_ref.id,
volume_ref.size)
LOG.debug('New image-volume cache entry created: %(entry)s.',
{'entry': self._entry_to_str(cache_entry)})
return cache_entry
def is_up(self, service_ref):
"""Moved from nova.utils
Check whether a service is up based on last heartbeat.
"""
last_heartbeat = service_ref['updated_at'] or service_ref['created_at']
if isinstance(last_heartbeat, six.string_types):
# NOTE(russellb) If this service_ref came in over rpc via
# conductor, then the timestamp will be a string and needs to be
# converted back to a datetime.
last_heartbeat = timeutils.parse_strtime(last_heartbeat)
else:
# Objects have proper UTC timezones, but the timeutils comparison
# below does not (and will fail)
last_heartbeat = last_heartbeat.replace(tzinfo=None)
# Timestamps in DB are UTC.
elapsed = timeutils.delta_seconds(last_heartbeat, timeutils.utcnow())
is_up = abs(elapsed) <= self.service_down_time
if not is_up:
LOG.debug(
'Seems service is down. Last heartbeat was %(lhb)s. '
'Elapsed time is %(el)s', {
'lhb': str(last_heartbeat),
'el': str(elapsed)
})
return is_up
def assertValidISO8601ExtendedFormatDatetime(self, dt):
try:
return timeutils.parse_strtime(dt, fmt=TIME_FORMAT)
except Exception:
msg = '%s is not a valid ISO 8601 extended format date time.' % dt
raise AssertionError(msg)
self.assertIsInstance(dt, datetime.datetime)
def _add_lease_date(self, values, lease, key, delta_date, positive_delta):
delta_sec = utils.from_elapsed_time_to_delta(
delta_date,
pos_sign=positive_delta)
date = timeutils.parse_strtime(lease[key],
utils.LEASE_DATE_FORMAT)
values[key] = (date + delta_sec).strftime(utils.API_DATE_FORMAT)
def is_up(self, service_ref):
"""Moved from nova.utils
Check whether a service is up based on last heartbeat.
"""
last_heartbeat = (service_ref.get('last_seen_up') or
service_ref['created_at'])
if isinstance(last_heartbeat, six.string_types):
# NOTE(russellb) If this service_ref came in over rpc via
# conductor, then the timestamp will be a string and needs to be
# converted back to a datetime.
last_heartbeat = timeutils.parse_strtime(last_heartbeat)
else:
# Objects have proper UTC timezones, but the timeutils comparison
# below does not (and will fail)
last_heartbeat = last_heartbeat.replace(tzinfo=None)
# Timestamps in DB are UTC.
elapsed = timeutils.delta_seconds(last_heartbeat, timeutils.utcnow())
is_up = abs(elapsed) <= self.service_down_time
if not is_up:
LOG.debug('Seems service %(binary)s on host %(host)s is down. '
'Last heartbeat was %(lhb)s. Elapsed time is %(el)s',
{'binary': service_ref.get('binary'),
'host': service_ref.get('host'),
'lhb': str(last_heartbeat), 'el': str(elapsed)})
return is_up
def __init__(self,
user_id,
project_id,
request_id=None,
is_admin=None,
remote_address=None,
auth_token=None,
user_name=None,
project_name=None,
overwrite=True,
service_catalog=None,
api_version=None,
is_os_admin=None,
**kwargs):
"""Parameters
:param overwrite: Set to False to ensure that the greenthread local
copy of the index is not overwritten.
:param kwargs: Extra arguments that might be present, but we ignore
because they possibly came in from older rpc messages.
"""
user = kwargs.pop('user', None)
tenant = kwargs.pop('tenant', None)
super(RequestContext,
self).__init__(auth_token=auth_token,
user=user_id or user,
tenant=project_id or tenant,
is_admin=is_admin,
request_id=request_id,
resource_uuid=kwargs.pop('resource_uuid', None),
overwrite=overwrite)
# oslo_context's RequestContext.to_dict() generates this field, we can
# safely ignore this as we don't use it.
kwargs.pop('user_identity', None)
if kwargs:
LOG.warning(
_LW('Arguments dropped when creating context: %s') %
str(kwargs))
self.user_id = user_id
self.project_id = project_id
self.remote_address = remote_address
timestamp = timeutils.utcnow()
if isinstance(timestamp, six.string_types):
timestamp = timeutils.parse_strtime(timestamp)
self.timestamp = timestamp
self.service_catalog = service_catalog
if self.service_catalog is None:
# if list is empty or none
self.service_catalog = []
self.user_name = user_name
self.project_name = project_name
self.is_admin = is_admin
# TODO(ft): call policy.check_is_admin if is_admin is None
self.is_os_admin = is_os_admin
self.api_version = api_version
def parse_strtime(strtime):
if _ms_time_regex.match(strtime):
# NOTE(MotoKen): time format for aws-sdk-java contains millisecond
time_format = "%Y-%m-%dT%H:%M:%S.%fZ"
else:
time_format = "%Y-%m-%dT%H:%M:%SZ"
return timeutils.parse_strtime(strtime, time_format)
def __init__(self, user_id, project_id, is_admin=None, read_deleted="no",
roles=None, remote_address=None, timestamp=None,
request_id=None, auth_token=None, overwrite=True,
quota_class=None, service_catalog=None, **kwargs):
"""Initialize RequestContext.
:param read_deleted: 'no' indicates deleted records are hidden, 'yes'
indicates deleted records are visible, 'only' indicates that
*only* deleted records are visible.
:param overwrite: Set to False to ensure that the greenthread local
copy of the index is not overwritten.
:param kwargs: Extra arguments that might be present, but we ignore
because they possibly came in from older rpc messages.
"""
user = kwargs.pop('user', None)
tenant = kwargs.pop('tenant', None)
super(RequestContext, self).__init__(
auth_token=auth_token,
user=user_id or user,
tenant=project_id or tenant,
domain=kwargs.pop('domain', None),
user_domain=kwargs.pop('user_domain', None),
project_domain=kwargs.pop('project_domain', None),
is_admin=is_admin,
read_only=kwargs.pop('read_only', False),
show_deleted=kwargs.pop('show_deleted', False),
request_id=request_id,
resource_uuid=kwargs.pop('resource_uuid', None),
overwrite=overwrite,
roles=roles)
kwargs.pop('user_identity', None)
if kwargs:
LOG.warning(_LW('Arguments dropped when creating context: %s.'),
str(kwargs))
self.user_id = self.user
self.project_id = self.tenant
if self.is_admin is None:
self.is_admin = policy.check_is_admin(self.roles)
elif self.is_admin and 'admin' not in self.roles:
self.roles.append('admin')
self.read_deleted = read_deleted
self.remote_address = remote_address
if not timestamp:
timestamp = timeutils.utcnow()
if isinstance(timestamp, six.string_types):
timestamp = timeutils.parse_strtime(timestamp)
self.timestamp = timestamp
if service_catalog:
self.service_catalog = [s for s in service_catalog
if s.get('type') in ('compute', 'volume')]
else:
self.service_catalog = []
self.quota_class = quota_class
def __init__(self,
user_id,
project_id,
is_admin=None,
read_deleted="no",
roles=None,
remote_address=None,
timestamp=None,
request_id=None,
auth_token=None,
overwrite=True,
user_name=None,
project_name=None,
service_catalog=None,
**kwargs):
"""
:param read_deleted: 'no' indicates deleted records are hidden, 'yes'
indicates deleted records are visible, 'only' indicates that
*only* deleted records are visible.
:param overwrite: Set to False to ensure that the greenthread local
copy of the index is not overwritten.
:param kwargs: Extra arguments that might be present, but we ignore
because they possibly came in from older rpc messages.
"""
super(RequestContext, self).__init__(auth_token=auth_token,
user=user_id,
tenant=project_id,
is_admin=is_admin,
request_id=request_id,
overwrite=overwrite,
roles=roles)
if kwargs:
LOG.warning(
_('Arguments dropped when creating context: %s') % str(kwargs))
self.user_id = user_id
self.project_id = project_id
self.read_deleted = read_deleted
self.remote_address = remote_address
if not timestamp:
timestamp = timeutils.utcnow()
if isinstance(timestamp, six.string_types):
timestamp = timeutils.parse_strtime(timestamp)
self.timestamp = timestamp
self.service_catalog = service_catalog
self.user_name = user_name
self.project_name = project_name
self.operation = None
self.operation_start_time = None
self.operation_get_progress_method = None
self.operation_item_id = None
self.operation_data = {}
def fake_vpn_instance():
return objects.Instance(
id=7,
image_ref=CONF.vpn_image_id,
vm_state='active',
created_at=timeutils.parse_strtime('1981-10-20T00:00:00.000000'),
uuid=uuid,
project_id=project_id)
def _get_share_networks(self, req, is_detail=True):
"""Returns a list of share networks."""
context = req.environ["manila.context"]
search_opts = {}
search_opts.update(req.GET)
if "all_tenants" in search_opts or (
"project_id" in search_opts and search_opts["project_id"] != context.project_id
):
policy.check_policy(context, RESOURCE_NAME, "get_all_share_networks")
if "security_service_id" in search_opts:
networks = db_api.share_network_get_all_by_security_service(context, search_opts["security_service_id"])
elif "project_id" in search_opts and search_opts["project_id"] != context.project_id:
networks = db_api.share_network_get_all_by_project(context, search_opts["project_id"])
elif "all_tenants" in search_opts:
networks = db_api.share_network_get_all(context)
else:
networks = db_api.share_network_get_all_by_project(context, context.project_id)
date_parsing_error_msg = """%s is not in yyyy-mm-dd format."""
if "created_since" in search_opts:
try:
created_since = timeutils.parse_strtime(search_opts["created_since"], fmt="%Y-%m-%d")
except ValueError:
msg = date_parsing_error_msg % search_opts["created_since"]
raise exc.HTTPBadRequest(explanation=msg)
networks = [network for network in networks if network["created_at"] >= created_since]
if "created_before" in search_opts:
try:
created_before = timeutils.parse_strtime(search_opts["created_before"], fmt="%Y-%m-%d")
except ValueError:
msg = date_parsing_error_msg % search_opts["created_before"]
raise exc.HTTPBadRequest(explanation=msg)
networks = [network for network in networks if network["created_at"] <= created_before]
opts_to_remove = ["all_tenants", "created_since", "created_before", "limit", "offset", "security_service_id"]
for opt in opts_to_remove:
search_opts.pop(opt, None)
if search_opts:
for key, value in six.iteritems(search_opts):
if key in ["ip_version", "segmentation_id"]:
value = int(value)
networks = [network for network in networks if network[key] == value]
limited_list = common.limited(networks, req)
return self._view_builder.build_share_networks(limited_list, is_detail)
def __init__(self, user_id=None, project_id=None, is_admin=None,
read_deleted="no", remote_address=None, timestamp=None,
quota_class=None, user_name=None, project_name=None,
service_catalog=None, instance_lock_checked=False,
user_auth_plugin=None, **kwargs):
""":param read_deleted: 'no' indicates deleted records are hidden,
'yes' indicates deleted records are visible,
'only' indicates that *only* deleted records are visible.
:param overwrite: Set to False to ensure that the greenthread local
copy of the index is not overwritten.
:param user_auth_plugin: The auth plugin for the current request's
authentication data.
"""
if user_id:
kwargs['user'] = user_id
if project_id:
kwargs['tenant'] = project_id
super(RequestContext, self).__init__(is_admin=is_admin, **kwargs)
self.read_deleted = read_deleted
self.remote_address = remote_address
if not timestamp:
timestamp = timeutils.utcnow()
if isinstance(timestamp, six.string_types):
timestamp = timeutils.parse_strtime(timestamp)
self.timestamp = timestamp
if service_catalog:
# Only include required parts of service_catalog
self.service_catalog = [s for s in service_catalog
if s.get('type') in ('volume', 'volumev2', 'key-manager',
'placement')]
else:
# if list is empty or none
self.service_catalog = []
self.instance_lock_checked = instance_lock_checked
# NOTE(markmc): this attribute is currently only used by the
# rs_limits turnstile pre-processor.
# See https://lists.launchpad.net/openstack/msg12200.html
self.quota_class = quota_class
self.user_name = user_name
self.project_name = project_name
# NOTE(dheeraj): The following attributes are used by cellsv2 to store
# connection information for connecting to the target cell.
# It is only manipulated using the target_cell contextmanager
# provided by this module
self.db_connection = None
self.mq_connection = None
self.user_auth_plugin = user_auth_plugin
if self.is_admin is None:
self.is_admin = policy.check_is_admin(self)
def _get_dummy_event_obj(self):
return {
'resource_id': '6261579e-d6f3-49ad-8bc3-a9cb974778ff',
'resource_state': 'ACTIVE',
'resource_type': 'VNF',
'event_details': '',
'event_type': 'scale_up',
'timestamp': timeutils.parse_strtime('2016-07-20T05:43:52.765172')
}
def __init__(self, user_id, project_id, is_admin=None, read_deleted="no",
roles=None, project_name=None, remote_address=None,
timestamp=None, request_id=None, auth_token=None,
overwrite=True, quota_class=None, service_catalog=None,
domain=None, user_domain=None, project_domain=None,
**kwargs):
"""Initialize RequestContext.
:param read_deleted: 'no' indicates deleted records are hidden, 'yes'
indicates deleted records are visible, 'only' indicates that
*only* deleted records are visible.
:param overwrite: Set to False to ensure that the greenthread local
copy of the index is not overwritten.
:param kwargs: Extra arguments that might be present, but we ignore
because they possibly came in from older rpc messages.
"""
super(RequestContext, self).__init__(auth_token=auth_token,
user=user_id,
tenant=project_id,
domain=domain,
user_domain=user_domain,
project_domain=project_domain,
is_admin=is_admin,
request_id=request_id)
self.roles = roles or []
self.project_name = project_name
self.read_deleted = read_deleted
self.remote_address = remote_address
if not timestamp:
timestamp = timeutils.utcnow()
if isinstance(timestamp, basestring):
timestamp = timeutils.parse_strtime(timestamp)
self.timestamp = timestamp
self.quota_class = quota_class
if overwrite or not hasattr(local.store, 'context'):
self.update_store()
if service_catalog:
# Only include required parts of service_catalog
self.service_catalog = [s for s in service_catalog
if s.get('type') in
('identity', 'compute', 'object-store')]
else:
# if list is empty or none
self.service_catalog = []
# We need to have RequestContext attributes defined
# when policy.check_is_admin invokes request logging
# to make it loggable.
if self.is_admin is None:
self.is_admin = policy.check_is_admin(self.roles)
elif self.is_admin and 'admin' not in self.roles:
self.roles.append('admin')
def report_state(self, context, **kwargs):
time = kwargs['time']
time = timeutils.parse_strtime(time)
if self.START_TIME > time:
LOG.info("H3CDriver Message with invalid time stamp received")
return
agent_state = kwargs['agent_state']['agent_state']
self._create_or_update_agent(context, agent_state)
LOG.info("H3CDriver(%s) report_state", agent_state['host'])
def update(self, lease_id, name=None, prolong_for=None, reduce_by=None,
end_date=None, advance_by=None, defer_by=None, start_date=None,
reservations=None):
"""Update attributes of the lease."""
values = {}
if name:
values['name'] = name
lease_end_date_change = prolong_for or reduce_by or end_date
lease_start_date_change = defer_by or advance_by or start_date
lease = None
if lease_end_date_change:
lease = self.get(lease_id)
if end_date:
date = timeutils.parse_strtime(end_date, utils.API_DATE_FORMAT)
values['end_date'] = date.strftime(utils.API_DATE_FORMAT)
else:
self._add_lease_date(values, lease, 'end_date',
lease_end_date_change,
prolong_for is not None)
if lease_start_date_change:
if lease is None:
lease = self.get(lease_id)
if start_date:
date = timeutils.parse_strtime(start_date,
utils.API_DATE_FORMAT)
values['start_date'] = date.strftime(utils.API_DATE_FORMAT)
else:
self._add_lease_date(values, lease, 'start_date',
lease_start_date_change,
defer_by is not None)
if reservations:
values['reservations'] = reservations
if not values:
return _('No values to update passed.')
resp, body = self.request_manager.put('/leases/%s' % lease_id,
body=values)
return body['lease']
