Fun

Like Lambda and Functions, but Fun^*.

Getting started

Implement a micro-service in a functional style as IFun

public class TabulateEvents : IFun
{
    public Task<MyDocument> Run (FunContext context, MyEvent input)
    {
        context.Logger.LogInformation(input.Description);

        if (input.Type == "Add") return new MyDocument{ Sum = input.Value1 + input Value2 };
        else return new MyDocument{ Sum = input.Value1 - input Value2 };
    } 
}

Implement a binding by inheriting from FunBinding

public class MyBinding : FunBinding
{
    public override async Task Bind() 
    {
        //...
    }
}

Map Functions to Bindings

app.UseFun<TabulateEvents, MyBinding>();

Build as a console exe and run anywhere that .NET Core is supported.

Fun

IFun promotes SOLID principles and Functional programming techniques; single input and output types (can be complex types) give better closure and promote single responsibility principle. Fun services are designed to contain only a few lines of business logic code.

public interface IFun
{
    Task<TOutput> Run(FunContext context, TInput input);
}

// e.g.
public class TabulateEvents : IFun
{
    public Task<MyDocument> Run (FunContext context, MyEvent input)
    {
        context.Logger.LogInformation(input.Description);

        if (input.Type == "Add") return new MyDocument{ Sum = input.Value1 + input Value2 };
        else return new MyDocument{ Sum = input.Value1 - input Value2 };
    } 
}

Bindings

Bindings are kept strictly separate; no leaky binding abstraction. Build on a library of generic bindings or build your own:

// Saves an Event received from an Event Hub to Cosmos DB. 
// Event deserialization and Document serialization is implemented in the generic Binding base class.
// Config and context are injected as dependencies.
public class SaveEventFun : EventHubCosmosFunBinding<MyEvent, MyDocument>
{
    public override Task<MyDocument> Run(FunContext context, MyEvent input)
    {
        try
        {
            return Task.FromResult(
                new MyDocument { 
                    Id = Guid.NewGuid().ToString("N"), 
                    MyProperty = input.MyProperty });
        }
        catch (Exception ex)
        {
            context.Logger.LogError(ex);
            context.PostHealth(FunHealth.Failure(ex));
            throw;
        }
    }
}

Build your own Binding by inheriting from FunBinding

public class MyBinding : FunBinding
{
    public override async Task Bind() 
    {
        //...
    }
}

Scale controllers

Build your own Scale controller by inheriting from FunController

public class FunDaprController : FunController
{
    public override async Task ScaleUp() 
    {
        //...
    }

    public override async Task ScaleDown()
    {
        //...
    }
}

Functions or Bindings can request Scale up or down:

catch (OutOfMemoryException ex)
{
    FunContext.Logger.LogError(ex);
    FunContext.ScaleUp(ex);
    FunContext.PostHealth(FunHealth.Degraded(ex));
}

FunContext

Health, Scale, Telemetry, Authorization, Logging and Configuration are first class citizens with properties and methods on FunContext

public virtual Task Authorize();

public virtual Task<FunHealth> GetHealth();

public virtual void PostHealth(FunHealth health);

public virtual void ScaleUp(object metadata);

public virtual void ScaleDown(object metadata);

public ILogger Logger { get; }

public ITelemetry Telemetry { get; }

public IConfiguration Configuration { get; }

HTTP Functions

Extension methods for ASP.NET Core

public void ConfigureServices(IServiceCollection services)
{
    services.AddFun<HelloFun>();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseRouting();
    app.UseFunPost<HelloFun>("/");
}

Easy to build on HttpFunBinding:

public class HelloFun : HttpFunBinding<MyModel, MyModel>
{
    public override Task<MyModel> Run(FunContext context, MyModel input)
    {
        return Task.FromResult(input);
    }
}

Rationale

^*This prototype looks to improve on some things that are not awesome in Lambda and Functions today:

Bindings are opaque and out of Users' (Developers') control
Scaling is opaque and out of Users' control
Bindings leak into Function code
Triggers are opaque, confusing, and leak into Function code
Telemetry is not first class and/or is tied to vendors' services
Health is not first class; Functions cannot report on their own health
Surpisingly not super easy to run in Containers. Not easily portable
IoC is incomplete and inconsistent
Authorization is not first-class

Contributions, feedback and issues welcome!

tsc-buddy/Fun