def set_rate_limit_changed(new_upload_rate, new_download_rate): try: current_upload_rate = int(Manager.get()._dao.get_config('upload_rate', -1)) except ValueError: current_upload_rate = -1 try: current_download_rate = int(Manager.get()._dao.get_config('download_rate', -1)) except ValueError: current_download_rate = -1 change = not (new_upload_rate == current_upload_rate and new_download_rate == current_download_rate) if not change: return slower = new_upload_rate < current_upload_rate or new_download_rate < current_download_rate if slower: # change processors first, then update the rate(s) ConfigWatcher.ConfigModifiedEventHandler.change_processors(new_upload_rate, new_download_rate) if new_upload_rate != current_upload_rate: BaseAutomationClient.set_upload_rate_limit(new_upload_rate) Manager.get()._dao.update_config('upload_rate', new_upload_rate) log.trace('update upload rate: %s', str(BaseAutomationClient.upload_token_bucket)) if new_download_rate != current_download_rate: BaseAutomationClient.set_download_rate_limit(new_download_rate) Manager.get()._dao.update_config('download_rate', new_download_rate) log.trace('update download rate: %s', str(BaseAutomationClient.download_token_bucket)) if change and new_upload_rate > current_upload_rate and new_download_rate > current_download_rate: # changed rate(s) first, then change processors ConfigWatcher.ConfigModifiedEventHandler.change_processors(new_upload_rate, new_download_rate)
def load(self): if self._engine_definitions is None: self._engine_definitions = self._dao.get_engines() in_error = dict() self._engines = dict() for engine in self._engine_definitions: if not engine.engine in self._engine_types: log.warn("Can't find engine %s anymore", engine.engine) if not engine.engine in in_error: in_error[engine.engine] = True self.engineNotFound.emit(engine) self._engines[engine.uid] = self._engine_types[engine.engine]( self, engine, remote_watcher_delay=self.remote_watcher_delay, processors=get_number_of_processors(BaseAutomationClient.get_upload_rate_limit(), BaseAutomationClient.get_download_rate_limit())) self._engines[engine.uid].online.connect(self._force_autoupdate) self.initEngine.emit(self._engines[engine.uid])
def bind_engine(self, engine_type, local_folder, name, binder, starts=True): """Bind a local folder to a remote nuxeo server""" if name is None and hasattr(binder, 'url'): name = self._get_engine_name(binder.url) if hasattr(binder, 'url'): url = binder.url if '#' in url: # Last part of the url is the engine type engine_type = url.split('#')[1] binder.url = url.split('#')[0] log.debug("Engine type has been specified in the url: %s will be used", engine_type) if not self.check_local_folder_available(local_folder): raise FolderAlreadyUsed() if not engine_type in self._engine_types: raise EngineTypeMissing() if self._engines is None: self.load() local_folder = normalized_path(local_folder) if local_folder == self.get_configuration_folder(): # Prevent from binding in the configuration folder raise FolderAlreadyUsed() uid = uuid.uuid1().hex # TODO Check that engine is not inside another or same position engine_def = self._dao.add_engine(engine_type, local_folder, uid, name) try: self._engines[uid] = self._engine_types[engine_type]( self, engine_def, binder=binder, remote_watcher_delay=self.remote_watcher_delay, processors=get_number_of_processors(BaseAutomationClient.get_upload_rate_limit(), BaseAutomationClient.get_download_rate_limit())) self._engine_definitions.append(engine_def) except Exception as e: log.exception(e) if uid in self._engines: del self._engines[uid] self._dao.delete_engine(uid) # TODO Remove the db ? raise e # As new engine was just bound, refresh application update status self.refresh_update_status() if starts: self._engines[uid].start() self.newEngine.emit(self._engines[uid]) return self._engines[uid]
def __init__(self, options): ''' Constructor ''' if Manager._singleton is not None: raise Exception("Only one instance of Manager can be create") Manager._singleton = self super(Manager, self).__init__() # Let's bypass HTTPS verification unless --consider-ssl-errors is passed # since many servers unfortunately have invalid certificates. # See https://www.python.org/dev/peps/pep-0476/ # and https://jira.nuxeo.com/browse/NXDRIVE-506 if not options.consider_ssl_errors: log.warn("--consider-ssl-errors option is False, won't verify HTTPS certificates") import ssl try: _create_unverified_https_context = ssl._create_unverified_context except AttributeError: log.info("Legacy Python that doesn't verify HTTPS certificates by default") else: log.info("Handle target environment that doesn't support HTTPS verification:" " globally disable verification by monkeypatching the ssl module though highly discouraged") ssl._create_default_https_context = _create_unverified_https_context else: log.info("--consider-ssl-errors option is True, will verify HTTPS certificates") self._autolock_service = None self.nxdrive_home = os.path.expanduser(options.nxdrive_home) self.nxdrive_home = os.path.realpath(self.nxdrive_home) if not os.path.exists(self.nxdrive_home): os.mkdir(self.nxdrive_home) self.remote_watcher_delay = options.delay self._nofscheck = options.nofscheck self._debug = options.debug self._engine_definitions = None self._engine_types = dict() from nxdrive.engine.next.engine_next import EngineNext from nxdrive.engine.engine import Engine self._engine_types["NXDRIVE"] = Engine self._engine_types["NXDRIVENEXT"] = EngineNext self._engines = None self.proxies = None self.proxy_exceptions = None self._app_updater = None self._dao = None self._create_dao() if options.proxy_server is not None: proxy = ProxySettings() proxy.from_url(options.proxy_server) proxy.save(self._dao) # Now we can update the logger if needed if options.log_level_file is not None: # Set the log_level_file option handler = self._get_file_log_handler() if handler is not None: handler.setLevel(options.log_level_file) # Store it in the database self._dao.update_config("log_level_file", str(handler.level)) else: # No log_level provide, use the one from db default is INFO self._update_logger(int(self._dao.get_config("log_level_file", "20"))) # Add auto lock on edit res = self._dao.get_config("direct_edit_auto_lock") if res is None: self._dao.update_config("direct_edit_auto_lock", "1") # Persist update URL infos self._dao.update_config("update_url", options.update_site_url) self._dao.update_config("beta_update_url", options.beta_update_site_url) self.refresh_proxies() self._os = AbstractOSIntegration.get(self) # setup the bandwidth rate limits upload_rate = self._dao.get_config('upload_rate') or options.upload_rate or -1 BaseAutomationClient.set_upload_rate_limit(upload_rate) log.debug('upload rate: %s', str(BaseAutomationClient.upload_token_bucket)) download_rate = self._dao.get_config('download_rate') or options.download_rate or -1 BaseAutomationClient.set_download_rate_limit(download_rate) log.debug('download rate: %s', str(BaseAutomationClient.download_token_bucket)) self.config_watcher = ConfigWatcher() # Create DirectEdit self._create_autolock_service() self._create_direct_edit(options.protocol_url) # Create notification service self._script_engine = None self._script_object = None self._create_notification_service() self._started = False # Pause if in debug self._pause = self.is_debug() self.device_id = self._dao.get_config("device_id") self.updated = False # self.update_version() if self.device_id is None: self.generate_device_id() self.load() # Create the application update verification thread self._create_updater(options.update_check_delay) # Force language if options.force_locale is not None: self.set_config("locale", options.force_locale) # Setup analytics tracker self._tracker = None if self.get_tracking(): self._create_tracker()