private void startRedeploy(Future<Void> fut) { discoveryManager.restartModules(res -> { if (res.succeeded()) { logger.info("Deploy completed succesfully"); } else { logger.info("Deploy failed: " + res.cause()); } fut.complete(); }); } }
public void init(Vertx vertx, String mapName, Handler<ExtendedAsyncResult<Void>> fut) { this.vertx = vertx; AsyncMapFactory.<String, String>create(vertx, mapName, res -> { if (res.succeeded()) { this.list = res.result(); fut.handle(new Success<>()); } else { fut.handle(new Failure<>(INTERNAL, res.cause())); } }); }
private void startEnv(Future<Void> fut) { logger.debug("starting Env"); envManager.init(vertx, res -> { if (res.succeeded()) { startDiscovery(fut); } else { fut.fail(res.cause()); } }); }
private void startDiscovery(Future<Void> fut) { logger.debug("Starting discovery"); discoveryManager.init(vertx, res -> { if (res.succeeded()) { startDeployment(fut); } else { fut.fail(res.cause()); } }); }
private void startModmanager(Future<Void> fut) { moduleManager.init(vertx, res -> { if (res.succeeded()) { startTenants(fut); } else { logger.fatal("ModuleManager init: " + res.cause().getMessage()); fut.fail(res.cause()); } }); }
private void startTenants(Future<Void> fut) { tenantManager.init(vertx, res -> { if (res.succeeded()) { checkInternalModules(fut); } else { logger.fatal("load tenants failed: " + res.cause().getMessage()); fut.fail(res.cause()); } }); }
private void startDeployment(Future<Void> fut) { if (deploymentManager == null) { startListening(fut); } else { logger.debug("Starting deployment"); deploymentManager.init(res -> { if (res.succeeded()) { startListening(fut); } else { fut.fail(res.cause()); } }); } }
private void healthList(List<DeploymentDescriptor> list, Handler<ExtendedAsyncResult<List<HealthDescriptor>>> fut) { List<HealthDescriptor> all = new LinkedList<>(); CompList<List<HealthDescriptor>> futures = new CompList<>(INTERNAL); for (DeploymentDescriptor md : list) { Future<HealthDescriptor> f = Future.future(); health(md, res -> { if (res.succeeded()) { all.add(res.result()); } f.handle(res); }); futures.add(f); } futures.all(all, fut); }
/** * Get all modules that are enabled for the given tenant. * * @param ten tenant to check for * @param fut callback with a list of ModuleDescriptors (may be empty list) */ public void getEnabledModules(Tenant ten, Handler<ExtendedAsyncResult<List<ModuleDescriptor>>> fut) { List<ModuleDescriptor> mdl = new LinkedList<>(); CompList<List<ModuleDescriptor>> futures = new CompList<>(INTERNAL); for (String id : ten.getEnabled().keySet()) { Future<ModuleDescriptor> f = Future.future(); modules.get(id, res -> { if (res.succeeded()) { mdl.add(res.result()); } f.handle(res); }); futures.add(f); } futures.all(mdl, fut); } }
public void getNodes(Handler<ExtendedAsyncResult<List<NodeDescriptor>>> fut) { nodes.getKeys(resGet -> { if (resGet.failed()) { fut.handle(new Failure<>(resGet.getType(), resGet.cause())); } else { Collection<String> keys = resGet.result(); if (clusterManager != null) { List<String> n = clusterManager.getNodes(); keys.retainAll(n); } List<NodeDescriptor> all = new LinkedList<>(); CompList<List<NodeDescriptor>> futures = new CompList<>(INTERNAL); for (String nodeId : keys) { Future<NodeDescriptor> f = Future.future(); getNode1(nodeId, res -> { if (res.succeeded()) { all.add(res.result()); } f.handle(res); }); futures.add(f); } futures.all(all, fut); } }); }
public void list(Handler<ExtendedAsyncResult<List<TenantDescriptor>>> fut) { tenants.getKeys(lres -> { if (lres.failed()) { logger.warn("TenantManager list: Getting keys FAILED: ", lres); fut.handle(new Failure<>(INTERNAL, lres.cause())); } else { CompList<List<TenantDescriptor>> futures = new CompList<>(INTERNAL); List<TenantDescriptor> tdl = new LinkedList<>(); for (String s : lres.result()) { Future<Tenant> future = Future.future(); tenants.get(s, res -> { if (res.succeeded()) { tdl.add(res.result().getDescriptor()); } future.handle(res); }); futures.add(future); } futures.all(tdl, fut); } }); }
public void autoUndeploy(ModuleDescriptor md, ProxyContext pc, Handler<ExtendedAsyncResult<Void>> fut) { logger.info("autoUndeploy " + md.getId()); if (md.getId().startsWith(XOkapiHeaders.OKAPI_MODULE)) { fut.handle(new Success<>()); return; } deployments.get(md.getId(), res -> { if (res.succeeded()) { List<DeploymentDescriptor> ddList = res.result(); CompList<List<Void>> futures = new CompList<>(USER); for (DeploymentDescriptor dd : ddList) { if (dd.getNodeId() != null) { Future<Void> f = Future.future(); callUndeploy(dd, pc, f::handle); futures.add(f); } } futures.all(fut); } else { fut.handle(new Failure<>(res.getType(), res.cause())); } }); }
public void autoDeploy(ModuleDescriptor md, ProxyContext pc, Handler<ExtendedAsyncResult<Void>> fut) { logger.info("autoDeploy " + md.getId()); // internal Okapi modules is not part of discovery so ignore it if (md.getId().startsWith(XOkapiHeaders.OKAPI_MODULE)) { fut.handle(new Success<>()); return; } nodes.getKeys(res1 -> { if (res1.failed()) { fut.handle(new Failure<>(res1.getType(), res1.cause())); } else { Collection<String> allNodes = res1.result(); deployments.get(md.getId(), res -> { if (res.succeeded()) { autoDeploy2(md, pc, allNodes, res.result(), fut); } else if (res.getType() == NOT_FOUND) { autoDeploy2(md, pc, allNodes, new LinkedList<>(), fut); } else { fut.handle(new Failure<>(res.getType(), res.cause())); } }); } }); }
/** * Get all records in the map. Returns them in a LinkedHashMap, so they come * in well defined order. * * @param fut callback with the result, or some failure. */ public void getAll(Handler<ExtendedAsyncResult<LinkedHashMap<String, T>>> fut) { getKeys(kres -> { if (kres.failed()) { fut.handle(new Failure<>(kres.getType(), kres.cause())); return; } Collection<String> keys = kres.result(); LinkedHashMap<String, T> results = new LinkedHashMap<>(); CompList<LinkedHashMap<String,T>> futures = new CompList<>(INTERNAL); for (String key : keys) { Future<String> f = Future.future(); getString(key, null, res -> { if (res.succeeded()) { T t = Json.decodeValue(res.result(), clazz); results.put(key, t); } f.handle(res); }); futures.add(f); } futures.all(results, fut); }); }
public void listModules(String id, boolean full, Handler<ExtendedAsyncResult<List<ModuleDescriptor>>> fut) { tenants.get(id, gres -> { if (gres.failed()) { fut.handle(new Failure<>(gres.getType(), gres.cause())); } else { Tenant t = gres.result(); List<ModuleDescriptor> tl = new LinkedList<>(); CompList<List<ModuleDescriptor>> futures = new CompList<>(INTERNAL); for (String mId : t.listModules()) { Future<ModuleDescriptor> f = Future.future(); moduleManager.get(mId, res -> { if (res.succeeded()) { if (full) { tl.add(res.result()); } else { ModuleDescriptor md = new ModuleDescriptor(res.result(), false); md.setName(null); // name not part of tenantModuleDescriptor tl.add(md); } } f.handle(res); }); futures.add(f); } futures.all(tl, fut); } }); }
/** * Get all known DeploymentDescriptors (all services on all nodes). */ public void get(Handler<ExtendedAsyncResult<List<DeploymentDescriptor>>> fut) { deployments.getKeys(resGet -> { if (resGet.failed()) { logger.debug("DiscoveryManager:get all: " + resGet.getType().name()); fut.handle(new Failure<>(resGet.getType(), resGet.cause())); } else { Collection<String> keys = resGet.result(); List<DeploymentDescriptor> all = new LinkedList<>(); CompList<List<DeploymentDescriptor>> futures = new CompList<>(INTERNAL); for (String s : keys) { Future<List<DeploymentDescriptor>> f = Future.future(); this.get(s, res -> { if (res.succeeded()) { all.addAll(res.result()); } f.handle(res); }); futures.add(f); } futures.all(all, fut); } }); }
/** * Insert a tenant. * * @param t * @param fut */ public void insert(Tenant t, Handler<ExtendedAsyncResult<String>> fut) { String id = t.getId(); tenants.get(id, gres -> { if (gres.succeeded()) { fut.handle(new Failure<>(USER, messages.getMessage("10400", id))); } else if (gres.getType() == NOT_FOUND) { if (tenantStore == null) { // no db, just add it to shared mem insert2(t, id, fut); } else { // insert into db first tenantStore.insert(t, res -> { if (res.failed()) { logger.warn("TenantManager: Adding " + id + " FAILED: ", res); fut.handle(new Failure<>(res.getType(), res.cause())); } else { insert2(t, id, fut); } }); } } else { fut.handle(new Failure<>(gres.getType(), gres.cause())); } }); }
private void removeAndUndeploy(ProxyContext pc, List<DeploymentDescriptor> ddList, Handler<ExtendedAsyncResult<Void>> fut) { CompList<List<Void>> futures = new CompList<>(INTERNAL); for (DeploymentDescriptor dd : ddList) { Future<Void> f = Future.future(); logger.info("removeAndUndeploy " + dd.getSrvcId() + " " + dd.getInstId()); callUndeploy(dd, pc, res -> { if (res.succeeded()) { deploymentStore.delete(dd.getInstId(), f::handle); } else { f.handle(res); } }); futures.add(f); } futures.all(fut); }
public void updateDescriptor(TenantDescriptor td, Handler<ExtendedAsyncResult<Void>> fut) { final String id = td.getId(); tenants.get(id, gres -> { if (gres.failed() && gres.getType() != NOT_FOUND) { logger.warn("TenantManager: UpDesc: getting " + id + " FAILED: ", gres); fut.handle(new Failure<>(INTERNAL, "")); } Tenant t; if (gres.succeeded()) { t = new Tenant(td, gres.result().getEnabled()); } else { t = new Tenant(td); } if (tenantStore == null) { tenants.add(id, t, fut); // no database. handles success directly } else { tenantStore.updateDescriptor(td, upres -> { if (upres.failed()) { logger.warn("TenantManager: Updating database for " + id + " FAILED: ", upres); fut.handle(new Failure<>(INTERNAL, "")); } else { tenants.add(id, t, fut); // handles success } }); } }); }
final String interfaceVersion = md.getProvides()[0].getVersion(); moduleManager.get(okapiModule, gres -> { if (gres.succeeded()) { // we already have one, go on logger.debug("checkInternalModules: Already have " + okapiModule + " with interface version " + interfaceVersion);