The uniform interface is 42

The uniform

interface is 42(exclusively for Orleans Virtual Meetup)

About me

Preface

sergeybykov commented on Jan 29

@yevhen do we have a date set for your

presentation yet? Looks like we might want to

dedicate a part of it to this interesting philosophical

discussion. :-)

jkonecki commented on Dec 9, 2014

I would like to hear @yevhen talk about his

Orleans.Bus project and Orleans patterns / best

practices.

https://github.com/sergeybykov

https://github.com/dotnet/orleans/issues/42#issuecomment-72047061

https://github.com/yevhen

https://github.com/jkonecki

https://github.com/OrleansContrib/meetups/issues/1#issuecomment-66290831

https://github.com/yevhen

MS SQL

iPhone6 (100pcs)

Buyers Sellers

HoloLens (10pcs)

Pebble(200pcs)

PetCube(122pcs)

XBOX1(1500pcs)

eCommerce (Inventory)

check-out 10

check-out 50

check-out

check-in 100

create

deactivate

AppleWatch (10000pcs)

rename (“iWatch”)

Use-Cases

• Create item

• Rename item

• Deactivate item

• Add to stock (quantity)

• Order item (quantity)

Buyers Sellers

Both

• Get item details (name, quantity in-stock, active?)

Orleans Interface Project

using System;using System.Linq;using System.Threading.Tasks;

using Orleans;

namespace Example{

[ExtendedPrimaryKey]public interface IInventoryItemGrain : IGrain{

Task Create(string name);Task Rename(string newName);Task CheckIn(int qty);Task CheckOut(int qty);Task Deactivate();Task<InventoryItemDetails> GetDetails();

}

[Serializable]public class InventoryItemDetails{

public string Name;public int Total;public bool Active;

}}

public interface IInventoryItemGrainState : IGrainState{

string Name { get; set; }int Qantity { get; set; }bool Active { get; set; }

}

[StorageProvider(ProviderName = "SqlStore")]public class InventoryItemGrain : Grain<IInventoryItemGrainState>, IInventoryItemGrain{

public Task Create(string name){

…}

public Task CheckOut(int qty){

…}

public Task Deactivate(){

… }

…}

Orleans Implementation Project

Create Item


if (string.IsNullOrEmpty(name))throw new ArgumentException("Inventory item name cannot be null or empty");

if (State.Name != null)throw new InvalidOperationException(

string.Format("Inventory item with id {0} has been already created", this.GetPrimaryKey()));

State.Name = name;State.Active = true;

return State.WriteStateAsync();}

Deactivate Item


if (!State.Active)throw new InvalidOperationException(

this.GetPrimaryKey() + " item is deactivated");

State.Active = false;


Check-out


if (qty <= 0)throw new InvalidOperationException(

"Can't check-out negative quantity from inventory");

if (State.Qty - qty < 0)throw new InvalidOperationException(

"Can't check-out more quantity than there is in stock");

State.Qty -= qty;


The issue


// some business logic ...








The issue










The issue










Duplication !!!

The issue










Duplication !!!

Violation of DRY

Testing business logic






State.Qty -= qty;








State.Qty -= qty;








State.Qty -= qty;


[TestFixture]public class InventoryItemFixture{

[Test]public void When_checking_out_more_than_there_is_in_stock(){

var grain = new InventoryItemGrain(); Assert.Throws<InvalidOperationException>(()=> grain.CheckOut(10));

} }


------ Test started: Assembly: Example.Meetup.exe ------

Test 'Example.InventoryItemFixture.When_checking_out_more_than_there_is_in_stock' failed: Expected: <System.InvalidOperationException>But was: <System.NullReferenceException> (Object reference not set to an instance of an object.)at Example.InventoryItemGrain.CheckOut(Int32 qty) in C:\Work\Source\Example.Meetup\Fixture.cs:line 62at NUnit.Framework.Assert.Throws(IResolveConstraint expression, TestDelegate code, String message,…)

Fixture.cs(110,0): at Example.InventoryItemFixture.When_checking_out_more_than_there_is_in_stock()

0 passed, 1 failed, 0 skipped, took 0.51 seconds (NUnit 2.6.2).



Test 'Example.InventoryItemFixture.When_checking_out_more_than_there_is_in_stock' failed: Expected: <System.InvalidOperationException>But was: <System.NullReferenceException> (Object reference not set to an instance of an object.)at Example.InventoryItemGrain.CheckOut(Int32 qty) in C:\Work\Source\Example.Meetup\Fixture.cs:line 62at NUnit.Framework.Assert.Throws(IResolveConstraint expression, TestDelegate code, String message,…)









