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()
