flatpak-builder/src/builder-context.c

/* builder-context.c
 *
 * Copyright (C) 2015 Red Hat, Inc
 *
 * This file 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 file 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 program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Authors:
 *       Alexander Larsson <alexl@redhat.com>
 */

#include "config.h"

#include <string.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/statfs.h>
#include <sys/prctl.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/resource.h>

#include <glib/gi18n.h>
#include "builder-flatpak-utils.h"
#include "builder-context.h"
#include "builder-cache.h"
#include "builder-utils.h"

struct BuilderContext
{
  GObject         parent;

  GFile          *app_dir;
  GFile          *run_dir; /* directory flatpak-builder was started from */
  GFile          *base_dir; /* directory with json manifest, origin for source files */
  char           *state_subdir;
  SoupSession    *soup_session;
  CURL           *curl_session;
  char           *arch;
  char           *default_branch;
  char           *stop_at;
  gint64          source_date_epoch;

  GFile          *download_dir;
  GPtrArray      *sources_dirs;
  GPtrArray      *sources_urls;
  GFile          *state_dir;
  GFile          *build_dir;
  GFile          *cache_dir;
  GFile          *checksums_dir;
  GFile          *ccache_dir;
  GFile          *rofiles_dir;
  GFile          *rofiles_allocated_dir;
  GLnxLockFile   rofiles_file_lock;

  BuilderOptions *options;
  gboolean        keep_build_dirs;
  gboolean        delete_build_dirs;
  int             jobs;
  char          **cleanup;
  char          **cleanup_platform;
  gboolean        use_ccache;
  gboolean        build_runtime;
  gboolean        build_extension;
  gboolean        separate_locales;
  gboolean        bundle_sources;
  gboolean        sandboxed;
  gboolean        rebuild_on_sdk_change;
  gboolean        use_rofiles;
  gboolean        have_rofiles;
  gboolean        run_tests;
  gboolean        no_shallow_clone;

  BuilderSdkConfig *sdk_config;
};

typedef struct
{
  GObjectClass parent_class;
} BuilderContextClass;

G_DEFINE_TYPE (BuilderContext, builder_context, G_TYPE_OBJECT);

enum {
  PROP_0,
  PROP_APP_DIR,
  PROP_RUN_DIR,
  PROP_STATE_SUBDIR,
  LAST_PROP
};


static void
builder_context_finalize (GObject *object)
{
  BuilderContext *self = (BuilderContext *) object;

  g_clear_object (&self->state_dir);
  g_clear_object (&self->download_dir);
  g_clear_object (&self->build_dir);
  g_clear_object (&self->cache_dir);
  g_clear_object (&self->checksums_dir);
  g_clear_object (&self->rofiles_dir);
  g_clear_object (&self->ccache_dir);
  g_clear_object (&self->app_dir);
  g_clear_object (&self->run_dir);
  g_clear_object (&self->base_dir);
  g_clear_object (&self->soup_session);
  g_clear_object (&self->options);
  g_clear_object (&self->sdk_config);
  g_free (self->arch);
  g_free (self->default_branch);
  g_free (self->state_subdir);
  g_free (self->stop_at);
  g_strfreev (self->cleanup);
  g_strfreev (self->cleanup_platform);
  glnx_release_lock_file(&self->rofiles_file_lock);

  g_clear_pointer (&self->sources_dirs, g_ptr_array_unref);
  g_clear_pointer (&self->sources_urls, g_ptr_array_unref);

  curl_easy_cleanup (self->curl_session);
  self->curl_session = NULL;
  curl_global_cleanup ();

  G_OBJECT_CLASS (builder_context_parent_class)->finalize (object);
}

