Esempio n. 1
0
  /**
   * If my peer is responsible, I'll issue a put if absent to make sure all replicas are stored.
   *
   * @param locationKey The location key
   * @param domainKey The domain key
   * @param dataMapConverted The data to store
   * @return The future of the put
   */
  protected FutureDone<?> send(final Number160 locationKey) {
    int replicationFactor = replication.replicationFactor() - 1;
    List<PeerAddress> closePeers = new ArrayList<PeerAddress>();
    SortedSet<PeerStatistic> sortedSet =
        peer.peerBean().peerMap().closePeers(locationKey, replicationFactor);
    int count = 0;
    List<FutureDone<?>> retVal = new ArrayList<FutureDone<?>>(replicationFactor);
    for (PeerStatistic peerStatistic : sortedSet) {
      if (replication.rejectReplication(peerStatistic.peerAddress())) {
        continue;
      }

      count++;
      closePeers.add(peerStatistic.peerAddress());
      // this must be inside the loop as we need to retain the data for every peer

      Number640 min = new Number640(locationKey, Number160.ZERO, Number160.ZERO, Number160.ZERO);
      Number640 max =
          new Number640(locationKey, Number160.MAX_VALUE, Number160.MAX_VALUE, Number160.MAX_VALUE);
      final NavigableMap<Number640, Data> dataMap = peer.storageLayer().get(min, max, -1, true);

      retVal.add(replicationSender.sendDirect(peerStatistic.peerAddress(), locationKey, dataMap));
      if (count == replicationFactor) {
        break;
      }
    }
    LOG.debug(
        "[storage refresh] I ({}) restore {} to {}", peer.peerAddress(), locationKey, closePeers);
    return FutureDone.whenAll(retVal);
  }
Esempio n. 2
0
 @Override
 public FutureDone<?> meResponsible(final Number160 locationKey, PeerAddress newPeer) {
   LOG.debug("I ({}) sync {} to {}", peer.peerAddress(), locationKey, newPeer);
   Number640 min = new Number640(locationKey, Number160.ZERO, Number160.ZERO, Number160.ZERO);
   Number640 max =
       new Number640(locationKey, Number160.MAX_VALUE, Number160.MAX_VALUE, Number160.MAX_VALUE);
   final NavigableMap<Number640, Data> dataMap = peer.storageLayer().get(min, max, -1, true);
   return replicationSender.sendDirect(newPeer, locationKey, dataMap);
 }
Esempio n. 3
0
  @Override
  public FutureDone<?> otherResponsible(final Number160 locationKey, final PeerAddress other) {

    LOG.debug(
        "Other peer {} is responsible for {}. I'm {}", other, locationKey, peer.peerAddress());

    Number640 min = new Number640(locationKey, Number160.ZERO, Number160.ZERO, Number160.ZERO);
    Number640 max =
        new Number640(locationKey, Number160.MAX_VALUE, Number160.MAX_VALUE, Number160.MAX_VALUE);
    final NavigableMap<Number640, Data> dataMap = peer.storageLayer().get(min, max, -1, true);
    LOG.debug("transfer from {} to {} for key {}", peer.peerAddress(), other, locationKey);
    return replicationSender.sendDirect(other, locationKey, dataMap);
  }
Esempio n. 4
0
  @Override
  public void run() {
    try {
      // we get called every x seconds for content we are responsible for. So
      // we need to make sure that there are enough copies. The easy way is to
      // publish it again... The good way is to do a diff
      Collection<Number160> locationKeys =
          peer.storageLayer().findContentForResponsiblePeerID(peer.peerID());

      for (Number160 locationKey : locationKeys) {
        synchronizeData(locationKey);
      }
      // recalculate replication factor
      int replicationFactor = IndirectReplication.this.replicationFactor.replicationFactor();
      replication.replicationFactor(replicationFactor);
    } catch (Throwable t) {
      t.printStackTrace();
    }
  }