def load_config(self, parser): import ConfigParser config_name = 'config.ini' config = ConfigParser.ConfigParser() configs = [] path = os.path.join(os.path.dirname(sys.executable), config_name) if os.path.exists(path): configs.append(path) if os.path.exists(config_name): configs.append(config_name) user_ini = os.path.expanduser(os.path.join(self.default_home, config_name)) if os.path.exists(user_ini): configs.append(user_ini) if len(configs) > 0: config.read(configs) if config.has_option(ConfigParser.DEFAULTSECT, 'env'): env = config.get(ConfigParser.DEFAULTSECT, 'env') args = AbstractOSIntegration.get(None).get_system_configuration() for item in config.items(env): if item[0] == 'env': continue args[item[0].replace('-', '_')] = item[1] if len(args): parser.set_defaults(**args) else: parser.set_defaults(**AbstractOSIntegration.get(None).get_system_configuration())
def load_config(self, parser): import ConfigParser config_name = 'config.ini' config = ConfigParser.ConfigParser() configs = [] path = os.path.join(os.path.dirname(sys.executable), config_name) if os.path.exists(path): configs.append(path) if os.path.exists(config_name): configs.append(config_name) user_ini = os.path.expanduser( os.path.join(self.default_home, config_name)) if os.path.exists(user_ini): configs.append(user_ini) if len(configs) > 0: config.read(configs) if config.has_option(ConfigParser.DEFAULTSECT, 'env'): env = config.get(ConfigParser.DEFAULTSECT, 'env') args = AbstractOSIntegration.get(None).get_system_configuration() for item in config.items(env): if item[0] == 'env': continue args[item[0].replace('-', '_')] = item[1] if len(args): parser.set_defaults(**args) else: parser.set_defaults( **AbstractOSIntegration.get(None).get_system_configuration())
def load_config(self, parser): import ConfigParser config_name = 'config.ini' config = ConfigParser.ConfigParser() configs = [] path = os.path.join(os.path.dirname(sys.executable), config_name) if os.path.exists(path): configs.append(path) if os.path.exists(config_name): configs.append(config_name) user_ini = os.path.expanduser( os.path.join(Options.nxdrive_home, config_name)) if os.path.exists(user_ini): configs.append(user_ini) if configs: config.read(configs) args = AbstractOSIntegration.get(None).get_system_configuration() if config.has_option(ConfigParser.DEFAULTSECT, 'env'): env = config.get(ConfigParser.DEFAULTSECT, 'env') for item in config.items(env): if item[0] == 'env': continue value = item[1] if value == '': continue if '\n' in item[1]: # Treat multiline option as a set value = tuple(sorted(item[1].split())) args[item[0].replace('-', '_')] = value if args: Options.update(args, setter='local') parser.set_defaults(**args)
def load_config(self, parser): import ConfigParser config_name = 'config.ini' config = ConfigParser.ConfigParser() configs = [] path = os.path.join(os.path.dirname(sys.executable), config_name) if os.path.exists(path): configs.append(path) if os.path.exists(config_name): configs.append(config_name) user_ini = os.path.expanduser(os.path.join(Options.nxdrive_home, config_name)) if os.path.exists(user_ini): configs.append(user_ini) if configs: config.read(configs) args = AbstractOSIntegration.get(None).get_system_configuration() if config.has_option(ConfigParser.DEFAULTSECT, 'env'): env = config.get(ConfigParser.DEFAULTSECT, 'env') for item in config.items(env): if item[0] == 'env': continue value = item[1] if value == '': continue if '\n' in item[1]: # Treat multiline option as a set value = tuple(sorted(item[1].split())) args[item[0].replace('-', '_')] = value if args: Options.update(args, setter='local') parser.set_defaults(**args)
def test_folder_registration(): path = Path("TestCazz") # Unregister first; to ensure favorite bar is cleaned. osi = AbstractOSIntegration.get(None) osi.unregister_folder_link(path) assert not is_folder_registered(osi, path.name) osi.register_folder_link(path) assert is_folder_registered(osi, path.name) osi.unregister_folder_link(path) assert not is_folder_registered(osi, path.name)
def test_folder_registration(): name = "TestCazz" # Unregister first; to ensure favorite bar is cleaned. osi = AbstractOSIntegration.get(None) osi.unregister_folder_link(name) assert not is_folder_registered(osi, name) osi.register_folder_link(".", name) assert is_folder_registered(osi, name) osi.unregister_folder_link(name) assert not is_folder_registered(osi, name)
def test_folder_registration(self): name = "TestCazz" # Unregister first; to ensure favorite bar is cleaned. os = AbstractOSIntegration.get(None) os.unregister_folder_link(name) self.assertFalse(self._is_folder_registered(name)) os.register_folder_link(".", name) self.assertTrue(self._is_folder_registered(name)) os.unregister_folder_link(name) self.assertFalse(self._is_folder_registered(name)) assert 1
def test_folder_registration(self): try: name = "TestCazz" # Unregister first; to ensure favorite bar is cleaned. os = AbstractOSIntegration.get(None) os.unregister_folder_link(name) self.assertFalse(self._is_folder_registered(name)) os.register_folder_link(".", name) self.assertTrue(self._is_folder_registered(name)) os.unregister_folder_link(name) self.assertFalse(self._is_folder_registered(name)) assert 1 except ImportError: # Sometimes you cannot import LSSharedFileListCreate pass
def fatal_error_qt(exc_formatted: str) -> None: """Display a "friendly" dialog box on fatal error using Qt.""" from PyQt5.QtCore import Qt, QUrl from PyQt5.QtGui import QDesktopServices, QIcon from PyQt5.QtWidgets import ( QApplication, QDialog, QDialogButtonBox, QLabel, QTextEdit, QVBoxLayout, ) from nxdrive.translator import Translator from nxdrive.utils import find_icon, find_resource def section(header: str, content: str) -> str: """Format a "section" of information.""" return f"{header}\n```\n{content.strip()}\n```" Translator(find_resource("i18n")) tr = Translator.get app = QApplication([]) app.setQuitOnLastWindowClosed(True) dialog = QDialog() dialog.setWindowTitle(tr("FATAL_ERROR_TITLE", [APP_NAME])) dialog.setWindowIcon(QIcon(str(find_icon("app_icon.svg")))) dialog.resize(800, 600) layout = QVBoxLayout() css = "font-family: monospace; font-size: 12px;" details = [] # Display a little message to apologize info = QLabel(tr("FATAL_ERROR_MSG", [APP_NAME, COMPANY])) info.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter) layout.addWidget(info) # Display CLI arguments if sys.argv[1:]: text = tr("FATAL_ERROR_CLI_ARGS") label_cli = QLabel(text) label_cli.setAlignment(Qt.AlignVCenter) cli_args = QTextEdit() cli_args.setStyleSheet(css) cli_args.setReadOnly(True) args = "\n".join(arg for arg in sys.argv[1:]) details.append(section(text, args)) cli_args.setText(args) cli_args.setSizeAdjustPolicy(QTextEdit.AdjustToContents) layout.addWidget(label_cli) layout.addWidget(cli_args) # Display the exception text = tr("FATAL_ERROR_EXCEPTION") label_exc = QLabel(text) label_exc.setAlignment(Qt.AlignVCenter) exception = QTextEdit() exception.setStyleSheet(css) exception.setReadOnly(True) details.append(section(text, exc_formatted)) exception.setText(exc_formatted) layout.addWidget(label_exc) layout.addWidget(exception) # Display last lines from the memory log with suppress(Exception): from nxdrive.report import Report # Last 20th lines raw_lines = Report.export_logs(-20) lines = b"\n".join(raw_lines).decode(errors="replace") if lines: text = tr("FATAL_ERROR_LOGS") label_log = QLabel(text) details.append(section(text, lines)) label_log.setAlignment(Qt.AlignVCenter) layout.addWidget(label_log) logs = QTextEdit() logs.setStyleSheet(css) logs.setReadOnly(True) logs.setLineWrapColumnOrWidth(4096) logs.setLineWrapMode(QTextEdit.FixedPixelWidth) logs.setText(lines) layout.addWidget(logs) def open_update_site() -> None: """Open the update web site.""" with suppress(Exception): QDesktopServices.openUrl(QUrl(Options.update_site_url)) # Buttons buttons = QDialogButtonBox() buttons.setStandardButtons(QDialogButtonBox.Ok) buttons.accepted.connect(dialog.close) update_button = buttons.addButton(tr("FATAL_ERROR_UPDATE_BTN"), QDialogButtonBox.ActionRole) update_button.setToolTip(tr("FATAL_ERROR_UPDATE_TOOLTIP", [APP_NAME])) update_button.clicked.connect(open_update_site) layout.addWidget(buttons) def copy() -> None: """Copy details to the clipboard and change the text of the button. """ osi.cb_set("\n".join(details)) copy_paste.setText(tr("FATAL_ERROR_DETAILS_COPIED")) # "Copy details" button with suppress(Exception): from nxdrive.osi import AbstractOSIntegration osi = AbstractOSIntegration.get(None) copy_paste = buttons.addButton(tr("FATAL_ERROR_DETAILS_COPY"), QDialogButtonBox.ActionRole) copy_paste.clicked.connect(copy) dialog.setLayout(layout) dialog.show() app.exec_()
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__() self._autolock_service = None self.client_version = __version__ 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.engine import Engine self._engine_types["NXDRIVE"] = Engine 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("drive_edit_auto_lock") if res is None: self._dao.update_config("update_url", "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) # Create DriveEdit self._create_autolock_service() self._create_drive_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()
def _is_folder_registered(self, name): os = AbstractOSIntegration.get(None) lst = os._get_favorite_list() return os._find_item_in_list(lst, name) is not None
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 = dict() 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) # 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()
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) # 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()