# # Copyright (C) 2007-2009 Andrew Resch # # This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with # the additional special exception to link portions of this program with the OpenSSL library. # See LICENSE for more details. # import logging import os from socket import gaierror, getaddrinfo from urllib.parse import urlparse from gi.repository import Gtk from twisted.internet import defer, reactor import deluge.component as component from deluge.common import resource_filename, windows_check from deluge.configmanager import ConfigManager, get_config_dir from deluge.error import AuthenticationRequired, BadLoginError, IncompatibleClient from deluge.ui.client import Client, client from deluge.ui.hostlist import DEFAULT_PORT, LOCALHOST, HostList from .common import get_clipboard_text from .dialogs import AuthenticationDialog, ErrorDialog log = logging.getLogger(__name__) HOSTLIST_COL_ID = 0 HOSTLIST_COL_HOST = 1 HOSTLIST_COL_PORT = 2 HOSTLIST_COL_USER = 3 HOSTLIST_COL_PASS = 4 HOSTLIST_COL_STATUS = 5 HOSTLIST_COL_VERSION = 6 HOSTLIST_COL_STATUS_I18N = 7 HOSTLIST_ICONS = { 'offline': 'action-unavailable-symbolic', 'online': 'network-server-symbolic', 'connected': 'network-transmit-receive-symbolic', } STATUS_I18N = { 'offline': _('Offline'), 'online': _('Online'), 'connected': _('Connected'), } def cell_render_host(column, cell, model, row, data): host, port, username = model.get(row, *data) text = host + ':' + str(port) if username: text = username + '@' + text cell.set_property('text', text) def cell_render_status_icon(column, cell, model, row, data): status = model[row][data] status = status if status else 'offline' icon_name = HOSTLIST_ICONS.get(status, None) cell.set_property('icon-name', icon_name) class ConnectionManager(component.Component): def __init__(self): component.Component.__init__(self, 'ConnectionManager') self.gtkui_config = ConfigManager('gtk3ui.conf') self.hostlist = HostList() self.running = False # Component overrides def start(self): pass def stop(self): # Close this dialog when we are shutting down if self.running: self.connection_manager.response(Gtk.ResponseType.CLOSE) def shutdown(self): pass # Public methods def show(self): """Show the ConnectionManager dialog.""" self.builder = Gtk.Builder() self.builder.add_from_file( resource_filename( __package__, os.path.join('glade', 'connection_manager.ui') ) ) self.connection_manager = self.builder.get_object('connection_manager') self.connection_manager.set_transient_for(component.get('MainWindow').window) # Setup the hostlist liststore and treeview self.treeview = self.builder.get_object('treeview_hostlist') self.treeview.set_tooltip_column(HOSTLIST_COL_STATUS_I18N) self.liststore = self.builder.get_object('liststore_hostlist') render = Gtk.CellRendererPixbuf() column = Gtk.TreeViewColumn(_('Status'), render) column.set_cell_data_func(render, cell_render_status_icon, HOSTLIST_COL_STATUS) self.treeview.append_column(column) render = Gtk.CellRendererText() column = Gtk.TreeViewColumn(_('Host'), render, text=HOSTLIST_COL_HOST) host_data = (HOSTLIST_COL_HOST, HOSTLIST_COL_PORT, HOSTLIST_COL_USER) column.set_cell_data_func(render, cell_render_host, host_data) column.set_expand(True) self.treeview.append_column(column) column = Gtk.TreeViewColumn( _('Version'), Gtk.CellRendererText(), text=HOSTLIST_COL_VERSION ) self.treeview.append_column(column) # Load any saved host entries self._load_liststore() # Set widgets to values from gtkui config. self._load_widget_config() self._update_widget_buttons() # Connect the signals to the handlers self.builder.connect_signals(self) self.treeview.get_selection().connect( 'changed', self.on_hostlist_selection_changed ) # Set running True before update status call. self.running = True if windows_check(): # Call to simulate() required to workaround showing daemon status (see #2813) reactor.simulate() self._update_host_status() # Trigger the on_selection_changed code and select the first host if possible self.treeview.get_selection().unselect_all() if len(self.liststore): self.treeview.get_selection().select_path(0) # Run the dialog self.connection_manager.run() # Dialog closed so cleanup. self.running = False self.connection_manager.destroy() del self.builder del self.connection_manager del self.liststore del self.treeview def _load_liststore(self): """Load saved host entries""" for host_entry in self.hostlist.get_hosts_info(): host_id, host, port, username = host_entry self.liststore.append([host_id, host, port, username, '', '', '', '']) def _load_widget_config(self): """Set the widgets to show the correct options from the config.""" self.builder.get_object('chk_autoconnect').set_active( self.gtkui_config['autoconnect'] ) self.builder.get_object('chk_autostart').set_active( self.gtkui_config['autostart_localhost'] ) self.builder.get_object('chk_donotshow').set_active( not self.gtkui_config['show_connection_manager_on_start'] ) def _update_host_status(self): """Updates the host status""" if not self.running: # Callback likely fired after the window closed. return def on_host_status(status_info, row): if self.running and row: status = status_info[1].lower() row[HOSTLIST_COL_STATUS] = status row[HOSTLIST_COL_STATUS_I18N] = STATUS_I18N[status] row[HOSTLIST_COL_VERSION] = status_info[2] self._update_widget_buttons() deferreds = [] for row in self.liststore: host_id = row[HOSTLIST_COL_ID] d = self.hostlist.get_host_status(host_id) try: d.addCallback(on_host_status, row) except AttributeError: on_host_status(d, row) else: deferreds.append(d) defer.DeferredList(deferreds) def _update_widget_buttons(self): """Updates the dialog button states.""" self.builder.get_object('button_refresh').set_sensitive(len(self.liststore)) self.builder.get_object('button_startdaemon').set_sensitive(False) self.builder.get_object('button_connect').set_sensitive(False) self.builder.get_object('button_connect').set_label(_('C_onnect')) self.builder.get_object('button_edithost').set_sensitive(False) self.builder.get_object('button_removehost').set_sensitive(False) self.builder.get_object('button_startdaemon').set_sensitive(False) self.builder.get_object('image_startdaemon').set_from_icon_name( 'system-run-symbolic', Gtk.IconSize.BUTTON ) self.builder.get_object('label_startdaemon').set_text_with_mnemonic( _('_Start Daemon') ) model, row = self.treeview.get_selection().get_selected() if row: self.builder.get_object('button_edithost').set_sensitive(True) self.builder.get_object('button_removehost').set_sensitive(True) else: return # Get selected host info. __, host, port, __, __, status, __, __ = model[row] try: getaddrinfo(host, None) except gaierror as ex: log.error( 'Error resolving host %s to ip: %s', row[HOSTLIST_COL_HOST], ex.args[1] ) self.builder.get_object('button_connect').set_sensitive(False) return log.debug('Host Status: %s, %s', host, status) # Check to see if the host is online if status == 'connected' or status == 'online': self.builder.get_object('button_connect').set_sensitive(True) self.builder.get_object('image_startdaemon').set_from_icon_name( 'process-stop-symbolic', Gtk.IconSize.MENU ) self.builder.get_object('label_startdaemon').set_text_with_mnemonic( _('_Stop Daemon') ) self.builder.get_object('button_startdaemon').set_sensitive(False) if status == 'connected': # Display a disconnect button if we're connected to this host self.builder.get_object('button_connect').set_label(_('_Disconnect')) self.builder.get_object('button_removehost').set_sensitive(False) # Currently can only stop daemon when connected to it self.builder.get_object('button_startdaemon').set_sensitive(True) elif host in LOCALHOST: # If localhost we can start the dameon. self.builder.get_object('button_startdaemon').set_sensitive(True) def start_daemon(self, port, config): """Attempts to start local daemon process and will show an ErrorDialog if not. Args: port (int): Port for the daemon to listen on. config (str): Config path to pass to daemon. Returns: bool: True is successfully started the daemon, False otherwise. """ if client.start_daemon(port, config): log.debug('Localhost daemon started') reactor.callLater(1, self._update_host_status) return True else: ErrorDialog( _('Unable to start daemon!'), _('Check deluged package is installed and logs for further details'), ).run() return False # Signal handlers def _connect(self, host_id, username=None, password=None, try_counter=0): def do_connect(result, username=None, password=None, *args): log.debug('Attempting to connect to daemon...') for host_entry in self.hostlist.config['hosts']: if host_entry[0] == host_id: __, host, port, host_user, host_pass = host_entry username = username if username else host_user password = password if password else host_pass d = client.connect(host, port, username, password) d.addCallback(self._on_connect, host_id) d.addErrback(self._on_connect_fail, host_id, try_counter) return d if client.connected(): return client.disconnect().addCallback(do_connect, username, password) else: return do_connect(None, username, password) def _on_connect(self, daemon_info, host_id): log.debug('Connected to daemon: %s', host_id) if self.gtkui_config['autoconnect']: self.gtkui_config['autoconnect_host_id'] = host_id if self.running: # When connected to a client, and then trying to connect to another, # this component will be stopped(while the connect deferred is # running), so, self.connection_manager will be deleted. # If that's not the case, close the dialog. self.connection_manager.response(Gtk.ResponseType.OK) component.start() def _on_connect_fail(self, reason, host_id, try_counter): log.debug('Failed to connect: %s', reason.value) if reason.check(AuthenticationRequired, BadLoginError): log.debug('PasswordRequired exception') dialog = AuthenticationDialog(reason.value.message, reason.value.username) def dialog_finished(response_id): if response_id == Gtk.ResponseType.OK: self._connect(host_id, dialog.get_username(), dialog.get_password()) return dialog.run().addCallback(dialog_finished) elif reason.check(IncompatibleClient): return ErrorDialog(_('Incompatible Client'), reason.value.message).run() if try_counter: log.info('Retrying connection.. Retries left: %s', try_counter) return reactor.callLater( 0.5, self._connect, host_id, try_counter=try_counter - 1 ) msg = str(reason.value) if not self.gtkui_config['autostart_localhost']: msg += '\n' + _( 'Auto-starting the daemon locally is not enabled. ' 'See "Options" on the "Connection Manager".' ) ErrorDialog(_('Failed To Connect'), msg).run() def on_button_connect_clicked(self, widget=None): """Button handler for connect to or disconnect from daemon.""" model, row = self.treeview.get_selection().get_selected() if not row: return host_id, host, port, __, __, status, __, __ = model[row] # If status is connected then connect button disconnects instead. if status == 'connected': def on_disconnect(reason): self._update_host_status() return client.disconnect().addCallback(on_disconnect) try_counter = 0 auto_start = self.builder.get_object('chk_autostart').get_active() if auto_start and host in LOCALHOST and status == 'offline': # Start the local daemon and then connect with retries set. if self.start_daemon(port, get_config_dir()): try_counter = 6 else: # Don't attempt to connect to offline daemon. return self._connect(host_id, try_counter=try_counter) def on_button_close_clicked(self, widget): self.connection_manager.response(Gtk.ResponseType.CLOSE) def _run_addhost_dialog(self, edit_host_info=None): """Create and runs the add host dialog. Supplying edit_host_info changes the dialog to an edit dialog. Args: edit_host_info (list): A list of (host, port, user, pass) to edit. Returns: list: The new host info values (host, port, user, pass). """ self.builder.add_from_file( resource_filename( __package__, os.path.join('glade', 'connection_manager.addhost.ui') ) ) dialog = self.builder.get_object('addhost_dialog') dialog.set_transient_for(self.connection_manager) hostname_entry = self.builder.get_object('entry_hostname') port_spinbutton = self.builder.get_object('spinbutton_port') username_entry = self.builder.get_object('entry_username') password_entry = self.builder.get_object('entry_password') if edit_host_info: dialog.set_title(_('Edit Host')) hostname_entry.set_text(edit_host_info[0]) port_spinbutton.set_value(edit_host_info[1]) username_entry.set_text(edit_host_info[2]) password_entry.set_text(edit_host_info[3]) response = dialog.run() new_host_info = [] if response: new_host_info.append(hostname_entry.get_text()) new_host_info.append(port_spinbutton.get_value_as_int()) new_host_info.append(username_entry.get_text()) new_host_info.append(password_entry.get_text()) dialog.destroy() return new_host_info def on_button_addhost_clicked(self, widget): log.debug('on_button_addhost_clicked') host_info = self._run_addhost_dialog() if host_info: hostname, port, username, password = host_info try: host_id = self.hostlist.add_host(hostname, port, username, password) except ValueError as ex: ErrorDialog(_('Error Adding Host'), ex).run() else: status = 'offline' version = '' self.liststore.append( [ host_id, hostname, port, username, password, status, version, STATUS_I18N[status], ] ) self._update_host_status() def on_button_edithost_clicked(self, widget=None): log.debug('on_button_edithost_clicked') model, row = self.treeview.get_selection().get_selected() status = model[row][HOSTLIST_COL_STATUS] host_id = model[row][HOSTLIST_COL_ID] host_info = [ self.liststore[row][HOSTLIST_COL_HOST], self.liststore[row][HOSTLIST_COL_PORT], self.liststore[row][HOSTLIST_COL_USER], self.liststore[row][HOSTLIST_COL_PASS], ] new_host_info = self._run_addhost_dialog(edit_host_info=host_info) if new_host_info: hostname, port, username, password = new_host_info try: self.hostlist.update_host(host_id, hostname, port, username, password) except ValueError as ex: ErrorDialog(_('Error Updating Host'), ex).run() else: self.liststore[row] = ( host_id, hostname, port, username, password, '', '', '', ) self._update_host_status() if status == 'connected': def on_disconnect(reason): self._update_host_status() client.disconnect().addCallback(on_disconnect) def on_button_removehost_clicked(self, widget): log.debug('on_button_removehost_clicked') # Get the selected rows model, row = self.treeview.get_selection().get_selected() self.hostlist.remove_host(model[row][HOSTLIST_COL_ID]) self.liststore.remove(row) # Update the hostlist self._update_host_status() def on_button_startdaemon_clicked(self, widget): log.debug('on_button_startdaemon_clicked') if not self.liststore.iter_n_children(None): # There is nothing in the list, so lets create a localhost entry try: self.hostlist.add_default_host() except ValueError as ex: log.error('Error adding default host: %s', ex) else: self.start_daemon(DEFAULT_PORT, get_config_dir()) finally: return paths = self.treeview.get_selection().get_selected_rows()[1] if len(paths): __, host, port, user, password, status, __, __ = self.liststore[paths[0]] else: return if host not in LOCALHOST: return def on_daemon_status_change(result): """Daemon start/stop callback""" reactor.callLater(0.7, self._update_host_status) if status in ('online', 'connected'): # Button will stop the daemon if status is online or connected. def on_connect(d, c): """Client callback to call daemon shutdown""" c.daemon.shutdown().addCallback(on_daemon_status_change) if client.connected() and (host, port, user) == client.connection_info(): client.daemon.shutdown().addCallback(on_daemon_status_change) elif user and password: c = Client() c.connect(host, port, user, password).addCallback(on_connect, c) else: # Otherwise button will start the daemon. self.start_daemon(port, get_config_dir()) def on_button_refresh_clicked(self, widget): self._update_host_status() def on_hostlist_row_activated(self, tree, path, view_column): self.on_button_connect_clicked() def on_hostlist_selection_changed(self, treeselection): self._update_widget_buttons() def on_chk_toggled(self, widget): self.gtkui_config['autoconnect'] = self.builder.get_object( 'chk_autoconnect' ).get_active() self.gtkui_config['autostart_localhost'] = self.builder.get_object( 'chk_autostart' ).get_active() self.gtkui_config[ 'show_connection_manager_on_start' ] = not self.builder.get_object('chk_donotshow').get_active() def on_entry_host_paste_clipboard(self, widget): text = get_clipboard_text() log.debug('on_entry_proxy_host_paste-clipboard: got paste: %s', text) text = text if '//' in text else '//' + text parsed = urlparse(text) if parsed.hostname: widget.set_text(parsed.hostname) widget.emit_stop_by_name('paste-clipboard') if parsed.port: self.builder.get_object('spinbutton_port').set_value(parsed.port) if parsed.username: self.builder.get_object('entry_username').set_text(parsed.username) if parsed.password: self.builder.get_object('entry_password').set_text(parsed.password)