class ConfigureContext(object):
def __init__(self):
self.env = Environment()
self.tools = []
self._tool_modules = {}
self.builders = {}
self.cache = {}
self.conf_results = []
self._configured = {}
self._stdout_cache = {}
self._cmd_cache = {}
self.src_root = None
self.bld_root = None
self.path = None
def load_tool(self, tool, tooldir=None):
_t = import_tools([tool], tooldir)
self.tools.append({"tool": tool, "tooldir": tooldir})
mod = _t[tool]
self._tool_modules[tool] = mod
if hasattr(mod, "get_builder"):
self.builders[tool] = mod.get_builder(self)
return mod
def use_tools(self, tools, tooldir=None):
ret = {}
for t in tools:
if t in self._tool_modules:
_t = self._tool_modules[t]
else:
_t = self.load_tool(t, tooldir)
ret[t] = _t
self.setup_tools()
return ret
def setup_tools(self):
for builder in self.builders.values():
if not builder.configured:
builder.configure()
self._configured[builder] = True
def store(self):
default_env = self.bld_root.make_node(DEFAULT_ENV)
self.env.store(default_env.abspath())
self.log.close()
config_cache = self.bld_root.make_node(CONFIG_CACHE)
out = []
out.append(dumps(self.cache))
out.append(dumps(self._stdout_cache))
out.append(dumps(self._cmd_cache))
config_cache.write(join_bytes(out), flags="wb")
build_config = self.bld_root.make_node(BUILD_CONFIG)
build_config.write("%r\n" % self.tools)
hook_dump = self.bld_root.make_node(HOOK_DUMP)
s = dumps({"extensions": yaku.task_manager.RULES_REGISTRY,
"files": _hook_id_to_hook_path(yaku.task_manager.FILES_REGISTRY)})
hook_dump.write(s, flags="wb")
def start_message(self, msg):
_OUTPUT.write(msg + "... ")
self.log.write("=" * 79 + "\n")
self.log.write("%s\n" % msg)
def end_message(self, msg):
_OUTPUT.write("%s\n" % msg)
def fail_configuration(self, msg):
msg = "%s\nPlease look at the configuration log %r" % (msg, self.log.name)
self.log.flush()
raise ConfigurationFailure(msg)
def set_cmd_cache(self, task, cmd):
self._cmd_cache[task.get_uid()] = cmd[:]
def get_cmd(self, task):
tid = task.get_uid()
try:
return self._cmd_cache[tid]
except KeyError:
raise UnknownTask
def set_stdout_cache(self, task, stdout):
self._stdout_cache[task.get_uid()] = stdout
def get_stdout(self, task):
tid = task.get_uid()
try:
return self._stdout_cache[tid]
except KeyError:
raise UnknownTask
class ConfigureContext(object):
def __init__(self):
self.env = Environment()
self.tools = []
self._tool_modules = {}
self.builders = {}
self.cache = {}
self.conf_results = []
self._configured = {}
self._stdout_cache = {}
self._cmd_cache = {}
self.src_root = None
self.bld_root = None
self.path = None
def load_tool(self, tool, tooldir=None):
_t = import_tools([tool], tooldir)
self.tools.append({"tool": tool, "tooldir": tooldir})
mod = _t[tool]
self._tool_modules[tool] = mod
if hasattr(mod, "get_builder"):
self.builders[tool] = mod.get_builder(self)
return mod
def use_tools(self, tools, tooldir=None):
ret = {}
for t in tools:
if t in self._tool_modules:
_t = self._tool_modules[t]
else:
_t = self.load_tool(t, tooldir)
ret[t] = _t
self.setup_tools()
return ret
def setup_tools(self):
for builder in list(self.builders.values()):
if not builder.configured:
builder.configure()
self._configured[builder] = True
def store(self):
default_env = self.bld_root.make_node(DEFAULT_ENV)
self.env.store(default_env.abspath())
self.log.close()
config_cache = self.bld_root.make_node(CONFIG_CACHE)
out = []
out.append(dumps(self.cache))
out.append(dumps(self._stdout_cache))
out.append(dumps(self._cmd_cache))
config_cache.write(join_bytes(out), flags="wb")
build_config = self.bld_root.make_node(BUILD_CONFIG)
build_config.write("%r\n" % self.tools)
hook_dump = self.bld_root.make_node(HOOK_DUMP)
s = dumps({
"extensions":
yaku.task_manager.RULES_REGISTRY,
"files":
_hook_id_to_hook_path(yaku.task_manager.FILES_REGISTRY)
})
hook_dump.write(s, flags="wb")
def start_message(self, msg):
_OUTPUT.write(msg + "... ")
self.log.write("=" * 79 + "\n")
self.log.write("%s\n" % msg)
def end_message(self, msg):
_OUTPUT.write("%s\n" % msg)
def fail_configuration(self, msg):
msg = "%s\nPlease look at the configuration log %r" % (msg,
self.log.name)
self.log.flush()
raise ConfigurationFailure(msg)
def set_cmd_cache(self, task, cmd):
self._cmd_cache[task.get_uid()] = cmd[:]
def get_cmd(self, task):
tid = task.get_uid()
try:
return self._cmd_cache[tid]
except KeyError:
raise UnknownTask
def set_stdout_cache(self, task, stdout):
self._stdout_cache[task.get_uid()] = stdout
def get_stdout(self, task):
tid = task.get_uid()
try:
return self._stdout_cache[tid]
except KeyError:
raise UnknownTask
class ConfigureContext(object):
def __init__(self):
self.env = Environment()
self.tools = []
self._tool_modules = {}
self.builders = {}
self.cache = {}
self.conf_results = []
self._configured = {}
self._stdout_cache = {}
self._cmd_cache = {}
self.src_root = None
self.bld_root = None
self.path = None
def load_tool(self, tool, tooldir=None):
_t = import_tools([tool], tooldir)
self.tools.append({"tool": tool, "tooldir": tooldir})
mod = _t[tool]
self._tool_modules[tool] = mod
if hasattr(mod, "get_builder"):
self.builders[tool] = mod.get_builder(self)
return mod
def use_tools(self, tools, tooldir=None):
ret = {}
for t in tools:
if t in self._tool_modules:
_t = self._tool_modules[t]
else:
_t = self.load_tool(t, tooldir)
ret[t] = _t
self.setup_tools()
return ret
def setup_tools(self):
for builder in self.builders.values():
if not builder.configured:
builder.configure()
self._configured[builder] = True
def store(self):
default_env = self.bld_root.make_node(DEFAULT_ENV)
self.env.store(default_env.abspath())
self.log.close()
config_cache = self.bld_root.make_node(CONFIG_CACHE)
out = []
out.append(dumps(self.cache))
out.append(dumps(self._stdout_cache))
out.append(dumps(self._cmd_cache))
config_cache.write(join_bytes(out), flags="wb")
build_config = self.bld_root.make_node(BUILD_CONFIG)
build_config.write("%r\n" % self.tools)
hook_dump = self.bld_root.make_node(HOOK_DUMP)
s = dumps({
"extensions":
yaku.task_manager.RULES_REGISTRY,
"files":
_hook_id_to_hook_path(yaku.task_manager.FILES_REGISTRY)
})
hook_dump.write(s, flags="wb")
def start_message(self, msg):
_OUTPUT.write(msg + "... ")
self.log.write("=" * 79 + "\n")
self.log.write("%s\n" % msg)
def end_message(self, msg):
_OUTPUT.write("%s\n" % msg)
def fail_configuration(self, msg):
msg = "%s\nPlease look at the configuration log %r" % (msg,
self.log.name)
self.log.flush()
raise ConfigurationFailure(msg)
def set_cmd_cache(self, task, cmd):
self._cmd_cache[task.get_uid()] = cmd[:]
def get_cmd(self, task):
tid = task.get_uid()
try:
return self._cmd_cache[tid]
except KeyError:
raise UnknownTask
def set_stdout_cache(self, task, stdout):
self._stdout_cache[task.get_uid()] = stdout
def get_stdout(self, task):
tid = task.get_uid()
try:
return self._stdout_cache[tid]
except KeyError:
raise UnknownTask
def try_command(self, cmd, cwd=None, env=None, kw=None):
if cwd is None:
cwd = self.bld_root.abspath()
if kw is None:
kw = {}
if env is not None:
kw["env"] = env
def log_failure(succeed, explanation):
if succeed:
self.log.write("---> Succeeded !\n")
else:
self.log.write("---> Failure !\n")
self.log.write("~~~~~~~~~~~~~~\n")
self.log.write(explanation)
self.log.write("~~~~~~~~~~~~~~\n")
self.log.write("Command was:\n")
self.log.write("%s\n" % cmd)
self.log.write("\n")
try:
p = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
cwd=cwd,
**kw)
stdout = p.communicate()[0].decode("utf-8")
log_failure(p.returncode == 0, stdout)
if p.returncode:
return False
return True
except OSError:
e = get_exception()
log_failure(False, str(e))
except WindowsError:
e = get_exception()
log_failure(False, str(e))
return False
class ConfigureContext(object):
def __init__(self):
self.env = Environment()
self.tools = []
self._tool_modules = {}
self.builders = {}
self.cache = {}
self.conf_results = []
self._configured = {}
self._stdout_cache = {}
self._cmd_cache = {}
self.src_root = None
self.bld_root = None
self.path = None
def load_tool(self, tool, tooldir=None):
_t = import_tools([tool], tooldir)
self.tools.append({"tool": tool, "tooldir": tooldir})
mod = _t[tool]
self._tool_modules[tool] = mod
if hasattr(mod, "get_builder"):
self.builders[tool] = mod.get_builder(self)
return mod
def use_tools(self, tools, tooldir=None):
ret = {}
for t in tools:
if t in self._tool_modules:
_t = self._tool_modules[t]
else:
_t = self.load_tool(t, tooldir)
ret[t] = _t
self.setup_tools()
return ret
def setup_tools(self):
for builder in self.builders.values():
if not builder.configured:
builder.configure()
self._configured[builder] = True
def store(self):
default_env = self.bld_root.make_node(DEFAULT_ENV)
self.env.store(default_env.abspath())
self.log.close()
config_cache = self.bld_root.make_node(CONFIG_CACHE)
out = []
out.append(dumps(self.cache))
out.append(dumps(self._stdout_cache))
out.append(dumps(self._cmd_cache))
config_cache.write(join_bytes(out), flags="wb")
build_config = self.bld_root.make_node(BUILD_CONFIG)
build_config.write("%r\n" % self.tools)
hook_dump = self.bld_root.make_node(HOOK_DUMP)
s = dumps({"extensions": yaku.task_manager.RULES_REGISTRY,
"files": _hook_id_to_hook_path(yaku.task_manager.FILES_REGISTRY)})
hook_dump.write(s, flags="wb")
def start_message(self, msg):
_OUTPUT.write(msg + "... ")
self.log.write("=" * 79 + "\n")
self.log.write("%s\n" % msg)
def end_message(self, msg):
_OUTPUT.write("%s\n" % msg)
def fail_configuration(self, msg):
msg = "%s\nPlease look at the configuration log %r" % (msg, self.log.name)
self.log.flush()
raise ConfigurationFailure(msg)
def set_cmd_cache(self, task, cmd):
self._cmd_cache[task.get_uid()] = cmd[:]
def get_cmd(self, task):
tid = task.get_uid()
try:
return self._cmd_cache[tid]
except KeyError:
raise UnknownTask
def set_stdout_cache(self, task, stdout):
self._stdout_cache[task.get_uid()] = stdout
def get_stdout(self, task):
tid = task.get_uid()
try:
return self._stdout_cache[tid]
except KeyError:
raise UnknownTask
def try_command(self, cmd, cwd=None, env=None, kw=None):
if cwd is None:
cwd = self.bld_root.abspath()
if kw is None:
kw = {}
if env is not None:
kw["env"] = env
def log_failure(succeed, explanation):
if succeed:
self.log.write("---> Succeeded !\n")
else:
self.log.write("---> Failure !\n")
self.log.write("~~~~~~~~~~~~~~\n")
self.log.write(explanation)
self.log.write("~~~~~~~~~~~~~~\n")
self.log.write("Command was:\n")
self.log.write("%s\n" % cmd)
self.log.write("\n")
try:
p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT, cwd=cwd, **kw)
stdout = p.communicate()[0].decode("utf-8")
log_failure(p.returncode == 0, stdout)
if p.returncode:
return False
return True
except OSError:
e = get_exception()
log_failure(False, str(e))
except WindowsError:
e = get_exception()
log_failure(False, str(e))
return False
class ConfigureContext(object):
def __init__(self):
self.env = Environment()
self.tools = []
self._tool_modules = {}
self.builders = {}
self.cache = {}
self.conf_results = []
self._configured = {}
self._stdout_cache = {}
self._cmd_cache = {}
def load_tool(self, tool, tooldir=None):
_t = import_tools([tool], tooldir)
self.tools.append({"tool": tool, "tooldir": tooldir})
mod = _t[tool]
self._tool_modules[tool] = mod
if hasattr(mod, "get_builder"):
self.builders[tool] = mod.get_builder(self)
return mod
def use_tools(self, tools, tooldir=None):
ret = {}
for t in tools:
if t in self._tool_modules:
_t = self._tool_modules[t]
else:
_t = self.load_tool(t, tooldir)
ret[t] = _t
self.setup_tools()
return ret
def setup_tools(self):
for builder in self.builders.values():
if not builder.configured:
builder.configure()
self._configured[builder] = True
def store(self):
self.env.store(DEFAULT_ENV)
self.log.close()
fid = open(CONFIG_CACHE, "wb")
try:
dump(self.cache, fid)
dump(self._stdout_cache, fid)
dump(self._cmd_cache, fid)
finally:
fid.close()
fid = myopen(BUILD_CONFIG, "w")
try:
fid.write("%r\n" % self.tools)
finally:
fid.close()
fid = myopen(HOOK_DUMP, "wb")
try:
dump({"extensions": yaku.task_manager.RULES_REGISTRY,
"files": _hook_id_to_hook_path(yaku.task_manager.FILES_REGISTRY)},
fid)
finally:
fid.close()
def start_message(self, msg):
sys.stderr.write(msg + "... ")
self.log.write("=" * 79 + "\n")
self.log.write("%s\n" % msg)
def end_message(self, msg):
sys.stderr.write("%s\n" % msg)
def set_cmd_cache(self, task, cmd):
self._cmd_cache[task.get_uid()] = cmd[:]
def get_cmd(self, task):
tid = task.get_uid()
try:
return self._cmd_cache[tid]
except KeyError:
raise UnknownTask
def set_stdout_cache(self, task, stdout):
self._stdout_cache[task.get_uid()] = stdout
def get_stdout(self, task):
tid = task.get_uid()
try:
return self._stdout_cache[tid]
except KeyError:
raise UnknownTask
