def stage_package(self): logger.debugln("class: {} package name {} ".format( type(self).__name__, self.name)) util.clear_directory(self.package_stage_include_dir_path) util.rm_file("{}/libcrypto.a".format(self.stage_lib_dir_path)) util.rm_file("{}/libssl.a".format(self.stage_lib_dir_path)) sys_desc = platform.platform() if re.search('Linux', sys_desc) is not None \ and re.search('x86_64', sys_desc) is not None: arch_arg = "linux-x86_64" elif re.search('Darwin', sys_desc) is not None: arch_arg = "darwin64-x86_64-cc" else: raise RuntimeError( "could not determine platform type for openssl build options - platform is: {}" .format(sys_desc)) exec.run( [ "./Configure", "--prefix={}".format(self.cfg_obj.stage_dir), "--openssldir={}".format(self.vendor_ssl_dir), "--debug", arch_arg, # "linux-x86_64" # "darwin64-x86_64-cc" ], self.package_clone_dir_versioned_path) exec.run(["make", "all"], self.package_clone_dir_versioned_path) exec.run(["make", "install"], self.package_clone_dir_versioned_path)
def stage_package(self): logger.debugln("class: {} package name {} ".format( type(self).__name__, self.name)) self.stage_headers_only_from_repo( repo_name="json", stage_name="json", repo_sub_directory="single_include/nlohmann")
def __init__(self, package_name, cfg_obj: cfg.ConfigObject): logger.debugln("class: {} package name {} ".format("SourcePackage", package_name)); super().__init__(package_name, cfg_obj) self.stage_external_src_dir_path = os.path.join(self.cfg_obj.stage_dir, "external_src") self.package_stage_external_src_dir_path = os.path.join(self.stage_external_src_dir_path, self.package_name) self.package_external_src_dir_path = os.path.join(self.cfg_obj.source_dir, "external_src", self.package_name) self.project_external_src_dir_path = self.cfg_obj.external_dir
def __init__(self, package_name, cfg_obj: cfg.ConfigObject): logger.debugln("class: {} package name {} ".format("PackageBase", package_name)); self.parms = cfg_obj.package_parms(package_name) if not hasattr(self.parms, 'version'): raise ValueError("package name {} does not specify a version ".format(package_name)) self.version_in_configfile = self.parms.version self.version = self.version_in_configfile self.cfg_obj = cfg_obj self.package_name = package_name # these will be set by the package specific derived class self.release = None self.git_url = None self.package_url = None # this nmay not be correct package "name" versus "package_name" is a bit of a mess self.package_clone_dir_path = os.path.join(cfg_obj.clone_dir, package_name) # straight redundant data self.stage_include_dir_path = cfg_obj.stage_include_dir self.stage_lib_dir_path = cfg_obj.stage_lib_dir self.vendor_include_dir_path = cfg_obj.vendor_include_dir self.vendor_lib_dir_path = cfg_obj.vendor_lib_dir self.package_stage_include_dir_path = os.path.join(self.stage_include_dir_path, package_name) self.package_vendor_include_dir_path = os.path.join(self.vendor_include_dir_path, package_name) util.mkdir_p(self.cfg_obj.clone_dir) util.mkdir_p(self.cfg_obj.stage_include_dir) util.mkdir_p(self.cfg_obj.stage_lib_dir) util.mkdir_p(self.cfg_obj.stage_src_dir) util.mkdir_p(self.cfg_obj.vendor_dir) util.mkdir_p(self.vendor_include_dir_path) util.mkdir_p(self.vendor_lib_dir_path)
def list_package(self) -> str: logger.debugln("class: {} package name {} ".format("PackageBase", self.package_name)); return "{:21} release: {:11} version: {:11} url: {}".format( self.package_name[0:19], self.release[0:9] if self.release is not None else "", self.version[0:9], self.git_url if self.git_url is not None else self.package_url)
def stage_package(self): logger.debugln("class: {} package name {} ".format(type(self).__name__, self.name)); logger.writeln("Boost stage_package begin") util.mkdir_p(self.stage_include_dir_path) # make sure stage/include/boost exists and is empty util.mkdir_p(self.package_stage_include_dir_path) util.rm_directory_contents(self.package_stage_include_dir_path) util.mkdir_p(self.stage_lib_dir_path) exec.run(["rm", "-rf", "{}/libboost*".format(self.stage_lib_dir_path)], None) exec.run([ "./bootstrap.sh", "--with-python=/usr/bin/python3", #this MUST be the system location not a venv location "--prefix={}".format(self.cfg_obj.stage_dir), "darwin64-x86_64-cc" ], self.clone_dir_path) exec.run([ "./b2", "install", "--link=static", "--threading=multi", "--variant=debug", "--layout=system", ], self.clone_dir_path) logger.writeln("Boost stage_package end")
def dispatch_all(subcmd, cfg_obj): logger.debugln("package_name: {} subcmd: {}".format("all", subcmd)) if subcmd == "clean": clean.clean_install_dirs(cfg_obj) else: for pkg in cfg_obj.dependencies: parms = cfg_obj.dependencies[pkg] dispatch_package(pkg, subcmd, parms, cfg_obj)
def build_in_clone(self): logger.debugln("class: {} package name {} ".format( type(self).__name__, self.name)) # this package require the source and headers to be generated exec.run(["npm", "install"], self.package_clone_dir_path) exec.run(["make", "release"], self.package_clone_dir_path) # exec.run(["make", "install"], self.package_clone_dir_versioned_path) pass
def exec_cmd(cmd, where: Union[str, None]) -> None: """ Does the hard work of executing commands, optionally in the given directory with the reporting global reporting option. On failure of the command it quits the program """ logger.debugln(" cmd: {} where: {} dry_run: {}".format(",".join(cmd), where, options.dry_run)) if options.dry_run: return if where is None: where = os.getcwd() try: stderr_output = "unassigned" if options.reporting_option == REPORTING_OPT_STDOUT_STDERR: result = subprocess.run(cmd, cwd = where) retcode = result.returncode elif options.reporting_option == REPORTING_OPT_STDOUT_ONLY: result = subprocess.run(cmd, cwd = where, stderr=subprocess.PIPE) retcode = result.returncode stderr_output = result.stderr elif options.reporting_option == REPORTING_OPT_STDERR_ONLY: result = subprocess.run(cmd, cwd = where, stdout=subprocess.PIPE) retcode = result.returncode stderr_output = result.stderr elif options.reporting_option == REPORTING_OPT_STDERR_STDOUT_PROGRESS: count = 0 result = subprocess.Popen(cmd, cwd = where, stdout=subprocess.PIPE, stderr=subprocess.PIPE) while result.poll() is None: if count == 0: sys.stdout.write("\n") stdoutline = result.stdout.readline() sys.stdout.write("X") count = (count + 1) % 50 flush = result.stdout.read() sys.stdout.write("YY\n") # sys.stdout.write("\n") result.stdout.close() # print("result.stdout closed") retcode = result.returncode stderr_output = result.stderr else: result = subprocess.run(cmd, cwd = where, stdout=subprocess.PIPE, stderr=subprocess.PIPE) retcode = result.returncode stderr_output = result.stderr if retcode > 0: sys.stderr.write("ERROR cmd: {} return code {}\n".format(", ".join(cmd), retcode)) sys.stderr.write("stderr {}\n".format(stderr_output)) raise RuntimeError("bad return code") except Exception as exception: sys.stderr.write("Cmd was {}\n".format(", ".join(cmd))) sys.stderr.write( "An error occurred while running command [{}] error type: {}\n".format(", ".join(cmd), type(exception).__name__)) sys.stderr.write("Details: \n{}\n".format(str(exception))) quit()
def get_and_unpack_tar(self, tar_url, tar_file_name, tar_unpacked_name): logger.debugln("class: {} package name {} ".format("PackageBase", self.package_name)); package_clone_dir = os.path.join(self.cfg_obj.clone_dir, tar_unpacked_name) util.rm_directory(package_clone_dir) tar_file_path = os.path.join(self.cfg_obj.clone_dir, tar_file_name) util.rm_file(tar_file_path) # exec.run(["wget", "-O", tar_file_path, tar_url]) util.wget(tar_url, tar_file_path) util.unpack_tar_gz(tar_file_path, self.cfg_obj.clone_dir) util.list_directory(self.cfg_obj.clone_dir)
def headers_from_stage_to_vendor(self, stage_name, vendor_name): """ Empties vendor/include/vendor_name and then Copies header files from stage/include/stage_name to vendor/include/vendor_name """ logger.debugln("class: {} package name {} ".format("PackageBase", self.package_name)); from_dir = os.path.join(self.stage_include_dir_path, stage_name) to_dir = os.path.join(self.vendor_include_dir_path, vendor_name) util.clear_directory(to_dir) util.cp_directory_contents(from_dir, to_dir)
def stage_headers_only_from_repo(self, repo_name, stage_name, repo_sub_directory=None): logger.debugln("class: {} package name {} ".format("PackageBase", self.package_name)); to_dir = os.path.join(self.stage_include_dir_path, stage_name) if repo_sub_directory is None: from_dir = os.path.join(self.cfg_obj.clone_dir, repo_name) else: from_dir = os.path.join(self.cfg_obj.clone_dir, repo_name, repo_sub_directory) util.clear_directory(to_dir) util.cp_directory_contents(from_dir, to_dir) util.list_directory(to_dir)
def __init__(self, name: str, parms: PackageParms, cfg_obj: ConfigObject): logger.debugln("class: {} package name {} ".format( type(self).__name__, name)) super().__init__(name, cfg_obj) self.name = name self.parms = parms self.release = "v2.2.0" self.git_url = "https://github.com/nodejs/llhttp" self.package_clone_dir_path = os.path.join(self.cfg_obj.clone_dir, "llhttp")
def __init__(self, name, parms: PackageParms, cfg_obj: ConfigObject): logger.debugln("class: {} package name {} ".format(type(self).__name__, name)); super().__init__(name, cfg_obj) self.name = name self.parms = parms if parms.version not in supported_version: raise ValueError("version {} not supported".format(parms.version)) self.release = parms.version self.git_url = "https://github.com/robertblackwell/trog.git" self.git_branch_arg = self.release self.package_clone_dir_path = os.path.join(self.cfg_obj.clone_dir, "trog") self.package_clone_dir_source_path = os.path.join(self.package_clone_dir_path, "trog")
def libs_from_stage_to_vendor(self, lib_pattern): """ Removes all files matching lib_pattern from vendor/lib and then copies lib files matching lib_patterm from from stage/lib to vendor/lib """ logger.debugln("class: {} package name {} ".format("PackageBase", self.package_name)); from_dir = self.stage_lib_dir_path to_dir = self.vendor_lib_dir_path util.rm_directory_contents(to_dir, lib_pattern) util.cp_directory_files(from_dir, to_dir, lib_pattern) util.list_directory(to_dir)
def stage_source(self, repo_name, stage_name, repo_sub_directory=None, clear_to_dir=True): logger.debugln("class: {} package name {} ".format("PackageBase", self.package_name)); to_dir = os.path.join(self.stage_external_src_dir_path, stage_name) if repo_sub_directory is None: from_dir = os.path.join(self.cfg_obj.clone_dir, repo_name) else: from_dir = os.path.join(self.cfg_obj.clone_dir, repo_name, repo_sub_directory) print("SourcePackage package build/stage: {} from_dir {} to_dir {} " .format(self.package_name, from_dir, to_dir)) if clear_to_dir: util.clear_directory(to_dir) util.cp_directory_contents(from_dir, to_dir) util.list_directory(to_dir)
def __init__(self, name, parms: PackageParms, cfg_obj: ConfigObject): logger.debugln("class: {} package name {} ".format( type(self).__name__, name)) super().__init__(name, cfg_obj) self.name = name self.parms = parms self.release = "" self.git_url = "https://github.com/robertblackwell/cxxurl.git" self.package_clone_dir_path = os.path.join(self.cfg_obj.clone_dir, "cxxurl") self.package_clone_dir_source_path = os.path.join( self.package_clone_dir_path, "cxxurl") self.package_stage_source_path = os.path.join( self.package_stage_external_src_dir_path, "cxxurl")
def install_stage_to_project(self, stage_name, source_name, clear_to_dir=True): """ Empties project_source/external_src/source_name and then Copies header+source files from stage/external/stage_name to project_sourcer/external_src/source_name """ logger.debugln("class: {} package name {} ".format("PackageBase", self.package_name)); from_dir = os.path.join(self.stage_external_src_dir_path, stage_name) to_dir = os.path.join(self.project_external_src_dir_path, source_name) print("SourcePackage package: {} from_dir {} to_dir {} " .format(self.package_name, from_dir, to_dir)) if clear_to_dir: util.clear_directory(to_dir) util.cp_directory_contents(from_dir, to_dir) util.list_directory(to_dir)
def __init__(self, name, parms: PackageParms, cfg_obj: ConfigObject): logger.debugln("class: {} package name {} ".format( type(self).__name__, name)) super().__init__(name, cfg_obj) self.name = name self.parms = parms self.release = "v0.1.0" self.git_url = "https://github.com/robertblackwell/x509_certificate_library.git" self.package_clone_dir_path = os.path.join(self.cfg_obj.clone_dir, "x509_certificate_library") self.git_branch_arg = self.release self.package_stage_include_dir_path = os.path.join( self.cfg_obj.stage_dir, "include", "cert") self.package_vendor_include_dir_path = os.path.join( self.cfg_obj.vendor_dir, "include", "cert") self.cmake_dir = os.path.join(self.package_clone_dir_path, "cmake-build-debug")
def dispatch_package(package_name: str, subcmd: str, parms: Any, cfg_obj: configuration.ConfigObject) -> None: logger.debugln("package_name: {} subcmd: {}".format(package_name, subcmd)) h = package_handler(package_name, parms, cfg_obj) if subcmd == "all": h.get_package() h.stage_package() h.install_package() elif subcmd == "download": h.get_package() elif subcmd == "build": h.stage_package() elif subcmd == "install": h.install_package() elif subcmd == "list": print(h.list_package()) pass
def __init__(self, name: str, parms: PackageParms, cfg_obj: ConfigObject): logger.debugln("class: {} package name {} ".format( type(self).__name__, name)) super().__init__(name, cfg_obj) self.name = name # the name of the directory that the cloned repo will unpack into self.package_clone_dir_path = os.path.join(self.cfg_obj.clone_dir, "doctest") self.parms = parms # the release must match a repo tag self.release = "2.3.7" self.git_url = "https://github.com/onqtam/doctest.git" self.git_branch_arg = "{}".format(self.release) # the dir in the repo from where we copy headers self.cp_from_here_dir = os.path.join(self.package_clone_dir_path, "doctest")
def __init__(self, name, parms: PackageParms, cfg_obj: ConfigObject): logger.debugln("class: {} package name {} ".format( type(self).__name__, name)) super().__init__(package_name, cfg_obj) self.name = name self.parms = parms self.release = "1.1.1f" self.package_url = "https://www.openssl.org/source/{}.tar.gz".format( openssl_name) self.package_targz_file_path = os.path.join(self.cfg_obj.clone_dir, package_targz_file) self.wget_output_path = self.cfg_obj.clone_dir self.package_targz_file_path = os.path.join(self.cfg_obj.clone_dir, package_targz_file) self.vendor_ssl_dir = os.path.join(self.cfg_obj.vendor_dir, "ssl") self.package_clone_dir_versioned_path = os.path.join( self.cfg_obj.clone_dir, "openssl-1.1.1f")
def __init__(self, name, parms: PackageParms, cfg_obj: ConfigObject): logger.debugln("class: {} package name {} ".format( type(self).__name__, name)) super().__init__(name, cfg_obj) self.name = name self.package_clone_dir_path = os.path.join(self.cfg_obj.clone_dir, "json") self.parms = parms self.release = "v3.7.3" self.git_url = "https://github.com/nlohmann/json.git" self.git_branch_arg = self.release self.single_include_dir = os.path.join(self.package_clone_dir_path, "single_include", "nlohmann") self.package_clone_dir_path = os.path.join(self.cfg_obj.clone_dir, "json") self.package_stage_include_dir_path = os.path.join( self.cfg_obj.stage_dir, "include", "json") self.package_vendor_include_dir_path = os.path.join( self.cfg_obj.vendor_dir, "include", "json")
def __init__(self, name, parms: PackageParms, cfg_obj: ConfigObject): logger.debugln("class: {} package name {} ".format(type(self).__name__, name)); super().__init__(name, cfg_obj) if parms.version not in supported_versions: v = ", ".join(supported_versions.keys()) raise ValueError( "config file specifies boost version {} can only install version {}".format(parms.version, v)) vers = parms.version self.name = name self.parms = parms self.release = vers self.package_url = supported_versions[vers]['url'] self.targz = supported_versions[vers]['targz'] self.repo_name = supported_versions[vers]['repo_name'] self.package_targz_file_path = os.path.join(self.cfg_obj.clone_dir, self.targz) self.wget_output_path = os.path.join(self.cfg_obj.clone_dir, self.targz) self.package_targz_file_path = os.path.join(self.cfg_obj.clone_dir, self.targz) self.clone_dir_path = os.path.join(self.cfg_obj.clone_dir, self.repo_name)
def __init__(self, name, parms: PackageParms, cfg_obj: ConfigObject): package_name = name logger.debugln("class: {} package name {} ".format( type(self).__name__, name)) parms.repo_name = "Catch2" parms.repo_branch_argument = "v2.11.1" parms.stage_name = "catch2" parms.vendor_name = "catch2" parms.repo_sub_directory = "single_include/catch2" super().__init__(package_name, cfg_obj) self.name = name self.package_clone_dir_path = os.path.join(self.cfg_obj.clone_dir, "Catch2") self.parms = parms self.release = "v2.12.1" self.git_url = "https://github.com/catchorg/Catch2.git" self.git_branch_arg = self.release self.single_include_dir = os.path.join(self.package_clone_dir_path, "single_include")
def stage_package(self): logger.debugln("class: {} package name {} ".format( type(self).__name__, self.name)) util.mkdir_p(self.stage_include_dir_path) util.mkdir_p(self.stage_lib_dir_path) util.clear_directory(self.package_stage_include_dir_path) util.rm_directory_contents(self.stage_lib_dir_path, "libcert.*") # exec.run(["rm", "-rf", "{}/libcert*".format(self.stage_lib_dir_path)]) self.cmake_dir = os.path.join(self.package_clone_dir_path, "cmake-build-debug") util.clear_directory(self.cmake_dir) exec.run([ "cmake", "-DVENDOR_DIR={}".format(self.cfg_obj.stage_dir), "-DSTAGE_DIR={}".format(self.cfg_obj.stage_dir), ".." ], self.cmake_dir) exec.run(["make", "-j30", "cert_library"], self.cmake_dir) exec.run(["cmake", "--build", ".", "--target", "install", "-j", "8"], self.cmake_dir) # just installed the headers into stage/include/cert logger.writeln("CertLib stage_package end")
def get_package(self): logger.debugln("class: {} package name {} ".format( type(self).__name__, self.name)) self.get_git_repo(self.git_url, "x509_certificate_library", self.git_branch_arg)
def get_git_repo(self, repo_url: str, repo_name: str, branch_argument=None): logger.debugln("class: {} package name {} ".format("PackageBase", self.package_name)); package_clone_dir = os.path.join(self.cfg_obj.clone_dir, repo_name) util.rm_directory(package_clone_dir) util.git_clone(self.git_url, self.cfg_obj.clone_dir, branch_argument) util.list_directory(package_clone_dir)
def install_package(self): logger.debugln("class: {} package name {} ".format( type(self).__name__, self.name)) self.headers_from_stage_to_vendor("cert", "cert") self.libs_from_stage_to_vendor("libcert.*")
def __init__(self, package_name, cfg_obj: cfg.ConfigObject): logger.debugln("class: {} package name {} ".format("HeaderOnlyPackage", package_name)); super().__init__(package_name, cfg_obj)