static int
bz_pacman__package__is_needed(void *user_data, bool *is_needed)
{
struct bz_env *env = user_data;
const char *package_name;
bool force = false;
rip_check(package_name = bz_env_get_string(env, "name", true));
rie_check(force = bz_env_get_bool(env, "force", true));
if (force) {
*is_needed = true;
clog_info("(%s) Force creation of binary package",
package_name);
return 0;
} else {
struct cork_path *package_file;
rip_check(package_file = bz_env_get_path
(env, "pacman.package_file", true));
clog_info("(%s) Check whether binary package %s exists",
package_name, cork_path_get(package_file));
rii_check(bz_file_exists(cork_path_get(package_file), is_needed));
*is_needed = !*is_needed;
return 0;
}
}
static int
bz_autotools__stage(void *user_data)
{
struct bz_env *env = user_data;
const char *package_name;
struct cork_path *build_dir;
struct cork_path *staging_dir;
bool verbose;
struct cork_env *exec_env;
struct cork_exec *exec;
rii_check(bz_stage_message(env, "autotools"));
rip_check(package_name = bz_env_get_string(env, "name", true));
clog_info("(%s) Stage using autotools", package_name);
rip_check(build_dir = bz_env_get_path(env, "build_dir", true));
rip_check(staging_dir = bz_env_get_path(env, "staging_dir", true));
rie_check(verbose = bz_env_get_bool(env, "verbose", true));
/* Create the staging path */
rii_check(bz_create_directory(cork_path_get(staging_dir), 0750));
/* $ make install */
exec = cork_exec_new("make");
cork_exec_add_param(exec, "make");
cork_exec_add_param(exec, "install");
cork_exec_set_cwd(exec, cork_path_get(build_dir));
exec_env = cork_env_clone_current();
cork_env_add(exec_env, "DESTDIR", cork_path_get(staging_dir));
cork_exec_set_env(exec, exec_env);
return bz_subprocess_run_exec(verbose, NULL, exec);
}
static void
bz_git_make_slug(struct cork_buffer *dest, const char *url, const char *commit)
{
struct cork_path *path;
cork_hash hash;
/* First grab the basename of the URL. */
path = cork_path_new(url);
cork_path_set_basename(path);
cork_buffer_append_string(dest, cork_path_get(path));
cork_path_free(path);
/* Then remove any trailing ".git" extension. */
if (dest->size >= 4) {
const char *extension = &cork_buffer_char(dest, dest->size - 4);
if (strcmp(extension, ".git") == 0) {
cork_buffer_truncate(dest, dest->size - 4);
}
}
/* Then calculate the hash of the full URL and commit, and append that to
* ensure we have a unique slug. */
hash = 0x48f2a642; /* hash of "git" */
hash = cork_stable_hash_buffer(hash, url, strlen(url));
hash = cork_stable_hash_buffer(hash, commit, strlen(commit));
cork_buffer_append_printf(dest, "-%08" PRIx32, hash);
}
static int
bz_pacman_add_install_scripts(struct bz_env *env,
struct cork_buffer *pkgbuild_buf)
{
struct cork_buffer install_buf = CORK_BUFFER_INIT();
/* Copy each kind of script into install_buf, if present. */
rii_check(bz_pacman_add_install_script
(env, &install_buf, "pre_install_script", "pre_install"));
rii_check(bz_pacman_add_install_script
(env, &install_buf, "post_install_script", "post_install"));
rii_check(bz_pacman_add_install_script
(env, &install_buf, "pre_remove_script", "pre_remove"));
rii_check(bz_pacman_add_install_script
(env, &install_buf, "post_remove_script", "post_remove"));
/* If any of them added content to the install script, save that to a file
* and reference it in the PKGBUILD. */
if (install_buf.size > 0) {
struct cork_path *install;
const char *install_base;
rip_check(install = bz_env_get_path(env, "pacman.install", true));
rip_check(install_base =
bz_env_get_string(env, "pacman.install_base", true));
rii_check(bz_create_file(cork_path_get(install), &install_buf, 0640));
cork_buffer_append_printf(pkgbuild_buf, "install=%s\n", install_base);
}
cork_buffer_done(&install_buf);
return 0;
}
static void
print_path(const char *prefix, struct cork_path *path)
{
rp_check_exit(path);
printf("%s %s\n", prefix, cork_path_get(path));
cork_path_free(path);
}
static int
bz_pacman__install(void *user_data)
{
struct bz_env *env = user_data;
const char *package_name;
struct cork_path *package_file;
rii_check(bz_install_message(env, "pacman"));
rip_check(package_name = bz_env_get_string(env, "name", true));
rip_check(package_file = bz_env_get_path(env, "pacman.package_file", true));
clog_info("(%s) Install %s using pacman",
package_name, cork_path_get(package_file));
return bz_subprocess_run
(false, NULL,
"sudo", "pacman", "-U", "--noconfirm", cork_path_get(package_file),
NULL);
}
static void
pwd_run(int argc, char **argv)
{
struct cork_path *path;
rp_check_exit(path = cork_path_cwd());
printf("%s\n", cork_path_get(path));
cork_path_free(path);
exit(EXIT_SUCCESS);
}
static int
bz_pacman_add_install_script(struct bz_env *env, struct cork_buffer *buf,
const char *var_name, const char *func_name)
{
struct cork_path *install_script;
rie_check(install_script = bz_env_get_path(env, var_name, false));
if (install_script != NULL) {
cork_buffer_append_printf(buf, "%s () {\n", func_name);
rii_check(bz_load_file(cork_path_get(install_script), buf));
cork_buffer_append_string(buf, "\n}\n");
}
return 0;
}
static void
find_run(int argc, char **argv)
{
struct cork_path_list *list;
if (argc < 1) {
cork_command_show_help(&find, "Missing file");
exit(EXIT_FAILURE);
} else if (argc < 2) {
cork_command_show_help(&find, "Missing path");
exit(EXIT_FAILURE);
} else if (argc < 2) {
cork_command_show_help(&find, "Too many parameters");
exit(EXIT_FAILURE);
}
list = cork_path_list_new(argv[1]);
if (find_all) {
struct cork_file_list *file_list;
size_t i;
size_t count;
rp_check_exit(file_list = cork_path_list_find_files(list, argv[0]));
count = cork_file_list_size(file_list);
for (i = 0; i < count; i++) {
struct cork_file *file = cork_file_list_get(file_list, i);
printf("%s\n", cork_path_get(cork_file_path(file)));
}
cork_file_list_free(file_list);
} else {
struct cork_file *file;
rp_check_exit(file = cork_path_list_find_file(list, argv[0]));
printf("%s\n", cork_path_get(cork_file_path(file)));
cork_file_free(file);
}
cork_path_list_free(list);
exit(EXIT_SUCCESS);
}
struct bz_repo *
bz_git_repo_new(const char *url, const char *commit)
{
struct bz_git_repo *repo;
struct bz_env *repo_env;
struct cork_path *base_dir;
repo = cork_new(struct bz_git_repo);
cork_buffer_init(&repo->slug);
repo->url = cork_strdup(url);
repo->commit = cork_strdup(commit);
bz_git_make_slug(&repo->slug, url, commit);
repo_env = bz_repo_env_new_empty();
bz_env_add_override
(repo_env, "repo.git.url", bz_string_value_new(url));
bz_env_add_override
(repo_env, "repo.git.commit", bz_string_value_new(commit));
bz_env_add_override
(repo_env, "repo.name",
bz_interpolated_value_new("${repo.git.url} (${repo.git.commit})"));
bz_env_add_override
(repo_env, "repo.slug", bz_string_value_new(repo->slug.buf));
bz_env_add_override
(repo_env, "repo.base_dir",
bz_interpolated_value_new("${repo_dir}/${repo.slug}"));
bz_env_add_override
(repo_env, "package_slug",
bz_interpolated_value_new("${name}-${repo.slug}"));
repo->repo = bz_repo_new
(repo_env, repo, bz_git__free,
bz_git__load,
bz_git__update);
ep_check(base_dir = bz_env_get_path(repo_env, "repo.base_dir", true));
bz_env_set_base_path(repo_env, cork_path_get(base_dir));
return repo->repo;
error:
bz_repo_free(repo->repo);
return NULL;
}
END_TEST
static void
test_unavailable(struct bz_env *env)
{
struct cork_path *source_dir = cork_path_new("/home/test/source");
struct bz_pdb *pdb;
struct bz_builder *builder;
fail_if_error(pdb = bz_arch_native_pdb());
bz_pdb_register(pdb);
bz_mock_file_exists(cork_path_get(source_dir), true);
bz_env_add_override(env, "source_dir", bz_path_value_new(source_dir));
bz_env_add_override(env, "verbose", bz_string_value_new("0"));
fail_if_error(builder = bz_cmake_builder_new(env));
fail_unless_error(bz_builder_stage(builder));
bz_builder_free(builder);
}
static void
test_stage_package(struct bz_env *env, bool force,
const char *expected_actions)
{
struct cork_path *source_dir = cork_path_new("/home/test/source");
struct bz_pdb *pdb;
struct bz_builder *builder;
fail_if_error(pdb = bz_arch_native_pdb());
bz_pdb_register(pdb);
bz_mock_file_exists(cork_path_get(source_dir), true);
bz_env_add_override(env, "source_dir", bz_path_value_new(source_dir));
bz_env_add_override(env, "force", bz_string_value_new(force? "1": "0"));
bz_env_add_override(env, "verbose", bz_string_value_new("0"));
fail_if_error(builder = bz_cmake_builder_new(env));
fail_if_error(bz_builder_stage(builder));
test_actions(expected_actions);
bz_builder_free(builder);
}
static int
bz_autotools__test(void *user_data)
{
struct bz_env *env = user_data;
const char *package_name;
struct cork_path *build_dir;
bool verbose;
struct cork_exec *exec;
rii_check(bz_test_message(env, "autotools"));
/* $ make check */
rip_check(package_name = bz_env_get_string(env, "name", true));
clog_info("(%s) Test using autotools", package_name);
rip_check(build_dir = bz_env_get_path(env, "build_dir", true));
rie_check(verbose = bz_env_get_bool(env, "verbose", true));
exec = cork_exec_new("make");
cork_exec_add_param(exec, "make");
cork_exec_add_param(exec, "check");
cork_exec_set_cwd(exec, cork_path_get(build_dir));
return bz_subprocess_run_exec(verbose, NULL, exec);
}
static void
test_create_package(struct bz_env *env, bool force,
const char *expected_actions)
{
struct cork_path *binary_package_dir = cork_path_new(".");
struct cork_path *staging_dir = cork_path_new("/tmp/staging");
struct bz_pdb *pdb;
struct bz_packager *packager;
fail_if_error(pdb = bz_apt_native_pdb());
bz_pdb_register(pdb);
mock_deb_arch("amd64");
bz_mock_file_exists(cork_path_get(staging_dir), true);
bz_env_add_override(env, "binary_package_dir",
bz_path_value_new(binary_package_dir));
bz_env_add_override(env, "staging_dir", bz_path_value_new(staging_dir));
bz_env_add_override(env, "force", bz_string_value_new(force? "1": "0"));
bz_env_add_override(env, "verbose", bz_string_value_new("0"));
fail_if_error(packager = bz_deb_packager_new(env));
fail_if_error(bz_packager_package(packager));
test_actions(expected_actions);
bz_packager_free(packager);
}
static int
bz_autotools__build(void *user_data)
{
struct bz_env *env = user_data;
struct bz_value *ctx = bz_env_as_value(env);
const char *package_name;
struct cork_path *build_dir;
struct cork_path *source_dir;
struct cork_path *configure;
struct bz_value *configure_args;
const char *pkgconfig_path;
bool exists;
bool verbose;
struct cork_exec *exec;
struct cork_env *exec_env;
struct cork_buffer buf = CORK_BUFFER_INIT();
rii_check(bz_install_dependency_string("autoconf", ctx));
rii_check(bz_install_dependency_string("automake", ctx));
rii_check(bz_build_message(env, "autotools"));
rip_check(package_name = bz_env_get_string(env, "name", true));
rip_check(build_dir = bz_env_get_path(env, "build_dir", true));
rip_check(source_dir = bz_env_get_path(env, "source_dir", true));
rip_check(configure =
bz_env_get_path(env, "autotools.configure.configure", true));
rie_check(pkgconfig_path = bz_env_get_string(env, "pkgconfig.path", false));
rie_check(verbose = bz_env_get_bool(env, "verbose", true));
/* Create the build path */
rii_check(bz_create_directory(cork_path_get(build_dir), 0750));
clog_info("(%s) Configure using autotools", package_name);
/* $ autoreconf -i */
rii_check(bz_file_exists(cork_path_get(configure), &exists));
if (!exists) {
exec = cork_exec_new("autoreconf");
cork_exec_add_param(exec, "autoreconf");
cork_exec_add_param(exec, "-i");
cork_exec_set_cwd(exec, cork_path_get(source_dir));
ei_check(bz_subprocess_run_exec(verbose, NULL, exec));
}
#define add_dir(buzzy_name, param_name) \
do { \
struct cork_path *value; \
ep_check(value = bz_env_get_path(env, buzzy_name, true)); \
cork_buffer_printf(&buf, "--" param_name "=%s", cork_path_get(value)); \
cork_exec_add_param(exec, buf.buf); \
} while (0)
/* $ ./configure ... */
exec = cork_exec_new(cork_path_get(configure));
exec_env = cork_env_clone_current();
cork_exec_set_env(exec, exec_env);
cork_exec_add_param(exec, cork_path_get(configure));
add_dir("prefix", "prefix");
add_dir("exec_prefix", "exec-prefix");
add_dir("bin_dir", "bindir");
add_dir("sbin_dir", "sbindir");
add_dir("lib_dir", "libdir");
add_dir("libexec_dir", "libexecdir");
add_dir("share_dir", "datadir");
add_dir("man_dir", "mandir");
/* Add custom configure arguments, if given. */
configure_args = bz_env_get_value(env, "autotools.configure.args");
if (configure_args != NULL) {
struct bz_configure_add_arg state = { exec, env };
switch (bz_value_kind(configure_args)) {
case BZ_VALUE_SCALAR:
ei_check(bz_configure_add_arg(&state, configure_args));
break;
case BZ_VALUE_ARRAY:
ei_check(bz_array_value_map
(configure_args, &state, bz_configure_add_arg));
break;
case BZ_VALUE_MAP:
bz_bad_config("autotools.configure.args cannot be a map");
goto error;
default:
cork_unreachable();
}
}
cork_exec_set_cwd(exec, cork_path_get(build_dir));
if (pkgconfig_path != NULL) {
cork_env_add(exec_env, "PKG_CONFIG_PATH", pkgconfig_path);
}
ei_check(bz_subprocess_run_exec(verbose, NULL, exec));
/* $ make */
clog_info("(%s) Build using autotools", package_name);
exec = cork_exec_new("make");
cork_exec_add_param(exec, "make");
cork_exec_set_cwd(exec, cork_path_get(build_dir));
ei_check(bz_subprocess_run_exec(verbose, NULL, exec));
cork_buffer_done(&buf);
return 0;
error:
cork_buffer_done(&buf);
return -1;
}
static int
bz_pacman__package(void *user_data)
{
struct bz_env *env = user_data;
struct bz_value *ctx = bz_env_as_value(env);
struct cork_path *staging_dir;
struct cork_path *binary_package_dir;
struct cork_path *package_build_dir;
struct cork_path *pkgbuild;
struct cork_path *package_file;
const char *package_name;
const char *version;
const char *pkgrel;
const char *pkgext;
const char *architecture;
const char *license;
bool verbose;
struct cork_env *exec_env;
struct cork_exec *exec;
struct cork_buffer buf = CORK_BUFFER_INIT();
bool staging_exists;
rii_check(bz_install_dependency_string("pacman", ctx));
rii_check(bz_package_message(env, "pacman"));
rip_check(package_name = bz_env_get_string(env, "name", true));
clog_info("(%s) Package using pacman", package_name);
rip_check(staging_dir = bz_env_get_path(env, "staging_dir", true));
rip_check(binary_package_dir =
bz_env_get_path(env, "binary_package_dir", true));
rip_check(package_build_dir =
bz_env_get_path(env, "package_build_dir", true));
rip_check(pkgbuild = bz_env_get_path(env, "pacman.pkgbuild", true));
rip_check(package_file = bz_env_get_path(env, "pacman.package_file", true));
rip_check(version = bz_env_get_string(env, "pacman.version", true));
rip_check(pkgrel = bz_env_get_string(env, "pacman.pkgrel", true));
rip_check(pkgext = bz_env_get_string(env, "pacman.pkgext", true));
rip_check(architecture = bz_env_get_string(env, "pacman.arch", true));
rip_check(license = bz_env_get_string(env, "license", true));
rie_check(verbose = bz_env_get_bool(env, "verbose", true));
rii_check(bz_file_exists(cork_path_get(staging_dir), &staging_exists));
if (CORK_UNLIKELY(!staging_exists)) {
cork_error_set_printf
(ENOENT, "Staging directory %s does not exist",
cork_path_get(staging_dir));
return -1;
}
/* NOTE: pacman runs ldconfig automatically, so unlike the other packagers,
* we do NOT need to add an ldconfig call to the post-install and
* post-remove scripts. */
/* Create the temporary directory and the packaging destination */
rii_check(bz_create_directory(cork_path_get(package_build_dir), 0750));
rii_check(bz_create_directory(cork_path_get(binary_package_dir), 0750));
/* Create a PKGBUILD file for this package */
cork_buffer_append_printf(&buf, "pkgname='%s'\n", package_name);
cork_buffer_append_printf(&buf, "pkgver='%s'\n", version);
cork_buffer_append_printf(&buf, "pkgrel='%s'\n", pkgrel);
cork_buffer_append_printf(&buf, "arch=('%s')\n", architecture);
cork_buffer_append_printf(&buf, "license=('%s')\n", license);
rii_check(bz_pacman_fill_deps(env, &buf, "depends", "dependencies"));
cork_buffer_append_printf(&buf,
"package () {\n"
" rm -rf \"${pkgdir}\"\n"
" cp -a '%s' \"${pkgdir}\"\n"
"}\n",
cork_path_get(staging_dir)
);
/* Add pre- and post-install scripts, if necessary. */
rii_check(bz_pacman_add_install_scripts(env, &buf));
ei_check(bz_create_file(cork_path_get(pkgbuild), &buf, 0640));
cork_buffer_done(&buf);
exec_env = cork_env_clone_current();
cork_env_add(exec_env, "PKGDEST", cork_path_get(binary_package_dir));
cork_env_add(exec_env, "PKGEXT", pkgext);
exec = cork_exec_new_with_params("makepkg", "-sf", NULL);
cork_exec_set_cwd(exec, cork_path_get(package_build_dir));
cork_exec_set_env(exec, exec_env);
clog_info("(%s) Create %s using pacman",
package_name, cork_path_get(package_file));
return bz_subprocess_run_exec(verbose, NULL, exec);
error:
cork_buffer_done(&buf);
return -1;
}
