Attachment #10536 for bug #52272

View | Details | Raw Unified | Return to bug 52272 | Differences between
Collapse All | Expand All




		except KeyError:
			CORE.info('Session %r not found' % (sessionid,))

	@classmethod
	def clean_sessions(cls):
		now = time.time()
		for sessionid, user in list(Ressource.sessions.items()):
			session = UMCP_Dispatcher.sessions.get(sessionid)
			if (not session or not session._requestid2response_queue) and user.timed_out(now):
				CORE.info('session %r timed out' % (sessionid,))
				Ressource.sessions.pop(user.sessionid, None)
		return True  # execute again!


class UploadManager(dict):


		self.username = username
		self.password = password
		self.saml = saml
		self._time_remaining = _session_timeout
		self.reset_timeout()
		self.data = data or {}

	def reset_timeout(self):
		self._timeout = time.time() + _session_timeout

	def timed_out(self, now):
		return self.session_end_time < now
		if self.saml is not None:
			return self.time_remaining
		return _session_timeout

	@property
	def session_end_time(self):
		if self.is_saml_user() and self.saml.response.not_on_or_after:
			return self.saml.response.not_on_or_after
		return self._timeout
		remaining.append(self._time_remaining)
		try:
			return min(remaining)
		except ValueError:  # no SAML, no client
			return 0

	def is_saml_user(self):
		# self.saml indicates that it was originally a

		else:
			return None

	def timed_out(self):
		return self.saml.timed_out()

	def __repr__(self):
		return '<User(%s, %s, %s)>' % (self.username, self.sessionid, self.saml is not None)


		self.data = response.ava
		self.username = u''.join(self.data['uid'])

	@property
	def time_remaining(self):
		if self.response.not_on_or_after == 0:
			return 0
		return int(self.response.not_on_or_after - time.time())

	def timed_out(self):
		if self.response.not_on_or_after == 0:
			return False
		return self.time_remaining < 0


traceback_pattern = re.compile(r'(Traceback.*most recent call|File.*line.*in.*\d)')



	def check_saml_session_validity(self):
		user = self.get_user()
		if user and user.saml is not None and user.timed_out(time.time()):
			raise UMC_HTTPError(UNAUTHORIZED)

	def set_cookies(self, *cookies, **kwargs):

		olduser = self.get_user()

		user = User(sessionid, username, password, saml or olduser and olduser.saml, kwargs)
		self._session_timeout_timer(user)

		self.sessions[sessionid] = user
		self.set_cookies(('UMCSessionId', sessionid), ('UMCUsername', username))
		return user

		if not value or value not in self.sessions:
			return
		user = self.sessions[value]
		if user.timed_out(time.time()):
			return
		return user

	def _session_timeout_timer(self, user):
		"""In order to avoid problems when the system time is changed (e.g.,
		via rdate), we register a timer event that counts down the session
		timeout second-wise."""

		# count down the remaining time
		user._time_remaining -= 1

		session = UMCP_Dispatcher.sessions.get(user.sessionid)
		if user._time_remaining <= 0 and (not session or not session._requestid2response_queue):
			self._log('info', 'session timed out')
			self.sessions.pop(user.sessionid, None)
			return

		# count down the timer second-wise (in order to avoid problems when
		# changing the system time, e.g. via rdate)
		notifier.timer_add(1000, lambda: self._session_timeout_timer(user))


class CPgeneric(Ressource):


			raise UMC_HTTPError(UNAUTHORIZED)
		info['username'] = user.username
		info['auth_type'] = user.saml and 'SAML'
		info['remaining'] = user.session_end_time - time.time()
		info['validity'] = user.session_validity
		return json.dumps({"status": 200, "result": info, "message": ""}).encode('ASCII')

	@cherrypy.expose

		CORE.info('CPAuth/auth/sso: got new auth request (%s:%s <=> %s)' % (get_ip_address(), remote.port, remote.name))

		user = self.get_user()
		if not user or not user.saml or user.timed_out(time.time()):
			# redirect user to login page in case he's not authenticated or his session timed out
			raise HTTPRedirect('/univention/saml/')


			notifier.init(notifier.GENERIC)
			notifier.dispatch.MIN_TIMER = get_int('umc/http/dispatch-interval', notifier.dispatch.MIN_TIMER)
			notifier.dispatcher_add(UMCP_Dispatcher.check_queue)
			notifier.timer_add(1000, UMCP_Dispatcher.clean_sessions)
			notifier.loop()
		except (SystemExit, KeyboardInterrupt) as exc:
			# stop the web server

Return to bug 52272