path: root/bbot/agent.cxx

// file      : bbot/agent.cxx -*- C++ -*-
// copyright : Copyright (c) 2014-2017 Code Synthesis Ltd
// license   : MIT; see accompanying LICENSE file

#include <limits.h> // PATH_MAX
#include <signal.h> // signal()
#include <unistd.h> // sleep(), realink()

#include <iostream>

#include <butl/pager>
#include <butl/fdstream>
#include <butl/filesystem> // dir_iterator

#include <butl/manifest-parser>
#include <butl/manifest-serializer>

#include <bbot/manifest>

#include <bbot/types>
#include <bbot/utility>

#include <bbot/diagnostics>
#include <bbot/agent-options>

#include <bbot/bootstrap-manifest>

using namespace std;
using namespace butl;
using namespace bbot;

const string bs_prot ("1"); // Bootstrap protocol version.

string tc_name; // Toolchain name.
string tc_num;  // Toolchain number.
string tc_id;   // Toolchain id.

template <typename T>
static T
parse_manifest (const path& f, const char* what, bool ignore_unknown = true)
{
  try
  {
    if (!file_exists (f))
      fail << what << " manifest file " << f << " does not exist";

    ifdstream ifs (f);
    manifest_parser mp (ifs, f.string ());
    return T (mp, ignore_unknown);
  }
  catch (const manifest_parsing& e)
  {
    fail << "invalid " << what << " manifest: "
         << f << ':' << e.line << ':' << e.column << ": " << e.description
         << endf;
  }
  catch (const io_error& e)
  {
    fail << "unable to read " << what << " manifest " << f << ": " << e
         << endf;
  }
  catch (const system_error& e) // EACCES, etc.
  {
    fail << "unable to access " << what << " manifest " << f << ": " << e
         << endf;
  }
}

