silas / node-consul Goto Github PK

Thanks a lot for this great job.

But it seems the API consul.kv.get didn't get promisified properly with the option 'promisify: true', like below, see the comments:

consul.kv.get(myKey).then((res) => {
  if (res.Value === mySub) {
    return consul.kv.set({
      key: myKey,
      value: myValue,
      cas: res.ModifyIndex
    });
  } else {
    // Here I reject with my custom error, will not reach the 'catch' properly.
    // But if I use bluebird promisify 'consul.kv.get' again, then everything will be fine.
    return bluebird.reject(new Error('My custom Error.'));
  }
}).catch((err) => {
  throw err;
});

Make it possible to abort requests, this is especially important for long running calls such as those using wait.

When I call consul.kv.set() with the proper params, the function returns the following error:

EPROTO 140735269093376:error:140770FC:SSL routines:SSL23_GET_SERVER_HELLO:unknown protocol:../deps/openssl/openssl/ssl/s23_clnt.c:794

I am running Consul v0.6.4

Hi.
I can't install the latest version, as npm says its not exist:

$ npm install [email protected]
npm ERR! Darwin 14.5.0
npm ERR! argv "/usr/local/Cellar/node/5.3.0/bin/node" "/usr/local/bin/npm" "install" "[email protected]"
npm ERR! node v5.3.0
npm ERR! npm  v3.3.12

npm ERR! No compatible version found: [email protected]
npm ERR! Valid install targets:
npm ERR! 0.20.0, 0.19.0, 0.18.1, 0.18.0, 0.17.0, 0.16.0, 0.15.0, 0.14.0, 0.13.0, 0.12.0, 0.11.0, 0.10.0, 0.9.2, 0.9.1, 0.9.0, 0.8.0, 0.7.1, 0.7.0, 0.6.0, 0.5.0, 0.4.2, 0.4.1, 0.4.0, 0.3.0, 0.2.1, 0.1.0
npm ERR!
npm ERR!
npm ERR! If you need help, you may report this error at:
npm ERR!     <https://github.com/npm/npm/issues>

npm ERR! Please include the following file with any support request:
npm ERR!     /Users/shmuell/Workspace/playground/npm-debug.log

as you can see, the latest version by npm is 0.20.0, although if ill look here you can see that the latest version is published.
BTW, I tried that on node v4.1.2 and on node v5.3.0.

Thanks.

Hi,

consider following code:

var consul = require('consul')({host: '192.168.59.103'});

consul.watch({ method: consul.kv.get, options: { key: 'test1' }}).on('change', function (result) {
  console.log('test1:', result);
});

consul.watch({ method: consul.kv.get, options: { key: 'test2' }}).on('change', function (result) {
  console.log('test2:', result);
});

1. before starting app, KV is empty:

   test1: undefined
   test2: undefined
   

2. Create test1 entry:

   test1: { CreateIndex: 215,
     ModifyIndex: 215,
     LockIndex: 0,
     Key: 'test1',
     Flags: 0,
     Value: 'va1' }
   test2: undefined
   

3. Create test2 entry:

   test2: { CreateIndex: 218,
     ModifyIndex: 218,
     LockIndex: 0,
     Key: 'test2',
     Flags: 0,
     Value: 'tes2' }
   

4. Update test1:

   test1: { CreateIndex: 215,
     ModifyIndex: 219,
     LockIndex: 0,
     Key: 'test1',
     Flags: 0,
     Value: 'va11' }
   

5. Delete test2:

   test2: undefined
   

6. Update test1:

   test2: undefined
   test1: { CreateIndex: 215,
     ModifyIndex: 223,
     LockIndex: 0,
     Key: 'test1',
     Flags: 0,
     Value: 'va111' }
   

Question

Why in 2 and 6 callback for test2 get fired? Look like that on every key update every callback for key that doesn't exist get fired. Is it proper behaviour?

i'm trying to watch changes on node status in order that every time node status change (alive/left .. ) i will get notified

for example: (output of ./consul members)
client6 172.30.110.6:8301 left client 1.0.2 2 dc1 <default>
and
client6 172.30.110.6:8301 alive client 1.0.2 2 dc1 <default>

i'm using the following http request to get the current status
curl http://localhost:8500/v1/agent/members

my watch is

var watch = consul.watch({ method: consul.agent.members});

but nothing triggered when changing client6 status
what i'm doing wrong?

Thanks!

In a little spike I have:

consul = require("consul")({
  host: "s-consul-server-01"
})

