apbp/apbp.py

   1 #!/usr/bin/python
   2 #
   3 #       apbp.py
   4 #
   5 #       Copyright 2010 Alexander Preisinger <alexander.preisinger@gmail.com>
   6 #
   7 #       This program is free software; you can redistribute it and/or modify
   8 #       it under the terms of the GNU General Public License as published by
   9 #       the Free Software Foundation; either version 2 of the License, or
  10 #       (at your option) any later version.
  11 #
  12 #       This program is distributed in the hope that it will be useful,
  13 #       but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 #       GNU General Public License for more details.
  16 #
  17 #       You should have received a copy of the GNU General Public License
  18 #       along with this program; if not, write to the Free Software
  19 #       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  20 #       MA 02110-1301, USA.
  21
  22 __version__ = "1.0"
  23
  24 import os
  25 import os.path
  26 import sys
  27 import tarfile
  28 import datetime
  29 from optparse import OptionParser
  30
  31 # Cron fix
  32 if 'XDG_DATA_HOME' not in os.environ:
  33     os.environ['XDG_DATA_HOME'] = os.path.join(os.environ['HOME'], \
  34         '.local/share')
  35 # Cron fix
  36
  37 _ex = os.path.exists
  38 _abs = os.path.abspath
  39 _isdir = os.path.isdir
  40 _dpath = _abs(os.path.join(os.environ['XDG_DATA_HOME'], 'apbp')) + os.sep
  41 _trust = _dpath+'.SECURE'
  42
  43 if not _ex(_dpath):
  44     os.makedirs(_dpath)
  45
  46 with open(_dpath+'.SECURE', 'w') as trusted_file:
  47     pass
  48
  49
  50 optparser = OptionParser("""\n{name} [OPTIONS] [ADDITIONAL-FILES]
  51 {name} -x ARCHIVE FILES
  52 {name} -c CONFIG-FILE [ADDITIONAL-FILES]""".format(name=sys.argv[0]))
  53
  54 optparser.add_option("-c", "--config", dest="config", \
  55     help="use a config", metavar="FILENAME")
  56
  57 optparser.add_option("-x", "--archive", dest="archive", \
  58     help="choose an archive (gzip, bzip2)", metavar="TAR-ARCHIVE")
  59
  60 optparser.add_option("-i", "--ignore", dest="ignore", \
  61     help="""ignores files in the given path
  62 use comma to sepperate paths (e.g. FILE1,PATH1,FILE2,...)""", metavar="FILE")
  63
  64 optparser.add_option("-r", "--restore", dest="restore", \
  65     help="restores the saved data, will overwrite the original files", \
  66     metavar="TAR-ARCHIVE")
  67
  68 optparser.add_option("-s", "--separator", dest="separator", \
  69     help="use a different separator for lists of files", metavar="CHAR")
  70
  71 optparser.add_option("-v", "--verbose", action="store_true", dest="verbose",
  72     default=False, help="verbose output")
  73
  74
  75 def get_config(filename, separator):
  76     """
  77     Reads the lines from the given file and checks if these lines are valid.
  78     """
  79     configs = {'separator' : separator}
  80
  81     filename = _abs(filename)
  82     if _ex(filename):
  83         cfile = open(filename, 'r')
  84
  85         for line in cfile.readlines():
  86             line = line.strip()
  87
  88             if line.startswith('#') or line == '':
  89                 continue
  90             else:
  91
  92                 if line == 'replace':
  93                     try:
  94                         key, value = line.split('=')
  95                     except ValueError:
  96                         key = line
  97                         value = 1
  98
  99                 else:
 100                     try:
 101                         key, value = line.split('=')
 102
 103                     except ValueError:
 104                         optparser.error('{file} contains an invalid line'\
 105                             .format(file=filename))
 106
 107                     key = key.strip()
 108                     value = value.strip()
 109
 110                     if key == 'files' or key == 'ignore':
 111
 112                         if configs['separator'] in value:
 113                             value = value.split(configs['separator'])
 114                         else:
 115                             value = [value]
 116
 117                 configs[key] = value
 118
 119         cfile.close()
 120
 121         return configs
 122
 123     else:
 124         optparser.error('{file} does not exist'.format(file=filename))
 125
 126
 127 def abs_and_check(files):
 128     """
 129     Returns the files with the absolute pathname and checks if the file exists.
 130     """
 131     files = [_abs(file) for file in files]
 132
 133     for file in files:
 134         if not _ex(file):
 135             optparser.error('{file} does not exist'.format(file=file))
 136
 137     return files
 138
 139
 140 def subdir(files):
 141     """
 142     Checks if the file is a directory. If true then the directory will be
 143     removed from the filelist and its files will be added and also this files
 144     will be checked if they are directories and so on.
 145     """
 146     for file in files:
 147
 148         if _isdir(file):
 149             files.remove(file)
 150
 151             if not file.endswith(os.sep):
 152                 file = file + os.sep
 153
 154             subfiles = [file+subfile for subfile in os.listdir(file)]
 155             files.extend(subdir(subfiles))
 156
 157     return files
 158
 159
 160 def get_files(afiles, ignore):
 161     """
 162     Removes the ignored files form the file list.
 163     """
 164     afiles = abs_and_check(afiles)
 165     ignore = abs_and_check(ignore)
 166
 167     afiles = subdir(afiles)
 168
 169     nfiles = []
 170     for file in afiles:
 171         IGN = False
 172
 173         for ign in ignore:
 174             if file.startswith(ign):
 175                 IGN = True
 176
 177         if not IGN:
 178             nfiles.append(file)
 179
 180     return nfiles
 181
 182
 183 def archive(archive_name, files, verbose=False):
 184     """
 185     Finally archives the file under the given name
 186     """
 187     archive_type = archive_name.split('.')[-1]
 188
 189     if archive_type != 'gz' and archive_type != 'bz2':
 190         optparser.error('the archive has to be a *.tar.gz or a *.tar.bz2 file')
 191
 192     archive_file = tarfile.open(archive_name, 'w:%s' % archive_type)
 193
 194     for file in files:
 195
 196         if verbose:
 197             print(file)
 198
 199         archive_file.add(file)
 200
 201     archive_file.add(_trust, os.path.basename(_trust))
 202
 203     archive_file.close()
 204
 205
 206 def main(options, args):
 207     configs = {'replace' : 0, 'files' : [], 'ignore' : [], 'separator' : ','}
 208
 209     if options.separator:
 210         configs['separator'] = options.separator
 211
 212     if options.config:
 213         configs.update(get_config(options.config, configs['separator']))
 214
 215     if options.archive:
 216         configs['archive'] = options.archive
 217
 218     if options.ignore:
 219         if configs['separator'] not in options.ignore:
 220             ignore = [options.ignore]
 221
 222         else:
 223             ignore = options.ignore.split(configs['separator'])
 224
 225         configs['ignore'].extend(ignore)
 226
 227     configs['files'].extend(args)
 228
 229     if 'archive' in configs:
 230         files = get_files(configs['files'], configs['ignore'])
 231
 232         ctime = datetime.datetime.now()
 233         # Support for time formatting in the archive name
 234         name = ctime.strftime(configs['archive'])
 235
 236         archive(name, files, options.verbose)
 237
 238         if options.verbose:
 239             print('--> '+_abs(name))
 240
 241         if configs['replace']:
 242             conf_filename = os.path.basename(options.config)
 243             rpfilename = _dpath + conf_filename
 244
 245             if _ex(rpfilename):
 246                 rpfile = file(rpfilename, 'r')
 247                 rep_files = [files.strip() for files in rpfile.readlines()]
 248                 rpfile.close()
 249
 250                 rep_no = int(configs['replace'])
 251                 if rep_no == len(rep_files):
 252
 253                     del_filename = rep_files.pop(rep_no-1)
 254
 255                     if _ex(del_filename):
 256                         if name != del_filename:
 257                             os.remove(del_filename)
 258
 259                 rep_files.insert(0, name)
 260                 rpfile = file(rpfilename, 'w')
 261                 rpfile.write('\n'.join(rep_files))
 262                 rpfile.close()
 263
 264             else:
 265                 rpfile = file(rpfilename, 'w')
 266                 rpfile.write(name)
 267                 rpfile.close
 268
 269     elif options.restore:
 270         archive_name = _abs(options.restore)
 271
 272         if options.verbose:
 273             print('<-- '+archive_name)
 274
 275         if _ex(archive_name):
 276             archive_file = tarfile.open(archive_name, 'r')
 277             try:
 278                 archive_file.getmember(os.path.basename(_trust))
 279
 280                 if len(args) == 0:
 281                     if options.verbose:
 282                         members = archive_file.getmembers()
 283
 284                         for member in members:
 285                             if member.name != '.SECURE':
 286                                 print(member.name)
 287                                 archive_file.extract(member, '/')
 288
 289                     else:
 290                         archive_file.extractall('/')
 291
 292                 else:
 293                     members = archive_file.getmembers()
 294
 295                     for member in members:
 296
 297                         if member.name != '.SECURE':
 298                             for replace in args:
 299
 300                                 if replace.startswith('/'):
 301                                     replace = replace[1:]
 302
 303                                 if member.name.startswith(replace):
 304
 305                                     if options.verbose:
 306                                         print(member.name)
 307
 308                                     archive_file.extract(member, '/')
 309
 310             except:
 311                 optparser.error("{file} is not a trusted archive"\
 312                     .format(file=archive_name))
 313
 314         else:
 315             optparser.error("{file} does not exist".format(file=archive_name))
 316     else:
 317         optparser.print_help()
 318
 319 if __name__ == "__main__":
 320     options, args = optparser.parse_args()
 321     try:
 322         main(options, args)
 323     except KeyboardInterrupt:
 324         optparser.error('KeyboardInterrupt')