congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
DockerScanner.getNeoRxClient
Code IndexAdd Tabnine to your IDE (free)

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

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

origin: LendingClub/mercator

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;
}
origin: LendingClub/mercator

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;
}
origin: LendingClub/mercator

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
origin: LendingClub/mercator

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());
  }
}
origin: LendingClub/mercator

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();
}
origin: LendingClub/mercator

/**
 * 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);
  }
}
origin: LendingClub/mercator

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);
    }
  }
}
origin: LendingClub/mercator

    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);
origin: LendingClub/mercator

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);
origin: LendingClub/mercator

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);
origin: LendingClub/mercator

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;
  }
}
origin: LendingClub/mercator

  @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;
    }
    
  }
}
org.lendingclub.mercator.dockerDockerScannergetNeoRxClient

Popular methods of DockerScanner

  • getDockerClient
  • scan
  • <init>
  • getProjector
  • getRestClient
  • getSchemaManager
  • maybeThrow
  • scanService
  • scanTask
  • updateEngineInfo

Popular in Java

  • Running tasks concurrently on multiple threads
  • orElseThrow (Optional)
    Return the contained value, if present, otherwise throw an exception to be created by the provided s
  • compareTo (BigDecimal)
  • setScale (BigDecimal)
  • SocketException (java.net)
    This SocketException may be thrown during socket creation or setting options, and is the superclass
  • SocketTimeoutException (java.net)
    This exception is thrown when a timeout expired on a socket read or accept operation.
  • URLEncoder (java.net)
    This class is used to encode a string using the format required by application/x-www-form-urlencoded
  • Path (java.nio.file)
  • BitSet (java.util)
    The BitSet class implements abit array [http://en.wikipedia.org/wiki/Bit_array]. Each element is eit
  • JButton (javax.swing)
  • Best plugins for Eclipse
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now