static void
builder_context_get_property (GObject    *object,
                              guint       prop_id,
                              GValue     *value,
                              GParamSpec *pspec)
{
  BuilderContext *self = BUILDER_CONTEXT (object);

  switch (prop_id)
    {
    case PROP_RUN_DIR:
      g_value_set_object (value, self->run_dir);
      break;

    case PROP_APP_DIR:
      g_value_set_object (value, self->app_dir);
      break;

    case PROP_STATE_SUBDIR:
      g_value_set_string (value, self->state_subdir);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

static void
builder_context_set_property (GObject      *object,
                              guint         prop_id,
                              const GValue *value,
                              GParamSpec   *pspec)
{
  BuilderContext *self = BUILDER_CONTEXT (object);

  switch (prop_id)
    {
    case PROP_RUN_DIR:
      g_set_object (&self->run_dir, g_value_get_object (value));
      break;

    case PROP_APP_DIR:
      g_set_object (&self->app_dir, g_value_get_object (value));
      break;

    case PROP_STATE_SUBDIR:
      g_free (self->state_subdir);
      self->state_subdir = g_value_dup_string (value);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

static void
builder_context_constructed (GObject *object)
{
  BuilderContext *self = BUILDER_CONTEXT (object);

  self->state_dir = g_file_resolve_relative_path (self->run_dir, self->state_subdir ? self->state_subdir : ".flatpak-builder");
  self->download_dir = g_file_get_child (self->state_dir, "downloads");
  self->build_dir = g_file_get_child (self->state_dir, "build");
  self->cache_dir = g_file_get_child (self->state_dir, "cache");
  self->checksums_dir = g_file_get_child (self->state_dir, "checksums");

  // Check, if CCACHE_DIR is set in environment and use it, instead of subdir of state_dir
  const char * env_ccache_dir = g_getenv ("CCACHE_DIR");
  if (env_ccache_dir && g_path_is_absolute(env_ccache_dir))
    {
      g_debug ("Using CCACHE_DIR '%s'", env_ccache_dir);
      self->ccache_dir = g_file_new_for_path (env_ccache_dir);
    }
    else
    {
      self->ccache_dir = g_file_get_child(self->state_dir, "ccache");
    }
}

static void
builder_context_class_init (BuilderContextClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  object_class->constructed = builder_context_constructed;
  object_class->finalize = builder_context_finalize;
  object_class->get_property = builder_context_get_property;
  object_class->set_property = builder_context_set_property;

  g_object_class_install_property (object_class,
                                   PROP_APP_DIR,
                                   g_param_spec_object ("app-dir",
                                                        "",
                                                        "",
                                                        G_TYPE_FILE,
                                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
  g_object_class_install_property (object_class,
                                   PROP_RUN_DIR,
                                   g_param_spec_object ("run-dir",
                                                        "",
                                                        "",
                                                        G_TYPE_FILE,
                                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
  g_object_class_install_property (object_class,
                                   PROP_STATE_SUBDIR,
                                   g_param_spec_string ("state-subdir",
                                                        "",
                                                        "",
                                                        "",
                                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
}

static void
builder_context_init (BuilderContext *self)
{
  GLnxLockFile init = { 0, };
  g_autofree char *path = NULL;

  self->rofiles_file_lock = init;
  path = g_find_program_in_path ("rofiles-fuse");
  self->have_rofiles = path != NULL;
}

GFile *
builder_context_get_run_dir (BuilderContext *self)
{
  return self->run_dir;
}

GFile *
builder_context_get_base_dir (BuilderContext *self)
{
  return self->base_dir;
}

void
builder_context_set_base_dir (BuilderContext *self,
                              GFile          *base_dir)
{
  g_set_object (&self->base_dir, base_dir);
}

GFile *
builder_context_get_state_dir (BuilderContext *self)
{
  return self->state_dir;
}

GFile *
builder_context_get_app_dir_raw (BuilderContext *self)
{
  return self->app_dir;
}

GFile *
builder_context_get_app_dir (BuilderContext *self)
{
  if (self->rofiles_dir)
    return self->rofiles_dir;
  return self->app_dir;
}

GFile *
builder_context_get_download_dir (BuilderContext *self)
{
  return self->download_dir;
}

GPtrArray *
builder_context_get_sources_dirs (BuilderContext *self)
{
  return self->sources_dirs;
}

void
builder_context_set_sources_dirs (BuilderContext *self,
                                  GPtrArray      *sources_dirs)
{
  g_clear_pointer (&self->sources_dirs, g_ptr_array_unref);
  self->sources_dirs = g_ptr_array_ref (sources_dirs);
}

GFile *
builder_context_find_in_sources_dirs_va (BuilderContext *self,
                                         va_list args)
{
  int i;

  if (self->sources_dirs == NULL)
    return NULL;

  for (i = 0; i < self->sources_dirs->len; i++)
    {
      GFile *dir = g_ptr_array_index (self->sources_dirs, i);
      g_autoptr(GFile) local_file = NULL;
      va_list args2;

      va_copy (args2, args);
      local_file = flatpak_build_file_va (dir, args2);
      va_end (args2);

      if (g_file_query_exists (local_file, NULL))
        return g_steal_pointer (&local_file);
    }

  return NULL;
}

GFile *
builder_context_find_in_sources_dirs (BuilderContext *self,
                                      ...)
{
  GFile *res;
  va_list args;

  va_start (args, self);
  res = builder_context_find_in_sources_dirs_va (self, args);
  va_end (args);

  return res;
}

GPtrArray *
builder_context_get_sources_urls (BuilderContext *self)
{
  return self->sources_urls;
}

void
builder_context_set_sources_urls (BuilderContext *self,
                                  GPtrArray      *sources_urls)
{
  g_clear_pointer (&self->sources_urls, g_ptr_array_unref);
  self->sources_urls = g_ptr_array_ref (sources_urls);
}

gboolean
builder_context_download_uri (BuilderContext *self,
                              const char     *url,
                              const char    **mirrors,
                              GFile          *dest,
                              const char     *checksums[BUILDER_CHECKSUMS_LEN],
                              GChecksumType   checksums_type[BUILDER_CHECKSUMS_LEN],
                              GError        **error)
{
  int i;
  g_autoptr(SoupURI) original_uri = soup_uri_new (url);
  g_autoptr(GError) first_error = NULL;

  if (original_uri == NULL)
    return flatpak_fail (error, _("Could not parse URI “%s”"), url);

  g_print ("Downloading %s\n", url);

  if (self->sources_urls != NULL)
    {
      g_autofree char *base_name = g_path_get_basename (soup_uri_get_path (original_uri));
      g_autofree char *rel = g_build_filename ("downloads", checksums[0], base_name, NULL);

      for (i = 0; i < self->sources_urls->len; i++)
        {
          SoupURI *base_uri = g_ptr_array_index (self->sources_urls, i);
          g_autoptr(SoupURI) mirror_uri = soup_uri_new_with_base (base_uri, rel);
          g_autofree char *mirror_uri_str = soup_uri_to_string (mirror_uri, FALSE);
          g_print ("Trying mirror %s\n", mirror_uri_str);
          g_autoptr(GError) my_error = NULL;

          if (builder_download_uri (mirror_uri,
                                    dest,
                                    checksums, checksums_type,
                                    builder_context_get_curl_session (self),
                                    &my_error))
            return TRUE;

          if (!g_error_matches (my_error, BUILDER_CURL_ERROR, CURLE_REMOTE_FILE_NOT_FOUND))
            g_warning ("Error downloading from mirror: %s\n", my_error->message);
        }
    }

  if (!builder_download_uri (original_uri,
                             dest,
                             checksums, checksums_type,
                             builder_context_get_curl_session (self),
                             &first_error))
    {
      gboolean mirror_ok = FALSE;

      if (mirrors != NULL && mirrors[0] != NULL)
        {
          g_print ("Error downloading, trying mirrors\n");
          for (i = 0; mirrors[i] != NULL; i++)
            {
              g_autoptr(GError) mirror_error = NULL;
              g_autoptr(SoupURI) mirror_uri = soup_uri_new (mirrors[i]);
              g_print ("Trying mirror %s\n", mirrors[i]);
              if (!builder_download_uri (mirror_uri,
                                         dest,
                                         checksums, checksums_type,
                                         builder_context_get_curl_session (self),
                                         &mirror_error))
                {
                  g_print ("Error downloading mirror: %s\n", mirror_error->message);
                }
              else
                {
                  mirror_ok = TRUE;
                  break;
                }
            }
        }

      if (!mirror_ok)
        {
          g_propagate_error (error, g_steal_pointer (&first_error));
          return FALSE;
        }
    }

  return TRUE;
}

GFile *
builder_context_get_cache_dir (BuilderContext *self)
{
  return self->cache_dir;
}

GFile *
builder_context_get_build_dir (BuilderContext *self)
{
  return self->build_dir;
}

char *
builder_context_get_checksum_for (BuilderContext *self,
                                  const char *name)
{
  g_autofree char *checksum_name = g_strdup_printf ("%s-%s", builder_context_get_arch (self), name);
  g_autoptr(GFile) checksum_file = g_file_get_child (self->checksums_dir, checksum_name);
  g_autofree gchar *checksum = NULL;

  if (!g_file_get_contents (flatpak_file_get_path_cached (checksum_file), &checksum, NULL, NULL))
    return NULL;

  return g_steal_pointer (&checksum);
}

gboolean
builder_context_set_checksum_for (BuilderContext  *self,
                                  const char      *name,
                                  const char      *checksum,
                                  GError         **error)
{
  g_autofree char *checksum_name = g_strdup_printf ("%s-%s", builder_context_get_arch (self), name);
  g_autoptr(GFile) checksum_file = g_file_get_child (self->checksums_dir, checksum_name);

  if (!flatpak_mkdir_p (self->checksums_dir,
                        NULL, error))
    return FALSE;

  return g_file_set_contents (flatpak_file_get_path_cached (checksum_file), checksum, -1, error);
}

GFile *
builder_context_allocate_build_subdir (BuilderContext *self,
                                       const char *name,
                                       GError **error)
{
  g_autoptr(GError) my_error = NULL;
  int count;

  if (!flatpak_mkdir_p (self->build_dir,
                        NULL, error))
    return NULL;

  for (count = 1; count < 1000; count++)
    {
      g_autofree char *buildname = NULL;
      g_autoptr(GFile) subdir = NULL;

      buildname = g_strdup_printf ("%s-%d", name, count);
      subdir = g_file_get_child (self->build_dir, buildname);

      if (g_file_make_directory (subdir, NULL, &my_error))
        return g_steal_pointer (&subdir);
      else
        {
          if (!g_error_matches (my_error, G_IO_ERROR, G_IO_ERROR_EXISTS))
            {
              g_propagate_error (error, g_steal_pointer (&my_error));
              return NULL;
            }
          g_clear_error (&my_error);
          /* Already exists, try again */
        }
    }

  flatpak_fail (error, "Unable to allocate build dir for %s\n", name);
  return NULL;
}

GFile *
builder_context_get_ccache_dir (BuilderContext *self)
{
  return self->ccache_dir;
}

SoupSession *
builder_context_get_soup_session (BuilderContext *self)
{
  if (self->soup_session == NULL)
    self->soup_session = flatpak_create_soup_session ("flatpak-builder " PACKAGE_VERSION);

  return self->soup_session;
}

CURL *
builder_context_get_curl_session (BuilderContext *self)
{
  if (self->curl_session == NULL)
    self->curl_session = flatpak_create_curl_session ("flatpak-builder " PACKAGE_VERSION);

  return self->curl_session;
}

const char *
builder_context_get_arch (BuilderContext *self)
{
  if (self->arch == NULL)
    self->arch = g_strdup (flatpak_get_arch ());

  return (const char *) self->arch;
}

void
builder_context_set_arch (BuilderContext *self,
                          const char     *arch)
{
  g_free (self->arch);
  self->arch = g_strdup (arch);
}

const char *
builder_context_get_default_branch (BuilderContext *self)
{
  return (const char *) self->default_branch;
}

void
builder_context_set_default_branch (BuilderContext *self,
                                    const char     *default_branch)
{
  g_free (self->default_branch);
  self->default_branch = g_strdup (default_branch);
}

void
builder_context_set_source_date_epoch (BuilderContext *self,
                                       gint64 source_date_epoch)
{
  self->source_date_epoch = source_date_epoch;
}

const char *
builder_context_get_stop_at (BuilderContext *self)
{
  return self->stop_at;
}

void
builder_context_set_stop_at (BuilderContext *self,
                             const char     *module)
{
  g_free (self->stop_at);
  self->stop_at = g_strdup (module);
}

BuilderOptions *
builder_context_get_options (BuilderContext *self)
{
  return self->options;
}

void
builder_context_set_options (BuilderContext *self,
                             BuilderOptions *option)
{
  g_set_object (&self->options, option);
}

int
builder_context_get_jobs (BuilderContext *self)
{
  if (self->jobs == 0)
    return (int) sysconf (_SC_NPROCESSORS_ONLN);
  return self->jobs;
}

void
builder_context_set_jobs (BuilderContext *self,
                          int jobs)
{
  self->jobs = jobs;
}

void
builder_context_set_keep_build_dirs (BuilderContext *self,
                                     gboolean        keep_build_dirs)
{
  self->keep_build_dirs = keep_build_dirs;
}

void
builder_context_set_delete_build_dirs (BuilderContext *self,
                                       gboolean        delete_build_dirs)
{
  self->delete_build_dirs = delete_build_dirs;
}

void
builder_context_set_global_cleanup (BuilderContext *self,
                                    const char    **cleanup)
{
  g_strfreev (self->cleanup);
  self->cleanup = g_strdupv ((char **) cleanup);
}

const char **
builder_context_get_global_cleanup (BuilderContext *self)
{
  return (const char **) self->cleanup;
}

void
builder_context_set_global_cleanup_platform (BuilderContext *self,
                                             const char    **cleanup)
{
  g_strfreev (self->cleanup_platform);
  self->cleanup_platform = g_strdupv ((char **) cleanup);
}

const char **
builder_context_get_global_cleanup_platform (BuilderContext *self)
{
  return (const char **) self->cleanup_platform;
}

gboolean
builder_context_get_keep_build_dirs (BuilderContext *self)
{
  return self->keep_build_dirs;
}

gboolean
builder_context_get_delete_build_dirs (BuilderContext *self)
{
  return self->delete_build_dirs;
}

void
builder_context_set_sandboxed (BuilderContext *self,
                               gboolean        sandboxed)
{
  self->sandboxed = sandboxed;
}

gboolean
builder_context_get_sandboxed (BuilderContext *self)
{
  return self->sandboxed;
}

gboolean
builder_context_get_build_runtime (BuilderContext *self)
{
  return self->build_runtime;
}

void
builder_context_set_build_runtime (BuilderContext *self,
                                   gboolean        build_runtime)
{
  self->build_runtime = !!build_runtime;
}

gboolean
builder_context_get_build_extension (BuilderContext *self)
{
  return self->build_extension;
}

void
builder_context_set_build_extension (BuilderContext *self,
                                     gboolean        build_extension)
{
  self->build_extension = !!build_extension;
}

gboolean
builder_context_get_separate_locales (BuilderContext *self)
{
  return self->separate_locales;
}

void
builder_context_set_separate_locales (BuilderContext *self,
                                      gboolean        separate_locales)
{
  self->separate_locales = !!separate_locales;
}

gboolean
builder_context_get_bundle_sources (BuilderContext *self)
{
  return self->bundle_sources;
}

void
builder_context_set_bundle_sources (BuilderContext *self,
                                    gboolean        bundle_sources)
{
  self->bundle_sources = !!bundle_sources;
}

static char *rofiles_unmount_path = NULL;

static void
rofiles_umount_handler (int signum)
{
  char *argv[] = { "fusermount", "-uz", NULL,
                     NULL };

  argv[2] = rofiles_unmount_path;
  g_debug ("unmounting rofiles-fuse %s", rofiles_unmount_path);
  g_spawn_sync (NULL, (char **)argv, NULL,
                G_SPAWN_SEARCH_PATH | G_SPAWN_CLOEXEC_PIPES | G_SPAWN_STDOUT_TO_DEV_NULL | G_SPAWN_STDERR_TO_DEV_NULL,
                NULL, NULL, NULL, NULL, NULL, NULL);
  exit (0);
}

static void
rofiles_child_setup (gpointer user_data)
{
  struct rlimit limit;

  /* I had issues with rofiles-fuse running into EMFILE, so
     lets push it as far up as we can */

  if (getrlimit (RLIMIT_NOFILE, &limit) == 0 &&
      limit.rlim_max != limit.rlim_cur)
    {
      limit.rlim_cur  = limit.rlim_max;
      setrlimit (RLIMIT_NOFILE, &limit);
    }
}

gboolean
builder_context_enable_rofiles (BuilderContext *self,
                                GError        **error)
{
  g_autoptr(GFile) rofiles_base = NULL;
  g_autoptr(GFile) rofiles_dir = NULL;
  g_autofree char *tmpdir_name = NULL;
  char *argv[] = { "rofiles-fuse",
                   "-o",
                   "kernel_cache,entry_timeout=60,attr_timeout=60,splice_write,splice_move",
                   (char *)flatpak_file_get_path_cached (self->app_dir),
                   NULL,
                   NULL };
  gint exit_status;
  pid_t child;

  if (!self->use_rofiles)
    return TRUE;

  if (!self->have_rofiles)
    {
      g_warning ("rofiles-fuse not available, doing without");
      return TRUE;
    }

  g_assert (self->rofiles_dir == NULL);

  if (self->rofiles_allocated_dir == NULL)
    {
      rofiles_base = g_file_get_child (self->state_dir, "rofiles");
      if (g_mkdir_with_parents (flatpak_file_get_path_cached (rofiles_base), 0755) != 0)
        {
          glnx_set_error_from_errno (error);
          return FALSE;
        }

      if (!flatpak_allocate_tmpdir (AT_FDCWD,
                                    flatpak_file_get_path_cached (rofiles_base),
                                    "rofiles-",
                                    &tmpdir_name, NULL,
                                    &self->rofiles_file_lock,
                                    NULL, NULL, error))
        return FALSE;

      self->rofiles_allocated_dir = g_file_get_child (rofiles_base, tmpdir_name);

      /* Make sure we unmount the fuse fs if flatpak-builder dies unexpectedly */
      rofiles_unmount_path = (char *)flatpak_file_get_path_cached (self->rofiles_allocated_dir);
      child = fork ();
      if (child == -1)
        {
          glnx_set_error_from_errno (error);
          return FALSE;
        }

      if (child == 0)
        {
          /* In child */
          struct sigaction new_action;

          prctl (PR_SET_PDEATHSIG, SIGHUP);

          new_action.sa_handler = rofiles_umount_handler;
          sigemptyset (&new_action.sa_mask);
          new_action.sa_flags = 0;
          sigaction (SIGHUP, &new_action, NULL);

          sigset (SIGINT, SIG_IGN);
          sigset (SIGPIPE, SIG_IGN);
          sigset (SIGSTOP, SIG_IGN);

          while (TRUE)
            pause ();

          exit (0);
        }
    }

  rofiles_dir = g_object_ref (self->rofiles_allocated_dir);
  argv[4] = (char *)flatpak_file_get_path_cached (rofiles_dir);

  g_debug ("starting: rofiles-fuse %s %s", argv[3], argv[4]);
  if (!g_spawn_sync (NULL, (char **)argv, NULL, G_SPAWN_SEARCH_PATH | G_SPAWN_CLOEXEC_PIPES, rofiles_child_setup, NULL, NULL, NULL, &exit_status, error))
    {
      g_prefix_error (error, "Can't spawn rofiles-fuse");
      return FALSE;
    }
  else if (exit_status != 0)
    {
      return flatpak_fail (error, "Failure spawning rofiles-fuse, exit_status: %d", exit_status);
    }


  self->rofiles_dir = g_steal_pointer (&rofiles_dir);

  return TRUE;
}

gboolean
builder_context_disable_rofiles (BuilderContext *self,
                                 GError        **error)
{
  char *argv[] = { "fusermount", "-u", NULL,
                     NULL };

  if (!self->use_rofiles)
    return TRUE;

  if (!self->have_rofiles)
    return TRUE;

  g_assert (self->rofiles_dir != NULL);

  argv[2] = (char *)flatpak_file_get_path_cached (self->rofiles_dir);

  g_debug ("unmounting rofiles-fuse %s", rofiles_unmount_path);
  g_spawn_sync (NULL, (char **)argv, NULL,
                G_SPAWN_SEARCH_PATH | G_SPAWN_CLOEXEC_PIPES,
                NULL, NULL, NULL, NULL, NULL, NULL);

  g_clear_object (&self->rofiles_dir);

  return TRUE;
}

gboolean
builder_context_get_rofiles_active (BuilderContext *self)
{
  return self->rofiles_dir != NULL;
}

gboolean
builder_context_get_use_rofiles (BuilderContext *self)
{
  return self->use_rofiles;
}

void
builder_context_set_use_rofiles (BuilderContext *self,
                                 gboolean use_rofiles)
{
  self->use_rofiles = use_rofiles;
}

gboolean
builder_context_get_run_tests (BuilderContext *self)
{
  return self->run_tests;
}

void
builder_context_set_run_tests (BuilderContext *self,
                               gboolean run_tests)
{
  self->run_tests = run_tests;
}

void
builder_context_set_no_shallow_clone (BuilderContext *self,
                                      gboolean        no_shallow_clone)
{
  self->no_shallow_clone = no_shallow_clone;
}

gboolean
builder_context_get_no_shallow_clone (BuilderContext *self)
{
  return self->no_shallow_clone;
}

gboolean
builder_context_get_rebuild_on_sdk_change (BuilderContext *self)
{
  return self->rebuild_on_sdk_change;
}

void
builder_context_set_rebuild_on_sdk_change (BuilderContext *self,
                                           gboolean        rebuild_on_sdk_change)
{
  self->rebuild_on_sdk_change = !!rebuild_on_sdk_change;
}

gboolean
builder_context_set_enable_ccache (BuilderContext *self,
                                   gboolean        enable,
                                   GError        **error)
{
  int i;

  self->use_ccache = !!enable;

  if (enable)
    {
      g_autofree char *ccache_path = g_file_get_path (self->ccache_dir);
      g_autofree char *ccache_bin_path = g_build_filename (ccache_path, "bin", NULL);
      static const char *compilers[] = {
        "cc",
        "c++",
        "gcc",
        "g++"
      };

      if (g_mkdir_with_parents (ccache_bin_path, 0755) != 0)
        {
          glnx_set_error_from_errno (error);
          return FALSE;
        }

      for (i = 0; i < G_N_ELEMENTS (compilers); i++)
        {
          const char *symlink_path = g_build_filename (ccache_bin_path, compilers[i], NULL);
          if (symlink ("/usr/bin/ccache", symlink_path) && errno != EEXIST)
            {
              glnx_set_error_from_errno (error);
              return FALSE;
            }
        }
    }
  else
    {
      g_autoptr(GFile) ccache_disabled_dir = g_file_get_child (self->ccache_dir, "disabled");
      g_autofree char *ccache_disabled_path = g_file_get_path (ccache_disabled_dir);
      g_autofree char *ccache_config_path = g_build_filename (ccache_disabled_path, "ccache.conf", NULL);
      g_autoptr(GError) my_error = NULL;

      if (g_mkdir_with_parents (ccache_disabled_path, 0755) != 0)
        {
          glnx_set_error_from_errno (error);
          return FALSE;
        }

      if (!g_file_set_contents (ccache_config_path, "disable = true\n", -1, &my_error))
        {
          if (!g_error_matches (my_error, G_FILE_ERROR, G_FILE_ERROR_EXIST))
            {
              g_propagate_error (error, g_steal_pointer (&my_error));
              return FALSE;
            }
          g_clear_error (&my_error);
        }
    }

  return TRUE;
}

char **
builder_context_extend_env_pre (BuilderContext *self,
                                char          **envp)
{
  if (self->source_date_epoch != 0)
    {
      g_autofree char *s_d_e = g_strdup_printf ("%" G_GUINT64_FORMAT, self->source_date_epoch);
      envp = g_environ_setenv (envp, "SOURCE_DATE_EPOCH", s_d_e, FALSE);
    }

  return envp;
}

char **
builder_context_extend_env_post (BuilderContext *self,
                                 char          **envp)
{
  g_autofree char *path = NULL;
  const char *ccache_dir = NULL;

  path = g_strdup (g_environ_getenv (envp, "PATH"));
  if (path == NULL)
    path = g_strdup ("/app/bin:/usr/bin"); /* This is the flatpak default PATH, we alway set it so we can easily append to it */

  if (self->use_ccache)
    {
      char *new_path = g_strdup_printf ("/run/ccache/bin:%s", path);
      g_free (path);
      path = new_path;
      ccache_dir = "/run/ccache";
    }
  else
    {
      ccache_dir = "/run/ccache/disabled";
    }

  envp = g_environ_setenv (envp, "CCACHE_DIR", ccache_dir, TRUE);
  envp = g_environ_setenv (envp, "PATH", path, TRUE);

  return envp;
}

gboolean
builder_context_load_sdk_config (BuilderContext   *self,
                                 const char       *sdk_path,
                                 GError          **error)
{
  g_autoptr(GFile) root = g_file_new_for_path (sdk_path);
  g_autoptr(GFile) config_file = g_file_resolve_relative_path (root, "files/etc/flatpak-builder/defaults.json");
  g_autoptr(GError) local_error = NULL;
  g_autoptr(BuilderSdkConfig) sdk_config = NULL;

  sdk_config = builder_sdk_config_from_file (config_file, &local_error);
  if (sdk_config == NULL &&
      !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
    {
      g_propagate_error (error, g_steal_pointer (&local_error));
      return FALSE;
    }

  g_set_object (&self->sdk_config, sdk_config);
  return TRUE;
}

BuilderSdkConfig *
builder_context_get_sdk_config (BuilderContext *self)
{
  return self->sdk_config;
}

BuilderContext *
builder_context_new (GFile *run_dir,
                     GFile *app_dir,
                     const char *state_subdir)
{
  return g_object_new (BUILDER_TYPE_CONTEXT,
                       "run-dir", run_dir,
                       "app-dir", app_dir,
                       "state-subdir", state_subdir,
                       NULL);
}