def main():
sys.excepthook = excepthook
QApplication.setDesktopSettingsAware(False)
QApplication.setStyle(QStyleFactory.create("Fusion"))
app = QApplication(sys.argv)
app.setAttribute(QtCore.Qt.AA_UseHighDpiPixmaps)
sys.stderr.write("\n")
cli = BaseCLI(
"DERIVA Authentication Agent",
"For more information see: https://github.com/informatics-isi-edu/deriva-qt",
VERSION)
cli.parser.add_argument(
"--cookie-persistence",
action="store_true",
help="Enable cookie and local storage persistence for QtWebEngine.")
args = cli.parse_cli()
config = read_config(args.config_file,
create_default=False) if args.config_file else None
authWindow = AuthWindow(config,
args.credential_file,
cookie_persistence=args.cookie_persistence)
authWindow.show()
ret = app.exec_()
return ret
def configure(self, config, credential_file):
self.config = config if config else read_config(
self.config_file, create_default=True, default=DEFAULT_CONFIG)
self.credential_file = credential_file
host = self.config.get("host")
if not host:
self.setHtml(
ERROR_HTML %
"Could not locate hostname parameter in configuration.")
return
self.auth_url = QUrl()
self.auth_url.setScheme(config.get("protocol", "https"))
self.auth_url.setHost(host)
if config.get("port") is not None:
self.auth_url.setPort(config["port"])
self.authn_cookie_name = self.config.get("cookie_name", "webauthn")
retries = Retry(
connect=DEFAULT_SESSION_CONFIG['retry_connect'],
read=DEFAULT_SESSION_CONFIG['retry_read'],
backoff_factor=DEFAULT_SESSION_CONFIG['retry_backoff_factor'],
status_forcelist=DEFAULT_SESSION_CONFIG['retry_status_forcelist'])
self._session.mount(self.auth_url.toString() + '/',
HTTPAdapter(max_retries=retries))
def __init__(self, **kwargs):
client_id = kwargs.get("client_id")
client_secret = kwargs.get("client_secret")
if not (client_id and client_secret):
cred_file = kwargs.get("credential_file", CLIENT_CRED_FILE)
creds = read_config(cred_file)
if creds:
client = creds.get("web")
if client:
client_id = client.get('client_id')
client_secret = client.get('client_secret')
try:
global GLOBUS_SDK, GlobusAuthAPIError
GLOBUS_SDK = importlib.import_module("globus_sdk")
GlobusAuthAPIError = GLOBUS_SDK.AuthAPIError
except Exception as e:
raise DependencyError("Unable to load a required module: %s" %
format_exception(e))
if not (client_id and client_secret):
logging.warning(
"Client ID and secret not specified and/or could not be determined."
)
self.client = GLOBUS_SDK.ConfidentialAppAuthClient(
client_id, client_secret)
self.client_id = client_id
def __init__(self,
config,
credential_file=None,
cookie_persistence=False,
authentication_success_callback=None,
authentication_failure_callback=None,
log_level=logging.INFO):
super(AuthWindow, self).__init__()
self.config = config
self.log_level = log_level
self.credential_file = credential_file if credential_file else DEFAULT_CREDENTIAL_FILE
self.cookie_persistence = cookie_persistence
self.authentication_success_callback = \
self.successCallback if not authentication_success_callback else authentication_success_callback
self.authentication_failure_callback = \
self.failureCallback if not authentication_failure_callback else authentication_failure_callback
self.window_icon = QIcon(":/images/keys.png")
qApp.setWindowIcon(QIcon(self.window_icon))
self.systemTrayIcon = QSystemTrayIcon(self)
self.systemTrayIcon.setIcon(self.window_icon)
self.systemTrayIcon.setVisible(True)
self.systemTrayIcon.activated.connect(self.on_systemTrayIcon_activated)
if not self.config:
self.config = read_config(DEFAULT_CONFIG_FILE,
create_default=True,
default=DEFAULT_CONFIG)
self.ui = AuthWindowUI(self)
self.hide()
self.populateServerList()
self.show()
self.on_actionLogin_triggered()
qApp.aboutToQuit.connect(self.logout)
def configure(self, config_path):
# configure logging
self.ui.logTextBrowser.widget.log_update_signal.connect(self.updateLog)
self.ui.logTextBrowser.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
logging.getLogger().addHandler(self.ui.logTextBrowser)
logging.getLogger().setLevel(logging.INFO)
# configure Ermrest/Hatrac
if not config_path:
config_path = os.path.join(os.path.expanduser(
os.path.normpath("~/.deriva/synapse/synspy-launcher")), "config.json")
self.config_path = config_path
config = read_config(self.config_path, create_default=True, default=DEFAULT_CONFIG)
protocol = config["server"]["protocol"]
self.server = config["server"]["host"]
catalog_id = config["server"]["catalog_id"]
session_config = config.get("session")
self.catalog = ErmrestCatalog(protocol, self.server, catalog_id, self.credential, session_config=session_config)
self.store = HatracStore(protocol, self.server, self.credential, session_config=session_config)
# create working dir (tempdir)
self.tempdir = tempfile.mkdtemp(prefix="synspy_")
# determine viewer mode
self.use_3D_viewer = True if config.get("viewer_mode", "2d").lower() == "3d" else False
# curator mode?
curator_mode = config.get("curator_mode")
if not curator_mode:
config["curator_mode"] = False
self.curator_mode = config.get("curator_mode")
# save config
self.config = config
write_config(self.config_path, self.config)
def _is_processor_whitelisted(processor_type, **kwargs):
if kwargs.get("bypass_whitelist", False):
return True
config_file_path = kwargs.get("config_file_path")
config = read_config(config_file=config_file_path)
whitelist = config.get("upload_processor_whitelist", [])
return processor_type in whitelist
def __init__(self, server,
output_dir=None, kwargs=None, config=None, config_file=None, credentials=None, credential_file=None):
self.server = server
self.hostname = None
self.output_dir = output_dir if output_dir else "."
self.envars = kwargs if kwargs else dict()
self.catalog = None
self.store = None
self.config = config
self.cancelled = False
self.credentials = credentials if credentials else dict()
self.metadata = dict()
self.sessions = dict()
info = "%s v%s [Python %s, %s]" % (
self.__class__.__name__, VERSION, platform.python_version(), platform.platform(aliased=True))
logging.info("Initializing downloader: %s" % info)
if not self.server:
raise RuntimeError("Server not specified!")
# server variable initialization
self.hostname = self.server.get('host', '')
if not self.hostname:
raise RuntimeError("Host not specified!")
protocol = self.server.get('protocol', 'https')
self.server_url = protocol + "://" + self.hostname
catalog_id = self.server.get("catalog_id", "1")
session_config = self.server.get('session')
# credential initialization
if credential_file:
self.credentials = get_credential(self.hostname, credential_file)
# catalog and file store initialization
if self.catalog:
del self.catalog
self.catalog = ErmrestCatalog(
protocol, self.hostname, catalog_id, self.credentials, session_config=session_config)
if self.store:
del self.store
self.store = HatracStore(
protocol, self.hostname, self.credentials, session_config=session_config)
# process config file
if config_file and os.path.isfile(config_file):
self.config = read_config(config_file)
def getUpdatedConfig(self):
# if we are using an overridden config file, skip the update check
if self.override_config_file:
return
logging.info("Checking for updated configuration...")
remote_config = self.getRemoteConfig()
if not remote_config:
logging.info(
"Remote configuration not present, using default local configuration file."
)
return
deployed_config_file_path = self.getDeployedConfigFilePath()
if os.path.isfile(deployed_config_file_path):
current_md5 = hu.compute_file_hashes(deployed_config_file_path,
hashes=['md5'])['md5'][0]
else:
logging.info("Local config not found.")
current_md5 = None
tempdir = tempfile.mkdtemp(prefix="deriva_upload_")
if os.path.exists(tempdir):
updated_config_path = os.path.abspath(
os.path.join(tempdir, DerivaUpload.DefaultConfigFileName))
with io.open(updated_config_path,
'w',
newline='\n',
encoding='utf-8') as config:
config.write(
json.dumps(remote_config,
ensure_ascii=False,
sort_keys=True,
separators=(',', ': '),
indent=2))
new_md5 = hu.compute_file_hashes(updated_config_path,
hashes=['md5'])['md5'][0]
if current_md5 != new_md5:
logging.info("Updated configuration found.")
config = read_config(updated_config_path)
self._update_internal_config(config)
else:
logging.info("Configuration is up-to-date.")
config = None
shutil.rmtree(tempdir, ignore_errors=True)
return config
def __init__(self, server, **kwargs):
self.server = server
self.hostname = None
self.catalog = None
self.store = None
self.cancelled = False
self.output_dir = os.path.abspath(kwargs.get("output_dir", "."))
self.envars = kwargs.get("envars", dict())
self.config = kwargs.get("config")
self.credentials = kwargs.get("credentials", dict())
config_file = kwargs.get("config_file")
credential_file = kwargs.get("credential_file")
self.metadata = dict()
self.sessions = dict()
info = "%s v%s [Python %s, %s]" % (
self.__class__.__name__, get_installed_version(VERSION),
platform.python_version(), platform.platform(aliased=True))
logging.info("Initializing downloader: %s" % info)
if not self.server:
raise DerivaDownloadConfigurationError("Server not specified!")
# server variable initialization
self.hostname = self.server.get('host', '')
if not self.hostname:
raise DerivaDownloadConfigurationError("Host not specified!")
protocol = self.server.get('protocol', 'https')
self.server_url = protocol + "://" + self.hostname
catalog_id = self.server.get("catalog_id", "1")
session_config = self.server.get('session')
# credential initialization
token = kwargs.get("token")
oauth2_token = kwargs.get("oauth2_token")
username = kwargs.get("username")
password = kwargs.get("password")
if credential_file:
self.credentials = get_credential(self.hostname, credential_file)
elif token or oauth2_token or (username and password):
self.credentials = format_credential(token=token,
oauth2_token=oauth2_token,
username=username,
password=password)
# catalog and file store initialization
if self.catalog:
del self.catalog
self.catalog = ErmrestCatalog(protocol,
self.hostname,
catalog_id,
self.credentials,
session_config=session_config)
if self.store:
del self.store
self.store = HatracStore(protocol,
self.hostname,
self.credentials,
session_config=session_config)
# init dcctx cid to a default
self.set_dcctx_cid(self.__class__.__name__)
# process config file
if config_file:
try:
self.config = read_config(config_file)
except Exception as e:
raise DerivaDownloadConfigurationError(e)
def initialize(self, cleanup=False):
info = "%s v%s [Python %s, %s]" % (self.__class__.__name__, VERSION,
platform.python_version(),
platform.platform(aliased=True))
logging.info("Initializing uploader: %s" % info)
# cleanup invalidates the current configuration and credentials in addition to clearing internal state
if cleanup:
self.cleanup()
# reset just clears the internal state
else:
self.reset()
if not self.server:
logging.warning(
"A server was not specified and an internal default has not been set."
)
return
# server variable initialization
protocol = self.server.get('protocol', 'https')
host = self.server.get('host', '')
self.server_url = protocol + "://" + host
catalog_id = self.server.get("catalog_id", "1")
session_config = self.server.get('session')
# overriden credential initialization
if self.override_credential_file:
self.credentials = get_credential(host, self.override_config_file)
# catalog and file store initialization
if self.catalog:
del self.catalog
self.catalog = ErmrestCatalog(protocol,
host,
catalog_id,
self.credentials,
session_config=session_config)
if self.store:
del self.store
self.store = HatracStore(protocol,
host,
self.credentials,
session_config=session_config)
# transfer state initialization
self.loadTransferState()
"""
Configuration initialization - this is a bit complex because we allow for:
1. Run-time overriding of the config file location.
2. Sub-classes of this class to bundle their own default configuration files in an arbitrary location.
3. The updating of already deployed configuration files if bundled internal defaults are newer.
"""
config_file = self.override_config_file if self.override_config_file else None
# 1. If we don't already have a valid (i.e., overridden) path to a config file...
if not (config_file and os.path.isfile(config_file)):
# 2. Get the currently deployed config file path, which could possibly be overridden by subclass
config_file = self.getDeployedConfigFilePath()
# 3. If the deployed default path is not valid, OR, it is valid AND is older than the bundled default
if (not (config_file and os.path.isfile(config_file))
or self.isFileNewer(self.getDefaultConfigFilePath(),
self.getDeployedConfigFilePath())):
# 4. If we can locate a bundled default config file,
if os.path.isfile(self.getDefaultConfigFilePath()):
# 4.1 Copy the bundled default config file to the deployment-specific config path
copy_config(self.getDefaultConfigFilePath(), config_file)
else:
# 4.2 Otherwise, fallback to writing a failsafe default based on internal hardcoded settings
write_config(config_file, DefaultConfig)
# 5. Finally, read the resolved configuration file into a config object
self._update_internal_config(read_config(config_file))
def getServers(cls):
return read_config(os.path.join(cls.getDeployedConfigPath(),
cls.DefaultServerListFileName),
create_default=True,
default=[])
def is_processor_whitelisted(processor_type, **kwargs):
config_file_path = kwargs.get("config_file_path")
config = read_config(config_file=config_file_path)
whitelist = config.get("download_processor_whitelist", [])
return processor_type in whitelist
