How to use

Key

in

co.edu.uniquindio.overlay

if (key1.getHashing().compareTo(key2.getHashing()) == -1) {
  if (hashing.compareTo(key1.getHashing()) == 1
      && (hashing.compareTo(key2.getHashing()) == -1 || hashing
      .compareTo(key2.getHashing()) == 0)) {
    return true;
  if (key1.getHashing().compareTo(key2.getHashing()) == 1) {
    if ((hashing.compareTo(key1.getHashing()) == 1 && hashing
        .compareTo(key2.getHashing()) == 1)
        || hashing.compareTo(key2.getHashing()) == 0) {
      return true;
    } else {
      if (hashing.compareTo(key1.getHashing()) == -1
          && hashing.compareTo(key2.getHashing()) == -1) {
        return true;
    if (hashing.compareTo(key2.getHashing()) == 0) {
      return true;

/**
 * Relocates the resources of the node.
 *
 * @param key The node where the files will be relocated.
 */
public void relocateAllResources(Key key, ProgressStatus progressStatus) throws StorageException {
  Set<String> resourcesNames = resourceManager.getAllKeys();
  log.info("Relocating Files...");
  log.debug("Number of files: [" + resourcesNames.size() + "]");
  int filesRelocated = 0;
  for (String name : resourcesNames) {
    Resource resource = resourceManager.find(name);
    Key fileKey = getFileKey(name);
    if (!fileKey.isBetween(key, overlayNode.getKey())) {
      boolean relocate = put(resource, key, false, progressStatus);
      filesRelocated++;
    }
  }
  log.info("Files relocated: [" + filesRelocated + "]");
}

boolean putSync(Resource resource, ProgressStatus progressStatus) throws StorageException {
  progressStatus.status("put", 0L, 1L);
  progressStatus.status("overlay-node-lookup", 0L, 1L);
  Key key = keyFactory.newKey(resource.getId());
  log.debug("Resource to put: [" + resource.getId() + "] Hashing: ["
      + key.getHashing() + "]");
  Key lookupKey = overlayNode.lookUp(key);
  progressStatus.status("overlay-node-lookup", 1L, 1L);
  if (lookupKey == null) {
    log.error("Impossible to do put the resource: "
        + resource.getId() + " in this moment");
    throw new StorageException("Impossible to do put the resource: "
        + resource.getId() + " in this moment");
  }
  log.debug("Lookup key for " + key.getHashing() + ": ["
      + lookupKey.getValue() + "]");
  boolean success = put(resource, lookupKey, true, progressStatus);
  progressStatus.status("put", 1L, 1L);
  return success;
}

public void leave(ProgressStatus progressStatus) throws StorageException {
  try {
    Key[] keys = overlayNode.leave();
    Set<String> resourcesNames = resourceManager.getAllKeys();
    log.info("Leaving...");
    log.debug("Number of files to transfer: ["
        + resourcesNames.size() + "]");
    if (!keys[0].equals(overlayNode.getKey())) {
      for (String name : resourcesNames) {
        Resource resource = resourceManager.find(name);
        put(resource, keys[0], false, progressStatus);
        resource.close();
      }
    }
    resourceManager.deleteAll();
    communicationManager.removeObserver(overlayNode.getKey().getValue());
  } catch (OverlayException | IOException e) {
    log.error("Error while leaving dhash node: '"
        + overlayNode.getKey().toString() + "'");
  }
}

} else {
  log.debug("Node '" + nodeChord.getKey().getValue() + "' found '"
      + findNode.getValue() + "'");
  nodeChord.join(findNode);

/**
 * Join a Chord ring using node <code>node</code>.
 * <p>
 * The <code>join</code> function asks <code>node</code> to find the
 * immediate successor of <code>n</code>.
 *
 * @param node Identifier of the known node.
 */
public void join(Key node) {
  Message lookupMessage;
  predecessor = null;
  lookupMessage = Message.builder()
      .id(idGenerator.newId())
      .sendType(Message.SendType.REQUEST)
      .messageType(Protocol.LOOKUP)
      .address(Address.builder()
          .destination(node.getValue())
          .source(key.getValue())
          .build())
      .param(Protocol.LookupParams.HASHING.name(), key.getHashing().toString())
      .param(Protocol.LookupParams.TYPE.name(), LookupType.JOIN.name())
      .build();
  successor = communicationManager.send(lookupMessage,
      ChordKey.class, LookupResponseParams.NODE_FIND.name());
  successorList.initializeSuccessors();
}

if (key1.getHashing().compareTo(key2.getHashing()) == -1) {
  if (hashing.compareTo(key1.getHashing()) == 1
      && (hashing.compareTo(key2.getHashing()) == -1)) {
    return true;
  if (key1.getHashing().compareTo(key2.getHashing()) == 1) {
    if (hashing.compareTo(key1.getHashing()) == 1
        && hashing.compareTo(key2.getHashing()) == 1) {
      return true;
    } else {
      if (hashing.compareTo(key1.getHashing()) == -1
          && hashing.compareTo(key2.getHashing()) == -1) {
        return true;
    if (hashing.compareTo(key2.getHashing()) == 0) {
      return true;

.messageType(Protocol.PUT)
.address(Address.builder()
    .destination(lookupKey.getValue())
    .source(name)
    .build())

/**
 * Replicates the specified file in its successors.
 *
 * @param resourceId The specified {@link Resource} to replicate.
 * @throws OverlayException
 */
public void replicateData(String resourceId, ProgressStatus progressStatus)
    throws OverlayException, StorageException {
  Key[] succesorList = overlayNode.getNeighborsList();
  for (int i = 0; i < Math.min(replicationFactor, succesorList.length); i++) {
    Resource resource = resourceManager.find(resourceId);
    log
        .debug("Replicate File: [" + resource.getId()
            + "] Hashing: ["
            + succesorList[i].getHashing() + "]");
    log.debug("Replicate to " + succesorList[i].getHashing());
    put(resource, succesorList[i], false, progressStatus);
  }
}

.messageType(Protocol.LOOKUP)
.address(Address.builder()
    .destination(next.getValue())
    .source(key.getValue())
    .build())

.messageType(Protocol.CONTAIN)
.address(Address.builder()
    .destination(lookupKey.getValue())
    .source(name)
    .build())
  .messageType(Protocol.GET)
  .address(Address.builder()
      .destination(lookupKey.getValue())
      .source(name)
      .build())