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)
