示例#1
0
  /**
   * Returns known active commands in an unmodifiable list. The list contains at most {@link
   * #MAX_COMMANDS_SIZE} elements from the command database. It is safe to call it frequently.
   * Threads should care of synchronization when iterating over the it.
   */
  public synchronized List getCommands() {

    List o = commandCollection;
    if (o == null) {
      o = Collections.unmodifiableList(new ArrayList(commands.keySet()));
      commandCollection = o;
    }

    return o;
  }
示例#2
0
  /**
   * Returns known contributions in an unmodifiable list. The list contains at most {@link
   * #MAX_CACHE_SIZE} random elements from the contribution repository. Might return the same list
   * when called again if there is two little time between the calls. The dynamic type of elements
   * is ContributionBox. It is safe to call it frequently. Threads should care of synchronization
   * when iterating over it.
   */
  public synchronized List getContributions() {

    List o = cacheCollection;
    if (o == null) {
      o = Collections.unmodifiableList(new ArrayList(cache.values()));
      cacheCollection = o;
    }

    return o;
  }
示例#3
0
  /**
   * Removes randomly chosen entries until from the cache and commands until the size is not larger
   * than MAX_CACHE_SIZE and MAX_COMMANDS_SIZE respectively.
   */
  private void cutToSize() {

    if (MAX_CACHE_SIZE < cache.size())
      synchronized (cache) {
        Vector keyList = new Vector(cache.keySet());
        Collections.shuffle(keyList);
        while (MAX_CACHE_SIZE < cache.size()) {
          cache.remove(keyList.get(0));
          keyList.remove(0);
        }
      }
    if (MAX_COMMANDS_SIZE < commands.size())
      synchronized (commands) {
        Vector keyList = new Vector(commands.keySet());
        Collections.shuffle(keyList);
        while (MAX_COMMANDS_SIZE < commands.size()) {
          commands.remove(keyList.get(0));
          keyList.remove(0);
        }
      }
  }
示例#4
0
  /**
   * Initiates an information exchange with a known and living other base if such a base exists.
   *
   * @return true if refresh was succesful, false otherwise.
   */
  private boolean refresh() {

    final String logSender = observer + "#refresh";
    final String contrName = ((contributor != null) ? contributor.getName() : null);

    // --- refreshing local contribution and commands
    updateLocalInfo();

    // --- creating a random permutation of peers
    Vector peers = null;
    synchronized (cache) {
      peers = new Vector(cache.values());
      // just to be sure, shouldn't be there anyway
      if (contrName != null) peers.remove(cache.get(contrName));
    }
    Collections.shuffle(peers);
    if (peers.isEmpty()) {
      Logger.debug(logSender, "no peers in cache");
      return false;
    }

    // --- reset array representations
    cacheCollection = null;
    commandCollection = null;

    // --- trying to talk to random peer
    IRequest answer = null;
    Address peer = null;
    for (int i = 0; i < peers.size(); ++i) {
      if (!shouldLive) return false;

      peer = ((ContributionBox) peers.get(i)).contributor;
      Logger.debug(logSender, "asking " + peer);

      answer = observer.fireMessage(peer, "collectiveUpdate-" + name, this);
      while (answer.getStatus() == IRequest.WAITING) {
        try {
          Thread.sleep(100);
        } catch (Exception e) {
        }
      }
      if (answer.getStatus() == IRequest.DONE) break;
      Logger.debug(logSender, "not accessable: " + peer);
    }

    if (answer.getStatus() != IRequest.DONE) {
      Logger.debug(logSender, "no accessable peers");
      observer.collectiveUpdated(null);
      return false;
    } else {
      Collective c = (Collective) answer.getInfo("reply");

      // --- remove possible garbage
      if (contributor != null) {
        cache.remove(contributor.getName());
        c.cache.remove(contributor.getName());
      }
      cache.remove(peer.name);
      c.cache.remove(peer.name);

      repairSenderAddress(c, peer);
      merge(c);
      observer.collectiveUpdated((ContributionBox) cache.get(c.myContribution.contributor.name));
      return true;
    }
  }