This repo hosts the source for Jet's dotnet new
templates.
Equinox only
These templates focus solely on Consistent Processing using Equinox Stores:
eqxweb
- Boilerplate for an ASP .NET Core 2 Web App, with an associated storage-independent Domain project using Equinox.eqxwebcs
- Boilerplate for an ASP .NET Core 2 Web App, with an associated storage-independent Domain project using Equinox, ported to C#.eqxtestbed
- Host that allows running back-to-back benchmarks when prototyping models using Equinox, using different stores and/or store configuration parameters.
Propulsion related
The following templates focus specifically on the usage of Propulsion
components:
-
proProjector
- Boilerplate for an Azure CosmosDb ChangeFeedProcessor (typically unrolling events fromEquinox.Cosmos
stores usingPropulsion.Cosmos
)-k
adds Optional projection to Apache Kafka usingPropulsion.Kafka
.-p
shows parallel consumption mode (where source is not stream-oriented; i.e. is not fromEquinox.Cosmos
) -
proConsumer
- Boilerplate for an Apache Kafka Consumer usingPropulsion.Kafka
. (typically consuming from an app produced withdotnet new proProjector -k
)
The bulk of the remaining templates have a consumer aspect, and hence involve usage of Propulsion
.
The specific behaviors carried out in reaction to incoming events often use `Equinox components
-
proReactor
- Boilerplate for an application that handles reactive actions ranging from publishing notifications via Kafka (simple, or summarising events through to driving follow-on actions implied by events (e.g., updating a denormalized view of an aggregate)Input options are:
- (default) dual mode CosmosDB ChangeFeed Processor and/or EventStore
$all
stream projector/reactor usingPropulsion.Cosmos
/Propulsion.EventStore
depending on whether the program is run withcosmos
ores
arguments --source changeFeedOnly
: removesEventStore
wiring from commandline processing--source kafkaEventSpans
: changes source to be Kafka Event Spans, as emitted fromdotnet new proProjector --kafka
The reactive behavior template has the following options:
- Default processing shows importing (in summary form) from an aggregate in
EventStore
or a CosmosDB ChangeFeedProcessor to a Summary form inCosmos
--blank
: remove sample Ingester logic, yielding a minimal projector--kafka
(without--blank
): adds Optional projection to Apache Kafka usingPropulsion.Kafka
(instead of ingesting into a localCosmos
store). Produces versioned Summary Event feed.--kafka --blank
: provides wiring for producing to Kafka, without summary reading logic etc
Miscellaneous options:
--filter
- include category filtering boilerplate
NOTE At present, checkpoint storage when projecting from EventStore uses Azure CosmosDB - help wanted ;)
- (default) dual mode CosmosDB ChangeFeed Processor and/or EventStore
-
summaryConsumer
- Boilerplate for an Apache Kafka Consumer usingPropulsion.Kafka
to ingest versioned summaries produced by adotnet new proReactor --kafka
-
trackingConsumer
- Boilerplate for an Apache Kafka Consumer usingPropulsion.Kafka
to ingest accumulating changes in anEquinox.Cosmos
store idempotently. -
proSync
- Boilerplate for a console app that that syncs events betweenEquinox.Cosmos
andEquinox.EventStore
stores using the relevantPropulsion
.* libraries, filtering/enriching/mapping Events as necessary.
-
eqxShipping
- Example demonstrating the implementation of a Process Manager usingEquinox
that manages the enlistment of a set ofShipment
Aggregate items into a separatedContainer
Aggregate as an atomic operation. 🙏 @Kimserey- processing is fully idempotent; retries, concurrent or overlapping transactions are intended to be handled thoroughly and correctly
- if any
Shipment
s cannot beReserved
, those that have been getRevoked
, and the failure is reported to the caller - includes a
Watchdog
console app (based ondotnet new proReactor --source changeFeedOnly --blank
) responsible for concluding abandoned transaction instances (e.g., where processing is carried out in response to a HTTP request and the Clients fails to retry after a transient failure leaves processing in a non-terminal state).
As dictated by the design of dotnet's templating mechanism, consumption is ultimately via the .NET Core SDK's dotnet new
CLI facility and/or associated facilities in Visual Studio, Rider etc.
To use from the command line, the outline is:
- Install a template locally (use
dotnet new --list
to view your current list) - Use
dotnet new
to expand the template in a given directory
# install the templates into `dotnet new`s list of available templates so it can be picked up by
# `dotnet new`, Rider, Visual Studio etc.
dotnet new -i Equinox.Templates
# --help shows the options including wiring for storage subsystems,
# -t includes an example Domain, Handler, Service and Controller to test from app to storage subsystem
dotnet new eqxweb -t --help
# if you want to see a C# equivalent:
dotnet new eqxwebcs -t
# see readme.md in the generated code for further instructions regarding the TodoBackend the above -t switch above triggers the inclusion of
start readme.md
# ... to add an Ingester that reacts to events, as they are written (via EventStore $all or CosmosDB ChangeFeedProcessor) summarising them and feeding them into a secondary stream
# (equivalent to pairing the Projector and Ingester programs we make below)
md -p ../DirectIngester | Set-Location
dotnet new proReactor
# ... to add a Projector
md -p ../Projector | Set-Location
# (-k emits to Kafka and hence implies having a Consumer)
dotnet new proProjector -k
start README.md
# ... to add a Generic Consumer (proProjector -k emits to Kafka and hence implies having a Consumer)
md -p ../Consumer | Set-Location
dotnet new proConsumer
start README.md
# ... to add an Ingester based on the events that Projector sends to kafka
# (equivalent in function to DirectIngester, above)
md -p ../Ingester | Set-Location
dotnet new proReactor --source kafkaEventSpans
# ... to add a Summary Projector
md -p ../SummaryProducer | Set-Location
dotnet new proReactor --kafka
start README.md
# ... to add a Custom Projector
md -p ../SummaryProducer | Set-Location
dotnet new proReactor --kafka --blank
start README.md
# ... to add a Summary Consumer (ingesting output from `SummaryProducer`)
md -p ../SummaryConsumer | Set-Location
dotnet new summaryConsumer
start README.md
# ... to add a Testbed
md -p ../My.Tools.Testbed | Set-Location
# -e -c # add EventStore and CosmosDb suppport to got with the default support for MemoryStore
dotnet new eqxtestbed -c -e
start README.md
# run for 1 min with 10000 rps against an in-memory store
dotnet run -p Testbed -- run -d 1 -f 10000 memory
# run for 30 mins with 2000 rps against a local EventStore
dotnet run -p Testbed -- run -f 2000 es
# run for two minutes against CosmosDb (see https://github.com/jet/equinox#quickstart) for provisioning instructions
dotnet run -p Testbed -- run -d 2 cosmos
# ... to add a Sync tool
md -p ../My.Tools.Sync | Set-Location
# (-m includes an example of how to upconvert from similar event-sourced representations in an existing store)
dotnet new proSync -m
start README.md
# ... to add a Shipping Domain example containing a Process Manager with a Watchdog Service
md -p ../Shipping | Set-Location
dotnet new eqxShipping
There's integration tests in the repo that check everything compiles before we merge/release
dotnet build build.proj # build Equinox.Templates package, run tests \/
dotnet pack build.proj # build Equinox.Templates package only
dotnet test build.proj # Test aphabetically newest file in bin/nupkgs only
One can also do it manually:
-
Generate the package (per set of changes you make locally)
a. ensuring the template's base code compiles (see runnable templates concept in
dotnet new
docs)b. packaging into a local nupkg
$ cd ~/dotnet-templates $ dotnet pack build.proj Successfully created package '/Users/me/dotnet-templates/bin/nupkg/Equinox.Templates.3.10.1-alpha.0.1.nupkg'.
-
Test, per variant
(Best to do this in another command prompt in a scratch area)
a. installing the templates into the
dotnet new
local repo$ dotnet new -i /Users/me/dotnet-templates/bin/nupkg/Equinox.Templates.3.10.1-alpha.0.1.nupkg
b. get to an empty scratch area
$ mkdir -p ~/scratch/templs/t1 $ cd ~/scratch/templs/t1
c. test a variant (i.e. per
symbol
in the config)$ dotnet new proReactor -k # an example - in general you only need to test stuff you're actually changing $ dotnet build # test it compiles $ # REPEAT N TIMES FOR COMBINATIONS OF SYMBOLS
-
uninstalling the locally built templates from step 2a:
$ dotnet new -u Equinox.Templates
Wherever possible, the samples strongly type identifiers, particularly ones that might naturally be represented as primitives, i.e. string
etc.
-
FSharp.UMX
is useful to transparently pin types in a message contract cheaply - it works well for a number of contexts:- Coding/decoding events using FsCodec. (because Events are things that have happened, validating them is not a central concern as we load and fold these incontrovertible Facts)
- Model binding in ASP.NET (because the types de-sugar to the primitives, no special support is required). Unlike events, there are more considerations in play in this context though; often you'll want to apply validation to the inputs (representing Commands) as you map them to Value Objects, Making Illegal States Unrepresentable. Often, Single Case Discriminated Unions can be a better tool inb that context
There are established conventions documented in Equinox's module Aggregate
overview
All the templates herein attempt to adhere to a consistent structure for the composition root module
(the one containing an Application’s main
), consisting of the following common elements:
Responsible for: Loading secrets and custom configuration, supplying defaults when environment variables are not set
Wiring up retrieval of configuration values is the most environment-dependent aspect of the wiring up of an application's interaction with its environment and/or data storage mechanisms. This is particularly relevant where there is variance between local (development time), testing and production deployments. For this reason, the retrieval of values from configuration stores or key vaults is not managed directly within the module Args
section
The Settings
module is responsible for the following:
- Feeding defaults into process-local Environment Variables, where those are not already supplied
- Encapsulating all bindings to Configuration or Secret stores (Vaults) in order that this does not have to be complected with the argument parsing or defaulting in
module Args
- DO (sparingly) rely on inputs from the command line to drive the lookup process
- DONT log values (
module Args
’sArguments
wrappers should do that as applicable as part of the wireup process) - DONT perform redundant work to load values if they’ve already been supplied via Environment Variables
Responsible for: mapping Environment Variables and the Command Line argv
to an Arguments
model
module Args
fulfils three roles:
- uses Argu to map the inputs passed via
argv
to values per argument, providing good error and/or help messages in the case of invalid inputs - responsible for managing all defaulting of input values including echoing them to console such that an operator can infer the arguments in force without having to go look up defaults in a source control repo
- expose an object model that the
build
orstart
functions can use to succinctly wire up the dependencies without needing to touchArgu
,Configuration
, or any concrete Configuration or Secrets storage mechanisms
- DO take values via Argu or Environment Variables
- DO log the values being applied, especially where defaulting is in play
- DONT log secrets
- DONT mix in any application or settings specific logic (no retrieval of values, don’t make people read the boilerplate to see if this app has custom secrets retrieval)
- DONT invest time changing the layout; leaving it consistent makes it easier for others to scan
- DONT be tempted to merge blocks of variables into a coupled monster - the intention is to (to the maximum extent possible) group arguments into clusters of 5-7 related items
- DONT reorder types - it'll just make it harder if you ever want to remix and/or compare and contrast across a set of programs
NOTE: there's a medium term plan to submit a PR to Argu extending it to be able to fall back to environment variables where a value is not supplied, by means of declarative attributes on the Argument specification in the DU, including having the --help
message automatically include a reference to the name of the environment variable that one can supply the value through
Responsible for applying logging config and setting up loggers for the application
- DO allow overriding of log level via a command line argument and/or environment variable (by passing
Args.Arguments
or values from it)
module Logging =
let initialize verbose =
Log.Logger <- LoggerConfiguration(….)
The start
function contains the specific wireup relevant to the infrastructure requirements of the microservice - it's the sole aspect that is not expected to adhere to a standard layout as prescribed in this section.
let start (args : Args.Arguments) =
…
(yields a started application loop)
The run
function formalizes the overall pattern. It is responsible for:
- Managing the correct sequencing of the startup procedure, weaving together the above elements
- managing the emission of startup or abnormal termination messages to the console
- DONT alter the canonical form - the processing is in this exact order for a multitude of reasons
- DONT have any application specific wire within
run
- any such logic should live within thestart
and/orbuild
functions - DONT return an
int
fromrun
; letmain
define the exit codes in one place
let run args =
use consumer = start args
consumer.AwaitCompletion() |> Async.RunSynchronously
consumer.RanToCompletion
[<EntryPoint>]
let main argv =
try let args = Args.parse argv
try Logging.initialize args.Verbose
try Configuration.initialize ()
if run args then 0 else 3
with e when not (e :? Args.MissingArg) -> Log.Fatal(e, "Exiting"); 2
finally Log.CloseAndFlush()
with Args.MissingArg msg -> eprintfn "%s" msg; 1
| :? Argu.ArguParseException as e -> eprintfn "%s" e.Message; 1
| e -> eprintf "Exception %s" e.Message; 1
Please don't hesitate to create a GitHub issue for any questions, so others can benefit from the discussion. For any significant planned changes or additions, please err on the side of reaching out early so we can align expectations - there's nothing more frustrating than having your hard work not yielding a mutually agreeable result ;)
See the Equinox repo's CONTRIBUTING section for general guidelines wrt how contributions are considered specifically wrt Equinox.
The following sorts of things are top of the list for the templates:
- Fixes for typos, adding of info to the readme or comments in the emitted code etc
- Small-scale cleanup or clarifications of the emitted code
- support for additional languages in the templates
- further straightforward starter projects
While there is no rigid or defined limit to what makes sense to add, it should be borne in mind that dotnet new eqx/pro*
is sometimes going to be a new user's first interaction with Equinox and/or [asp]dotnetcore. Hence there's a delicate (and intrinsically subjective) balance to be struck between:
- simplicity of programming techniques used / beginner friendliness
- brevity of the generated code
- encouraging good design practices
In other words, there's lots of subtlety to what should and shouldn't go into a template - so discussing changes before investing time is encouraged; agreed changes will generally be rolled out across the repo.