org.lendingclub.mercator.docker.DockerScanner.getNeoRxClient java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 DateTime d =new DateTime()
DateTimeFormatter formatter;String text;formatter.parseDateTime(text)
Object instant;new DateTime(instant)
Smart code suggestions by Tabnine
}

public void deleteTask(String id) {
  Optional<String> scid = getSwarmClusterId();
  if (scid.isPresent()) {
    dockerScanner.getNeoRxClient().execCypher(
        "match (s:DockerSwarm {swarmClusterId:{swarmClusterId}})--(x:DockerTask {taskId:{taskId}}) detach delete x",
        "taskId", id, "swarmClusterId", scid.get());
    dockerScanner.getNeoRxClient().execCypher(
        "match (x:DockerTask {taskId:{taskId}, swarmClusterId:{swarmClusterId}}) detach delete x", "taskId",
        id, "swarmClusterId", scid.get());
  }
  return;
}

public void deleteNode(String id) {
  Optional<String> scid = getSwarmClusterId();
  if (scid.isPresent()) {
    dockerScanner.getNeoRxClient().execCypher(
        "match (s:DockerSwarm {swarmClusterId:{swarmClusterId}})--(x:DockerHost {swarmNodeId:{swarmNodeId}}) detach delete x",
        "swarmNodeId", id, "swarmClusterId", scid.get());
    dockerScanner.getNeoRxClient().execCypher(
        "match (x:DockerHost {swarmNodeId:{swarmNodeId}, swarmClusterId:{swarmClusterId}}) detach delete x",
        "swarmNodeId", id, "swarmClusterId", scid.get());
  }
  return;
}

private void updateEngineInfo(JsonNode nodeInfo) {
  ObjectNode n = new ObjectMapper().createObjectNode();
  n.set("engineId", nodeInfo.get("ID"));
  n.put("architecture", nodeInfo.path("Architecture").asText());
  n.put("osType", nodeInfo.path("OSType").asText());
  n.put("operatingSystem", nodeInfo.path("OperatingSystem").asText());
  n.put("kernelVersion", nodeInfo.path("KernelVersion").asText());
  n.put("serverVersion", nodeInfo.path("ServerVersion").asText());
  n.put("nCPU", nodeInfo.path("NCPU").asLong());
  n.put("memTotal", nodeInfo.path("MemTotal").asLong());
  
  n.path("Labels").fields().forEachRemaining(it -> {
    String labelKey = "label_" + it.getKey();
    n.set(labelKey, it.getValue());
  });
  
  getNeoRxClient().execCypher("merge (h:DockerHost {engineId:{engineId}}) set h+={props}, h.updateTs=timestamp()","engineId",n.path("engineId").asText(),"props",n);
  
} 
@Override

public void deleteService(String id) {
  Optional<String> scid = getSwarmClusterId();
  if (scid.isPresent()) {
    logger.info("deleting neo4j DockerService id/name={}", id);
    dockerScanner.getNeoRxClient().execCypher(
        "match (x:DockerService {name:{name},swarmClusterId:{swarmClusterId}}) detach delete x", "name", id,
        "swarmClusterId", scid.get());
    dockerScanner.getNeoRxClient().execCypher(
        "match (x:DockerService {serviceId:{serviceId},swarmClusterId:{swarmClusterId}}) detach delete x",
        "serviceId", id, "swarmClusterId", scid.get());
    dockerScanner.getNeoRxClient().execCypher(
        "match (s:DockerSwarm {swarmClusterId:{swarmClusterId}})--(x:DockerService {serviceId:{serviceId}}) detach delete x",
        "serviceId", id, "swarmClusterId", scid.get());
    dockerScanner.getNeoRxClient().execCypher(
        "match (s:DockerSwarm {swarmClusterId:{swarmClusterId}})--(x:DockerService {name:{name}}) detach delete x",
        "name", id, "swarmClusterId", scid.get());
  }
}

long saveDockerNode(String swarmClusterId, JsonNode n) {
  String swarmNodeId = n.get("swarmNodeId").asText();
  AtomicLong updateTs = new AtomicLong(Long.MAX_VALUE);
  dockerScanner.getNeoRxClient()
      .execCypher(
          "merge (n:DockerHost {swarmNodeId:{nodeId}}) set n+={props}, n.updateTs=timestamp() return n",
          "nodeId", swarmNodeId, "props", n)
      .forEach(actual -> {
        removeDockerLabels("DockerHost", "swarmNodeId", swarmNodeId, n, actual);
        updateTs.set(Math.min(updateTs.get(), actual.path("updateTs").asLong(Long.MAX_VALUE)));
      });
  logger.info("connecting swarm={} to node={}", swarmClusterId, swarmNodeId);
  dockerScanner.getNeoRxClient().execCypher(
      "match (s:DockerSwarm {swarmClusterId:{swarmClusterId}}), (n:DockerHost {swarmNodeId:{nodeId}}) merge (s)-[x:CONTAINS]->(n) set x.updateTs=timestamp()",
      "swarmClusterId", swarmClusterId, "nodeId", swarmNodeId);
  return updateTs.get();
}

