X-Git-Url: https://scripts.mit.edu/gitweb/wizard.git/blobdiff_plain/ff0505d4d123bed81223d9f16c8d5e76873b78f2..319f82896fb658d9bbaf8d01d6c2c7410eb967c7:/wizard/command/__init__.py diff --git a/wizard/command/__init__.py b/wizard/command/__init__.py index bbf389b..8d5e14c 100644 --- a/wizard/command/__init__.py +++ b/wizard/command/__init__.py @@ -1,5 +1,178 @@ -import migrate -import massmigrate -import info -import summary -import upgrade +import logging +import traceback +import os +import sys +import optparse +import errno +import pwd +import shutil +import cStringIO + +import wizard +from wizard import util, shell + +def chdir_to_production(): + if os.path.exists(".git/WIZARD_UPGRADE_VERSION"): # XXX do something more robust + util.chdir(shell.eval("git", "config", "remote.origin.url")) + return True + return False + +logging_setup = False +debug = True # This will get overwritten with the real value early on + +def setup_logger(options, numeric_args): + global logging_setup + if logging_setup: return logging.getLogger() + logger = logging.getLogger() + logger.handlers = [] # under certain cases, a spurious stream handler is set. We don't know why + logger.setLevel(logging.INFO) + stderr = logging.StreamHandler(sys.stderr) + stderr.setFormatter(logging.Formatter('%(levelname)s: %(message)s')) + if not options.quiet: + logger.addHandler(stderr) + else: + logger.addHandler(NullLogHandler()) # prevent default + if options.log_file: + setup_file_logger(options.log_file, options.debug) + if options.debug: + logger.setLevel(logging.DEBUG) + else: + stderr.setLevel(logging.WARNING) + if options.verbose: + stderr.setLevel(logging.INFO) + logging_setup = True + return logger + +def setup_file_logger(log_file, debug): + logger = logging.getLogger() + file = logging.FileHandler(log_file) + logformatter = logging.Formatter("%(asctime)s %(levelname)s: %(message)s", "%Y-%m-%d %H:%M") + file.setFormatter(logformatter) + logger.addHandler(file) + if not debug: + file.setLevel(logging.INFO) + return file + +def make_base_args(options, **grab): + """Takes parsed options, and breaks them back into a command + line string that we can pass into a subcommand""" + args = [] + grab["debug"] = "--debug" + grab["verbose"] = "--verbose" + grab["quiet"] = "--quiet" + #grab["log_db"] = "--log-db" + for k,flag in grab.items(): + value = getattr(options, k) + if not value: continue + args.append(flag) + if type(value) is not bool: + args.append(str(value)) + return args + +def security_check_homedir(location): + """ + Performs a check against a directory to determine if current + directory's owner has a home directory that is a parent directory. + This protects against malicious mountpoints, and is roughly equivalent + to the suexec checks. + """ + # XXX: this is a smidge unfriendly to systems who haven't setup + # nswitch. + try: + uid = util.get_dir_uid(location) + real = os.path.realpath(location) + if not real.startswith(pwd.getpwuid(uid).pw_dir + "/"): + logging.error("Security check failed, owner of deployment and " + "owner of home directory mismatch for %s" % location) + return False + except KeyError: + logging.error("Security check failed, could not look up " + "owner of %s (uid %d)" % (location, uid)) + return False + except OSError as e: + logging.error("OSError: %s" % str(e)) + return False + return True + +def calculate_log_name(log_dir, i): + """ + Calculates a log entry given a numeric identifier, and + directory under operation. + """ + return os.path.join(log_dir, "%04d.log" % i) + +def create_logdir(log_dir): + """ + Creates a log directory and chmods it 777 to enable de-priviledged + processes to create files. + """ + try: + os.mkdir(log_dir) + except OSError as e: + if e.errno != errno.EEXIST: + raise + #if create_subdirs: + # log_dir = os.path.join(log_dir, str(int(time.time()))) + # os.mkdir(log_dir) # if fails, be fatal + # # XXX: update last symlink + os.chmod(log_dir, 0o777) + +class NullLogHandler(logging.Handler): + """Log handler that doesn't do anything""" + def emit(self, record): + pass + +class WizardOptionParser(optparse.OptionParser): + """Configures some default user-level options""" + store_help = False + def __init__(self, *args, **kwargs): + kwargs["add_help_option"] = False + if "store_help" in kwargs: + self.store_help = kwargs["store_help"] + del kwargs["store_help"] + optparse.OptionParser.__init__(self, *args, **kwargs) + def parse_all(self, *args, **kwargs): + if self.store_help: + self.add_option("-h", "--help", action="store_true", default=False, dest="help", help=optparse.SUPPRESS_HELP) + else: + self.add_option("-h", "--help", action="help", help=optparse.SUPPRESS_HELP) + group = optparse.OptionGroup(self, "Common Options") + group.add_option("-v", "--verbose", dest="verbose", action="store_true", + default=util.boolish(os.getenv("WIZARD_VERBOSE")), help="Turns on verbose output. Envvar is WIZARD_VERBOSE") + group.add_option("--debug", dest="debug", action="store_true", + default=util.boolish(os.getenv("WIZARD_DEBUG")), help="Turns on debugging output. Envvar is WIZARD_DEBUG") + group.add_option("-q", "--quiet", dest="quiet", action="store_true", + default=util.boolish(os.getenv("WIZARD_QUIET")), help="Turns off output to stdout. Envvar is WIZARD_QUIET") + group.add_option("--log-file", dest="log_file", metavar="FILE", + default=os.getenv("WIZARD_LOGFILE"), help="Logs verbose output to file") + group.add_option("--directory", dest="directory", metavar="PATH", + default=os.getenv("WIZARD_DIRECTORY", ".wizard"), help="Initialize this folder to store metadata.") + self.add_option_group(group) + options, numeric_args = self.parse_args(*args, **kwargs) + setup_logger(options, numeric_args) + debug = options.debug + # we're going to process the global --log-dir/--seen dependency here + if hasattr(options, "seen") and hasattr(options, "log_dir"): + if not options.seen and options.log_dir: + options.seen = os.path.join(options.log_dir, "seen.txt") + return options, numeric_args + +class OptionBaton(object): + """Command classes may define options that they sub-commands may + use. Since wizard --global-command subcommand is not a supported + mode of operation, these options have to be passed down the command + chain until a option parser is ready to take it; this baton is + what is passed down.""" + def __init__(self): + self.store = {} + def add(self, *args, **kwargs): + key = kwargs["dest"] # require this to be set + self.store[key] = optparse.make_option(*args, **kwargs) + def push(self, option_parser, *args): + """Hands off parameters to option parser""" + for key in args: + option_parser.add_option(self.store[key]) + +class Error(wizard.Error): + """Base error class for all command errors""" + pass