def __copylogfile(self): # TODO: we should flush the log file before copy! _op = fam.get_file_operations_facade_instance() if not self.__fam_target_hdl.is_initialized(): self.logger.warning( _("Unable to copy log. File access is not initialized.")) else: if self.__snapshot is not None: logf_src = self.config.get_current_logfile() if logf_src is None: self.logger.warning(_("No log file specified.")) else: logf_name = _op.get_basename(logf_src) logf_target = _op.joinpath(self.__snapshot.getPath(), logf_name) if _op.path_exists(logf_src): try: _op.copyfile(logf_src, logf_target) except exceptions.CopyFileAttributesError: self.logger.warning(_("Unable to change permissions for file '%s'.")\ % logf_target) except (OSError, IOError), error: self.logger.warning( _("Unable to copy log file: %s") % error) else: self.logger.warning( _("Unable to find logfile to copy into snapshot."))
def __init__ (self, path): """The snapshot constructor. :param path : the path to the snapshot dir. :todo: Any distinction between creation of a new snapshot and opening\ an existing one from disk would be useful! The reason is that\ instantiation a Snapshot with a not existing path creates a\ snapshot directory in any case, currently! We need to handle the\ case: opening an snapshot that is supposed to exist but in fact\ doesn't! :todo: Separate commit of snapshot and the snapshot (name, path, ...) itself into classes with concise responsibilities. """ self.logger = log.LogFactory.getLogger() self._fop = fam.get_file_operations_facade_instance() # Attributes self.__name = False self.__base = None self.__format = "none" # default value self.__followlinks = False self.__snarfile = None # explicitely defined include and exclude file lists; these lists are filled from the configuration self.__includeFlist = structs.SBdict() self.__includeFlistFile = None # Str self.__excludeFlist = structs.SBdict() self.__excludeFlistFile = None # Str self.__space_required = constants.SPACE_REQUIRED_UNKNOWN self.__splitedSize = 0 self.__excludes = False self.__packages = False self.__version = False self.__snapshotpath = None self.__baseSnapshot = None # set some attributes self.setPath(path) # sets path and validates name # check if it's an existing snapshot if self._fop.path_exists(self.__snapshotpath): self.__validateSnapshot(self.__snapshotpath, self.__name) else : # Snapshot for creation self._fop.makedir(self.__snapshotpath) #LP #785512: make the snapshot directory RWX only by owner self._fop.chmod_no_rwx_grp_oth(self.__snapshotpath)
def __init__(self, parent=None): GladeWindow.__init__(self, gladefile=Util.get_resource_file( gtk_rsrc.RESTOREGUI_GLADEFILE), widget_list=gtk_rsrc.get_restoregui_widgets(), handlers=gtk_rsrc.get_restoregui_handlers(), root=gtk_rsrc.RESTOREGUI_TOPWINDOW, parent=parent, pull_down_dict=None) self.set_top_window(self.widgets[gtk_rsrc.RESTOREGUI_TOPWINDOW]) Gtk.Window.set_default_icon_from_file( Util.get_resource_file(constants.RESTORE_ICON_FILENAME)) # setup progress bar ProgressbarMixin.__init__(self, self.widgets['progressbar']) self._init_pulse() self.logger = LogFactory.getLogger(level=10) self.config = self.__get_configuration() self.__default_destination_path = self.config.get_destination_path() self.currentSnp = None self.currentsbdict = None self.currSnpFilesInfos = None self.restoreman = None self.snpman = None self.target = None self.__fam_target_hdl = fam.get_fam_target_handler_facade_instance() self.__fop = fam.get_file_operations_facade_instance() # tree stores self.snplisttreestore = Gtk.TreeStore(str, str) self.flisttreestore = Gtk.TreeStore(str, str) self.flisttreesort = Gtk.TreeModelSort(self.flisttreestore) self.historylisttreestore = Gtk.TreeStore(str) self.__init_treeviews() self.widgets['snpdetails'].set_sensitive(False) self.__context_id = None self.__init_statusbar() # firstly initialize destination with target of default profile self._defaultdest_active = True self.widgets['defaultradiob'].set_active(True) self._apply_defaultradiob_state() self.widgets['defaultfolderlabel'].set_text(_("n.a.")) self._defaultdest_active = True GObject.idle_add(self.__set_destination, self.__default_destination_path) self.__restore_dialog = RestoreDialog(parent=self)
def debug_print_snarfile(filename): """Print function only for debugging. :param filename: full path of snar to be printed out :type filename: string """ _fop = fam.get_file_operations_facade_instance() if _fop.path_exists(filename): _snar = SnapshotFile(filename, writeFlag=False) print("\nSUMMARY of SNAR '%s':" % filename) for _record in _snar.parseFormat2(): print("%s" % _record) else: print("\nSUMMARY of SNAR '%s': file not found!" % filename)
def debug_snarfile_to_list(filename): """Helper function for debugging: the snar-file given by parameter 'filename' is converted into a list and this list is returned by the function. :param filename: full path of snar to be converted :type filename: string :return: list containing snar file entries """ _res = [] _fop = fam.get_file_operations_facade_instance() if _fop.path_exists(filename): _snar = SnapshotFile(filename, writeFlag=False) for _record in _snar.parseFormat2(): _res.append(_record) return _res
def __init__(self, destination): """Default constructor. Takes the path to the target backup directory as parameter. """ if not isinstance(destination, str): raise TypeError("Destination path of type string expected. Got %s instead"\ % type(destination)) self.logger = LogFactory.getLogger() self._fop = fam.get_file_operations_facade_instance() # This is the current directory used by this SnapshotManager self.__dest_path = destination # The list of the snapshots is stored the first time it's used, # so we don't have to re-get it later self.__snapshots = None # helper variables for displaying status messages self.statusMessage = None self.substatusMessage = None self.statusNumber = None
def __init__(self, targethandler): """ """ self.logger = log.LogFactory.getLogger() self.__fam_target_hdl = targethandler self._fop = fam.get_file_operations_facade_instance()
def __retrieve_basic_infos(self, force_full_snp=False): """Retrieves basic informations about the snapshot that is going to be created. This informations include: 1. the path of the new snapshot 2. the base of the new snapshot :param listing: a list of snapshots :return: the determined `snppath` and `base` :rtype: a tuple """ _fop = fam.get_file_operations_facade_instance() # Get the list of snapshots that matches the latest snapshot format listing = self.__snpman.get_snapshots() agelimit = int(self.config.get("general", "maxincrement")) increment = False base = None if (len(listing) == 0) or (force_full_snp is True): increment = False else: # we got some snaphots # we search for the last full base = listing[0] if listing[0].isfull(): # Last backup was full backup self.logger.debug("Last (%s) was a full backup" % listing[0].getName()) d = listing[0].getDate() age = (datetime.date.today() - datetime.date(d["year"], d["month"], d["day"])).days if age < agelimit: # Less than maxincrement days passed since that -> make an increment self.logger.info( "Last full backup is %i days old < %s -> make inc backup" % (age, agelimit)) increment = True else: self.logger.info( "Last full backup is %i days old > %s -> make full backup" % (age, agelimit)) increment = False # Too old -> make full backup else: # Last backup was an increment - lets search for the last full one self.logger.debug( " Last snapshot (%s) was incremental. Lookup of latest full snapshot." % listing[0].getName()) for i in listing: if i.isfull(): d = i.getDate() age = (datetime.date.today() - datetime.date( d["year"], d["month"], d["day"])).days if age < agelimit: # Last full backup is fresh -> make an increment self.logger.info( "Last full backup is fresh (%d days old )-> make an increment" % age) increment = True else: # Last full backup is old -> make a full backup self.logger.info( "Last full backup is old -> make a full backup" ) increment = False break else: self.logger.info( "No full backup found -> lets make a full backup to be safe" ) increment = False # Determine and create backup target directory hostname = socket.gethostname() snpname = "%s.%s" % (datetime.datetime.now().isoformat("_").replace( ":", "."), hostname) if increment is True: snpname = "%s.inc" % snpname else: snpname = "%s.ful" % snpname tdir = self.__fam_target_hdl.get_snapshot_path(snpname) self.logger.debug("Snapshot path: %s" % tdir) return (tdir, base)