/**
 * Removes labels that were present from a scan, but subsequently removed.
 * 
 * @param neo4jLabel
 * @param idName
 * @param idVal
 * @param intended
 * @param actual
 */
protected void removeDockerLabels(String neo4jLabel, String idName, String idVal, JsonNode intended,
    JsonNode actual) {
  List<String> x = Lists.newArrayList();
  actual.fieldNames().forEachRemaining(it -> {
    if (it != null && it.startsWith("label_")) {
      if (!intended.has(it)) {
        if (!it.contains(" ")) {
          x.add("a.`" + it + "`");
        }
      }
    }
  });
  if (!x.isEmpty()) {
    String cypher = "match (a:" + neo4jLabel + " {" + idName + ":{id}}) remove " + Joiner.on(", ").join(x)
        + " return a";
    dockerScanner.getNeoRxClient().execCypher(cypher, "id", idVal);
  }
}

public void scanTasksForSwarm(String swarmClusterId) {
  logger.info("scanning tasks for swarm: {}", swarmClusterId);
  AtomicLong earlistUpdate = new AtomicLong(Long.MAX_VALUE);
  AtomicBoolean error = new AtomicBoolean(false);
  JsonNode response = getRestClient().getTasks();
  response.forEach(it -> {
    try {
      earlistUpdate.set(Math.min(earlistUpdate.get(), saveTask(it)));
    } catch (Exception e) {
      logger.warn("problem updating task", e);
      error.set(true);
    }
  });
  if (error.get() == false) {
    if (earlistUpdate.get() < System.currentTimeMillis()) {
      dockerScanner.getNeoRxClient().execCypher(
          "match (x:DockerTask) where x.swarmClusterId={swarmClusterId} and x.updateTs<{cutoff} detach delete x",
          "cutoff", earlistUpdate.get(), "swarmClusterId", swarmClusterId);
    }
  }
}

    ObjectNode n = flattenService(it);
    n.put("swarmClusterId", swarmClusterId);
    dockerScanner.getNeoRxClient().execCypher(
        "merge (x:DockerService {serviceId:{serviceId}}) set x+={props}, x.updateTs=timestamp() return x",
        "serviceId", n.get("serviceId").asText(), "props", n).forEach(svc -> {
              .set(Math.min(earlistUpdate.get(), svc.path("updateTs").asLong(Long.MAX_VALUE)));
        });
    dockerScanner.getNeoRxClient().execCypher(
        "match (swarm:DockerSwarm {swarmClusterId:{swarmClusterId}}),(service:DockerService{serviceId:{serviceId}}) merge (swarm)-[x:CONTAINS]->(service) set x.updateTs=timestamp()",
        "swarmClusterId", swarmClusterId, "serviceId", n.path("serviceId").asText());