State.Qty -= qty;








State.Qty -= qty;


1. Define an interface

interface IInventoryItemGrainState : IGrainState{

string Name { get; set; }int Quantity { get; set; }bool Active { get; set; }

}

Orleans’ declarative persistence




}

2. Inherit from Grain<TGrainState>

[StorageProvider(ProviderName = "SqlStore")]class InventoryItemGrain : Grain<IInventoryItemGrainState>, IInventoryItemGrain





}



3. Proxy implementation of TGrainState will be generated





}




4. At run time, the framework will create an instance of TGrainState

and set State property





}




4. At run time, the framework will create an instance of TGrainState

and set State property


Q: But we can just set State property to a

stub within a test harness, right?


Q: But we can just set State property to a

stub within a test harness, right?


A: Nope, you can’t. It’s protected and

read-only. There is no setter.



var grain = InventoryItemGrainFactory.GetGrain("test-123"); Assert.Throws<InvalidOperationException>(()=> grain.CheckOut(10));

} }

Testing business logic (with real Silo)




} }



Test 'Example.InventoryItemFixture.When_checking_out_more_than_there_is_in_stock' failed: Expected: <System.InvalidOperationException>But was: <System.Data.SqlClient.SqlException> (Server does not exist or connection was refused )at Example.SqlProvider.ReadStateAsync(GrainState state) in C:\Work\Source\Example.Meetup\Fixture.cs:line 8at Example.InventoryItemFixture.When_checking_out_more_than_there_is_in_stock()





} }



Test 'Example.InventoryItemFixture.When_checking_out_more_than_there_is_in_stock' failed: Expected: <System.InvalidOperationException>But was: <System.Data.SqlClient.SqlException> (Server does not exist or connection was refused )at Example.SqlProvider.ReadStateAsync(GrainState state) in C:\Work\Source\Example.Meetup\Fixture.cs:line 8at Example.InventoryItemFixture.When_checking_out_more_than_there_is_in_stock()



[StorageProvider(ProviderName = "SqlStore")]public class InventoryItemGrain : Grain<IInventoryItemGrainState>, IInventoryItemGrain{

public Task ActivateAsync(){

State.ReadStateAsync();}

…}


1. Setup and run test integration silo in a test harness


1. Setup and run Orleans silo in a test harness

2. Setup fresh test database




3. Run migration scripts to setup db schema




3. Run migration scripts to setup db schema

4. Cleanup db before every test (isolation, repeatability)

To test a single line of domain code?

if (this.qty - qty < 0)throw new InvalidOperationException();

1. Use only full-blown integration testing


1. Use only integration testing



2. Don’t write unit-tests



2. Don’t write unit-tests


Is slow.

Unit testing business logic

Is slow.

Is hard.


Is slow.

Is hard.

Doesn’t worth the price.


Is slow.

Is hard.


Don’t fight the framework.


Is slow.


Is hard.


Don’t fight the framework.

Just write an integration test.

Separation of Concerns


VIOLATION

OF

Different levels of abstraction






State.Qty -= qty;








State.Qty -= qty;


domain







State.Qty -= qty;


domain

infrastructure

class InventoryItemGrain : IInventoryItemGrain{

InventoryItem item;

public override Task OnActivateAsync(){

item = new InventoryItem(GetPrimaryKey(), State);

return base.OnActivateAsync();}


item.CheckOut(qty);



item.Deactivate();


class InventoryItem{

readonly string id;readonly IInventoryItemGrainState state;

public InventoryItem(string id, IInventoryItemGrainState state){

this.state = state;this.id = id;

}

public void CheckOut(int qty){



if (state.Qty - qty < 0)throw new InvalidOperationException(

"Can't check-out more than there is in stock");

state.Qty -= qty;}

public void Deactivate(){

if (!state.Active)throw new InvalidOperationException(id + " is inactive");

state.Active = false;}

Framework (infrastructure) dependent

hard to testInfrastructure independent, POCO

easy to test


InventoryItem item;

public override Task OnActivateAsync(){

item = new InventoryItem(GetPrimaryKey(), State);

return base.OnActivateAsync();}


item.CheckOut(qty);



item.Deactivate();



readonly string id;readonly IInventoryItemGrainState state;

public InventoryItem(string id, IInventoryItemGrainState state){

this.state = state;this.id = id;

}




if (state.Qty - qty < 0)throw new InvalidOperationException(

"Can't check-out more than there is in stock");

state.Qty -= qty;}


if (!state.Active)throw new InvalidOperationException(id + " is inactive");

state.Active = false;}

