Condense is a reliable event driven architecture implementation, leveraging a durable persistence store, with flexible integration options.
You provide an in-code description of your business data model and process in a regular .Net assembly project, referred to as your business domain. This domain assembly can then be hosted by a Runtime which fulfills the promises of the framework. This could be the in-process Condense Light framework, the SaaS Condense Cloud offering, or a private cluster.
Condense provides your application three key capabilities to in relation to your business domain. These are:
Storage and retrieval of your data,
Executing code in response to new or changed data,
Hiding complexity of underlying processes behind interfaces.
Additionally, the Condense framework records how each entity was created, the specific code that was run, and which entities were used as inputs to the process. This provides a strict causality tree (in conjunction with revisioning), which provides complete traceability for every piece of business data, and replayability for every part of your business process. It also provides significant benefits when it comes to selection of related data.
Condense also provides many other features such as data retention policies, and even multiple simultaneous code versions.
Condense aims to be a zero-boilerplate framework. For a simple business application there will be very little configuration - we only require you to positively identify your data classes and methods that should be executed in response to your changing data.
Your business data should be declared as a plain C#1 object, referred to as a business entity. This entire object is serialized and stored as a document - it may contain complex properties such as lists and dictionaries. These documents are able to be queried and retrieved as expected, contain references to other documents, and have their changes tracked. You identify these classes by adding the
In addition to typical queries, you are also able to easily consider the causality of your entities, eg: selecting Purchase Orders which have not caused a Shipment.
Additional reading: Entities, Context, and the IUnitOfWork. This document will also describe the important concept of context in detail.
To have the runtime execute code in response to the arrival of new or changed data, you must declare a method with an entity parameter and decorate it with the
[Lambda] attribute. These methods are referred to as lambda methods. They may take in additional entity parameters, which are filled according to various default rules, which you can change using attributes. If this method returns an entity or an enumerable, the resulting entities will be stored and may trigger additional lambdas to be executed. Execution may be reliably deferred in times ranging from minutes to months, as delayed actions, or to timeout waiting for parameters.
A lambda method runs asynchronously in an isolated transaction. When triggered it is guaranteed to execute and complete, on failure it will rollback and be retried. In a hosted cluster, your business process will become fault-tolerant, based on proven technology from Couchbase and AWS.
Additional reading: Lambda Execution. This document will detail how the context mentioned above is leveraged in selection of multiple parameters.
An entire business process may take weeks to complete, yet a given perspective may only be interested in a small subset. Applications that interact with a business domain may wish to simply create new facts for the domain to process, or to subscribe to specific events of new data arriving. Condense supports these situations.
In addition, a client application may provide an interface that describes how it wishes to view it’s interaction with the domain.
Condense will dynamically implement an appropriate method to fulfil the contract specified by the interface - for example a method which takes a Client and a LoanApplication and returns a LendingDecision. There does not need to be any direct link between these business entities. The runtime will store and publish the new data, subscribe and await the appropriate result. The application is isolated from the domain. The result the application is waiting on may not be the end of this business process; in fact the input parameters to this method could be the continuation of an existing process.
Nevertheless, code that is using the integration point is isolated from domain internals, not just in terms of reliability, but in relation to process changes as the business evolves. As long as the return type is still expected to be produced in a reasonable time frame, this client code will be unaffected.
Your interface definitions are plain C# interfaces. An implementation is provided to you by the Runtime in-process, or provided as a web endpoint for cluster based hosts.
Additional reading: Integration. This document will detail integration interfaces, and how to flow external causality and context into the Runtime.
A domain assembly built for the Condense Framework will run on any runtime, and will scale with it, without modification.
An in-process runtime
Use the benefits of the Condense framework inside your own application. Using the Couchbase-backed storage provider it supports the durability and performance of a Couchbase cluster. Light uses a fast in-memory queue provider and manages its own worker threads, making it as reliable as the application it is running inside.
This runtime is initialized with a single line of code, and the only configuration required is the storage URI. Direct references to any integration interface are provided on-demand.
Scalable & guaranteed event processing
Clients will run their own clustered solution using an AWS Marketplace machine image which supports auto-configuration. Billing will be handled by AWS, and priced as a percentage on top of their EC2 rates, allowing maximum flexibility.
A minimal amount of configuration is set in EC2 metadata (data store url, bucket name), which allows Condense to bootstrap itself from an S3 bucket. Integration endpoints will be exposed as web API.
This supports auto-scaling using Elastic Beanstalk, and AWS features such as API Gateway, Virtual Private Cloud, and GovCloud.
Custom in-house scalability
Clients will be provided Condense server software, equivalent to the Condense Cloud solution. This will allow use of the Framework where a cloud solution is inappropriate.
Condense is designed to allow interchangeable providers for storage and queues. You will have the choice of using existing supported infrastructure, or we can assist with developing drivers for your existing queues, event bus, and storage. Source code will be available.
Private Cluster applications can use the existing standards for exposing integration services as web API, or we can assist with integrating Condense into a more complex web service application. The architecture allows a split between integration and worker nodes, increasing deployment flexibility.
+15%on AWS EC2 rate
Negotiated FeeSoftware + customization