consul.kv.get {key: "tenant/t1", dc: "production"}, (err, r) ->
  console.log "--- err=", err
  console.log "--- r=", r

This works and returns the kv value.

But when I try to move the dc to the global options:

consul = require("consul")({
  host: "s-consul-server-01"
  dc: "production"
})

consul.kv.get {key: "tenant/t1"}, (err, r) ->
  console.log "--- err=", err
  console.log "--- r=", r

Here the callback is invoked with undefined for both 'err' and 'r'.

From the docs it looks like I should be able to do this. Am I missing something here?

Is there a way to get the Value of a key value pair to not be a string? IE: I add a key value pair foo with value 10. It looks like the client will receive the value "10". I'm going down the path of using a Joi schema for all of our Key value pairs but I wanted to double check there isn't something built in already with consul and node-consul.

The problem is in conflict with the https://github.com/silas/node-papi repository.
The issues occurs when running multiple health checks to consul with a delay.

For health check, use consul.agent.check.pass({id: ...}).
A new http client instance is created for each request against consul, which exhausts local ports and results in a ENOBUFS execption after a while.

Hello. I'm using consul client for service discovery. My code looks like:

const consulCli = require('consul');
const Promise = require('bluebird');

const client = consulCli({
  host,
  port,
  promisify: Promise.fromCallback
});

const options = {
  service: 'my-service-name'
};

client
      .watch({
        method: client.catalog.service.nodes,
        options,
        wait: '2m'
      })
      .on('change', (data) => {
        console.log('CHANGE');
      })
      .on('error', (err) => {
        console.log('ERROR');
      });

I run this code locally on my machine and consul is running on remote machine. When network connection is up, changes coming (it logs CHANGE). But when I shutdown my network connection consul client never steps into neither change event, nor in error event.