Framework (infrastructure) dependent

hard to testInfrastructure independent, POCO

easy to test



var state = new InventoryItemStateStub {Qty = 0};var item = new InventoryItem(state, "test-123"); Assert.Throws<InvalidOperationException>(()=> grain.CheckOut(10));

} }

Unit testing business logic (with POCO)




} }







} }




IS A BREATHE !!!

Duplicationall over the place

interface IInventoryItemGrain : IGrain{

Task CheckOut(int qty);Task Deactivate();…

}




}



poco.CheckOut(qty);…

}


poco.Deactivate();…

}




}




}



}



…}


…}




}




}



}



…}


…}




}




}



}



…}


…}

Signatures are repeated

4 times for every op




}




}



}



…}


…}

This is not DRY!!!

How can we get rid of duplication?Why do we have it?

Non-uniform interfaceis the issue

“uniform” WAT!?!




}



}



…}


…}

Generic dispatch

Non-uniform interface



…}


…}

1. Variable method names

2. Variable method signatures

Variable signatures

Introduce Parameter Object

solution

Refactoring, M.Fowler

Introduce Parameter Object



…}


…}

public class CheckOutArgs{

public int Qty;}

public class DeactivateArgs{}


public void CheckOut(CheckOutArgs args){

…}

public void Deactivate(DeactivateArgs args){

…}

Parameter Objects(DTO)



poco.CheckOut(new CheckOutArgs {Qty = qty});…

}


poco.Deactivate(new DeactivateArgs());…

}



…}


…}

Generic dispatch



poco.CheckOut(new CheckOutArgs {Qty = qty});…

}


poco.Deactivate(new DeactivateArgs());…

}



…}


…}

Still unable to make it generic

Generic dispatch

Variable method names

C# overloads

solution

Use overloads


public void Handle(CheckOutArgs args){

…}

public void Handle(DeactivateArgs args){

…}



…}


…}



poco.Handle(new CheckOutArgs {Qty = qty});…

}


poco.Handle(new DeactivateArgs());…

}



…}


…}

Generic dispatch



poco.Handle(new CheckOutArgs {Qty = qty});…

}


poco.Handle(new DeactivateArgs());…

}



…}


…}

Now we can make it generic

Generic dispatch



…}


…}

Generic dispatch


InventoryItem item;


Handle(new CheckOutArgs {Qty = qty}); …

}


Handle(new DeactivateArgs());…

}

void Handle(object args){

item.Handle((dynamic)args);}



…}


…}

Dynamic dispatch Is easy!

Generic dispatch


InventoryItem item;



}



}





…}


…}

Non-uniform to uniform


InventoryItem item;



}



}





…}


…}

Non-uniform to uniform


InventoryItem item;



}



}



That’s silly

Uniform grain interface

public interface IInventoryItemGrain : IGrain{


}

Uniform grain interface



}


Task CheckOut(int qty);Task Deactivate();Task Receive(object args);

}

Uniform grain implementation


InventoryItem item;


Handle(new CheckOutArgs {Qty = qty}); return State.WriteStateAsync();

}


Handle(new DeactivateArgs());return State.WriteStateAsync();

}





InventoryItem item;



}



}




InventoryItem item;

public Task Receive(object args){

item.Handle((dynamic)args);return State.WriteStateAsync();

}



InventoryItem item;



}



}




InventoryItem item;



}

That’s nice

Grain interface project

public class CheckOutArgs{

public int Qty;}

public class DeactivateArgs{}


[Serializable]public class CheckOutArgs{

public int Qty;}

[Serializable]public class DeactivateArgs{}



public int Qty;}




public int Qty;}


Noise

POCO interface



…}


…}

POCO interface


public void Handle(CheckOut args){

…}

public void Handle(Deactivate args){

…}

POCO interface


public void Handle(CheckOut msg){

…}

public void Handle(Deactivate msg){

…}

Client-side

await grain.CheckOut(15);

was

Client-side

await grain.CheckOut(15);

await grain.Receive(new CheckOut(15));

was

now


InventoryItem item;



}



…}


…}

Grain is a POCO


