@Override public void start() throws Exception { ConsulClient consulClient = ConsulClient.create(vertx); consulClient.putValue("key11", "value11", putResult -> { if (putResult.succeeded()) { System.out.println("KV pair saved"); consulClient.getValue("key11", getResult -> { if (getResult.succeeded()) { System.out.println("KV pair retrieved"); System.out.println(getResult.result().getValue()); } else { getResult.cause().printStackTrace(); } }); } else { putResult.cause().printStackTrace(); } }); } }
public Service(String service, Vertx vertx, ConsulClientOptions options) { super(vertx, ConsulClient.create(vertx, options)); this.service = service; }
public static void TestClusterTestContext(ConsulTestEnv env, TestContext ctx) { ctx.assertTrue(env.nodeCount() == 5); ctx.assertTrue(env.nodes().stream().map(env::getNode).allMatch(ConsulTestNode::isRunning)); ctx.assertTrue(env.nodes().stream().map(env::getNode).filter(ConsulTestNode::isServer).count() == 3); ctx.assertTrue(env.nodes().stream().map(env::getNode).filter(a -> !a.isServer()).count() == 2); env.getServerNode().setHandler(ctx.asyncAssertSuccess(node -> { env.clientOptionsForNode(node, null).map(opt -> { ConsulClient client = ConsulClient.create(env.vertx(), opt); client.catalogNodes(nodes -> { if (nodes.failed()) { client.close(); } ctx.assertTrue(nodes.succeeded()); ctx.assertEquals(env.nodeCount(), nodes.result().getList().size(), "ConsulTestEnv node map and HTTP API result are inconsistent"); nodes.result().getList().stream().map(Node::getName).collect(Collectors.toList()).forEach(name -> ctx.assertTrue(env.nodes().contains(name))); }); return client; }).setHandler(client -> { ctx.assertTrue(client.succeeded()); client.result().close(); }); })); }
String serviceName = randomAlphaString(10); ServiceOptions opts = randomServiceOptions().setName(serviceName).setId(null); ctx.writeClient().registerService(opts, tc.asyncAssertSuccess(reg -> { ctx.writeClient().localServices(tc.asyncAssertSuccess(services -> { String serviceId = checkService(tc, services, serviceName, opts); ctx.writeClient().localChecks(tc.asyncAssertSuccess(checks -> { Check c = checks.stream() .filter(i -> serviceName.equals(i.getServiceName())) tc.assertEquals(c.getId(), "service:" + serviceName); tc.assertEquals(c.getNotes(), opts.getCheckOptions().getNotes()); ctx.writeClient().catalogNodeServices(ctx.nodeName(), tc.asyncAssertSuccess(nodeServices -> { tc.assertEquals(2, nodeServices.getList().size()); checkService(tc, nodeServices.getList(), serviceName, opts); Async async = tc.async(2); ServiceQueryOptions knownOpts = new ServiceQueryOptions().setTag(opts.getTags().get(0)); ctx.writeClient().catalogServiceNodesWithOptions(serviceName, knownOpts, tc.asyncAssertSuccess(nodeServicesWithKnownTag -> { tc.assertEquals(1, nodeServicesWithKnownTag.getList().size()); async.countDown(); })); ServiceQueryOptions unknownOpts = new ServiceQueryOptions().setTag("unknownTag"); ctx.writeClient().catalogServiceNodesWithOptions(serviceName, unknownOpts, tc.asyncAssertSuccess(nodeServicesWithUnknownTag -> { tc.assertEquals(0, nodeServicesWithUnknownTag.getList().size()); async.countDown(); })); async.handler(v -> { ctx.writeClient().deregisterService(serviceId, tc.asyncAssertSuccess(deregistered -> { ctx.writeClient().localServices(tc.asyncAssertSuccess(cleaned -> { tc.assertEquals(cleaned.stream()
@Test public void lifecycle(TestContext tc) { ctx.masterClient().listAclTokens(tc.asyncAssertSuccess(backupTokens -> { AclToken init = new AclToken() .setName("tokenName") .setRules("key \"bar/\" { policy = \"read\" }"); ctx.masterClient().createAclToken(init, tc.asyncAssertSuccess(id -> { ctx.masterClient().infoAclToken(id, tc.asyncAssertSuccess(token -> { tc.assertEquals(id, token.getId()); tc.assertEquals(init.getName(), token.getName()); tc.assertEquals(init.getRules(), token.getRules()); ctx.masterClient().cloneAclToken(id, tc.asyncAssertSuccess(clonedId -> { ctx.masterClient().infoAclToken(clonedId, tc.asyncAssertSuccess(clonedToken -> { tc.assertEquals(clonedId, clonedToken.getId()); tc.assertEquals(token.getName(), clonedToken.getName()); .setName("updatedName") .setRules("key \"bar/\" { policy = \"write\" }"); ctx.masterClient().updateAclToken(token2, tc.asyncAssertSuccess(updatedId -> { ctx.masterClient().infoAclToken(updatedId, tc.asyncAssertSuccess(updatedToken -> { tc.assertEquals(token2.getId(), updatedToken.getId()); tc.assertEquals(token2.getName(), updatedToken.getName()); tc.assertEquals(token2.getRules(), updatedToken.getRules()); ctx.masterClient().destroyAclToken(id, tc.asyncAssertSuccess(v1 -> { ctx.masterClient().destroyAclToken(clonedId, tc.asyncAssertSuccess(v2 -> { ctx.masterClient().listAclTokens(tc.asyncAssertSuccess(aliveTokens -> { tc.assertEquals(backupTokens.size(), aliveTokens.size()); }));
/** * Close the client and release its resources */ public void close() { delegate.close(); }
private void createMasterClient(ConsulTestNode node) { AtomicReference<ConsulTestNode> usedNode = new AtomicReference<>(node); masterClient = ConsulClient.create(vertx, new ConsulClientOptions().setAclToken(MASTER_TOKEN).setDc(TEST_DC).setHost(LOCALHOST).setPort(usedNode.get().httpPort()).setSsl(false)); vertx.setPeriodic(5000, l -> { if ((usedNode.get() == null || !usedNode.get().isRunning()) && masterClient != null) { masterClient.close(); masterClient = null; } }); } }
@Test public void readClientEmptyValue(TestContext tc) { String key = randomFooBarAlpha(); ctx.writeClient() .putValue(key, "", tc.asyncAssertSuccess(b -> { tc.assertTrue(b); ctx.readClient().getValue(key, tc.asyncAssertSuccess(pair -> { tc.assertEquals(key, pair.getKey()); tc.assertEquals("", pair.getValue()); ctx.writeClient().deleteValue(key, tc.asyncAssertSuccess()); })); })); }
private void blockingQuery(TestContext tc, BiConsumer<String, Handler<Long>> indexSupplier) { String key = randomFooBarAlpha(); String value = randomAlphaString(10); ctx.writeClient() .putValue(key, randomAlphaString(10), tc.asyncAssertSuccess(b1 -> { tc.assertTrue(b1); indexSupplier.accept(key, consulIndex -> { Async async = tc.async(2); vertx.setTimer(TimeUnit.SECONDS.toMillis(2), l -> { ctx.writeClient().putValue(key, value, tc.asyncAssertSuccess(b2 -> { tc.assertTrue(b2); ctx.readClient().getValueWithOptions(key, new BlockingQueryOptions().setIndex(consulIndex), tc.asyncAssertSuccess(kv -> { tc.assertTrue(kv.getModifyIndex() > consulIndex); tc.assertEquals(kv.getValue(), value); async.countDown(); })); ctx.readClient().getValuesWithOptions("foo/bar", new BlockingQueryOptions().setIndex(consulIndex), tc.asyncAssertSuccess(kv -> { tc.assertTrue(kv.getIndex() > consulIndex); tc.assertTrue(kv.getList().size() == 1); async.countDown(); })); })); }); async.handler(v -> ctx.writeClient().deleteValue(key, tc.asyncAssertSuccess())); }); })); } }
@Test public void canSetAllFlags(TestContext tc) { String key = randomFooBarAlpha(); String value = randomAlphaString(10); KeyValueOptions opts = new KeyValueOptions().setFlags(-1); ctx.writeClient() .putValueWithOptions(key, value, opts, tc.asyncAssertSuccess(b -> { tc.assertTrue(b); ctx.readClient().getValue(key, tc.asyncAssertSuccess(pair -> { tc.assertEquals(key, pair.getKey()); tc.assertEquals(value, pair.getValue()); assertEquals(opts.getFlags(), pair.getFlags()); ctx.writeClient().deleteValue(key, tc.asyncAssertSuccess()); })); })); }
@Test public void checkAndSet(TestContext tc) { String key = randomFooBarAlpha(); ctx.writeClient() .putValue(key, randomAlphaString(10), tc.asyncAssertSuccess(b1 -> { tc.assertTrue(b1); ctx.readClient().getValue(key, tc.asyncAssertSuccess(pair1 -> { ctx.writeClient().putValue(key, randomAlphaString(10), tc.asyncAssertSuccess(b2 -> { tc.assertTrue(b2); ctx.readClient().getValue(key, tc.asyncAssertSuccess(pair2 -> { tc.assertTrue(pair1.getModifyIndex() < pair2.getModifyIndex()); ctx.writeClient().putValueWithOptions(key, randomAlphaString(10), new KeyValueOptions().setCasIndex(pair1.getModifyIndex()), tc.asyncAssertSuccess(b3 -> { tc.assertFalse(b3); ctx.writeClient().putValueWithOptions(key, randomAlphaString(10), new KeyValueOptions().setCasIndex(pair2.getModifyIndex()), tc.asyncAssertSuccess(b4 -> { tc.assertTrue(b4); ctx.writeClient().deleteValue(key, tc.asyncAssertSuccess()); })); })); })); })); })); })); }
@Test public void deleteBehavior(TestContext tc) { ctx.writeClient().createSessionWithOptions(new SessionOptions().setTtl(442).setBehavior(SessionBehavior.DELETE), tc.asyncAssertSuccess(id -> { ctx.writeClient().putValueWithOptions("foo/bar", "value1", new KeyValueOptions().setAcquireSession(id), tc.asyncAssertSuccess(b -> { tc.assertTrue(b); ctx.writeClient().getValue("foo/bar", tc.asyncAssertSuccess(pair -> { tc.assertEquals("value1", pair.getValue()); tc.assertEquals(id, pair.getSession()); ctx.writeClient().destroySession(id, tc.asyncAssertSuccess(v -> { ctx.writeClient().getValue("foo/bar", tc.asyncAssertSuccess(notfound -> { tc.assertFalse(notfound.isPresent()); })); })); })); })); })); } }
/** * Returns the services registered in a datacenter * @param resultHandler will be provided with list of services * @return reference to this, for fluency */ public io.vertx.rxjava.ext.consul.ConsulClient catalogServices(Handler<AsyncResult<ServiceList>> resultHandler) { delegate.catalogServices(resultHandler); return this; }
private void createKV(TestContext tc, String key, String value, Handler<Long> resultHandler) { ctx.writeClient().putValue(key, value, tc.asyncAssertSuccess(b -> { tc.assertTrue(b); ctx.readClient().getValue(key, tc.asyncAssertSuccess(pair -> { resultHandler.handle(pair.getModifyIndex()); })); })); } }
/** * Returns key/value pair that corresponding to the specified key. * An empty {@link io.vertx.ext.consul.KeyValue} object will be returned if no such key is found. * @param key the key * @param resultHandler will be provided with key/value pair * @return reference to this, for fluency */ public io.vertx.rxjava.ext.consul.ConsulClient getValue(String key, Handler<AsyncResult<KeyValue>> resultHandler) { delegate.getValue(key, resultHandler); return this; }
/** * Returns the services registered in a datacenter * This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#catalogServices} * @param options the blocking options * @param resultHandler will be provided with list of services * @return reference to this, for fluency */ public io.vertx.rxjava.ext.consul.ConsulClient catalogServicesWithOptions(BlockingQueryOptions options, Handler<AsyncResult<ServiceList>> resultHandler) { delegate.catalogServicesWithOptions(options, resultHandler); return this; }
/** * Returns the nodes registered in a datacenter * @param resultHandler will be provided with list of nodes * @return reference to this, for fluency */ public io.vertx.rxjava.ext.consul.ConsulClient catalogNodes(Handler<AsyncResult<NodeList>> resultHandler) { delegate.catalogNodes(resultHandler); return this; }
/** * Returns the nodes registered in a datacenter * @param options options used to request nodes * @param resultHandler will be provided with list of nodes * @return reference to this, for fluency */ public io.vertx.rxjava.ext.consul.ConsulClient catalogNodesWithOptions(NodeQueryOptions options, Handler<AsyncResult<NodeList>> resultHandler) { delegate.catalogNodesWithOptions(options, resultHandler); return this; }
@Override public ConsulService createAclToken(AclToken aclToken, Handler<AsyncResult<String>> idHandler) { consulClient.createAclToken(aclToken, idHandler); return this; }
@Override public ConsulService getValueWithOptions(String key, BlockingQueryOptions options, Handler<AsyncResult<KeyValue>> resultHandler) { consulClient.getValueWithOptions(key, options, resultHandler); return this; }