path: root/src/ostree/ot-builtin-find-remotes.c

/*
 * Copyright © 2017 Endless Mobile, Inc.
 *
 * SPDX-License-Identifier: LGPL-2.0+
 *
 * This library 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 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, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * Authors:
 *  - Philip Withnall <withnall@endlessm.com>
 */

#include "config.h"

#include "ot-main.h"
#include "ot-builtins.h"
#include "ostree.h"
#include "otutil.h"

#include "ostree-remote-private.h"

static gchar *opt_cache_dir = NULL;
static gchar *opt_finders = NULL;
static gboolean opt_disable_fsync = FALSE;
static gboolean opt_pull = FALSE;
static gboolean opt_mirror = FALSE;

static GOptionEntry options[] =
  {
    { "cache-dir", 0, 0, G_OPTION_ARG_FILENAME, &opt_cache_dir, "Use custom cache dir", NULL },
    { "disable-fsync", 0, 0, G_OPTION_ARG_NONE, &opt_disable_fsync, "Do not invoke fsync()", NULL },
    { "finders", 0, 0, G_OPTION_ARG_STRING, &opt_finders, "Use the specified comma separated list of finders (e.g. config,lan,mount)", "FINDERS" },
    { "pull", 0, 0, G_OPTION_ARG_NONE, &opt_pull, "Pull the updates after finding them", NULL },
    { "mirror", 0, 0, G_OPTION_ARG_NONE, &opt_mirror, "Do a mirror pull (see ostree pull --mirror)", NULL},
    { NULL }
  };

static gchar *
uint64_secs_to_iso8601 (guint64 secs)
{
  g_autoptr(GDateTime) dt = g_date_time_new_from_unix_utc (secs);

  if (dt != NULL)
    return g_date_time_format (dt, "%FT%TZ");
  else
    return g_strdup ("invalid");
}

static gchar *
format_ref_to_checksum (GHashTable  *ref_to_checksum  /* (element-type OstreeCollectionRef utf8) */,
                        const gchar *line_prefix)
{
  GHashTableIter iter;
  const OstreeCollectionRef *ref;
  const gchar *checksum;
  g_autoptr(GString) out = NULL;

  g_hash_table_iter_init (&iter, ref_to_checksum);
  out = g_string_new ("");

  while (g_hash_table_iter_next (&iter, (gpointer *) &ref, (gpointer *) &checksum))
    g_string_append_printf (out, "%s - (%s, %s) = %s\n",
                            line_prefix, ref->collection_id, ref->ref_name,
                            (checksum != NULL) ? checksum : "(not found)");

  return g_string_free (g_steal_pointer (&out), FALSE);
}

static gchar *
remote_get_uri (OstreeRemote *remote)
{
  g_autoptr(GError) error = NULL;
  g_autofree gchar *uri = NULL;

  uri = g_key_file_get_string (remote->options, remote->group, "url", &error);
  g_assert_no_error (error);

  return g_steal_pointer (&uri);
}

/* Add each key from @keys_input to @set iff its value is non-%NULL. */
static void
add_keys_to_set_if_non_null (GHashTable *set,
                             GHashTable *keys_input)
{
  GHashTableIter iter;
  gpointer key, value;

  g_hash_table_iter_init (&iter, keys_input);

  while (g_hash_table_iter_next (&iter, &key, &value))
    if (value != NULL)
      g_hash_table_add (set, key);
}

static void
get_result_cb (GObject      *obj,
               GAsyncResult *result,
               gpointer      user_data)
{
  GAsyncResult **result_out = user_data;
  *result_out = g_object_ref (result);
}

static void
collection_ref_free0 (OstreeCollectionRef *ref)
{
  if (ref == NULL)
    return;
  ostree_collection_ref_free (ref);
}

static gboolean
validate_finders_list (const char     **finders,
                       GOptionContext  *context,
                       GError         **error)
{
  typedef struct {
    gchar *finder_name;
    gboolean already_used;
  } Finder;
  Finder valid_finders[] = {
    {.finder_name = "config", .already_used = FALSE},
    {.finder_name = "lan", .already_used = FALSE},
    {.finder_name = "mount", .already_used = FALSE}
  };

  if (finders == NULL || *finders == NULL)
    {
      ot_util_usage_error (context, "List of finders in --finders option must not be empty", error);
      return FALSE;
    }

  for (const char **iter = finders; iter && *iter; iter++)
    {
      gboolean is_valid_finder = FALSE;
      for (unsigned int i = 0; i < G_N_ELEMENTS (valid_finders); i++)
        {
          if (valid_finders[i].already_used == TRUE)
            continue;
          if (g_strcmp0 (*iter, valid_finders[i].finder_name) == 0)
            {
              is_valid_finder = TRUE;
              valid_finders[i].already_used = TRUE;
            }
        }
      if (!is_valid_finder)
        {
          g_autofree gchar *error_msg = NULL;
          error_msg = g_strdup_printf ("Unknown or duplicate finder type given in --finders option: ‘%s’", *iter);
          ot_util_usage_error (context, error_msg, error);
          return FALSE;
        }
    }

  return TRUE;
}

