def get_user_private_keys_info(self):
"""
Gets info of all user keys and returns it in form of dictionary:
{
"pkfp": {
"pkfp": "pkfp",
"alias": "alias",
"created": <date>
}
}
"pkfp is public key SHA256"
:return:
"""
keys = os.listdir(get_full_path(self.user_keys_path))
res = {}
for key in keys:
try:
with open(
get_full_path(
os.path.join(self.user_keys_path, key,
KEY_INFO_FILENAME)), "r") as fp:
res[key] = json.load(fp)
except Exception as e:
log.error("Error getting key info: %s " % str(e))
return res
def vboxmanage_select_path(self):
res = QFileDialog.getOpenFileName(parent=self,
filter='vboxmanage.exe',
directory=get_full_path(
self.config['homedir']))
if res != ('', ''):
self.config['vboxmanage'] = get_full_path(res[0])
self.config.save()
self.ui.vboxmanagePathLineEdit.setText(
get_full_path(self.config['vboxmanage']))
def get_trusted_keys_info(self):
keys = os.listdir(get_full_path(self.trusted_keys_path))
res = {}
for key in keys:
try:
with open(
get_full_path(
os.path.join(self.trusted_keys_path, key,
KEY_INFO_FILENAME)), "r") as fp:
res[key] = json.load(fp)
except Exception as e:
log.error("Error getting key info: %s " % str(e))
return res
def save_user_key(self, pkfp, public, private, alias=None):
"""
Saves private key on disk.
Assumed that all checks are already completed.
If folder exists - files with the same names will be replaced.
:param pkfp: Public key fingerprint SHA256
:param public: Public key derived from private key
:param private: Encrypted private key
:param alias: User note
:return:
"""
keyfolder = get_full_path(
os.path.join(self.user_keys_path, str(pkfp, "utf8")))
if not os.path.isdir(keyfolder):
os.mkdir(keyfolder)
with open(os.path.join(keyfolder, "public.pem"), "wb") as pubf, \
open(os.path.join(keyfolder, "private.pem"), "wb") as privf, \
open(os.path.join(keyfolder, KEY_INFO_FILENAME), "w") as nf:
pubf.write(public)
privf.write(private)
key_info = dict()
key_info["created"] = str(dt.datetime.fromtimestamp(time.time()))
key_info["pkfp"] = str(pkfp, "utf8")
if alias is not None:
key_info["alias"] = alias
json.dump(key_info, nf)
def setup_logger(config, debug):
logger = logging.getLogger()
if debug:
print("Setting logging to debug mode")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
logger.addHandler(handler)
else:
print("Setting logging to production mode")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler(sys.stdout)
logger.addHandler(handler)
manager_path = get_full_path(config["manager_data_folder"])
if not os.path.exists(manager_path):
os.mkdir(manager_path)
log_path = os.path.join(manager_path, "islands_manager.log")
file_handler = RotatingFileHandler(log_path,
mode="a",
maxBytes=5 * 1024 * 1024,
backupCount=1,
encoding=None,
delay=0)
formatter = logging.Formatter(
'%(asctime)s %(levelname)s %(name)s %(funcName)s(%(lineno)d) %(message)s '
)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.debug("Logger initialized.")
try:
with open("version", "r") as fp:
logger.info("ISLAND MANAGER version %s" % fp.read())
except Exception as e:
pass
def open_select_file_dialog(self):
res = QFileDialog.getOpenFileName(
self, "Select key file", get_full_path(self.config['homedir']),
"Key file (*.pem)")
if res == ('', ''):
print("Cancelled")
else:
self.ui.key_file_path.setText(res[0])
def ensure_manager_directories_exist(self):
if not os.path.exists(get_full_path(
self.config["manager_data_folder"])):
os.makedirs(get_full_path(self.config["manager_data_folder"]))
if not os.path.exists(get_full_path(self.config["downloads_path"])):
os.mkdir(get_full_path(self.config["downloads_path"]))
if not os.path.exists(get_full_path(self.config["user_keys_path"])):
os.mkdir(get_full_path(self.config["user_keys_path"]))
if not os.path.exists(get_full_path(self.config["trusted_keys_path"])):
os.mkdir(get_full_path(self.config["trusted_keys_path"]))
def __init__(self, config):
log.debug("Initalizing torrent manager")
self.config = config
self.download_rate = 0
self.upload_rate = 0
self.upload_rate_limit = 0
self.download_rate_limit = 0
self.session = lt.session()
self.stat = {}
self.stat_samples = []
self._alert_processors = self._get_alert_processors()
self.exiting = False
if os.path.exists("ltsession.dump"):
try:
log.debug("Session dump found. Trying to load session data")
with open(SESSION_DUMP_FILENAME, "rb") as fp:
session_data = lt.bdecode(fp.read())
self.session.load_state(session_data)
peer_class = self.session.get_peer_class(
lt.session.global_peer_class_id)
self.download_rate_limit = peer_class["download_limit"]
self.upload_rate = peer_class["upload_limit"]
except Exception as e:
log.exception(e)
self.init_new_session()
else:
self.init_new_session()
settings = self.session.get_settings()
settings["alert_mask"] = 65
self.session.apply_settings(settings)
self.save_session_state()
self.torrents_path = get_full_path(config["downloads_path"])
self.temp_path = get_full_path(config["temp_path"])
self.torrent_metadata_path = get_full_path(
config["torrent_metadata_path"])
if not os.path.exists(self.torrent_metadata_path):
os.mkdir(self.torrent_metadata_path)
self.stats_update = Thread(target=self._process_alerts)
self.stats_update.start()
self.launch_torrents()
def __init__(self, config: IMConfig):
self.config = config
self.releases_history_dir = os.path.join(
get_full_path(self.config["manager_data_folder"]),
RELEASES_HISTORY_DIR_NAME)
if not os.path.isdir(self.releases_history_dir):
log.debug("Releases directory does not exist. Creating: %s" %
self.releases_history_dir)
os.makedirs(self.releases_history_dir)
def select_image(self):
res = QFileDialog.getOpenFileName(
QFileDialog(self), "Select Islands image file",
get_full_path(self.config['homedir']),
"Islands image file (*.isld)")
if res == ('', ''):
print("Cancelled")
else:
self.ui.path_to_image.setText(res[0])
def save_datafolder_path(self):
res = QM.question(self, "Confirm",
"This will require stopping Islands. Continue?",
QM.Yes | QM.No)
if res == QM.No:
return
print("saving new data folder")
self.island_manager.set_new_datafolder(self.ui.dfLineEdit.text())
self.ui.dfLineEdit.setText(get_full_path(self.config['data_folder']))
def _linux_install_download(self):
log.debug("Downloading virtualbox")
self.init_progres_bar("Downloading virtualbox...")
self.path_to_vbox_distr = Dl.get(url=self.config["vbox_download"],
dest_path=get_full_path(
self.config["downloads_path"]),
on_update=self.update_progres_bar,
abort=self.abort)
self.finalize_progres_bar()
self.message("Download completed. Installing...")
def select_source_file(self):
log.debug("Selecting source image")
res = QFileDialog.getOpenFileName(
QFileDialog(self), "Select Islands image file",
get_full_path(self.config['homedir']), "Virtual Appliance (*.ova)")
if res == ("", ""):
log.debug("Image select cancel")
else:
self.ui.source_file.setText(res[0])
log.debug("Source path is %s" % (res[0]))
def clear_logs(self):
if QMessageBox.question(
self, "Confirm", "All logs will be deleted. Continue?",
QMessageBox.Yes | QMessageBox.No) == QMessageBox.Yes:
print("Clearing all logs")
l1 = get_full_path(
os.path.join(self.logs_dir, "islands_manager.log"))
l2 = get_full_path(
os.path.join(self.logs_dir, "islands_manager.log.1"))
if os.path.exists(l1):
with open(l1, "w") as fp:
fp.write("")
if os.path.exists(l2):
with open(l2, "w") as fp:
fp.write("")
self.logs_data = []
self.render_logs()
else:
log.debug("Log clear cancel.")
def select_data(self):
dialog = QFileDialog(self)
res = None
if self.ui.select_mode.currentIndex() == 0:
# Selecting file
res = QFileDialog.getOpenFileName(
dialog, "Select file", get_full_path(self.config["homedir"]))
elif self.ui.select_mode.currentIndex() == 1:
res = QFileDialog.getExistingDirectory(
dialog, "Select directory",
get_full_path(self.config["homedir"]))
else:
log.error("File dialog error")
return
if res and res != ("", ""):
path_to_data = res[0] if self.ui.select_mode.currentIndex(
) == 0 else res
log.debug("Selected data: %s" % path_to_data)
self.ui.path_to_data.setText(path_to_data)
def select_islands_image(self):
res = QFileDialog.getOpenFileName(
self, "Select Islands image",
util.get_full_path(self.config['homedir']),
"Islands Virtual Appliance (*.isld)")
if res == ('', ''):
log.debug("Image selection cancelled")
else:
log.debug("Islands image chosen for import: %s" % res[0])
self.ui.path_islands_vm.setText(res[0])
def configure_data_folder(self):
f_dialog = QFileDialog(self)
res = f_dialog.getExistingDirectory(self,
"Select directory",
directory=get_full_path(
self.config["homedir"]))
if not res:
return
if get_full_path(res) == get_full_path(
self.config["manager_data_folder"]):
log.debug(
"Islands Manager data and Island data cannot be the same directory!"
)
QM.warning(
self, "Error",
"Islands Manager data and Island data cannot be the same directory!",
QM.Ok)
return
if basename(normpath(res)) != self.config["shared_folder_name"]:
res = join(res, self.config["shared_folder_name"])
wmsg = "The virtual machine will be stopped now. Shared folder named islandsData will be unregistered " \
"and selected directory will be mounted under islandsData name.\n\nSelected directory: %s\n\n" \
"Proceed?" % res
if QM.question(self, "Confirm", wmsg, QM.Yes | QM.No) != QM.Yes:
log.debug("Data folder config cancelled. Returning...")
return
log.debug("Configuring data dir to " + res)
try:
self.island_manager.set_new_datafolder(res)
self.config["data_folder"] = res
self.config.save()
log.debug("Data folder configured")
self.refresh_vm_info()
QM.information(self, "Info", "Data folder configured successfully",
QM.Ok)
except IslandManagerException as e:
errmsg = "Error configuring Island data directory: %s" % str(e)
log.error(errmsg)
QM.information(self, "Info", errmsg, QM.Ok)
def restore_default_df_path(self):
if self.is_running():
Executor.exec_sync(self.cmd.shutdown_vm(force=True))
time.sleep(3)
Executor.exec_sync(self.cmd.sharedfolder_remove())
self.config.restore_default("data_folder")
fullpath = get_full_path(self.config["data_folder"])
if not os.path.exists(fullpath):
os.makedirs(fullpath)
res = Executor.exec_sync(self.cmd.sharedfolder_setup(fullpath))
if res[0] != 0:
raise IslandManagerException(
"Datafolder reset finished with error: %s" % res[2])
def set_new_datafolder(self, new_path):
if self.is_running():
Executor.exec_sync(self.cmd.shutdown_vm(force=True))
time.sleep(3)
new_path_full = get_full_path(new_path)
if not os.path.exists(new_path_full):
os.makedirs(new_path_full)
Executor.exec_sync(self.cmd.sharedfolder_remove())
self.config['data_folder'] = new_path_full
self.config.save()
res = Executor.exec_sync(self.cmd.sharedfolder_setup(new_path_full))
if res[0] != 0:
raise IslandManagerException(
"Datafolder setup finished with error: %s" % res[2])
def restore_default_data_folder_path(self):
# Check if custom path is different from default
# confirm
if self.config.is_default("data_folder"):
print("Already default")
return
res = QM.question(QM(self), "Confirm",
"This will require stopping Islands. Continue?",
QM.Yes | QM.No)
if res == QM.No:
return
print("Restoring default data folder")
self.island_manager.restore_default_df_path()
self.ui.dfLineEdit.setText(get_full_path(self.config['data_folder']))
def load_logs(self):
log.debug("Loading logs")
try:
logfile1 = get_full_path(
os.path.join(self.logs_dir, "islands_manager.log"))
logfile2 = get_full_path(
os.path.join(self.logs_dir, "islands_manager.log.1"))
if os.path.exists(logfile1):
with open(logfile1, "r") as fp:
regex = re.compile(
"^\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2},\d{3}.+$")
self.logs_data += list(
filter(regex.search,
fp.read().split("\n")))
if os.path.exists(logfile2):
with open(logfile2, "r") as fp:
regex = re.compile("\d+.*\w+")
self.logs_data += list(
filter(regex.search,
fp.read().split("\n")))
except Exception as e:
log.error("Error loading logs: %s" % str(e))
def save_trusted_public_key(self, pkfp, public, alias=None):
keyfolder = get_full_path(
os.path.join(self.trusted_keys_path, str(pkfp, "utf8")))
if not os.path.isdir(keyfolder):
os.mkdir(keyfolder)
with open(os.path.join(keyfolder, "public.pem"), "wb") as pubf, \
open(os.path.join(keyfolder, KEY_INFO_FILENAME), "w") as nf:
pubf.write(public)
key_info = dict()
key_info["created"] = str(dt.datetime.fromtimestamp(time.time()))
key_info["pkfp"] = str(pkfp, "utf8")
if alias is not None:
key_info["alias"] = alias
json.dump(key_info, nf)
def run_update(self):
"""
Launches VM installation
"""
log.debug("Running update")
self.on_message("Initializing islands update")
self.ui.output_console.setVisible(True)
if not (self.ui.opt_from_file.isChecked()
or self.ui.opt_download.isChecked()):
msg = "None of VM update option are selected"
log.debug(msg)
show_user_error_window(self, msg)
return
if self.island_manager.is_running():
self.on_message("Islands currently running. Shutting down...")
self.island_manager.stop_island_sync(force=True)
self.on_message("Islands was shut down. Now updating...")
data_path = get_full_path(self.config["data_folder"])
self.lock_form()
log.info("Attempting to update islands VM...")
self.unknown_key_confirm_request.connect(self.untrusted_key_confirm)
self.lock_form(True)
self.repaint()
if self.ui.opt_download.isChecked():
self.download_timeout_signal.connect(self.on_download_timeout)
log.debug("Trying to import VM from %s " %
self.ui.path_to_image.text())
self.working = True
self.setup.run_update(
on_message=self.on_message,
on_complete=lambda res, opt_msg="": self.update_completed.emit(
res, opt_msg),
on_error=self.on_error,
init_progres_bar=self.get_init_progress_bar_handler(),
update_progres_bar=self.get_update_progress_bar_handler(),
finalize_progres_bar=self.get_finalize_progress_bar_handler(),
download=self.ui.opt_download.isChecked(),
setup=self.setup,
island_manager=self.island_manager,
on_download_timeout=lambda: self.download_timeout_signal.emit(),
magnet_link=self.ui.magnet_link.text().strip(),
on_confirm_required=lambda: self.unknown_key_confirm_request.emit(
),
image_path=self.ui.path_to_image.text().strip(),
config=self.config,
on_configuration_in_progress=lambda x: self.
configuration_in_progress_signal.emit(x),
data_path=data_path)
def __init__(self, parent, logs_dir):
super(QDialog, self).__init__(parent)
self.ui = Ui_LogsForm()
self.ui.setupUi(self)
self.logs_dir = logs_dir
self.logs_data = []
self.load_logs()
self.ui.lbl_logs_location.setText(get_full_path(logs_dir))
self.order_logs()
self.render_logs()
self.ui.cb_order.currentIndexChanged.connect(self.apply_order)
self.ui.cb_filter.currentIndexChanged.connect(self.apply_filter)
self.ui.btn_reload.clicked.connect(self.reload_logs)
self.ui.btn_clear.clicked.connect(self.clear_logs)
adjust_window_size(self)
self.show()
def get_stats_path(self):
return get_full_path(os.path.join(self["data_folder"], self["stats"]))
def vboxmanage_process_change(self):
self.ui.vboxmanageSave.setEnabled(self.ui.vboxmanagePathLineEdit.text(
) != get_full_path(self.config['vboxmanage']))
def ensure_default_data_folder_exists(self):
default_data_dir_path = get_full_path(
self.__default["manager_data_folder"])
if not os.path.exists(default_data_dir_path):
os.makedirs(default_data_dir_path)
def load_settings(self):
self.ui.vboxmanagePathLineEdit.setText(
get_full_path(self.config['vboxmanage']))
def __init__(self, config):
self.temp_path = get_full_path(config["temp_path"])
self.temp_dir_name_length = config["temp_dir_name_length"]
if not os.path.exists(self.temp_path):
os.mkdir(self.temp_path)
def restore_default_vboxmanage_path(self):
self.config.restore_default("vboxmanage")
self.ui.vboxmanagePathLineEdit.setText(
get_full_path(self.config["vboxmanage"]))
self.ui.vboxmanageSave.setEnabled(False)
self.refresh_required = True