Such behavior only appear when network disconnect happens after establishing consul client connection (line const client = consulCli({).

Steps 2 reproduce:

• Connect to consul via consul client library
• Create watcher via client
• Wait some time
• Disconnect from network
• See result - no error event emitted

Also when I enable connection again consul client never receive nether change nor error event. It looks like it's getting stuck somewhere inside request.

If consul host is already down papi lib throws timeout exception and it's handled well.

UPD: Seems it happens not always. Also specifying defaults with timeout seems resolves this issue (but I think that some timeout should be set by default to value passed in wait + some seconds.

Using version 0.31.0

My method:

async keys(path: string): Promise<string[]> {
    const data = await this.consul.kv.keys(path);
    return data;
}

works fine. However if the path does not exist, a 500 error will be thrown, crashing the application.

If I pass an error handling function:

async keys(path: string): Promise<string[]> {
    const data = await this.consul.kv.keys(path, function(e) {
      console.log(e);
    });
    return data ? data : [];
}

then calling it with a non-existing path will not make the application crash, because the error will be properly handled. However this will make all calls always returning undefined (even with existing paths).

Hi,

I am using consul in node js. My code snippet is below

var consul = require('consul')({'host': config.CONSUL_IP_ADDRESS, 'port': config.CONSUL_PORT})

consul.agent.service.register({'name': config.SERVICE_NAME, 
  'id': config.SERVICE_ID, 'tags': config.TAGS, 
  'address': config.SERVICE_IP, 
  'port': config.SERVICE_PORT}, function (err) {
 if (err) {
    console.log('error in register')
    console.log(err)
   } else {
      console.log('error in success')
      console.log('sucess')
 }
});

I am getting below error:

Failed to load resource: the server responded with a status of 400 (Bad Request)

Kindly help me to resolve this issue

This does not seem to work very consistently.

While using consul watch -type event echo "event" first every time an even is received, doing the same with node-consul results in inconsistent behavior.

Sometimes the change event will fire, other times it will not, if I manually trigger 10 events, generally node-consul will fire change on the first, and then it could do it on the next or after I've fired 10 events and then change will be fired and contain all the events I triggered.

According to the README, consul.health.service() works as follows:

consul.health.service(options, callback)

Returns the nodes and health info of a service.

Options

• service (String): service ID
• dc (String, optional): datacenter (defaults to local for agent)
• tag (String, optional): filter by tag
• passing (Boolean, optional): restrict to passing checks

Usage

consul.health.service('example', function(err, result) {
 if (err) throw err;
});

Result

[
 {
   "Node": {
     "Node": "node1",
     "Address": "127.0.0.1"
   },
   "Service": {
     "ID": "example",
     "Service": "example",
     "Tags": [],
     "Port": 0
   },
   "Checks": [
     {
       "Node": "node1",
       "CheckID": "service:example",
       "Name": "Service 'example' check",
       "Status": "critical",
       "Notes": "",
       "Output": "",
       "ServiceID": "example",
       "ServiceName": "example"
     },
     {
       "Node": "node1",
       "CheckID": "serfHealth",
       "Name": "Serf Health Status",
       "Status": "passing",
       "Notes": "",
       "Output": "Agent alive and reachable",
       "ServiceID": "",
       "ServiceName": ""
     }
   ]
 }
]

However, according to the Consul documentation for the API command it uses, the parameter used isn't actually serviceID, it's name:

/v1/health/service/

This endpoint is hit with a GET and returns the nodes providing the service indicated on the path. By default, the datacenter of the agent is queried; however, the dc can be provided using the "?dc=" query parameter.

By default, all nodes matching the service are returned. The list can be filtered by tag using the "?tag=" query parameter.

Providing the "?passing" query parameter, added in Consul 0.2, will filter results to only nodes with all checks in the passing state. This can be used to avoid extra filtering logic on the client side.

This endpoint is very similar to the /v1/catalog/service endpoint; however, this endpoint automatically returns the status of the associated health check as well as any system level health checks. This allows a client to avoid sending traffic to nodes that are failing health tests or reporting warnings.

Users can also build in support for dynamic load balancing and other features by incorporating the use of health checks.

It returns a JSON body like this:

[
 {
   "Node": {
     "Node": "foobar",
     "Address": "10.1.10.12"
   },
   "Service": {
     "ID": "redis",
     "Service": "redis",
     "Tags": null,
     "Port": 8000
   },
   "Checks": [
     {
       "Node": "foobar",
       "CheckID": "service:redis",
       "Name": "Service 'redis' check",
       "Status": "passing",
       "Notes": "",
       "Output": "",
       "ServiceID": "redis",
       "ServiceName": "redis"
     },
     {
       "Node": "foobar",
       "CheckID": "serfHealth",
       "Name": "Serf Health Status",
       "Status": "passing",
       "Notes": "",
       "Output": "",
       "ServiceID": "",
       "ServiceName": ""
     }
   ]
 }
]

This endpoint supports blocking queries and all consistency modes.

Note the line

This endpoint is hit with a GET and returns the nodes providing the service indicated on the path.

This caused a few minutes of confusion as I was trying to use consul.health.service() to test the health of a specific instance of a service by id. The documentation here says that is what it does, but the documentation for Consul says that it returns the health of all instances of the service by service name.

Is it possible to set the 'key' option on a lock operation?

I'm trying to do the equivalent of

consul lock -name='ConsulSync' -pass-stdin -token=$TOKEN service/us/locks/foo child_command

My code is

var lock_options = {  key : 'service/us/locks/foo',
                      name : 'ConsulSync',
                      token : process.env.TOKEN
                   };

var lock = consul.lock(lock_options);

but I'm getting a 403 "rpc error: Permission denied"

Also, can I set 'pass-stdin'?

Hi there,

I noticed you changed HTTP verbs to PUT. Will that break older versions of Consul or is it simply that Consul 1.0.0 has become strict about it where before it ignored the verb?

Only a minor version bump and nothing in the readme... I wonder if blindly upgrading node-consul would've gotten me into trouble or not (FWIW, I'm not using Consul 1.0.0 yet).

I maybe misinterpreting something, but how would a registered service listen/handle an event that was fired?

When creating a new instance of Consul, the port type is a string. However, when registering a new service the port type is a number.

This makes extending the typings for this module a little awkward, see:
https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/consul/index.d.ts#L263

https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/consul/index.d.ts#L990

It seems like the lock method almost gets you there. However the lock method does not provide a limit which is key for having the semaphore work.

https://www.consul.io/docs/guides/semaphore.html
https://godoc.org/github.com/hashicorp/consul/api#Semaphore

The default request timeout for a lock kv.get request which is being set is too sensitive for some environments - lockwaittime +1000ms.
This is causing random timeout errors which are emitting 'end' event for the lock.

Changing this to +5000ms seems to fix my issues, so I've opened a PR with a fix to expose the request timeout to the lock() options.

#56

It should be possible to pass a note for a check when calling
consul.agent.check.pass()
consul.agent.check.warn()
consul.agent.check.fail()
Consul allows you to pass it via query parameters:
https://www.consul.io/docs/agent/http/agent.html#agent_check_pass

my consul version is 1.0.0, and node-consul is 0.29.0

here is my code

var consul = require('consul')();
consul.agent.service.deregister('example', (err, result) => {
	console.log(err, result)
})

and output is

{ Error: method GET not allowed
    at create (/home/bob/consul/node_modules/papi/lib/errors.js:14:5)
    at Object.response [as Response] (/home/bob/consul/node_modules/papi/lib/errors.js:38:15)
    at IncomingMessage.<anonymous> (/home/bob/consul/node_modules/papi/lib/client.js:592:26)
    at emitNone (events.js:91:20)
    at IncomingMessage.emit (events.js:188:7)
    at endReadableNT (_stream_readable.js:974:12)
    at _combinedTickCallback (internal/process/next_tick.js:80:11)
    at process._tickCallback (internal/process/next_tick.js:104:9)
  isPapi: true,
  isResponse: true,
  message: 'method GET not allowed',
  statusCode: 405 } undefined

and code in consul/lib/agent/service.js is

93 AgentService.prototype.deregister = function(opts, callback) {
 94   if (typeof opts === 'string') {
 95     opts = { id: opts };
 96   }
 97 
 98   opts = utils.normalizeKeys(opts);
 99   opts = utils.defaults(opts, this.consul._defaults);
100 
101   var req = {
102     name: 'agent.service.deregister',
103     path: '/agent/service/deregister/{id}',
104     params: { id: opts.id },
105   };
106 
107   if (!opts.id) {
108     return callback(this.consul._err(errors.Validation('id required'), req))    ;
109   }
110 
111   utils.options(req, opts);
112 
113   this.consul._get(req, utils.empty, callback);
114 };

i think put method should be used when deregister service but uses get

I am trying to get many keys at the same time. here is my code

consul.kv.set('hello/my/friend', 'world', function(err, result) {
        if (err) throw err;
    });
consul.kv.set('hello/my/friend1', 'world', function(err, result) {
        if (err) throw err;
    });
    consul.kv.get('hello', function(err, result) {
        if (err) throw err;
        console.log("hello",result);
    });

the result of the console.log is 'hello undefined'. I would expect it to be an object with my at the parent object, and friend and friend1 as the keys, and world as the values. instead I get 'undefined'

How can I get this package to return more than one key value pair at a time?

The retry behavior of node-consul is overly aggressive in a clustered environment.

By the 1500 millisecond mark after a network issue we have already made 4 attempts to reconnect to Consul, per process/cluster worker. This can easily spam a consul daemon if you have a larger cluster. And if you aren't running a slave on localhost, you're really in trouble.

Instead of hard-coding an interval of 100, this should be a parameter with a default.

Like title. Tried consul RPC APIs, cannot work.

Hi,
In the register service. is there a support for the docker + interval feature of consul?

Thanks,
Ofer

node-consul won't initialize with default params

var consul = require('consul')();

node.js:201
        throw e; // process.nextTick error, or 'error' event on first tick
              ^
TypeError: Expecting a function in instanceof check, but got http://127.0.0.1:8500/v1
    at Consul.Client (/vagrant/web/node_modules/consul/node_modules/papi/lib/client.js:44:36)
    at new Consul (/vagrant/web/node_modules/consul/lib/consul.js:43:15)
    at Consul (/vagrant/web/node_modules/consul/lib/consul.js:30:12)
    at Object.<anonymous> (/vagrant/web/index.js:7:9)
    at Module._compile (module.js:441:26)
    at Object..js (module.js:459:10)
    at Module.load (module.js:348:32)
    at Function._load (module.js:308:12)
    at Array.0 (module.js:479:10)
    at EventEmitter._tickCallback (node.js:192:41)

The papi library is now checking the baseUrl to make sure its an instance of url.Url. node-consul is creating a baseUrl string. Which fails on the test.

Hi @silas can you please add subject, because this is supported since Consul v0.5 and can be very useful and remove requirements to use external scripts to avoid errors.
https://github.com/hashicorp/consul/blob/a533e255ab7740da4c476e2be8820245c4914d5a/command/agent/config.go#L1155-L1175

Hi ! Thanks for your great work !

I've found a simple bug : kv.set {release: session} doesn't work because of
https://github.com/silas/node-consul/blob/master/lib/kv.js#L110

It should read :
if (options.hasOwnProperty('release')) req.query.release = options.release;
instead of :
if (options.hasOwnProperty('release')) req.query.release = options.acrelease;

acrelease was probably a copy/paste typo...

Missing https://www.consul.io/docs/agent/watches.html.

Specifically, I need type: services in order to watch for service changes.

More specifically, I'd like my client to know as soon as the service it is using fails a health check without having to poll. Perhaps there is an alternate way to do this that I am missing?

It seems that the API is missing getting a status on a specific service.
It also seems the the correct api should be catalog.list.service.
Currently this api is providing list of all services which should be a different api call... (catalog.list.services)

Consul go api providing QueryMeta it would be good to implement in this package

I'm unable to get information from my consul server.. here is what I'm doing

var CONSUL_HOST, consul, opts;

CONSUL_HOST = "myconsulserver.com";

opts = {
  host: CONSUL_HOST,
  secure: false
};

consul = require('consul')(opts);

consul.kv.get("/code/deploy/sha", function(err, data) {
  console.log(err);
  return console.log(data);
});

I get an error like this:

{ [Error: consul: kv.get: moved permanently]
  isPapi: true,
  isResponse: true,
  message: 'consul: kv.get: moved permanently' }

Based on the docs and code i can't find a way to watch something that isn't just a normal kv

am I missing something? :)

I somehow didn't see this module on npm before I started working on my own... which are quite similar actually! Do you think you will keep working on this module? If so, I think I'll just drop mine off the face of the earth and send you a bunch of PRs.

https://github.com/gjohnson/consul-node

Hello,

Any plans on subject:
https://www.hashicorp.com/blog/consul-0-7.html#txn
?

Thank you for the project anyway.

method GET not allowed

Function query.create not works in case use ACL.
For example:
const consul = require('consul')({
"host":"127.0.0.1",
"port":8085,
"sequre":false,
"defaults":{
"token":"vagrant"
}
});
consul.query.create({
name: "rabbitmqQuery",
service: {
service: "rabbitmq",
onlypassing: true
}
}).then(....)

Unhandled rejection Error: Permission denied
at create (/var/www/kvartus-parser/node_modules/consul/node_modules/papi/lib/errors.js:14:5)
at Object.response (/var/www/kvartus-parser/node_modules/consul/node_modules/papi/lib/errors.js:38:15)
at IncomingMessage. (/var/www/kvartus-parser/node_modules/consul/node_modules/papi/lib/client.js:593:26)
at emitNone (events.js:72:20)
at IncomingMessage.emit (events.js:166:7)
at endReadableNT (_stream_readable.js:923:12)
at nextTickCallbackWith2Args (node.js:511:9)
at process._tickCallback (node.js:425:17)

Lets say I have to following keys:
foo/bar & foo-test/bar

fetching the keys like so:
consul.kv.get({'key': 'foo', recurse:true}, function(err,kvs,res) {console.log(kvs);});

would fetch both keys. I'm not sure if this is expected or not? one solution on my side would be to append a / to the key name, but again, I'm not sure if this should be solved on the client side.

How can I override the default of 127.0.0.1:8500 as the address of the consul agent on a watch command?

In the Consul cli, there is a -http-addr option, but the below code does not seem to work (I still see the watch attempting to connect to 127.0.0.1:8500)

`
var watch_options = { 'type' : 'services', 'datacenter' : 'ord', 'http-addr' : '100.78.239.21:8500'};
console.log ("Trying to reach agent ", watch_options["http-addr"]);

var watch = consul.watch({ method: consul.catalog.service.list, options: watch_options});

watch.on('change', function (data, res) {
console.log ("BOOM");
console.log('data:', data);
});
`

It would be awesome if this module provided support for promises. Right now, we're wrapping our calls in Bluebird but with ES6 gaining ground, it would be nice to follow the standard.

I had to comment out https://github.com/silas/node-consul/blob/master/lib/lock.js#L307-L315 and https://github.com/silas/node-consul/blob/master/lib/lock.js#L232-L235 to get the lock system to work reliably.

I found that the monitor updates code is broken and the time is always going to fail, so basically after 15 seconds ( the default) it will always release the lock.

I also found that the data.Flags would always fail on subsequent restarts of the application to check the lock.

By commenting out those two portions, the locking systems seems to work reliably for me now.

There is this consul.lock() which is not available actually. Does anybody know where it's gone?

The release of Consul ver 1.0.0 has resulted in breaking changes to the allowed verbs for many API endpoints. e.g. agent/service/deregister MUST now be a PUT operation rather than a GET. A complete list of change can be found in the 1.0.0 changelog.
The current client is essentially unusable for the latest version of Consul.

I'd be willing to submit a pull request to fix this if you could provide some guidance on how you would like backwards compatibility to be handled, I can't seem to see any way to know what version of server the client is talking to in order to decide on which verbs to use.

8 acceptance tests fail when moving from Consul 0.5.x to 0.6.x due to extra keys. For example:

  8) Session renew should renew session:
     Uncaught AssertionError: expected Object {
  Behavior: 'release',
  Checks: Array [ 'serfHealth' ],
  CreateIndex: 21,
  ID: 'f40db325-912a-07d2-e2fc-f0f190ece90b',
  LockDelay: 15000000000,
  ModifyIndex: 21,
  Name: '',
  Node: 'node1',
  TTL: ''
} to have keys CreateIndex, ID, Name, Node, Checks, LockDelay, Behavior, TTL
    extra keys: ModifyIndex

