You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@isis.apache.org by da...@apache.org on 2014/07/25 14:29:59 UTC
svn commit: r1613410 - in /isis/site/trunk/content: documentation.md
reference/services/background-command-service.md
reference/services/background-service.md
reference/services/command-context.md reference/services/command-service.md
Author: danhaywood
Date: Fri Jul 25 12:29:58 2014
New Revision: 1613410
URL: http://svn.apache.org/r1613410
Log:
updating docs
Added:
isis/site/trunk/content/reference/services/background-command-service.md
isis/site/trunk/content/reference/services/command-service.md
Modified:
isis/site/trunk/content/documentation.md
isis/site/trunk/content/reference/services/background-service.md
isis/site/trunk/content/reference/services/command-context.md
Modified: isis/site/trunk/content/documentation.md
URL: http://svn.apache.org/viewvc/isis/site/trunk/content/documentation.md?rev=1613410&r1=1613409&r2=1613410&view=diff
==============================================================================
--- isis/site/trunk/content/documentation.md (original)
+++ isis/site/trunk/content/documentation.md Fri Jul 25 12:29:58 2014
@@ -278,6 +278,13 @@ Decouple business logic across modules u
{col-md-4
+#### <a name="domain-services-information-sharing">command context/background</a>
+
+Context in which actions invoked, infrastructure to run actions in background (asynchronously).
+
+* [Command Context](./reference/services/command-context.html) <a href="./reference/services/command-context.html#screencast"><img src="./images/tv_show-25.png"></a>
+* [Background Service](./reference/services/background-service.html)
+
#### <a name="domain-services-information-sharing">Information sharing</a>
@@ -318,14 +325,14 @@ Co-ordinate sharing of information acros
#### <a name="isis-module-auditing">Auditing</a>
-* [Auditing Service](./reference/services/auditing-service.html)
+* [Auditing](./reference/services/auditing-service.html)
#### <a name="isis-module-command">Commands</a>
-<i>for profiling/background execution/extended auditing</i>
+Profiling/background execution/extended auditing.
-* [Command Context/Service](./reference/services/command-context.html) <a href="./reference/services/command-context.html#screencast"><img src="./images/tv_show-25.png"></a>
-* [Background Service / Background Command Service](./reference/services/background-service.html)
+* [Command Service](./reference/services/command-service.html) <a href="./reference/services/command-context.html#screencast"><img src="./images/tv_show-25.png"></a>
+* [Background Command Service](./reference/services/background-command-service.html)
}
Added: isis/site/trunk/content/reference/services/background-command-service.md
URL: http://svn.apache.org/viewvc/isis/site/trunk/content/reference/services/background-command-service.md?rev=1613410&view=auto
==============================================================================
--- isis/site/trunk/content/reference/services/background-command-service.md (added)
+++ isis/site/trunk/content/reference/services/background-command-service.md Fri Jul 25 12:29:58 2014
@@ -0,0 +1,111 @@
+Title: Background Command Service (isis-module-command-jdo)
+
+The `BackgroundCommandService` supports the [BackgroundService](./background-service.html), persisting action invocations as commands such that they can subsequently be invoked in the background.
+
+The `BackgroundService` is responsible for capturing a memento representing the action invocation, and then hands off to the `BackgroundCommandService` to actually persist it. The `isis-module-command-jdo` module provides an implementation of `BackgroundCommandService` ([BackgroundCommandServiceJdo](../../components/objectstores/jdo/services/background-command-service-jdo.html)) that persists to an RBMS entities.
+
+The persisting of commands is only half the story; there needs to be a separate process to read the commands and execute them. The abstract [BackgroundCommandExecution](./background-service.html#BackgroundCommandExecution) provides a mechanism to do this; the `isis-module-command-jdo` provides a concrete subclass (`BackgroundCommandExecutionFromBackgroundCommandServiceJdo`) that knows how to query for persisted (background) `Command`s such that they can be executed by a scheduler.
+
+
+## BackgroundCommandService
+
+The `BackgroundCommandService` typically isn't called from domain classes, but it exists as a domain service so that it is pluggable into `BackgroundService`.
+
+
+### API
+
+The API of the `BackgroundCommandService` is:
+
+ public interface BackgroundCommandService {
+
+ public void schedule(
+ final ActionInvocationMemento aim,
+ final Command command,
+ final String targetClassName, final String targetActionName, final String targetArgs);
+
+ }
+
+where `ActionInvocationMemento` is a wrapper around a [MementoService](./memento-service.html)'s `Memento`, capturing the details of an action invocation (for execution later on).
+
+For the record, the API of `ActionInvocationMemento` is:
+
+ public class ActionInvocationMemento {
+
+ public String getActionId() { ... }
+ public String getTargetClassName() { ... }
+ public String getTargetActionName() { ... }
+ public Bookmark getTarget() { ... }
+ public int getNumArgs() { ... }
+ public Class<?> getArgType(final int num) throws ClassNotFoundException { ... }
+ public <T> T getArg(final int num, final Class<T> type) { ... }
+
+ public String asMementoString() { ... }
+ }
+
+The `asMementoString()` method therefore lets the `BackgroundCommandService` implementation convert the action invocation into a simple string.
+
+
+### Implementation
+
+The `isis-module-command-jdo` module provides the [BackgroundCommandServiceJdo](../../components/objectstores/jdo/services/background-command-service-jdo.html) implementation that persists `Command`s to an RDBMS.
+
+There is also a supporting repository to query persisted background `Command`s:
+
+* `org.apache.isis.objectstore.jdo.applib.service.background.BackgroundCommandServiceJdoRepository`
+
+In addition, there is a supporting contributions service that contributes actions for searching for persisted child and sibling `Command`s:
+
+* `org.apache.isis.objectstore.jdo.applib.service.background.BackgroundCommandServiceJdoContributions`
+
+
+### Usage
+
+As noted above, this service isn't intended to be called from domain classes; rather it acts as a plug-in point to the default `BackgroundServiceDefault` service.
+
+
+## Related Services
+
+As discussed above, this service supports the [BackgroundService](./background-service.html), persisting `Command`s such that they can be executed in the background.
+
+There is also a tie-up with the [CommandContext](./command-context.html) and its supporting `CommandService` service. The `CommandContext` service is responsible for providing a parent `Command` with which the background `Command`s can then be associated as children, while the `CommandService` is responsible for persisting those parent `Command`s (analogous to the way in which the `BackgroundCommandService` persists the child background `Command`s). The `BackgroundCommandService` ensures that these background `Command`s are associated with the parent "foreground" `Command`.
+
+What that means is that the implementations of `CommandService` and `BackgroundCommandService` go together, hence both implemented in the `isis-module-command-jdo` module: ([CommandServiceJdo](../../components/objectstores/jdo/services/command-service-jdo.html) and [BackgroundCommandServiceJdo](../../components/objectstores/jdo/services/background-command-service-jdo.html)).
+
+
+## BackgroundCommandExecution concrete implementation
+
+The `BackgroundCommandExecution` (in isis-core) is an abstract template class provided by isis-core that defines an abstract hook method to obtain background `Command`s to be executed:
+
+ public abstract class BackgroundCommandExecution
+ extends AbstractIsisSessionTemplate {
+ ...
+ protected abstract List<? extends Command> findBackgroundCommandsToExecute();
+ ...
+ }
+
+The developer is required to implement this hook method in a subclass.
+
+The `isis-module-command-jdo` module provides a concrete subclass that queries for commands persisted by its `BackgroundCommandServiceJdo`, namely:
+
+* `org.apache.isis.objectstore.jdo.service.BackgroundCommandExecutionFromBackgroundCommandServiceJdo`
+
+
+
+## Quartz Scheduler Configuration
+
+Details are provided on the [BackgroundService](./background-service.html) page.
+
+
+
+## Registering the Services
+
+Assuming that the `configuration-and-annotation` services installer is configured:
+
+ isis.services-installer=configuration-and-annotation
+
+then the `BackgroundCommandServiceJdo` and `BackgroundCommandJdoRepository` services are automatically registered if the `isis-module-command-jdo` module is on the classpath. The `BackgroundCommandServiceJdoContributions` service (because it influences the user interface) must be explicitly registered:
+
+ isis.services=...,\
+ org.apache.isis.objectstore.jdo.applib.service.background.BackgroundCommandServiceJdoContributions,\
+ ...
+
Modified: isis/site/trunk/content/reference/services/background-service.md
URL: http://svn.apache.org/viewvc/isis/site/trunk/content/reference/services/background-service.md?rev=1613410&r1=1613409&r2=1613410&view=diff
==============================================================================
--- isis/site/trunk/content/reference/services/background-service.md (original)
+++ isis/site/trunk/content/reference/services/background-service.md Fri Jul 25 12:29:58 2014
@@ -2,12 +2,10 @@ Title: Background Service
The `BackgroundService`, and its companion `BackgroundCommandService`, enable action invocations to be persisted such that they may be invoked in the background.
-The `BackgroundService` is responsible for capturing a memento representing the action invocation, and persisting it. The default `BackgroundServiceDefault` implementation (provided by isis-core) uses (a private copy of) [MementoService](./memento-service.html), and then delegates the persistence of the memento to the companion `BackgroundCommandService` (discussed further [below](#BackgroundCommandService)).
+The `BackgroundService` is responsible for capturing a memento representing the action invocation, and persisting it. The default `BackgroundServiceDefault` implementation (provided by isis-core) uses (a private copy of) [MementoService](./memento-service.html), and then delegates the persistence of the memento to an appropriate implementation of the companion `BackgroundCommandService`. One such implementation is `isis-module-command-jdo`'s [BackgroundCommandServiceJdo](./background-command-service.html).
-The JDO objectstore provides an implementation of `BackgroundCommandService` ([BackgroundCommandServiceJdo](../../components/objectstores/jdo/services/background-command-service-jdo.html)) that persists to an RBMS entities. You are welcome to write other implementations to other data stores (eg NoSQL) if required.
-
-The persisting of commands is only half the story; there needs to be a separate process to read the commands and execute them. The `BackgroundCommandExecution` class (also discussed [below](#BackgroundCommandExecution) provides the mechanism to do this.
-
+The persisting of commands is only half the story; there needs to be a separate process to read the commands and execute them. The `BackgroundCommandExecution` abstract class (discussed [below](#BackgroundCommandExecution) provides infrastructure to do this; the concrete
+implementation of this class depends on the configured `BackgroundCommandService` (in order to query for the persisted (background) `Command`s.
## BackgroundService
@@ -68,64 +66,14 @@ We could therefore refactor the method a
where `commandContext` field is the injected `CommandContext` domain service.
-## BackgroundCommandService
-
-The `BackgroundCommandService` is a companion to the default `BackgroundServiceDefault` implementation, and takes responsibility for persisting the required action as a background command.
-
-Typically this service isn't called from domain classes, but it exists as a domain service so that it is pluggable.
-
-
-### API
-
-The API of the `BackgroundCommandService` is:
-
- public interface BackgroundCommandService {
-
- public void schedule(
- final ActionInvocationMemento aim,
- final Command command,
- final String targetClassName, final String targetActionName, final String targetArgs);
-
- }
-
-where `ActionInvocationMemento` is a wrapper around a [MementoService](./memento-service.html)'s `Memento`, capturing the details of an action invocation (for execution later on).
-
-For the record, the API of `ActionInvocationMemento` is:
-
- public class ActionInvocationMemento {
-
- public String getActionId() { ... }
- public String getTargetClassName() { ... }
- public String getTargetActionName() { ... }
- public Bookmark getTarget() { ... }
- public int getNumArgs() { ... }
- public Class<?> getArgType(final int num) throws ClassNotFoundException { ... }
- public <T> T getArg(final int num, final Class<T> type) { ... }
-
- public String asMementoString() { ... }
- }
-
-The `asMementoString()` method tehrefore lets the `BackgroundCommandService` implementation convert the action invocation into a simple string.
-
-
-### Implementation
-
-The JDO object store provides the [BackgroundCommandServiceJdo](../../components/objectstores/jdo/services/background-command-service-jdo.html) implementation that persists `Command`s to an RDBMS.
-
-
-### Usage
-
-As noted above, this service isn't intended to be called from domain classes; rather it acts as a plug-in point to the default `BackgroundServiceDefault` service.
-
## Related Services
-These services are closely related to the `CommandContext` and `CommandService` services (both described [here]](./command-context.html) services. The `CommandContext` service is responsible for providing a parent `Command` with which the background `Command`s can then be associated as children, while the `CommandService` is responsible for persisting those parent `Command`s (analogous to the way in which the `BackgroundCommandService` persists the child background `Command`s).
+This service is closely related to the [CommandContext](./command-context.html) and also that service's supporting [CommandService](./command-service.html) service. The `CommandContext` service is responsible for providing a parent `Command` with which the background `Command`s can then be associated as children, while the `CommandService` is responsible for persisting those parent `Command`s. The latter is analogous to the way in which the `BackgroundCommandService` persists the child background `Command`s.
-The core framework provides default implementations of `CommandContext` and also `BackgroundService`, and there is very little reason to use any other implementation.
-
-The implementations of `CommandService` and `BackgroundCommandService` also go together; typically both parent `Command`s and child background `Command`s will be persisted in the same way. The JDO objectstore provides implementations of both ([CommandServiceJdo](../../components/objectstores/jdo/services/command-service-jdo.html) and [BackgroundCommandServiceJdo](../../components/objectstores/jdo/services/background-command-service-jdo.html)).
+The implementations of `CommandService` and `BackgroundCommandService` go together; typically both parent `Command`s and child background `Command`s will be persisted in the same way. The `isis-module-command-jdo` module provides implementations of both (see [CommandServiceJdo](../../components/objectstores/jdo/services/command-service-jdo.html) and [BackgroundCommandServiceJdo](../../components/objectstores/jdo/services/background-command-service-jdo.html)).
-## BackgroundCommandExecution
+
+## BackgroundCommandExecution abstract class
The `BackgroundCommandExecution` (in isis-core) is an abstract template class provided by isis-core that defines an abstract hook method to obtain background `Command`s to be executed:
@@ -136,20 +84,14 @@ The `BackgroundCommandExecution` (in isi
...
}
-The developer is required to implement this hook method in a subclass.
-
-If using the JDO implementation of `BackgroundCommandService`, then this subclass exists already, namely:
-
-* `org.apache.isis.objectstore.jdo.service.BackgroundCommandExecutionFromBackgroundCommandServiceJdo`
-
-This returns all background `Command`s that are not yet started.
+The developer is required to implement this hook method in a subclass. The `isis-module-command-jdo` module provides a suitable concrete implementation.
## Quartz Scheduler Configuration
The last part of the puzzle is to actually run this class. These could be run in a batch job overnight, or run continually by, say, the [Quartz](http://quartz-scheduler.org) scheduler. For the latter case, we want to define a Quartz cron job that will inherit the `execute(...)` method of `BackgroundCommandExecution` (inherited from *its* superclass, `AbstractIsisSessionTemplate`).
-The following does the trick:
+If using the `isis-module-command-jdo`, then the following does the trick:
import org.apache.isis.objectstore.jdo.service.BackgroundCommandExecutionFromBackgroundCommandServiceJdo;
@@ -290,6 +232,8 @@ and the entry in `web.xml` for the Quart
</servlet>
+
+<!--
All of this stuff is configured in the example todo app, found on github (as of Isis 1.5.0):
* [BackgroundCommandExecutionQuartzJob](https://github.com/apache/isis/blob/isis-1.5.0/example/application/quickstart_wicket_restful_jdo/webapp/src/main/java/webapp/scheduler/BackgroundCommandExecutionQuartzJob.java)
@@ -297,17 +241,14 @@ All of this stuff is configured in the e
* [quartz-config.xml](https://github.com/apache/isis/blob/isis-1.5.0/example/application/quickstart_wicket_restful_jdo/webapp/src/main/resources/webapp/scheduler/quartz-config.xml)
* [quartz.properties](https://github.com/apache/isis/blob/isis-1.5.0/example/application/quickstart_wicket_restful_jdo/webapp/src/main/resources/webapp/scheduler/quartz.properties)
* [web.xml](https://github.com/apache/isis/blob/isis-1.5.0/example/application/quickstart_wicket_restful_jdo/webapp/src/main/webapp/WEB-INF/web.xml#L308)
+-->
## Registering the Services
-Register like any other service in `isis.properties`. For example, if using the default implementation of `BackgroundService` and the JDO implementation of `BackgroundCommandService`, it would be:
+Assuming that the `configuration-and-annotation` services installer is configured:
+
+ isis.services-installer=configuration-and-annotation
- isis.services=...,\
- org.apache.isis.core.runtime.services.background.BackgroundServiceDefault,\
- org.apache.isis.objectstore.jdo.applib.service.background.BackgroundCommandServiceJdo,\
- org.apache.isis.objectstore.jdo.applib.service.background.BackgroundCommandServiceJdoRepository,\
- org.apache.isis.objectstore.jdo.applib.service.background.BackgroundCommandServiceJdoContributions,\
- ...
+then Isis' core implementation of `BackgroundService` will be automatically registered and injected into your entities/services.
-Note that the JDO implementation provides additional supporting `...Repository` and `...Contributions` services to query for and render background `Command`s.
Modified: isis/site/trunk/content/reference/services/command-context.md
URL: http://svn.apache.org/viewvc/isis/site/trunk/content/reference/services/command-context.md?rev=1613410&r1=1613409&r2=1613410&view=diff
==============================================================================
--- isis/site/trunk/content/reference/services/command-context.md (original)
+++ isis/site/trunk/content/reference/services/command-context.md Fri Jul 25 12:29:58 2014
@@ -1,9 +1,9 @@
-Title: CommandContext and CommandService
+Title: CommandContext
The `CommandContext` service is a [request-scoped](../../more-advanced-topics/how-to-09-020-How-to-write-a-typical-domain-service.html) service that reifies the invocation of an action on a domain object into an object itself. This reified information is encapsulated within the `Command` object.
By default, the `Command` is held in-memory only; once the action invocation has completed, the `Command` object is gone. The optional
- supporting `CommandService` enables the implementation of `Command` to be pluggable. With an appropriate implementation (eg the JDO implementation, described below) the `Command` may then be persisted.
+ supporting `CommandService` enables the implementation of `Command` to be pluggable. With an appropriate implementation (eg as provided by the `isis-command-module-jdo`'s [CommandServiceJdo](./command-service.html)) the `Command` may then be persisted.
Persistent `Command`s support several use cases:
@@ -91,13 +91,7 @@ The `CommandContext` implementation is p
#### CommandService (for persistent `Command`s)
-The `CommandService` interface - which acts as the factory for different `Command` implementations - is pluggable. Currently there is only a single implementation, provided by the JDO objectstore, which persists `Command`s to an RDBMS:
-
-* `org.apache.isis.objectstore.jdo.applib.service.command.CommandServiceJdo`
-
-There is also a supporting repository to query persisted `Command`s:
-
-* `org.apache.isis.objectstore.jdo.applib.service.command.CommandServiceJdoRepository`
+The `CommandService` interface - which acts as the factory for different `Command` implementations - is pluggable. The [isis-module-command-jdo](command-service.html) implementation persists `Command`s to an RDBMS.
## Usage
@@ -126,6 +120,8 @@ The annotation can also be used to speci
When a background command is invoked, the user is returned the command object itself (to provide a handle to the command being invoked).
+This requires that an implementation of `CommandService` that persists the commands (such as `isis-module-command-jdo`'s `CommandService` [implementation](./command-service.html)) is configured. It also requires that a scheduler is configured to execute the background commands, see [BackgroundCommandService](./background-command-service.html)).
+
#### Making commands the default
As an alternative to annotating every action with `@Command`, alternatively this can be configured as the default.
@@ -149,7 +145,7 @@ To disable globally, use:
If the key is not present in `isis.properties`, then commands are disabled by default.
-#### Interating with the services
+#### Interacting with the services
Typically the domain objects have little need to interact with the `CommandContext` and `Command` directly; what is more useful is that these are persisted in support of the various use cases identified above.
@@ -172,17 +168,15 @@ The domain object can still obtain the o
## Registering the Services
-Register like any other service in `isis.properties`. For example, if using the core `CommandContext` service along with the [JDO implementation](../../components/objectstores/jdo/services/command-service-jdo.html) of the `CommandService`, then it would be:
+Assuming that the `configuration-and-annotation` services installer is configured:
+
+ isis.services-installer=configuration-and-annotation
- isis.services=...,\
- org.apache.isis.applib.services.command.CommandContext,\
- org.apache.isis.objectstore.jdo.applib.service.command.CommandServiceJdo,\
- org.apache.isis.objectstore.jdo.applib.service.command.CommandServiceJdoRepository,\
- ...
+then the `CommandContext` service is automatically registered and injected into your entities/services; no further configuration is required.
## Related Services
-These services are most often used in conjunction with the `BackgroundService` and `BackgroundCommandService` (both described [here](./background-service.html)). For `BackgroundService` captures commands for execution in the background, while the [BackgroundCommandService] persists such commands for execution.
+As discussed above, the supporting [CommandService](./command-service.html) enables `Command` objects to be persisted. Other related services are the [BackgroundService](./background-service.html) and [BackgroundCommandService](./background-service.html)). For `BackgroundService` captures commands for execution in the background, while the [BackgroundCommandService] persists such commands for execution.
The implementations of `CommandService` and `BackgroundCommandService` are intended to go together, so that persistent parent `Command`s can be associated with their child background `Command`s.
Added: isis/site/trunk/content/reference/services/command-service.md
URL: http://svn.apache.org/viewvc/isis/site/trunk/content/reference/services/command-service.md?rev=1613410&view=auto
==============================================================================
--- isis/site/trunk/content/reference/services/command-service.md (added)
+++ isis/site/trunk/content/reference/services/command-service.md Fri Jul 25 12:29:58 2014
@@ -0,0 +1,85 @@
+Title: CommandService (isis-module-command-jdo)
+
+The `CommandService` service supports the [CommandContext](./command-context.html) service such that `Command` objects (that reify the invocation of an action on a domain object into an object) can be persisted.
+
+Persistent `Command`s support several use cases:
+
+- they enable profiling of the running application (which actions are invoked then most often, what is their response time)
+- they act as a parent to any background commands that might be invoked through the [BackgroundService](./background-service.html)
+- if [auditing](./auditing-service.html) is configured, they provide better audit informatio, since the `Command` (the 'cause' of an action) can be correlated to the audit records (the "effect" of the action) through the unique `transactionId` GUID
+- if [publishing](./publishing-service.html) is configured, they provide better traceability as the `Command` is also correlated with any published events, again through the unique `transactionId` GUID
+- the associated [@Command](../recognized-annotations/Command.html) annotation also allows action invocations to be performed in the background. In this case the act of invoking the action on an object instead returns the `Command` to the user.
+
+## <a name="screencast">Screencast</a>
+
+The screencast provides a run-through of the command (profiling) service, auditing service, publishing service. It also shows how commands can be run in the background either explicitly by scheduling through the background service or implicitly by way of a framework annotation.
+
+<iframe width="560" height="315" src="//www.youtube.com/embed/tqXUZkPB3EI" frameborder="0" allowfullscreen></iframe>
+
+
+## API
+
+The `CommandService` service defines the following very simple API:
+
+ public interface CommandService {
+
+ @Programmatic
+ Command create();
+
+ @Programmatic
+ void startTransaction(final Command command, final UUID transactionId);
+
+ @Programmatic
+ void complete(final Command command);
+
+ @Programmatic
+ boolean persistIfPossible(Command command);
+
+ }
+
+where `Command` is defined as defined by the [CommandContext](./command-context.html) service.
+
+
+
+## Implementation
+
+#### CommandService (for persistent `Command`s)
+
+The `CommandService` interface (defined in the Isis applib) is implemented within `isis-module-command-jdo` by:
+
+* `org.apache.isis.objectstore.jdo.applib.service.command.CommandServiceJdo`
+
+There is also a supporting repository to query persisted `Command`s:
+
+* `org.apache.isis.objectstore.jdo.applib.service.command.CommandServiceJdoRepository`
+
+In addition, there is a supporting contributions service that contributes actions for searching for persisted `Command`s for any object:
+
+* `org.apache.isis.objectstore.jdo.applib.service.command.CommandServiceJdoContributions`
+
+
+## Usage
+
+
+## Registering the Services
+
+Assuming that the `configuration-and-annotation` services installer is configured:
+
+ isis.services-installer=configuration-and-annotation
+
+then the `CommandServiceJdo` and `CommandServiceJdoRepository` services are automatically registered if the `isis-module-command-jdo` module
+is on the classpath. The `CommandServiceJdoContributions` service (because it influences the user interface) must be explicitly
+registered:
+
+
+ isis.services=...,\
+ org.apache.isis.objectstore.jdo.applib.service.command.CommandServiceJdoContributions,\
+ ...
+
+
+## Related Services
+
+As discussed above, this service supports the [CommandContext](./command-context.html), providing the ability for `Command` objects to be
+persisted. This is closely related to the [BackgroundCommandService](./background-command-service.html) that allows the [BackgroundService](./background-service.html)) to schedule commands for background/asynchronous execution.
+
+The implementations of `CommandService` and `BackgroundCommandService` are intended to go together, so that persistent parent `Command`s can be associated with their child background `Command`s.