Dundee.Core 0.0.9.8

Dundee.Framework

Built using:

• https://github.com/dotnet/orleans
• https://github.com/OrleansContrib/Orleans.Providers.RabbitMQ
• https://github.com/OrleansContrib/Orleans.Providers.MongoDB
• https://github.com/OrleansContrib/Orleans.EventSourcing.Snapshot
• Coffee, trial and error!

This was a playground excercise but feedback would be appreciated.

A wrapper framework for working with Orleans, event driven architecture, with RMQ.

This includes

• A ready to go example with various ways of doing similar things (everyone has their own flavour!)
• Some primitive ways of keeping a queryable index (this is on the todo list)
• GraphQL

Setup

Clone repo, have docker installed and run the docker-compose up

Key points

### startup.cs

public void ConfigureServices(IServiceCollection services)
{
            services.AddRequiredServices(Environment, Configuration, "Dundee.Api", "1");

            services.AddOrleansServices(Configuration);

            services.AddScoped<IPublishingService, PublishingService>();

            //Graph QL
            services.AddScoped<CustomerQuery>();
            services.AddScoped<CustomerMutation>();
            services.AddScoped<CustomerSchema>();

            //Dundee
            services.AddScoped<IAdapterProcessor, OrleansProcessor>();
            services.AddScoped<CustomerAdapter>();
            services.AddScoped<PurchaseOrderAdapter>();
        }
}

Todo/whats left

• Decide how to package up hardcoded orleans projects for storage and rmq
• Versioning events (Its done but there isnt a proven way to handle this as its based on serialization)
• Code generator assumes that the same structure has been followed and could be improved/less brittle
• Code generators for indexing? Use cachealot? Create queryable props for the aggregate of each state prop (this could later enhanced with an attrib so that large data sets are stored elsewhere)
• Use of projections via eventstore (think destroying data by meta data)
• Replaying events so they publish to indexing (this might already be in but it would be costly)
• Tidy up code examples
• Demonstrate production config
• Introduce auto mapper to simplfy gql (or provide an example that maps directly to the aggregate state)
• Introduce an alternative processor (experimentally remove orleans)
• Look at projecting to sql and dynamic EF migrations (see nuget package).
• Add unit tests to framework
• Add further tests using docker compose
• Look at compositions (keeping the grains small works best)
• Change project for MongoDb (experimentally using gridfs however no evidence this is needed and should be seen as not for production)
• GQL aggregation
• Code linting and scanning
• Large object attribute that can be stored and streamed on demand
• Scan for all other Todos!

Remarks/Questions

There is a good amount of refactoring to do in some key areas which I intend to cover over time as I think this could be a useful way to get the benefits Orleans, EDA and GQL without an overly exhaustive uphill climb.

Also there some direct copies of other projects namely https://github.com/OrleansContrib/Orleans.Providers.MongoDB and https://github.com/OrleansContrib/Orleans.Providers.RabbitMQ that I need to review as their great work, alongside the work of the Orleans project, is what drove this forward the first place!