build_building()

1 files changed, 294 insertions, 7 deletions

diff --git a/mod/mod-ci-github.cxx b/mod/mod-ci-github.cxx
index 9ffc2d2..22ba205 100644
--- a/mod/mod-ci-github.cxx
+++ b/mod/mod-ci-github.cxx
@@ -1508,14 +1508,301 @@ namespace brep
                   const diag_epilogue& log_writer) const noexcept
   {
     // Note that we may receive this notification before the corresponding
-    // check run object has been persistent in the service data (see the
-    // returned by build_queued() lambda for details). So we may try to create
-    // a new check run but find out that it's actually already exist on the
-    // GitHub side. In this case we will somehow need to get the node_id for
-    // the existing check run and re-try but this time updating instead of
-    // creating.
+    // check run object has been persisted in the service data (see the
+    // returned by build_queued() lambda for details). Thus we wouldn't know
+    // whether the check run has been created on GitHub yet or not. And given
+    // that, on GitHub, creating a check run with an existent name does not
+    // fail but instead replaces the existing check run (same name, different
+    // node ID), we have to check whether a check run already exists on GitHub
+    // before creating it.
+    //
+    // @@ TMP Will have to do this in build_queued() as well.
+    //
+    NOTIFICATION_DIAG (log_writer);
 
-    return nullptr;
+    service_data sd;
+    try
+    {
+      sd = service_data (*ts.data);
+    }
+    catch (const invalid_argument& e)
+    {
+      error << "failed to parse service data: " << e;
+      return nullptr;
+    }
+
+    service_data::check_run cr; // Updated check run.
+
+    // Create a new check run on GitHub.
+    //
+    auto create = [&cr, &b, &hs, &sd, &error] (const string& iat)
+    {
+      string rq (graphql_request (create_check_runs (sd.repository_id,
+                                                     sd.head_sha,
+                                                     {b},
+                                                     build_state::building,
+                                                     &hs)));
+
+      return mutate_check_run (cr,
+                               {b},
+                               iat,
+                               move (rq),
+                               build_state::building,
+                               error);
+    };
+
+    // Update a check run that already exists on GitHub.
+    //
+    auto update =
+        [&cr, &b, &sd, &error] (const string& iat,
+                                const string& nid,
+                                build_state st = build_state::building)
+    {
+      string rq (graphql_request (
+          update_check_run (sd.repository_id, nid, build_state::building)));
+
+      return mutate_check_run (cr, {b}, iat, move (rq), st, error);
+    };
+
+    // Get a new installation access token if the current one has expired.
+    //
+    const installation_access_token* iat (nullptr);
+    optional<installation_access_token> new_iat;
+
+    if (system_clock::now () > sd.installation_access.expires_at)
+    {
+      if (optional<string> jwt = generate_jwt (trace, error))
+      {
+        new_iat = obtain_installation_access_token (sd.installation_id,
+                                                    move (*jwt),
+                                                    error);
+        if (new_iat)
+          iat = &*new_iat;
+      }
+    }
+    else
+      iat = &sd.installation_access;
+
+    if (iat != nullptr)
+    {
+      string bid (check_run_name (b)); // Full Build ID.
+
+      // Stored check run.
+      //
+      const service_data::check_run* scr (sd.find_check_run (bid));
+
+      if (scr != nullptr && scr->node_id)
+      {
+        // The check run exists on GitHub and in the persisted service data.
+        //
+        if (!scr->state || *scr->state == build_state::queued)
+        {
+          // If the stored state is queued (most likely), at least
+          // build_queued() and its lambda has run. If this is all then GitHub
+          // has the queued status. But it's also possible that build_built()
+          // has also run and updated GitHub to built but its lambda has not
+          // yet run.
+          //
+          // On the other hand, if there is no stored state, both of the other
+          // notifications must have run: the first created the check run on
+          // GitHub and stored the node ID; the second failed to update GitHub
+          // and stored the nullopt state. Either way around, build_built()
+          // has run so built is the correct state.
+          //
+          //   @@ TMP Maybe we should always store the state and add a flag
+          //          like "gh_updated", then we would know for sure whether
+          //          we need to update to built or building.
+          //
+          // So GitHub currently either has queued or built but we can't be
+          // sure which.
+          //
+          // If it has queued, updating to building is correct.
+          //
+          // If it has built then it would be a logical mistake to update to
+          // building. However, GitHub ignores updates from built to any other
+          // state (the REST API responds with HTTP 200 and the full check run
+          // JSON body but with the "completed" status; presumably the GraphQL
+          // API has the same semantics) so we can just try to update to
+          // building and see what the actual status it returns is.
+          //
+          // If scr->state is nullopt then GitHub has either queued or built
+          // but we know build_built() has run so we need to update to built
+          // instead of building.
+          //
+          cr = move (*scr);
+          cr.state = nullopt;
+
+          build_state st (scr->state ? build_state::building
+                                     : build_state::built);
+
+          if (update (iat->token, *cr.node_id, st))
+          {
+            // @@ TODO If !scr->state and GH had built then we probably don't
+            //         want to run the lambda either but currently it will run
+            //         and this update message is not accurate. Is stored
+            //         failed state the only way?
+            //
+            if (cr.state == st)
+              l3 ([&]{trace << "updated check_run { " << cr << " }";});
+            else
+            {
+              // Do not persist anything if state was already built on
+              // GitHub.
+              //
+              assert (cr.state == build_state::built);
+
+              return nullptr;
+            }
+          }
+        }
+        else if (*scr->state == build_state::built)
+        {
+          // Ignore out of order built notification.
+          //
+          assert (*scr->state == build_state::built);
+
+          warn << *scr << ": "
+               << "out of order transition from "
+               << to_string (build_state::queued) << " to "
+               << to_string (build_state::building) <<
+            " (stored state is " << to_string (build_state::built) << ")";
+
+          return nullptr;
+        }
+      }
+      else // (src == nullptr || !scr->node_id)
+      {
+        // No state has been persisted, or one or both of the other
+        // notifications were unable to create the check run on GitHub.
+        //
+        // It's also possible that another notification has since created the
+        // check run on GitHub but its lambda just hasn't run yet.
+        //
+        // Thus the check run may or may not exist on GitHub.
+        //
+        // Because creation destroys check runs with the same name (see
+        // comments at top of function) we have to check whether the check run
+        // exists on GitHub before we can do anything.
+        //
+        // Destructive creation would be catastrophic if, for example, our
+        // "new" building check run replaced the existing built one because it
+        // would look exactly like a transition from built back to building in
+        // the GitHub UI. And then the built lambda could run after our
+        // building lambda, creating an opportunity for the real node ID to be
+        // overwritten with the old one.
+        //
+        cr.build_id = move (bid);
+
+        // Fetch the check run by name from GitHub.
+        //
+        pair<optional<check_run>, bool> pr (
+            fetch_check_run (iat->token,
+                             ts.id,
+                             check_run_name (b, &hs),
+                             error));
+
+        if (pr.second) // No errors.
+        {
+          if (!pr.first) // Check run does not exist on GitHub.
+          {
+            // Assume the most probable cases: build_queued() failed to create
+            // the check run or build_building() is running before
+            // build_queued(), so creating with building state is
+            // correct. (The least likely being that build_built() ran before
+            // this, in which case we should create with the built state.)
+            //
+            // @@ TODO Create with whatever the failed state was if we decide
+            //         to store it.
+            //
+            if (create (iat->token))
+              l3 ([&]{trace << "created check_run { " << cr << " }";});
+          }
+          else // Check run exists on GitHub.
+          {
+            if (pr.first->status == to_string_gh (build_state::queued))
+            {
+              if (scr != nullptr)
+              {
+                cr = move (*scr);
+                cr.state = nullopt;
+              }
+
+              if (update (iat->token, pr.first->node_id))
+                l3 ([&]{trace << "updated check_run { " << cr << " }";});
+            }
+            else
+            {
+              // Do nothing because the GitHub state is already built so the
+              // lambda returned by build_built() will update the database to
+              // built.
+              //
+              return nullptr;
+            }
+          }
+        }
+        else // Error communicating with GitHub.
+        {
+          // Can't tell whether the check run exists GitHub. Make the final
+          // decision on whether or not to store nullopt in node_id and state
+          // based on what's in the database when the lambda runs
+          // (build_built() and its lambda could run in the meantime).
+          //
+          // @@ TODO Store build_state::building if we start storing failed
+          //         state.
+        }
+      }
+    }
+
+    return [iat = move (new_iat),
+            cr = move (cr),
+            error = move (error),
+            warn = move (warn)] (const tenant_service& ts) -> optional<string>
+    {
+      // NOTE: this lambda may be called repeatedly (e.g., due to transaction
+      // being aborted) and so should not move out of its captures.
+
+      service_data sd;
+      try
+      {
+        sd = service_data (*ts.data);
+      }
+      catch (const invalid_argument& e)
+      {
+        error << "failed to parse service data: " << e;
+        return nullopt;
+      }
+
+      if (iat)
+        sd.installation_access = *iat;
+
+      if (service_data::check_run* scr = sd.find_check_run (cr.build_id))
+      {
+        // Update existing check run.
+        //
+        // @@ TODO What if the failed GH update was for built? May end up with
+        //         permanently building check run.
+        //
+        if (!scr->state || scr->state == build_state::queued)
+        {
+          scr->state = cr.state;
+          if (!scr->node_id)
+            scr->node_id = move (cr.node_id);
+        }
+      }
+      else
+      {
+        // Store new check run.
+        //
+        sd.check_runs.push_back (cr);
+
+        warn << "check run { " << cr << " }: "
+             << to_string (build_state::building)
+             << " state being persisted before "
+             << to_string (build_state::queued);
+      }
+
+      return sd.json ();
+    };
   }
 
   function<optional<string> (const tenant_service&)> ci_github::