if (error.get() == false) {
  if (earlistUpdate.get() < System.currentTimeMillis()) {
    dockerScanner.getNeoRxClient().execCypher(
        "match (x:DockerService) where x.swarmClusterId={swarmClusterId} and x.updateTs<{cutoff} detach delete x",
        "cutoff", earlistUpdate.get(), "swarmClusterId", swarmClusterId);

dockerScanner.getNeoRxClient()
    .execCypher("merge (x:DockerTask {taskId:{taskId}}) set x+={props}, x.updateTs=timestamp() return x",
        "taskId", taskId, "props", n)
  dockerScanner.getNeoRxClient().execCypher(
      "match (s:DockerService {serviceId:{serviceId}}),(t:DockerTask{taskId:{taskId}}) merge (s)-[x:CONTAINS]->(t) set x.updateTs=timestamp() return t,s",
      "serviceId", serviceId, "taskId", taskId);
  if (!Strings.isNullOrEmpty(swarmNodeId)) {
    dockerScanner.getNeoRxClient().execCypher(
        "match (h:DockerHost {swarmNodeId:{swarmNodeId}}), (t:DockerTask {swarmNodeId:{swarmNodeId}}) merge (h)-[x:RUNS]->(t) set x.updateTs=timestamp()",
        "swarmNodeId", swarmNodeId);

props.put("updatedAt", updatedAt);
JsonNode swarmNode = dockerScanner.getNeoRxClient()
    .execCypher(
        "merge (c:DockerSwarm {swarmClusterId:{id}}) set c+={props},c.updateTs=timestamp() return c",
    dockerScanner.getNeoRxClient().execCypher("match (c:DockerSwarm {name:{name}}) return c", "name", name)
        .forEach(it -> {
          String oldSwarmClusterId = it.path("swarmClusterId").asText();
          if (!swarmClusterId.equals(oldSwarmClusterId)) {
            dockerScanner.getNeoRxClient().execCypher(
                "match (c:DockerSwarm {swarmClusterId:{swarmClusterId}}) detach delete c",
                "swarmClusterId", oldSwarmClusterId);
    dockerScanner.getNeoRxClient().execCypher(
        "match (c:DockerSwarm {swarmClusterId:{id}}) set c.managerApiUrl={managerApiUrl},c.name={name},c.tridentClusterId={name} return c",
        "id", swarmClusterId, "managerApiUrl", LOCAL_DOCKER_DAEMON_SOCKET_URL, "name", name);
  if (earliestTimestamp.get() < System.currentTimeMillis()) {
    logger.info("deleting DockerHost nodes before with updateTs<{}", earliestTimestamp.get());
    dockerScanner.getNeoRxClient().execCypher(
        "match (s:DockerSwarm {swarmClusterId:{id}})--(x:DockerHost) where s.updateTs>x.updateTs detach delete x",
        "id", swarmClusterId);

public void scanService(String id) {
  try {
    Optional<String> scid = getSwarmClusterId();
    if (scid.isPresent()) {
      logger.info("performing targeted scan of service={}", id);
      JsonNode it = getRestClient().getService(id);
      ObjectNode n = flattenService(it);
      n.put("swarmClusterId", scid.get());
      dockerScanner.getNeoRxClient().execCypher(
          "merge (x:DockerService {serviceId:{serviceId}}) set x+={props}, x.updateTs=timestamp() return x",
          "serviceId", n.get("serviceId").asText(), "props", n).forEach(actual -> {
            try {
              removeDockerLabels("DockerService", "serviceId", n.get("serviceId").asText(), n,
                  actual);
            } catch (Exception e) {
              logger.warn("problem removing labels: " + e.toString());
            }
          });
      dockerScanner.getNeoRxClient().execCypher(
          "match (swarm:DockerSwarm {swarmClusterId:{swarmClusterId}}),(service:DockerService{serviceId:{serviceId}}) merge (swarm)-[x:CONTAINS]->(service) set x.updateTs=timestamp()",
          "swarmClusterId", scid.get(), "serviceId", n.path("serviceId").asText());
    }
  } catch (RuntimeException e) {
    if (isNotFound(e)) {
      deleteService(id);
      return;
    }
    throw e;
  }
}

  @BeforeClass
  public static void setupDockerScanner() {
    DockerScanner ds = new Projector.Builder().build().createBuilder(DockerScannerBuilder.class).withLocalDockerDaemon().build();
    boolean b = ds.getNeoRxClient().checkConnection();
    if (b==false) {
      logger.warn("neo4j is not available...integration tests will be skipped");
      Assume.assumeTrue("neo4j available", b);
    }
    else {
      logger.info("neo4j is available for integration tests");
    }
    
    try {
      Info info = ds.getDockerClient().infoCmd().exec();
      logger.info("local docker daemon is available for integration tests");
      dockerScanner = ds;
    }
    catch (Exception e) {
      logger.warn("neo4j is not available for integration tests",e);
      Assume.assumeTrue(false);
      return;
    }
    
  }
}

Popular methods of DockerScanner

Popular in Java

Creating JSON documents from java classes using gson
runOnUiThread (Activity)
orElseThrow (Optional)
Return the contained value, if present, otherwise throw an exception to be created by the provided s
scheduleAtFixedRate (ScheduledExecutorService)
FlowLayout (java.awt)
A flow layout arranges components in a left-to-right flow, much like lines of text in a paragraph. F
ArrayList (java.util)
ArrayList is an implementation of List, backed by an array. All optional operations including adding
AtomicInteger (java.util.concurrent.atomic)
An int value that may be updated atomically. See the java.util.concurrent.atomic package specificati
JarFile (java.util.jar)
JarFile is used to read jar entries and their associated data from jar files.
Get (org.apache.hadoop.hbase.client)
Used to perform Get operations on a single row. To get everything for a row, instantiate a Get objec
Location (org.springframework.beans.factory.parsing)
Class that models an arbitrary location in a Resource.Typically used to track the location of proble
PhpStorm for WordPress

How to use getNeoRxClientmethodin org.lendingclub.mercator.docker.DockerScanner

Best Java code snippets using org.lendingclub.mercator.docker.DockerScanner.getNeoRxClient (Showing top 12 results out of 315)

How to use
getNeoRxClient
method
in
org.lendingclub.mercator.docker.DockerScanner