class DBUpdater: def __init__(self, db_name, protocol="http", source=""): self.db_name= db_name fantom_tmp_path= os.path.join(fantom_tmp_dir, '%s.txt' % db_name) urls= all_db_urls[db_name] self.download_manager= DownloadManager(db_name, download_dir, protocol, urls) self.parser = Parser(db_name, fantom_tmp_path, self.download_manager, source) self.updater= BioDBUpdater(db_name, sql_db_path, fantom_tmp_path ) def run(self): print "Downloading the database..." self.download_manager.download() print "Parsing files..." self.parser.parse() print "Updating sqlite database..." self.updater.store_database() def stats(self): self.n_ids="" self.n_levels=""
def __init__(self, system_bus, mainloop): # Init dbus service. dbus.service.Object.__init__(self, system_bus, DSC_SERVICE_PATH) # Init. self.mainloop = mainloop self.pkg_cache = AptCache() self.exit_flag = False self.simulate = False self.all_upgrade_pkg_names = [] self.download_dir = "/var/cache/apt/archives" self.is_upgrading = False self.in_update_list = False self.apt_action_pool = AptActionPool(self.pkg_cache) self.apt_action_pool.start() global_event.register_event('parse-download-error', self.send_parse_download_error) global_event.register_event("action-start", self.action_start) global_event.register_event("action-update", self.action_update) global_event.register_event("action-finish", self.action_finish) global_event.register_event("action-failed", self.action_failed) global_event.register_event("download-start", self.download_start) global_event.register_event("download-update", self.download_update) global_event.register_event("download-finish", self.download_finish) global_event.register_event("download-stop", self.download_stop) global_event.register_event("download-error", self.download_failed) global_event.register_event("update-list-start", self.update_list_start) global_event.register_event("update-list-finish", self.update_list_finish) global_event.register_event("update-list-failed", self.update_list_failed) global_event.register_event("update-list-update", self.update_list_update) self.packages_status = {} self.exit_manager = ExitManager(self.mainloop, self.is_update_list_running, self.is_download_action_running, self.is_apt_action_running, self.have_exit_request) self.exit_manager.start() self.set_download_dir('/var/cache/apt/archives') self.download_manager = DownloadManager(global_event, verbose=True)
def _initialize_hosts(self): log.msg('Retry count: {}'.format(self.retry_count)) max_retries = self.app.max_retries if self.retry_count == max_retries or not self.initialized: self.retry_count = 0 hosts = self.app.pirate_bay_hosts host_config = hosts[self.host_index] web_host = "http://{}".format(host_config['host']) torrent_host = host_config['torrent_host'] use_tor = host_config['use_tor_network'] self.pirate_bay_client = ThePirateBay(web_host, use_tor) self.download_manager = DownloadManager() self.download_manager.initialize(torrent_host, use_tor, self.app) log.msg('Switching to different host') self.host_index += 1 if self.host_index == len(hosts): self.host_index = 0 else: self.retry_count += 1
def __init__(self): """""" if not shared.configuration.configured: logger.warning("No configuration found!") #events system shared.events = Events() shared.max_downloads = shared.configuration.get_max_downloads() shared.max_download_speed = shared.configuration.get_max_download_speed( ) ServiceManager.__init__(self) self.history = History() self.download_manager = DownloadManager(self.get_download_plugin, self.services)
def __set_image_buttons(self): try: from .__init__ import __main__ except ImportError: from __init__ import __main__ buttons_frame = tkinter.Frame(master=self.f, height=50) buttons_frame.place(x=0, rely=1 - self.BUTTONS_BUTTON_OFFSET / 100, height=50, relwidth=1, anchor="sw") self.image_play = tkinter.PhotoImage(master=buttons_frame, file=__main__.i_f("play.png")) self.image_pause = tkinter.PhotoImage(master=buttons_frame, file=__main__.i_f("pause.png")) self.image_plus = tkinter.PhotoImage(master=buttons_frame, file=__main__.i_f("plus.png")) self.image_download = tkinter.PhotoImage( master=buttons_frame, file=__main__.i_f("download.png")) self.image_delete = ImageTk.PhotoImage(Image.open( __main__.i_f("plus.png")).rotate(45), master=self.f) image_next = tkinter.PhotoImage(master=buttons_frame, file=__main__.i_f("next.png")) image_back = tkinter.PhotoImage(master=buttons_frame, file=__main__.i_f("back.png")) self.action_button = ttk.Button(buttons_frame, image=self.image_plus, command=self.actionClick) self.action_button.place(width=50, height=50, relx=0.2, anchor="n") self.back_button = ttk.Button(buttons_frame, image=image_back, command=self.backButtonClick) self.back_button.image = image_back self.back_button.place(width=50, height=50, relx=0.35, anchor="n") self.play_button = ttk.Button(buttons_frame, image=self.image_pause, command=self.pauseButtonClick) self.play_button.image = self.image_pause self.play_button.place(width=50, height=50, relx=0.5, anchor="n") self.next_button = ttk.Button(buttons_frame, image=image_next, command=self.nextButtonClick) self.next_button.image = image_next self.next_button.place(width=50, height=50, relx=0.65, anchor="n") self.button_download = ttk.Button( buttons_frame, image=self.image_download, command=lambda: DownloadManager.get().download(self.item)) self.button_download.place(width=50, height=50, relx=0.8, anchor="n") self.iconbitmap(__main__.icon())
def __init__(self, config): self.config = config self.download_manager = DownloadManager() self.__get_widgets() self.__make_extensions_treeview() self.__connect_widgets() self.__add_config_notifications() # Set widget states from configuration self.status_icon_checkbutton.set_active(self.config.show_status_icon) self.main_window_checkbutton.set_active(self.config.show_main_window) self.notifications_checkbutton.set_active(self.config.show_notifications) self.quit_dialog_checkbutton.set_active(self.config.show_quit_dialog) self.autostart_checkbutton.set_active(self.config.autostart) self.main_window_checkbutton.set_sensitive(self.config.show_status_icon) if self.config.ask_for_location: self.ask_folder_radiobutton.set_active(True) else: self.specify_folder_radiobutton.set_active(True) self.default_folder_filechooserbutton.set_current_folder(self.config.default_folder) self.extensions_checkbutton.set_active(self.config.check_extensions) if not self.config.check_extensions: self.extensions_alignment.set_sensitive(False) for extension, folder in zip(self.config.extensions, self.config.extension_folders): self.extensions_model.append((extension, folder)) self.manual_proxy_vbox.set_sensitive(False) if self.config.proxy_mode == "gnome": self.gnome_radiobutton.set_active(True) elif self.config.proxy_mode == "manual": self.manual_radiobutton.set_active(True) else: self.direct_radiobutton.set_active(True) self.proxy_entry.set_text(self.config.proxy_host) self.proxy_port_spinbutton.set_value(self.config.proxy_port) self.proxy_auth_checkbutton.set_active(self.config.proxy_auth) self.proxy_auth_hbox.set_sensitive(self.config.proxy_auth) self.proxy_user_entry.set_text(self.config.proxy_user) self.proxy_password_entry.set_text(self.config.proxy_password)
def __init__(self, db_name, protocol="http", source=""): self.db_name= db_name fantom_tmp_path= os.path.join(fantom_tmp_dir, '%s.txt' % db_name) urls= all_db_urls[db_name] self.download_manager= DownloadManager(db_name, download_dir, protocol, urls) self.parser = Parser(db_name, fantom_tmp_path, self.download_manager, source) self.updater= BioDBUpdater(db_name, sql_db_path, fantom_tmp_path )
def __init__(self, config_file_location): config = yaml.load(file(config_file_location, 'r')) synology_config = config['synology'] self.downloadstation_credentials = DownloadStationCredentials( synology_config['url'], synology_config['username'], synology_config['password']) self.putio_credentials = PutioCredentials(config['putio']['token']) self.feed_details = FeedsDetails(config['monitor_minutes'], config['feeds']) download_manager = DownloadManager(self.downloadstation_credentials, self.putio_credentials, self.feed_details)
class Core(ServiceManager): """""" def __init__(self): """""" if not shared.configuration.configured: logger.warning("No configuration found!") #events system shared.events = Events() shared.max_downloads = shared.configuration.get_max_downloads() shared.max_download_speed = shared.configuration.get_max_download_speed() ServiceManager.__init__(self) self.history = History() self.download_manager = DownloadManager(self.get_download_plugin, self.services) def stop_all(self): """""" self.download_manager.quit() ServiceManager.stop_all(self)
def __init__(self, system_bus, mainloop): # Init dbus service. dbus.service.Object.__init__(self, system_bus, DSC_SERVICE_PATH) # Init. self.mainloop = mainloop self.pkg_cache = AptCache() self.exit_flag = False self.simulate = False self.all_upgrade_pkg_names = [] self.download_dir = "/var/cache/apt/archives" self.is_upgrading = False self.in_update_list = False self.apt_action_pool = AptActionPool(self.pkg_cache) self.apt_action_pool.start() global_event.register_event( 'parse-download-error', self.send_parse_download_error) global_event.register_event("action-start", self.action_start) global_event.register_event("action-update", self.action_update) global_event.register_event("action-finish", self.action_finish) global_event.register_event("action-failed", self.action_failed) global_event.register_event("download-start", self.download_start) global_event.register_event("download-update", self.download_update) global_event.register_event("download-finish", self.download_finish) global_event.register_event("download-stop", self.download_stop) global_event.register_event("download-error", self.download_failed) global_event.register_event( "update-list-start", self.update_list_start) global_event.register_event( "update-list-finish", self.update_list_finish) global_event.register_event( "update-list-failed", self.update_list_failed) global_event.register_event( "update-list-update", self.update_list_update) self.packages_status = {} self.exit_manager = ExitManager( self.mainloop, self.is_update_list_running, self.is_download_action_running, self.is_apt_action_running, self.have_exit_request) self.exit_manager.start() self.set_download_dir('/var/cache/apt/archives') self.download_manager = DownloadManager(global_event, verbose=True)
class FileManagerTestCase(unittest.TestCase): def setUp(self): youtube = YoutubeDownloader(url=self.billboard2019_playlist()) self.dm = DownloadManager(youtube) def billboard2019_playlist(self): '''Sample playlist''' return "https://www.youtube.com/playlist?list=" \ "PLCzImqCYRfNfJOzblgIkAPkG0HuMBtT5j" """ The open method is mocked without being used; this is to prevent the positions file from being overwritten. """ @mock.patch('download_manager.open') @mock.patch.object(youtube.YoutubeDownloader, 'download') def test_downloadPlaylist_downloadsToFolder(self, mock_download, mock_open): self.dm.download_all() mock_download.assert_called() @mock.patch('download_manager.open') @mock.patch.object(youtube.YoutubeDownloader, 'download') @mock.patch.object(download_manager.pickle, 'dump') def test_downloadAll_updatesLastFileDownloaded(self, mock_pickler, mock_download, mock_open): self.dm.download_all() mock_pickler.assert_called() @mock.patch('download_manager.open') @mock.patch.object(youtube.YoutubeDownloader, 'download') def test_downloadAll_startsAtLastPositionDownloaded( self, mock_youtube_dl, mock_open): # Start at position 5 self.dm.download_positions = {self.billboard2019_playlist(): 5} self.dm.download_all() mock_youtube_dl.assert_called_once_with(start_at_position=5) @mock.patch('download_manager.open') @mock.patch.object(download_manager.pickle, 'load') def test_getPositions_returnsPickleFilePositions(self, mock_pickler, mock_open): expected_return_value = {self.billboard2019_playlist(): "1"} mock_pickler.return_value = expected_return_value with mock.patch('builtins.open'): positions = self.dm.load_positions() self.assertEqual(expected_return_value, positions)
def run(self): self.__init_i18n() [args, headers] = self.__get_options() gnome.init(NAME, VERSION) gtk.gdk.threads_init() gtk.window_set_default_icon_list(*gui.get_icon_list([16, 22, 24, 32])) self.download_list = DownloadList() self.download_manager = DownloadManager() self.dbus_service = dbus_service.DBusService() # If the DBus service is already running, add downloads using it if not self.dbus_service.register(): for uri in args: self.dbus_service.download_manager.AddDownload( uri, os.getcwd(), headers) return 0 self.dbus_service.register_object(dbus_service.DOWNLOAD_MGR_OBJ_PATH, self.download_list) self.main_window = MainWindow(self.config, self.download_list) self.dbus_service.register_object(dbus_service.MAIN_WINDOW_OBJ_PATH, self.main_window) if self.config.show_main_window: self.main_window.window.show() self.status_icon = TrayIcon(self.main_window) if not self.config.show_status_icon: self.status_icon.icon.hide_all() sys.excepthook = self.main_window.on_unhandled_exception self.download_list.load_from_xml() for uri in args: if self.config.ask_for_location: add = AddDownloadDialog(uri, headers) add.dialog.run() else: self.download_list.add_download(uri, self.config.default_folder, headers) gtk.main()
class PackageManager(dbus.service.Object): ''' docs ''' def invoked_log(func): @functools.wraps(func) def wrapper(*args, **kw): info = "dbus method invoked: %s, arguments: %s" % ( func.__name__, str(args[1:])) logger.debug(info) return func(*args, **kw) return wrapper def __init__(self, system_bus, mainloop): # Init dbus service. dbus.service.Object.__init__(self, system_bus, DSC_SERVICE_PATH) # Init. self.mainloop = mainloop self.pkg_cache = AptCache() self.exit_flag = False self.simulate = False self.all_upgrade_pkg_names = [] self.download_dir = "/var/cache/apt/archives" self.is_upgrading = False self.in_update_list = False self.apt_action_pool = AptActionPool(self.pkg_cache) self.apt_action_pool.start() global_event.register_event( 'parse-download-error', self.send_parse_download_error) global_event.register_event("action-start", self.action_start) global_event.register_event("action-update", self.action_update) global_event.register_event("action-finish", self.action_finish) global_event.register_event("action-failed", self.action_failed) global_event.register_event("download-start", self.download_start) global_event.register_event("download-update", self.download_update) global_event.register_event("download-finish", self.download_finish) global_event.register_event("download-stop", self.download_stop) global_event.register_event("download-error", self.download_failed) global_event.register_event( "update-list-start", self.update_list_start) global_event.register_event( "update-list-finish", self.update_list_finish) global_event.register_event( "update-list-failed", self.update_list_failed) global_event.register_event( "update-list-update", self.update_list_update) self.packages_status = {} self.exit_manager = ExitManager( self.mainloop, self.is_update_list_running, self.is_download_action_running, self.is_apt_action_running, self.have_exit_request) self.exit_manager.start() self.set_download_dir('/var/cache/apt/archives') self.download_manager = DownloadManager(global_event, verbose=True) def download_start(self, pkg_name, action_type): utils.set_running_lock(True) self.update_signal([("download-start", (pkg_name, action_type))]) if action_type == ACTION_UPGRADE: self.is_upgrading = True def download_update(self, pkg_name, action_type, data): self.update_signal([("download-update", ( pkg_name, action_type, data))]) if action_type == ACTION_UPGRADE: self.is_upgrading = True def download_stop(self, pkg_name, action_type): self.update_signal([("download-stop", (pkg_name, action_type))]) self.exit_manager.check() if action_type == ACTION_UPGRADE: self.is_upgrading = False def download_failed(self, pkg_name, action_type, e): logger.error("%s download failed with %s" % (pkg_name, e)) utils.set_running_lock(False) self.update_signal([("download-failed", (pkg_name, action_type, e))]) self.exit_manager.check() if action_type == ACTION_UPGRADE: self.is_upgrading = False def download_finish(self, action_id, action_type, all_pkg_names): utils.set_running_lock(False) self.update_signal([("download-finish", (action_id, action_type))]) if action_type == ACTION_INSTALL: self.apt_action_pool.add_install_action(all_pkg_names) elif action_type == ACTION_UPGRADE: self.start_upgrade(all_pkg_names, action_id) self.is_upgrading = False self.exit_manager.check() def action_start(self, signal_content): utils.set_running_lock(True) self.update_signal([("action-start", signal_content)]) if signal_content[1] == ACTION_UPGRADE: self.is_upgrading = True def action_update(self, signal_content): self.update_signal([("action-update", signal_content)]) if signal_content[1] == ACTION_UPGRADE: self.is_upgrading = True def action_finish(self, signal_content): utils.set_running_lock(False) pkg_name, action_type, pkg_info_list = signal_content if action_type == ACTION_INSTALL: for pkg_info in pkg_info_list: self.pkg_cache.set_pkg_status( pkg_name, self.pkg_cache.PKG_STATUS_INSTALLED) elif action_type == ACTION_UPGRADE: for pkg_info in pkg_info_list: self.pkg_cache.set_pkg_status( pkg_name, self.pkg_cache.PKG_STATUS_UPGRADED) elif action_type == ACTION_UNINSTALL: for pkg_info in pkg_info_list: self.pkg_cache.set_pkg_status( pkg_name, self.pkg_cache.PKG_STATUS_UNINSTALLED) self.update_signal([("action-finish", signal_content)]) self.exit_manager.check() if signal_content[1] == ACTION_UPGRADE: self.is_upgrading = False def action_failed(self, signal_content): utils.set_running_lock(False) self.update_signal([("action-failed", signal_content)]) self.exit_manager.check() if signal_content[1] == ACTION_UPGRADE: self.is_upgrading = False def is_update_list_running(self): return self.in_update_list def is_download_action_running(self): return len(self.download_manager.download_task_info) > 0 def is_apt_action_running(self): return len(self.apt_action_pool.active_mission_list) + len( self.apt_action_pool.wait_mission_list) > 0 def have_exit_request(self): return self.exit_flag def update_list_start(self): self.in_update_list = True self.update_signal([("update-list-start", "")]) def update_list_finish(self): self.update_signal([("update-list-merge", "")]) self.pkg_cache.open(apb.OpProgress()) db_build.BuildSoftwareDB(self.pkg_cache) self.update_signal([("update-list-finish", "")]) self.in_update_list = False self.exit_manager.check() def update_list_failed(self): self.in_update_list = False self.update_signal([("update-list-failed", "")]) self.exit_manager.check() def update_list_update(self, percent, status_message, speed_str): self.update_signal([( "update-list-update", (percent, status_message, speed_str))]) def handle_dbus_reply(self, *reply): logger.info("%s (reply): %s" % (self.module_dbus_name, str(reply))) def handle_dbus_error(self, *error): logger.info("%s (error): %s" % (self.module_dbus_name, str(error))) def send_parse_download_error(self, pkg_name, action_type): self.update_signal([("parse-download-error", (pkg_name, action_type))]) def get_unique_id(self): return str(uuid.uuid4()) def get_real_pkg_name(self, pkg_name): if pkg_name in self.pkg_cache: return pkg_name elif (pkg_name + ":i386") in self.pkg_cache: return pkg_name + ":i386" else: return None def dist_upgrade(self): action_type = ACTION_UPGRADE action_id = '%s_%s' % (self.get_unique_id(), action_type) self.update_signal([( "ready-download-start", (action_id, action_type))]) dist_upgrade_changes = self.pkg_cache.get_dist_upgrade_changes() # detect and prevent the system components from being uninstalled pkg_in_white_list = [] download_pkgs = [] self.all_upgrade_pkg_names = [] for pkg in dist_upgrade_changes["delete"]: name = pkg.name if name in SYS_PKG_WHITE_LIST: pkg_in_white_list.append(name) if len(pkg_in_white_list) > 0: self.update_signal([( "remove-pkgs-in-white-list", (json.dumps(pkg_in_white_list), action_type))]) logger.error("found remove system packages: %s" % json.dumps(pkg_in_white_list)) else: for status in dist_upgrade_changes: for pkg in dist_upgrade_changes[status]: self.all_upgrade_pkg_names.append(pkg.name) if status == "delete" or status == "keep": continue if not parse_pkg.pkg_file_has_exist(pkg): download_pkgs.append(pkg) self.update_signal([("ready-download-finish", (action_id, action_type))]) if len(download_pkgs) == 0: global_event.emit("download-finish", action_id, action_type, self.all_upgrade_pkg_names) else: names = [] download_urls = [] download_hash_infos = [] pkg_sizes = [] for pkg in download_pkgs: names.append(pkg.name) download_urls.append(pkg.candidate.uri) download_hash_infos.append(pkg.candidate.md5) pkg_sizes.append(pkg.candidate.size) self.download_manager.add_download( action_id, action_type, download_urls, download_sizes=pkg_sizes, download_md5s=download_hash_infos, all_task_names=names, all_change_pkgs=self.all_upgrade_pkg_names, file_save_dir=self.download_dir ) def add_download(self, pkg_name, action_type, simulate=False): installed = self.get_pkg_installed(pkg_name) if installed == 1: self.update_signal([("pkg-installed", (pkg_name, action_type))]) return elif installed == -1: self.update_signal([("pkg-not-in-cache", (pkg_name, action_type))]) return pkg_infos = get_pkg_download_info(self.pkg_cache, pkg_name) status = pkg_infos["status"] self.update_signal([("ready-download-finish", (pkg_name, action_type))]) if status == DOWNLOAD_STATUS_NOTNEED: self.download_finish(pkg_name, action_type, [pkg_name,]) elif status == DOWNLOAD_STATUS_ERROR: self.update_signal([("parse-download-error", (pkg_name, action_type))]) else: names = [] download_urls = [] download_hash_infos = [] pkg_sizes = [] for info in pkg_infos["info"]: names.append(info["name"]) download_urls.append(info["url"]) download_hash_infos.append(info["hash"]) pkg_sizes.append(info["size"]) self.download_manager.add_download( pkg_name, action_type, download_urls, download_sizes=pkg_sizes, download_md5s=download_hash_infos, all_task_names=[pkg_name], file_save_dir=self.download_dir ) def start_upgrade(self, pkg_names, action_id): self.apt_action_pool.add_multi_upgrade_mission(pkg_names, action_id) def del_source_list_d(self): white_list_path = os.path.join(get_parent_dir(__file__), 'white_list.txt') if os.path.exists(white_list_path): with open(white_list_path) as fp: for line in fp: line = line.strip() if os.path.exists(line): os.remove(line) def get_desktops(self, pkg_name): desktops = [] try: pkg_obj = self.pkg_cache[pkg_name] for f in pkg_obj.installed_files: if f.endswith(".desktop"): desktops.append(f) except: pass return desktops @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature='', out_signature='as') def read_no_notify_config(self, no_notify_config_path): if os.path.exists(no_notify_config_path): no_notify_config_str = read_file(no_notify_config_path) try: no_notify_config = eval(no_notify_config_str) if type(no_notify_config).__name__ != "list": no_notify_config = [] except Exception: no_notify_config = [] return no_notify_config else: return [] @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def add_no_notify_pkg(self, info): pkg_name, path = info no_notify_config = self.read_no_notify_config(path) if pkg_name not in no_notify_config: pkg_name = str(pkg_name) no_notify_config.append(pkg_name) write_file(path, str(no_notify_config)) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def remove_no_notify_pkg(self, info): pkg_name, path = info pkg_name = str(pkg_name) path = str(path) no_notify_config = self.read_no_notify_config(path) if pkg_name in no_notify_config: write_file(path, str(filter( lambda config_pkg_name: config_pkg_name != pkg_name, no_notify_config))) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="i", out_signature="") def init_download_manager(self, number): pass @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="s", out_signature="") def set_download_dir(self, local_dir): apt_pkg.config.set("Dir::Cache::Archives", local_dir) self.download_dir = local_dir @invoked_log @dbus.service.method( DSC_SERVICE_NAME, in_signature="s", out_signature="ai") def get_download_size(self, pkg_name): total_size = 0 pkg_infos = get_pkg_download_info(self.pkg_cache, pkg_name) status = pkg_infos["status"] if status == DOWNLOAD_STATUS_NOTNEED: total_size = get_pkg_own_size(self.pkg_cache, pkg_name) size_flag = PKG_SIZE_OWN elif status == DOWNLOAD_STATUS_ERROR: total_size = -1 size_flag = PKG_SIZE_ERROR else: for info in pkg_infos["info"]: total_size += info["size"] size_flag = PKG_SIZE_DOWNLOAD return [size_flag, total_size] @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="ai") def clean_download_cache(self): '''Clean download cache.''' # get action packages. remain_pkgs = [] for pkg_name in self.download_manager.task_name_to_id.keys(): remain_pkgs.append(pkg_name) for pkg_name in self.apt_action_pool.install_action_dict.keys(): remain_pkgs.append(pkg_name) for pkg_name in self.apt_action_pool.upgrade_action_dict.keys(): remain_pkgs.append(pkg_name) # Get depend packages. remain_pkgs_paths = [] for pkg_name in remain_pkgs: result = get_pkg_dependence_file_path(self.pkg_cache, pkg_name) if not result: remain_pkgs_paths += result # Init clean size. packageNum = 0 cleanSize = 0 # Delete cache directory. cache_archive_dir = get_cache_archive_dir() if os.path.exists(cache_archive_dir): for root, folder, files in os.walk(cache_archive_dir): for file_name in files: path = os.path.join(root, file_name) if path.endswith(".deb") and ( path not in remain_pkgs_paths): packageNum += 1 cleanSize += os.path.getsize(path) remove_file(path) return [packageNum, cleanSize] @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="b", out_signature="") def say_hello(self, simulate): # Set exit_flag with False to prevent backend exit, # this just useful that frontend start again before backend exit. self.exit_flag = False self.simulate = simulate @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="") def request_quit(self): # Set exit flag. self.exit_flag = True self.exit_manager.check() self.update_signal([("frontend-quit", "")]) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def change_source_list(self, repo_urls): ubuntu_repo_url, deepin_repo_url = repo_urls new_source_list_content = get_source_list_contents( ubuntu_repo_url, deepin_repo_url) os.system('cp %s %s.save' % (SOURCE_LIST, SOURCE_LIST)) with open(SOURCE_LIST, 'w') as fp: fp.write(new_source_list_content) @invoked_log @dbus.service.method( DSC_SERVICE_NAME, in_signature="", out_signature="(ss)") def RequestUpgradeStatus(self): if self.in_update_list: return ("cache-updating", json.dumps([])) elif self.is_upgrading: return ("upgrading", json.dumps([])) else: dist_upgrade_changes = self.pkg_cache.get_dist_upgrade_changes() return_infos = [] for status in dist_upgrade_changes: for pkg in dist_upgrade_changes[status]: return_infos.append(dict( status=status, name=pkg.name, version=pkg.candidate.version, size=pkg.candidate.size, downloaded=parse_pkg.pkg_file_has_exist(pkg) )) return ("normal", json.dumps(return_infos)) @invoked_log @dbus.service.method( DSC_SERVICE_NAME, in_signature="a(si)", out_signature="") def RemoveWaitMissions(self, pkg_infos): self.apt_action_pool.remove_wait_missions(pkg_infos) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="s") def request_uninstall_pkgs(self): return json.dumps(self.pkg_cache.get_uninstall_pkgs()) @invoked_log @dbus.service.method( DSC_SERVICE_NAME, in_signature="as", out_signature="as") def request_pkgs_install_version(self, pkg_names): pkg_versions = [] for pkg_name in pkg_names: try: version = self.pkg_cache[pkg_name].versions[0].version pkg_versions.append(version) except: try: version = self.pkg_cache[pkg_name+":i386"].versions[0].version pkg_versions.append(version) except: self.update_signal([("pkg-not-in-cache", pkg_name)]) return pkg_versions @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="s", out_signature="as") def is_pkg_in_cache(self, pkg_name): result = [] try: self.pkg_cache[pkg_name] result.append(pkg_name) except: try: pkg_name += ":i386" self.pkg_cache[pkg_name] result.append(pkg_name) except: pass return result @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="as") def request_pkgs_uninstall_version(self, pkg_names): return self.pkg_cache.get_pkgs_uninstall_version(pkg_names) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def install_pkg(self, pkg_names): for pkg_name in pkg_names: real_pkg_name = self.get_real_pkg_name(pkg_name) if real_pkg_name: ThreadMethod(self.add_download, (real_pkg_name, ACTION_INSTALL, self.simulate)).start() else: self.update_signal([("pkg-not-in-cache", pkg_name)]) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="sb", out_signature="") def uninstall_pkg(self, pkg_name, purge): real_pkg_name = self.get_real_pkg_name(pkg_name) if real_pkg_name: self.apt_action_pool.add_uninstall_action(real_pkg_name, self.simulate, purge) else: self.update_signal([("pkg-not-in-cache", pkg_name)]) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="sb", out_signature="") def uninstall_pkg_from_desktop(self, desktop_path, purge): ThreadMethod(self.uninstall_pkg_from_desktop_thread, (desktop_path, purge)).start() def uninstall_pkg_from_desktop_thread(self, path, purge): pkg_name = self.get_pkg_name_from_path(path) if pkg_name: self.uninstall_pkg(pkg_name, purge) else: global_event.emit("action-failed", (path, ACTION_UNINSTALL, [], "no package found for path: %s" % path)) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="s", out_signature="s") def get_pkg_name_from_path(self, path): pkg_name = utils.file_path_to_package_name(path) if pkg_name == "" and path.endswith(".desktop"): desktop_name = os.path.split(path)[1] path = utils.desktop_name_to_desktop_path(desktop_name) pkg_name = utils.file_path_to_package_name(path) return pkg_name @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def upgrade_pkg(self, pkg_names): for pkg_name in pkg_names: real_pkg_name = self.get_real_pkg_name(pkg_name) if real_pkg_name: self.update_signal([("ready-download-start", (real_pkg_name, ACTION_UPGRADE))]) ThreadMethod(self.add_download, (real_pkg_name, ACTION_UPGRADE, self.simulate)).start() else: self.update_signal([("pkg-not-in-cache", pkg_name)]) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="") def DistUpgrade(self): ThreadMethod(self.dist_upgrade).start() @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def stop_download_pkg(self, pkg_names): for pkg_name in pkg_names: self.download_manager.stop_wait_download(pkg_name) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="") def cancel_upgrade_download(self): if getattr(self, 'upgrade_id'): self.download_manager.stop_wait_download(self.upgrade_id) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def remove_wait_downloads(self, pkg_names): for pkg_name in pkg_names: self.download_manager.stop_wait_download(pkg_name) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="s", out_signature="s") def request_pkg_short_desc(self, pkg_name): return self.pkg_cache.get_pkg_short_desc(pkg_name) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="as") def request_status(self): download_status = { ACTION_INSTALL : [], ACTION_UPGRADE : []} for info_dict in self.download_manager.download_task_info.values(): pkg_name = info_dict["task_name"] if info_dict["action_type"] == ACTION_INSTALL: download_status[ACTION_INSTALL].append((pkg_name, info_dict["status"])) elif info_dict["action_type"] == ACTION_UPGRADE: download_status[ACTION_UPGRADE].append((pkg_name, info_dict["status"])) action_status = { ACTION_INSTALL : [], ACTION_UPGRADE : [], ACTION_UNINSTALL : []} for info_dict in self.apt_action_pool.install_action_dict.values(): pkg_name = info_dict["task_name"] action_status[ACTION_INSTALL].append((pkg_name, info_dict["status"])) for info_dict in self.apt_action_pool.upgrade_action_dict.values(): pkg_name = info_dict["task_name"] action_status[ACTION_UPGRADE].append((pkg_name, info_dict["status"])) for info_dict in self.apt_action_pool.uninstall_action_dict.values(): pkg_name = info_dict["task_name"] action_status[ACTION_UNINSTALL].append((pkg_name, info_dict["status"])) return [str(download_status), str(action_status)] @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="") def start_update_list(self): self.del_source_list_d() self.pkg_cache.open(apb.OpProgress()) self.apt_action_pool.add_update_list_mission() @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="ab") def request_pkgs_install_status(self, pkg_names): _status = [] for pkg in pkg_names: _status.append(self.pkg_cache.is_pkg_installed(pkg)) return _status @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="(si)", out_signature="") def set_pkg_status(self, pkg_status): pkg_name, status = pkg_status self.pkg_cache.set_pkg_status(pkg_name, pkg_status) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="s", out_signature="i") def get_pkg_installed(self, pkg_name): if self.is_pkg_in_cache(pkg_name): if self.pkg_cache.is_pkg_installed(pkg_name): return 1 else: return 0 else: return -1 @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="ss", out_signature="s") def get_pkg_start_status(self, pkg_name, start_pkg_names): is_current_installed = self.get_pkg_installed(pkg_name) if is_current_installed == -1: return "unknown" elif is_current_installed == 0: return "uninstalled" else: desktops = self.get_desktops(pkg_name) names = start_pkg_names.split(",") for name in names: if self.get_pkg_installed(name) == 1: desktops += self.get_desktops(name) return json.dumps(desktops) @dbus.service.signal(DSC_SERVICE_NAME, signature='a(sv)') # Use below command for test: # dbus-monitor --system "type='signal', interface='com.linuxdeepin.softwarecenter'" def update_signal(self, message): # The signal is emitted when this method exits # You can have code here if you wish info = str(message) logger.debug("dbus signal emit: %s" % info)
class PackageManager(dbus.service.Object): ''' docs ''' def __init__(self, system_bus, mainloop): log("init dbus") # Init dbus service. dbus.service.Object.__init__(self, system_bus, DSC_SERVICE_PATH) # Init. self.mainloop = mainloop self.pkg_cache = AptCache() self.exit_flag = False self.simulate = False self.all_upgrade_pkg_names = [] self.is_upgrading = False self.in_update_list = False self.apt_action_pool = AptActionPool(self.pkg_cache) self.apt_action_pool.start() global_event.register_event('parse-download-error', self.send_parse_download_error) global_event.register_event("action-start", self.action_start) global_event.register_event("action-update", self.action_update) global_event.register_event("action-finish", self.action_finish) global_event.register_event("action-failed", self.action_failed) global_event.register_event("download-start", self.download_start) global_event.register_event("download-update", self.download_update) global_event.register_event("download-finish", self.download_finish) global_event.register_event("download-stop", self.download_stop) global_event.register_event("download-error", self.download_failed) global_event.register_event("update-list-start", self.update_list_start) global_event.register_event("update-list-finish", self.update_list_finish) global_event.register_event("update-list-failed", self.update_list_failed) global_event.register_event("update-list-update", self.update_list_update) self.packages_status = {} self.exit_manager = ExitManager( self.mainloop, self.is_update_list_running, self.is_download_action_running, self.is_apt_action_running, self.have_exit_request) self.exit_manager.start() log("init finish") self.set_download_dir('/var/cache/apt/archives') self.init_download_manager(5) def download_start(self, pkg_name, action_type): utils.set_running_lock(True) self.update_signal([("download-start", (pkg_name, action_type))]) if action_type == ACTION_UPGRADE: self.is_upgrading = True def download_update(self, pkg_name, action_type, data): self.update_signal([("download-update", (pkg_name, action_type, data))]) if action_type == ACTION_UPGRADE: self.is_upgrading = True def download_stop(self, pkg_name, action_type): self.update_signal([("download-stop", (pkg_name, action_type))]) self.exit_manager.check() if action_type == ACTION_UPGRADE: self.is_upgrading = False def download_failed(self, pkg_name, action_type, e): logger.error("%s download failed with %s" % (pkg_name, e)) utils.set_running_lock(False) self.update_signal([("download-failed", (pkg_name, action_type, e))]) self.exit_manager.check() if action_type == ACTION_UPGRADE: self.is_upgrading = False def download_finish(self, action_id, action_type, all_pkg_names): utils.set_running_lock(False) self.update_signal([("download-finish", (action_id, action_type))]) if action_type == ACTION_INSTALL: self.apt_action_pool.add_install_action(all_pkg_names) elif action_type == ACTION_UPGRADE: self.start_upgrade(all_pkg_names, action_id) self.is_upgrading = False self.exit_manager.check() def action_start(self, signal_content): utils.set_running_lock(True) self.update_signal([("action-start", signal_content)]) if signal_content[1] == ACTION_UPGRADE: self.is_upgrading = True def action_update(self, signal_content): self.update_signal([("action-update", signal_content)]) if signal_content[1] == ACTION_UPGRADE: self.is_upgrading = True def action_finish(self, signal_content): utils.set_running_lock(False) pkg_name, action_type, pkg_info_list = signal_content if action_type == ACTION_INSTALL: for pkg_info in pkg_info_list: self.pkg_cache.set_pkg_status(pkg_name, self.pkg_cache.PKG_STATUS_INSTALLED) elif action_type == ACTION_UPGRADE: for pkg_info in pkg_info_list: self.pkg_cache.set_pkg_status(pkg_name, self.pkg_cache.PKG_STATUS_UPGRADED) elif action_type == ACTION_UNINSTALL: for pkg_info in pkg_info_list: self.pkg_cache.set_pkg_status(pkg_name, self.pkg_cache.PKG_STATUS_UNINSTALLED) self.update_signal([("action-finish", signal_content)]) self.exit_manager.check() if signal_content[1] == ACTION_UPGRADE: self.is_upgrading = False def action_failed(self, signal_content): utils.set_running_lock(False) self.update_signal([("action-failed", signal_content)]) self.exit_manager.check() if signal_content[1] == ACTION_UPGRADE: self.is_upgrading = False def is_update_list_running(self): return self.in_update_list def is_download_action_running(self): return len(self.download_manager.fetch_files_dict) > 0 def is_apt_action_running(self): return len(self.apt_action_pool.active_mission_list) + len(self.apt_action_pool.wait_mission_list) > 0 def have_exit_request(self): return self.exit_flag def update_list_start(self): self.in_update_list = True self.update_signal([("update-list-start", "")]) def update_list_finish(self): self.update_signal([("update-list-merge", "")]) self.pkg_cache.open(apb.OpProgress()) db_build.BuildSoftwareDB(self.pkg_cache) self.update_signal([("update-list-finish", "")]) self.in_update_list = False self.exit_manager.check() def update_list_failed(self): self.in_update_list = False self.update_signal([("update-list-failed", "")]) self.exit_manager.check() def update_list_update(self, percent, status_message, speed_str): self.update_signal([("update-list-update", (percent, status_message, speed_str))]) def handle_dbus_reply(self, *reply): log("%s (reply): %s" % (self.module_dbus_name, str(reply))) def handle_dbus_error(self, *error): log("%s (error): %s" % (self.module_dbus_name, str(error))) def send_parse_download_error(self, pkg_name, action_type): self.update_signal([("parse-download-error", (pkg_name, action_type))]) def get_unique_id(self): return str(uuid.uuid4()) def get_real_pkg_name(self, pkg_name): if pkg_name in self.pkg_cache: return pkg_name elif (pkg_name + ":i386") in self.pkg_cache: return pkg_name + ":i386" else: return None def add_upgrade_download_with_new_policy(self, pkg_names, action_type): action_id = '%s_%s' % (self.get_unique_id(), action_type) self.update_signal([("ready-download-start", (action_id, action_type))]) real_pkg_dict, not_in_cache = parse_pkg.get_real_pkg_dict(self.pkg_cache, pkg_names) if not_in_cache: self.update_signal([("pkgs-not-in-cache", (json.dumps(not_in_cache), action_type))]) else: (all_change_pkgs, mark_failed_pkg_dict, marked_delete_sys_pkgs ) = parse_pkg.get_changes_pkgs(self.pkg_cache, real_pkg_dict) if mark_failed_pkg_dict: self.update_signal([("pkgs-mark-failed", (json.dumps(mark_failed_pkg_dict.keys()), action_type))]) elif marked_delete_sys_pkgs: self.update_signal([("marked-delete-system-pkgs", (json.dumps(marked_delete_sys_pkgs), action_type))]) else: self.update_signal([("ready-download-finish", (action_id, action_type))]) download_pkg_infos = parse_pkg.check_pkg_download_info(all_change_pkgs) if download_pkg_infos[0] == DOWNLOAD_STATUS_ERROR: self.update_signal([("pkgs-parse-download-error", (str(download_pkg_infos[1]), action_type))]) elif download_pkg_infos[0] == DOWNLOAD_STATUS_NOTNEED: self.start_upgrade(pkg_names, action_id) else: (names, download_urls, download_hash_infos, pkg_sizes) = download_pkg_infos self.all_upgrade_pkg_names = all_change_pkgs self.download_manager.add_download( action_id, action_type, download_urls, all_pkg_names=pkg_names, all_change_pkgs=all_change_pkgs, file_save_dir=self.download_dir, ) def add_download(self, pkg_name, action_type, simulate=False): pkg_infos = get_pkg_download_info(self.pkg_cache, pkg_name) self.update_signal([("ready-download-finish", (pkg_name, action_type))]) if pkg_infos[0] == DOWNLOAD_STATUS_NOTNEED: self.download_finish(pkg_name, action_type, [pkg_name,]) print "Don't need download" elif pkg_infos[0] == DOWNLOAD_STATUS_ERROR: self.update_signal([("parse-download-error", (pkg_name, action_type))]) print "Download error" else: (names, download_urls, download_hash_infos, pkg_sizes) = pkg_infos self.download_manager.add_download( pkg_name, action_type, download_urls, all_pkg_names=[pkg_name,], file_save_dir=self.download_dir) def start_upgrade(self, pkg_names, action_id): self.apt_action_pool.add_multi_upgrade_mission(pkg_names, action_id) def del_source_list_d(self): white_list_path = os.path.join(get_parent_dir(__file__), 'white_list.txt') if os.path.exists(white_list_path): with open(white_list_path) as fp: for line in fp: line = line.strip() if os.path.exists(line): os.remove(line) def get_desktops(self, pkg_name): desktops = [] try: pkg_obj = self.pkg_cache[pkg_name] for f in pkg_obj.installed_files: if f.endswith(".desktop"): desktops.append(f) except: pass return desktops @dbus.service.method(DSC_SERVICE_NAME, in_signature='', out_signature='as') def read_no_notify_config(self, no_notify_config_path): if os.path.exists(no_notify_config_path): no_notify_config_str = read_file(no_notify_config_path) try: no_notify_config = eval(no_notify_config_str) if type(no_notify_config).__name__ != "list": no_notify_config = [] except Exception: no_notify_config = [] return no_notify_config else: return [] @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def add_no_notify_pkg(self, info): pkg_name, path = info no_notify_config = self.read_no_notify_config(path) if pkg_name not in no_notify_config: pkg_name = str(pkg_name) no_notify_config.append(pkg_name) write_file(path, str(no_notify_config)) @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def remove_no_notify_pkg(self, info): pkg_name, path = info pkg_name = str(pkg_name) path = str(path) no_notify_config = self.read_no_notify_config(path) if pkg_name in no_notify_config: write_file(path, str(filter(lambda config_pkg_name: config_pkg_name != pkg_name, no_notify_config))) @dbus.service.method(DSC_SERVICE_NAME, in_signature="i", out_signature="") def init_download_manager(self, number): self.download_manager = DownloadManager(global_event, number, verbose=True) @dbus.service.method(DSC_SERVICE_NAME, in_signature="s", out_signature="") def set_download_dir(self, local_dir): apt_pkg.config.set("Dir::Cache::Archives", local_dir) self.download_dir = local_dir @dbus.service.method(DSC_SERVICE_NAME, in_signature="s", out_signature="ai") def get_download_size(self, pkg_name): total_size = 0 pkg_infos = get_pkg_download_info(self.pkg_cache, pkg_name) if pkg_infos[0] == DOWNLOAD_STATUS_NOTNEED: total_size = get_pkg_own_size(self.pkg_cache, pkg_name) size_flag = PKG_SIZE_OWN elif pkg_infos[0] == DOWNLOAD_STATUS_ERROR: total_size = -1 size_flag = PKG_SIZE_ERROR else: (names, download_urls, download_hash_infos, pkg_sizes) = pkg_infos for size in pkg_sizes: total_size += size size_flag = PKG_SIZE_DOWNLOAD return [size_flag, total_size] @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="as") def get_upgrade_download_size(self, pkg_names): real_pkg_dict, not_in_cache = parse_pkg.get_real_pkg_dict(self.pkg_cache, pkg_names) if not_in_cache: return ["-1", json.dumps([])] else: (all_change_pkgs, mark_failed_pkg_dict, marked_delete_sys_pkgs ) = parse_pkg.get_changes_pkgs(self.pkg_cache, real_pkg_dict) download_pkg_infos = parse_pkg.check_pkg_download_info(all_change_pkgs) change_pkg_names = [pkg.name for pkg in all_change_pkgs] if download_pkg_infos[0] == DOWNLOAD_STATUS_ERROR: return ["-1", json.dumps([])] elif download_pkg_infos[0] == DOWNLOAD_STATUS_NOTNEED: return ["0", json.dumps(change_pkg_names)] else: (names, download_urls, download_hash_infos, pkg_sizes) = download_pkg_infos total_size = 0 for size in pkg_sizes: total_size += size return [str(total_size), json.dumps(change_pkg_names)] @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="ai") def clean_download_cache(self): '''Clean download cache.''' # get action packages. remain_pkgs = [] for (pkg_name, info_dict) in self.download_manager.fetch_files_dict.items(): remain_pkgs.append(pkg_name) for (pkg_name, info_dict) in self.apt_action_pool.install_action_dict.items(): remain_pkgs.append(pkg_name) for (pkg_name, info_dict) in self.apt_action_pool.upgrade_action_dict.items(): remain_pkgs.append(pkg_name) # Get depend packages. remain_pkgs_paths = [] for pkg_name in remain_pkgs: result = get_pkg_dependence_file_path(self.pkg_cache, pkg_name) if not result: remain_pkgs_paths += result # Init clean size. packageNum = 0 cleanSize = 0 # Delete cache directory. cache_archive_dir = get_cache_archive_dir() if os.path.exists(cache_archive_dir): for root, folder, files in os.walk(cache_archive_dir): for file_name in files: path = os.path.join(root, file_name) if path.endswith(".deb") and (path not in remain_pkgs_paths): packageNum += 1 cleanSize += os.path.getsize(path) remove_file(path) return [packageNum, cleanSize] @dbus.service.method(DSC_SERVICE_NAME, in_signature="b", out_signature="") def say_hello(self, simulate): # Set exit_flag with False to prevent backend exit, # this just useful that frontend start again before backend exit. log("Say hello from frontend.") self.exit_flag = False self.simulate = simulate @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="") def request_quit(self): # Set exit flag. self.exit_flag = True self.exit_manager.check() self.update_signal([("frontend-quit", "")]) @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def change_source_list(self, repo_urls): ubuntu_repo_url, deepin_repo_url = repo_urls new_source_list_content = get_source_list_contents(ubuntu_repo_url, deepin_repo_url) os.system('cp %s %s.save' % (SOURCE_LIST, SOURCE_LIST)) with open(SOURCE_LIST, 'w') as fp: fp.write(new_source_list_content) @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="(sas)") # def request_upgrade_pkgs(self): // old api name def RequestUpgradeStatus(self): """ Get upgrade status @return: Return (status_code, [json.dumps(pkg_name, pkg_version)]), status code is in below constants: - normal: no dpkg action, just return packages that need to upgrade; - upgrading: in upgrading packages; - cache-updating: in updating apt cache; """ if self.in_update_list: return ("cache-updating", []) elif self.is_upgrading: return ("upgrading", []) else: cache_upgrade_pkgs = self.pkg_cache.get_upgrade_pkgs() return ("normal", cache_upgrade_pkgs) @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="s") def request_uninstall_pkgs(self): return json.dumps(self.pkg_cache.get_uninstall_pkgs()) @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="as") def request_pkgs_install_version(self, pkg_names): pkg_versions = [] for pkg_name in pkg_names: try: version = self.pkg_cache[pkg_name].versions[0].version pkg_versions.append(version) except: try: version = self.pkg_cache[pkg_name+":i386"].versions[0].version pkg_versions.append(version) except: self.update_signal([("pkg-not-in-cache", pkg_name)]) return pkg_versions @dbus.service.method(DSC_SERVICE_NAME, in_signature="s", out_signature="as") def is_pkg_in_cache(self, pkg_name): result = [] try: self.pkg_cache[pkg_name] result.append(pkg_name) except: try: pkg_name += ":i386" self.pkg_cache[pkg_name] result.append(pkg_name) except: pass return result @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="as") def request_pkgs_uninstall_version(self, pkg_names): return self.pkg_cache.get_pkgs_uninstall_version(pkg_names) @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def install_pkg(self, pkg_names): for pkg_name in pkg_names: real_pkg_name = self.get_real_pkg_name(pkg_name) if real_pkg_name: ThreadMethod(self.add_download, (real_pkg_name, ACTION_INSTALL, self.simulate)).start() else: self.update_signal([("pkg-not-in-cache", pkg_name)]) @dbus.service.method(DSC_SERVICE_NAME, in_signature="sb", out_signature="") def uninstall_pkg(self, pkg_name, purge): real_pkg_name = self.get_real_pkg_name(pkg_name) if real_pkg_name: self.apt_action_pool.add_uninstall_action(real_pkg_name, self.simulate, purge) else: self.update_signal([("pkg-not-in-cache", pkg_name)]) @dbus.service.method(DSC_SERVICE_NAME, in_signature="sb", out_signature="") def uninstall_pkg_from_desktop(self, desktop_path, purge): ThreadMethod(self.uninstall_pkg_from_desktop_thread, (desktop_path, purge)).start() def uninstall_pkg_from_desktop_thread(self, path, purge): pkg_name = self.get_pkg_name_from_path(path) if pkg_name: self.uninstall_pkg(pkg_name, purge) else: global_event.emit("action-failed", (path, ACTION_UNINSTALL, [], "no package found for path: %s" % path)) @dbus.service.method(DSC_SERVICE_NAME, in_signature="s", out_signature="s") def get_pkg_name_from_path(self, path): result = subprocess.check_output(['dpkg', '-S', path]).strip().split(":") if len(result) == 2 and result[1].strip() == path.strip(): return result[0].strip() else: return "" @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def upgrade_pkg(self, pkg_names): for pkg_name in pkg_names: real_pkg_name = self.get_real_pkg_name(pkg_name) if real_pkg_name: self.update_signal([("ready-download-start", (real_pkg_name, ACTION_UPGRADE))]) ThreadMethod(self.add_download, (real_pkg_name, ACTION_UPGRADE, self.simulate)).start() else: self.update_signal([("pkg-not-in-cache", pkg_name)]) @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def upgrade_pkgs_with_new_policy(self, pkg_names): ThreadMethod(self.add_upgrade_download_with_new_policy, (pkg_names, ACTION_UPGRADE)).start() @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def stop_download_pkg(self, pkg_names): for pkg_name in pkg_names: self.download_manager.stop_wait_download(pkg_name) @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="") def cancel_upgrade_download(self): if getattr(self, 'upgrade_id'): self.download_manager.stop_wait_download(self.upgrade_id) @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def remove_wait_missions(self, pkg_infos): self.apt_action_pool.remove_wait_missions(pkg_infos) @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def remove_wait_downloads(self, pkg_names): for pkg_name in pkg_names: self.download_manager.stop_wait_download(pkg_name) @dbus.service.method(DSC_SERVICE_NAME, in_signature="s", out_signature="s") def request_pkg_short_desc(self, pkg_name): return self.pkg_cache.get_pkg_short_desc(pkg_name) @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="as") def request_status(self): download_status = { ACTION_INSTALL : [], ACTION_UPGRADE : []} for (pkg_name, info_dict) in self.download_manager.fetch_files_dict.items(): if info_dict["action_type"] == ACTION_INSTALL: download_status[ACTION_INSTALL].append((pkg_name, info_dict["status"])) elif info_dict["action_type"] == ACTION_UPGRADE: download_status[ACTION_UPGRADE].append((pkg_name, info_dict["status"])) action_status = { ACTION_INSTALL : [], ACTION_UPGRADE : [], ACTION_UNINSTALL : []} for (pkg_name, info_dict) in self.apt_action_pool.install_action_dict.items(): action_status[ACTION_INSTALL].append((pkg_name, info_dict["status"])) for (pkg_name, info_dict) in self.apt_action_pool.upgrade_action_dict.items(): action_status[ACTION_UPGRADE].append((pkg_name, info_dict["status"])) for (pkg_name, info_dict) in self.apt_action_pool.uninstall_action_dict.items(): action_status[ACTION_UNINSTALL].append((pkg_name, info_dict["status"])) return [str(download_status), str(action_status)] @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="") def start_update_list(self): log("start update list...") self.del_source_list_d() self.pkg_cache.open(apb.OpProgress()) self.apt_action_pool.add_update_list_mission() log("start update list done") @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="ab") def request_pkgs_install_status(self, pkg_names): _status = [] for pkg in pkg_names: _status.append(self.pkg_cache.is_pkg_installed(pkg)) return _status @dbus.service.method(DSC_SERVICE_NAME, in_signature="(si)", out_signature="") def set_pkg_status(self, pkg_status): pkg_name, status = pkg_status self.pkg_cache.set_pkg_status(pkg_name, pkg_status) @dbus.service.method(DSC_SERVICE_NAME, in_signature="s", out_signature="i") def get_pkg_installed(self, pkg_name): if self.is_pkg_in_cache(pkg_name): if self.pkg_cache.is_pkg_installed(pkg_name): return 1 else: return 0 else: return -1 @dbus.service.method(DSC_SERVICE_NAME, in_signature="ss", out_signature="s") def get_pkg_start_status(self, pkg_name, start_pkg_names): is_current_installed = self.get_pkg_installed(pkg_name) if is_current_installed == -1: return "unknown" elif is_current_installed == 0: return "uninstalled" else: desktops = self.get_desktops(pkg_name) names = start_pkg_names.split(",") for name in names: if self.get_pkg_installed(name) == 1: desktops += self.get_desktops(name) return json.dumps(desktops) @dbus.service.signal(DSC_SERVICE_NAME, signature='a(sv)') # Use below command for test: # dbus-monitor --system "type='signal', interface='com.linuxdeepin.softwarecenter'" def update_signal(self, message): # The signal is emitted when this method exits # You can have code here if you wish pass
def init_download_manager(self, number): self.download_manager = DownloadManager(global_event, number, verbose=True)
class TorrentMonitor(borg.Borg): host_index = 0 retry_count = 0 def __init__(self): super(TorrentMonitor, self).__init__() log.msg('Starting up monitor') if not hasattr(self, 'initialized'): self.initialized = False self.app = config.Application() self.initialize() def initialize(self): self._initialize_hosts() if not self.initialized: self.torrent_loop = task.LoopingCall( self.search_for_torrents ) self.torrent_progress_loop = task.LoopingCall( self.download_manager.monitor_torrent_progress ) self.retry_download_loop = task.LoopingCall( self.retry_download ) deferreds = [ self.torrent_loop.start( self.app.monitor_torrent ), self.torrent_progress_loop.start( self.app.torrent_progress ), self.retry_download_loop.start( self.app.retry_download ) ] for d in deferreds: d.addErrback(self._reconnect_stores) self.initialized = True def _initialize_hosts(self): log.msg('Retry count: {}'.format(self.retry_count)) max_retries = self.app.max_retries if self.retry_count == max_retries or not self.initialized: self.retry_count = 0 hosts = self.app.pirate_bay_hosts host_config = hosts[self.host_index] web_host = "http://{}".format(host_config['host']) torrent_host = host_config['torrent_host'] use_tor = host_config['use_tor_network'] self.pirate_bay_client = ThePirateBay(web_host, use_tor) self.download_manager = DownloadManager() self.download_manager.initialize(torrent_host, use_tor, self.app) log.msg('Switching to different host') self.host_index += 1 if self.host_index == len(hosts): self.host_index = 0 else: self.retry_count += 1 def retry_download(self): log.msg('Going to reset the statuses of NOT_FOUND items in queue') TorrentQueue.update_status( new_status='PENDING', status='NOT_FOUND', async=False ) def search_for_torrents(self): log.msg('Searching for my torrents') queue = TorrentQueue.load_pending_queue(async=False) for torrent in queue: req = self.pirate_bay_client.search( query=torrent.query, optimize_query=True, order=ORDERS.SEEDERS.DES, category=CATEGORIES.VIDEO.ALL ) req.load_torrents( callback=self.on_torrents_found, errback=self.error_finding_torrents, db_id=torrent.id ) def on_torrents_found(self, torrents, db_id): """ Callback for reponse from pirate bay sites :param: list of torrents :param: the id refrencing the queue database table """ if len(torrents) > 0: log.msg('Torrent found for queue with id of {}'.format(db_id)) self.download_manager.download(torrents[0], db_id) else: log.msg('No Torrents found for queue with id of {}'.format(db_id)) TorrentQueue.update_status( new_status='NOT_FOUND', id=db_id, async=False ) self.error_finding_torrents() def error_finding_torrents(self): log.msg('Going to try again') self._initialize_hosts() def _reconnect_stores(self, error): """Reconnect all the stores if there is some problem """ if error is not None: log.err('Whooops, detected an error:') log.err(error) zstorm = getUtility(IZStorm) for name, store in zstorm.iterstores(): log.msg('Reconnecting store {}...'.format(name)) store.rollback() if not self.torrent_loop.running: time.sleep(0.5) d = self.torrent_loop.start(self.app.monitor_torrent) d.addErrback(self._reconnect_stores) if not self.torrent_progress_loop.running: time.sleep(0.5) d = self.torrent_progress_loop.start(self.app.torrent_progress) d.addErrback(self._reconnect_stores) if not self.retry_download_loop.running: time.sleep(0.5) d = self.retry_download_loop.start(self.app.retry_download) d.addErrback(self._reconnect_stores) self.error_finding_torrents()
def setUp(self): youtube = YoutubeDownloader(url=self.billboard2019_playlist()) self.dm = DownloadManager(youtube)
def __init__(self): """""" DownloadManager.__init__(self) AddDownloadsManager.__init__(self) self.session_parser = SessionParser()
class PackageManager(dbus.service.Object): ''' docs ''' def invoked_log(func): @functools.wraps(func) def wrapper(*args, **kw): info = "dbus method invoked: %s, arguments: %s" % (func.__name__, str(args[1:])) logger.debug(info) return func(*args, **kw) return wrapper def __init__(self, system_bus, mainloop): # Init dbus service. dbus.service.Object.__init__(self, system_bus, DSC_SERVICE_PATH) # Init. self.mainloop = mainloop self.pkg_cache = AptCache() self.exit_flag = False self.simulate = False self.all_upgrade_pkg_names = [] self.download_dir = "/var/cache/apt/archives" self.is_upgrading = False self.in_update_list = False self.apt_action_pool = AptActionPool(self.pkg_cache) self.apt_action_pool.start() global_event.register_event('parse-download-error', self.send_parse_download_error) global_event.register_event("action-start", self.action_start) global_event.register_event("action-update", self.action_update) global_event.register_event("action-finish", self.action_finish) global_event.register_event("action-failed", self.action_failed) global_event.register_event("download-start", self.download_start) global_event.register_event("download-update", self.download_update) global_event.register_event("download-finish", self.download_finish) global_event.register_event("download-stop", self.download_stop) global_event.register_event("download-error", self.download_failed) global_event.register_event("update-list-start", self.update_list_start) global_event.register_event("update-list-finish", self.update_list_finish) global_event.register_event("update-list-failed", self.update_list_failed) global_event.register_event("update-list-update", self.update_list_update) self.packages_status = {} self.exit_manager = ExitManager(self.mainloop, self.is_update_list_running, self.is_download_action_running, self.is_apt_action_running, self.have_exit_request) self.exit_manager.start() self.set_download_dir('/var/cache/apt/archives') self.download_manager = DownloadManager(global_event, verbose=True) def download_start(self, pkg_name, action_type): utils.set_running_lock(True) self.update_signal([("download-start", (pkg_name, action_type))]) if action_type == ACTION_UPGRADE: self.is_upgrading = True def download_update(self, pkg_name, action_type, data): self.update_signal([("download-update", (pkg_name, action_type, data)) ]) if action_type == ACTION_UPGRADE: self.is_upgrading = True def download_stop(self, pkg_name, action_type): self.update_signal([("download-stop", (pkg_name, action_type))]) self.exit_manager.check() if action_type == ACTION_UPGRADE: self.is_upgrading = False def download_failed(self, pkg_name, action_type, e): logger.error("%s download failed with %s" % (pkg_name, e)) utils.set_running_lock(False) self.update_signal([("download-failed", (pkg_name, action_type, e))]) self.exit_manager.check() if action_type == ACTION_UPGRADE: self.is_upgrading = False def download_finish(self, action_id, action_type, all_pkg_names): utils.set_running_lock(False) self.update_signal([("download-finish", (action_id, action_type))]) if action_type == ACTION_INSTALL: self.apt_action_pool.add_install_action(all_pkg_names) elif action_type == ACTION_UPGRADE: self.start_upgrade(all_pkg_names, action_id) self.is_upgrading = False self.exit_manager.check() def action_start(self, signal_content): utils.set_running_lock(True) self.update_signal([("action-start", signal_content)]) if signal_content[1] == ACTION_UPGRADE: self.is_upgrading = True def action_update(self, signal_content): self.update_signal([("action-update", signal_content)]) if signal_content[1] == ACTION_UPGRADE: self.is_upgrading = True def action_finish(self, signal_content): utils.set_running_lock(False) pkg_name, action_type, pkg_info_list = signal_content if action_type == ACTION_INSTALL: for pkg_info in pkg_info_list: self.pkg_cache.set_pkg_status( pkg_name, self.pkg_cache.PKG_STATUS_INSTALLED) elif action_type == ACTION_UPGRADE: for pkg_info in pkg_info_list: self.pkg_cache.set_pkg_status( pkg_name, self.pkg_cache.PKG_STATUS_UPGRADED) elif action_type == ACTION_UNINSTALL: for pkg_info in pkg_info_list: self.pkg_cache.set_pkg_status( pkg_name, self.pkg_cache.PKG_STATUS_UNINSTALLED) self.update_signal([("action-finish", signal_content)]) self.exit_manager.check() if signal_content[1] == ACTION_UPGRADE: self.is_upgrading = False def action_failed(self, signal_content): utils.set_running_lock(False) self.update_signal([("action-failed", signal_content)]) self.exit_manager.check() if signal_content[1] == ACTION_UPGRADE: self.is_upgrading = False def is_update_list_running(self): return self.in_update_list def is_download_action_running(self): return len(self.download_manager.download_task_info) > 0 def is_apt_action_running(self): return len(self.apt_action_pool.active_mission_list) + len( self.apt_action_pool.wait_mission_list) > 0 def have_exit_request(self): return self.exit_flag def update_list_start(self): self.in_update_list = True self.update_signal([("update-list-start", "")]) def update_list_finish(self): self.update_signal([("update-list-merge", "")]) self.pkg_cache.open(apb.OpProgress()) db_build.BuildSoftwareDB(self.pkg_cache) self.update_signal([("update-list-finish", "")]) self.in_update_list = False self.exit_manager.check() def update_list_failed(self): self.in_update_list = False self.update_signal([("update-list-failed", "")]) self.exit_manager.check() def update_list_update(self, percent, status_message, speed_str): self.update_signal([("update-list-update", (percent, status_message, speed_str))]) def handle_dbus_reply(self, *reply): logger.info("%s (reply): %s" % (self.module_dbus_name, str(reply))) def handle_dbus_error(self, *error): logger.info("%s (error): %s" % (self.module_dbus_name, str(error))) def send_parse_download_error(self, pkg_name, action_type): self.update_signal([("parse-download-error", (pkg_name, action_type))]) def get_unique_id(self): return str(uuid.uuid4()) def get_real_pkg_name(self, pkg_name): if pkg_name in self.pkg_cache: return pkg_name elif (pkg_name + ":i386") in self.pkg_cache: return pkg_name + ":i386" else: return None def dist_upgrade(self): action_type = ACTION_UPGRADE action_id = '%s_%s' % (self.get_unique_id(), action_type) self.update_signal([("ready-download-start", (action_id, action_type)) ]) dist_upgrade_changes = self.pkg_cache.get_dist_upgrade_changes() # detect and prevent the system components from being uninstalled pkg_in_white_list = [] download_pkgs = [] self.all_upgrade_pkg_names = [] for pkg in dist_upgrade_changes["delete"]: name = pkg.name if name in SYS_PKG_WHITE_LIST: pkg_in_white_list.append(name) if len(pkg_in_white_list) > 0: self.update_signal([("remove-pkgs-in-white-list", (json.dumps(pkg_in_white_list), action_type)) ]) logger.error("found remove system packages: %s" % json.dumps(pkg_in_white_list)) else: for status in dist_upgrade_changes: for pkg in dist_upgrade_changes[status]: self.all_upgrade_pkg_names.append(pkg.name) if status == "delete" or status == "keep": continue if not parse_pkg.pkg_file_has_exist(pkg): download_pkgs.append(pkg) self.update_signal([("ready-download-finish", (action_id, action_type))]) if len(download_pkgs) == 0: global_event.emit("download-finish", action_id, action_type, self.all_upgrade_pkg_names) else: names = [] download_urls = [] download_hash_infos = [] pkg_sizes = [] for pkg in download_pkgs: names.append(pkg.name) download_urls.append(pkg.candidate.uri) download_hash_infos.append(pkg.candidate.md5) pkg_sizes.append(pkg.candidate.size) self.download_manager.add_download( action_id, action_type, download_urls, download_sizes=pkg_sizes, download_md5s=download_hash_infos, all_task_names=names, all_change_pkgs=self.all_upgrade_pkg_names, file_save_dir=self.download_dir) def add_download(self, pkg_name, action_type, simulate=False): installed = self.get_pkg_installed(pkg_name) if installed == 1: self.update_signal([("pkg-installed", (pkg_name, action_type))]) return elif installed == -1: self.update_signal([("pkg-not-in-cache", (pkg_name, action_type))]) return pkg_infos = get_pkg_download_info(self.pkg_cache, pkg_name) status = pkg_infos["status"] self.update_signal([("ready-download-finish", (pkg_name, action_type)) ]) if status == DOWNLOAD_STATUS_NOTNEED: self.download_finish(pkg_name, action_type, [ pkg_name, ]) elif status == DOWNLOAD_STATUS_ERROR: self.update_signal([("parse-download-error", (pkg_name, action_type))]) else: names = [] download_urls = [] download_hash_infos = [] pkg_sizes = [] for info in pkg_infos["info"]: names.append(info["name"]) download_urls.append(info["url"]) download_hash_infos.append(info["hash"]) pkg_sizes.append(info["size"]) self.download_manager.add_download( pkg_name, action_type, download_urls, download_sizes=pkg_sizes, download_md5s=download_hash_infos, all_task_names=[pkg_name], file_save_dir=self.download_dir) def start_upgrade(self, pkg_names, action_id): self.apt_action_pool.add_multi_upgrade_mission(pkg_names, action_id) def del_source_list_d(self): white_list_path = os.path.join(get_parent_dir(__file__), 'white_list.txt') if os.path.exists(white_list_path): with open(white_list_path) as fp: for line in fp: line = line.strip() if os.path.exists(line): os.remove(line) def get_desktops(self, pkg_name): desktops = [] try: pkg_obj = self.pkg_cache[pkg_name] for f in pkg_obj.installed_files: if f.endswith(".desktop"): desktops.append(f) except: pass return desktops @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature='', out_signature='as') def read_no_notify_config(self, no_notify_config_path): if os.path.exists(no_notify_config_path): no_notify_config_str = read_file(no_notify_config_path) try: no_notify_config = eval(no_notify_config_str) if type(no_notify_config).__name__ != "list": no_notify_config = [] except Exception: no_notify_config = [] return no_notify_config else: return [] @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def add_no_notify_pkg(self, info): pkg_name, path = info no_notify_config = self.read_no_notify_config(path) if pkg_name not in no_notify_config: pkg_name = str(pkg_name) no_notify_config.append(pkg_name) write_file(path, str(no_notify_config)) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def remove_no_notify_pkg(self, info): pkg_name, path = info pkg_name = str(pkg_name) path = str(path) no_notify_config = self.read_no_notify_config(path) if pkg_name in no_notify_config: write_file( path, str( filter(lambda config_pkg_name: config_pkg_name != pkg_name, no_notify_config))) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="i", out_signature="") def init_download_manager(self, number): pass @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="s", out_signature="") def set_download_dir(self, local_dir): apt_pkg.config.set("Dir::Cache::Archives", local_dir) self.download_dir = local_dir @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="s", out_signature="ai") def get_download_size(self, pkg_name): total_size = 0 pkg_infos = get_pkg_download_info(self.pkg_cache, pkg_name) status = pkg_infos["status"] if status == DOWNLOAD_STATUS_NOTNEED: total_size = get_pkg_own_size(self.pkg_cache, pkg_name) size_flag = PKG_SIZE_OWN elif status == DOWNLOAD_STATUS_ERROR: total_size = -1 size_flag = PKG_SIZE_ERROR else: for info in pkg_infos["info"]: total_size += info["size"] size_flag = PKG_SIZE_DOWNLOAD return [size_flag, total_size] @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="ai") def clean_download_cache(self): '''Clean download cache.''' # get action packages. remain_pkgs = [] for pkg_name in self.download_manager.task_name_to_id.keys(): remain_pkgs.append(pkg_name) for pkg_name in self.apt_action_pool.install_action_dict.keys(): remain_pkgs.append(pkg_name) for pkg_name in self.apt_action_pool.upgrade_action_dict.keys(): remain_pkgs.append(pkg_name) # Get depend packages. remain_pkgs_paths = [] for pkg_name in remain_pkgs: result = get_pkg_dependence_file_path(self.pkg_cache, pkg_name) if not result: remain_pkgs_paths += result # Init clean size. packageNum = 0 cleanSize = 0 # Delete cache directory. cache_archive_dir = get_cache_archive_dir() if os.path.exists(cache_archive_dir): for root, folder, files in os.walk(cache_archive_dir): for file_name in files: path = os.path.join(root, file_name) if path.endswith(".deb") and (path not in remain_pkgs_paths): packageNum += 1 cleanSize += os.path.getsize(path) remove_file(path) return [packageNum, cleanSize] @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="b", out_signature="") def say_hello(self, simulate): # Set exit_flag with False to prevent backend exit, # this just useful that frontend start again before backend exit. self.exit_flag = False self.simulate = simulate @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="") def request_quit(self): # Set exit flag. self.exit_flag = True self.exit_manager.check() self.update_signal([("frontend-quit", "")]) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def change_source_list(self, repo_urls): ubuntu_repo_url, deepin_repo_url = repo_urls new_source_list_content = get_source_list_contents( ubuntu_repo_url, deepin_repo_url) os.system('cp %s %s.save' % (SOURCE_LIST, SOURCE_LIST)) with open(SOURCE_LIST, 'w') as fp: fp.write(new_source_list_content) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="(ss)") def RequestUpgradeStatus(self): if self.in_update_list: return ("cache-updating", json.dumps([])) elif self.is_upgrading: return ("upgrading", json.dumps([])) else: dist_upgrade_changes = self.pkg_cache.get_dist_upgrade_changes() return_infos = [] for status in dist_upgrade_changes: for pkg in dist_upgrade_changes[status]: return_infos.append( dict(status=status, name=pkg.name, version=pkg.candidate.version, size=pkg.candidate.size, downloaded=parse_pkg.pkg_file_has_exist(pkg))) return ("normal", json.dumps(return_infos)) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="a(si)", out_signature="") def RemoveWaitMissions(self, pkg_infos): self.apt_action_pool.remove_wait_missions(pkg_infos) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="s") def request_uninstall_pkgs(self): return json.dumps(self.pkg_cache.get_uninstall_pkgs()) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="as") def request_pkgs_install_version(self, pkg_names): pkg_versions = [] for pkg_name in pkg_names: try: version = self.pkg_cache[pkg_name].versions[0].version pkg_versions.append(version) except: try: version = self.pkg_cache[pkg_name + ":i386"].versions[0].version pkg_versions.append(version) except: self.update_signal([("pkg-not-in-cache", pkg_name)]) return pkg_versions @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="s", out_signature="as") def is_pkg_in_cache(self, pkg_name): result = [] try: self.pkg_cache[pkg_name] result.append(pkg_name) except: try: pkg_name += ":i386" self.pkg_cache[pkg_name] result.append(pkg_name) except: pass return result @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="as") def request_pkgs_uninstall_version(self, pkg_names): return self.pkg_cache.get_pkgs_uninstall_version(pkg_names) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def install_pkg(self, pkg_names): for pkg_name in pkg_names: real_pkg_name = self.get_real_pkg_name(pkg_name) if real_pkg_name: ThreadMethod( self.add_download, (real_pkg_name, ACTION_INSTALL, self.simulate)).start() else: self.update_signal([("pkg-not-in-cache", pkg_name)]) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="sb", out_signature="") def uninstall_pkg(self, pkg_name, purge): real_pkg_name = self.get_real_pkg_name(pkg_name) if real_pkg_name: self.apt_action_pool.add_uninstall_action(real_pkg_name, self.simulate, purge) else: self.update_signal([("pkg-not-in-cache", pkg_name)]) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="sb", out_signature="") def uninstall_pkg_from_desktop(self, desktop_path, purge): ThreadMethod(self.uninstall_pkg_from_desktop_thread, (desktop_path, purge)).start() def uninstall_pkg_from_desktop_thread(self, path, purge): pkg_name = self.get_pkg_name_from_path(path) if pkg_name: self.uninstall_pkg(pkg_name, purge) else: global_event.emit("action-failed", (path, ACTION_UNINSTALL, [], "no package found for path: %s" % path)) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="s", out_signature="s") def get_pkg_name_from_path(self, path): pkg_name = utils.file_path_to_package_name(path) if pkg_name == "" and path.endswith(".desktop"): desktop_name = os.path.split(path)[1] path = utils.desktop_name_to_desktop_path(desktop_name) pkg_name = utils.file_path_to_package_name(path) return pkg_name @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def upgrade_pkg(self, pkg_names): for pkg_name in pkg_names: real_pkg_name = self.get_real_pkg_name(pkg_name) if real_pkg_name: self.update_signal([("ready-download-start", (real_pkg_name, ACTION_UPGRADE))]) ThreadMethod( self.add_download, (real_pkg_name, ACTION_UPGRADE, self.simulate)).start() else: self.update_signal([("pkg-not-in-cache", pkg_name)]) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="") def DistUpgrade(self): ThreadMethod(self.dist_upgrade).start() @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def stop_download_pkg(self, pkg_names): for pkg_name in pkg_names: self.download_manager.stop_wait_download(pkg_name) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="") def cancel_upgrade_download(self): if getattr(self, 'upgrade_id'): self.download_manager.stop_wait_download(self.upgrade_id) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="") def remove_wait_downloads(self, pkg_names): for pkg_name in pkg_names: self.download_manager.stop_wait_download(pkg_name) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="s", out_signature="s") def request_pkg_short_desc(self, pkg_name): return self.pkg_cache.get_pkg_short_desc(pkg_name) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="as") def request_status(self): download_status = {ACTION_INSTALL: [], ACTION_UPGRADE: []} for info_dict in self.download_manager.download_task_info.values(): pkg_name = info_dict["task_name"] if info_dict["action_type"] == ACTION_INSTALL: download_status[ACTION_INSTALL].append( (pkg_name, info_dict["status"])) elif info_dict["action_type"] == ACTION_UPGRADE: download_status[ACTION_UPGRADE].append( (pkg_name, info_dict["status"])) action_status = { ACTION_INSTALL: [], ACTION_UPGRADE: [], ACTION_UNINSTALL: [] } for info_dict in self.apt_action_pool.install_action_dict.values(): pkg_name = info_dict["task_name"] action_status[ACTION_INSTALL].append( (pkg_name, info_dict["status"])) for info_dict in self.apt_action_pool.upgrade_action_dict.values(): pkg_name = info_dict["task_name"] action_status[ACTION_UPGRADE].append( (pkg_name, info_dict["status"])) for info_dict in self.apt_action_pool.uninstall_action_dict.values(): pkg_name = info_dict["task_name"] action_status[ACTION_UNINSTALL].append( (pkg_name, info_dict["status"])) return [str(download_status), str(action_status)] @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="", out_signature="") def start_update_list(self): self.del_source_list_d() self.pkg_cache.open(apb.OpProgress()) self.apt_action_pool.add_update_list_mission() @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="as", out_signature="ab") def request_pkgs_install_status(self, pkg_names): _status = [] for pkg in pkg_names: _status.append(self.pkg_cache.is_pkg_installed(pkg)) return _status @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="(si)", out_signature="") def set_pkg_status(self, pkg_status): pkg_name, status = pkg_status self.pkg_cache.set_pkg_status(pkg_name, pkg_status) @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="s", out_signature="i") def get_pkg_installed(self, pkg_name): if self.is_pkg_in_cache(pkg_name): if self.pkg_cache.is_pkg_installed(pkg_name): return 1 else: return 0 else: return -1 @invoked_log @dbus.service.method(DSC_SERVICE_NAME, in_signature="ss", out_signature="s") def get_pkg_start_status(self, pkg_name, start_pkg_names): is_current_installed = self.get_pkg_installed(pkg_name) if is_current_installed == -1: return "unknown" elif is_current_installed == 0: return "uninstalled" else: desktops = self.get_desktops(pkg_name) names = start_pkg_names.split(",") for name in names: if self.get_pkg_installed(name) == 1: desktops += self.get_desktops(name) return json.dumps(desktops) @dbus.service.signal(DSC_SERVICE_NAME, signature='a(sv)') # Use below command for test: # dbus-monitor --system "type='signal', interface='com.linuxdeepin.softwarecenter'" def update_signal(self, message): # The signal is emitted when this method exits # You can have code here if you wish info = str(message) logger.debug("dbus signal emit: %s" % info)
class PreferencesDialog: def __init__(self, config): self.config = config self.download_manager = DownloadManager() self.__get_widgets() self.__make_extensions_treeview() self.__connect_widgets() self.__add_config_notifications() # Set widget states from configuration self.status_icon_checkbutton.set_active(self.config.show_status_icon) self.main_window_checkbutton.set_active(self.config.show_main_window) self.notifications_checkbutton.set_active(self.config.show_notifications) self.quit_dialog_checkbutton.set_active(self.config.show_quit_dialog) self.autostart_checkbutton.set_active(self.config.autostart) self.main_window_checkbutton.set_sensitive(self.config.show_status_icon) if self.config.ask_for_location: self.ask_folder_radiobutton.set_active(True) else: self.specify_folder_radiobutton.set_active(True) self.default_folder_filechooserbutton.set_current_folder(self.config.default_folder) self.extensions_checkbutton.set_active(self.config.check_extensions) if not self.config.check_extensions: self.extensions_alignment.set_sensitive(False) for extension, folder in zip(self.config.extensions, self.config.extension_folders): self.extensions_model.append((extension, folder)) self.manual_proxy_vbox.set_sensitive(False) if self.config.proxy_mode == "gnome": self.gnome_radiobutton.set_active(True) elif self.config.proxy_mode == "manual": self.manual_radiobutton.set_active(True) else: self.direct_radiobutton.set_active(True) self.proxy_entry.set_text(self.config.proxy_host) self.proxy_port_spinbutton.set_value(self.config.proxy_port) self.proxy_auth_checkbutton.set_active(self.config.proxy_auth) self.proxy_auth_hbox.set_sensitive(self.config.proxy_auth) self.proxy_user_entry.set_text(self.config.proxy_user) self.proxy_password_entry.set_text(self.config.proxy_password) def __get_widgets(self): """Get widgets from the glade file.""" xml = gtk.glade.XML(gui.glade_file, domain=NAME.lower()) self.dialog = xml.get_widget("preferences_dialog") # General tab self.status_icon_checkbutton = xml.get_widget("status_icon_checkbutton") self.main_window_checkbutton = xml.get_widget("main_window_checkbutton") self.notifications_checkbutton = xml.get_widget("notifications_checkbutton") self.quit_dialog_checkbutton = xml.get_widget("quit_dialog_checkbutton") self.autostart_checkbutton = xml.get_widget("autostart_checkbutton") # Folders tab self.ask_folder_radiobutton = xml.get_widget("ask_folder_radiobutton") self.specify_folder_radiobutton = xml.get_widget("specify_folder_radiobutton") self.default_folder_filechooserbutton = xml.get_widget("default_folder_filechooserbutton") self.extensions_checkbutton = xml.get_widget("extensions_checkbutton") self.extensions_alignment = xml.get_widget("extensions_alignment") self.extensions_treeview = xml.get_widget("extensions_treeview") self.add_extension_button = xml.get_widget("add_extension_button") self.remove_extension_button = xml.get_widget("remove_extension_button") # Network tab self.direct_radiobutton = xml.get_widget("direct_radiobutton") self.gnome_radiobutton = xml.get_widget("gnome_radiobutton") self.manual_radiobutton = xml.get_widget("manual_radiobutton") self.manual_proxy_vbox = xml.get_widget("manual_proxy_vbox") self.proxy_entry = xml.get_widget("proxy_entry") self.proxy_port_spinbutton = xml.get_widget("proxy_port_spinbutton") self.proxy_auth_checkbutton = xml.get_widget("proxy_auth_checkbutton") self.proxy_auth_hbox = xml.get_widget("proxy_auth_hbox") self.proxy_user_entry = xml.get_widget("proxy_user_entry") self.proxy_password_entry = xml.get_widget("proxy_password_entry") # Buttons self.close_button = xml.get_widget("close_button") def __make_extensions_treeview(self): self.extensions_model = gtk.ListStore(str, str) self.extensions_treeview.set_model(self.extensions_model) # Extension self.extension_cell_renderer = gtk.CellRendererText() self.extension_cell_renderer.props.xpad = 3 self.extension_cell_renderer.props.ypad = 3 self.extension_cell_renderer.props.editable = True self.extension_cell_renderer.connect("edited", self.__extension_cell_renderer_edited) self.extension_treeview_column = gtk.TreeViewColumn(_("Extension"), self.extension_cell_renderer) self.extension_treeview_column.set_cell_data_func( self.extension_cell_renderer, self.__extension_cell_data_func) self.extensions_treeview.append_column(self.extension_treeview_column) # Folder folder_cell_renderer = gtk.CellRendererText() folder_cell_renderer.props.xpad = 3 folder_cell_renderer.props.ypad = 3 folder_cell_renderer.props.editable = True folder_cell_renderer.connect("edited", self.__folder_cell_renderer_edited) folder_treeview_column = gtk.TreeViewColumn(_("Folder"), folder_cell_renderer) folder_treeview_column.set_cell_data_func(folder_cell_renderer, self.__folder_cell_data_func) self.extensions_treeview.append_column(folder_treeview_column) def __extension_cell_data_func(self, column, cell, model, iter): cell.props.text = model.get_value(iter, 0) def __folder_cell_data_func(self, column, cell, model, iter): cell.props.text = model.get_value(iter, 1) def __extension_cell_renderer_edited(self, cell, path, new_text): extensions = self.config.extensions if self.extensions_model[path][0] in extensions: extensions[extensions.index(self.extensions_model[path][0])] = new_text self.config.extensions = extensions self.extensions_model[path][0] = new_text def __folder_cell_renderer_edited(self, cell, path, new_text): extension_folders = self.config.extension_folders if self.extensions_model[path][1] in extension_folders: extension_folders[extension_folders.index(self.extensions_model[path][1])] = new_text self.config.extension_folders = extension_folders self.extensions_model[path][1] = new_text def __connect_widgets(self): """Connect to the widget signals we are interested in.""" # General tab self.status_icon_checkbutton.connect("toggled", self.__status_icon_checkbutton_toggled) self.main_window_checkbutton.connect("toggled", self.__main_window_checkbutton_toggled) self.notifications_checkbutton.connect("toggled", self.__notifications_checkbutton_toggled) self.quit_dialog_checkbutton.connect("toggled", self.__quit_dialog_checkbutton_toggled) self.autostart_checkbutton.connect("toggled", self.__autostart_checkbutton_toggled) # Folders tab self.ask_folder_radiobutton.connect("toggled", self.__ask_folder_radiobutton_toggled) self.default_folder_filechooserbutton.connect("current-folder-changed", self.__default_folder_filechooserbutton_current_folder_changed) self.extensions_checkbutton.connect("toggled", self.__extensions_checkbutton_toggled) self.add_extension_button.connect("clicked", self.__add_extension_button_clicked) self.remove_extension_button.connect("clicked", self.__remove_extension_button_clicked) selection = self.extensions_treeview.get_selection() selection.connect("changed", self.__extensions_treeview_selection_changed) # Network tab self.direct_radiobutton.connect("toggled", self.__direct_radiobutton_toggled) self.gnome_radiobutton.connect("toggled", self.__gnome_radiobutton_toggled) self.manual_radiobutton.connect("toggled", self.__manual_radiobutton_toggled) self.proxy_entry.connect("changed", self.__proxy_entry_changed) self.proxy_port_spinbutton.connect("value-changed", self.__proxy_port_spinbutton_value_changed) self.proxy_auth_checkbutton.connect("toggled", self.__proxy_auth_checkbutton_toggled) self.proxy_user_entry.connect("changed", self.__proxy_user_entry_changed) self.proxy_password_entry.connect("changed", self.__proxy_password_entry_changed) # Buttons self.close_button.connect("clicked", self.__close_button_clicked) def __add_config_notifications(self): """Adds callbacks which gets called when configuration keys changes in gconf.""" self.config.add_notify(config.KEY_SHOW_STATUS_ICON, self.__show_status_icon_key_changed) self.config.add_notify(config.KEY_SHOW_MAIN_WINDOW, self.__show_main_window_key_changed) self.config.add_notify(config.KEY_SHOW_NOTIFICATIONS, self.__show_notifications_key_changed) self.config.add_notify(config.KEY_SHOW_QUIT_DIALOG, self.__show_quit_dialog_key_changed) self.config.add_notify(config.KEY_AUTOSTART, self.__autostart_key_changed) self.config.add_notify(config.KEY_ASK_FOR_LOCATION, self.__ask_for_location_key_changed) self.config.add_notify(config.KEY_DEFAULT_FOLDER, self.__default_folder_key_changed) self.config.add_notify(config.KEY_CHECK_EXTENSIONS, self.__check_extensions_key_changed) self.config.add_notify(config.KEY_PROXY_MODE, self.__proxy_mode_key_changed) self.config.add_notify(config.KEY_PROXY_HOST, self.__proxy_host_key_changed) self.config.add_notify(config.KEY_PROXY_PORT, self.__proxy_port_key_changed) self.config.add_notify(config.KEY_PROXY_AUTH, self.__proxy_auth_key_changed) self.config.add_notify(config.KEY_PROXY_USER, self.__proxy_user_key_changed) self.config.add_notify(config.KEY_PROXY_PASSWORD, self.__proxy_password_key_changed) def __show_status_icon_key_changed(self, client, cnxn_id, entry, data): if not entry.value: self.status_icon_checkbutton.set_active(True) elif entry.value.type == gconf.VALUE_BOOL: value = entry.value.get_bool() status_icon = TrayIcon() # status_icon.icon.set_visible(value) if value: status_icon.icon.show_all() else: status_icon.icon.hide_all() self.status_icon_checkbutton.set_active(value) # Main window must be showed if no status icon is showed if not value: self.main_window_checkbutton.set_sensitive(False) self.config.show_main_window = True else: if not self.main_window_checkbutton.get_property("sensitive"): self.main_window_checkbutton.set_sensitive(True) else: self.status_icon_checkbutton.set_active(True) def __show_main_window_key_changed(self, client, cnxn_id, entry, data): if not entry.value: self.main_window_checkbutton.set_active(True) elif entry.value.type == gconf.VALUE_BOOL: self.main_window_checkbutton.set_active(entry.value.get_bool()) else: self.main_window_checkbutton.set_active(True) def __show_notifications_key_changed(self, client, cnxn_id, entry, data): if not entry.value: self.notifications_checkbutton.set_active(True) elif entry.value.type == gconf.VALUE_BOOL: self.notifications_checkbutton.set_active(entry.value.get_bool()) else: self.notifications_checkbutton.set_active(True) def __show_quit_dialog_key_changed(self, client, cnxn_id, entry, data): if not entry.value: self.quit_dialog_checkbutton.set_active(True) elif entry.value.type == gconf.VALUE_BOOL: self.quit_dialog_checkbutton.set_active(entry.value.get_bool()) else: self.quit_dialog_checkbutton.set_active(True) def __autostart_key_changed(self, client, cnxn_id, entry, data): if not entry.value: self.autostart_checkbutton.set_active(True) elif entry.value.type == gconf.VALUE_BOOL: value = entry.value.get_bool() self.autostart_checkbutton.set_active(value) autostart_dir = os.path.expanduser(AUTOSTART_DIR) if value: try: item = gnomedesktop.item_new_from_basename(DESKTOP_FILE, gnomedesktop.LOAD_ONLY_IF_EXISTS) except gobject.GError: raise ValueError("File path not a .desktop file") if not item: raise ValueError("URI not found") # Looks like gnomedesktop.DesktopItem.save(str, bool) isn't # implemented so copying manually for now. if not os.path.exists(autostart_dir): os.makedirs(autostart_dir) shutil.copy2(item.get_location().replace("file://", ""), autostart_dir) else: autostart_file = os.path.join(autostart_dir, DESKTOP_FILE) if os.path.exists(autostart_file): os.remove(autostart_file) else: self.autostart_checkbutton.set_active(True) def __ask_for_location_key_changed(self, client, cnxn_id, entry, data): if not entry.value: self.ask_folder_radiobutton.set_active(True) elif entry.value.type == gconf.VALUE_BOOL: value = entry.value.get_bool() self.ask_folder_radiobutton.set_active(value) if not value: self.specify_folder_radiobutton.set_active(True) else: self.ask_folder_radiobutton.set_active(True) def __default_folder_key_changed(self, client, cnxn_id, entry, data): if entry.value.type == gconf.VALUE_STRING: folder = entry.value.to_string() self.default_folder_filechooserbutton.set_current_folder(folder) def __check_extensions_key_changed(self, client, cnxn_id, entry, data): if not entry.value: self.extensions_checkbutton.set_active(True) self.extensions_alignment.set_sensitive(True) elif entry.value.type == gconf.VALUE_BOOL: value = entry.value.get_bool() self.extensions_checkbutton.set_active(value) self.extensions_alignment.set_sensitive(value) else: self.extensions_checkbutton.set_active(True) self.extensions_alignment.set_sensitive(True) def __proxy_mode_key_changed(self, client, cnxn_id, entry, data): if entry.value.type == gconf.VALUE_STRING: mode = entry.value.to_string() if mode == "direct": self.direct_radiobutton.set_active(True) self.manual_proxy_vbox.set_sensitive(False) elif mode == "gnome": self.gnome_radiobutton.set_active(True) self.manual_proxy_vbox.set_sensitive(False) if self.config.use_http_proxy: if self.config.use_http_proxy_auth: self.download_manager.set_proxy("http", "http://%s:%s@%s:%s" % (self.config.http_proxy_user, self.config.http_proxy_pass, self.config.http_proxy_host, self.config.http_proxy_port)) if self.config.use_same_proxy: self.download_manager.set_proxy("https", "https://%s:%s@%s:%s" % (self.config.http_proxy_user, self.config.http_proxy_pass, self.config.proxy_https_host, self.config.proxy_https_port)) self.download_manager.set_proxy("ftp", "ftp://%s:%s@%s:%s" % (self.config.http_proxy_user, self.config.http_proxy_pass, self.config.proxy_ftp_host, self.config.proxy_ftp_port)) else: self.download_manager.set_proxy("http", "http://%s:%s" % (self.config.http_proxy_host, self.config.http_proxy_port)) self.download_manager.set_proxy("https", "https://%s:%s" % (self.config.proxy_https_host, self.config.proxy_https_port)) self.download_manager.set_proxy("ftp", "ftp://%s:%s" % (self.config.proxy_ftp_host, self.config.proxy_ftp_port)) elif mode == "manual": self.manual_radiobutton.set_active(True) self.manual_proxy_vbox.set_sensitive(True) if self.config.proxy_auth: self.download_manager.set_proxy("http", "http://%s:%s@%s:%s" % (self.config.proxy_user, self.config.proxy_password, self.config.proxy_host, self.config.proxy_port)) else: self.download_manager.set_proxy("http", "http://%s:%s" % (self.config.proxy_host, self.config.proxy_port)) def __proxy_host_key_changed(self, client, cnxn_id, entry, data): if entry.value.type == gconf.VALUE_STRING: self.proxy_entry.set_text(entry.value.to_string()) def __proxy_port_key_changed(self, client, cnxn_id, entry, data): if entry.value.type == gconf.VALUE_INT: self.proxy_port_spinbutton.set_value(entry.value.get_int()) def __proxy_auth_key_changed(self, client, cnxn_id, entry, data): if entry.value.type == gconf.VALUE_BOOL: auth = entry.value.get_bool() self.proxy_auth_checkbutton.set_active(auth) self.proxy_auth_hbox.set_sensitive(auth) def __proxy_user_key_changed(self, client, cnxn_id, entry, data): if entry.value.type == gconf.VALUE_STRING: self.proxy_user_entry.set_text(entry.value.to_string()) def __proxy_password_key_changed(self, client, cnxn_id, entry, data): if entry.value.type == gconf.VALUE_STRING: self.proxy_password_entry.set_text(entry.value.to_string()) def __status_icon_checkbutton_toggled(self, checkbutton): self.config.show_status_icon = checkbutton.get_active() def __main_window_checkbutton_toggled(self, checkbutton): self.config.show_main_window = checkbutton.get_active() def __notifications_checkbutton_toggled(self, checkbutton): self.config.show_notifications = checkbutton.get_active() def __quit_dialog_checkbutton_toggled(self, checkbutton): self.config.show_quit_dialog = checkbutton.get_active() def __autostart_checkbutton_toggled(self, checkbutton): self.config.autostart = checkbutton.get_active() def __ask_folder_radiobutton_toggled(self, radiobutton): active = radiobutton.get_active() self.config.ask_for_location = active self.default_folder_filechooserbutton.set_sensitive(not active) def __default_folder_filechooserbutton_current_folder_changed(self, filechooserbutton): folder = filechooserbutton.get_current_folder() # Prevent infinite loop if self.config.default_folder != folder: self.config.default_folder = folder def __extensions_checkbutton_toggled(self, checkbutton): self.config.check_extensions = checkbutton.get_active() def __extensions_treeview_selection_changed(self, selection): """When selection changes set sensitivity appropriately.""" (extensions_model, extensions_iter) = selection.get_selected() if extensions_iter: self.remove_extension_button.set_sensitive(True) else: self.remove_extension_button.set_sensitive(False) def __add_extension_button_clicked(self, button): extensions = self.config.extensions extensions.append("*.*") self.config.extensions = extensions extension_folders = self.config.extension_folders extension_folders.append(self.config.default_folder) self.config.extension_folders = extension_folders iter = self.extensions_model.append(("*.*", self.config.default_folder)) path = self.extensions_model.get_path(iter) self.extensions_treeview.set_cursor_on_cell(path, self.extension_treeview_column, self.extension_cell_renderer, True) def __remove_extension_button_clicked(self, button): selection = self.extensions_treeview.get_selection() (extensions_model, extensions_iter) = selection.get_selected() if extensions_iter: extension = extensions_model.get_value(extensions_iter, 0) extension_folder = extensions_model.get_value(extensions_iter, 1) extensions_model.remove(extensions_iter) extensions = self.config.extensions if extension in extensions: extensions.remove(extension) self.config.extensions = extensions extension_folders = self.config.extension_folders if extension_folder in extension_folders: extension_folders.remove(extension_folder) self.config.extension_folders = extension_folders def __direct_radiobutton_toggled(self, radiobutton): if radiobutton.get_active(): self.config.proxy_mode = "direct" def __gnome_radiobutton_toggled(self, radiobutton): if radiobutton.get_active(): self.config.proxy_mode = "gnome" def __manual_radiobutton_toggled(self, radiobutton): if radiobutton.get_active(): self.config.proxy_mode = "manual" def __proxy_entry_changed(self, entry): self.config.proxy_host = entry.get_text() def __proxy_port_spinbutton_value_changed(self, spinbutton): self.config.proxy_port = spinbutton.get_value_as_int() def __proxy_auth_checkbutton_toggled(self, checkbutton): self.config.proxy_auth = checkbutton.get_active() def __proxy_user_entry_changed(self, entry): self.config.proxy_user = entry.get_text() def __proxy_password_entry_changed(self, entry): self.config.proxy_password = entry.get_text() def __close_button_clicked(self, button): self.dialog.hide()
def download(self,item=None): item = self.audios[self.count] if type(item)!=vk_audio.AudioObj else item; DownloadManager.get().download(item);