#!/usr/bin/python 

"""
backup the critical filesystems
"""


import os, sys, string, time, getopt
import stat

def copyfile(src, dst):
    """Copy data from src to dst"""
    fsrc = None
    fdst = None
    try:
        fsrc = open(src, 'rb')
        fdst = open(dst, 'wb')
	i = 0
        while 1:
	  i = i + 1
	  buf = fsrc.read(64*1024)
	  if not buf:
	    break
	  fdst.write(buf)

	  if (i % 100)== 0:
	    time.sleep(1)
    finally:
        if fdst:
            fdst.close()
        if fsrc:
            fsrc.close()


def copystat(src, dst):
    """Copy all stat info (mode bits, atime and mtime) from src to dst"""
    st = os.stat(src)
    mode = stat.S_IMODE(st[stat.ST_MODE])
    os.chmod(dst, mode)
    os.utime(dst, (st[stat.ST_ATIME], st[stat.ST_MODE]))

def copy2(src, dst):
    """Copy data and all stat info ("cp -p src dst").

    The destination may be a directory.

    """
    if os.path.isdir(dst):
        dst = os.path.join(dst, os.path.basename(src))
    copyfile(src, dst)
    copystat(src, dst)


def copytree(src, dst, symlinks=0):
    """Recursively copy a directory tree using copy2().

    The destination directory must not already exist.
    Error are reported to standard output.

    If the optional symlinks flag is true, symbolic links in the
    source tree result in symbolic links in the destination tree; if
    it is false, the contents of the files pointed to by symbolic
    links are copied.

    XXX Consider this example code rather than the ultimate tool.

    """
    names = os.listdir(src)
    files = []
    for name in names:
      srcname = os.path.join(src, name)
      length = os.stat(srcname)[6]
      files.append((length, name))
    files.sort()

    os.mkdir(dst)
    for (length, name) in files:
        srcname = os.path.join(src, name)
        dstname = os.path.join(dst, name)
        try:
            if symlinks and os.path.islink(srcname):
                linkto = os.readlink(srcname)
                os.symlink(linkto, dstname)
            elif os.path.isdir(srcname):
                copytree(srcname, dstname)
            else:
                copy2(srcname, dstname)
            # XXX What about devices, sockets etc.?
        except (IOError, os.error), why:
            print "Can't copy %s to %s: %s" % (`srcname`, `dstname`, str(why))
  


def Backup(backuptype, source, dest, numbackups):
  if backuptype != "cp":
    try: os.unlink(dest + ".%d" % (numbackups))
    except os.error: pass
  else:
    cmd = "rm -rf %s.%d" % (dest, numbackups)
    rc = os.system(cmd)

  for i in range(numbackups, 0, -1):
    cmd = "mv %s.%d %s.%d >& /dev/null" % (dest, i-1, dest, i)
    rc = os.system(cmd)

  fn = dest + ".0"
  if backuptype == "cp":
    copytree(source, fn)
  elif backuptype == "tar":
    cmd = "tar cf %(fn)s %(source)s >& /dev/null" % vars()
    rc = os.system(cmd)
  else:
    cmd = "tar czf %(fn)s %(source)s >& /dev/null" % vars()
    rc = os.system(cmd)

  rc = rc >> 8
  if rc != 0: 
    sys.stderr.write("Backup failed\n")
    sys.exit (-1)
    
def exceptionString():
  import StringIO
  import traceback

  ## get the traceback message  
  sfp = StringIO.StringIO()
  traceback.print_exc(file=sfp)
  exception = sfp.getvalue()
  sfp.close()

  return exception

def usage(progname):
  print "usage: %s [--num=d] sourcepath destpath" % progname
  print __doc__

def main(argc, argv):
  progname = argv[0]
  list, args = getopt.getopt(argv[1:], "", ["help", "copy", "tar", "tgz", "num=", "log"])

  backuptype = "tgz"

  if len(args) == 0:
    usage(progname)
    return

  numbackups = 10

  for (field, val) in list:
    if field == "--help":
      usage(progname)
      return
    if field == "--copy":
      backuptype = "cp"

    if field == "--tar":
      backuptype = "tar"

    if field == "--tgz":
      backuptype = "tgz"

    if field == "--num":
      numbackups = string.atoi(val)
    
  try:
    Backup(backuptype, args[0], args[1], numbackups)
  except:
    sys.stderr.write("Unable to complete Backup!!\n%s\n" % (exceptionString()))

if __name__ == "__main__":
  main(len(sys.argv), sys.argv)