InventoryItem item;



}



…}


…}

Grain is a POCO

We can merge POCO methods

back to grain(while still keeping them easily testable)


InventoryItem item;


this.Handle((dynamic)args);return State.WriteStateAsync();

}


…}


…}

Grain is also a POCO


InventoryItem item;



}


…}


…}


run-time


InventoryItem item;



}


…}


…}


run-time

unit-tests



var item = new InventoryItem(); Assert.Throws<InvalidOperationException>(()=> grain.Handle(new CheckOut(15)));

} }

Unit testing business logic (with POCO grain)



var item = new InventoryItem(); Assert.Throws<InvalidOperationException>(()=> grain.Handle(new CheckOut(15)));

} }

Unit testing business logic (with POCO grain)


Test 'Example.InventoryItemFixture.When_checking_out_more_than_there_is_in_stock' failed: Expected: <System.InvalidOperationException>But was: <System.NullReferenceException> (Object reference not set to an instance of an object.)at Example.InventoryItemGrain.Handle(CheckOut msg) in C:\Work\Source\Example.Meetup\Fixture.cs:line 44at NUnit.Framework.Assert.Throws(IResolveConstraint expression, TestDelegate code, String message,…)



Inconvinient declarative persistence


if (msg.Qty <= 0)throw new InvalidOperationException(


if (State.Qty – msg.Qty < 0)throw new InvalidOperationException(


State.Qty -= msg.Qty;}



this.Handle((dynamic)args);









if (!State.Active)throw new InvalidOperationException(“Item is deactivated");

State.Active = false;}












if (!State.Active)throw new InvalidOperationException(“Item is deactivated");

State.Active = false;}



VIOLATION

OF

IGrainState concept

has mixed levels of abstraction

It is both:

1. Bag of custom state properties

2. And also a Unit of Work

Splitting concerns

class InventoryItemGrain : Grain<IInventoryItemGrainState>, IInventoryItemGrain{

string name;int qty;bool active;




if (this.qty – msg.Qty < 0)throw new InvalidOperationException(


this.qty -= msg.Qty;}


if (!this.active)throw new InvalidOperationException(“Item is deactivated");

this.active = false;}

class InventoryItemGrain : Grain<IInventoryItemGrainState>, IInventoryItemGrain{

string name;int qty;bool active;



State.Name = this.name;State.Qty = this.qty;State.Active = this.active;


…

Splitting concerns

class InventoryItemGrain : Grain, IInventoryItemGrain{

InventoryItemRepository repo;string name;int qty;bool active;


this.Handle((dynamic)args);return repo.StoreAsync(this);

}…

Custom storage repository

Recap

Recap


Task Receive(object msg);}

Recap

[Serializable]public class CheckOut{

public int Qty;}

[Serializable]public class Deactivate{}



Recap


public int Qty;}




public class InventoryItemGrain : Grain, IInventoryItemGrain{

…

public Task Receive(object msg){

this.Handle((dynamic)msg);…

}


…}


…}

}

Message Passing

In computer science, message passing sends a message

to a process (which may be an actor or object) and

relies on the process and the supporting infrastructure to

select and invoke the actual code to run. Message

passing differs from conventional programming where a

process, subroutine, or function is directly invoked by

name

From Wikipedia:

Message passing


public int Qty;}





…



}


…}


…}

}

messages

select&invoke(dispatcher)

Functional style


…



}


…}


…}

}

a.k.a.

Higher-order function

Higher-order functions

Messages

+

=

l < 3


Messages

+

=

l < 3


Messages

+

=

42

Messages

1. The set of messages that a server (grain)

can process defines its public interface


public int Qty;}


public interface IGrain{

Task<object> Receive(object msg);}

Uniform interface

2. Message is schema

namespace Example

struct CheckOut{

0: int Qty;1: …;

}

struct Deactivate{

0: int Qty;1: …;

}


public int Qty;}


It all boils down just to serialization

Microsoft Bond Microsoft .NET

Custom protocol is breathe (HTTP)

POST http://host/api/item/123/checkout

CONTENT-TYPE: application/json

BODY:{

qty: 15

}

POST http://host/api/item/123/checkout

CONTENT-TYPE: application/json

BODY:{

qty: 15

}

type id op

Custom protocol is breathe (HTTP)


AOP for free



this.Handle((dynamic)msg);

}}

<pre>

<post>

The most important hook!

the

END

Software

The uniform interface is 42