132 lines
5.2 KiB
C++
132 lines
5.2 KiB
C++
// Copyright 2015 The Android Open Source Project
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#ifndef WEBSERVER_LIBWEBSERV_SERVER_H_
|
|
#define WEBSERVER_LIBWEBSERV_SERVER_H_
|
|
|
|
// In our own Android.mk, we set these flags for ourselves. However, for
|
|
// libraries consuming libwebserv, they don't have any of that logic. Leave us
|
|
// with DBus bindings until the Binder interface is ready.
|
|
#if !defined(WEBSERV_USE_DBUS) && !defined(WEBSERV_USE_BINDER)
|
|
#define WEBSERV_USE_DBUS
|
|
#endif
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
|
|
#include <base/callback.h>
|
|
#include <base/macros.h>
|
|
#include <libwebserv/export.h>
|
|
|
|
#if defined(WEBSERV_USE_DBUS)
|
|
#include <base/memory/ref_counted.h>
|
|
#include <brillo/dbus/async_event_sequencer.h>
|
|
#include <dbus/bus.h>
|
|
#endif // defined(WEBSERV_USE_DBUS)
|
|
|
|
#if defined(WEBSERV_USE_BINDER)
|
|
#include <brillo/message_loops/message_loop.h>
|
|
#endif // defined(WEBSERV_USE_BINDER)
|
|
|
|
namespace libwebserv {
|
|
|
|
class ProtocolHandler;
|
|
|
|
// Top-level wrapper class around HTTP server and provides an interface to
|
|
// the web server.
|
|
class LIBWEBSERV_EXPORT Server {
|
|
public:
|
|
Server() = default;
|
|
virtual ~Server() = default;
|
|
|
|
#if defined(WEBSERV_USE_DBUS)
|
|
// Establish a connection to the system webserver.
|
|
//
|
|
// |service_name| is the well known D-Bus name of the client's process, used
|
|
// to expose a callback D-Bus object the web server calls back with incoming
|
|
// requests.
|
|
// |on_server_online| and |on_server_offline| will notify the caller when the
|
|
// server comes up and down.
|
|
//
|
|
// Note that you can use the returned Server instance as if the webserver
|
|
// process is actually running (ignoring webserver crashes and restarts).
|
|
// All registered request handlers will simply be re-registered when the
|
|
// webserver appears again.
|
|
static std::unique_ptr<Server> ConnectToServerViaDBus(
|
|
const scoped_refptr<dbus::Bus>& bus,
|
|
const std::string& service_name,
|
|
const brillo::dbus_utils::AsyncEventSequencer::CompletionAction& cb,
|
|
const base::Closure& on_server_online,
|
|
const base::Closure& on_server_offline);
|
|
#endif // defined(WEBSERV_USE_DBUS)
|
|
|
|
#if defined(WEBSERV_USE_BINDER)
|
|
// Establish a connection to the system webserver.
|
|
//
|
|
// |on_server_online| and |on_server_offline| will notify the caller when the
|
|
// server comes up and down.
|
|
//
|
|
// Note that you can use the returned Server instance as if the webserver
|
|
// process is actually running (ignoring webserver crashes and restarts).
|
|
// All registered request handlers will simply be re-registered when the
|
|
// webserver appears again.
|
|
static std::unique_ptr<Server> ConnectToServerViaBinder(
|
|
brillo::MessageLoop* message_loop,
|
|
const base::Closure& on_server_online,
|
|
const base::Closure& on_server_offline);
|
|
#endif // defined(WEBSERV_USE_BINDER)
|
|
|
|
// A helper method that returns the default handler for "http".
|
|
virtual ProtocolHandler* GetDefaultHttpHandler() = 0;
|
|
|
|
// A helper method that returns the default handler for "https".
|
|
virtual ProtocolHandler* GetDefaultHttpsHandler() = 0;
|
|
|
|
// Returns an existing protocol handler by name. If the handler with the
|
|
// requested |name| does not exist, a new one will be created.
|
|
//
|
|
// The created handler is purely client side, and depends on the server
|
|
// being configured to open a corresponding handler with the given name.
|
|
// Because clients and the server come up asynchronously, we allow clients
|
|
// to register anticipated handlers before server starts up.
|
|
virtual ProtocolHandler* GetProtocolHandler(const std::string& name) = 0;
|
|
|
|
// Returns true if |this| is connected to the web server daemon via IPC.
|
|
virtual bool IsConnected() const = 0;
|
|
|
|
// Set a user-callback to be invoked when a protocol handler is connect to the
|
|
// server daemon. Multiple calls to this method will overwrite previously set
|
|
// callbacks.
|
|
virtual void OnProtocolHandlerConnected(
|
|
const base::Callback<void(ProtocolHandler*)>& callback) = 0;
|
|
|
|
// Set a user-callback to be invoked when a protocol handler is disconnected
|
|
// from the server daemon (e.g. on shutdown). Multiple calls to this method
|
|
// will overwrite previously set callbacks.
|
|
virtual void OnProtocolHandlerDisconnected(
|
|
const base::Callback<void(ProtocolHandler*)>& callback) = 0;
|
|
|
|
// Returns the default request timeout used to process incoming requests.
|
|
// The reply to an incoming request should be sent within this timeout or
|
|
// else the web server will automatically abort the connection. If the timeout
|
|
// is not set, the returned value will be base::TimeDelta::Max().
|
|
virtual base::TimeDelta GetDefaultRequestTimeout() const = 0;
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(Server);
|
|
};
|
|
|
|
} // namespace libwebserv
|
|
|
|
#endif // WEBSERVER_LIBWEBSERV_SERVER_H_
|