public IObservable <StreamAction> GetInstances(CancellationToken token)
        {
            IDisposable subscription = null;

            return(Observable.Create <StreamAction>(async(observer) =>
            {
                try
                {
                    var result = await _etcd.GetKey(_key).WithRecursive(true);
                    ProcessInstances(observer, result);
                }
                catch (Draft.Exceptions.KeyNotFoundException)
                {
                }

                subscription = _etcd.Watch(_key).WithRecursive(true).Subscribe((IKeyEvent e) =>
                {
                    if (token.IsCancellationRequested)
                    {
                        subscription.Dispose();
                        return;
                    }

                    if (Interlocked.CompareExchange(ref _processing, 1, 0) == 0)
                    {
                        // TODO
                        //   ProcessInstances(observer, e);
                        Interlocked.Exchange(ref _processing, 0);
                    }
                });

                return Disposable.Create(() => { subscription.Dispose(); });
            }));
        }
        internal override EtcdConfigurationChangeToken ProduceChangeToken(IEtcdClient client)
        {
            var changeToken = base.ProduceChangeToken(client);

            client.Watch(keyToMonitor, (oldValue, newValue) =>
            {
                if (callback(oldValue, newValue))
                {
                    Refresh();
                }
            });

            return(changeToken);
        }