Method run

3rdparty/libprocess/src/http.cpp:2120–2204

`Server` implementation.

  // `Server` implementation.
  Future<Nothing> run()
  {
    return state.transition<State::INITIALIZED, State::RUNNING>([=]() {
        // Start the accept loop and store the future so we can later
        // discard it when we need to stop the server.
        accepting = loop(
          self(),
          [=]() {
            return socket.accept();
          },
          [=](const network::Socket& socket) -> ControlFlow<Nothing> {
            // If we've transitioned to STOPPING we should break. It
            // may seem like we should never get here because we
            // discard the accept loop before we transition to
            // STOPPING but it's possible that we've already
            // dispatched this lambda and it is only now getting
            // invoked. It's critical that we break because after we
            // transition to STOPPING we assume that `clients` will
            // not be modified by the accept loop.
            if (state.is<State::STOPPING>()) {
              return Break();
            }

            Client client = {
              /* .socket = */ socket,
              /* .serving = */ http::serve(
                  socket,
                  [=](const Request& request) {
                    return f(socket, request);
                  })
            };

            clients.put(socket, client);

            client.serving
              .onAny(defer(self(), [=](const Future<Nothing>&) {
                clients.erase(socket);
              }));

            return Continue();
          });

      // We return a _discardable_ `accepting` so the caller can stop
      // running a server by "discarding the run", for example:
      //
      //   Future<Nothing> run = server.run();
      //   run.discard();
      //
      // Even if we returned an _undiscardable_ `accepting` we still
      // need to do a `recover()` on it in the event that the accept
      // loop fails (or is abandoned) so we can stop the server (if it
      // isn't already being stopped). If `accepting` completes
      // successfully then we must be stopping so just wait until
      // we've stopped!
      return accepting
        .then(defer(self(), [=]() {
          return state.when<State::STOPPED>();
        }))