gboolean
xdg_app_builtin_install (int argc, char **argv, GCancellable *cancellable, GError **error)
{
gboolean ret = FALSE;
g_autoptr(GOptionContext) context = NULL;
g_autoptr(XdgAppDir) dir = NULL;
g_autoptr(GFile) deploy_base = NULL;
const char *repository;
const char *name;
const char *branch = NULL;
g_autofree char *ref = NULL;
g_autofree char *installed_ref = NULL;
gboolean is_app;
gboolean created_deploy_base = FALSE;
g_auto(GLnxLockFile) lock = GLNX_LOCK_FILE_INIT;
g_autoptr(GError) my_error = NULL;
context = g_option_context_new ("REPOSITORY NAME [BRANCH] - Install an application or runtime");
if (!xdg_app_option_context_parse (context, options, &argc, &argv, 0, &dir, cancellable, error))
return FALSE;
if (opt_bundle)
return install_bundle (dir, context, argc, argv, cancellable, error);
if (argc < 3)
return usage_error (context, "REPOSITORY and NAME must be specified", error);
repository = argv[1];
name = argv[2];
if (argc >= 4)
branch = argv[3];
if (!opt_app && !opt_runtime)
opt_app = opt_runtime = TRUE;
installed_ref = xdg_app_dir_find_installed_ref (dir,
name,
branch,
opt_arch,
opt_app, opt_runtime, &is_app,
&my_error);
if (installed_ref != NULL)
{
return xdg_app_fail (error, "%s %s, branch %s is already installed",
is_app ? "App" : "Runtime", name, branch ? branch : "master");
}
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;
}
ref = xdg_app_dir_find_remote_ref (dir, repository, name, branch, opt_arch,
opt_app, opt_runtime, &is_app, cancellable, error);
if (ref == NULL)
return FALSE;
deploy_base = xdg_app_dir_get_deploy_dir (dir, ref);
if (g_file_query_exists (deploy_base, cancellable))
return xdg_app_fail (error, "Ref %s already deployed", ref);
if (!opt_no_pull)
{
if (!xdg_app_dir_pull (dir, repository, ref, NULL,
cancellable, error))
return FALSE;
}
/* After we create the deploy base we must goto out on errors */
if (!opt_no_deploy)
{
if (!xdg_app_dir_lock (dir, &lock,
cancellable, error))
goto out;
if (!g_file_make_directory_with_parents (deploy_base, cancellable, error))
goto out;
created_deploy_base = TRUE;
if (!xdg_app_dir_set_origin (dir, ref, repository, cancellable, error))
goto out;
if (!xdg_app_dir_deploy (dir, ref, NULL, cancellable, error))
goto out;
if (is_app)
{
if (!xdg_app_dir_make_current_ref (dir, ref, cancellable, error))
goto out;
if (!xdg_app_dir_update_exports (dir, name, cancellable, error))
goto out;
}
glnx_release_lock_file (&lock);
}
xdg_app_dir_cleanup_removed (dir, cancellable, NULL);
if (!xdg_app_dir_mark_changed (dir, error))
goto out;
ret = TRUE;
out:
if (created_deploy_base && !ret)
gs_shutil_rm_rf (deploy_base, cancellable, NULL);
return ret;
}
gboolean
flatpak_builtin_install (int argc, char **argv, GCancellable *cancellable, GError **error)
{
g_autoptr(GOptionContext) context = NULL;
g_autoptr(GPtrArray) dirs = NULL;
g_autoptr(FlatpakDir) dir = NULL;
g_autofree char *remote = NULL;
g_autofree char *remote_url = NULL;
char **prefs = NULL;
int i, n_prefs;
g_autofree char *target_branch = NULL;
g_autofree char *default_branch = NULL;
FlatpakKinds kinds;
g_autoptr(FlatpakTransaction) transaction = NULL;
g_autoptr(FlatpakDir) dir_with_remote = NULL;
gboolean auto_remote = FALSE;
context = g_option_context_new (_("[LOCATION/REMOTE] [REF…] - Install applications or runtimes"));
g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
if (!flatpak_option_context_parse (context, options, &argc, &argv,
FLATPAK_BUILTIN_FLAG_ALL_DIRS | FLATPAK_BUILTIN_FLAG_OPTIONAL_REPO,
&dirs, cancellable, error))
return FALSE;
/* Start with the default or specified dir, this is fine for opt_bundle or opt_from */
dir = g_object_ref (g_ptr_array_index (dirs, 0));
if (!opt_bundle && !opt_from && argc >= 2)
{
if (flatpak_file_arg_has_suffix (argv[1], ".flatpakref"))
opt_from = TRUE;
if (flatpak_file_arg_has_suffix (argv[1], ".flatpak"))
opt_bundle = TRUE;
}
if (opt_bundle)
return install_bundle (dir, context, argc, argv, cancellable, error);
if (opt_from)
return install_from (dir, context, argc, argv, cancellable, error);
if (argc < 2)
return usage_error (context, _("At least one REF must be specified"), error);
if (argc == 2)
auto_remote = TRUE;
kinds = flatpak_kinds_from_bools (opt_app, opt_runtime);
if (!opt_noninteractive)
g_print (_("Looking for matches…\n"));
if (!auto_remote &&
(g_path_is_absolute (argv[1]) ||
g_str_has_prefix (argv[1], "./")))
{
g_autoptr(GFile) remote_file = g_file_new_for_commandline_arg (argv[1]);
remote_url = g_file_get_uri (remote_file);
remote = g_strdup (remote_url);
}
else
{
g_autoptr(GError) local_error = NULL;
/* If the remote was used, and no single dir was specified, find which
* one based on the remote. If the remote isn't found assume it's a ref
* and we should auto-detect the remote. */
if (!auto_remote &&
!flatpak_resolve_duplicate_remotes (dirs, argv[1], &dir_with_remote, cancellable, &local_error))
{
if (g_error_matches (local_error, FLATPAK_ERROR, FLATPAK_ERROR_REMOTE_NOT_FOUND))
{
auto_remote = TRUE;
}
else
{
g_propagate_error (error, g_steal_pointer (&local_error));
return FALSE;
}
}
if (!auto_remote)
{
remote = g_strdup (argv[1]);
g_clear_object (&dir);
dir = g_object_ref (dir_with_remote);
}
else
{
g_autoptr(GPtrArray) remote_dir_pairs = NULL;
RemoteDirPair *chosen_pair = NULL;
remote_dir_pairs = g_ptr_array_new_with_free_func ((GDestroyNotify) remote_dir_pair_free);
/* Search all remotes for a matching ref. This is imperfect
* because it only takes the first specified ref into account and
* doesn't distinguish between an exact match and a fuzzy match, but
* that's okay because the user will be asked to confirm the remote
*/
for (i = 0; i < dirs->len; i++)
{
FlatpakDir *this_dir = g_ptr_array_index (dirs, i);
g_auto(GStrv) remotes = NULL;
guint j = 0;
remotes = flatpak_dir_list_remotes (this_dir, cancellable, error);
if (remotes == NULL)
return FALSE;
for (j = 0; remotes[j] != NULL; j++)
{
const char *this_remote = remotes[j];
g_autofree char *this_default_branch = NULL;
g_autofree char *id = NULL;
g_autofree char *arch = NULL;
g_autofree char *branch = NULL;
FlatpakKinds matched_kinds;
g_auto(GStrv) refs = NULL;
g_autoptr(GError) local_error = NULL;
if (flatpak_dir_get_remote_disabled (this_dir, this_remote) ||
flatpak_dir_get_remote_noenumerate (this_dir, this_remote))
continue;
this_default_branch = flatpak_dir_get_remote_default_branch (this_dir, this_remote);
flatpak_split_partial_ref_arg_novalidate (argv[1], kinds, opt_arch, target_branch,
&matched_kinds, &id, &arch, &branch);
if (opt_no_pull)
refs = flatpak_dir_find_local_refs (this_dir, this_remote, id, branch, this_default_branch, arch,
flatpak_get_default_arch (),
matched_kinds, FIND_MATCHING_REFS_FLAGS_FUZZY,
cancellable, &local_error);
else
refs = flatpak_dir_find_remote_refs (this_dir, this_remote, id, branch, this_default_branch, arch,
flatpak_get_default_arch (),
matched_kinds, FIND_MATCHING_REFS_FLAGS_FUZZY,
cancellable, &local_error);
if (refs == NULL)
{
g_warning ("An error was encountered searching remote ‘%s’ for ‘%s’: %s", this_remote, argv[1], local_error->message);
continue;
}
if (g_strv_length (refs) == 0)
continue;
else
{
RemoteDirPair *pair = remote_dir_pair_new (this_remote, this_dir);
g_ptr_array_add (remote_dir_pairs, pair);
}
}
}
if (remote_dir_pairs->len == 0)
return flatpak_fail (error, _("No remote refs found similar to ‘%s’"), argv[1]);
if (!flatpak_resolve_matching_remotes (opt_yes, remote_dir_pairs, argv[1], &chosen_pair, error))
return FALSE;
remote = g_strdup (chosen_pair->remote_name);
g_clear_object (&dir);
dir = g_object_ref (chosen_pair->dir);
}
}
if (auto_remote)
{
prefs = &argv[1];
n_prefs = argc - 1;
}
else
{
prefs = &argv[2];
n_prefs = argc - 2;
}
/* Backwards compat for old "REMOTE NAME [BRANCH]" argument version */
if (argc == 4 && flatpak_is_valid_name (argv[2], NULL) && looks_like_branch (argv[3]))
{
target_branch = g_strdup (argv[3]);
n_prefs = 1;
}
default_branch = flatpak_dir_get_remote_default_branch (dir, remote);
if (opt_noninteractive)
transaction = flatpak_quiet_transaction_new (dir, error);
else
transaction = flatpak_cli_transaction_new (dir, opt_yes, TRUE, error);
if (transaction == NULL)
return FALSE;
flatpak_transaction_set_no_pull (transaction, opt_no_pull);
flatpak_transaction_set_no_deploy (transaction, opt_no_deploy);
flatpak_transaction_set_disable_static_deltas (transaction, opt_no_static_deltas);
flatpak_transaction_set_disable_dependencies (transaction, opt_no_deps);
flatpak_transaction_set_disable_related (transaction, opt_no_related);
flatpak_transaction_set_reinstall (transaction, opt_reinstall);
for (i = 0; i < n_prefs; i++)
{
const char *pref = prefs[i];
FlatpakKinds matched_kinds;
g_autofree char *id = NULL;
g_autofree char *arch = NULL;
g_autofree char *branch = NULL;
g_autofree char *ref = NULL;
g_auto(GStrv) refs = NULL;
guint refs_len;
g_autoptr(GError) local_error = NULL;
flatpak_split_partial_ref_arg_novalidate (pref, kinds, opt_arch, target_branch,
&matched_kinds, &id, &arch, &branch);
/* We used _novalidate so that the id can be partial, but we can still validate the branch */
if (branch != NULL && !flatpak_is_valid_branch (branch, &local_error))
return flatpak_fail_error (error, FLATPAK_ERROR_INVALID_REF, _("Invalid branch %s: %s"), branch, local_error->message);
if (opt_no_pull)
refs = flatpak_dir_find_local_refs (dir, remote, id, branch, default_branch, arch,
flatpak_get_default_arch (),
matched_kinds, FIND_MATCHING_REFS_FLAGS_FUZZY,
cancellable, error);
else
refs = flatpak_dir_find_remote_refs (dir, remote, id, branch, default_branch, arch,
flatpak_get_default_arch (),
matched_kinds, FIND_MATCHING_REFS_FLAGS_FUZZY,
cancellable, error);
if (refs == NULL)
return FALSE;
refs_len = g_strv_length (refs);
if (refs_len == 0)
{
if (opt_no_pull)
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("Nothing matches %s in local repository for remote %s"), id, remote);
else
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("Nothing matches %s in remote %s"), id, remote);
return FALSE;
}
if (!flatpak_resolve_matching_refs (remote, dir, opt_yes, refs, id, &ref, error))
return FALSE;
if (!flatpak_transaction_add_install (transaction, remote, ref, (const char **)opt_subpaths, error))
{
if (!g_error_matches (*error, FLATPAK_ERROR, FLATPAK_ERROR_ALREADY_INSTALLED))
return FALSE;
g_printerr (_("Skipping: %s\n"), (*error)->message);
g_clear_error (error);
}
}
if (!flatpak_transaction_run (transaction, cancellable, error))
{
if (g_error_matches (*error, FLATPAK_ERROR, FLATPAK_ERROR_ABORTED))
{
g_clear_error (error);
return TRUE;
}
return FALSE;
}
return TRUE;
}
gboolean
flatpak_builtin_install (int argc, char **argv, GCancellable *cancellable, GError **error)
{
g_autoptr(GOptionContext) context = NULL;
g_autoptr(FlatpakDir) dir = NULL;
const char *repository;
const char *name;
const char *branch = NULL;
g_autofree char *ref = NULL;
gboolean is_app;
g_autoptr(GFile) deploy_dir = NULL;
g_autoptr(GPtrArray) related = NULL;
int i;
context = g_option_context_new ("REPOSITORY NAME [BRANCH] - Install an application or runtime");
if (!flatpak_option_context_parse (context, options, &argc, &argv, 0, &dir, cancellable, error))
return FALSE;
if (opt_bundle)
return install_bundle (dir, context, argc, argv, cancellable, error);
if (argc < 3)
return usage_error (context, "REPOSITORY and NAME must be specified", error);
repository = argv[1];
name = argv[2];
if (argc >= 4)
branch = argv[3];
if (!opt_app && !opt_runtime)
opt_app = opt_runtime = TRUE;
ref = flatpak_dir_find_remote_ref (dir, repository, name, branch, opt_arch,
opt_app, opt_runtime, &is_app, cancellable, error);
if (ref == NULL)
return FALSE;
deploy_dir = flatpak_dir_get_if_deployed (dir, ref, NULL, cancellable);
if (deploy_dir != NULL)
{
g_auto(GStrv) parts = flatpak_decompose_ref (ref, error);
return flatpak_fail (error, "%s %s, branch %s is already installed",
is_app ? "App" : "Runtime", name, parts[3]);
}
if (!flatpak_dir_install (dir,
opt_no_pull,
opt_no_deploy,
ref, repository, (const char **)opt_subpaths,
NULL,
cancellable, error))
return FALSE;
if (!opt_no_related)
{
g_autoptr(GError) local_error = NULL;
if (opt_no_pull)
related = flatpak_dir_find_local_related (dir, ref, repository, NULL, &local_error);
else
related = flatpak_dir_find_remote_related (dir, ref, repository, NULL, &local_error);
if (related == NULL)
{
g_printerr ("Warning: Problem looking for related refs: %s\n", local_error->message);
g_clear_error (&local_error);
}
else
{
for (i = 0; i < related->len; i++)
{
FlatpakRelated *rel = g_ptr_array_index (related, i);
g_auto(GStrv) parts = NULL;
if (!rel->download)
continue;
parts = g_strsplit (rel->ref, "/", 0);
g_print ("Installing related: %s\n", parts[1]);
if (!flatpak_dir_install_or_update (dir,
opt_no_pull,
opt_no_deploy,
rel->ref, repository,
(const char **)rel->subpaths,
NULL,
cancellable, &local_error))
{
g_printerr ("Warning: Failed to install related ref: %s\n",
rel->ref);
g_clear_error (&local_error);
}
}
}
}
return TRUE;
}
