summaryrefslogtreecommitdiff
path: root/src/mongo/db/service_context.h
diff options
context:
space:
mode:
authorMark Benvenuto <mark.benvenuto@mongodb.com>2015-06-20 00:22:50 -0400
committerMark Benvenuto <mark.benvenuto@mongodb.com>2015-06-20 10:56:02 -0400
commit9c2ed42daa8fbbef4a919c21ec564e2db55e8d60 (patch)
tree3814f79c10d7b490948d8cb7b112ac1dd41ceff1 /src/mongo/db/service_context.h
parent01965cf52bce6976637ecb8f4a622aeb05ab256a (diff)
downloadmongo-9c2ed42daa8fbbef4a919c21ec564e2db55e8d60.tar.gz
SERVER-18579: Clang-Format - reformat code, no comment reflow
Diffstat (limited to 'src/mongo/db/service_context.h')
-rw-r--r--src/mongo/db/service_context.h568
1 files changed, 286 insertions, 282 deletions
diff --git a/src/mongo/db/service_context.h b/src/mongo/db/service_context.h
index 066f6c6bc70..8f07c34d5a1 100644
--- a/src/mongo/db/service_context.h
+++ b/src/mongo/db/service_context.h
@@ -40,362 +40,366 @@
namespace mongo {
- class AbstractMessagingPort;
- class Client;
- class OperationContext;
- class OpObserver;
+class AbstractMessagingPort;
+class Client;
+class OperationContext;
+class OpObserver;
+/**
+ * Classes that implement this interface can receive notification on killOp.
+ *
+ * See GlobalEnvironmentExperiment::registerKillOpListener() for more information, including
+ * limitations on the lifetime of registered listeners.
+ */
+class KillOpListenerInterface {
+public:
/**
- * Classes that implement this interface can receive notification on killOp.
- *
- * See GlobalEnvironmentExperiment::registerKillOpListener() for more information, including
- * limitations on the lifetime of registered listeners.
+ * Will be called *after* ops have been told they should die.
+ * Callback must not fail.
*/
- class KillOpListenerInterface {
- public:
- /**
- * Will be called *after* ops have been told they should die.
- * Callback must not fail.
- */
- virtual void interrupt(unsigned opId) = 0;
- virtual void interruptAll() = 0;
+ virtual void interrupt(unsigned opId) = 0;
+ virtual void interruptAll() = 0;
- protected:
- // Should not delete through a pointer of this type
- virtual ~KillOpListenerInterface() {}
- };
+protected:
+ // Should not delete through a pointer of this type
+ virtual ~KillOpListenerInterface() {}
+};
+
+class StorageFactoriesIterator {
+ MONGO_DISALLOW_COPYING(StorageFactoriesIterator);
+
+public:
+ virtual ~StorageFactoriesIterator() {}
+ virtual bool more() const = 0;
+ virtual const StorageEngine::Factory* next() = 0;
- class StorageFactoriesIterator {
- MONGO_DISALLOW_COPYING(StorageFactoriesIterator);
+protected:
+ StorageFactoriesIterator() {}
+};
+
+/**
+ * Class representing the context of a service, such as a MongoD database service or
+ * a MongoS routing service.
+ *
+ * A ServiceContext is the root of a hierarchy of contexts. A ServiceContext owns
+ * zero or more Clients, which in turn each own OperationContexts.
+ */
+class ServiceContext : public Decorable<ServiceContext> {
+ MONGO_DISALLOW_COPYING(ServiceContext);
+
+public:
+ /**
+ * Special deleter used for cleaning up Client objects owned by a ServiceContext.
+ * See UniqueClient, below.
+ */
+ class ClientDeleter {
public:
- virtual ~StorageFactoriesIterator() { }
- virtual bool more() const = 0;
- virtual const StorageEngine::Factory* next() = 0;
- protected:
- StorageFactoriesIterator() { }
+ void operator()(Client* client) const;
};
/**
- * Class representing the context of a service, such as a MongoD database service or
- * a MongoS routing service.
- *
- * A ServiceContext is the root of a hierarchy of contexts. A ServiceContext owns
- * zero or more Clients, which in turn each own OperationContexts.
+ * Observer interface implemented to hook client and operation context creation and
+ * destruction.
*/
- class ServiceContext : public Decorable<ServiceContext> {
- MONGO_DISALLOW_COPYING(ServiceContext);
+ class ClientObserver {
public:
- /**
- * Special deleter used for cleaning up Client objects owned by a ServiceContext.
- * See UniqueClient, below.
- */
- class ClientDeleter {
- public:
- void operator()(Client* client) const;
- };
+ virtual ~ClientObserver() = default;
/**
- * Observer interface implemented to hook client and operation context creation and
- * destruction.
- */
- class ClientObserver {
- public:
- virtual ~ClientObserver() = default;
-
- /**
- * Hook called after a new client "client" is created on a service by
- * service->makeClient().
- *
- * For a given client and registered instance of ClientObserver, if onCreateClient
- * returns without throwing an exception, onDestroyClient will be called when "client"
- * is deleted.
- */
- virtual void onCreateClient(Client* client) = 0;
-
- /**
- * Hook called on a "client" created by a service before deleting "client".
- *
- * Like a destructor, must not throw exceptions.
- */
- virtual void onDestroyClient(Client* client) = 0;
-
- /**
- * Hook called after a new operation context is created on a client by
- * service->makeOperationContext(client) or client->makeOperationContext().
- *
- * For a given operation context and registered instance of ClientObserver, if
- * onCreateOperationContext returns without throwing an exception,
- * onDestroyOperationContext will be called when "opCtx" is deleted.
- */
- virtual void onCreateOperationContext(OperationContext* opCtx) = 0;
-
- /**
- * Hook called on a "opCtx" created by a service before deleting "opCtx".
- *
- * Like a destructor, must not throw exceptions.
- */
- virtual void onDestroyOperationContext(OperationContext* opCtx) = 0;
- };
-
- using ClientSet = unordered_set<Client*>;
-
- /**
- * Cursor for enumerating the live Client objects belonging to a ServiceContext.
+ * Hook called after a new client "client" is created on a service by
+ * service->makeClient().
*
- * Lifetimes of this type are synchronized with client creation and destruction.
- */
- class LockedClientsCursor {
- public:
- /**
- * Constructs a cursor for enumerating the clients of "service", blocking "service" from
- * creating or destroying Client objects until this instance is destroyed.
- */
- explicit LockedClientsCursor(ServiceContext* service);
-
- /**
- * Returns the next client in the enumeration, or nullptr if there are no more clients.
- */
- Client* next();
-
- private:
- stdx::unique_lock<stdx::mutex> _lock;
- ClientSet::const_iterator _curr;
- ClientSet::const_iterator _end;
- };
-
- /**
- * Special deleter used for cleaning up OperationContext objects owned by a ServiceContext.
- * See UniqueOperationContext, below.
- */
- class OperationContextDeleter {
- public:
- void operator()(OperationContext* opCtx) const;
- };
-
- /**
- * This is the unique handle type for Clients created by a ServiceContext.
+ * For a given client and registered instance of ClientObserver, if onCreateClient
+ * returns without throwing an exception, onDestroyClient will be called when "client"
+ * is deleted.
*/
- using UniqueClient = std::unique_ptr<Client, ClientDeleter>;
+ virtual void onCreateClient(Client* client) = 0;
/**
- * This is the unique handle type for OperationContexts created by a ServiceContext.
- */
- using UniqueOperationContext = std::unique_ptr<OperationContext, OperationContextDeleter>;
-
- virtual ~ServiceContext();
-
- /**
- * Registers an observer of lifecycle events on Clients created by this ServiceContext.
- *
- * See the ClientObserver type, above, for details.
+ * Hook called on a "client" created by a service before deleting "client".
*
- * All calls to registerClientObserver must complete before ServiceContext
- * is used in multi-threaded operation, or is used to create clients via calls
- * to makeClient.
+ * Like a destructor, must not throw exceptions.
*/
- void registerClientObserver(std::unique_ptr<ClientObserver> observer);
+ virtual void onDestroyClient(Client* client) = 0;
/**
- * Creates a new Client object representing a client session associated with this
- * ServiceContext.
+ * Hook called after a new operation context is created on a client by
+ * service->makeOperationContext(client) or client->makeOperationContext().
*
- * The "desc" string is used to set a descriptive name for the client, used in logging.
- *
- * If supplied, "p" is the communication channel used for communicating with the client.
+ * For a given operation context and registered instance of ClientObserver, if
+ * onCreateOperationContext returns without throwing an exception,
+ * onDestroyOperationContext will be called when "opCtx" is deleted.
*/
- UniqueClient makeClient(std::string desc, AbstractMessagingPort* p = nullptr);
+ virtual void onCreateOperationContext(OperationContext* opCtx) = 0;
/**
- * Creates a new OperationContext on "client".
+ * Hook called on a "opCtx" created by a service before deleting "opCtx".
*
- * "client" must not have an active operation context.
+ * Like a destructor, must not throw exceptions.
*/
- UniqueOperationContext makeOperationContext(Client* client);
+ virtual void onDestroyOperationContext(OperationContext* opCtx) = 0;
+ };
- //
- // Storage
- //
-
- /**
- * Register a storage engine. Called from a MONGO_INIT that depends on initializiation of
- * the global environment.
- * Ownership of 'factory' is transferred to global environment upon registration.
- */
- virtual void registerStorageEngine(const std::string& name,
- const StorageEngine::Factory* factory) = 0;
+ using ClientSet = unordered_set<Client*>;
+ /**
+ * Cursor for enumerating the live Client objects belonging to a ServiceContext.
+ *
+ * Lifetimes of this type are synchronized with client creation and destruction.
+ */
+ class LockedClientsCursor {
+ public:
/**
- * Returns true if "name" refers to a registered storage engine.
+ * Constructs a cursor for enumerating the clients of "service", blocking "service" from
+ * creating or destroying Client objects until this instance is destroyed.
*/
- virtual bool isRegisteredStorageEngine(const std::string& name) = 0;
+ explicit LockedClientsCursor(ServiceContext* service);
/**
- * Produce an iterator over all registered storage engine factories.
- * Caller owns the returned object and is responsible for deleting when finished.
- *
- * Never returns nullptr.
+ * Returns the next client in the enumeration, or nullptr if there are no more clients.
*/
- virtual StorageFactoriesIterator* makeStorageFactoriesIterator() = 0;
+ Client* next();
- virtual void initializeGlobalStorageEngine() = 0;
+ private:
+ stdx::unique_lock<stdx::mutex> _lock;
+ ClientSet::const_iterator _curr;
+ ClientSet::const_iterator _end;
+ };
- /**
- * Shuts down storage engine cleanly and releases any locks on mongod.lock.
- */
- virtual void shutdownGlobalStorageEngineCleanly() = 0;
+ /**
+ * Special deleter used for cleaning up OperationContext objects owned by a ServiceContext.
+ * See UniqueOperationContext, below.
+ */
+ class OperationContextDeleter {
+ public:
+ void operator()(OperationContext* opCtx) const;
+ };
- /**
- * Return the storage engine instance we're using.
- */
- virtual StorageEngine* getGlobalStorageEngine() = 0;
+ /**
+ * This is the unique handle type for Clients created by a ServiceContext.
+ */
+ using UniqueClient = std::unique_ptr<Client, ClientDeleter>;
- //
- // Global operation management. This may not belong here and there may be too many methods
- // here.
- //
+ /**
+ * This is the unique handle type for OperationContexts created by a ServiceContext.
+ */
+ using UniqueOperationContext = std::unique_ptr<OperationContext, OperationContextDeleter>;
- /**
- * Signal all OperationContext(s) that they have been killed.
- */
- virtual void setKillAllOperations() = 0;
+ virtual ~ServiceContext();
- /**
- * Reset the operation kill state after a killAllOperations.
- * Used for testing.
- */
- virtual void unsetKillAllOperations() = 0;
+ /**
+ * Registers an observer of lifecycle events on Clients created by this ServiceContext.
+ *
+ * See the ClientObserver type, above, for details.
+ *
+ * All calls to registerClientObserver must complete before ServiceContext
+ * is used in multi-threaded operation, or is used to create clients via calls
+ * to makeClient.
+ */
+ void registerClientObserver(std::unique_ptr<ClientObserver> observer);
- /**
- * Get the state for killing all operations.
- */
- virtual bool getKillAllOperations() = 0;
+ /**
+ * Creates a new Client object representing a client session associated with this
+ * ServiceContext.
+ *
+ * The "desc" string is used to set a descriptive name for the client, used in logging.
+ *
+ * If supplied, "p" is the communication channel used for communicating with the client.
+ */
+ UniqueClient makeClient(std::string desc, AbstractMessagingPort* p = nullptr);
- /**
- * @param i opid of operation to kill
- * @return if operation was found
- **/
- virtual bool killOperation(unsigned int opId) = 0;
+ /**
+ * Creates a new OperationContext on "client".
+ *
+ * "client" must not have an active operation context.
+ */
+ UniqueOperationContext makeOperationContext(Client* client);
- /**
- * Kills all operations that have a Client that is associated with an incoming user
- * connection, except for the one associated with txn.
- */
- virtual void killAllUserOperations(const OperationContext* txn) = 0;
+ //
+ // Storage
+ //
- /**
- * Registers a listener to be notified each time an op is killed.
- *
- * listener does not become owned by the environment. As there is currently no way to
- * unregister, the listener object must outlive this ServiceContext object.
- */
- virtual void registerKillOpListener(KillOpListenerInterface* listener) = 0;
+ /**
+ * Register a storage engine. Called from a MONGO_INIT that depends on initializiation of
+ * the global environment.
+ * Ownership of 'factory' is transferred to global environment upon registration.
+ */
+ virtual void registerStorageEngine(const std::string& name,
+ const StorageEngine::Factory* factory) = 0;
- //
- // Global OpObserver.
- //
+ /**
+ * Returns true if "name" refers to a registered storage engine.
+ */
+ virtual bool isRegisteredStorageEngine(const std::string& name) = 0;
- /**
- * Set the OpObserver.
- */
- virtual void setOpObserver(std::unique_ptr<OpObserver> opObserver) = 0;
+ /**
+ * Produce an iterator over all registered storage engine factories.
+ * Caller owns the returned object and is responsible for deleting when finished.
+ *
+ * Never returns nullptr.
+ */
+ virtual StorageFactoriesIterator* makeStorageFactoriesIterator() = 0;
- /**
- * Return the OpObserver instance we're using.
- */
- virtual OpObserver* getOpObserver() = 0;
+ virtual void initializeGlobalStorageEngine() = 0;
- /**
- * Returns the tick source set in this context.
- */
- TickSource* getTickSource() const;
+ /**
+ * Shuts down storage engine cleanly and releases any locks on mongod.lock.
+ */
+ virtual void shutdownGlobalStorageEngineCleanly() = 0;
- /**
- * Replaces the current tick source with a new one. In other words, the old tick source
- * will be destroyed. So make sure that no one is using the old tick source when
- * calling this.
- */
- void setTickSource(std::unique_ptr<TickSource> newSource);
+ /**
+ * Return the storage engine instance we're using.
+ */
+ virtual StorageEngine* getGlobalStorageEngine() = 0;
- protected:
- ServiceContext() = default;
+ //
+ // Global operation management. This may not belong here and there may be too many methods
+ // here.
+ //
- /**
- * Mutex used to synchronize access to mutable state of this ServiceContext instance,
- * including possibly by its subclasses.
- */
- stdx::mutex _mutex;
+ /**
+ * Signal all OperationContext(s) that they have been killed.
+ */
+ virtual void setKillAllOperations() = 0;
- private:
- /**
- * Returns a new OperationContext. Private, for use by makeOperationContext.
- */
- virtual std::unique_ptr<OperationContext> _newOpCtx(Client* client) = 0;
+ /**
+ * Reset the operation kill state after a killAllOperations.
+ * Used for testing.
+ */
+ virtual void unsetKillAllOperations() = 0;
- /**
- * Vector of registered observers.
- */
- std::vector<std::unique_ptr<ClientObserver>> _clientObservers;
- ClientSet _clients;
+ /**
+ * Get the state for killing all operations.
+ */
+ virtual bool getKillAllOperations() = 0;
- std::unique_ptr<TickSource> _tickSource;
- };
+ /**
+ * @param i opid of operation to kill
+ * @return if operation was found
+ **/
+ virtual bool killOperation(unsigned int opId) = 0;
/**
- * Returns true if there is a global ServiceContext.
+ * Kills all operations that have a Client that is associated with an incoming user
+ * connection, except for the one associated with txn.
*/
- bool hasGlobalServiceContext();
+ virtual void killAllUserOperations(const OperationContext* txn) = 0;
/**
- * Returns the singleton ServiceContext for this server process.
- *
- * Fatal if there is currently no global ServiceContext.
+ * Registers a listener to be notified each time an op is killed.
*
- * Caller does not own pointer.
+ * listener does not become owned by the environment. As there is currently no way to
+ * unregister, the listener object must outlive this ServiceContext object.
*/
- ServiceContext* getGlobalServiceContext();
+ virtual void registerKillOpListener(KillOpListenerInterface* listener) = 0;
+
+ //
+ // Global OpObserver.
+ //
/**
- * Sets the global ServiceContext. If 'serviceContext' is NULL, un-sets and deletes
- * the current global ServiceContext.
- *
- * Takes ownership of 'serviceContext'.
+ * Set the OpObserver.
*/
- void setGlobalServiceContext(std::unique_ptr<ServiceContext>&& serviceContext);
+ virtual void setOpObserver(std::unique_ptr<OpObserver> opObserver) = 0;
/**
- * Shortcut for querying the storage engine about whether it supports document-level locking.
- * If this call becomes too expensive, we could cache the value somewhere so we don't have to
- * fetch the storage engine every time.
+ * Return the OpObserver instance we're using.
*/
- bool supportsDocLocking();
+ virtual OpObserver* getOpObserver() = 0;
/**
- * Returns true if the storage engine in use is MMAPV1.
+ * Returns the tick source set in this context.
*/
- bool isMMAPV1();
-
- /*
- * Extracts the storageEngine bson from the CollectionOptions provided. Loops through each
- * provided storageEngine and asks the matching registered storage engine if the
- * collection/index options are valid. Returns an error if the collection/index options are
- * invalid.
- * If no matching registered storage engine is found, return an error.
- * Validation function 'func' must be either:
- * - &StorageEngine::Factory::validateCollectionStorageOptions; or
- * - &StorageEngine::Factory::validateIndexStorageOptions
+ TickSource* getTickSource() const;
+
+ /**
+ * Replaces the current tick source with a new one. In other words, the old tick source
+ * will be destroyed. So make sure that no one is using the old tick source when
+ * calling this.
*/
- Status validateStorageOptions(const BSONObj& storageEngineOptions,
- stdx::function<Status (const StorageEngine::Factory* const, const BSONObj&)> validateFunc);
+ void setTickSource(std::unique_ptr<TickSource> newSource);
+
+protected:
+ ServiceContext() = default;
- /*
- * Returns a BSONArray containing the names of available storage engines, or an empty
- * array if there is no global ServiceContext
+ /**
+ * Mutex used to synchronize access to mutable state of this ServiceContext instance,
+ * including possibly by its subclasses.
*/
- BSONArray storageEngineList();
+ stdx::mutex _mutex;
- /*
- * Appends a the list of available storage engines to a BSONObjBuilder for reporting purposes.
+private:
+ /**
+ * Returns a new OperationContext. Private, for use by makeOperationContext.
*/
- void appendStorageEngineList(BSONObjBuilder* result);
+ virtual std::unique_ptr<OperationContext> _newOpCtx(Client* client) = 0;
+
+ /**
+ * Vector of registered observers.
+ */
+ std::vector<std::unique_ptr<ClientObserver>> _clientObservers;
+ ClientSet _clients;
+
+ std::unique_ptr<TickSource> _tickSource;
+};
+
+/**
+ * Returns true if there is a global ServiceContext.
+ */
+bool hasGlobalServiceContext();
+
+/**
+ * Returns the singleton ServiceContext for this server process.
+ *
+ * Fatal if there is currently no global ServiceContext.
+ *
+ * Caller does not own pointer.
+ */
+ServiceContext* getGlobalServiceContext();
+
+/**
+ * Sets the global ServiceContext. If 'serviceContext' is NULL, un-sets and deletes
+ * the current global ServiceContext.
+ *
+ * Takes ownership of 'serviceContext'.
+ */
+void setGlobalServiceContext(std::unique_ptr<ServiceContext>&& serviceContext);
+
+/**
+ * Shortcut for querying the storage engine about whether it supports document-level locking.
+ * If this call becomes too expensive, we could cache the value somewhere so we don't have to
+ * fetch the storage engine every time.
+ */
+bool supportsDocLocking();
+
+/**
+ * Returns true if the storage engine in use is MMAPV1.
+ */
+bool isMMAPV1();
+
+/*
+ * Extracts the storageEngine bson from the CollectionOptions provided. Loops through each
+ * provided storageEngine and asks the matching registered storage engine if the
+ * collection/index options are valid. Returns an error if the collection/index options are
+ * invalid.
+ * If no matching registered storage engine is found, return an error.
+ * Validation function 'func' must be either:
+ * - &StorageEngine::Factory::validateCollectionStorageOptions; or
+ * - &StorageEngine::Factory::validateIndexStorageOptions
+ */
+Status validateStorageOptions(
+ const BSONObj& storageEngineOptions,
+ stdx::function<Status(const StorageEngine::Factory* const, const BSONObj&)> validateFunc);
+
+/*
+ * Returns a BSONArray containing the names of available storage engines, or an empty
+ * array if there is no global ServiceContext
+ */
+BSONArray storageEngineList();
+
+/*
+ * Appends a the list of available storage engines to a BSONObjBuilder for reporting purposes.
+ */
+void appendStorageEngineList(BSONObjBuilder* result);
} // namespace mongo