def build(self, context, variant, build_path, install_path, install=False, build_type=BuildType.local): # communicate args to bez by placing in a file doc = dict(source_path=self.working_dir, build_path=build_path, install_path=install_path, build_args=self.build_args) ret = {} content = dump_yaml(doc) bezfile = os.path.join(build_path, ".bez.yaml") with open(bezfile, 'w') as f: f.write(content + '\n') if self.write_build_scripts: # write out the script that places the user in a build env, where # they can run bez directly themselves. build_env_script = os.path.join(build_path, "build-env") create_forwarding_script(build_env_script, module=("build_system", "bez"), func_name="_FWD__spawn_build_shell", working_dir=self.working_dir, build_path=build_path, variant_index=variant.index, install=install, install_path=install_path) ret["success"] = True ret["build_env_script"] = build_env_script return ret # run bez in the build environment cmd = ["bez"] if install and "install" not in cmd: cmd.append("install") callback = functools.partial(self._add_build_actions, context=context, package=self.package, variant=variant, build_type=build_type, install=install, build_path=build_path, install_path=install_path) retcode, _, _ = context.execute_shell(command=cmd, block=True, cwd=build_path, post_actions_callback=callback) ret["success"] = (not retcode) return ret
def build(self, context, variant, build_path, install_path, install=False, build_type=BuildType.local): """Perform the build. Note that most of the func args aren't used here - that's because this info is already passed to the custom build command via environment variables. """ ret = {} if self.write_build_scripts: # write out the script that places the user in a build env build_env_script = os.path.join(build_path, "build-env") create_forwarding_script(build_env_script, module=("build_system", "custom"), func_name="_FWD__spawn_build_shell", working_dir=self.working_dir, build_path=build_path, variant_index=variant.index, install=install, install_path=install_path) ret["success"] = True ret["build_env_script"] = build_env_script return ret # get build command command = self.package.build_command # False just means no build command if command is False: ret["success"] = True return ret def expand(txt): return txt.format(build_path=build_path, install="install" if install else '', install_path=install_path, name=self.package.name, root=self.package.root, variant_index=variant.index if variant.index is not None else '', version=self.package.version).strip() if isinstance(command, basestring): if self.build_args: command = command + ' ' + ' '.join(map(quote, self.build_args)) command = expand(command) cmd_str = command else: # list command = command + self.build_args command = list(map(expand, command)) cmd_str = ' '.join(map(quote, command)) if self.verbose: pr = Printer(sys.stdout) pr("Running build command: %s" % cmd_str, heading) # run the build command def _callback(executor): self._add_build_actions(executor, context=context, package=self.package, variant=variant, build_type=build_type, install=install, build_path=build_path, install_path=install_path) if self.opts: # write args defined in ./parse_build_args.py out as env vars extra_args = getattr(self.opts.parser, "_rezbuild_extra_args", []) for key, value in list(vars(self.opts).items()): if key in extra_args: varname = "__PARSE_ARG_%s" % key.upper() # do some value conversions if isinstance(value, bool): value = 1 if value else 0 elif isinstance(value, (list, tuple)): value = list(map(str, value)) value = list(map(quote, value)) value = ' '.join(value) executor.env[varname] = value retcode, _, _ = context.execute_shell(command=command, block=True, cwd=build_path, post_actions_callback=_callback) ret["success"] = (not retcode) return ret
def save(self, path, verbose=False): """Save the suite to disk. Args: path (str): Path to save the suite to. If a suite is already saved at `path`, then it will be overwritten. Otherwise, if `path` exists, an error is raised. verbose (bool): Show more messages. """ if verbose and self._is_live: print("saving live suite...") # todo: # 1. instead of wiping it all out, cherry-pick tools to update/remove # by requests. # 2. make a copy of current suite (in timestamp dir) path = os.path.realpath(path) if os.path.exists(path): if self.load_path and self.load_path == path: if verbose: print("saving over previous suite...") for context_name in self.context_names: self.context(context_name) # load before dir deleted forceful_rmtree(path) else: raise SuiteError("Cannot save, path exists: %r" % path) os.makedirs(path) # write suite data data = self.to_dict() filepath = os.path.join(path, "suite.yaml") with open(filepath, "w") as f: f.write(dump_yaml(data)) # write contexts for context_name in self.context_names: context = self.context(context_name) context._set_parent_suite(path, context_name) # noqa self._save_context_rxt(context_name, context, path) # create alias wrappers tools_path = os.path.join(path, "bin") os.makedirs(tools_path) if verbose: print("creating alias wrappers in %r..." % tools_path) tools = self.get_tools() for tool_alias, d in tools.items(): tool_name = d["tool_name"] context_name = d["context_name"] data = self._context(context_name) prefix_char = data.get("prefix_char") if verbose: print("creating %r -> %r (%s context)..." % (tool_alias, tool_name, context_name)) filepath = os.path.join(tools_path, tool_alias) if self._is_live: context = data["context"] requests = [str(r) for r in context.requested_packages()] kwargs = { "module": ("command", "sweet"), # rez plugin "func_name": "_FWD__invoke_suite_tool_alias_in_live", "package_requests": requests, "context_name": context_name, "tool_name": tool_name, "prefix_char": prefix_char, } else: kwargs = { "module": "suite", "func_name": "_FWD__invoke_suite_tool_alias", "context_name": context_name, "tool_name": tool_name, "prefix_char": prefix_char, } create_forwarding_script(filepath, **kwargs)
def save(self, path, verbose=False): """Save the suite to disk. Args: path (str): Path to save the suite to. If a suite is already saved at `path`, then it will be overwritten. Otherwise, if `path` exists, an error is raised. """ path = os.path.realpath(path) if os.path.exists(path): if self.load_path and self.load_path == path: if verbose: print("saving over previous suite...") for context_name in self.context_names: self.context(context_name) # load before dir deleted shutil.rmtree(path) else: raise SuiteError("Cannot save, path exists: %r" % path) contexts_path = os.path.join(path, "contexts") os.makedirs(contexts_path) # write suite data data = self.to_dict() filepath = os.path.join(path, "suite.yaml") with open(filepath, "w") as f: f.write(dump_yaml(data)) # write contexts for context_name in self.context_names: context = self.context(context_name) context._set_parent_suite(path, context_name) filepath = self._context_path(context_name, path) if verbose: print("writing %r..." % filepath) context.save(filepath) # create alias wrappers tools_path = os.path.join(path, "bin") os.makedirs(tools_path) if verbose: print("creating alias wrappers in %r..." % tools_path) tools = self.get_tools() for tool_alias, d in tools.items(): tool_name = d["tool_name"] context_name = d["context_name"] data = self._context(context_name) prefix_char = data.get("prefix_char") re_resolve = data["re_resolve"] if verbose: print("creating %r -> %r (%s context)..." % (tool_alias, tool_name, context_name)) filepath = os.path.join(tools_path, tool_alias) create_forwarding_script(filepath, module="suite", func_name="_FWD__invoke_suite_tool_alias", context_name=context_name, tool_name=tool_name, re_resolve=re_resolve, prefix_char=prefix_char)
def build(self, context, variant, build_path, install_path, install=False, build_type=BuildType.local): def _pr(s): if self.verbose: print(s) # find cmake binary if self.settings.cmake_binary: exe = self.settings.cmake_binary else: exe = context.which("cmake", fallback=True) if not exe: raise RezCMakeError("could not find cmake binary") found_exe = which(exe) if not found_exe: raise RezCMakeError("cmake binary does not exist: %s" % exe) sh = create_shell() # assemble cmake command cmd = [found_exe] # cmd.append("-d") # see https://github.com/nerdvegas/rez/issues/1055 cmd.append(self.working_dir) cmd += (self.settings.cmake_args or []) cmd += (self.build_args or []) cmd.append("-DCMAKE_INSTALL_PREFIX=%s" % install_path) cmd.append("-DCMAKE_MODULE_PATH=%s" % sh.get_key_token("CMAKE_MODULE_PATH").replace('\\', '/')) cmd.append("-DCMAKE_BUILD_TYPE=%s" % self.build_target) cmd.append("-DREZ_BUILD_TYPE=%s" % build_type.name) cmd.append("-DREZ_BUILD_INSTALL=%d" % (1 if install else 0)) cmd.extend(["-G", self.build_systems[self.cmake_build_system]]) if config.rez_1_cmake_variables and \ not config.disable_rez_1_compatibility and \ build_type == BuildType.central: cmd.append("-DCENTRAL=1") # execute cmake within the build env _pr("Executing: %s" % ' '.join(cmd)) if not os.path.abspath(build_path): build_path = os.path.join(self.working_dir, build_path) build_path = os.path.realpath(build_path) callback = functools.partial(self._add_build_actions, context=context, package=self.package, variant=variant, build_type=build_type, install=install, build_path=build_path, install_path=install_path) # run the build command and capture/print stderr at the same time retcode, _, _ = context.execute_shell(command=cmd, block=True, cwd=build_path, post_actions_callback=callback) ret = {} if retcode: ret["success"] = False return ret if self.write_build_scripts: # write out the script that places the user in a build env, where # they can run make directly themselves. build_env_script = os.path.join(build_path, "build-env") create_forwarding_script(build_env_script, module=("build_system", "cmake"), func_name="_FWD__spawn_build_shell", working_dir=self.working_dir, build_path=build_path, variant_index=variant.index, install=install, install_path=install_path) ret["success"] = True ret["build_env_script"] = build_env_script return ret # assemble make command make_binary = self.settings.make_binary if not make_binary: if self.cmake_build_system == "mingw": make_binary = "mingw32-make" elif self.cmake_build_system == "nmake": make_binary = "nmake" elif self.cmake_build_system == "ninja": make_binary = "ninja" else: make_binary = "make" cmd = [make_binary] + (self.child_build_args or []) # nmake has no -j if make_binary != "nmake": if not any(x.startswith("-j") for x in (self.child_build_args or [])): n = variant.config.build_thread_count cmd.append("-j%d" % n) # execute make within the build env _pr("\nExecuting: %s" % ' '.join(cmd)) retcode, _, _ = context.execute_shell(command=cmd, block=True, cwd=build_path, post_actions_callback=callback) if not retcode and install and "install" not in cmd: cmd.append("install") # execute make install within the build env _pr("\nExecuting: %s" % ' '.join(cmd)) retcode, _, _ = context.execute_shell(command=cmd, block=True, cwd=build_path, post_actions_callback=callback) ret["success"] = (not retcode) return ret