micros

The Micros-Framework

The programming approach to create software that is lightwight in development and has less cross dependencies to build anti-monolitic software. Each programming feature stands alone with his own dependencies (as a module) and redirects to other modules to complete the main process. The concept follows a simple pipe that is optionally splitted in multiple sub-pipes to process parallel working tasks and combine all sub results for further processing. You can switch between different communication models like http or websockets. This Framework is inspired by Express (Connect), the MicroService growth and message passing interfaces (like scatter, gather, accumlators and broadcasts). Each process is a predefined chain that describe the data flow throught the modules. The last module must output the result in different ways. This framework is a product from the Bachelor Thesis Social Media Recommendations from Francesco Möller, Josua Koschwitz and Maximilian Stroh.

Create a MicroService

TL;DR: Here is a short example for a MicroService that add two numbers or accumulate over multiple numbers (sum):

# Create a new MicroService 
MicroService = require('micros').MicroService
add = new MicroService 'add'                    # Create a new MicroService with a given name 
add.$set 'api', 'ws'                            # Set the API on websockets 
 
# Define the Runtime 
# Standard Addition 
runtime = (req, res, next, params...) ->        # The method definition like an Express middleware 
  next req + params[0], req + params[0]
 
# An accumulator or sum 
runtime.sum = (req, res, next) ->
  res = req.reduce ((akk, val) -> val + akk), 0
  next res, res
 
# A minimum function over all incoming numbers 
runtime.min = (req, res, next) ->
  res = req.reduce ((akk, val) -> if val < akk then val else akk), req[0]
  next res, res
 
# Install the runtime 
add.$install runtime
 
## Module Export 
module.exports = add

All MicroServices will be included with require and can be used in chains and other features. The method next calls the next MicroService of the underlying chain. For better functional support you can get the chain context in which the MicroService was called from next with next.chain for all further coming services and next.previous for the previous MicroService. You can call next with multiple request objects to differ data for next broadcast or an accumulate. If there exist only one request object for a upcoming broadcast, all MicroServices from the broadcast gets the same request:

next req1, req2, req3, reqn, res                  # Multiple requests for Broadcast 
# or 
next req, res                                     # Only one request for all Broadcast links 

Their always exist one response object with excepttion for an previous accumulate from a broadcast.

Chains

The chains are valid CoffeeScript but can read as a flowing pipe. Begin the chain at your desire:

chain1 = new Chain m1 -> m2 -> m3 -> m4 -> m5
chain2 = new Chain -> m1 -> m2 -> m3 -> m4 -> m5
chain3 = Chain -> m1 -> m2 -> m3 -> m4 -> m5
chain4 = m1 -> m2 -> m3 -> m4 -> m5

Defining Splitters: Splitters can be: Scatters, Broadcasts, variable Scatters, variable Broadcasts

chain = new Chain m1 -> m2 -> Splitter(m3 -> m4, m3) -> m5

You can include Chains in Chains:

inner_chain = new Chain -> m2 -> m3 -> m4
chain = new Chain m1 -> inner_chain -> m5

Use custom MicroService methods to better control your level of abstraction:

chain = new Chain -> m1 -> m2.method -> m3 -> m4

Use parameters for better variation (works also with service methods). This parameters cames from the described chains and can be found in params from MicroService method definitions:

chain = new Chain m1 3, -> m2.method -> m3.method 'msg', -> m4 -> m5

An alternative parameter syntax is in various situations better to read:

chain = new Chain m1(3) -> m2.method -> m3.method('msg') -> m4 -> m5

Graphics coming soon

Example App

The following example shows how to use the predefined MicroServices:

Micros = require 'micros'
MicroService = Micros.MicroService
Chain = Micros.Chain
Splitter = Micros.Splitter
 
# Configure MicroService 
Micros.set 'ms_folder', 'services'              # Define the MicroService folder (Default is 'node_modules') 
 
# Spawm services 
Micros.spawn (service) ->                       # Spawn all processes with are corresponding API interface 
  eval "#{service.$name} = service"             # register the services in global scope 
 
###
  There exist three MicroService examples: inc, add, print
  inc: increase the number with one
  add: adds two numbers
  print: print the number on stdout
###
 
cb = ->
  # Define Chain 1 
  inner_chain = new Chain inc -> inc -> inc
  chain = new Chain add(3) -> inner_chain -> add(10) -> print
  chain.exec 2
 
  # Define Chain 2 with a splitter 
  splitter = new Splitter inner_chain, inc, add(2)
  chain = add(3) -> splitter -> add.sum -> print
  chain.exec 5
 
setTimeout cb, 2000

Messages

The Inter Communication Message (ICM) from MPI's are use to send information between MicroServices. The messages are described in JSON and are planned with other formats in the future (like ProtoBuf).

message = {
  request: {...}    # The Request Object with processing parameters 
  response: {...}   # The Response Object with processing results 
  chain: [...]      # The further chain 
  sender: 'sender'  # The senders $module_name 
  params: [...]     # As Array (optional) 
  method: 'method'  # The MicroService method (optional) 
  gather: {         # Used for Gather the same chain over multiple requests (optional) 
    key: 'd6sd436'
    services: 5     # Service counter 
  }
}