Nearsighted Paramecium Multiverse
    Share your code. npm Orgs help your team discover, share, and reuse code. Create a free org »




    yoda gif

    etcd v2 client for monitoring changes to the force - useful for networks that are changing dynamically.

    Yoda gives you 2 things:

    • a node.js event listener that reacts to changes in network topology (endpoints coming and going)
    • a bash script that an orchestration script calls to register and un-register endpoints

    If you want to speak like yoda - check out yoda-said

    example 1 - node.js <-> Mongo

    node.js client

    Somewhere on a small lonely planet - a plucky little node script wants to connect to some Mongo databases (or ZeroMQ sockets or any TCP thing).

    We know we have an etcd server running on and so we tell Yoda to connect to it to get updates about Mongos.

    var Yoda = require('yoda');
    // hostname + port of the etcd server 
    var yoda = new Yoda('', 4001);
    // location will emit events for anything below /mongo 
    var location = yoda.connect('/mongo');
    // listen for servers arriving 
    location.on('add', function(route, data){
        // route will be the id of the server 
        console.log('server id: ' + route);
        // data is a string at this point - encode how you like! 
        // we probably want to connect to the mongo server at this point 

    bash client

    Meanwhile - in amoungst the alliance fleet - we have a Mongo spawning bash script that knows the IP of the server it is running a Mongo database on.

    # the IP address of the mongo server we are booting
    # first run a mongo container using docker
    MONGO_CONTAINER=$(docker run -p 27017 -t quarry/mongo)
    # now get the port it is listening
    MONGO_PORT=$(docker port $MONGO_CONTAINER 27017)
    # now lets tell yoda about the server


    A command to boot 2 servers and register them under '/servers' with yoda:

    $ node server.js 5678 &
    $ node server.js 5679 &
    $ yoda set /servers/1 tcp://
    $ yoda set /servers/2 tcp://

    example 2 - ZeroMQ <-> ZeroMQ

    A brokerless ZeroMQ REQ/REP network where multiple clients connect to multiple servers - a feel-the-force mesh!


    #!/usr/bin/env node
    var zmq = require('zmq')
      , sock = zmq.socket('rep');
    var port = process.argv[2] || 8791;
    sock.on('message', function(msg){
    sock.bindSync('tcp://' + port);


    A ZeroMQ REQ client that connects to servers registered under '/servers' with yoda:

    var zmq = require('zmq')
      , server_socket = zmq.socket('req')
      , Yoda = require('yoda');
    var yoda = new Yoda('', 4001);
    var server_pool = yoda.connect('/servers');
    server_pool.on('add', function(route, endpoint){
        // this is load balanced across the server sockets 
    }, 1000)



    The node.js part is so your app can listen to changes in the network and connect/disconnect to endpoints as they come and go.

    $ npm install yoda --save


    The bash part is so your orchestration script can write changes to the network as you are spawning/killing processes.

    $ wget -qO- | sudo bash

    etcd server

    You need an etcd server running in order for yoda to speak to the force.

    2 environment variables are used by yoda to speak to the etcd server:

    • YODA_HOST (default
    • YODA_PORT (default 4001)

    You can use the Makefile to run an etcd server in a docker container.

    First install docker.

    Then, to run etcd on the default port:

    $ make etcd

    running examples

    There is an example setup so you can see the rough idea

    In the first shell:

    $ node examples/app.js

    And then in the second shell:

    $ ./examples/

    You should see servers arriving in the first shell.


    var Yoda = require('yoda');

    var yoda = new Yoda(etcd_host, etcd_port);

    Create a new yoda object connected to the given etcd_host & etcd_port.

    var location = yoda.connect('/my/location');

    Returns a location object that will update when anything under '/my/location' changes.


    location.on('add', function(route, data) {})

    Called when a new item has been added to the locations path.

    The route is the full key to the new item and data is the new value.

    location.on('remove', function(route, data) {})

    Called when an item has been deleted from the locations path.

    location.on('change', function(route, data) {})

    Called when an item has been added or removed from the locations path.

    bash methods

    yoda set $PATH $DATA

    Set the value of $PATH to $DATA.

    yoda get $PATH

    Get the JSON packet of $PATH.

    yoda value $PATH

    Get the value of $PATH.

    yoda keys $PATH

    Print all keys beneath $PATH one per line

    yoda del $PATH

    Remove $PATH.

    yoda rmdir $PATH

    Remove $PATH and everything beneath.




    npm i yoda

    Downloadsweekly downloads







    last publish


    • avatar