def nextEvent(self, checkFrom=None, startEvent=True, offset=None):
"""
Returns next event for this interval
Returns a list of two elements. First is datetime of event begining, second is timedelta of duration
"""
logger.debug('Obtaining nextEvent')
if checkFrom is None:
checkFrom = getSqlDatetime()
if offset is None:
offset = datetime.timedelta(minutes=0)
cacheKey = str(hash(self.calendar.modified)) + self.calendar.uuid + str(
offset.seconds) + str(int(time.mktime(checkFrom.timetuple()))) + 'event' + ('x' if startEvent is True else '_')
next_event = CalendarChecker.cache.get(cacheKey, None)
if next_event is None:
logger.debug('Regenerating cached nextEvent')
next_event = self._updateEvents(checkFrom + offset,
startEvent) # We substract on checkin, so we can take into account for next execution the "offset" on start & end (just the inverse of current, so we substract it)
if next_event is not None:
next_event += offset
CalendarChecker.cache.put(cacheKey, next_event, 3600)
else:
logger.debug('nextEvent cache hit')
CalendarChecker.hits += 1
return next_event
def get(self,
skey: typing.Union[str, bytes],
defValue: typing.Any = None) -> typing.Any:
now: datetime = typing.cast(datetime, getSqlDatetime())
# logger.debug('Requesting key "%s" for cache "%s"', skey, self._owner)
try:
key = self.__getKey(skey)
# logger.debug('Key: %s', key)
c: DBCache = DBCache.objects.get(pk=key) # @UndefinedVariable
# If expired
if now > c.created + timedelta(seconds=c.validity):
return defValue
try:
# logger.debug('value: %s', c.value)
val = pickle.loads(
typing.cast(bytes, encoders.decode(c.value, 'base64')))
except Exception: # If invalid, simple do no tuse it
logger.exception('Invalid pickle from cache. Removing it.')
c.delete()
return defValue
Cache.hits += 1
return val
except DBCache.DoesNotExist: # @UndefinedVariable
Cache.misses += 1
# logger.debug('key not found: %s', skey)
return defValue
except Exception:
Cache.misses += 1
# logger.debug('Cache inaccesible: %s:%s', skey, e)
return defValue
def put(self,
skey: typing.Union[str, bytes],
value: typing.Any,
validity: typing.Optional[int] = None) -> None:
# logger.debug('Saving key "%s" for cache "%s"' % (skey, self._owner,))
if validity is None:
validity = Cache.DEFAULT_VALIDITY
key = self.__getKey(skey)
value = typing.cast(
str, encoders.encode(pickle.dumps(value), 'base64', asText=True))
now: datetime = typing.cast(datetime, getSqlDatetime())
try:
DBCache.objects.create(owner=self._owner,
key=key,
value=value,
created=now,
validity=validity) # @UndefinedVariable
except Exception:
try:
# Already exists, modify it
c: DBCache = DBCache.objects.get(pk=key) # @UndefinedVariable
c.owner = self._owner
c.key = key
c.value = value
c.created = now
c.validity = validity
c.save()
except transaction.TransactionManagementError:
logger.debug('Transaction in course, cannot store value')
def check(self, dtime=None):
"""
Checks if the given time is a valid event on calendar
@param dtime: Datetime object to check
TODO: We can improve performance of this by getting from a cache first if we can
"""
if dtime is None:
dtime = getSqlDatetime()
# First, try to get data from cache if it is valid
cacheKey = str(hash(self.calendar.modified)) + str(dtime.date().toordinal()) + self.calendar.uuid + 'checker'
cached = CalendarChecker.cache.get(cacheKey, None)
if cached is not None:
data = bitarray.bitarray() # Empty bitarray
data.frombytes(cached)
CalendarChecker.cache_hit += 1
else:
data = self._updateData(dtime)
# Now data can be accessed as an array of booleans.
# Store data on persistent cache
CalendarChecker.cache.put(cacheKey, data.tobytes(), 3600 * 24)
return data[dtime.hour * 60 + dtime.minute]
def check(self, dtime=None):
"""
Checks if the given time is a valid event on calendar
@param dtime: Datetime object to check
"""
if dtime is None:
dtime = getSqlDatetime()
# memcached access
memCache = caches['memory']
# First, try to get data from cache if it is valid
cacheKey = (str(self.calendar.modified.toordinal()) +
str(dtime.date().toordinal()) + self.calendar.uuid +
'checker')
# First, check "local memory cache", and if not found, from DB cache
cached = memCache.get(cacheKey)
if not cached:
cached = CalendarChecker.cache.get(cacheKey, None)
if cached:
memCache.set(cacheKey, cached, ONE_DAY)
if cached:
data = bitarray.bitarray() # Empty bitarray
data.frombytes(cached)
CalendarChecker.cache_hit += 1
else:
data = self._updateData(dtime)
# Now data can be accessed as an array of booleans.
# Store data on persistent cache
CalendarChecker.cache.put(cacheKey, data.tobytes(), ONE_DAY)
memCache.set(cacheKey, data.tobytes(), ONE_DAY)
return data[dtime.hour * 60 + dtime.minute]
def deleteItem(self, parent: 'Calendar', item: str) -> None:
logger.debug('Deleting rule %s from %s', item, parent)
try:
calRule = parent.rules.get(uuid=processUuid(item))
calRule.calendar.modified = getSqlDatetime()
calRule.calendar.save()
calRule.delete()
except Exception:
logger.exception('Exception')
raise self.invalidItemException()
def refresh(self, skey: typing.Union[str, bytes]) -> None:
# logger.debug('Refreshing key "%s" for cache "%s"' % (skey, self._owner,))
try:
key = self.__getKey(skey)
c = DBCache.objects.get(pk=key) # @UndefinedVariable
c.created = getSqlDatetime()
c.save()
except DBCache.DoesNotExist: # @UndefinedVariable
logger.debug(
'Can\'t refresh cache key %s because it doesn\'t exists', skey)
return
def publish(self) -> str:
"""
Realizes the publication of the service
"""
self._name = 'Publication {}'.format(getSqlDatetime())
return State.FINISHED
def getLink( # pylint: disable=too-many-locals
self,
userService: 'models.UserService',
transport: 'models.Transport',
ip: str,
os: typing.Dict[str, str],
user: '******',
password: str,
request: 'HttpRequest',
) -> str:
credsInfo = self.processUserAndPassword(userService, user, password)
username, password, domain = (
credsInfo['username'],
credsInfo['password'],
credsInfo['domain'],
)
scrambler = cryptoManager().randomString(32)
passwordCrypted = cryptoManager().symCrypt(password, scrambler)
# Build params dict
params = {
'protocol': 'rdp',
'hostname': ip,
'username': username,
'password': passwordCrypted,
'resize-method': 'display-update',
'ignore-cert': 'true',
'security': self.security.value,
'drive-path': '/share/{}'.format(user.uuid),
'create-drive-path': 'true',
}
if False: # Future imp
sanitize = lambda x: re.sub("[^a-zA-Z0-9_-]", "_", x)
params['recording-path'] = (
'/share/recording/' + sanitize(user.manager.name) + '_' +
sanitize(user.name) + '/' +
getSqlDatetime().strftime('%Y%m%d-%H%M'))
params['create-recording-path'] = 'true'
if domain:
params['domain'] = domain
if self.enableFileSharing.value == 'true':
params['enable-drive'] = 'true'
elif self.enableFileSharing.value == 'down':
params['enable-drive'] = 'true'
params['disable-upload'] = 'true'
elif self.enableFileSharing.value == 'up':
params['enable-drive'] = 'true'
params['disable-download'] = 'true'
if self.serverLayout.value != '-':
params['server-layout'] = self.serverLayout.value
if not self.enableAudio.isTrue():
params['disable-audio'] = 'true'
elif self.enableAudioInput.isTrue():
params['enable-audio-input'] = 'true'
if self.enablePrinting.isTrue():
params['enable-printing'] = 'true'
params['printer-name'] = 'UDS-Printer'
if self.wallpaper.isTrue():
params['enable-wallpaper'] = 'true'
if self.desktopComp.isTrue():
params['enable-desktop-composition'] = 'true'
if self.smooth.isTrue():
params['enable-font-smoothing'] = 'true'
logger.debug('RDP Params: %s', params)
ticket = models.TicketStore.create(params,
validity=self.ticketValidity.num())
onw = ('&o_n_w={};'.format(hash(transport.name))
if self.forceNewWindow.isTrue() else '')
return str("{}/guacamole/#/?data={}.{}{}".format(
self.guacamoleServer.value, ticket, scrambler, onw))
