Method _consume

src/process.cpp:3785–3882

Future<Response> ProcessBase::_consume(
    const HttpEndpoint& endpoint,
    const string& name,
    const Owned<Request>& request)
{
  Future<Option<AuthenticationResult>> authentication = None();

  if (endpoint.realm.isSome()) {
    authentication = authenticator_manager->authenticate(
        *request, endpoint.realm.get());
  }

  // TODO(bmahler): This is an interim check to diagnose MESOS-8687.
  CHECK(handlers.httpSequence.get() != nullptr)
    << "PID '" << pid << "' with endpoint name '" << name << "'";

  // Sequence the authentication future to ensure the handlers
  // are invoked in the same order that requests arrive.
  authentication = handlers.httpSequence->add<Option<AuthenticationResult>>(
      [authentication]() { return authentication; });

  return authentication
    .then(defer(self(), [this, endpoint, request, name](
        const Option<AuthenticationResult>& authentication)
          -> Future<Response> {
      Option<Principal> principal = None();

      // If authentication failed, we do not continue with authorization.
      if (authentication.isSome()) {
        if (authentication->unauthorized.isSome()) {
          // Request was not authenticated, challenged issued.
          return authentication->unauthorized.get();
        } else if (authentication->forbidden.isSome()) {
          // Request was not authenticated, no challenge issued.
          return authentication->forbidden.get();
        }

        CHECK_SOME(authentication->principal);
        principal = authentication->principal;
      }

      // Look for an authorization callback installed for this endpoint.
      //
      // NOTE: we use double-checked locking here to avoid
      // head-of-line blocking that occurs when the first thread
      // attempts to check for authorization callbacks.
      //
      // TODO(bmahler): Consider a read/write lock in addition to
      // double checked locking. Since we expect the callbacks to
      // be set in production, it would be ideal to avoid locking
      // altogether. This would be possible if authorization
      // callbacks were bound to the lifetime of libprocess
      // initialization and finalization.
      //
      // TODO(benh): Consider optimizing this further to not be
      // sequentially consistent. For more details see:
      // http://preshing.com/20130930/double-checked-locking-is-fixed-in-cpp11.
      Future<bool> authorization = true;