I've been toying with this all afternoon, and the only conclusion I can come to is that this doesn't work. The X-Consul-Index header is a number larger than parseInt supports (for instance, I'm seeing 2728514738556540332 and 16053482842036918036 and such as indexes), which causes Watch.prototype._run to spam the consul server with requests similar to:

    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (35.285µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (27.953µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (30.412µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (33.294µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (29.642µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (33.401µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (31.815µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (36.465µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (32.218µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (29.328µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (42.818µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (31.697µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (33.518µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (29.718µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (30.11µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (34.945µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (32.085µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (41.429µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (38.103µs)
    2015/12/04 14:30:34 [DEBUG] http: Request /v1/event/list?index=996658596045402018&wait=30s (35.314µs)

Eventually it seems that the watch gives up on that particular run and stops making requests. I don't know if this is supposed to be supported, but it would be nice if it was supported. For the moment, I'm going to write my own watch logic.

I'm implementing the leader election pattern in the Consul docs. I'd like to set the session's TTL to 10s since the health checks are a little slower than I like. I've noticed that when I don't set the TTL field in the options, the leader sticks around for a while. When I do set the TTL, the leader's lock is released periodically and the rate matches the amount of time I set the TTL. I looked through the code and it appears that it should renew the TTL. Unfortunately, it looks like this isn't happening.

Sorry to be a pest....

My code is almost working perfectly now - it went through several 'watch' and 'lock' events perfectly - but then it got an error. It looks like a lock.release() caused an error because somehow there was no lock? But the lock.release() is called only within the lock.on('acquire' callback.

/usr/src/app/node_modules/consul/lib/lock.js:110
  if (!self._ctx) throw errors.Validation('no lock in use');
                  ^

Error: no lock in use
    at create (/usr/src/app/node_modules/consul/lib/errors.js:14:5)
    at Object.validation (/usr/src/app/node_modules/consul/lib/errors.js:26:15)
    at Lock.release (/usr/src/app/node_modules/consul/lib/lock.js:110:32)
    at /usr/src/app/src/main/node/agent.js:40:18
    at /usr/src/app/src/main/node/catalog.js:32:5
    at ChildProcess.exithandler (child_process.js:204:7)
    at emitTwo (events.js:87:13)
    at ChildProcess.emit (events.js:172:7)
    at maybeClose (internal/child_process.js:827:16)
    at Process.ChildProcess._handle.onexit (internal/child_process.js:211:5)

  var watch = consul.watch({ method: consul.catalog.service.list, options: this.watch_options});

  watch.on('change', function (data, res) {

    that.health.setWatch ("UP");

    var lock = consul.lock(that.lock_options);

    lock.on('acquire', function(){
        that.health.setLock ("UP");
        var catalog = new Catalog(that.health);
        catalog.update(data, function(){
            lock.release();
        });
    });

    lock.on('error', function(err){
        console.log ("ERROR: Consul Lock Error");
        console.log (JSON.stringify(err, null, 4));
        that.health.setLock ("ERROR");
    });

    lock.acquire();
  });

  watch.on('error', function (err) {
    console.log ('ERROR: Consul Watch Error');
    console.log (JSON.stringify(err, null, 4));
    that.health.setWatch ("ERROR");
  });

Consul 0.5.0 supports a new (poorly documented) Checks field, which can be used to associate multiple checks with a service at registration. The new field is an array, with each element a check. See hashicorp/consul#591 for full implementation details.

Can you expose this in the consul.agent.service.register() call?

If you agree with me and think this is usefull, i would provide a PR for that