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 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()
