#!/usr/bin/env python3 """ Syncthing-GTK - Notifications Listens to syncing events on daemon and displays desktop notifications. """ from syncthing_gtk.tools import IS_GNOME, IS_WINDOWS DELAY = 5 # Display notification only after no file is downloaded for seconds ICON_DEF = "syncthing-gtk" ICON_ERR = "syncthing-gtk-error" HAS_DESKTOP_NOTIFY = False Notifications = None try: if not IS_WINDOWS: import gi gi.require_version('Notify', '0.7') from gi.repository import Notify HAS_DESKTOP_NOTIFY = True except ImportError: pass if HAS_DESKTOP_NOTIFY: import logging import os from syncthing_gtk.timermanager import TimerManager from syncthing_gtk.tools import _ # gettext function log = logging.getLogger("Notifications") class STNotification(): """ Basic class to track a notification and update its text """ ACT_DEFAULT = "default" ACT_IGNORE = "IGNORE" ACT_ACCEPT = "ACCEPT" app = None n = None id = None label = None def __init__(self, app, id, label=None): self.app = app self.id = id self.set_label(label) def set_label(self, label): self.label = label def clean(self): pass def close_notification(self): try: self.n.close_notification() except Exception: # If I can't close the notification, I don't care pass def cb_notification_closed(self, notif): self.n = None self.clean() def supports(self, caps, supported=True, unsupported=False): if IS_GNOME: return unsupported else: return supported def addactions(self, n, actions=[], clear=True): if not self.supports("actions"): return if clear: n.clear_actions() for act, label, cb, data in actions: n.add_action(act, label, cb, data) def show(self, n): try: n.show() except Exception: # Ignore all errors here, there is no way I can handle # everything what can be broken with notifications... pass def push(self, summary, body=None, **kwargs): icon = kwargs.get('icon', ICON_DEF) urg = kwargs.get('urg') actions = kwargs.get('actions', []) if not self.n: self.n = Notify.Notification.new(summary, body, icon) self.n.connect("closed", self.cb_notification_closed), else: self.n.update(summary, body, icon) if urg: self.n.set_urgency(urg) self.addactions(self.n, actions) self.show(self.n) class STNotificationDevice(STNotification): """Notification class to track a notification, which is related to a syncthing device""" def cb_accept(self, n, action, user_data): self.app.open_editor_device(self.id, self.label) def cb_ignore(self, n, action, user_data): self.app.add_ignored("ignoredDevices", self.id) def rejected(self): label_fb = self.label or self.id actions = [ (self.ACT_DEFAULT, _('Accept device "%s"') % label_fb, self.cb_accept, None), (self.ACT_ACCEPT, _('Accept device "%s"') % label_fb, self.cb_accept, None), (self.ACT_IGNORE, _('Ignore device "%s"') % label_fb, self.cb_ignore, None), ] summary = _("Unknown Device") body = _( 'Device "%s" is trying to connect to syncthing daemon.' % self.label) self.push(summary, body, actions=actions, urg=Notify.Urgency.CRITICAL) class STNotificationFolder(STNotification, TimerManager): """Notification class to track a notification, which is related to a syncthing folder""" syncing = False updated = set([]) deleted = set([]) updating = set([]) conflict = set([]) timer_id = "display" timer_delay = DELAY def __init__(self, app, id, label=None): TimerManager.__init__(self) STNotification.__init__(self, app, id, label) def set_label(self, label): if label: self.label = label elif self.id in self.app.folders: self.label = self.app.folders[self.id]["label"] def clean(self): self.syncing = False self.cancel_timer(self.timer_id) self.updated.clear() self.deleted.clear() self.updating.clear() def cb_accept(self, n, action, user_data): self.app.open_editor_folder(self.id, self.label, user_data) def cb_ignore(self, n, action, user_data): self.app.add_ignored("ignoredFolders", self.id) def rejected(self, nid): device = self.app.devices[nid].get_title() label_fb = self.label or self.id actions = [ (self.ACT_DEFAULT, _('Accept folder "%s"') % label_fb, self.cb_accept, nid), (self.ACT_ACCEPT, _('Accept folder "%s"') % label_fb, self.cb_accept, nid), (self.ACT_IGNORE, _('Ignore folder "%s"') % label_fb, self.cb_ignore, nid), ] markup_dev = self.supports("body-markup", "%s" % device, device) markup_fol = self.supports("body-markup", "%s" % label_fb, label_fb) summary = _("Folder rejected") body = _('Unexpected folder "%(folder)s" sent from device "%(device)s".') % { 'device': markup_dev, 'folder': markup_fol } self.push(summary, body, actions=actions, urg=Notify.Urgency.CRITICAL) def add_path(self, path, itm_finished=True): path_full = os.path.join( self.app.folders[self.id]["norm_path"], path) if itm_finished: if ".sync-conflict" in path and os.path.exists(path_full): # Updated or new conflict self.sync_conflict(path) elif path in self.updating: if os.path.exists(path_full): self.updated.add(path) else: self.deleted.add(path) self.updating.remove(path) if not self.timer_active(self.timer_id): self.timer(self.timer_id, self.timer_delay, self.display) else: self.updating.add(path) def display(self, finished=False): summary = "" body = "" filename = "" if finished: summary = _('Completed synchronization in "%s"') % ( self.label or self.id) else: summary = _('Updates in folder "%s"') % (self.label or self.id) if len(self.updated) == 1 and len(self.deleted) == 0: f_path = os.path.join( self.app.folders[self.id]["norm_path"], self.updated.pop()) filename = os.path.split(f_path)[-1] self.supports("body-hyperlinks", "%s" % ( f_path.encode('unicode-escape'), filename), f_path) body = _( "%(hostname)s: Downloaded '%(filename)s' to reflect remote changes.") elif len(self.updated) == 0 and len(self.deleted) == 1: f_path = os.path.join( self.app.folders[self.id]["norm_path"], self.deleted.pop()) filename = os.path.split(f_path)[-1] body = _( "%(hostname)s: Deleted '%(filename)s' to reflect remote changes.") elif len(self.deleted) == 0 and len(self.updated) > 0: body = _( "%(hostname)s: Downloaded %(updated)s files to reflect remote changes.") elif len(self.updated) == 0 and len(self.deleted) > 0: body = _( "%(hostname)s: Deleted %(deleted)s files to reflect remote changes.") elif len(self.deleted) > 0 and len(self.updated) > 0: body = _( "%(hostname)s: downloaded %(updated)s files and deleted %(deleted)s files to reflect remote changes.") elif len(self.conflict) > 0: # If we reached this point, there are only sync-conflicts updated # we don't want to have another notification return body = body % { 'hostname': self.app.get_local_name(), 'updated': len(self.updated), 'deleted': len(self.deleted), 'filename': (filename), } self.push(summary, body) def set_progress(self, progress): if progress < 1.0: self.syncing = True def finished(self): if len(self.deleted) + len(self.updating) + len(self.updated) > 0 \ or self.syncing: self.display(True) def sync_conflict(self, path): path_full = os.path.join( self.app.folders[self.id]["norm_path"], path) summary = _('Conflicting file in "%s"') % (self.label or self.id) text = _('Conflict in path "%s" detected.') % path_full n = Notify.Notification.new(summary, text, ICON_ERR) n.set_urgency(Notify.Urgency.CRITICAL) n.add_action(self.ACT_DEFAULT, _( "Open Conflicting file in filemanager"), self.cb_open_conflict, path_full) n.connect("closed", self.cb_sync_conflict_closed), self.conflict.add(n) self.show(n) def cb_sync_conflict_closed(self, notif): self.conflict.remove(notif) def cb_open_conflict(self, n, action, user_data): if user_data and os.path.exists(user_data): dirname = os.path.dirname(user_data) self.app.cb_browse_folder({'path': dirname}) class NotificationsCls(): """ Watches for filesystem changes and reports them to daemon """ def __init__(self, app, daemon): Notify.init("Syncthing GTK") # Prepare stuff self.app = app self.daemon = daemon self.notify_folders = {} self.notify_devices = {} # Make deep connection with daemon self.signals = [ self.daemon.connect("connected", self.cb_syncthing_connected) ] if self.app.config["notification_for_error"]: self.signals += [ self.daemon.connect("error", self.cb_syncthing_error), self.daemon.connect("folder-rejected", self.cb_syncthing_folder_rejected), self.daemon.connect("device-rejected", self.cb_syncthing_device_rejected) ] log.verbose("Error notifications enabled") if self.app.config["notification_for_update"]: self.signals += [ self.daemon.connect( 'item-started', self.cb_syncthing_item_started), self.daemon.connect( 'item-updated', self.cb_syncthing_item_updated), ] log.verbose("File update notifications enabled") if self.app.config["notification_for_folder"]: self.signals += [ self.daemon.connect( 'folder-sync-progress', self.cb_syncthing_folder_progress), self.daemon.connect( 'folder-sync-finished', self.cb_syncthing_folder_finished) ] log.verbose("Folder notifications enabled") def get_folder(self, folder_id, label=None): if folder_id not in self.notify_folders: self.notify_folders[folder_id] = STNotificationFolder( self.app, folder_id, label) return self.notify_folders[folder_id] def get_device(self, device_id, label=None): if device_id not in self.notify_devices: self.notify_devices[device_id] = STNotificationDevice( self.app, device_id, label) return self.notify_devices[device_id] def clear_notifications(self): # Clear download list and close related notifications for dct in [self.notify_devices, self.notify_folders]: for obj in dct.values(): obj.close_notification() dct = {} def kill(self, *a): """ Removes all event handlers and frees some stuff """ for s in self.signals: self.daemon.handler_disconnect(s) self.clear_notifications() log.info("Notifications killed") def cb_syncthing_connected(self, *a): self.clear_notifications() def cb_syncthing_error(self, daemon, message): summary = _('An error occurred in Syncthing!') n = Notify.Notification.new(summary, None, ICON_ERR) n.set_urgency(Notify.Urgency.CRITICAL) try: n.show() except Exception: pass def cb_syncthing_folder_rejected(self, daemon, device_id, folder_id, label): if device_id not in self.app.devices: return n = self.get_folder(folder_id, label) n.rejected(device_id) def cb_syncthing_device_rejected(self, daemon, nid, name, address): n = self.get_device(nid, name) n.rejected() def cb_syncthing_item_started(self, daemon, folder_id, path, time): n = self.get_folder(folder_id) n.add_path(path, itm_finished=False) def cb_syncthing_item_updated(self, daemon, folder_id, path, *a): n = self.get_folder(folder_id) n.add_path(path) def cb_syncthing_folder_progress(self, daemon, folder_id, progress): n = self.get_folder(folder_id) n.set_progress(progress) def cb_syncthing_folder_finished(self, daemon, folder_id): n = self.get_folder(folder_id) n.finished() # Notifications is set to class only if libnotify is available Notifications = NotificationsCls """ Events emitted when file is changed on remote node: ItemStarted repo_name, path, time LocalIndexUpdated (item-updated) repo_name, path, time """