Change RequestResponseProtocol to use a Message type parameter in anticipation of Functions

[srfc]

Proposed Changes

• Change RequestResponseProtocol to be compatible with envisioned MultiDactorFunctions, specifically the SequentialFunction
• Add Message types to Request, Response, and the subtypes (Success and Failure)

Message definitions will change from:

object GetCustomerGroupId {
  case class Request() extends RequestResponseProtocol.Request
  case class Success(result: Relation) extends RequestResponseProtocol.Success
  case class Failure(e: Throwable) extends RequestResponseProtocol.Failure
}

to

object GetCustomerGroupId {
  sealed trait GetCustomerGroupId extends Message
  case class Request() extends RequestResponseProtocol.Request[GetCustomerGroupId]
  case class Success(result: Relation) extends RequestResponseProtocol.Response[GetCustomerGroupId]
  case class Failure(e: Throwable) extends RequestResponseProtocol.Failure[GetCustomerGroupId]
}

Related

• merge Add fouleggs sample application #105 first

[SebastianSchmidl]

Looks good, but a small clarification needed in the scaladoc for RequestResponseProtocol

[SebastianSchmidl]

One could explain a little bit more, how this works and why it is needed. I think that's not obvious.
You can add an example usage.

Use the word marker trait, as all descendants will never be implemented, right?

[srfc]

You're right it's a little thin there.

There is a slight problem with the system we want at the moment though which relates to the trait Message explanation, though:

In how I am currently implementing SequentialFunction (in the experimental script), I lose the Message type information of the Response being passed back to the initial caller of the function. I am unsure if this is due to type erasure and has been that way regardless or if it is because of the following:

When I send messages to multiple recipients in a start or next step, I wait for them, collect all individual responses and then have to:

1. unpack the Responses to get the Relation to union them
2. re-pack into the appropriate Responses to pass on to the next next or end step

I am currently doing this like this:

// Receive
case message: Success[Message] =>
  // are we still waiting for messages? if so, become current state with the received message remembered
  // if not:
  val constructor = message.getClass.getConstructors()(0) // get constr to be able to repack as (hopefully) the correct `Response` subtype
  val unionResponse = (previouslyReceivedResponses :+ message)
    .foldLeft(constructor.newInstance(Relation.empty).asInstanceOf[Success[Message]])((a: Success[Message], b: Success[Message]) =>
      constructor.newInstance(a.result.unionAll(b.result)).asInstanceOf[Success[Message]])
  // use unionResponse to continue with next steps

Due to me losing the specific Response (or rather Success) subtype I can then not match for a specific answer anymore.

If this persists we don't get anything from the current Message type parameter, right?

[SebastianSchmidl]

discussed in skype

[SebastianSchmidl]

example can follow later, when functors are implemented