+ # Find the type
+ self.type = self.__find_type ()
+
+ logger.addMessage ('Detected set of type: %s' % self, RarslaveLogger.MessageType.Debug)
+
+ # Find the heads
+ self.heads = self.__find_heads ()
+
+ for h in self.heads:
+ logger.addMessage ('Adding extraction head: %s' % h, RarslaveLogger.MessageType.Debug)
+
+ def __repr__ (self):
+ return \
+ { TYPE_OLDRAR : 'Old RAR',
+ TYPE_NEWRAR : 'New RAR',
+ TYPE_ZIP : 'Zip',
+ TYPE_NOEXTRACT : 'No Extract',
+ TYPE_UNKNOWN : 'Unknown' } [self.type]
+
+ def __find_type (self):
+
+ all_files = no_duplicates (self.name_matched_files + self.prot_matched_files)
+
+ if self.is_oldrar (all_files):
+ return TYPE_OLDRAR
+ elif self.is_newrar (all_files):
+ return TYPE_NEWRAR
+ elif self.is_zip (all_files):
+ return TYPE_ZIP
+ elif self.is_noextract (all_files):
+ return TYPE_NOEXTRACT
+
+ return TYPE_UNKNOWN
+
+ def __generic_find_heads (self, regex, ignorecase=True):
+
+ heads = []
+
+ if ignorecase:
+ cregex = re.compile (regex, re.IGNORECASE)
+ else:
+ cregex = re.compile (regex)
+
+ all_files = no_duplicates (self.name_matched_files + self.prot_matched_files)
+
+ for f in all_files:
+ if cregex.match (f):
+ heads.append (f)
+
+ return heads
+
+ def __find_heads (self):
+
+ if self.type == TYPE_OLDRAR:
+ return self.__generic_find_heads ('^.*\.rar$')
+ elif self.type == TYPE_NEWRAR:
+ return self.__generic_find_heads ('^.*\.part0*1\.rar$')
+ elif self.type == TYPE_ZIP:
+ return self.__generic_find_heads ('^.*\.zip$')
+ elif self.type == TYPE_NOEXTRACT:
+ return self.prot_matched_files
+
+ return []
+
+ def __create_directory (self, dir):
+ if dir == None:
+ return SUCCESS
+
+ if os.path.isdir (dir):
+ return SUCCESS
+
+ try:
+ os.makedirs (dir)
+ logger.addMessage ('Created directory: %s' % dir, RarslaveLogger.MessageType.Verbose)
+ except OSError:
+ logger.addMessage ('FAILED to create directory: %s' % dir, RarslaveLogger.MessageType.Fatal)
+ return -EEXTRACT
+
+ return SUCCESS
+
+ def runExtract (self, todir=None):
+ # Extract all heads of this set
+
+ # Extract to the head's dir if we don't care where to extract
+ if todir == None:
+ todir = self.dir
+
+ # Create the directory $todir if it doesn't exist
+ ret = self.__create_directory (todir)
+
+ if ret != SUCCESS:
+ return -EEXTRACT
+
+ # Extract all heads
+ extraction_func = \
+ { TYPE_OLDRAR : self.__extract_rar,
+ TYPE_NEWRAR : self.__extract_rar,
+ TYPE_ZIP : self.__extract_zip,
+ TYPE_NOEXTRACT : self.__extract_noextract,
+ TYPE_UNKNOWN : self.__extract_unknown }[self.type]
+
+ # Call the extraction function on each head
+ for h in self.heads:
+ full_head = full_abspath (h)
+ ret = extraction_func (full_head, todir)
+ logger.addMessage ('Extraction Function returned: %d' % ret, RarslaveLogger.MessageType.Debug)
+
+ # Check error code
+ if ret != SUCCESS:
+ logger.addMessage ('Failed extracting: %s' % h, RarslaveLogger.MessageType.Fatal)
+ return -EEXTRACT
+
+ return SUCCESS
+
+ def __extract_rar (self, file, todir):
+ assert os.path.isfile (file)
+ assert os.path.isdir (todir)
+
+ RAR_CMD = config.get_value ('commands', 'unrar')
+
+ cmd = '%s \"%s\"' % (RAR_CMD, file)
+ ret = run_command (cmd, todir)
+
+ # Check error code
+ if ret != 0:
+ return -EEXTRACT
+
+ return SUCCESS
+
+ def __extract_zip (self, file, todir):
+ ZIP_CMD = config.get_value ('commands', 'unzip')
+
+ cmd = ZIP_CMD % (file, todir)
+ ret = run_command (cmd)
+
+ # Check error code
+ if ret != 0:
+ return -EEXTRACT
+
+ return SUCCESS
+
+ def __extract_noextract (self, file, todir):
+ # Just move this file to the $todir, since no extraction is needed
+ # FIXME: NOTE: mv will fail by itself if you're moving to the same dir!
+ NOEXTRACT_CMD = config.get_value ('commands', 'noextract')
+
+ # Make sure that both files are not the same file. If they are, don't run at all.
+ if os.path.samefile (file, os.path.join (todir, file)):
+ return SUCCESS
+
+ cmd = NOEXTRACT_CMD % (file, todir)
+ ret = run_command (cmd)
+
+ # Check error code
+ if ret != 0:
+ return -EEXTRACT
+
+ return SUCCESS
+
+ def __extract_unknown (self, file, todir):
+ return SUCCESS
+
+ def __generic_matcher (self, files, regex, nocase=False):
+ """Run the regex over the files, and see if one matches or not.
+ NOTE: this does not return the matches, just if a match occurred."""
+
+ if nocase:
+ cregex = re.compile (regex, re.IGNORECASE)
+ else:
+ cregex = re.compile (regex)
+
+ for f in files:
+ if cregex.match (f):
+ return True
+
+ return False
+
+ def is_oldrar (self, files):
+ return self.__generic_matcher (files, '^.*\.r00$')
+
+ def is_newrar (self, files):
+ return self.__generic_matcher (files, '^.*\.part0*1\.rar$')
+
+ def is_zip (self, files):
+ return self.__generic_matcher (files, '^.*\.zip$')
+
+ def is_noextract (self, files):
+ # Type that needs no extraction.
+ # TODO: Add others ???
+ return self.__generic_matcher (files, '^.*\.001$')
+
+class PAR2Set (object):
+
+ dir = None
+ p2file = None # The starting par2
+ basename = None # The p2file's basename
+ all_p2files = []
+ name_matched_files = [] # Files that match by basename of the p2file
+ prot_matched_files = [] # Files that match by being protected members
+
+ def __init__ (self, dir, p2file):
+ assert os.path.isdir (dir)
+ assert os.path.isfile (os.path.join (dir, p2file))
+
+ self.dir = dir
+ self.p2file = p2file
+ self.basename = self.__get_basename (p2file)
+
+ # Find files that match by name only
+ self.name_matched_files = self.__find_name_matches (self.dir, self.basename)
+
+ # Find all par2 files for this set using name matches
+ self.all_p2files = find_par2_files (self.name_matched_files)
+
+ # Try to get the protected files for this set
+ self.prot_matched_files = self.__parse_all_par2 ()
+
+ def __list_eq (self, l1, l2):
+
+ if len(l1) != len(l2):
+ return False
+
+ for e in l1:
+ if e not in l2:
+ return False
+
+ return True
+
+ def __eq__ (self, rhs):
+ return (self.dir == rhs.dir) and (self.basename == rhs.basename) and \
+ self.__list_eq (self.name_matched_files, rhs.name_matched_files) and \
+ self.__list_eq (self.prot_matched_files, rhs.prot_matched_files)
+
+ def __get_basename (self, name):
+ """Strips most kinds of endings from a filename"""
+
+ regex = config.get_value ('regular expressions', 'basename_regex')
+ r = re.compile (regex, re.IGNORECASE)
+ done = False
+
+ while not done:
+ done = True
+
+ if r.match (name):
+ g = r.match (name).groups()
+ name = g[0]
+ done = False
+
+ return name
+
+ def __parse_all_par2 (self):
+ """Searches though self.all_p2files and tries to parse at least one of them"""
+ done = False
+ files = []
+
+ for f in self.all_p2files:
+
+ # Exit early if we've found a good file
+ if done:
+ break
+
+ try:
+ files = Par2Parser.get_protected_files (self.dir, f)
+ done = True
+ except (EnvironmentError, OSError, OverflowError):
+ logger.addMessage ('Corrupt PAR2 file: %s' % f, RarslaveLogger.MessageType.Fatal)
+
+ # Now that we're out of the loop, check if we really finished
+ if not done:
+ logger.addMessage ('All PAR2 files corrupt for: %s' % self.p2file, RarslaveLogger.MessageType.Fatal)
+
+ # Return whatever we've got, empty or not
+ return files
+
+ def __find_name_matches (self, dir, basename):
+ """Finds files which are likely to be part of the set corresponding
+ to $name in the directory $dir"""
+
+ assert os.path.isdir (dir)
+
+ ename = re.escape (basename)
+ regex = re.compile ('^%s.*$' % (ename, ))
+
+ return [f for f in os.listdir (dir) if regex.match (f)]
+
+ def __update_name_matches (self):
+ """Updates the self.name_matched_files variable with the most current information.
+ This should be called after the directory contents are likely to change."""
+
+ self.name_matched_files = self.__find_name_matches (self.dir, self.basename)
+
+ def __is_joinfile (self, filename):
+ regex = re.compile ('^.*\.\d\d\d$', re.IGNORECASE)
+ if regex.match (filename):
+ return True
+
+ return False
+
+ def __should_be_joined (self, files):
+ for f in files:
+ if self.__is_joinfile (f):
+ return True
+
+ def runCheckAndRepair (self):
+ PAR2_CMD = config.get_value ('commands', 'par2repair')