/*

static bootstrapped_machine_manifest
bootstrap_machine (const dir_path&);

static machine_manifests
enumerate_machines (const dir_path& rd)
{
  tracer trace ("enumerate_machines");

  machine_manifests r;

  // The first level are machine volumes.
  //
  for (const dir_entry& ve: dir_iterator (rd))
  {
    const string vn (ve.path ().string ());

    // Ignore hidden directories.
    //
    if (ve.type () != entry_type::directory || vn[0] == '.')
      continue;

    const dir_path vd (dir_path (rd) /= vn);

    // Inside we have machines.
    //
    for (const dir_entry& me: dir_iterator (vd))
    {
      const string mn (me.path ().string ());

      if (me.type () != entry_type::directory || mn[0] == '.')
        continue;

      const dir_path md (dir_path (vd) /= mn);

      // Our endgoal here is to obtain a bootstrapped snapshot of this machine
      // while watching out for potential race conditions (machines being
      // added/upgraded/removed; see the manual for details).
      //
      // So here is our overall plan:
      //
      // 1. Resolve current subvolume link for our bootstrap protocol.
      //
      // 2. If there is no link, cleanup and ignore this machine.
      //
      // 3. Try to create a snapshot of current subvolume (this operation is
      //    atomic). If failed (e.g., someone changed the link and removed the
      //    subvolume in the meantime), retry from #1.
      //
      // 4. Compare the snapshot to the already bootstrapped version (if any)
      //    and see if we need to re-bootstrap. If so, use the snapshot as a
      //    starting point. Rename to bootstrapped at the end (atomic).
      //
      const dir_path lp (dir_path (md) /= (mn + '-' + bs_prot)); // -<P>
      const dir_path tp (dir_path (md) /= (mn + '-' + tc_name)); // -<toolc...>
      bool te (dir_exists (tp));

      auto delete_t = [&tp] ()
      {
        // btrfs property set -ts $tp ro false
        // btrfs subvolume delete $tp
      };

      for (size_t retry (0);; ++retry)
      {
        if (retry != 0)
          sleep (1);

        // Resolve the link to subvolume path.
        //
        dir_path sp; // <name>-<P>.<R>
        try
        {
          char b [PATH_MAX + 1];
          ssize_t r (readlink (lp.string ().c_str (), b, sizeof (b)));

          if (r == -1)
          {
            if (errno != ENOENT)
              throw_generic_error (errno);
          }
          else if (static_cast<size_t> (r) >= sizeof (b))
            throw_generic_error (EINVAL);
          else
          {
            b[r] = '\0';
            sp = dir_path (b);
            if (sp.relative ())
              sp = md / sp;
          }
        }
        catch (const system_error& e)
        {
          fail << "unable to read subvolume link " << lp << ": " << e;
        }

        // If the resolution fails, then this means there is no current
        // machine subvolume (for this bootstrap protocol). In this case we
        // clean up our toolchain subvolume (<name>-<toolchain>) and ignore
        // this machine.
        //
        if (sp.empty ())
        {
          if (te)
            delete_t ();

          break;
        }

        // <name>-<toolchain>-<xxx>
        //
        const dir_path xp (dir_path (md) /=
                           path::traits::temp_name (mn + '-' + tc_name));

        // btrfs subvolume snapshot $sp $xp
        if (false)
        {
          if (retry >= 10)
            fail << "unable to snapshot subvolume " << sp;

          continue;
        }

        // Load the (original) machine manifest.
        //
        auto mm (
          parse_manifest<machine_manifest> (sp / "manifest", "machine"));

        // If we already have <name>-<toolchain>, see if it needs to be re-
        // bootstrapped. Things that render it obsolete:
        //
        // 1. New machine revision  (compare machine ids).
        // 2. New toolchain         (compare toolchain ids).
        // 3. New bbot/libbbot      (compare versions).
        //
        // The last case has a complication: what should we do if we have
        // bootstrapped a newer version of bbot? This would mean that we are
        // about to be stopped and upgraded (and the upgraded version will
        // probably be able to use the result). So we simply ignore this
        // machine for this run.

        // Return -1 if older, 0 if the same, and +1 if newer.
        //
        auto compare_bbot = [] (const bootstrap_manifest& m) -> int
        {
          auto cmp = [&m] (const string& n, uint64_t v) -> int
          {
            auto i = m.versions.find (n);
            return
              i == m.versions.end () || i->second < v
              ? -1
              : i->second > v ? 1 : 0;
          };

          // Start from the top assuming a new dependency cannot be added
          // without changing the dependent's version.
          //
          int r;
          return
            (r = cmp ("bbot",       BBOT_VERSION)) != 0 ? r :
            (r = cmp ("libbbot", LIBBBOT_VERSION)) != 0 ? r :
            (r = cmp ("libbpkg", LIBBPKG_VERSION)) != 0 ? r :
            (r = cmp ("libbutl", LIBBUTL_VERSION)) != 0 ? r : 0;
        };

        if (te)
        {
          auto bmm (
            parse_manifest<bootstrapped_machine_manifest> (
              tp / "manifest",
              "bootstrapped machine"));

          if (bmm.machine.id != mm.id)
          {
            trace << "re-bootstrapping " << tp << ": new machine";
            te = false;
          }

          if (bmm.toolchain.id != tc_id)
          {
            trace << "re-bootstrapping " << tp << ": new toolchain";
            te = false;
          }

          if (int i = compare_bbot (bmm.bootstrap))
          {
            if (i < 0)
            {
              trace << "re-bootstrapping " << tp << ": new bbot";
              te = false;
            }
            else
            {
              trace << "ignoring " << tp << ": newer bbot";
              // btrfs subvolume snapshot $xp
              break;
            }
          }

          if (!te)
            delete_t ();
        }

        if (!te)
        {
          // Use the <name>-<toolchain>-<xxx> snapshot that we have made to
          // bootstrap the new machine. Then atomically rename it to
          // <name>-<toolchain>.
          //
          bootstrapped_machine_manifest bmm (bootstrap_machine (xp));

          try
          {
            mvdir (xp, tp);
          }
          catch (const system_error& e)
          {
            fail << "unable to rename " << xp << " to " << tp;
          }

          te = true;

          // Check the boostrapped bbot version as above and ignore this
          // machine if it's newer than us.
          //
          if (int i = compare_bbot (bmm.bootstrap))
          {
            assert (i > 0);
            trace << "ignoring " << tp << ": newer bbot";
            break;
          }
        }
        else
          ;// btrfs subvolume snapshot $xp

        // Add the machine to the list.
        //
        // In order not to forget to clear new fields, we are instead going to
        // create a new instance with just the required fields.
        //
        r.push_back (machine_manifest (mm.id, mm.name, mm.summary));

        break;
      }
    }
  }

  return r;
}

*/

