persoconf/main.py

#!/usr/bin/env python3

import argparse
import logging
import os, os.path
import shutil
import time
import tarfile

from utils     import yes_no_question,        contractuser,      \
                      copy_file_or_directory, delete_file_or_dir

from metafile  import Metafile, MalformedMetafileError, NoPathDefinedError

from persoconf import Persoconf, FileInsteadOfDirError, \
                      PersoconfRootDoesNotExistError

import commands.list,   commands.package, commands.update, commands.add, \
       commands.delete, commands.check

    

# ARGPARSE
########################################
# Argument parsing using argparse
parser = argparse.ArgumentParser()

parser.add_argument( "--rootdir"                                              ,
                     type=str                                                 ,
                     default="~/.config/persoconf/"                           ,
                     help="The persoconf directory to use" )

parser.add_argument( "--metafile"                                             ,
                     type=str                                                 ,
                     default="META"                                           ,
                     help="The name of the metadata files" )

parser.add_argument( "--verbose", "-v"                                        ,
                     action="store_true"                                      ,
                     help="Spout out more logs" )


subparsers = parser.add_subparsers( dest="command"                            ,
                                    title="commands" )

# Help
parser_help = subparsers.add_parser( "help"                                   ,
                                     help="Print this help" )

# List
parser_list = subparsers.add_parser( "list"                                   ,
                                     help="List backuped apps" )
commands.list.init(parser_list)

# Package
parser_package = subparsers.add_parser( "package"                             ,
                                        help="Package a persoconf repository" )
commands.package.init(parser_package)

# Update
parser_update = subparsers.add_parser( "update"                               ,
                                       help="Backup an app configuration in " \
                                            "the persoconf directory with "   \
                                            "the configuration in use now" )
commands.update.init(parser_update)

# Add
parser_add = subparsers.add_parser( "add"                                     ,
                                    help="Add an app to the persoconf "       \
                                         "directory, or add a config file "   \
                                         "to an existing app" )
commands.add.init(parser_add)

# Check
parser_check = subparsers.add_parser( "check"                                 ,
                                      help="Checks if the backuped and the "  \
                                           "original file are different." )
commands.check.init(parser_check)

# Delete
parser_del = subparsers.add_parser( "delete"                                  ,
                                    help="Delete an app from the persoconf "  \
                                         "directory, or a config file from "  \
                                         "an existing app" )
commands.delete.init(parser_del)

# Parse arguments
args = parser.parse_args()

# Transform paths
args.rootdir = os.path.expanduser(args.rootdir)

# LOGGING
########################################
log = logging.getLogger("persoconf")
log.setLevel(logging.DEBUG)

# Console handler
log_handler_console = logging.StreamHandler()
log_handler_console.setLevel(logging.WARNING)

# Let's adjust the console handler to the verbosity level required
if(args.verbose):
    log_handler_console.setLevel(logging.DEBUG)

log_formatter_console = logging.Formatter("%(name)s:%(levelname)s: %(message)s")
log_handler_console.setFormatter(log_formatter_console)


log.addHandler(log_handler_console)

# SCRIPT
########################################
# If we were asked for help, let's give some
if args.command in [ "help", None ]:
    parser.print_help()
    exit()

# Try to create the Persoconf
try:
    persoconf = Persoconf(path=args.rootdir, metafile=args.metafile)

# If the place is already taken, there's nothing we can do
except FileInsteadOfDirError:
    log.error("'%s' exists but is a file" % str(args.rootdir))

# Otherwise, maybe we can create the directory ?
except PersoconfRootDoesNotExistError:
    log.warning("'%s' does not exist" % str(args.rootdir))

    # Ask before creating the directory
    if not yes_no_question( "Do you want to create the persoconf directory "  \
                            "'%s'?"
                            % str(args.rootdir) ) :
        log.info("The persoconf directory was not created")
        exit()

    # Create the directory
    log.info("Creating persoconf directory...")
    os.mkdir(args.rootdir)

    log.info("New persoconf directory created at '%s'" % args.rootdir)

    # Finally retry to create the Persoconf
    try:
        persoconf = Persoconf(args.rootdir, metafile=args.metafile)
    except Error as err:
        log.error("Something very unexpected occured, I'm sorry")
        log.error("Error dump follows")
        log.error(str(err))
        exit()

# LIST COMMAND
########################################
if args.command == "list":
    commands.list.run(args, persoconf, log)

# DELETE COMMAND
########################################
if args.command == "delete":
    commands.delete.run(args, persoconf, log)

# ADD COMMAND
########################################
if args.command == "add":
    commands.add.run(args, persoconf, log)

# CHECK COMMAND
########################################
if args.command == "check":
    commands.check.run(args, persoconf, log)

# UPDATE COMMAND
########################################
if args.command == "update":
    commands.update.run(args, persoconf, log)

# PACKAGE COMMAND
########################################
if args.command == "package":
    commands.package.run(args, persoconf, log)


    



########################################