def set_expiry(self, value): """ Set a custom expiration for the session. ``value`` can be an integer, a Python ``datetime`` or ``timedelta`` object or ``None``. If ``value`` is an integer, the session will expire after that many seconds of inactivity. If set to ``0`` then the session will expire on browser close. If ``value`` is a ``datetime`` or ``timedelta`` object, the session will expire at that specific future time. If ``value`` is ``None``, the session uses the global session expiry policy. """ if value is None: # Remove any custom expiration for this session. try: del self['_session_expiry'] except KeyError: pass return if isinstance(value, timedelta): value = timezone.now() + value self['_session_expiry'] = value
def get_expiry_age(self, **kwargs): """ Get the number of seconds until the session expires. Optionally, this function accepts `modification` and `expiry` keyword arguments specifying the modification and expiry of the session. """ try: modification = kwargs['modification'] except KeyError: modification = timezone.now() # Make the difference between "expiry=None passed in kwargs" and # "expiry not passed in kwargs", in order to guarantee not to trigger # self.load() when expiry is provided. try: expiry = kwargs['expiry'] except KeyError: expiry = self.get('_session_expiry') if not expiry: # Checks both None and 0 cases return settings.SESSION_COOKIE_AGE if not isinstance(expiry, datetime): return expiry delta = expiry - modification return delta.days * 86400 + delta.seconds
def result(self) -> list: if timezone.now() < self.start_at: raise VotingError('Voting not started') if self.anonymous: return [m.result for m in self.memderships] else: return [(m.result, m.user_id) for m in self.memderships]
async def on_start(self) -> None: await self.setup_app_version() await self.check_updates() await self.internal_connection.connect() self.start_celery() self.updates_checker.start() self.started_at = timezone.now() # TODO: already started? logger.info('Service `%s` started.' % self.name)
def _get_session_from_db(self): try: return self.model.query.filter( self.model.session_key == self.session_key, self.model.expire_date > timezone.now()).first() except Exception as e: logger.warning(str(e)) self._session_key = None
def create_object(self): group_id = self.get_argument('group_id', None) now = timezone.now() file = self.create_backup(now) kwargs = { 'group_id': group_id, 'created': now, 'file': file, } return Backup.create(**kwargs)
def heartbeat(self, report: Union[HeartbeatReport, RequestError]): if isinstance(report, RequestError): self.status = 'failed' self.last_failure_tb = traceback.format_tb(report.__traceback__) elif isinstance(report, HeartbeatReport): self.last_heartbeat = timezone.now() self.cpu_load = report.cpu_load self.ram_usage = report.ram_usage self.status = 'overload' if report.is_overload() else 'active' else: raise ValueError('`report` argument should be either instance of' 'HeartbeatReport or RequestError') self.save()
def run(self, is_active=True) -> Event: """Generates new event.""" self.last_run_at = timezone.now() self.total_run_count += 1 self.save() kwargs = { 'name': None, # TODO: auto 'category_id': self.category_id, 'start_at': self.start_at, 'finish_at': self.finish_at, 'payload': self.payload, 'is_active': is_active, 'generator_id': self.id, } return Event.create(**kwargs)
def run(self, *args, **kwargs): subject = 'Test email from %s on %s' % (socket.gethostname(), timezone.now()) send_mail( subject=subject, message="If you\'re reading this, it was successful.", from_email=None, recipient_list=kwargs['email'], ) if kwargs['managers']: mail_managers(subject, "This email was sent to the site managers.") if kwargs['admins']: mail_admins(subject, "This email was sent to the site admins.")
def get_expiry_date(self, **kwargs): """ Get session the expiry date (as a datetime object). Optionally, this function accepts `modification` and `expiry` keyword arguments specifying the modification and expiry of the session. """ try: modification = kwargs['modification'] except KeyError: modification = timezone.now() # Same comment as in get_expiry_age try: expiry = kwargs['expiry'] except KeyError: expiry = self.get('_session_expiry') if isinstance(expiry, datetime): return expiry expiry = expiry or settings.SESSION_COOKIE_AGE # Checks both None and 0 cases return modification + timedelta(seconds=expiry)
def start_in(self) -> Optional[timedelta]: if self.start_at >= timezone.now(): return self.start_at - timezone.now()
def finished(self) -> bool: return self.finish_at < timezone.now()
def started(self) -> bool: return self.start_at >= timezone.now()
def finish_in(self) -> Optional[timedelta]: if self.time_limited: return self.finish_at - timezone.now()
def finished(self) -> bool: if self.time_limited: return self.finish_at <= timezone.now() return True
def check_for_timeout(self): if not self.is_finished and 0 < self.timeout < timezone.now() - self.started: raise TransactionTimeoutError
def expired(self): return timezone.now() < self.expires
def changed(cls, session, instance): if not instance.no_changes: obj, _ = cls.update_or_create( session, defaults={'last_update': timezone.now()}, ident=1) session.add(obj) session.commit()
def active(cls) -> bool: return db.and_(cls.created <= timezone.now(), cls.enabled)
def datetime(handler): from anthill.framework.utils import timezone return {'now': timezone.now()}
def active(self) -> bool: return self.finish_at > timezone.now() >= self.start_at and self.is_active
def expired(self): return self.expires <= timezone.now()
def finish_in(self) -> Optional[timedelta]: if self.finish_at >= timezone.now(): return self.finish_at - timezone.now()
def uptime(self): if self.started_at is not None: return timezone.now() - self.started_at
def get_traceback_data(self): """Return a dictionary containing traceback information.""" frames = self.get_traceback_frames() for i, frame in enumerate(frames): if 'vars' in frame: frame_vars = [] for k, v in frame['vars']: v = pprint(v) # Trim large blobs of data if len(v) > 4096: v = '%s... <trimmed %d bytes string>' % (v[0:4096], len(v)) frame_vars.append((k, v)) frame['vars'] = frame_vars frames[i] = frame unicode_hint = '' if self.exc_type and issubclass(self.exc_type, UnicodeError): start = getattr(self.exc_value, 'start', None) end = getattr(self.exc_value, 'end', None) if start is not None and end is not None: unicode_str = self.exc_value.args[1] unicode_hint = force_text( unicode_str[max(start - 5, 0):min(end + 5, len(unicode_str))], 'ascii', errors='replace') from anthill.framework import get_version context = { 'is_email': self.is_email, 'unicode_hint': unicode_hint, 'frames': frames, 'application': self.app, 'app_version': self.app.version, 'user_str': None, 'handler': None, 'request': None, 'sys_executable': sys.executable, 'sys_version_info': '%d.%d.%d' % sys.version_info[0:3], 'server_time': timezone.now(), 'sys_path': sys.path, 'tornado_version_info': tornado.version, 'anthill_framework_version_info': get_version(), 'exception_type': None, 'exception_value': None, 'headers': None, 'request_variables': None, } if self.handler: context['handler'] = self.handler context['request'] = self.handler.request context['request_variables'] = { k: self.handler.decode_argument(v[0]) for k, v in self.handler.request.arguments.items() } if self.handler.request is None: user_str = None else: try: user_str = str(self.handler.current_user) except Exception: user_str = '[unable to retrieve the current user]' context['user_str'] = user_str if self.exc_type: context['exception_type'] = self.exc_type.__name__ if self.exc_value: context['exception_value'] = str(self.exc_value) if frames: context['lastframe'] = frames[-1] return context
def clear_expired(cls): model = cls.get_model_class() model.query.filter(model.expire_date < timezone.now()).delete()
def active(cls) -> bool: return db.and_( cls.finish_at > timezone.now(), cls.start_at <= timezone.now(), cls.is_active )
def active(self): return self.enabled and self.created <= timezone.now()