gboolean
ostree_builtin_find_remotes (int            argc,
                             char         **argv,
                             OstreeCommandInvocation *invocation,
                             GCancellable  *cancellable,
                             GError       **error)
{
  g_autoptr(GOptionContext) context = NULL;
  g_autoptr(OstreeRepo) repo = NULL;
  g_autoptr(GPtrArray) refs = NULL;  /* (element-type OstreeCollectionRef) */
  g_autoptr(GPtrArray) finders = NULL;  /* (element-type OstreeRepoFinder) */
  g_autoptr(OstreeRepoFinder) finder_config = NULL;
  g_autoptr(OstreeRepoFinder) finder_mount = NULL;
#ifdef HAVE_AVAHI
  g_autoptr(OstreeRepoFinder) finder_avahi = NULL;
#endif  /* HAVE_AVAHI */
  g_autoptr(OstreeAsyncProgress) progress = NULL;
  gsize i;
  g_autoptr(GAsyncResult) find_result = NULL, pull_result = NULL;
  g_auto(OstreeRepoFinderResultv) results = NULL;
  g_auto(GLnxConsoleRef) console = { 0, };
  g_autoptr(GHashTable) refs_found = NULL;  /* set (element-type OstreeCollectionRef) */
  g_autoptr(GVariant) pull_options = NULL;

  context = g_option_context_new ("COLLECTION-ID REF [COLLECTION-ID REF...]");

  /* Parse options. */
  if (!ostree_option_context_parse (context, options, &argc, &argv, invocation, &repo, cancellable, error))
    return FALSE;

  if (!ostree_ensure_repo_writable (repo, error))
    return FALSE;

  if (argc < 3)
    {
      ot_util_usage_error (context, "At least one COLLECTION-ID REF pair must be specified", error);
      return FALSE;
    }

  if (argc % 2 == 0)
    {
      ot_util_usage_error (context, "Only complete COLLECTION-ID REF pairs may be specified", error);
      return FALSE;
    }

  if (opt_mirror && !opt_pull)
    {
      ot_util_usage_error (context, "When --mirror is specified, --pull must also be", error);
      return FALSE;
    }

  if (opt_disable_fsync)
    ostree_repo_set_disable_fsync (repo, TRUE);

  if (opt_cache_dir &&
      !ostree_repo_set_cache_dir (repo, AT_FDCWD, opt_cache_dir, cancellable, error))
    return FALSE;

  /* Read in the refs to search for remotes for. */
  refs = g_ptr_array_new_full (argc, (GDestroyNotify) collection_ref_free0);

  for (i = 1; i < argc; i += 2)
    {
      if (!ostree_validate_collection_id (argv[i], error) ||
          !ostree_validate_rev (argv[i + 1], error))
        return FALSE;

      g_ptr_array_add (refs, ostree_collection_ref_new (argv[i], argv[i + 1]));
    }

  g_ptr_array_add (refs, NULL);

  /* Build the array of OstreeRepoFinder instances */
  if (opt_finders != NULL)
    {
      g_auto(GStrv) finders_strings = NULL;

      finders_strings = g_strsplit (opt_finders, ",", 0);
      if (!validate_finders_list ((const char **)finders_strings, context, error))
        return FALSE;

      finders = g_ptr_array_new_with_free_func (NULL);
      for (const char **iter = (const char **)finders_strings; iter && *iter; iter++)
        {
          if (g_strcmp0 (*iter, "config") == 0)
            {
              finder_config = OSTREE_REPO_FINDER (ostree_repo_finder_config_new ());
              g_ptr_array_add (finders, finder_config);
            }
          else if (g_strcmp0 (*iter, "mount") == 0)
            {
              finder_mount = OSTREE_REPO_FINDER (ostree_repo_finder_mount_new (NULL));
              g_ptr_array_add (finders, finder_mount);
            }
          else if (g_strcmp0 (*iter, "lan") == 0)
            {
#ifdef HAVE_AVAHI
              GMainContext *main_context = g_main_context_get_thread_default ();
              g_autoptr(GError) local_error = NULL;

              finder_avahi = OSTREE_REPO_FINDER (ostree_repo_finder_avahi_new (main_context));
              ostree_repo_finder_avahi_start (OSTREE_REPO_FINDER_AVAHI (finder_avahi), &local_error);

              if (local_error != NULL)
                {
                  g_warning ("Avahi finder failed; removing it: %s", local_error->message);
                  g_clear_object (&finder_avahi);
                }
              else
                g_ptr_array_add (finders, finder_avahi);
#else
              ot_util_usage_error (context, "LAN repo finder requested but ostree was compiled without Avahi support", error);
              return FALSE;
#endif  /* HAVE_AVAHI */
            }
          else
            g_assert_not_reached ();
        }
      g_ptr_array_add (finders, NULL);
    }

  /* Run the operation. */
  glnx_console_lock (&console);

  if (console.is_tty)
    progress = ostree_async_progress_new_and_connect (ostree_repo_pull_default_console_progress_changed, &console);

  ostree_repo_find_remotes_async (repo,
                                  (const OstreeCollectionRef * const *) refs->pdata,
                                  NULL  /* no options */,
                                  finders != NULL ? (OstreeRepoFinder **) finders->pdata : NULL,
                                  progress, cancellable,
                                  get_result_cb, &find_result);

  while (find_result == NULL)
    g_main_context_iteration (NULL, TRUE);

  results = ostree_repo_find_remotes_finish (repo, find_result, error);

  if (results == NULL)
    return FALSE;

  if (progress)
    ostree_async_progress_finish (progress);

  /* Print results and work out which refs were not found. */
  refs_found = g_hash_table_new_full (ostree_collection_ref_hash,
                                      ostree_collection_ref_equal, NULL, NULL);

  for (i = 0; results[i] != NULL; i++)
    {
      g_autofree gchar *uri = NULL;
      g_autofree gchar *refs_string = NULL;
      g_autofree gchar *last_modified_string = NULL;

      uri = remote_get_uri (results[i]->remote);
      refs_string = format_ref_to_checksum (results[i]->ref_to_checksum, "   ");
      add_keys_to_set_if_non_null (refs_found, results[i]->ref_to_checksum);

      if (results[i]->summary_last_modified > 0)
        last_modified_string = uint64_secs_to_iso8601 (results[i]->summary_last_modified);
      else
        last_modified_string = g_strdup ("unknown");

      g_print ("Result %" G_GSIZE_FORMAT ": %s\n"
               " - Finder: %s\n"
               " - Keyring: %s\n"
               " - Priority: %d\n"
               " - Summary last modified: %s\n"
               " - Refs:\n"
               "%s\n",
               i, uri, G_OBJECT_TYPE_NAME (results[i]->finder), results[i]->remote->keyring,
               results[i]->priority, last_modified_string, refs_string);
    }

  if (results[0] == NULL)
    {
      g_print ("No results.\n");
      return TRUE;
    }

  g_print ("%u/%u refs were found.\n", g_hash_table_size (refs_found), refs->len - 1);

  /* Print out the refs which weren’t found. */
  if (g_hash_table_size (refs_found) != refs->len - 1  /* NULL terminator */)
    {
      g_print ("Refs not found in any remote:\n");

      for (i = 0; i < refs->len && refs->pdata[i] != NULL; i++)
        {
          const OstreeCollectionRef *ref = g_ptr_array_index (refs, i);
          if (!g_hash_table_contains (refs_found, ref))
            g_print (" - (%s, %s)\n", ref->collection_id, ref->ref_name);
        }
    }

  /* Does the user want us to pull the updates? */
  if (!opt_pull)
    return TRUE;

  {
    GVariantBuilder builder;
    g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));

    if (opt_mirror)
      g_variant_builder_add (&builder, "{s@v}", "flags",
                             g_variant_new_variant (g_variant_new_int32 (OSTREE_REPO_PULL_FLAGS_MIRROR)));

    pull_options = g_variant_ref_sink (g_variant_builder_end (&builder));
  }

  /* Run the pull operation. */
  if (console.is_tty)
    progress = ostree_async_progress_new_and_connect (ostree_repo_pull_default_console_progress_changed, &console);

  ostree_repo_pull_from_remotes_async (repo,
                                       (const OstreeRepoFinderResult * const *) results,
                                       pull_options,
                                       progress, cancellable,
                                       get_result_cb, &pull_result);

  while (pull_result == NULL)
    g_main_context_iteration (NULL, TRUE);

  if (!ostree_repo_pull_from_remotes_finish (repo, pull_result, error))
    return FALSE;

  if (progress)
    ostree_async_progress_finish (progress);

  /* The pull operation fails if any of the refs can’t be pulled. */
  g_print ("Pulled %u/%u refs successfully.\n", refs->len - 1, refs->len - 1);

  return TRUE;
}