def test_is_soon(self): expires = timeutils.utcnow() + datetime.timedelta(minutes=5) self.assertFalse(timeutils.is_soon(expires, 120)) self.assertTrue(timeutils.is_soon(expires, 300)) self.assertTrue(timeutils.is_soon(expires, 600)) with mock.patch('datetime.datetime') as datetime_mock: datetime_mock.utcnow.return_value = self.skynet_self_aware_time expires = timeutils.utcnow() self.assertTrue(timeutils.is_soon(expires, 0))
def will_expire_soon(expires_at): if not expires_at: return False stale_duration = CONF.expiration_token_duration assert stale_duration, "expiration_token_duration must be specified" expires = timeutils.parse_isotime(expires_at) return timeutils.is_soon(expires, stale_duration)
def _is_token_valid(self): try: keystone = self.os_clients_dict['keystone'].keystone_client if not OpenStackDriver._token: OpenStackDriver._token = \ keystone.tokens.validate(keystone.session.get_token()) LOG.info("Get new OpenStackDriver._token expires_at=%s" % OpenStackDriver._token['expires_at']) # Reset the cached dictionary OpenStackDriver.os_clients_dict = collections.defaultdict(dict) return False keystone.tokens.validate(OpenStackDriver._token) except Exception as exception: LOG.info('_is_token_valid handle: %s', exception.message) # Reset the cached dictionary OpenStackDriver.os_clients_dict = collections.defaultdict(dict) OpenStackDriver._token = None return False expiry_time = timeutils.normalize_time( timeutils.parse_isotime(OpenStackDriver._token['expires_at'])) if timeutils.is_soon(expiry_time, STALE_TOKEN_DURATION): LOG.info('The cached keystone token will expire soon %s' % OpenStackDriver._token['expires_at']) # Reset the cached dictionary OpenStackDriver.os_clients_dict = collections.defaultdict(dict) OpenStackDriver._token = None return False else: return True
def _is_token_valid(self, region_name): try: keystone = \ self.os_clients_dict[region_name]['keystone'].keystone_client if (not self._identity_tokens or region_name not in self._identity_tokens or not self._identity_tokens[region_name]): self._identity_tokens[region_name] = \ keystone.tokens.validate(keystone.session.get_token()) LOG.info("Get new token for subcloud %s expires_at=%s" % (region_name, self._identity_tokens[region_name]['expires_at'])) # Reset the cached dictionary self.os_clients_dict[region_name] = \ collections.defaultdict(dict) return False token = \ keystone.tokens.validate(self._identity_tokens[region_name]) if token != self._identity_tokens[region_name]: LOG.info("updating token %s to %s" % (self._identity_tokens[region_name], token)) self._identity_tokens[region_name] = token self.os_clients_dict[region_name] = \ collections.defaultdict(dict) return False except Exception as exception: LOG.info('_is_token_valid handle: %s', exception.message) # Reset the cached dictionary self.os_clients_dict[region_name] = collections.defaultdict(dict) self._identity_tokens[region_name] = None return False expiry_time = timeutils.normalize_time( timeutils.parse_isotime( self._identity_tokens[region_name]['expires_at'])) if timeutils.is_soon(expiry_time, STALE_TOKEN_DURATION): LOG.info("The cached keystone token for subcloud %s " "will expire soon %s" % (region_name, self._identity_tokens[region_name]['expires_at'])) # Reset the cached dictionary self.os_clients_dict[region_name] = collections.defaultdict(dict) self._identity_tokens[region_name] = None return False else: return True
def _is_token_valid(self): keystone = self.os_clients_dict['keystone'].keystone_client try: token = keystone.tokens.validate(keystone.session.get_token()) except Exception as exception: LOG.info('Exception Occurred: %s', exception.message) # Reset the cached dictionary OpenStackDriver.os_clients_dict = collections.defaultdict(dict) return False expiry_time = timeutils.normalize_time( timeutils.parse_isotime(token['expires_at'])) if timeutils.is_soon(expiry_time, STALE_TOKEN_DURATION): LOG.info('The cached keystone token will expire soon') # Reset the cached dictionary OpenStackDriver.os_clients_dict = collections.defaultdict(dict) return False else: return True
def _is_token_valid(self, region_name): try: keystone = \ self.os_clients_dict[region_name]['keystone'].keystone_client if (not OpenStackDriver._identity_tokens or region_name not in OpenStackDriver._identity_tokens or not OpenStackDriver._identity_tokens[region_name]): identity_token = \ keystone.tokens.validate(keystone.session.get_token()) OpenStackDriver._identity_tokens[region_name] = identity_token LOG.info("Got new token for subcloud %s, expires_at=%s" % (region_name, identity_token['expires_at'])) # Reset the cached dictionary OpenStackDriver.os_clients_dict[region_name] = \ collections.defaultdict(dict) return False keystone.tokens.validate( OpenStackDriver._identity_tokens[region_name]) except Exception as exception: LOG.info('_is_token_valid handle: %s', exception.message) # Reset the cached dictionary OpenStackDriver.os_clients_dict[region_name] = \ collections.defaultdict(dict) OpenStackDriver._identity_tokens[region_name] = None return False identity_token = OpenStackDriver._identity_tokens[region_name] expiry_time = timeutils.normalize_time( timeutils.parse_isotime(identity_token['expires_at'])) if timeutils.is_soon(expiry_time, STALE_TOKEN_DURATION): LOG.info("The cached keystone token for subcloud %s will " "expire soon %s" % (region_name, identity_token['expires_at'])) # Reset the cached dictionary OpenStackDriver.os_clients_dict[region_name] = \ collections.defaultdict(dict) OpenStackDriver._identity_tokens[region_name] = None return False else: return True
def run_periodic_tasks(self, context, raise_on_error=False): """Tasks to be run at a periodic interval.""" idle_for = DEFAULT_INTERVAL for task_name, task in self._periodic_tasks: # pylint: disable=no-member full_task_name = '.'.join([self.__class__.__name__, task_name]) now = timeutils.utcnow() spacing = self._periodic_spacing[task_name] # pylint: disable=no-member last_run = self._periodic_last_run[task_name] # pylint: disable=no-member # If a periodic task is _nearly_ due, then we'll run it early if spacing is not None and last_run is not None: due = last_run + datetime.timedelta(seconds=spacing) if not timeutils.is_soon(due, 0.2): idle_for = min(idle_for, timeutils.delta_seconds(now, due)) continue if spacing is not None: idle_for = min(idle_for, spacing) LOG.debug(_("Running periodic task %(full_task_name)s"), {"full_task_name": full_task_name}) self._periodic_last_run[task_name] = timeutils.utcnow() # pylint: disable=no-member try: task(self, context) except Exception as e: if raise_on_error: raise LOG.exception(_("Error during %(full_task_name)s: %(e)s"), { "full_task_name": full_task_name, "e": e }) time.sleep(0) return idle_for