How to use etcd3 - 10 common examples

const { Etcd3 } = require('etcd3');

let endpoints = process.env.COMPOSE_ETCD_ENDPOINTS;
let envuser = process.env.COMPOSE_ETCD_USER
let envpass = process.env.COMPOSE_ETCD_PASS

// Create auth credentials
let opts = {
  hosts: endpoints.split(","),
  auth: {
    username: envuser,
    password: envpass
  }
}

var etcd = new Etcd3(opts).namespace("/grand_tour/words/");

// We want to extract the port to publish our app on
let port = process.env.PORT || 8080;

// We can now set up our web server. First up we set it to serve static pages
app.use(express.static(__dirname + '/public'));

// The user has clicked submit to add a word and definition to the database
// put them into etcd3 and respond
app.put("/words", function (request, response) {
  etcd.put(request.body.word).value(request.body.definition).then(
    (result) => {
      response.send(result);
    }
  ).catch((err) => {
    console.log(err);

process.exit(1);
}

let envuser = process.env.COMPOSE_ETCD_USER;
let envpass = process.env.COMPOSE_ETCD_PASS;

// Create auth credentials
let opts = {
    hosts: endpoints.split(","),
    auth: {
        username: envuser,
        password: envpass
    }
};

var etcd = new Etcd3(opts).namespace("/grand_tour/words/");

// We want to extract the port to publish our app on
let port = process.env.PORT || 8080;

// We can now set up our web server. First up we set it to serve static pages
app.use(express.static(__dirname + '/public'));

// Add a word to the database
function addWord(word, definition) {
    return new Promise(function(resolve, reject) {
        etcd.put(word).value(definition).then(() => {
            resolve();
        }).catch((err) => {
            reject(err);
        });
    });

delete(clusterStatus.apiEndpoints[node.metadata!.name!]);
  kubeadmCM.data![configMapKey] = yaml.safeDump(clusterStatus);
  const { response: cmReplaceResp } = await coreV1Client.replaceNamespacedConfigMap(configMapName, configMapNS, kubeadmCM);

  if (!purgedMasterIP) {
    logger.warn(`Failed to find IP of deleted master node from kubeadm-config: skipping etcd peer removal step`);
    return;
  }
  if (!remainingMasterIPs.length) {
    logger.error(`Cannot remove etcd peer: no remaining etcd endpoints available to connect to`);
    return;
  }

  // 2. Use the credentials from the mounted etcd client cert secret to connect to the remaining
  // etcd members and tell them to forget the purged member.
  const etcd = new Etcd3({
    credentials: {
      rootCertificate: fs.readFileSync("/etc/kubernetes/pki/etcd/ca.crt"),
      privateKey: fs.readFileSync("/etc/kubernetes/pki/etcd/client.key"),
      certChain: fs.readFileSync("/etc/kubernetes/pki/etcd/client.crt"),
    },
    hosts: _.map(remainingMasterIPs, (ip) => `https://${ip}:2379`),
  });
  const peerURL = `https://${purgedMasterIP}:2380`;
  const { members } = await etcd.cluster.memberList();
  const purgedMember = _.find(members, (member) => {
    return _.includes(member.peerURLs, peerURL);
  });
  if (!purgedMember) {
    logger.info(`Purged node was not a member of etcd cluster`);
    return;
  }

it('should throw cache update error if store op fails', () => {
      putStub = sandbox.stub(Etcd3.prototype, 'put', (k) => new PutStubber(hash, k, true));
      containsStub = sandbox.stub(subject, 'containsDeployment', () => Promise.resolve(false));
      return subject.saveDeployment('plan_id', '5', {}, {}).catch(err => {
        expect(err.code).to.eql('ETCDERROR');
      });
    });
  });

it('should return true if task is in cache', () => {
      getStub = sandbox.stub(Etcd3.prototype, 'get', (k) => new SingleRangeStubber(hash, k));
      return subject.containsBoshTask('1').then(o => {
        expect(o).to.eql(true);
      });
    });
    it('should return false if task is not in cache', () => {

it('should store deployment in cache if absent previously', () => {
      putStub = sandbox.stub(Etcd3.prototype, 'put', (k) => new PutStubber(hash, k));
      containsStub = sandbox.stub(subject, 'containsDeployment', () => Promise.resolve(false));
      return subject.store('plan_id', '4', {
        param: 'value'
      }, {
        arg: 'val'
      }).then(o => {
        expect(o).to.eql(true);
      });
    });
    it('should not store again if previously present in cache', () => {

it('should return true if task is in cache', () => {
      getStub = sandbox.stub(Etcd3.prototype, 'get', (k) => new SingleRangeStubber(hash, k));
      return subject.containsBoshTask('1').then(o => {
        expect(o).to.eql(true);
      });
    });
    it('should return false if task is not in cache', () => {

beforeEach(() => {
      sandbox = sinon.sandbox.create();
      valueStub = sandbox.stub();
      acquireStub = sandbox.stub();
      releaseStub = sandbox.stub();
      jsonStub = sandbox.stub();
      putStub = sandbox.stub(Etcd3.prototype, 'put', () => {
        return {
          value: (val) => Promise.resolve(valueStub(val))
        };
      });
      getStub = sandbox.stub(Etcd3.prototype, 'get', () => {
        return {
          json: () => Promise.resolve(jsonStub())
        };
      });
      lockStub = sandbox.stub(Etcd3.prototype, 'lock', () => {
        return {
          ttl: () => {
            return {
              acquire: () => Promise.resolve(acquireStub())
            };
          },

before(() => {
      sandbox = sinon.sandbox.create();
      valueStub = sandbox.stub();
      stringStub = sandbox.stub();
      jsonStub = sandbox.stub();
      putstub = sandbox.stub(Etcd3.prototype, 'put', () => {
        return {
          value: (val) => Promise.resolve(valueStub(val))
        };
      });
      getstub = sandbox.stub(Etcd3.prototype, 'get', () => {
        return {
          json: () => Promise.resolve(jsonStub()),
          string: () => Promise.resolve(stringStub()),
        };
      });

      prefixWatcherStub = sandbox.stub().returns({
        create: () => Promise.resolve({
          on: () => Promise.resolve('prefixWatcherStubResponse')
        }),
      });

before(() => {
      sandbox = sinon.sandbox.create();
      valueStub = sandbox.stub();
      stringStub = sandbox.stub();
      jsonStub = sandbox.stub();
      putstub = sandbox.stub(Etcd3.prototype, 'put', () => {
        return {
          value: (val) => Promise.resolve(valueStub(val))
        };
      });
      getstub = sandbox.stub(Etcd3.prototype, 'get', () => {
        return {
          json: () => Promise.resolve(jsonStub()),
          string: () => Promise.resolve(stringStub()),
        };
      });

      prefixWatcherStub = sandbox.stub().returns({
        create: () => Promise.resolve({
          on: () => Promise.resolve('prefixWatcherStubResponse')
        }),
      });
      keyWatcherStub = sandbox.stub().returns({
        create: () => Promise.resolve({
          on: () => Promise.resolve('keyWatcherStubResponse')
        }),
      });