forked from Mirrors/flatpak-builder
467 lines
16 KiB
C
467 lines
16 KiB
C
/*
|
|
* Copyright © 2014 Red Hat, Inc
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* Authors:
|
|
* Alexander Larsson <alexl@redhat.com>
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <locale.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
|
|
#include <glib/gi18n.h>
|
|
|
|
#include "libglnx/libglnx.h"
|
|
|
|
#include "flatpak-builtins.h"
|
|
#include "flatpak-builtins-utils.h"
|
|
#include "flatpak-utils.h"
|
|
|
|
static char *opt_arch;
|
|
static char *opt_var;
|
|
static char *opt_type;
|
|
static char *opt_sdk_dir;
|
|
static char **opt_sdk_extensions;
|
|
static char **opt_tags;
|
|
static char *opt_base;
|
|
static char *opt_base_version;
|
|
static char **opt_base_extensions;
|
|
static gboolean opt_writable_sdk;
|
|
static gboolean opt_update;
|
|
|
|
static GOptionEntry options[] = {
|
|
{ "arch", 0, 0, G_OPTION_ARG_STRING, &opt_arch, N_("Arch to use"), N_("ARCH") },
|
|
{ "var", 'v', 0, G_OPTION_ARG_STRING, &opt_var, N_("Initialize var from named runtime"), N_("RUNTIME") },
|
|
{ "base", 0, 0, G_OPTION_ARG_STRING, &opt_base, N_("Initialize apps from named app"), N_("APP") },
|
|
{ "base-version", 0, 0, G_OPTION_ARG_STRING, &opt_base_version, N_("Specify version for --base"), N_("VERSION") },
|
|
{ "base-extension", 0, 0, G_OPTION_ARG_STRING_ARRAY, &opt_base_extensions, N_("Include this base extension"), N_("EXTENSION") },
|
|
{ "writable-sdk", 'w', 0, G_OPTION_ARG_NONE, &opt_writable_sdk, N_("Initialize /usr with a writable copy of the sdk"), NULL },
|
|
{ "type", 0, 0, G_OPTION_ARG_STRING, &opt_type, N_("Specify the build type (app, runtime, extension)"), N_("TYPE") },
|
|
{ "tag", 0, 0, G_OPTION_ARG_STRING_ARRAY, &opt_tags, N_("Add a tag"), N_("TAG") },
|
|
{ "sdk-extension", 0, 0, G_OPTION_ARG_STRING_ARRAY, &opt_sdk_extensions, N_("Include this sdk extension in /usr"), N_("EXTENSION") },
|
|
{ "sdk-dir", 0, 0, G_OPTION_ARG_STRING, &opt_sdk_dir, N_("Where to store sdk (defaults to 'usr')"), N_("DIR") },
|
|
{ "update", 0, 0, G_OPTION_ARG_NONE, &opt_update, N_("Re-initialize the sdk/var"), NULL },
|
|
{ NULL }
|
|
};
|
|
|
|
static gboolean
|
|
copy_extensions (FlatpakDeploy *src_deploy, const char *default_branch,
|
|
char *src_extensions[], GFile *top_dir, GCancellable *cancellable, GError **error)
|
|
{
|
|
g_autoptr(GKeyFile) metakey = flatpak_deploy_get_metadata (src_deploy);
|
|
GList *extensions = NULL, *l;
|
|
int i;
|
|
|
|
/* We leak this on failure, as we have no autoptr for deep lists.. */
|
|
extensions = flatpak_list_extensions (metakey, opt_arch, default_branch);
|
|
|
|
for (i = 0; src_extensions[i] != NULL; i++)
|
|
{
|
|
const char *requested_extension = src_extensions[i];
|
|
gboolean found = FALSE;
|
|
|
|
for (l = extensions; l != NULL; l = l->next)
|
|
{
|
|
FlatpakExtension *ext = l->data;
|
|
|
|
if (strcmp (ext->installed_id, requested_extension) == 0 ||
|
|
strcmp (ext->id, requested_extension) == 0)
|
|
{
|
|
g_autoptr(GFile) target = g_file_resolve_relative_path (top_dir, ext->directory);
|
|
g_autoptr(GFile) target_parent = g_file_get_parent (target);
|
|
g_autoptr(GFile) ext_deploy_files = g_file_new_for_path (ext->files_path);
|
|
|
|
if (!ext->is_unmaintained)
|
|
{
|
|
g_autoptr(FlatpakDir) src_dir = NULL;
|
|
g_autoptr(GFile) deploy = NULL;
|
|
g_autoptr(GVariant) deploy_data = NULL;
|
|
const char **subpaths;
|
|
|
|
deploy = flatpak_find_deploy_dir_for_ref (ext->ref, &src_dir, cancellable, error);
|
|
if (deploy == NULL)
|
|
return FALSE;
|
|
deploy_data = flatpak_dir_get_deploy_data (src_dir, ext->ref, cancellable, error);
|
|
if (deploy_data == NULL)
|
|
return FALSE;
|
|
|
|
subpaths = flatpak_deploy_data_get_subpaths (deploy_data);
|
|
if (subpaths[0] != NULL)
|
|
return flatpak_fail (error, _("Requested extension %s is only partially installed"), ext->installed_id);
|
|
}
|
|
|
|
if (!flatpak_mkdir_p (target_parent, cancellable, error))
|
|
return FALSE;
|
|
|
|
/* An extension overrides whatever is there before, so we clean up first */
|
|
if (!flatpak_rm_rf (target, cancellable, error))
|
|
return FALSE;
|
|
|
|
if (!flatpak_cp_a (ext_deploy_files, target,
|
|
FLATPAK_CP_FLAGS_NO_CHOWN,
|
|
cancellable, error))
|
|
return FALSE;
|
|
|
|
found = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!found)
|
|
{
|
|
g_list_free_full (extensions, (GDestroyNotify) flatpak_extension_free);
|
|
return flatpak_fail (error, _("Requested extension %s not installed"), requested_extension);
|
|
}
|
|
}
|
|
|
|
g_list_free_full (extensions, (GDestroyNotify) flatpak_extension_free);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean
|
|
flatpak_builtin_build_init (int argc, char **argv, GCancellable *cancellable, GError **error)
|
|
{
|
|
g_autoptr(GOptionContext) context = NULL;
|
|
g_autoptr(GFile) var_deploy_files = NULL;
|
|
g_autoptr(GFile) base = NULL;
|
|
g_autoptr(GFile) files_dir = NULL;
|
|
g_autoptr(GFile) usr_dir = NULL;
|
|
g_autoptr(GFile) var_dir = NULL;
|
|
g_autoptr(GFile) var_tmp_dir = NULL;
|
|
g_autoptr(GFile) var_run_dir = NULL;
|
|
g_autoptr(GFile) metadata_file = NULL;
|
|
g_autoptr(GString) metadata_contents = NULL;
|
|
g_autoptr(GError) my_error = NULL;
|
|
const char *app_id;
|
|
const char *directory;
|
|
const char *sdk_pref;
|
|
const char *runtime_pref;
|
|
const char *default_branch = NULL;
|
|
g_autofree char *runtime_ref = NULL;
|
|
g_autofree char *var_ref = NULL;
|
|
g_autofree char *sdk_ref = NULL;
|
|
FlatpakKinds kinds;
|
|
int i;
|
|
g_autoptr(FlatpakDir) sdk_dir = NULL;
|
|
g_autoptr(FlatpakDir) runtime_dir = NULL;
|
|
gboolean is_app = FALSE;
|
|
gboolean is_extension = FALSE;
|
|
gboolean is_runtime = FALSE;
|
|
|
|
context = g_option_context_new (_("DIRECTORY APPNAME SDK RUNTIME [BRANCH] - Initialize a directory for building"));
|
|
g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
|
|
|
|
if (!flatpak_option_context_parse (context, options, &argc, &argv, FLATPAK_BUILTIN_FLAG_NO_DIR, NULL, cancellable, error))
|
|
return FALSE;
|
|
|
|
if (argc < 5)
|
|
return usage_error (context, _("RUNTIME must be specified"), error);
|
|
|
|
if (argc > 6)
|
|
return usage_error (context, _("Too many arguments"), error);
|
|
|
|
directory = argv[1];
|
|
app_id = argv[2];
|
|
sdk_pref = argv[3];
|
|
runtime_pref = argv[4];
|
|
if (argc >= 6)
|
|
default_branch = argv[5];
|
|
|
|
if (opt_type != NULL)
|
|
{
|
|
if (strcmp (opt_type, "app") == 0)
|
|
is_app = TRUE;
|
|
else if (strcmp (opt_type, "extension") == 0)
|
|
is_extension = TRUE;
|
|
else if (strcmp (opt_type, "runtime") == 0)
|
|
is_runtime = TRUE;
|
|
else
|
|
return flatpak_fail (error, _("'%s' is not a valid build type name, use app, runtime or extension"), opt_type);
|
|
}
|
|
else
|
|
is_app = TRUE;
|
|
|
|
if (!flatpak_is_valid_name (app_id, &my_error))
|
|
return flatpak_fail (error, _("'%s' is not a valid application name: %s"), app_id, my_error->message);
|
|
|
|
kinds = FLATPAK_KINDS_RUNTIME;
|
|
sdk_dir = flatpak_find_installed_pref (sdk_pref, kinds, opt_arch, default_branch, TRUE, FALSE, FALSE, NULL,
|
|
&sdk_ref, cancellable, error);
|
|
if (sdk_dir == NULL)
|
|
return FALSE;
|
|
|
|
kinds = FLATPAK_KINDS_RUNTIME;
|
|
if (is_extension)
|
|
kinds |= FLATPAK_KINDS_APP;
|
|
|
|
runtime_dir = flatpak_find_installed_pref (runtime_pref, kinds, opt_arch, default_branch, TRUE, FALSE, FALSE, NULL,
|
|
&runtime_ref, cancellable, error);
|
|
if (runtime_dir == NULL)
|
|
return FALSE;
|
|
|
|
base = g_file_new_for_commandline_arg (directory);
|
|
|
|
if (!flatpak_mkdir_p (base, cancellable, error))
|
|
return FALSE;
|
|
|
|
files_dir = g_file_get_child (base, "files");
|
|
if (opt_sdk_dir)
|
|
usr_dir = g_file_get_child (base, opt_sdk_dir);
|
|
else
|
|
usr_dir = g_file_get_child (base, "usr");
|
|
var_dir = g_file_get_child (base, "var");
|
|
var_tmp_dir = g_file_get_child (var_dir, "tmp");
|
|
var_run_dir = g_file_get_child (var_dir, "run");
|
|
metadata_file = g_file_get_child (base, "metadata");
|
|
|
|
if (!opt_update &&
|
|
g_file_query_exists (files_dir, cancellable))
|
|
return flatpak_fail (error, _("Build directory %s already initialized"), directory);
|
|
|
|
if (opt_writable_sdk || is_runtime)
|
|
{
|
|
g_autoptr(GFile) sdk_deploy_files = NULL;
|
|
g_autoptr(FlatpakDeploy) sdk_deploy = NULL;
|
|
|
|
sdk_deploy = flatpak_dir_load_deployed (sdk_dir, sdk_ref, NULL, cancellable, error);
|
|
if (sdk_deploy == NULL)
|
|
return FALSE;
|
|
|
|
if (!flatpak_rm_rf (usr_dir, NULL, &my_error))
|
|
{
|
|
if (!g_error_matches (my_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
|
|
{
|
|
g_propagate_error (error, g_steal_pointer (&my_error));
|
|
return FALSE;
|
|
}
|
|
|
|
g_clear_error (&my_error);
|
|
}
|
|
|
|
sdk_deploy_files = flatpak_deploy_get_files (sdk_deploy);
|
|
if (!flatpak_cp_a (sdk_deploy_files, usr_dir, FLATPAK_CP_FLAGS_NO_CHOWN, cancellable, error))
|
|
return FALSE;
|
|
|
|
if (opt_sdk_extensions &&
|
|
!copy_extensions (sdk_deploy, default_branch, opt_sdk_extensions, usr_dir, cancellable, error))
|
|
return FALSE;
|
|
}
|
|
|
|
if (opt_var)
|
|
{
|
|
var_ref = flatpak_build_runtime_ref (opt_var, default_branch, opt_arch);
|
|
|
|
var_deploy_files = flatpak_find_files_dir_for_ref (var_ref, cancellable, error);
|
|
if (var_deploy_files == NULL)
|
|
return FALSE;
|
|
}
|
|
|
|
if (opt_update)
|
|
return TRUE;
|
|
|
|
if (!g_file_make_directory (files_dir, cancellable, error))
|
|
return FALSE;
|
|
|
|
if (opt_base)
|
|
{
|
|
const char *base_branch;
|
|
g_autofree char *base_ref = NULL;
|
|
g_autoptr(GFile) base_deploy_files = NULL;
|
|
g_autoptr(FlatpakDeploy) base_deploy = NULL;
|
|
|
|
base_branch = opt_base_version ? opt_base_version : "master";
|
|
base_ref = flatpak_build_app_ref (opt_base, base_branch, opt_arch);
|
|
base_deploy = flatpak_find_deploy_for_ref (base_ref, cancellable, error);
|
|
if (base_deploy == NULL)
|
|
return FALSE;
|
|
|
|
base_deploy_files = flatpak_deploy_get_files (base_deploy);
|
|
if (!flatpak_cp_a (base_deploy_files, files_dir,
|
|
FLATPAK_CP_FLAGS_MERGE | FLATPAK_CP_FLAGS_NO_CHOWN,
|
|
cancellable, error))
|
|
return FALSE;
|
|
|
|
|
|
if (opt_base_extensions &&
|
|
!copy_extensions (base_deploy, base_branch, opt_base_extensions, files_dir, cancellable, error))
|
|
return FALSE;
|
|
}
|
|
|
|
if (var_deploy_files)
|
|
{
|
|
if (!flatpak_cp_a (var_deploy_files, var_dir, FLATPAK_CP_FLAGS_NONE, cancellable, error))
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
if (!g_file_make_directory (var_dir, cancellable, error))
|
|
return FALSE;
|
|
}
|
|
|
|
if (!flatpak_mkdir_p (var_tmp_dir, cancellable, error))
|
|
return FALSE;
|
|
|
|
if (!g_file_query_exists (var_run_dir, cancellable) &&
|
|
!g_file_make_symbolic_link (var_run_dir, "/run", cancellable, error))
|
|
return FALSE;
|
|
|
|
|
|
metadata_contents = g_string_new ("");
|
|
if (is_app)
|
|
g_string_append (metadata_contents, "[Application]\n");
|
|
else
|
|
g_string_append (metadata_contents, "[Runtime]\n");
|
|
|
|
g_string_append_printf (metadata_contents,
|
|
"name=%s\n",
|
|
app_id);
|
|
|
|
/* The "runtime" can be an app in case we're building an extension */
|
|
if (g_str_has_prefix (runtime_ref, "runtime/"))
|
|
g_string_append_printf (metadata_contents,
|
|
"runtime=%s\n",
|
|
runtime_ref + strlen ("runtime/"));
|
|
|
|
if (g_str_has_prefix (sdk_ref, "runtime/"))
|
|
g_string_append_printf (metadata_contents,
|
|
"sdk=%s\n",
|
|
sdk_ref + strlen ("runtime/"));
|
|
|
|
if (opt_tags != NULL)
|
|
{
|
|
g_string_append (metadata_contents, "tags=");
|
|
for (i = 0; opt_tags[i] != NULL; i++)
|
|
{
|
|
g_string_append (metadata_contents, opt_tags[i]);
|
|
g_string_append_c (metadata_contents, ';');
|
|
}
|
|
g_string_append_c (metadata_contents, '\n');
|
|
}
|
|
|
|
if (is_extension)
|
|
g_string_append_printf (metadata_contents,
|
|
"\n"
|
|
"[ExtensionOf]\n"
|
|
"ref=%s\n",
|
|
runtime_ref);
|
|
|
|
if (!g_file_replace_contents (metadata_file,
|
|
metadata_contents->str, metadata_contents->len, NULL, FALSE,
|
|
G_FILE_CREATE_REPLACE_DESTINATION,
|
|
NULL, cancellable, error))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean
|
|
flatpak_complete_build_init (FlatpakCompletion *completion)
|
|
{
|
|
g_autoptr(GOptionContext) context = NULL;
|
|
g_autoptr(FlatpakDir) user_dir = NULL;
|
|
g_autoptr(FlatpakDir) system_dir = NULL;
|
|
g_autoptr(GError) error = NULL;
|
|
int i;
|
|
|
|
context = g_option_context_new ("");
|
|
|
|
if (!flatpak_option_context_parse (context, options, &completion->argc, &completion->argv,
|
|
FLATPAK_BUILTIN_FLAG_NO_DIR, NULL, NULL, NULL))
|
|
return FALSE;
|
|
|
|
switch (completion->argc)
|
|
{
|
|
case 0:
|
|
case 1: /* DIR */
|
|
flatpak_complete_options (completion, global_entries);
|
|
flatpak_complete_options (completion, options);
|
|
|
|
flatpak_complete_dir (completion);
|
|
break;
|
|
|
|
case 2: /* APP */
|
|
break;
|
|
|
|
case 3: /* RUNTIME */
|
|
case 4: /* SDK */
|
|
user_dir = flatpak_dir_get_user ();
|
|
{
|
|
g_auto(GStrv) refs = flatpak_dir_find_installed_refs (user_dir, NULL, NULL, opt_arch,
|
|
FLATPAK_KINDS_RUNTIME, &error);
|
|
if (refs == NULL)
|
|
flatpak_completion_debug ("find local refs error: %s", error->message);
|
|
for (i = 0; refs != NULL && refs[i] != NULL; i++)
|
|
{
|
|
g_auto(GStrv) parts = flatpak_decompose_ref (refs[i], NULL);
|
|
if (parts)
|
|
flatpak_complete_word (completion, "%s ", parts[1]);
|
|
}
|
|
}
|
|
|
|
system_dir = flatpak_dir_get_system_default ();
|
|
{
|
|
g_auto(GStrv) refs = flatpak_dir_find_installed_refs (system_dir, NULL, NULL, opt_arch,
|
|
FLATPAK_KINDS_RUNTIME, &error);
|
|
if (refs == NULL)
|
|
flatpak_completion_debug ("find local refs error: %s", error->message);
|
|
for (i = 0; refs != NULL && refs[i] != NULL; i++)
|
|
{
|
|
g_auto(GStrv) parts = flatpak_decompose_ref (refs[i], NULL);
|
|
if (parts)
|
|
flatpak_complete_word (completion, "%s ", parts[1]);
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case 5: /* BRANCH */
|
|
user_dir = flatpak_dir_get_user ();
|
|
{
|
|
g_auto(GStrv) refs = flatpak_dir_find_installed_refs (user_dir, completion->argv[3], NULL, opt_arch,
|
|
FLATPAK_KINDS_RUNTIME, &error);
|
|
if (refs == NULL)
|
|
flatpak_completion_debug ("find local refs error: %s", error->message);
|
|
for (i = 0; refs != NULL && refs[i] != NULL; i++)
|
|
{
|
|
g_auto(GStrv) parts = flatpak_decompose_ref (refs[i], NULL);
|
|
if (parts)
|
|
flatpak_complete_word (completion, "%s ", parts[3]);
|
|
}
|
|
}
|
|
|
|
system_dir = flatpak_dir_get_system_default ();
|
|
{
|
|
g_auto(GStrv) refs = flatpak_dir_find_installed_refs (system_dir, completion->argv[3], NULL, opt_arch,
|
|
FLATPAK_KINDS_RUNTIME, &error);
|
|
if (refs == NULL)
|
|
flatpak_completion_debug ("find local refs error: %s", error->message);
|
|
for (i = 0; refs != NULL && refs[i] != NULL; i++)
|
|
{
|
|
g_auto(GStrv) parts = flatpak_decompose_ref (refs[i], NULL);
|
|
if (parts)
|
|
flatpak_complete_word (completion, "%s ", parts[3]);
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|