12 from wizard import util
15 debug = True # This will get overwritten with the real value early on
19 Parse the contents of an environment variable as a boolean.
20 This recognizes more values as ``False`` than :func:`bool` would.
31 except (ValueError, TypeError):
32 if val == "No" or val == "no" or val == "false" or val == "False":
36 def setup_logger(options, numeric_args):
38 if logging_setup: return logging.getLogger()
39 logger = logging.getLogger()
40 logger.handlers = [] # under certain cases, a spurious stream handler is set. We don't know why
41 logger.setLevel(logging.INFO)
42 stderr = logging.StreamHandler(sys.stderr)
43 stderr.setFormatter(logging.Formatter('%(levelname)s: %(message)s'))
45 logger.addHandler(stderr)
47 logger.addHandler(NullLogHandler()) # prevent default
49 setup_file_logger(options.log_file, options.debug)
51 logger.setLevel(logging.DEBUG)
53 stderr.setLevel(logging.WARNING)
55 stderr.setLevel(logging.INFO)
59 def setup_file_logger(log_file, debug):
60 logger = logging.getLogger()
61 file = logging.FileHandler(log_file)
62 logformatter = logging.Formatter("%(asctime)s %(levelname)s: %(message)s", "%Y-%m-%d %H:%M")
63 file.setFormatter(logformatter)
64 logger.addHandler(file)
66 file.setLevel(logging.INFO)
69 def make_base_args(options, **grab):
70 """Takes parsed options, and breaks them back into a command
71 line string that we can pass into a subcommand"""
73 grab["debug"] = "--debug"
74 grab["verbose"] = "--verbose"
75 grab["quiet"] = "--quiet"
76 #grab["log_db"] = "--log-db"
77 for k,flag in grab.items():
78 value = getattr(options, k)
79 if not value: continue
81 if type(value) is not bool:
82 args.append(str(value))
85 def security_check_homedir(location):
87 Performs a check against a directory to determine if current
88 directory's owner has a home directory that is a parent directory.
89 This protects against malicious mountpoints, and is roughly equivalent
93 uid = util.get_dir_uid(location)
94 real = os.path.realpath(location)
95 if not real.startswith(pwd.getpwuid(uid).pw_dir + "/"):
96 logging.error("Security check failed, owner of deployment and "
97 "owner of home directory mismatch for %s" % location)
100 logging.error("Security check failed, could not look up "
101 "owner of %s (uid %d)" % (location, uid))
104 logging.error("OSError: %s" % str(e))
108 def calculate_log_name(log_dir, i):
110 Calculates a log entry given a numeric identifier, and
111 directory under operation.
113 return os.path.join(log_dir, "%04d.log" % i)
115 def create_logdir(log_dir):
117 Creates a log directory and chmods it 777 to enable de-priviledged
118 processes to create files.
123 if e.errno != errno.EEXIST:
126 # log_dir = os.path.join(log_dir, str(int(time.time())))
127 # os.mkdir(log_dir) # if fails, be fatal
128 # # XXX: update last symlink
129 os.chmod(log_dir, 0o777)
131 class Report(object):
132 #: Set of indices that should be skipped
134 #: Dict of append names to counts. You should manually increment these as necessary
136 #: Number of successes
138 #: Names of the files objects
140 def __init__(self, names, fobjs, skip, fails):
145 for name, fobj in zip(names, fobjs):
146 setattr(self, name, fobj)
149 getattr(self, n).flush()
151 def report_files(log_dir, names):
152 return [os.path.join(os.path.join(log_dir, "%s.txt" % x)) for x in names]
154 def read_reports(log_dir, names):
156 Reads a number of reports files. The return value is a :class:`Report`
157 object with attributes that are open file objects that correspond to ``names``.
159 return Report(names, [(os.path.exists(f) and open(f, "r") or cStringIO.StringIO()) for f in report_files(log_dir, names)], set(), {})
161 def open_reports(log_dir, names=('warnings', 'errors'), redo=False, append_names=()):
163 Returns a :class:`Report` object configured appropriately for the
164 parameters passed. This object has attributes names + append_names which
165 contain file objects opened as "w". ``names`` report files are cleared unconditionally
166 when they are opened (i.e. are not preserved from run to run.) ``append_names``
167 report files are not cleared unless ``redo`` is True, and persist over
168 runs: assuming the convention that [0001] is the index of the deployment,
169 the ``skip`` attribute on the returned report object contains indexes that
175 rr = read_reports(log_dir, append_names)
176 def build_set(skip, fails, name, fobj):
177 lines = fobj.read().strip().splitlines()
178 skip |= set(int(l[1:5]) for l in lines)
179 fails[name] = len(lines)
181 for name in append_names:
182 build_set(skip, fails, name, getattr(rr, name))
184 names += append_names
185 for name in append_names:
188 files = report_files(log_dir, names)
189 append_files = report_files(log_dir, append_names)
191 old_reports = os.path.join(log_dir, "old-reports")
192 rundir = os.path.join(old_reports, "run")
193 if not os.path.exists(old_reports):
194 os.mkdir(old_reports)
196 util.safe_unlink(rundir)
198 if os.path.exists(f):
200 for f in append_files:
201 if os.path.exists(f):
202 shutil.copy(f, rundir)
203 return Report(names + append_names, [open(f, "w") for f in files] + [open(f, "a") for f in append_files], skip, fails)
205 class NullLogHandler(logging.Handler):
206 """Log handler that doesn't do anything"""
207 def emit(self, record):
210 class WizardOptionParser(optparse.OptionParser):
211 """Configures some default user-level options"""
213 def __init__(self, *args, **kwargs):
214 kwargs["add_help_option"] = False
215 if "store_help" in kwargs:
216 self.store_help = kwargs["store_help"]
217 del kwargs["store_help"]
218 optparse.OptionParser.__init__(self, *args, **kwargs)
219 def parse_all(self, *args, **kwargs):
221 self.add_option("-h", "--help", action="store_true", default=False, dest="help", help=optparse.SUPPRESS_HELP)
223 self.add_option("-h", "--help", action="help", help=optparse.SUPPRESS_HELP)
224 group = optparse.OptionGroup(self, "Common Options")
225 group.add_option("-v", "--verbose", dest="verbose", action="store_true",
226 default=boolish(os.getenv("WIZARD_VERBOSE")), help="Turns on verbose output. Envvar is WIZARD_VERBOSE")
227 group.add_option("--debug", dest="debug", action="store_true",
228 default=boolish(os.getenv("WIZARD_DEBUG")), help="Turns on debugging output. Envvar is WIZARD_DEBUG")
229 group.add_option("-q", "--quiet", dest="quiet", action="store_true",
230 default=boolish(os.getenv("WIZARD_QUIET")), help="Turns off output to stdout. Envvar is WIZARD_QUIET")
231 group.add_option("--log-file", dest="log_file", metavar="FILE",
232 default=None, help="Logs verbose output to file")
233 self.add_option_group(group)
234 options, numeric_args = self.parse_args(*args, **kwargs)
235 setup_logger(options, numeric_args)
236 debug = options.debug
237 # we're going to process the global --log-dir/--seen dependency here
238 if hasattr(options, "seen") and hasattr(options, "log_dir"):
239 if not options.seen and options.log_dir:
240 options.seen = os.path.join(options.log_dir, "seen.txt")
241 return options, numeric_args
243 class OptionBaton(object):
244 """Command classes may define options that they sub-commands may
245 use. Since wizard --global-command subcommand is not a supported
246 mode of operation, these options have to be passed down the command
247 chain until a option parser is ready to take it; this baton is
248 what is passed down."""
251 def add(self, *args, **kwargs):
252 key = kwargs["dest"] # require this to be set
253 self.store[key] = optparse.make_option(*args, **kwargs)
254 def push(self, option_parser, *args):
255 """Hands off parameters to option parser"""
257 option_parser.add_option(self.store[key])
259 class Error(wizard.Error):
260 """Base error class for all command errors"""