node package manager

eureka

Eureka

RPC and boardcast networks based on ZMQ

RPC

Creating server

var srv = Server.create({
  
  name: "s2",
  
  endpoint: {
    pub: "tcp://*:6061",
    router: "tcp://*:6611"
  }
  
});

Registering methods

Server.register() accepts a simple object that has a "_symbols_" map describing the methods avaiable. Method requests are checked against this map in case of illegal purpose.

srv.register({
  ns: "bar",
  foo: function(id) {},
  col: function(name) {},
  kar: function(file) {},
  
  __symbols__: {
    "bar.foo": {
      params: [{
        name: "id",
        type: "number"
      }],
      type: "method"
    },
    
    "bar.col": {
      params: [{
        name: "name",
        type: "string"
      }],
      type: "method"
    },
    
    "bar.kar": {
      params: [{
        name: "file",
        type: "string"
      }],
      type: "method"
    }
  }
});

You could specify a json file to clean up the mess:

srv.register(require("./foo"));

In foo.js

var Foo = {

  ns: "foo",
  
  bar: function(drip) {
    setTimeout(function() {
      console.log("%@ from %@".fmt(drip.req.params.greetings, drip.id));
      drip.out("nice");
      drip.end();
    }, 200);
  },
  
  __symbols__: require("./foo.json")
  
};

module.exports = Foo;

And we put method descriptions in foo.json.

Method invocation

var client = Client.create({

  name: "c1",
  
  endpoint: {
    sub: "tcp://127.0.0.1:60601",
    dealer: "tcp://127.0.0.1:60611"
  }
  
});

Client.request(api, params, cb)

Client#request method is the main entry point of method invocation, where cb is passed with single argument:

  • resp: a response stream object, which have "error", "data", "end " events

Client.get(api, params, cb)

This shortcut method is used to retrieve simple response from remote method. Cb is passed with two arugments:

  • error: an error object if any
  • data: stringified content of response stream

Relfection

There's a special API that can tell clients about the detailed info about avaliable methods on remote server.

client.get("core.reflection", "all", function(err, list) {
	//list contains all methods avaliable on server
});

Event boardcast

Server.boardcast(type, msg)

Boardcasting message to all clients is quite straight forward.

Client.subscribe(type, cb)

where cb is passed with message from server, and it's called when events of type is published by server.

Heartbeat

Heartbeat ping-pong requests are secretly handled by RPC.Server and RPC.Client. First heartbeat ping is sent after client's connection request. Server pong response will be replied immediately.

NextPingInterval = LastPingInterval * Math.E, LastPingInterval defaults to 5 seconds