def _trigger_on_user_modified(self, user):
if isinstance(user, basestring):
# user id
users = []
try:
session_ids = self._sessionids_by_userid[user]
for session_id in session_ids:
try:
users.append(
self._session_users_by_session[session_id])
except KeyError:
# unknown session id
continue
except KeyError:
# no session for user
return
elif isinstance(user, User) and not isinstance(user, SessionUser):
users = self.find_sessions_for(
lambda u: u.get_id() == user.get_id())
elif isinstance(user, User):
users = [user]
else:
return
for listener in self._login_status_listeners:
try:
for user in users:
listener.on_user_modified(user)
except Exception:
self._logger.exception(
"Error in on_user_modified on {!r}".format(listener),
extra=dict(callback=fqcn(listener)))
def login_user(self, user):
self._cleanup_sessions()
if user is None or user.is_anonymous:
return
if isinstance(user, LocalProxy):
# noinspection PyProtectedMember
user = user._get_current_object()
if not isinstance(user, User):
return None
if not isinstance(user, SessionUser):
user = SessionUser(user)
self._session_users_by_session[user.session] = user
userid = user.get_id()
if not userid in self._sessionids_by_userid:
self._sessionids_by_userid[userid] = set()
self._sessionids_by_userid[userid].add(user.session)
for listener in self._login_status_listeners:
try:
listener.on_user_logged_in(user)
except Exception:
self._logger.exception(
"Error in on_user_logged_in on {!r}".format(listener),
extra=dict(callback=fqcn(listener)))
self._logger.info("Logged in user: {}".format(user.get_id()))
return user
def _trigger_on_user_removed(self, username):
for listener in self._login_status_listeners:
try:
listener.on_user_removed(username)
except Exception:
self._logger.exception("Error in on_user_removed on {!r}".format(listener),
extra=dict(callback=fqcn(listener)))
def logout_user(self, user, stale=False):
if user is None or user.is_anonymous or isinstance(user, AdminUser):
return
if isinstance(user, LocalProxy):
user = user._get_current_object()
if not isinstance(user, SessionUser):
return
userid = user.get_id()
sessionid = user.session
if userid in self._sessionids_by_userid:
try:
self._sessionids_by_userid[userid].remove(sessionid)
except KeyError:
pass
if sessionid in self._session_users_by_session:
try:
del self._session_users_by_session[sessionid]
except KeyError:
pass
for listener in self._login_status_listeners:
try:
listener.on_user_logged_out(user, stale=stale)
except Exception:
self._logger.exception(
"Error in on_user_logged_out on {!r}".format(listener),
extra=dict(callback=fqcn(listener)))
self._logger.info("Logged out user: {}".format(user.get_id()))
def on_slicing_progress(self, slicer, source_location, source_path, dest_location, dest_path, _progress=None):
if not _progress:
return
progress_int = int(_progress * 100)
if self._last_slicing_progress != progress_int:
self._last_slicing_progress = progress_int
for callback in self._slicing_progress_callbacks:
try:
callback.sendSlicingProgress(slicer, source_location, source_path, dest_location, dest_path, progress_int)
except Exception:
self._logger.exception("Exception while pushing slicing progress",
extra=dict(callback=fqcn(callback)))
if progress_int:
def call_plugins(slicer, source_location, source_path, dest_location, dest_path, progress):
for plugin in self._progress_plugins:
try:
plugin.on_slicing_progress(slicer, source_location, source_path, dest_location, dest_path, progress)
except Exception:
self._logger.exception("Exception while sending slicing progress to plugin %s" % plugin._identifier,
extra=dict(plugin=plugin._identifier))
import threading
thread = threading.Thread(target=call_plugins, args=(slicer, source_location, source_path, dest_location, dest_path, progress_int))
thread.daemon = False
thread.start()
def login_user(self, user):
self._cleanup_sessions()
if user is None:
return
if isinstance(user, LocalProxy):
user = user._get_current_object()
if not isinstance(user, User):
return None
if not isinstance(user, SessionUser):
user = SessionUser(user)
self._session_users_by_session[user.session] = user
userid = user.get_id()
if not userid in self._sessionids_by_userid:
self._sessionids_by_userid[userid] = set()
self._sessionids_by_userid[userid].add(user.session)
self._logger.debug("Logged in user: %r" % user)
for callback in self._callbacks:
try:
callback("login", user)
except:
self._logger.exception(
"Error while calling login callback {!r}".format(callback),
extra=dict(callback=fqcn(callback)))
return user
def logout_user(self, user):
if user is None:
return
if isinstance(user, LocalProxy):
user = user._get_current_object()
if not isinstance(user, SessionUser):
return
userid = user.get_id()
sessionid = user.session
if userid in self._sessionids_by_userid:
try:
self._sessionids_by_userid[userid].remove(sessionid)
except KeyError:
pass
if sessionid in self._session_users_by_session:
del self._session_users_by_session[sessionid]
self._logger.debug("Logged out user: %r" % user)
for callback in self._callbacks:
try:
callback("logout", user)
except:
self._logger.exception(
"Error while calling logout callback {!r}".format(
callback),
extra=dict(callback=fqcn(callback)))
def on_group_permissions_changed(self, group, added=None, removed=None):
users = self.find_sessions_for(lambda u: group in u.groups)
for listener in self._login_status_listeners:
try:
for user in users:
listener.on_user_modified(user)
except Exception:
self._logger.exception("Error in on_user_modified on {!r}".format(listener),
extra=dict(callback=fqcn(listener)))
def _trigger_on_user_removed(self, username):
for listener in self._login_status_listeners:
try:
listener.on_user_removed(username)
except Exception:
self._logger.exception(
f"Error in on_user_removed on {listener!r}",
extra={"callback": fqcn(listener)},
)
def notify_callback(callback, config=None, timelapse=None):
if config is None and timelapse is not None:
config = timelapse.config_data()
try:
callback.sendTimelapseConfig(config)
except Exception:
logging.getLogger(__name__).exception(
"Exception while pushing timelapse configuration",
extra=dict(callback=fqcn(callback)))
def on_group_subgroups_changed(self, group, added=None, removed=None):
users = self.find_sessions_for(lambda u: group in u.groups)
for listener in self._login_status_listeners:
# noinspection PyBroadException
try:
for user in users:
listener.on_user_modified(user)
except Exception:
self._logger.exception(
"Error in on_user_modified on {!r}".format(listener),
extra={"callback": fqcn(listener)},
)
def notify_callbacks(timelapse):
if timelapse is None:
config = None
else:
config = timelapse.config_data()
for callback in _update_callbacks:
try:
callback.sendTimelapseConfig(config)
except:
logging.getLogger(__name__).exception(
"Exception while pushing timelapse configuration",
extra=dict(callback=fqcn(callback)))
def _analysis_finished(self, entry, result):
for callback in self._callbacks:
try:
callback(entry, result)
except:
self._logger.exception(u"Error while pushing analysis data to callback {}".format(callback),
extra=dict(callback=fqcn(callback)))
eventManager().fire(Events.METADATA_ANALYSIS_FINISHED, {"name": entry.name,
"path": entry.path,
"origin": entry.location,
"result": result,
# TODO: deprecated, remove in a future release
"file": entry.path})
def login_user(self, user):
"""
This method logs in the user into OctoPrint using authorization OAuth2.
After that, user is added into users.yaml config file.
"""
self._cleanup_sessions()
if user is None or user.is_anonymous:
return
if isinstance(user, LocalProxy):
user = user._get_current_object()
return user
if not isinstance(user, User):
return None
# -- Overridden parts -----------------------------------------------
if isinstance(user, OAuth2PGCUser):
username = user.get_id()
user = FilebasedUserManager.find_user(self, username)
if user is None:
FilebasedUserManager.add_user(self, username, '', active=True)
user = FilebasedUserManager.find_user(self, username)
# -- Overridden parts -----------------------------------------------
if not isinstance(user, SessionUser):
user = SessionUser(user)
self._session_users_by_session[user.session] = user
user_id = user.get_id()
if user_id not in self._sessionids_by_userid:
self._sessionids_by_userid[user_id] = set()
self._sessionids_by_userid[user_id].add(user.session)
for listener in self._login_status_listeners:
try:
listener.on_user_logged_in(user)
except Exception:
self._logger.exception(
"Error in on_user_logged_in on {!r}".format(listener),
extra=dict(callback=fqcn(listener)))
self._logger.info("Logged in user: {}".format(user.get_id()))
return user
def _analysis_finished(self, entry, result):
for callback in self._callbacks:
try:
callback(entry, result)
except Exception:
self._logger.exception(
"Error while pushing analysis data to callback {}".format(callback),
extra={"callback": fqcn(callback)},
)
eventManager().fire(
Events.METADATA_ANALYSIS_FINISHED,
{
"name": entry.name,
"path": entry.path,
"origin": entry.location,
"result": result,
},
)
