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