mirror of https://github.com/jumpserver/jumpserver
296 lines
8.9 KiB
Python
296 lines
8.9 KiB
Python
# -*- coding: utf-8 -*-
|
|
#
|
|
import re
|
|
from collections import OrderedDict
|
|
from itertools import chain
|
|
import logging
|
|
import datetime
|
|
import uuid
|
|
from functools import wraps
|
|
import copy
|
|
import ipaddress
|
|
|
|
|
|
UUID_PATTERN = re.compile(r'[0-9a-zA-Z\-]{36}')
|
|
ipip_db = None
|
|
|
|
|
|
def combine_seq(s1, s2, callback=None):
|
|
for s in (s1, s2):
|
|
if not hasattr(s, '__iter__'):
|
|
return []
|
|
|
|
seq = chain(s1, s2)
|
|
if callback:
|
|
seq = map(callback, seq)
|
|
return seq
|
|
|
|
|
|
def get_logger(name=None):
|
|
return logging.getLogger('jumpserver.%s' % name)
|
|
|
|
|
|
def timesince(dt, since='', default="just now"):
|
|
"""
|
|
Returns string representing "time since" e.g.
|
|
3 days, 5 hours.
|
|
"""
|
|
|
|
if since is '':
|
|
since = datetime.datetime.utcnow()
|
|
|
|
if since is None:
|
|
return default
|
|
|
|
diff = since - dt
|
|
|
|
periods = (
|
|
(diff.days / 365, "year", "years"),
|
|
(diff.days / 30, "month", "months"),
|
|
(diff.days / 7, "week", "weeks"),
|
|
(diff.days, "day", "days"),
|
|
(diff.seconds / 3600, "hour", "hours"),
|
|
(diff.seconds / 60, "minute", "minutes"),
|
|
(diff.seconds, "second", "seconds"),
|
|
)
|
|
|
|
for period, singular, plural in periods:
|
|
if period:
|
|
return "%d %s" % (period, singular if period == 1 else plural)
|
|
return default
|
|
|
|
|
|
def setattr_bulk(seq, key, value):
|
|
def set_attr(obj):
|
|
setattr(obj, key, value)
|
|
return obj
|
|
return map(set_attr, seq)
|
|
|
|
|
|
def set_or_append_attr_bulk(seq, key, value):
|
|
for obj in seq:
|
|
ori = getattr(obj, key, None)
|
|
if ori:
|
|
value += " " + ori
|
|
setattr(obj, key, value)
|
|
|
|
|
|
def capacity_convert(size, expect='auto', rate=1000):
|
|
"""
|
|
:param size: '100MB', '1G'
|
|
:param expect: 'K, M, G, T
|
|
:param rate: Default 1000, may be 1024
|
|
:return:
|
|
"""
|
|
rate_mapping = (
|
|
('K', rate),
|
|
('KB', rate),
|
|
('M', rate**2),
|
|
('MB', rate**2),
|
|
('G', rate**3),
|
|
('GB', rate**3),
|
|
('T', rate**4),
|
|
('TB', rate**4),
|
|
)
|
|
|
|
rate_mapping = OrderedDict(rate_mapping)
|
|
|
|
std_size = 0 # To KB
|
|
for unit in rate_mapping:
|
|
if size.endswith(unit):
|
|
try:
|
|
std_size = float(size.strip(unit).strip()) * rate_mapping[unit]
|
|
except ValueError:
|
|
pass
|
|
|
|
if expect == 'auto':
|
|
for unit, rate_ in rate_mapping.items():
|
|
if rate > std_size/rate_ > 1:
|
|
expect = unit
|
|
break
|
|
|
|
if expect not in rate_mapping:
|
|
expect = 'K'
|
|
|
|
expect_size = std_size / rate_mapping[expect]
|
|
return expect_size, expect
|
|
|
|
|
|
def sum_capacity(cap_list):
|
|
total = 0
|
|
for cap in cap_list:
|
|
size, _ = capacity_convert(cap, expect='K')
|
|
total += size
|
|
total = '{} K'.format(total)
|
|
return capacity_convert(total, expect='auto')
|
|
|
|
|
|
def get_short_uuid_str():
|
|
return str(uuid.uuid4()).split('-')[-1]
|
|
|
|
|
|
def is_uuid(seq):
|
|
if isinstance(seq, str):
|
|
if UUID_PATTERN.match(seq):
|
|
return True
|
|
else:
|
|
return False
|
|
else:
|
|
for s in seq:
|
|
if not is_uuid(s):
|
|
return False
|
|
return True
|
|
|
|
|
|
def get_request_ip(request):
|
|
x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR', '').split(',')
|
|
|
|
if x_forwarded_for and x_forwarded_for[0]:
|
|
login_ip = x_forwarded_for[0]
|
|
else:
|
|
login_ip = request.META.get('REMOTE_ADDR', '')
|
|
return login_ip
|
|
|
|
|
|
def validate_ip(ip):
|
|
try:
|
|
ipaddress.ip_address(ip)
|
|
return True
|
|
except ValueError:
|
|
pass
|
|
return False
|
|
|
|
|
|
def with_cache(func):
|
|
cache = {}
|
|
key = "_{}.{}".format(func.__module__, func.__name__)
|
|
|
|
@wraps(func)
|
|
def wrapper(*args, **kwargs):
|
|
cached = cache.get(key)
|
|
if cached:
|
|
return cached
|
|
res = func(*args, **kwargs)
|
|
cache[key] = res
|
|
return res
|
|
return wrapper
|
|
|
|
|
|
class LocalProxy(object):
|
|
|
|
"""
|
|
Copy from werkzeug.local.LocalProxy
|
|
"""
|
|
__slots__ = ('__local', '__dict__', '__name__', '__wrapped__')
|
|
|
|
def __init__(self, local, name=None):
|
|
object.__setattr__(self, '_LocalProxy__local', local)
|
|
object.__setattr__(self, '__name__', name)
|
|
if callable(local) and not hasattr(local, '__release_local__'):
|
|
# "local" is a callable that is not an instance of Local or
|
|
# LocalManager: mark it as a wrapped function.
|
|
object.__setattr__(self, '__wrapped__', local)
|
|
|
|
def _get_current_object(self):
|
|
"""Return the current object. This is useful if you want the real
|
|
object behind the proxy at a time for performance reasons or because
|
|
you want to pass the object into a different context.
|
|
"""
|
|
if not hasattr(self.__local, '__release_local__'):
|
|
return self.__local()
|
|
try:
|
|
return getattr(self.__local, self.__name__)
|
|
except AttributeError:
|
|
raise RuntimeError('no object bound to %s' % self.__name__)
|
|
|
|
@property
|
|
def __dict__(self):
|
|
try:
|
|
return self._get_current_object().__dict__
|
|
except RuntimeError:
|
|
raise AttributeError('__dict__')
|
|
|
|
def __repr__(self):
|
|
try:
|
|
obj = self._get_current_object()
|
|
except RuntimeError:
|
|
return '<%s unbound>' % self.__class__.__name__
|
|
return repr(obj)
|
|
|
|
def __bool__(self):
|
|
try:
|
|
return bool(self._get_current_object())
|
|
except RuntimeError:
|
|
return False
|
|
|
|
def __dir__(self):
|
|
try:
|
|
return dir(self._get_current_object())
|
|
except RuntimeError:
|
|
return []
|
|
|
|
def __getattr__(self, name):
|
|
if name == '__members__':
|
|
return dir(self._get_current_object())
|
|
return getattr(self._get_current_object(), name)
|
|
|
|
def __setitem__(self, key, value):
|
|
self._get_current_object()[key] = value
|
|
|
|
def __delitem__(self, key):
|
|
del self._get_current_object()[key]
|
|
|
|
__setattr__ = lambda x, n, v: setattr(x._get_current_object(), n, v)
|
|
__delattr__ = lambda x, n: delattr(x._get_current_object(), n)
|
|
__str__ = lambda x: str(x._get_current_object())
|
|
__lt__ = lambda x, o: x._get_current_object() < o
|
|
__le__ = lambda x, o: x._get_current_object() <= o
|
|
__eq__ = lambda x, o: x._get_current_object() == o
|
|
__ne__ = lambda x, o: x._get_current_object() != o
|
|
__gt__ = lambda x, o: x._get_current_object() > o
|
|
__ge__ = lambda x, o: x._get_current_object() >= o
|
|
__cmp__ = lambda x, o: cmp(x._get_current_object(), o) # noqa
|
|
__hash__ = lambda x: hash(x._get_current_object())
|
|
__call__ = lambda x, *a, **kw: x._get_current_object()(*a, **kw)
|
|
__len__ = lambda x: len(x._get_current_object())
|
|
__getitem__ = lambda x, i: x._get_current_object()[i]
|
|
__iter__ = lambda x: iter(x._get_current_object())
|
|
__contains__ = lambda x, i: i in x._get_current_object()
|
|
__add__ = lambda x, o: x._get_current_object() + o
|
|
__sub__ = lambda x, o: x._get_current_object() - o
|
|
__mul__ = lambda x, o: x._get_current_object() * o
|
|
__floordiv__ = lambda x, o: x._get_current_object() // o
|
|
__mod__ = lambda x, o: x._get_current_object() % o
|
|
__divmod__ = lambda x, o: x._get_current_object().__divmod__(o)
|
|
__pow__ = lambda x, o: x._get_current_object() ** o
|
|
__lshift__ = lambda x, o: x._get_current_object() << o
|
|
__rshift__ = lambda x, o: x._get_current_object() >> o
|
|
__and__ = lambda x, o: x._get_current_object() & o
|
|
__xor__ = lambda x, o: x._get_current_object() ^ o
|
|
__or__ = lambda x, o: x._get_current_object() | o
|
|
__div__ = lambda x, o: x._get_current_object().__div__(o)
|
|
__truediv__ = lambda x, o: x._get_current_object().__truediv__(o)
|
|
__neg__ = lambda x: -(x._get_current_object())
|
|
__pos__ = lambda x: +(x._get_current_object())
|
|
__abs__ = lambda x: abs(x._get_current_object())
|
|
__invert__ = lambda x: ~(x._get_current_object())
|
|
__complex__ = lambda x: complex(x._get_current_object())
|
|
__int__ = lambda x: int(x._get_current_object())
|
|
__float__ = lambda x: float(x._get_current_object())
|
|
__oct__ = lambda x: oct(x._get_current_object())
|
|
__hex__ = lambda x: hex(x._get_current_object())
|
|
__index__ = lambda x: x._get_current_object().__index__()
|
|
__coerce__ = lambda x, o: x._get_current_object().__coerce__(x, o)
|
|
__enter__ = lambda x: x._get_current_object().__enter__()
|
|
__exit__ = lambda x, *a, **kw: x._get_current_object().__exit__(*a, **kw)
|
|
__radd__ = lambda x, o: o + x._get_current_object()
|
|
__rsub__ = lambda x, o: o - x._get_current_object()
|
|
__rmul__ = lambda x, o: o * x._get_current_object()
|
|
__rdiv__ = lambda x, o: o / x._get_current_object()
|
|
__rtruediv__ = __rdiv__
|
|
__rfloordiv__ = lambda x, o: o // x._get_current_object()
|
|
__rmod__ = lambda x, o: o % x._get_current_object()
|
|
__rdivmod__ = lambda x, o: x._get_current_object().__rdivmod__(o)
|
|
__copy__ = lambda x: copy.copy(x._get_current_object())
|
|
__deepcopy__ = lambda x, memo: copy.deepcopy(x._get_current_object(), memo)
|