parser: Unify fetching declarations and implement template lookaside

[people/stevee/pakfire.git] / src / libpakfire / build.c

/*#############################################################################
#                                                                             #
# Pakfire - The IPFire package management system                              #
# Copyright (C) 2021 Pakfire development team                                 #
#                                                                             #
# This program is free software: you can redistribute it and/or modify        #
# it under the terms of the GNU General Public License as published by        #
# the Free Software Foundation, either version 3 of the License, or           #
# (at your option) any later version.                                         #
#                                                                             #
# This program is distributed in the hope that it will be useful,             #
# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
# GNU General Public License for more details.                                #
#                                                                             #
# You should have received a copy of the GNU General Public License           #
# along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
#                                                                             #
#############################################################################*/

#include <errno.h>
#include <stdlib.h>

#include <pakfire/build.h>
#include <pakfire/execute.h>
#include <pakfire/dist.h>
#include <pakfire/logging.h>
#include <pakfire/parser.h>
#include <pakfire/private.h>
#include <pakfire/types.h>
#include <pakfire/util.h>

static const char* stages[] = {
	"prepare",
	"build",
	"test",
	"install",
	NULL,
};

#define TEMPLATE \
	"#!/bin/bash --login\n" \
	"\n" \
	"set -e\n" \
	"set -x\n" \
	"\n" \
	"%%{_%s}\n" \
	"\n" \
	"exit 0\n"

static int pakfire_build_package(Pakfire pakfire, PakfireParser makefile, const char* handle) {
	int r = 1;

	// Expand the handle into the package name
	char* name = pakfire_parser_expand(makefile, "packages", handle);
	if (!name) {
		ERROR(pakfire, "Could not get package name: %s\n", strerror(errno));
		goto ERROR;
	}

	INFO(pakfire, "Building package '%s'...\n", name);

	// XXX actually do all the work

	// Success
	r = 0;

ERROR:
	if (name)
		free(name);

	return r;
}

static int pakfire_build_packages(Pakfire pakfire, PakfireParser makefile) {
	DEBUG(pakfire, "Creating packages...");
	int r = 1;

	// Fetch a list all all packages
	char** packages = pakfire_parser_list_namespaces(makefile, "packages.package:*");
	if (!packages) {
		ERROR(pakfire, "Could not find any packages: %s\n", strerror(errno));
		goto ERROR;
	}

	unsigned int num_packages = 0;

	// Count how many packages we have
	for (char** package = packages; *package; package++)
		num_packages++;

	DEBUG(pakfire, "Found %d package(s)\n", num_packages);

	// Build packages in reverse order
	for (int i = num_packages - 1; i >= 0; i--) {
		r = pakfire_build_package(pakfire, makefile,
			packages[i] + strlen("packages.package:"));
		if (r)
			goto ERROR;
	}

	// Success
	r = 0;

ERROR:
	if (packages)
		free(packages);

	return r;
}

static int pakfire_build_stage(Pakfire pakfire, PakfireParser makefile, const char* stage,
		pakfire_execute_logging_callback logging_callback, void* data) {
	char template[1024];

	// Prepare template for this stage
	int r = pakfire_string_format(template, TEMPLATE, stage);
	if (r < 0)
		return r;

	// Create the build script
	char* script = pakfire_parser_expand(makefile, "build", template);
	if (!script) {
		ERROR(pakfire, "Could not generate the build script for stage '%s': %s\n",
			stage, strerror(errno));
		goto ERROR;
	}

	INFO(pakfire, "Running build stage '%s'\n", stage);

	r = pakfire_execute_script(pakfire, script, strlen(script), NULL, 0,
		logging_callback, data);
	if (r) {
		ERROR(pakfire, "Build stage '%s' failed with status %d\n", stage, r);
	}

ERROR:
	if (script)
		free(script);

	return r;
}

PAKFIRE_EXPORT int pakfire_build(Pakfire pakfire, const char* path,
		const char* target, int flags,
		pakfire_execute_logging_callback logging_callback, void* data) {
	PakfireParser makefile = NULL;
	struct pakfire_parser_error* error = NULL;

	// Read makefile
	int r = pakfire_read_makefile(&makefile, pakfire, path, &error);
	if (r) {
		if (error) {
			ERROR(pakfire, "Could not parse makefile %s: %s\n", path,
				pakfire_parser_error_get_message(error));
			pakfire_parser_error_unref(error);
		} else {
			ERROR(pakfire, "Could not parse makefile %s: %s\n", path,
				strerror(errno));
		}

		goto ERROR;
	}

	// Run through all build stages
	for (const char** stage = stages; *stage; stage++) {
		int r = pakfire_build_stage(pakfire, makefile, *stage, logging_callback, data);
		if (r) {
			// Drop to a shell for debugging
			if (flags & PAKFIRE_BUILD_INTERACTIVE)
				pakfire_shell(pakfire);

			goto ERROR;
		}
	}

	// Create the packages
	r = pakfire_build_packages(pakfire, makefile);
	if (r) {
		ERROR(pakfire, "Could not create packages: %s\n", strerror(errno));
		goto ERROR;
	}

ERROR:
	if (makefile)
		pakfire_parser_unref(makefile);

	return r;
}

PAKFIRE_EXPORT int pakfire_shell(Pakfire pakfire) {
	const char* argv[] = {
		"/bin/bash", "--login", NULL,
	};

	const int flags =
		PAKFIRE_EXECUTE_INTERACTIVE | PAKFIRE_EXECUTE_ENABLE_NETWORK;

	return pakfire_execute(pakfire, argv, NULL, flags, NULL, NULL);
}