class Verify(): def __init__(self, backup_name, run_date): ''' Verify a run to ensure it is valid ''' self.config = Config.get_config() self.backup = self.config.backups[backup_name] self.store = self.config.storage[self.backup.store].copy() self.db = DB() # Find the run runs = self.db.runs(self.backup.name, run_date) if len(runs) == 0: raise Exception(_("Verify failed: Backup run does not exist")) self.vrun = runs[0] def run(self): self.test_store() # Get config and packages self.fetch_config() # We only check the data if there is actually something stored there. if self.vrun.nfiles == 0 and self.vrun.nfolders == 0: return True self.prepare_input(self.vrun, self.backup, self.store) try: # Only check for tar data if there are files backed up # Otherwise the tar will simply return an error tarinfo = self.tarfile.next() while tarinfo: tarinfo = self.tarfile.next() finally: self.close_input(self.backup) store_size, store_hash, = self.store_thread.get_hash() run_hash = self.vrun.hash run_size = self.vrun.size if store_size == run_size and store_hash == run_hash: return True # print(store_size, store_hash, run_size, run_hash) raise Exception(_("Verify failed - Run data is corrupt")) def test_store(self): store = self.config.storage[self.store.name].copy() store.connect() try: store.test() finally: store.disconnect() def fetch_config(self): store = self.config.storage[self.store.name].copy() store.connect() try: encrypted = False config = os.path.join(self.vrun.folder, const.ConfigName) if not store.exists(config): encrypted = True config = config + const.EncryptionSuffix if not store.exists(config): raise Exception(_("Configuration file missing. Bad run")) store.get(config, os.path.join(tempfile.gettempdir(), "__vault__tmp__")) os.remove(os.path.join(tempfile.gettempdir(), "__vault__tmp__")) if self.backup.include_packages: packages = os.path.join(self.vrun.folder, const.PackageFile) if encrypted: packages = packages + const.EncryptionSuffix store.get(packages, os.path.join(tempfile.gettempdir(), "__vault__tmp__")) os.remove(os.path.join(tempfile.gettempdir(), "__vault__tmp__")) finally: store.disconnect() def prepare_input(self, run, backup, store): ''' Open the tar file. Connect the output of the tar to either: a) the storage handler b) to encryption (openssl), THEN the storage handler ''' log.trace("Setting up input processes") # Set up the encryptor (use TEE for now) self.crypt_proc = None if backup.encrypt: log.debug("Creating crypt objects") self.crypto = cryptor.DecryptStream(self.config.data_passphrase) else: self.crypto = cryptor.Buffer() # Set up the storage handler log.debug("Starting storage thread") self.store_thread = StreamIn(self.crypto, store, run.folder) self.store_thread.start() log.debug("Connecting tar object") self.tarfile = tarfile.open(mode="r|gz", fileobj=self.crypto, bufsize=const.BufferSize) log.trace("Completed input preparation") def close_input(self, backup): log.trace("Closing output managers") # If we are using an external save command, we do nothing here try: self.tarfile.close() self.crypto.close() # Now we are ready to wait for the storage. self.store_thread.join() if self.store_thread.error: log.error("Closing store. Got error", str(self.store_thread.error)) # self.db.save_message("Error saving backup: %s" % str(self.store_thread.error)) raise self.store_thread.error finally: pass log.debug("All input closed")
class ConfigPanel(gui.ConfigPanel): ''' classdocs ''' def __init__(self, parent): ''' Constructor ''' log.info("***ConfigPanel.init") gui.ConfigPanel.__init__(self, parent) self.config = Config.get_config() self.db = DB() self.state = ViewState self.update_filetype_list() self.clear_filetype() self.image = wx.Bitmap(os.path.join(const.PixmapDir, "configure.png")) self.title = _("Configuration") if self.lstFileTypes.GetCount() > 0: self.lstFileTypes.SetSelection(0) self.onFileType(None) self.show_mail() self.txtMailServer.SetFocus() self.nb_config.SetSelection(0) self.show_security() self.pwd_hidden = True self.mail_hidden = True log.trace("Done ConfigPanel.init") def update_data(self): pass def update_filetype_list(self): self.lstFileTypes.Clear() self.lstFileTypes.AppendItems(self.config.file_types.keys()) ######################################################################3 # # FILE TYPE EVENTS # ######################################################################3 def onSaveTypes(self, event): self.save_filetype() self.state = ViewState self.update_state() self.lstFileTypes.SetStringSelection(self.txtName.GetValue()) def onFileType(self, event): # Get the name to be showed name = self.lstFileTypes.GetStringSelection() if len(name) == 0: return # Load it try: list = self.config.file_types[name] self.state = ViewState self.show_filetype(name, list) except Exception: # Missing backup! dlg.Warn(self, _("That File Type seems to be missing or corrupt.")) self.update_filetype_list() self.state = ViewState self.clear_filetype() return def onDelete(self, event): # Get the name to be showed name = self.lstFileTypes.GetStringSelection() if len(name) == 0: return if dlg.OkCancel(self, _("Delete File Type definition %s and all its data! Are you sure?") % name) == wx.ID_OK: self.delete_filetype(name) self.clear_filetype() self.state = ViewState def onNew(self, event): log.info("New!") self.state = NewState self.clear_filetype() self.txtName.SetFocus() def onName(self, event): self.update_state() def onSSL(self, event): if self.chkMailSSL.GetValue(): self.txtMailPort.SetValue("465") else: self.txtMailPort.SetValue("25") ######################################################################3 # # EMAIL EVENTS # ######################################################################3 def onHideMailPassword(self, event): if self.mail_hidden: self.txtMailPassword.SetWindowStyle(wx.NORMAL) self.mail_hidden = False self.btnHideMailPassword.SetLabel("Hide") else: self.txtMailPassword.SetWindowStyle(wx.TE_PASSWORD) self.mail_hidden = True self.btnHideMailPassword.SetLabel("Show") def onMailAuth(self, event): auth = self.chkMailAuth.GetValue() self.txtMailLogin.Enable(auth) self.txtMailPassword.Enable(auth) def onMailSave(self, event): self.config.mail_server = self.txtMailServer.GetValue() self.config.mail_port = self.txtMailPort.GetValue() self.config.mail_ssl = self.chkMailSSL.GetValue() self.config.mail_auth = self.chkMailAuth.GetValue() self.config.mail_login = self.txtMailLogin.GetValue() self.config.mail_password = self.txtMailPassword.GetValue() self.config.mail_from = self.txtMailFrom.GetValue() self.config.mail_to = self.txtMailTo.GetValue() self.config.save() def onMailTest(self, event): try: if not self.txtMailServer.GetValue() \ or not self.txtMailFrom.GetValue() \ or not self.txtMailTo.GetValue(): raise Exception(_("Mail server, from address and to address are required.")) with ProgressDialog(self, _("Sending"), _("Sending a test email.\nPlease wait...")): import time time.sleep(1) log.debug("Doing send") sendemail.sendemail2(self.txtMailServer.GetValue(), int(self.txtMailPort.GetValue()), self.chkMailSSL.GetValue(), self.txtMailFrom.GetValue(), self.txtMailTo.GetValue(), self.chkMailAuth.GetValue(), self.txtMailLogin.GetValue(), self.txtMailPassword.GetValue(), _('The Vault Backup System - Test Message'), _("This is a test message from The Vault Backup System.\n" "If you have received this, then email is correctly configured.")) dlg.Info(self, _("Mail was sent successfully. Please check it arrived.")) except Exception as e: dlg.Warn(self, str(e)) def show_mail(self): self.txtMailServer.SetValue(self.config.mail_server) self.txtMailPort.SetValue(str(self.config.mail_port)) self.chkMailSSL.SetValue(self.config.mail_ssl) self.chkMailAuth.SetValue(self.config.mail_auth) self.txtMailLogin.SetValue(self.config.mail_login) self.txtMailPassword.SetValue(self.config.mail_password) self.txtMailFrom.SetValue(self.config.mail_from) self.txtMailTo.SetValue(self.config.mail_to) self.onMailAuth(None) ######################################################################3 # # Security EVENTS # ######################################################################3 def onHidePassword(self, event): if self.pwd_hidden: self.txtMasterPassword.SetWindowStyle(wx.NORMAL) self.pwd_hidden = False self.btnHidePassword.SetLabel("Hide") else: self.txtMasterPassword.SetWindowStyle(wx.TE_PASSWORD) self.pwd_hidden = True self.btnHidePassword.SetLabel("Show") def show_security(self): if not self.config.data_passphrase: self.txtMasterPassword.SetValue("") else: self.txtMasterPassword.SetValue(self.config.data_passphrase) self.onMasterPasswordChar(None) def onMasterPasswordChar(self, event): """Recalculate entropy any time the password changes.""" pwd = self.txtMasterPassword.GetValue() e = int(cryptor.entropy(pwd)) if e < 0: e = 0 if e > 100: e = 100 self.strength.SetValue(e) if event: event.Skip() def onSavePassword(self, event): pwd = self.txtMasterPassword.GetValue() if pwd != self.config.data_passphrase: # Password has changed. Do we have any stored backups? # If so, they should be deleted. runs = self.db.runs() num_runs = len(runs) if num_runs > 0: size = 0 for run in runs: size += run.size # Check with the user. msg = _("You current have {numruns} backup runs stored, " \ "totalling {size} of remote data.\n" \ "Changing the Master Password means old encrypted backups cannot be used.\n" \ "Note that they can be kept for disaster recovery if needed,\n" \ "but we suggest you simply start fresh.").format(\ numruns=num_runs, size=utils.readable_form(size)) mbox = OptionDialog(self, msg, _("Delete Backup Runs"), _("Also delete all encrypted backup data stored remotely."), default=True) if mbox.ShowModal() != wx.ID_OK: return delete_offsite_data = mbox.chkOption.GetValue() # TODO skip if no runs # We keep track of all errors errors = "" with ProgressDialog(self, _("Deleting"), _("Deleting old encrypted backup data.\nPlease wait...")): for backup in self.config.backups.itervalues(): # If its encrypted if backup.encrypt: # If the option set - delete all offline data at the store if delete_offsite_data: try: # Get the list of unique stores used by runs of this backup runs = self.db.runs(backup.name) stores = set([r.store for r in runs]) # Get the store and delete all data. for storename in stores: store = self.config.storage[storename].copy() store.delete_backup_data(backup.name) except Exception as e: errors += "\nDelete offline data for %s failed: %s" % (backup.name, str(e)) # Now delete the database records of the run abd backup try: self.db.delete_backup(backup.name) except Exception as e: errors += "\nDelete local backup information for %s failed: " % (backup.name, str(e)) if len(errors) > 0: dlg.Error(self, errors) if not pwd: self.config.data_passphrase = None app.show_message('Password cleared') else: self.config.data_passphrase = pwd app.show_message('Password set') self.config.save() # Now delete all the backups and offsite data. ###################################################################### # # Save and Load # ###################################################################### def update_state(self): if self.state == ViewState: self.lblName.Show(True) self.txtName.Show(False) if self.state == NewState: self.lblName.Show(False) self.txtName.Show(True) #self.pnlDetails.Fit() self.pnlDetails.Refresh() def clear_filetype(self): self.show_filetype("<name>", []) def show_filetype(self, name, list): try: # General Information self.txtName.SetValue(name) self.lblName.SetLabel(name) # TODO! self.txtExtensions.Clear() list.sort() self.txtExtensions.AppendText("\n".join(list)) self.update_state() except Exception as e: log.error("Error showing File Type:", str(e)) def save_filetype(self): # BUILD THE Storage if len(self.txtName.GetValue()) == 0: dlg.Warn(self, _("File Type name cannot be blank")) return list = self.txtExtensions.GetValue().split("\n") try: # Create the new file_type object name = self.txtName.GetValue() # We already have list from above # ensure the list is clean cleanlist = [] for item in list: item = item.strip() while len(item) > 0 and item[0] == ".": item = item[1:] if len(item) == 0: continue if item not in cleanlist: cleanlist.append(item) cleanlist.sort() except Exception as e: dlg.Warn(self, str(e)) return if self.state == ViewState: # Delete the old name oldname = self.lstFileTypes.GetStringSelection() try: del self.config.file_types[oldname] except: pass self.config.file_types[name] = cleanlist self.config.save() self.update_filetype_list() self.show_filetype(name, cleanlist) ######################################################################3 # # Misc Routines # ######################################################################3 def delete_filetype(self, name): del self.config.file_types[name] self.config.save() self.update_filetype_list()
class BackupPanel(EditPanel, gui.BackupPanel): ''' classdocs ''' def __init__(self, parent): ''' Constructor ''' log.info("***BackupPanel.init") gui.BackupPanel.__init__(self, parent) self.btnAddFolder.SetBitmapLabel(wx.Bitmap(os.path.join(const.PixmapDir, "add.png"))) self.db = DB() self.config = Config.get_config() self.state = ViewState self.update_data(False) self.nbBackup.SetSelection(0) self.clear() self.nbBackup.Layout() self.Fit() self.radSchedDailyWeekly.SetValue(True) if self.lstItems.GetCount() > 0: self.lstItems.SetSelection(0) self.onItemSelected(None) # self.onNotifyEmail(None) self.image = wx.Bitmap(os.path.join(const.PixmapDir, "backup.png")) self.title = _("Backups") self.onBackupSchedule(None) log.trace("Done BackupPanel.init") def update_data(self, set_selection=True): # The next line should be # for child in self.pnlScheduleTab.GetChildren(): # if child.GetName().find("cboTime") == 0: # but there is a bug in wxFormBuilder. It doesn't set the name attribute. # See http://sourceforge.net/tracker/?func=detail&aid=3187563&group_id=135521&atid=733136 for name in dir(self): if name.find("cboTime") == 0: child = self.__getattribute__(name) child.Clear() child.AppendItems(const.HoursOfDay) child.SetSelection(0) if name.find("cboDay") == 0: child = self.__getattribute__(name) child.Clear() child.AppendItems(const.ShortDaysOfWeek) child.SetSelection(0) if name.find("cboMonthDay") == 0: child = self.__getattribute__(name) child.Clear() child.AppendItems([str(i) for i in xrange(1, 32)]) child.SetSelection(0) self.txtFolders.Clear() self.lstExcludeTypes.Clear() self.lstExcludeTypes.AppendItems(self.config.file_types.keys()) # Lets update this in a smart fasion. Need to keep the current selection if possible old_sel = self.cboStore.GetStringSelection() self.cboStore.Clear() self.cboStore.AppendItems(self.config.storage.keys()) self.cboStore.SetStringSelection(old_sel) # Lastly - lets reload the backup list self.update_backup_list(set_selection) def update_backup_list(self, set_selection=True): sel = self.lstItems.GetStringSelection() # Look for new items backups = self.lstItems.GetItems() keys = self.config.backups.keys() keys.sort() for item in keys: if not item in backups: # new item becomes selected (hopefully the first) sel = item break self.lstItems.Clear() self.lstItems.AppendItems(keys) if set_selection: self.lstItems.SetStringSelection(sel) self.onItemSelected(None) ######################################################################3 # # EVENTS # ######################################################################3 def onHistory(self, event): name = self.lstItems.GetStringSelection() if len(name) > 0: self.history(name) def onRun(self, event): name = self.lstItems.GetStringSelection() if len(name) > 0: self.run_backup(name) def onAddFolder(self, event): dlog = wx.DirDialog(self, _("Select a folder to back up"), "/home") ret = dlog.ShowModal() if ret == wx.ID_OK: folders = self.text_to_list(self.txtFolders.GetValue()) folders.append(dlog.GetPath()) self.txtFolders.Clear() self.txtFolders.AppendText("\n".join(folders)) def onBackupSchedule(self, event): if self.radSchedAdvanced.GetValue(): self.pnlAdvanced.Show() else: self.pnlAdvanced.Hide() ###################################################################### # # Save and Load # ###################################################################### def update_state(self): if self.state == ViewState: self.lblName.Show(True) self.txtName.Show(False) if self.state == NewState: self.lblName.Show(False) self.txtName.Show(True) self.onBackupSchedule(None) self.Fit() self.Refresh() def clear(self): b = Backup(EmptyName) self.show_backup(b) self.nbBackup.SetSelection(0) def delete(self, name): # Lets get some statistics runs = self.db.runs(backupname=name) num_runs = len(runs) size = 0 for run in runs: size += run.size if num_runs > 0: msg = _("Backup '{backup}' has {numruns} runs stored, " \ "totalling {size} of remote data.\n" \ "Are you sure you want to delete the backup definition?\n" \ "(hint - its usually better to just deactivate the backup)").format(\ backup=name, numruns=num_runs, size=utils.readable_form(size)) mbox = OptionDialog(self, msg, _("Delete Backup Definition"), _("Also delete all backup data stored remotely\nNote that this cannot be undone.")) if mbox.ShowModal() != wx.ID_OK: return delete_offsite_data = mbox.chkOption.GetValue() else: msg = _("Backup '{backup}' has never run. Are you " \ "sure you want to delete the backup definition?").format(backup=name) if dlg.OkCancel(self, msg, _("Confirm Delete")) != wx.ID_OK: return delete_offsite_data = False with ProgressDialog(self, _("Deleting"), _("Deleting backup %s%s.\nPlease wait...") % (name, " and all offsite data" if delete_offsite_data else "")): self.delete_backup(name, delete_offsite_data) import time time.sleep(3) self.clear() self.state = ViewState app.broadcast_update() def show(self, name): try: backup = self.config.backups[name] self.state = ViewState self.show_backup(backup) except Exception as e: # Missing backup! dlg.Warn(self, _("The backup '{backup}' seems to be corrupt. {error}").format(backup=name, error=str(e))) # self.update_backup_list() # self.state = ViewState # self.clear() def show_backup(self, b): # General Information self.txtName.SetValue(b.name) self.lblName.SetLabel(b.name) self.chkActive.SetValue(b.active) # Folder Information self.txtFolders.Clear() self.txtFolders.AppendText("\n".join(b.include_folders)) self.chkPackages.SetValue(b.include_packages) # Exclusions self.lstExcludeTypes.SetCheckedStrings(b.exclude_types) self.txtExcludePatterns.Clear() self.txtExcludePatterns.AppendText("\n".join(b.exclude_patterns)) # Destination self.cboStore.SetStringSelection(b.store) self.chkEncrypt.SetValue(b.encrypt) self.chkVerify.SetValue(b.verify) # Schedule if b.sched_type == "custom": self.radSchedAdvanced.SetValue(True) incr, full = b.sched_times.split("\n") self.txtCronIncr.SetValue(incr) self.txtCronFull.SetValue(full) else: # itime, dummy = incr.split("/") # iday not used # ftime, fday = full.split("/") time, day = b.sched_times.split("/") if b.sched_type == "daily/weekly": self.radSchedDailyWeekly.SetValue(True) self.cboTime1.SetStringSelection(time) self.cboDay1.SetStringSelection(day) elif b.sched_type == "daily/monthly": self.radSchedDailyMonthly.SetValue(True) self.cboTime2.SetStringSelection(time) self.cboMonthDay2.SetStringSelection(day) elif b.sched_type == "hourly/weekly": self.radSchedHourlyWeekly.SetValue(True) self.cboTime3.SetStringSelection(time) self.cboDay3.SetStringSelection(day) elif b.sched_type == "none/daily": self.radSchedNoneDaily.SetValue(True) self.cboTime4.SetStringSelection(time) elif b.sched_type == "none/weekly": self.radSchedNoneWeekly.SetValue(True) self.cboDay5.SetStringSelection(day) self.cboTime5.SetStringSelection(time) else: raise Exception(_("This backup is corrupt. Invalid schedule type")) # Notifications self.chkNotifyMsg.SetValue(b.notify_msg) self.chkNotifyEmail.SetValue(b.notify_email) self.chkShutdown.SetValue(b.shutdown_after) self.update_state() def text_to_list(self, text): list = [item.strip() for item in text.split("\n") if len(item.strip()) > 0] return list def get_time_str(self, cronitem): hour = cronitem.hour().render() if not hour.isdigit(): hour = "19" if len(hour) == 1: hour = '0' + hour min = cronitem.minute().render() if not min.isdigit(): min = "00" if len(min) == 1: min = '0' + min time = "%s:%s" % (hour, min) return time def get_dow(self, cronitem): dow = cronitem.dow().render() if not dow.isdigit(): dow = "0" return int(dow) def get_dom(self, cronitem): dom = cronitem.dom().render() if not dom.isdigit(): dom = "0" return int(dom) def save(self): # BUILD THE BACKUP if len(self.txtName.GetValue()) == 0: raise Exception(_("Backup name cannot be blank")) if self.chkEncrypt.GetValue() and not self.config.data_passphrase: raise Exception(_("You cannot select encryption when the passphrase is blank (see Configuration page).")) if self.txtName.GetValue() == EmptyName: raise Exception(_("You need to provide a proper backup name")) try: # Create the new backup object b = Backup(self.txtName.GetValue()) # General Information b.active = self.chkActive.GetValue() # Folder Information b.include_folders = self.text_to_list(self.txtFolders.GetValue()) b.include_packages = self.chkPackages.GetValue() # Exclusions b.exclude_types = list(self.lstExcludeTypes.GetCheckedStrings()) # returns a tuple, convert to array b.exclude_patterns = self.text_to_list(self.txtExcludePatterns.GetValue()) # Destination b.store = self.cboStore.GetStringSelection() b.encrypt = self.chkEncrypt.GetValue() b.verify = self.chkVerify.GetValue() # Schedule if self.radSchedAdvanced.GetValue(): b.sched_type = "custom" b.sched_times = "%s\n%s" % (self.txtCronIncr.GetValue(), self.txtCronFull.GetValue()) else: if self.radSchedDailyWeekly.GetValue(): b.sched_type = "daily/weekly" time = self.cboTime1.GetStringSelection() day = self.cboDay1.GetStringSelection() elif self.radSchedDailyMonthly.GetValue(): b.sched_type = "daily/monthly" time = self.cboTime2.GetStringSelection() day = self.cboMonthDay2.GetStringSelection() elif self.radSchedHourlyWeekly.GetValue(): b.sched_type = "hourly/weekly" time = self.cboTime3.GetStringSelection() day = self.cboDay3.GetStringSelection() elif self.radSchedNoneDaily.GetValue(): b.sched_type = "none/daily" time = self.cboTime4.GetStringSelection() day = "*" elif self.radSchedNoneWeekly.GetValue(): b.sched_type = "none/weekly" time = self.cboTime5.GetStringSelection() day = self.cboDay5.GetStringSelection() else: raise Exception(_("Corrupt backup")) b.sched_times = time + "/" + day # Notifications b.notify_msg = self.chkNotifyMsg.GetValue() b.notify_email = self.chkNotifyEmail.GetValue() b.shutdown_after = self.chkShutdown.GetValue() b.check() except Exception as e: raise e if self.state == ViewState: # Delete the old name oldname = self.lstItems.GetStringSelection() try: del self.config.backups[oldname] except: pass self.config.backups[b.name] = b self.config.save() self.update_backup_list() # Attempt to save the crontab. If this fails, the backup was corrupt. # But it has been saved. So that is a problem update_crontab(self.config.backups) ######################################################################3 # # Misc Routines # ######################################################################3 def hour_min_from_str(self, str): hour, min = str.split(":") return int(hour), int(min) def delete_backup(self, name, delete_offsite_data): # Delete the database runs. backup = self.config.backups[name] # Read the runs dummy = self.db.runs(name) success = True try: if delete_offsite_data: wx.Yield() store = self.config.storage[backup.store].copy() store.delete_backup_data(name) wx.Yield() self.db.delete_backup(name) except: # Most likely this will happen with a corrupt backup object. # We dont want that corruption to stop the deletion. success = False # Now delete the configuration. wx.Yield() del self.config.backups[name] update_crontab(self.config.backups) self.config.save() self.update_backup_list() if not success: dlg.Warn(self, _("There were errors during the delete. You should check/delete the offsite store manually."), _("Error During Delete")) def history(self, default_name): # Open the file list window win = HistoryWindow(self, default_name) win.Show() def run_backup(self, backup_name): win = RunBackupWindow(self, backup_name) win.Show()
class RestorePanel(gui.RestorePanel): ''' classdocs ''' def __init__(self, parent): ''' Constructor ''' log.info("***RestorePanel.init") gui.RestorePanel.__init__(self, parent) self.db = DB() self.config = Config.get_config() self.images = wx.ImageList(16, 16) self.images.Add( wx.Bitmap(os.path.join(const.PixmapDir, "folder.png"), wx.BITMAP_TYPE_PNG) ) self.images.Add( wx.Bitmap(os.path.join(const.PixmapDir, "document.png"), wx.BITMAP_TYPE_PNG) ) self.fs_tree.SetImageList(self.images) # Looks better if this is blank. self.set_selected_file("") self.force_rebuild() self.image = wx.Bitmap(os.path.join(const.PixmapDir, "review.png")) self.title = _("Restore") # Ensure the right page is showing self.nb_restore.SetSelection(0) log.trace("Done RestorePanel.init") def prepare_static_data(self): # Load all runs for the date slider self.runs = self.db.runs() self.date_slider.SetMin(0) log.debug("Date Slider: %d runs" % len(self.runs)) if len(self.runs) in [0, 1]: # Cannot set a slider with 0 or 1 positions. So disable it. self.date_slider.Enable(False) self.date_slider.SetMax(1) self.date_slider.SetValue(0) else: self.date_slider.SetMax(len(self.runs) - 1) self.date_slider.SetValue(len(self.runs) - 1) self.date_slider.Enable(True) self.cboBackup.Clear() self.cboBackup.AppendItems([name for name in self.config.backups.iterkeys()]) if self.cboBackup.Count > 0: self.cboBackup.SetSelection(0) def force_rebuild(self): log.debug("Forcing complete rebuild") self.displayed_run = None self.prepare_static_data() # Prepare the tree self.fs_tree.DeleteAllItems() self.root_node = self.fs_tree.AddRoot(text="/", image=0) self.fs_tree.SetItemPyData(self.root_node, node_info(0, 0, "D", False, "/")) self.expand_node(self.root_node) self.onSliderScroll(None) self.pnlRestore.Layout() def update_data(self): # TODO! This could be dangerously time consuming! self.prepare_static_data() self.onSliderScroll(None) self.rebuild_tree() self.pnlRestore.Layout() def get_current_run(self): if len(self.runs) == 0: return None if len(self.runs) == 1: return self.runs[0] idx = self.date_slider.GetValue() if idx >= len(self.runs): raise Exception("Invalid date slider position") return self.runs[idx] def expand_node(self, parent_node): log.trace("expand_node", parent_node) run = self.get_current_run() if not run: return # Get the folder - which is in data parent_info = self.fs_tree.GetItemPyData(parent_node) log.debug("expanding node", parent_info) if parent_info.expanded: log.debug("Already expanded") return if parent_info.type == "F": log.debug("File node (no children)") return # Clean out the dummy sub-node self.fs_tree.DeleteChildren(parent_node) # Now add the subnodes (Only up to the currently selected run files = self.db.list_dir_id(parent_info.fs_id, run_id=run.run_id) for name, item in files.iteritems(): if parent_info.fs_id == 0 and name == "/": continue # The type may be None because this could be a folder that # we log, but dont back up. type = item.type if type is None: type = "D" # We dont add in deleted files if type != "X": node_name = utils.display_escape(name) new_node = self.fs_tree.AppendItem(parent_node, node_name, image=0 if type == "D" else 1) new_info = node_info(parent_info.fs_id, item.fs_id, type, False, os.path.join(parent_info.path, name)) log.debug("New node: ", new_info) self.fs_tree.SetItemPyData(new_node, new_info) # For any folders, add a dummy sub-node so we can expand it later if type == "D": self.fs_tree.AppendItem(new_node, DummyTreeNode) # Update the parent node to show that its been expanded. upd_info = node_info(parent_info.parent_id, parent_info.fs_id, parent_info.type, True, parent_info.path) self.fs_tree.SetItemPyData(parent_node, upd_info) self.fs_tree.SortChildren(parent_node) ################################################################## # # Event Handlers # ################################################################## def onRefresh(self, event): self.force_rebuild() def onTreeItemExpanding(self, event): log.trace("onTreeItemExpanding") item = event.GetItem() self.expand_node(item) def onTreeSelChanged(self, event): log.trace("onTreeSelChanged") item = event.GetItem() print(item) info = self.fs_tree.GetItemPyData(item) self.set_selected_file(info.path) def onSliderScroll(self, event): # Get the run log.trace("Slider Scroll") run = self.get_current_run() if not run: self.date_label.SetLabel("") self.time_label.SetLabel("") self.pnlRestore.Layout() self.lblTreeTitle.SetLabel("No backups have run yet.") return date = run.start_time self.date_label.SetLabel(date.strftime(const.ShortDateFormat)) self.time_label.SetLabel(date.strftime(const.ShortTimeFormat)) self.pnlRestore.Layout() self.date_slider.SetToolTipString(date.strftime(const.ShortDateTimeFormat)) self.lblTreeTitle.SetLabel("File System as at " + date.strftime(const.ShortDateTimeFormat)) self.rebuild_tree() def onRunDetails(self, event): run = self.get_current_run() if not run: return dummy = RunDetailsWindow(self, run) def onRestore(self, event): sel = self.fs_tree.GetSelection() data = self.fs_tree.GetItemPyData(sel) dummy = RunRestoreWindow(self, data.path) def onReload(self, event): # Reload the configuration do_recover(self) def onRebuild(self, event): # Rebuild the local database of saved files. do_rebuilddb(self) def onRestoreTab(self, event): # Refresh the restore tab, then switch to it... self.onRefresh(event) self.nb_restore.SetSelection(0) def onShowPackages(self, event): # Fetch the package list from the last run of the selected backup if self.cboBackup.Count == 0: return # Get the backup and store bname = self.cboBackup.GetStringSelection() backup = self.config.backups[bname] store = self.config.storage[backup.store].copy() # Figure out the last run runs = self.db.runs(bname) if len(runs) == 0: dlg.Info(self, _("The selected backup has not run")) return # last is the most recent run = runs[-1] # Get the folder folder = os.path.join(bname, run.start_time_str + ' ' + run.type) src = os.path.join(folder, const.PackageFile) if backup.encrypt: src = src + const.EncryptionSuffix workfolder = tempfile.mkdtemp() store.connect() store.copy_from(src, workfolder) store.disconnect() package_path = os.path.join(workfolder, const.PackageFile) if backup.encrypt: crypt_path = package_path + const.EncryptionSuffix cryptor.decrypt_file(self.config.data_passphrase, crypt_path, package_path) package_list = open(package_path).read().split('\n') # Cleanup shutil.rmtree(workfolder) win = PackageWindow(self, package_list) def onSelectedFileSize(self, event): self.update_truncated_text(self.lblSelectedFile) ################################################################## # # Utilities # ################################################################## def set_selected_file(self, text): """ We dont want the SelectedFile expanding, nor do we want it resizing. We save the full text in the HelpText field. We set the text to a reduced text field that will fit. """ self.lblSelectedFile.SetToolTipString(text) self.update_truncated_text(self.lblSelectedFile) def update_truncated_text(self, field): dc = wx.ClientDC(field) maxWidth = self.lblSelectedFile.GetSize().x tt = field.GetToolTip() text = tt.GetTip() if tt else "" newText = self.truncate_text(dc, text, maxWidth) if newText == None: newText = "" self.lblSelectedFile.SetLabel(newText) def truncate_text(self, dc, text, maxWidth): """ Truncates a given string to fit given width size. if the text does not fit into the given width it is truncated to fit. the format of the fixed text is <truncate text ..>. """ textLen = len(text) tempText = text rectSize = maxWidth fixedText = "" textW, textH = dc.GetTextExtent(text) if rectSize >= textW: return text # The text does not fit in the designated area, # so we need to truncate it a bit suffix = "..." border = 5 w, h = dc.GetTextExtent(suffix) rectSize -= w for i in xrange(textLen, -1, -1): textW, textH = dc.GetTextExtent(tempText) if rectSize >= textW + border: fixedText = tempText fixedText += suffix return fixedText tempText = tempText[:-1] def rebuild_tree(self): # The date has changed. # We correct the tree for the current date. # Assume a number of nodes are visible/created # 1: if that node was not backed up in the run (or prior) then delete it # unless that node has never been backed up (i.e we just record its FS position) # 2: if that node changed type, fix it # 3: if a new node should be added, add it. # We must do this for all loaded nodes, not just visible. run = self.get_current_run() #self.runs[self.date_slider.GetValue()] if not run: return if run != self.displayed_run: log.info("Rebuilding tree for run:", run) self.rebuild_node(run, self.root_node) log.debug("Done rebuild tree") self.displayed_run = run else: log.debug("Already showing this run.") def rebuild_node(self, run, node): ''' Given a node, we want to correct it's state as at the given run. We do this as non-destructively as possible, so that the tree remains in shape. We are correcting the CHILDREN of the current node, so if the node is a leaf - we quit (it should have been corrected when correcting its parent) @param run: @type run: @param node: @type node: ''' node_data = self.fs_tree.GetItemPyData(node) # If this is NOT a folder node, exit. if node_data.type != "D": log.debug("Node not directory") return # If this node has not been expanded, exit if not node_data.expanded: log.debug("Node not expanded") return log.debug("rebuild_node", run, node, node_data) # From the DB, get all fs entries under the current one dbentries = self.db.list_dir_id(node_data.fs_id, run.run_id) if not dbentries: # This node has no children self.fs_tree.DeleteChildren(node) log.debug("Node has no children") return # # Get the child list - we have to get this in advance because our changes to # # the tree will cause iterators to fail # (child, cookie) = self.fs_tree.GetFirstChild(node) # For each of its children children_ids = [] (child, cookie) = self.fs_tree.GetFirstChild(node) while child: children_ids.append(child) child, cookie = self.fs_tree.GetNextChild(node, cookie) for child in children_ids: # Get information on this node. child_name = self.fs_tree.GetItemText(child) log.debug("Got ", child_name) child_data = self.fs_tree.GetItemPyData(child) if not child_data: raise Exception("Illegal: empty child node") log.debug("Visiting node:", child_name, child_data) # Fix the node. # If the node type is right, then we will leave it in. # Get the DB node: try: if child_name in dbentries: # Exists in tree AND in DB. Make sure the types are right db_data = dbentries[child_name] if db_data.type == 'X': log.debug("Type X = delete", child_name) self.fs_tree.Delete(child) elif db_data.type == 'D' and child_data.type == 'F': new_info = node_info(db_data.parent_id, db_data.fs_id, db_data.type, False, os.path.join(node_data.path, child_name)) log.debug("New node: ", new_info) self.fs_tree.SetItemPyData(child, new_info) # Adding a DIR node, so add a dummy to ensure it shows properly. self.fs_tree.AppendItem(child, DummyTreeNode) # TODO. change the icon from dir to file. elif db_data.type == 'F' and child_data.type == 'D': # Fix new_info = node_info(db_data.parent_id, db_data.fs_id, db_data.type, False, os.path.join(node_data.path, child_name)) log.debug("New node: ", new_info) self.fs_tree.SetItemPyData(child, new_info) self.fs_tree.DeleteChildren(child) # TODO. change the icon from file to dir. else: # The tree and DB nodes agree pass # Check on the children log.debug("Recursing") self.rebuild_node(run, child) log.debug("Completed node ", child_name) # This node has been completely fixed del dbentries[child_name] else: # NOTE IN DB log.debug("Entry no longer exists. Removing from tree") self.fs_tree.Delete(child) except Exception as e: log.error("Exception on %s: %s" % (child_name, str(e))) # Next node log.debug("Items Left:", dbentries) # Now add any missing items back in for name, db_data in dbentries.iteritems(): # Special case - watch for root if db_data.fs_id == 0: continue if db_data.type is None: type = 'D' else: type = db_data.type if db_data.type == 'X': continue node_name = utils.display_escape(name) new_node = self.fs_tree.AppendItem(node, node_name, image=0 if type == "D" else 1) new_info = node_info(db_data.parent_id, db_data.fs_id, type, False, os.path.join(node_data.path, name)) log.debug("New node: ", new_info) self.fs_tree.SetItemPyData(new_node, new_info) # For any folders, add a dummy sub-node so we can expand it later if type == "D": self.fs_tree.AppendItem(new_node, DummyTreeNode) # Ensure the nodes keep roughly the same position/order self.fs_tree.SortChildren(node) def get_path(self, node): ''' Walk back up the tree to work out the full path for the current node @param node: ''' if node == self.root_node: return "/" path = os.path.join(self.get_path(self.fs_tree.GetItemParent(node)), self.fs_tree.GetItemText(node)) return path
class VerifyTestCase(unittest.TestCase): def setUp(self): self.config = Config.get_config() self.db = DB() self.db.check_upgrade() self.mark_db_ids() self.test_folder = tempfile.mkdtemp() self.files_folder = os.path.join(self.test_folder, "files") self.store_folder = os.path.join(self.test_folder, "store") self.restore_folder = os.path.join(self.test_folder, "restore") utils.makedirs(self.files_folder) utils.makedirs(self.store_folder) utils.makedirs(self.restore_folder) utils.build_file_structure(self.files_folder, 50 * const.Kilobyte, 500 * const.Kilobyte) # Build a store object (dont save config) # Note the careful size selection - we want backups to overflow the FolderStore. self.store = FolderStore("teststore", "2MB", True, self.store_folder) self.config.storage[self.store.name] = self.store # Build the backup object (dont save config) self.backup = Backup("testbackup") self.backup.include_folders = [self.files_folder] self.backup.store = self.store.name self.backup.notify_msg = False self.include_packages = True self.config.backups[self.backup.name] = self.backup # build an options object for use with the backup self.options = BlankClass() self.options.dry_run = False self.options.message = False self.options.email = False self.options.shutdown = False self.options.norecurse = False self.old_pass = self.config.data_passphrase self.config.data_passphrase = "banana" def tearDown(self): self.config.data_passphrase = self.old_pass # Remove all DB records created during this test self.clean_db() shutil.rmtree(self.test_folder) self.assertFalse(os.path.isdir(self.test_folder)) def testVerify(self): # Run a full backup b = Run("testbackup", const.FullBackup, self.options) b.run() # Get the times runs = self.db.runs("testbackup") run = runs[0] v = Verify("testbackup", run.start_time) self.assertTrue(v.run()) def testBadVerify(self): # Run a full backup b = Run("testbackup", const.FullBackup, self.options) b.run() # Get the times runs = self.db.runs("testbackup") run = runs[0] # Get the location of the data file from the streamer streamer = StreamOut(None, self.store, b.backup_folder) datafile = os.path.join(self.store.root, streamer.get_path(0)) size = os.path.getsize(datafile) # Now corrupt the data file a little with open(datafile, "r+b") as f: f.seek(size // 2, 0) f.write("X") v = Verify("testbackup", run.start_time) self.assertRaises(Exception, v.run) def testBadConfig(self): # Run a full backup b = Run("testbackup", const.FullBackup, self.options) b.run() # Get the times runs = self.db.runs("testbackup") run = runs[0] # Delete The Config File configfile = os.path.join(run.folder, const.ConfigName) self.store.remove_file(configfile) v = Verify("testbackup", run.start_time) self.assertRaises(Exception, v.run) def testBadVerifyEncrypted(self): backup = self.config.backups[self.backup.name] backup.encrypt = True self.config.backups[backup.name] = backup # Run a full backup b = Run("testbackup", const.FullBackup, self.options) b.run() # Get the times runs = self.db.runs("testbackup") run = runs[0] # Get the location of the data file from the streamer streamer = StreamOut(None, self.store, b.backup_folder) datafile = os.path.join(self.store.root, streamer.get_path(0)) # Now corrupt the data file a little size = os.path.getsize(datafile) with open(datafile, "r+b") as f: f.seek(size // 2, 0) f.write("X") v = Verify("testbackup", run.start_time) self.assertRaises(Exception, v.run) ############################################################################ # # Utility Routines # ############################################################################ def mark_db_ids(self): self.max_fs_id = self.db.query("select max(fs_id) from fs", ())[0][0] if self.max_fs_id is None: self.max_fs_id = 0 self.max_version_id = self.db.query("select max(version_id) from versions", ())[0][0] if self.max_version_id is None: self.max_version_id = 0 self.max_run_id = self.db.query("select max(run_id) from runs", ())[0][0] if self.max_run_id is None: self.max_run_id = 0 self.max_message_id = self.db.query("select max(message_id) from messages", ())[0][0] if self.max_message_id is None: self.max_message_id = 0 def clean_db(self): self.db.execute("delete from messages where message_id > ?", (self.max_message_id,)) self.db.execute("delete from versions where version_id > ?", (self.max_version_id,)) self.db.execute("delete from fs where fs_id > ?", (self.max_fs_id,)) self.db.execute("delete from runs where run_id > ?", (self.max_run_id,))
class ServerTestCase(unittest.TestCase): def setUp(self): self.config = Config.get_config() self.db = DB() self.db.check_upgrade() self.mark_db_ids() self.test_folder = tempfile.mkdtemp() self.files_folder = os.path.join(self.test_folder, "files") self.store_folder = os.path.join(self.test_folder, "store") self.restore_folder = os.path.join(self.test_folder, "restore") utils.makedirs(self.files_folder) utils.makedirs(self.store_folder) utils.makedirs(self.restore_folder) utils.build_file_structure(self.files_folder, 50 * const.Kilobyte, 500 * const.Kilobyte) # Build a store object (dont save the config) # Note the careful size selection - we want backups to overflow the FolderStore. self.store = FolderStore("teststore", "2MB", True, self.store_folder) self.config.storage[self.store.name] = self.store # Build the backup object (dont save config) self.backup = Backup("testbackup") self.backup.include_folders = [self.files_folder] self.backup.store = self.store.name self.backup.notify_msg = False self.old_pass = self.config.data_passphrase self.config.data_passphrase = "goofy" self.backup.encrypt = True self.config.backups[self.backup.name] = self.backup # build an options object for use with the backup self.options = BlankClass() self.options.dry_run = False self.options.message = False self.options.email = False self.options.shutdown = False self.options.norecurse = False def tearDown(self): self.config.data_passphrase = self.old_pass # Remove all DB records created during this test self.clean_db() shutil.rmtree(self.test_folder) self.assertFalse(os.path.isdir(self.test_folder)) def testBackupRestore(self): self.backup_restore_compare() def testCheckFiles(self): self.backup.include_packages = True b = Run("testbackup", const.FullBackup, self.options) b.run() # Check that all the right files are there. runs = self.db.runs(self.backup.name) self.assertEqual(len(runs), 1) run = runs[0] folder = run.folder self.assertTrue(self.store.exists(os.path.join(folder, const.PackageFile + const.EncryptionSuffix))) self.assertTrue(self.store.exists(os.path.join(folder, const.LOFFile + const.EncryptionSuffix))) self.assertTrue(self.store.exists(os.path.join(folder, const.ConfigName + const.EncryptionSuffix))) self.assertTrue(self.store.exists) def testAutoManagementOfStore1(self): # Run a set of backups that will overload the store. # The automanaged store should continue to archive old backups as required. # Store space reclaimation happens across all backups (i.e. any run). # We should see older runs from the first backup disappear. max_size, dummy, dummy = self.store.limit_details() filesize = utils.du(self.backup.include_folders[0]) # Lets make sure we are going to do enough backups that # the older ones will be removed. RunCount = (max_size // filesize) + 2 last_start = None for cycle in xrange(RunCount): if last_start: # Make sure we have ticked to another second since the start of the last backup. while datetime.now() - last_start < timedelta(seconds=1): time.sleep(0.01) backup = Backup(self.backup.name + str(cycle)) backup.include_folders = self.backup.include_folders backup.store = self.backup.store backup.notify_msg = False self.config.backups[backup.name] = backup # Run a full backup b = Run(backup.name, const.FullBackup, self.options) b.run() last_start = b.start_time # Assert that the store is still of an appropriate size size, used, avail = self.store.current_usage() self.assertTrue(avail >= 0) self.assertTrue(used <= max_size) # Confirm that's true on disk disksize = utils.du(self.store.root) self.assertTrue(disksize <= max_size) # Check that some runs have actually been deleted runs = self.db.runs(self.backup.name + "0") self.assertTrue(len(runs) == 0) runs = self.db.runs(self.backup.name + "1") self.assertTrue(len(runs) == 0) def testAutoManagementOfStore2(self): # Run one backup multiple times to overload a store max_size, dummy, dummy = self.store.limit_details() filesize = utils.du(self.backup.include_folders[0]) # Lets make sure we are going to do enough backups that # the older ones will be removed. RunCount = (max_size // filesize) + 2 last_start = None for cycle in xrange(RunCount): if last_start: # Make sure we have ticked to another second since the start of the last backup. while datetime.now() - last_start < timedelta(seconds=1): time.sleep(0.01) # Run a full backup b = Run(self.backup.name, const.FullBackup, self.options) b.run() last_start = b.start_time # Assert that the store is still of an appropriate size size, used, avail = self.store.current_usage() self.assertTrue(avail >= 0) self.assertTrue(used <= max_size) # Confirm that's true on disk disksize = utils.du(self.store.root) self.assertTrue(disksize <= max_size) # Check that some runs have actually been deleted runs = self.db.runs(self.backup.name) self.assertTrue(len(runs) < RunCount) def testChanges(self): pass # Full Backup # change a file # Incremental backup # Restore most recent. ensure you get latest file # Restore to just prior to incremental, ensure you get earlier file # Run a full backup file = os.path.join(self.files_folder, "changer") restore_file = os.path.join(self.restore_folder, file[1:]) # t=0 - file does not exist b = Run("testbackup", const.FullBackup, self.options) b.run() # Make sure we have ticked to another second since the start of the last backup. while datetime.now() - b.start_time < timedelta(seconds=1): time.sleep(0.01) # t=1 - file exists with open(file, "w") as f: f.write("1") b = Run("testbackup", const.IncrBackup, self.options) b.run() # Make sure we have ticked to another second since the start of the last backup. while datetime.now() - b.start_time < timedelta(seconds=1): time.sleep(0.01) # t=2 - file changed with open(file, "w") as f: f.write("2") b = Run("testbackup", const.IncrBackup, self.options) b.run() # Get the times runs = self.db.runs("testbackup") t0 = runs[0].start_time t1 = runs[1].start_time t2 = runs[2].start_time for t, exists, contents in [(t0, False, None), (t1, True, "1"), (t2, True, "2"), (None, True, "2")]: # Attempt to restore most recent of ALL files # This tests the default restore. r = Restore(self.restore_folder, [self.files_folder], t, self.options) r.run() if exists: with open(restore_file, "r") as f: self.assertEqual(f.read(), contents) else: self.assertFalse(os.path.exists(restore_file)) # clean shutil.rmtree(self.restore_folder) utils.makedirs(self.restore_folder) def test7bitFilenames(self): # Make some 7 bit filenames strange_folder = os.path.join(self.files_folder, "strange") utils.makedirs(strange_folder) for i in xrange(1, 117, 10): name = "".join([chr(j) for j in xrange(i, i + 10) if chr(j) != "/"]) path = os.path.join(strange_folder, name) with open(path, "w") as f: f.write(os.urandom(100)) self.backup_restore_compare() def testUnicodeFilenames(self): # Make some unicode bit filenames # Clean out the ordinary files shutil.rmtree(self.files_folder) utils.makedirs(self.files_folder) unicode_folder = os.path.join(unicode(self.files_folder), u"unicode") utils.makedirs(unicode_folder) for i in xrange(1000, 1200, 10): name = u"".join([unichr(j) for j in xrange(i, i + 10) if unichr(j) != u"/"]) path = os.path.join(unicode_folder, name) with open(path, "w") as f: f.write(os.urandom(10)) self.backup_restore_compare() def backup_restore_compare(self): # Run a full backup b = Run("testbackup", const.FullBackup, self.options) b.run() # Make sure we have ticked to another second since the start of the last backup. while datetime.now() - b.start_time < timedelta(seconds=1): time.sleep(0.01) # Attempt to restore every file r = Restore(self.restore_folder, [self.files_folder], datetime.now(), self.options) r.run() # Check that the restored folder and original folder are identical left = unicode(self.files_folder) right = unicode(os.path.join(self.restore_folder, self.files_folder[1:])) d = utils.dircmp(left, right) self.assertEqual(d.left_only, set()) self.assertEqual(d.right_only, set()) self.assertEqual(d.diff_files, set()) self.assertTrue(len(d.same_files) > 0) # Check that all files are in the DB for folder, _, local_files in os.walk(self.files_folder): for file in local_files: path = os.path.join(file, folder) # This will raise an exception if it does not exist self.db.select_path(path, build=False) ############################################################################ # # Utility Routines # ############################################################################ def mark_db_ids(self): self.max_fs_id = self.db.query("select max(fs_id) from fs", ())[0][0] if self.max_fs_id is None: self.max_fs_id = 0 self.max_version_id = self.db.query("select max(version_id) from versions", ())[0][0] if self.max_version_id is None: self.max_version_id = 0 self.max_run_id = self.db.query("select max(run_id) from runs", ())[0][0] if self.max_run_id is None: self.max_run_id = 0 self.max_message_id = self.db.query("select max(message_id) from messages", ())[0][0] if self.max_message_id is None: self.max_message_id = 0 def clean_db(self): self.db.execute("delete from messages where message_id > ?", (self.max_message_id,)) self.db.execute("delete from versions where version_id > ?", (self.max_version_id,)) self.db.execute("delete from fs where fs_id > ?", (self.max_fs_id,)) self.db.execute("delete from runs where run_id > ?", (self.max_run_id,))
class Run(): def __init__(self, name, type, options): ''' Prepare to run a backup event @param name: name of the backup @param type: type (Full/Incr) @param type: dry_run If dry_run is True, then we will print the files we *would have* backed up to stdout. ''' self.type = type self.dry_run = options.dry_run self.options = options self.config = Config.get_config() try: self.backup = self.config.backups[name] except: raise Exception(_("Backup is missing or corrupt. Please reconfigure backup.")) try: # Get a fresh store (a copy of the config version self.store = self.config.storage[self.backup.store].copy() except: raise Exception(_("Storage definition is missing. Please reconfigure backup.")) self.db = DB() self.start_time = None self.nfiles = None self.nfolders = None self.bytes = None self.run_id = None self.backup_folder = None # Make sure there are no other backups running of this name self.lock = locking.InterProcessLock(name="Vault-%s" % self.backup.name) # Build a quick file exclusion list, to speed up exclusion checking self.excl_ext = self.build_excl_exts() log.debug("Exclusion List:", ",".join(self.excl_ext)) def run(self): ''' Execute the backup ''' try: self.lock.acquire() except: msg = _("Backup '%s' is already running. New backup run cannot start") \ % (self.backup.name) if not self.dry_run: # Since this is a real backup, we create the run, write to the log and fail immediately. self.db.start_run(self.backup.name, self.backup.store, self.type, datetime.now()) self.db.save_message(msg) self.db.update_run_status(const.StatusFailed) else: # We dont need to do anything for a dry run. The message will # be returned to the user. pass raise Exception(msg) # We have the lock now... try: self.orig_type = self.type self.check_old_backups() self.do_backup() finally: self.lock.release() def check_old_backups(self): ''' We have got the lock, but if there was a crash, there may be a "running" state backup left behind. Note that we *know* its not running because the lock is gone. Check for it and fail it if there is. ''' log.debug("Checking for dead backups") runs = self.db.runs(self.backup.name) runs = [run for run in runs if run.status == const.StatusRunning] # It looks like there is a run that is still running. for run in runs: log.warn("A prior run crashed. Cleaning up %s/%s" % (run.name, run.start_time_str)) # Get the store log.debug("Attempting to delete remote run data") try: self.store.delete_run_data(run) except: pass # Delete the entries in the database (but not the failed run itself) # This means the messages will persist, so we can see the usage. log.debug("Attempting to delete DB run data") self.db.delete_run_versions(self.run_id) # Update the status log.debug("Setting status to failed and logging") self.db.execute("update runs set status = ? where run_id = ?", (const.StatusFailed, run.run_id)) self.db.execute("insert into messages (run_id, message, time) values (?, ?, ?)", (run.run_id, _("Backup run crashed. It was cleaned up."), datetime.now().strftime(const.DateTimeFormat))) # If there are *no* full backups in the history, then this run MUST be a full, # even if an incremental is requested. Actually a request for incremental will # grab all files anyway, but still... lets make the name match the contents. runs = self.db.runs(self.backup.name) full_count = len([run for run in runs if run.type == const.FullBackup and run.status == const.StatusSuccess]) log.debug("Full backups: %d" % full_count) if full_count == 0 and self.type != const.FullBackup: log.debug("Resetting type to Full") self.type = const.FullBackup def do_backup(self) : self.start_time = datetime.now() self.nfiles = 0 self.nfolders = 0 self.bytes = 0 success = False message = "" self.backup_folder = os.path.join(self.backup.name, self.start_time.strftime(const.DateTimeFormat) + " " + self.type) if not self.dry_run: self.run_id = self.db.start_run(self.backup.name, self.backup.store, self.type, self.start_time) msg = _("Backup {server}/{backup}/{type} beginning").format( server=utils.get_hostname(), backup=self.backup.name, type=self.type) if self.dry_run: msg += _(" (Dry Run)") log.info(msg) self.db.save_message(msg) if self.orig_type != self.type: # The backup type was switched self.db.save_message(_("NOTE: Backup type switched to {newtype} from {oldtype}").format( newtype=self.type, oldtype=self.orig_type)) # After here we have a run set up in the database, and can begin logging errors. try: # Check that if ENCRYPTION is enabled, that there is a password defined. if self.backup.encrypt and not self.config.data_passphrase: raise Exception("Backup encryption required, but no passphrase has been configured. Backup cancelled.") self.prepare_store() # Prepare output/destinations/encryption self.prepare_output() try: # Now we actually DO the backup, for each listed folder for folder in self.backup.include_folders: self.recursive_backup_folder(folder) log.debug("Committing saved fs entries...") self.db.fs_saved_commit() log.debug("Closing...") self.close_output(success=True) #raise Exception("Test Exception") except Exception as e: log.warn("Exception during backup:", str(e)) # We are going to fail. But we need to try and close # whatever we can. Closing may fail, but in this case # we ignore that error. try: self.close_output(success=False) except: pass raise e if self.backup.verify and not self.dry_run: log.info("Starting verify phase") msg = _("Backup {server}/{backup}/{type} verification starting").format( server=utils.get_hostname(), backup=self.backup.name, type=self.type) self.db.save_message(msg) v = Verify(self.backup.name, self.start_time) v.run() msg = _("Backup {server}/{backup}/{type} verification succeeded").format( server=utils.get_hostname(), backup=self.backup.name, type=self.type) self.db.save_message(msg) # self.do_verify() # Messaging... # If its a dry run, the command line specifies messaging. # Otherwise both the command line AND backup spec do. if not self.dry_run: self.db.update_run_status(const.StatusSuccess) message = _("Backup {server}/{backup}/{type} completed").format( server=utils.get_hostname(), backup=self.backup.name, type=self.type) if self.dry_run: message += " " + _("(Dry Run)") success = True if not self.dry_run: self.db.save_message(message) except Exception as e: log.error("Exception in backup. Recording. ", e) message = _("Backup {server}/{backup}/{type} failed. {error}").format( server=utils.get_hostname(), backup=self.backup.name, type=self.type, error=str(e)) success = False if not self.dry_run: self.db.update_run_status(const.StatusFailed) # After a failed backup - we must remove the backup data because it # cannot be trusted. run = self.db.run_details(self.run_id) # Delete the remote data log.debug("Attempting to delete remote run data") self.store.delete_run_data(run) # Delete the entries in the database (but not the failed run itself) # This means the messages will persist, so we can see the usage. log.debug("Attempting to delete DB run data") self.db.delete_run_versions(self.run_id) self.db.save_message(message) if self.options.message or (self.backup.notify_msg and not self.dry_run): try: from lib.dlg import Notify Notify(const.AppTitle, message) except Exception as e: # This one is not really an error... there is probably no-one logged in. msg = _("Unable to send notification message (no-one logged in)") if not self.dry_run: self.db.save_message(message) log.info(msg) if self.options.email or (self.backup.notify_email and not self.dry_run): try: self.send_email(success, message) except Exception as e: msg = _("Unable to email notification message: {error}").format( error=str(e)) if not self.dry_run: self.db.save_message(message) log.error(msg) if self.options.shutdown or (self.backup.shutdown_after and not self.dry_run): try: cmd = ["zenity", "--question", "--ok-label", _("Shutdown Now"), "--cancel-label", _("Cancel Shutdown"), "--text", _("Backup {backup} complete. Computer will shut down in 2 minutes").format(backup=self.backup.name), "--timeout", "120"] status = subprocess.call(cmd) log.debug("Shutdown query. status=%d" % status) if status == 0 or status == 5: print("Running shutdown") subprocess.Popen(["shutdown", "-P", "now"]) print("Done running shutdown") except Exception as e: msg = _("Unable to shutdown PC: {error}").format( error=str(e)) if not self.dry_run: self.db.save_message(message) log.error(msg) def send_email(self, result, head): ''' Send a message to the appropriate users. If result is False (failure) then error message will contain the reason. @param result: @param error_message: ''' log.debug("send_email: ", result, head) if result: message_text = head + \ _("\n\nStatistics:\n {files} files backed up.\n " "{folders} folders backed up.\n {size} copied.\n" ).format(files=self.nfiles, folders=self.nfolders, size=utils.readable_form(self.bytes)) subject = _("Backup {server}/{backup}/{type} completed").format(server=utils.get_hostname(), backup=self.backup.name, type=self.type) else: message_text = head subject = _("Backup {server}/{backup}/{type} failed").format(server=utils.get_hostname(), backup=self.backup.name, type=self.type) if not self.options.dry_run: messages = " " + "\n ".join([message.time + " " + message.message for message in self.db.run_messages(self.run_id)]) message_text += _("\nBackup messages:\n") + messages else: message_text = "\n" log.debug("Starting mail send") try: sendemail.sendemail(subject, message_text) except Exception as e: msg = _("Unable to email results. {error}").format(error=str(e)) if not self.dry_run: self.db.save_message(msg) else: print(msg) log.trace("send_email completed") def backup_packages(self): ''' Build the package list. Then send to the backup server ''' log.info("Backing up packages") package_list = utils.get_packages() f = tempfile.NamedTemporaryFile(delete=False) f.write("\n".join(package_list)) f.close() self.copy_file(f.name, const.PackageFile) os.remove(f.name) def copy_file(self, path, name=None): log.debug("CopyFile: ", path, name) if not name: name = os.path.basename(path) if self.dry_run: print(utils.escape(name)) sys.stdout.flush() else: if self.backup.encrypt: if name: name = name + ".enc" # Otherwise left as None enc_path = path + ".enc" cryptor.encrypt_file(self.config.data_passphrase, path, enc_path) self.store.send(enc_path, os.path.join(self.backup_folder, name)) os.remove(enc_path) else: self.store.send(path, os.path.join(self.backup_folder, name)) def build_excl_exts(self): list = [] for name in self.backup.exclude_types: try: for ext in self.config.file_types[name]: list.append(ext) except: self.db.save_message(_("Exclusion Type %s is no longer recongnised. Ignored.") % name) return list def list_to_unicode(self, l): return [utils.path_to_unicode(p) for p in l] def recursive_backup_folder(self, root): ''' Backup a folder and all its sub-folders. This routine REQUIRES an absolute path. @param folder: ''' log.trace("recursive_backup_folder", root) # Before we interact with the FS - convert to utf-8 root = root.encode('utf-8') if len(root) == 0: raise Exception(_("Backup_folder called on empty folder name")) if root[0] != "/": raise Exception(_("Backup_folder requires absolute paths")) for folder, local_folders, local_files in os.walk(root): # Lets get everything to unicode # local_folders = self.list_to_unicode(local_folders) # local_files = self.list_to_unicode(local_files) log.debug("os.walk", folder, local_folders, local_files) # First: Check if this is specifically excluded if self.check_exclusion(folder): log.info("Excluding Dir:", folder) continue log.info("Backing up folder: %s" % folder) # local_files.sort() # local_folders.sort() # Get the data on this folder from the db db_files = self.db.list_dir(folder) log.debug("Backing up folder", folder) log.debug("local files:", local_files) log.debug("local folders:", local_folders) log.debug("DB files:", db_files) for local_file in local_files: try: local_path = os.path.join(folder, local_file) if self.check_backup(local_path, local_file, db_files): self.do_backup_file(folder, local_file) except StoreFullException as e: log.error(str(e)) raise e except Exception as e: log.warn("Skipping file %s: %s" % (local_file, str(e))) # Convert to unicode for checks below... local_folders = self.list_to_unicode(local_folders) local_files = self.list_to_unicode(local_files) # Have backed up all the local files. Now look for DB files # that exist, but are not local (i.e. they have been deleted) # Make sure we are only looking for 'F' and 'D' (ignore 'X') for db_file in db_files.itervalues(): try: uname = utils.path_to_unicode(db_file.name) if db_file.type in ['D', 'F'] and not uname in local_files and not uname in local_folders: self.do_backup_deleted(folder, db_file.name) except Exception as e: log.warn("Ignoring exception logging deleted file %s: %s" % (db_file.name, e)) for local_folder in local_folders: try: local_path = os.path.join(folder, local_folder) if self.check_backup(local_path, local_folder, db_files): self.do_backup_folder(folder, local_folder) except Exception as e: log.warn("Ignoring exception backing up folder %s: %s" % (local_path, e)) # # At the completion of a folder - we update the DB storage usage if not self.dry_run: self.bytes, self.hash = self.store_thread.get_hash() self.db.update_run_stats(self.bytes, self.nfiles, self.nfolders, self.backup.include_packages, self.hash) def lof_record(self, folder, name, type, mod_time=None, size=None): # Save the entry in the LOF log.trace("lof_record", folder, name) if folder != self.lof_folder: self.lof.write("\n%s\n" % utils.escape(folder)) self.lof_folder = folder self.lof.write("%s,%s" % (type, utils.escape(name))) if mod_time: self.lof.write(',%s,%d' % (mod_time, size)) self.lof.write("\n") def check_exclusion(self, path): _, ext = os.path.splitext(path) ext = ext[1:].lower() # Remove the '.' # Is this file excluded by type if ext in self.excl_ext: return True # Is this file excluded by filename/folder/glob ancestors = utils.ancestor_paths(path) #log.debug("Ancestor Pathlist:", ",".join(ancestors)) for patt in self.backup.exclude_patterns: for path in ancestors: if fnmatch.fnmatch(path, patt): return True return False def check_backup(self, path, basename, db_files): log.trace("check_backup", path, basename) # Check for exclusions if self.check_exclusion(path): log.debug("Excluding", path) return False # If this is a full backup, then its included if self.type == const.FullBackup: log.debug("Include", path, "because full backup") return True # Its an incremental - check timestamps. # Find it in the database... if not basename in db_files: log.debug("Include", path, "because new file") return True db_file = db_files[basename] # Was the last entry a delete? If so, its back and we back it up if db_file.type == 'X': log.debug("Include", path, "because file was deleted") return True if db_file.mod_time == None: # The last version record for this file must have been removed. # This can happen when the storage is too small for a complete # cycle of FULL and INCREMENTALS. The FULL has been deleted and # so there are FS entries, but no version entries. return True # Check the timestamp #local_modtime = self.get_file_time_str(path) local_modtime = datetime.fromtimestamp(os.path.getmtime(path)) # The file datetime is to the nearest microsecond. The DB time is not. local_modtime -= timedelta(microseconds=local_modtime.microsecond) log.debug("MOD TIME CHECK: db: %s local: %s" % (str(db_file.mod_time), str(local_modtime))) if local_modtime > db_file.mod_time: log.debug("Include", path, "because changed") return True # Check if the type has changed log.debug("TYPE CHECK: db type = %s isfile=%d" % (db_file.type, os.path.isfile(path))) if db_file.type == 'F' and not os.path.isfile(path): log.debug("Include", path, "because changed type") return True if db_file.type == 'D' and not os.path.isdir(path): log.debug("Include", path, "because changed type") return True # One extra check - just in case. Only for files if db_file.type == 'F': size = os.path.getsize(path) log.debug("SIZE CHECK: db: %s local: %s" % (db_file.size, size)) if size != db_file.size: log.debug("Include", path, "because changed size") return True return False def get_file_time_str(self, path): return datetime.fromtimestamp(os.path.getmtime(path)).strftime(const.DateTimeFormat) def do_backup_file(self, folder, name): log.trace("do_backup_file", folder, name) path = os.path.join(folder, name) if self.dry_run: print("F - %s" % utils.escape(path)) sys.stdout.flush() return # Add it to the tar try: # What's the encoding on the file? upath = utils.path_to_unicode(path) uname = utils.path_to_unicode(name) ufolder = utils.path_to_unicode(folder) # Due to issues with encoding... I'll open the file myself and pass to tar with open(path, "rb") as f: info = self.tarfile.gettarinfo(arcname=upath, fileobj=f) self.tarfile.addfile(info, f) #self.tarfile.addfile(name=path, recursive=False) mod_time = self.get_file_time_str(path) size = os.path.getsize(path) type = 'F' self.db.fs_saved(upath, mod_time, size, type) self.nfiles += 1 # Save the entry in the LOF self.lof_record(ufolder, uname, "F", mod_time, size) except Exception as e: # If the exception is in the store - we crash and burn # as we cannot save if self.store_thread.error: raise self.store_thread.error # Otherwise log it and keep going... msg = "Unable to backup %s: %s" % (path, str(e)) self.db.save_message(msg) log.warn(msg) def do_backup_folder(self, folder, name): log.trace("do_backup_folder", folder, name) path = os.path.join(folder, name) if self.dry_run: print("D - %s" % utils.escape(path)) sys.stdout.flush() return # We dont need to add it to the try: self.tarfile.add(name=path, recursive=False) mod_time = self.get_file_time_str(path) size = 0 type = 'D' self.db.fs_saved(path, mod_time, size, type) self.nfolders += 1 # Save the entry in the LOF self.lof_record(folder, name, "D", mod_time, size) except Exception as e: log.warn("Exception backing up folder %s: %s" % (path, str(e))) # If the exception is in the store - we crash and burn # as we cannot save if self.store_thread.error: raise self.store_thread.error # Otherwise log it and keep going... msg = "Unable to backup %s: %s" % (path, str(e)) self.db.save_message(msg) log.warn(msg) def do_backup_deleted(self, folder, name): path = os.path.join(folder, name) if self.dry_run: print("X - %s" % utils.escape(path)) sys.stdout.flush() return try: log.debug("FILE/FOLDER DELETED:", name) self.db.fs_deleted(path) # We keep track of deletions self.lof_record(folder, name, "X") except Exception as e: # If the exception is in the store - we crash and burn # as we cannot save if self.store_thread.error: raise self.store_thread.error # Otherwise log it and keep going... msg = "Unable to backup %s: %s" % (path, str(e)) self.db.save_message(msg) log.warn(msg) def prepare_store(self): # Test that the storage is available (this will connect and disconnect) self.store.test() # Connect to the store self.store.connect() try: log.info("Preparing store") # Ensure the store is properly marked and configured. self.store.setup_store() if self.backup.include_packages: self.backup_packages() # Backup the configuration self.copy_file(const.ConfigFile, const.ConfigName) finally: self.store.disconnect() def prepare_output(self): ''' Open the tar file. Connect the output of the tar to either: a) the storage handler b) to encryption (openssl), THEN the storage handler ''' log.trace("Setting up output processes") # If we are using an external save command, we do nothing here if self.dry_run: log.info("No output processes: Dry run") return # Set up the encryptor (use TEE for now) self.crypt_proc = None if self.backup.encrypt: log.debug("Creating crypto stream") self.crypto = cryptor.EncryptStream(self.config.data_passphrase) else: self.crypto = cryptor.Buffer() # Set up the storage handler log.debug("Starting storage thread") self.store_thread = StreamOut(self.crypto, self.store, self.backup_folder) self.store_thread.start() # Now set up the tar file which will feed all this log.debug("Connecting tar object") self.tarfile = tarfile.open(mode="w|gz", fileobj=self.crypto, format=tarfile.PAX_FORMAT, encoding="utf-8", dereference=False, bufsize=const.BufferSize) # Now set up a zipped temp file to record the list of files/folders saved tmp = tempfile.NamedTemporaryFile(delete=False) self.lof = gzip.GzipFile(tmp.name, mode="wb", compresslevel=9) tmp.close() # Used to keep track of the current folder self.lof_folder = "" log.trace("Completed output preparation") def close_output(self, success): ''' Close as much as we can. This means we may need to ignore some errors as we go to ensure everything gets closed. If success is True, then we have been successful up to this point. ''' log.trace("Closing output managers") # If we are using an external save command, we do nothing here if self.dry_run: log.info("No output managers: Dry Run") return # First exception will be returned. error = None try: self.tarfile.close() # Tar object tries to write after delete. Seems that in an error state, # we get more data after the crypto pipe is closed. # Its an ignorable error, that only occurs when output write fails. # del self.tarfile except Exception as e: if not error: error = e try: # Must manually close this (tarfile wont # close a file_obj self.crypto.close() except Exception as e: if not error: error = e try: # Now we are ready to wait for the storage. self.store_thread.join() if self.store_thread.error: msg = _("Error saving backup: %s") % str(self.store_thread.error) log.error(msg) self.db.save_message(msg) raise self.store_thread.error except Exception as e: # This one we will propogate error = e try: self.lof.close() if not error and success: # Send the lof only on success self.copy_file(self.lof.name, const.LOFFile) os.remove(self.lof.name) except Exception as e: if not error: error = e try: self.store.disconnect() # Update run data, ONLY if this was successful. if not error and success: self.bytes, self.hash = self.store_thread.get_hash() self.db.update_run_stats(self.bytes, self.nfiles, self.nfolders, self.backup.include_packages, self.hash) except Exception as e: if not error: error = e log.debug("All output closed. ") if error: raise error
class HistoryWindow(gui.HistoryWindow): ''' classdocs ''' def __init__(self, parent, default_name=None): ''' Constructor ''' gui.HistoryWindow.__init__(self, parent) log.trace("Starting up a history panel") self.db = DB() self.config = Config.get_config() self.order = const.ASC self.update_data(default_name) # self.imgList = wx.ImageList(16, 16) # self.img_up = self.imgList.Add(wx.Bitmap("images/go-up.png", wx.BITMAP_TYPE_PNG)) # self.img_down = self.imgList.Add(wx.Bitmap("images/go-down.png", wx.BITMAP_TYPE_PNG)) # self.lstRuns.SetImageList(self.imgList, wx.IMAGE_LIST_SMALL) icon = wx.Icon(os.path.join(const.PixmapDir, "storage.png"), wx.BITMAP_TYPE_ANY) self.SetIcon(icon) # listmix.ColumnSorterMixin.__init__(self, 7) # self.Bind(wx.EVT_LIST_COL_CLICK, self.onColClick, self.lstRuns) # self.SortListItems(2, 1) # Ensure the right page is showing self.nb_history.SetSelection(0) self.Show() def update_data(self, default_name = None): all = _("***All Backups***") if default_name: old_sel = default_name else: old_sel = self.cboBackup.GetStringSelection() if not old_sel: old_sel = all self.cboBackup.Clear() self.cboBackup.AppendItems([all]) self.cboBackup.AppendItems(self.config.backups.keys()) self.cboBackup.SetStringSelection(old_sel) self.update_runs() self.update_messages() def update_runs(self): if self.cboBackup.GetSelection() == 0: runs = self.db.runs() else: backup_name = self.cboBackup.GetStringSelection() runs = self.db.runs(backupname=backup_name) if self.order == const.ASC: runs.sort(key=lambda x : x.start_time_str, reverse=False) self.txtOrder.SetLabel("Order: Oldest First") else: runs.sort(key=lambda x : x.start_time_str, reverse=True) self.txtOrder.SetLabel("Order: Newest First") self.lstRuns.DeleteAllColumns() self.lstRuns.DeleteAllItems() self.lstRuns.InsertColumn(0, _("Name"), wx.LIST_FORMAT_LEFT) self.lstRuns.InsertColumn(1, _("Type"), wx.LIST_FORMAT_CENTER) self.lstRuns.InsertColumn(2, _("Time"), wx.LIST_FORMAT_CENTER) self.lstRuns.InsertColumn(3, _("Status"), wx.LIST_FORMAT_CENTER) self.lstRuns.InsertColumn(4, _("Files"), wx.LIST_FORMAT_CENTER) self.lstRuns.InsertColumn(5, _("Folders"), wx.LIST_FORMAT_CENTER) self.lstRuns.InsertColumn(6, _("Size"), wx.LIST_FORMAT_CENTER) self.itemDataMap = {} idx = 0 for run in runs: row = [run.name, run.type, run.start_time_str, run.status, str(run.nfiles), str(run.nfolders), utils.readable_form(run.size)] self.lstRuns.Append(row) self.lstRuns.SetItemData(idx, run.run_id) self.itemDataMap[idx + 1] = row idx = idx + 1 self.itemIndexMap = self.itemDataMap.keys() self.lstRuns.SetColumnWidth(0, 100) self.lstRuns.SetColumnWidth(1, 50) self.lstRuns.SetColumnWidth(2, wx.LIST_AUTOSIZE) self.lstRuns.SetColumnWidth(3, 80) self.lstRuns.SetColumnWidth(4, 120) self.lstRuns.SetColumnWidth(5, 100) self.lstRuns.SetColumnWidth(6, wx.LIST_AUTOSIZE) # Used by the ColumnSorterMixin, see wx/lib/mixins/listctrl.py def GetListCtrl(self): return self.lstRuns # Used by the ColumnSorterMixin, see wx/lib/mixins/listctrl.py def GetSortImages(self): return (self.img_down, self.img_up) def onColClick(self, event): event.Skip() def update_messages(self): self.lstMessages.DeleteAllColumns() self.lstMessages.DeleteAllItems() self.lstMessages.InsertColumn(0, _("Time")) self.lstMessages.InsertColumn(1, _("Message")) if self.cboBackup.GetSelection() == 0: messages = self.db.messages() else: backup_name = self.cboBackup.GetStringSelection() messages = self.db.backup_messages(backup_name) if self.order == const.ASC: messages.sort(reverse=False, key=lambda msg: msg.time) else: messages.sort(reverse=True, key=lambda msg: msg.time) for msg in messages: item = (msg.time, msg.message) self.lstMessages.Append(item) self.lstMessages.SetColumnWidth(0, wx.LIST_AUTOSIZE) self.lstMessages.SetColumnWidth(1, wx.LIST_AUTOSIZE) def onBackup(self, event): self.update_data() def onRefresh(self, event): self.update_data() def onDetails(self, event): # Get the selected item sel = self.lstRuns.GetFirstSelected() if sel == -1: return run_id = self.lstRuns.GetItemData(sel) # Will raise an exception if no run run = self.db.run_details(run_id) RunDetailsWindow(self, run) def onLeftDClick(self, event): self.onDetails(event) def onOrder(self, event): if self.order == const.ASC: self.order = const.DESC else: self.order = const.ASC self.update_data()