extern "C" void
handle_signal (int sig)
{
  switch (sig)
  {
  case SIGHUP:  exit (3); // Unimplemented feature.
  case SIGTERM: exit (0);
  default:      assert (false);
  }
}

// Right arrow followed by newline.
//
const char systemd_indent[] = "\xE2\x86\xB2\n";

int
main (int argc, char* argv[])
try
{
  cli::argv_scanner scan (argc, argv, true);
  agent_options ops (scan);

  if (ops.systemd_daemon ())
  {
    // Map to systemd severity prefixes (see sd-daemon(3) for details). Note
    // that here we assume we will never have location (like file name which
    // would end up being before the prefix).
    //
    trace_indent    =
      fail.indent_  =
      error.indent_ =
      warn.indent_  =
      info.indent_  =
      text.indent_  = systemd_indent;

    fail.type_  = "<3>";
    error.type_ = "<3>";
    warn.type_  = "<4>";
    info.type_  = "<6>";
    trace_type  = "<7>";
  }

  tracer trace ("main");

  // On POSIX ignore SIGPIPE which is signaled to a pipe-writing process if
  // the pipe reading end is closed. Note that by default this signal
  // terminates a process. Also note that there is no way to disable this
  // behavior on a file descriptor basis or for the write() function call.
  //
  if (signal (SIGPIPE, SIG_IGN) == SIG_ERR)
    fail << "unable to ignore broken pipe (SIGPIPE) signal: "
         << system_error (errno, generic_category ()); // Sanitize.

  // Version.
  //
  if (ops.version ())
  {
    cout << "bbot-agent " << BBOT_VERSION_STR << endl
         << "libbbot " << LIBBBOT_VERSION_STR << endl
         << "libbutl " << LIBBUTL_VERSION_STR << endl
         << "Copyright (c) 2014-2017 Code Synthesis Ltd" << endl
         << "MIT; see accompanying LICENSE file" << endl;

    return 0;
  }

  // Help.
  //
  if (ops.help ())
  {
    pager p ("bbot-agent help", false);
    print_bbot_agent_usage (p.stream ());

    // If the pager failed, assume it has issued some diagnostics.
    //
    return p.wait () ? 0 : 1;
  }

  if (argc != 4)
    fail << "toolchain name/id/num excected" <<
      info << "run " << argv[0] << " --help for details";

  tc_name = argv[1];
  tc_num  = argv[2];
  tc_id   = argv[3];

  // Handle SIGHUP and SIGTERM.
  //
  if (signal (SIGHUP,  &handle_signal) == SIG_ERR ||
      signal (SIGTERM, &handle_signal) == SIG_ERR)
    fail << "unable to set signal handler: "
         << system_error (errno, generic_category ()); // Sanitize.

  info << "bbot agent for " << tc_name << '/' << tc_num <<
    info << "toolchain id " << tc_id <<
    info << "CPU(s)       " << ops.cpu () <<
    info << "RAM(kB)      " << ops.ram ();

  for (;;)
  {
    error << "sleeping" <<
      warn << "lightly";
    sleep (10);
  }
}
catch (const failed&)
{
  return 1; // Diagnostics has already been issued.
}
catch (const cli::exception& e)
{
  error << e;
  return 1;
}