コード例 #1
0
 /**
  * Removes an allocation threshold action.
  *
  * <p>Removes the allocation threshold action for the given level and direction.
  *
  * @param direction registered actions direction
  * @param threshold registered actions threshold level
  * @return the removed condition or {@code null} if no action was present.
  */
 public synchronized Runnable removeAllocationThreshold(
     ThresholdDirection direction, long threshold) {
   switch (direction) {
     case RISING:
       return risingThresholds.remove(threshold);
     case FALLING:
       return fallingThresholds.remove(threshold);
   }
   throw new AssertionError();
 }
コード例 #2
0
  /** public for testing purposes */
  public synchronized void removeOldBackups() {

    SortedMap<Long, File> filesMap = getBackupFiles();

    if (filesMap.size() > 0) {

      Calendar rangeStart = TaskActivityUtil.getCalendar();
      rangeStart.setTimeInMillis(filesMap.lastKey());
      TaskActivityUtil.snapStartOfHour(rangeStart);
      int startHour = rangeStart.get(Calendar.HOUR_OF_DAY);
      Calendar rangeEnd = TaskActivityUtil.getCalendar();
      rangeEnd.setTimeInMillis(rangeStart.getTimeInMillis());
      rangeEnd.add(Calendar.HOUR_OF_DAY, 1);
      // Keep one backup for last 8 hours of today
      for (int x = 0; x <= startHour && x < 9; x++) {
        SortedMap<Long, File> subMap =
            filesMap.subMap(rangeStart.getTimeInMillis(), rangeEnd.getTimeInMillis());
        if (subMap.size() > 1) {
          while (subMap.size() > 1) {
            File toDelete = subMap.remove(subMap.firstKey());
            toDelete.delete();
          }
        }
        rangeStart.add(Calendar.HOUR_OF_DAY, -1);
        rangeEnd.add(Calendar.HOUR_OF_DAY, -1);
      }

      // Keep one backup a day for the past 12 days
      TaskActivityUtil.snapStartOfDay(rangeEnd);
      rangeStart.add(Calendar.DAY_OF_YEAR, -1);
      for (int x = 1; x <= 12; x++) {
        SortedMap<Long, File> subMap =
            filesMap.subMap(rangeStart.getTimeInMillis(), rangeEnd.getTimeInMillis());
        if (subMap.size() > 1) {
          while (subMap.size() > 1) {
            File toDelete = subMap.remove(subMap.firstKey());
            toDelete.delete();
          }
        }
        rangeStart.add(Calendar.DAY_OF_YEAR, -1);
        rangeEnd.add(Calendar.DAY_OF_YEAR, -1);
      }

      // Remove all older backups
      SortedMap<Long, File> subMap = filesMap.subMap(0l, rangeStart.getTimeInMillis());
      if (subMap.size() > 0) {
        while (subMap.size() > 0) {
          File toDelete = subMap.remove(subMap.firstKey());
          toDelete.delete();
        }
      }
    }
  }
コード例 #3
0
 /**
  * Set a function handler for the specific named function optionally tagging the function as
  * impure, replacing any existing handler for the given name; if the handler is null the function
  * handler is removed.
  *
  * <p>Pure functions have results which depend purely on their arguments; given constant arguments
  * they will have a constant result. Impure functions are rare.
  */
 public MathEval setFunctionHandler(String nam, FunctionHandler hdl, boolean impure) {
   validateName(nam);
   if (hdl == null) {
     pureFunctions.remove(nam);
     impureFunctions.remove(nam);
   } else if (impure) {
     pureFunctions.remove(nam);
     impureFunctions.put(nam, hdl);
   } else {
     pureFunctions.put(nam, hdl);
     impureFunctions.remove(nam);
   }
   return this;
 }
コード例 #4
0
  /**
   * Abort the transaction.
   *
   * @param transactionId
   * @throws IOException
   */
  public void abort(final long transactionId) throws IOException {
    // Not checking closing...
    TransactionState state;
    try {
      state = getTransactionState(transactionId);
    } catch (UnknownTransactionException e) {
      LOG.info(
          "Asked to abort unknown transaction ["
              + transactionId
              + "] in region ["
              + getRegionInfo().getRegionNameAsString()
              + "], ignoring");
      return;
    }

    state.setStatus(Status.ABORTED);

    if (state.hasWrite()) {
      this.transactionLog.writeAbortToLog(super.getRegionInfo(), state.getTransactionId());
    }

    // Following removes needed if we have voted
    if (state.getSequenceNumber() != null) {
      commitedTransactionsBySequenceNumber.remove(state.getSequenceNumber());
    }
    commitPendingTransactions.remove(state);

    retireTransaction(state);
  }
コード例 #5
0
  public void noMoreInstances() throws MaltChainedException {
    //		if (getGuide().getGuideMode() == Guide.GuideMode.CLASSIFY) {
    //			throw new GuideException("Can only finish all data during learning. ");
    //		}

    if (divideModels != null) {
      divideFeature.updateCardinality();
      for (Integer index : divideModels.keySet()) {
        divideModels.get(index).noMoreInstances();
      }
      final TreeSet<Integer> removeSet = new TreeSet<Integer>();
      for (Integer index : divideModels.keySet()) {
        if (divideModels.get(index).getFrequency() <= divideThreshold) {
          divideModels
              .get(index)
              .moveAllInstances(masterModel, divideFeature, divideFeatureIndexVector);
          removeSet.add(index);
        }
      }
      for (Integer index : removeSet) {
        divideModels.remove(index);
      }
      masterModel.noMoreInstances();

    } else {
      throw new GuideException("The feature divide models cannot be found. ");
    }
  }
コード例 #6
0
 public void testSubMapContents2() {
   ConcurrentNavigableMap map = map5();
   SortedMap sm = map.subMap(two, three);
   assertEquals(1, sm.size());
   assertEquals(two, sm.firstKey());
   assertEquals(two, sm.lastKey());
   assertFalse(sm.containsKey(one));
   assertTrue(sm.containsKey(two));
   assertFalse(sm.containsKey(three));
   assertFalse(sm.containsKey(four));
   assertFalse(sm.containsKey(five));
   Iterator i = sm.keySet().iterator();
   Object k;
   k = (Integer) (i.next());
   assertEquals(two, k);
   assertFalse(i.hasNext());
   Iterator j = sm.keySet().iterator();
   j.next();
   j.remove();
   assertFalse(map.containsKey(two));
   assertEquals(4, map.size());
   assertEquals(0, sm.size());
   assertTrue(sm.isEmpty());
   assertSame(sm.remove(three), null);
   assertEquals(4, map.size());
 }
コード例 #7
0
 @Override
 public void onNodeRemoved(OperationsNodeInfo node) {
   for (int i = 0; i < replicas; i++) {
     LOG.trace("Removing node {} replica {} from the circle", node.getConnectionInfo(), i);
     circle.remove(hash(node, i));
   }
 }
コード例 #8
0
ファイル: HttpState.java プロジェクト: nlevitt/heritrix3
  // BEGIN IA/HERITRIX CHANGES
  public /*synchronized*/ void addCookie(Cookie cookie) {
    LOG.trace("enter HttpState.addCookie(Cookie)");

    // PRIOR IMPL & COMPARISON HARNESS LEFT COMMENTED OUT FOR TEMPORARY REFERENCE
    //        Cookie removed1 = null;
    //        Cookie removed2 = null;
    if (cookie != null) {
      // first remove any old cookie that is equivalent
      //            for (Iterator it = cookiesArrayList.iterator(); it.hasNext();) {
      //                Cookie tmp = (Cookie) it.next();
      //                if (cookie.equals(tmp)) {
      //                    it.remove();
      //                    removed1 = tmp;
      //                    break;
      //                }
      //            }
      if (!cookie.isExpired()) {
        //                cookiesArrayList.add(cookie);
        cookiesMap.put(cookie.getSortKey(), cookie);
      } else {
        cookiesMap.remove(cookie.getSortKey());
      }
    }
    //        if(removed1!=null && !removed1.equals(removed2)) {
    //            System.out.println("addCookie discrepancy");
    //        }
    // END IA/HERITRIX CHANGES
  }
コード例 #9
0
 private void updateParentChildren(
     SortedMap<String, Requirement> map, String parent, Requirement entry) {
   Requirement parentRequirement = map.get(parent);
   Requirement updatedParentRequirement = parentRequirement.withChild(entry);
   map.remove(parent);
   map.put(parent, updatedParentRequirement);
 }
コード例 #10
0
ファイル: FailoverMonitorView.java プロジェクト: eclipse/cdo
    public Channel getChannel(String name) {
      synchronized (channels) {
        Channel channel = channels.get(name);
        if (channel == null) {
          boolean resize = false;

          channel = channels.remove(INITIAL);
          if (channel == null) {
            channel = new Channel(name);
            resize = true;
          } else {
            channel.setName(name);
          }

          channels.put(name, channel);
          channelArray = channels.values().toArray(new Channel[channels.size()]);

          if (resize) {
            getDisplay()
                .syncExec(
                    new Runnable() {
                      public void run() {
                        controlResized(null);
                      }
                    });
          }
        }

        return channel;
      }
    }
コード例 #11
0
ファイル: CArray.java プロジェクト: Techcable/CommandHelper
 /**
  * Removes the value at the specified key
  *
  * @param construct
  * @return
  */
 public Construct remove(Construct construct) {
   String c = normalizeConstruct(construct);
   Construct ret;
   if (!associative_mode) {
     try {
       ret = array.remove(Integer.parseInt(c));
       next_index--;
     } catch (NumberFormatException e) {
       throw ConfigRuntimeException.BuildException(
           "Expecting an integer, but received \""
               + c
               + "\" (were you expecting an associative array? This array is a normal array.)",
           ExceptionType.CastException,
           construct.getTarget());
     } catch (IndexOutOfBoundsException e) {
       throw ConfigRuntimeException.BuildException(
           "Cannot remove the value at '" + c + "', as no such index exists in the array",
           ExceptionType.RangeException,
           construct.getTarget());
     }
   } else {
     ret = associative_array.remove(c);
   }
   regenValue(new HashSet<CArray>());
   return ret;
 }
コード例 #12
0
  public synchronized void removeField(String fieldName) {
    if ((fieldName == null) || (fieldName.equals(""))) {
      return;
    }

    descriptorMap.remove(fieldName);
  }
コード例 #13
0
    private synchronized TaskAttemptId getAndRemove(int volumeId) {
      TaskAttemptId taskAttemptId = null;
      if (!unassignedTaskForEachVolume.containsKey(volumeId)) {
        if (volumeId > REMOTE) {
          diskVolumeLoads.remove(volumeId);
        }
        return taskAttemptId;
      }

      LinkedHashSet<TaskAttempt> list = unassignedTaskForEachVolume.get(volumeId);
      if (list != null && !list.isEmpty()) {
        TaskAttempt taskAttempt;
        synchronized (unassignedTaskForEachVolume) {
          Iterator<TaskAttempt> iterator = list.iterator();
          taskAttempt = iterator.next();
          iterator.remove();
        }

        taskAttemptId = taskAttempt.getId();
        for (DataLocation location : taskAttempt.getTask().getDataLocations()) {
          HostVolumeMapping volumeMapping =
              scheduledRequests.leafTaskHostMapping.get(location.getHost());
          if (volumeMapping != null) {
            volumeMapping.removeTaskAttempt(location.getVolumeId(), taskAttempt);
          }
        }

        increaseConcurrency(volumeId);
      }

      return taskAttemptId;
    }
コード例 #14
0
  /* If you set jmx.serial.form to "1.2.0" or "1.2.1", then we are
     bug-compatible with those versions.  Specifically, field names
     are forced to lower-case before being written.  This
     contradicts the spec, which, though it does not mention
     serialization explicitly, does say that the case of field names
     is preserved.  But in 1.2.0 and 1.2.1, this requirement was not
     met.  Instead, field names in the descriptor map were forced to
     lower case.  Those versions expect this to have happened to a
     descriptor they deserialize and e.g. getFieldValue will not
     find a field whose name is spelt with a different case.
  */
  private void writeObject(ObjectOutputStream out) throws IOException {
    ObjectOutputStream.PutField fields = out.putFields();
    boolean compat = "1.0".equals(serialForm);
    if (compat) fields.put("currClass", currClass);

    /* Purge the field "targetObject" from the DescriptorSupport before
     * serializing since the referenced object is typically not
     * serializable.  We do this here rather than purging the "descriptor"
     * variable below because that HashMap doesn't do case-insensitivity.
     * See CR 6332962.
     */
    SortedMap<String, Object> startMap = descriptorMap;
    if (startMap.containsKey("targetObject")) {
      startMap = new TreeMap<String, Object>(descriptorMap);
      startMap.remove("targetObject");
    }

    final HashMap<String, Object> descriptor;
    if (compat || "1.2.0".equals(serialForm) || "1.2.1".equals(serialForm)) {
      descriptor = new HashMap<String, Object>();
      for (Map.Entry<String, Object> entry : startMap.entrySet())
        descriptor.put(entry.getKey().toLowerCase(), entry.getValue());
    } else descriptor = new HashMap<String, Object>(startMap);

    fields.put("descriptor", descriptor);
    out.writeFields();
  }
コード例 #15
0
ファイル: DB.java プロジェクト: huangjun-pg/MapDB
  /**
   * rename named record into newName
   *
   * @param oldName current name of record/collection
   * @param newName new name of record/collection
   * @throws NoSuchElementException if oldName does not exist
   */
  public synchronized void rename(String oldName, String newName) {
    if (oldName.equals(newName)) return;

    Map<String, Object> sub = catalog.tailMap(oldName);
    List<String> toRemove = new ArrayList<String>();

    for (String param : sub.keySet()) {
      if (!param.startsWith(oldName)) break;

      String suffix = param.substring(oldName.length());
      catalog.put(newName + suffix, catalog.get(param));
      toRemove.add(param);
    }
    if (toRemove.isEmpty())
      throw new NoSuchElementException("Could not rename, name does not exist: " + oldName);

    WeakReference old = namesInstanciated.remove(oldName);
    if (old != null) {
      Object old2 = old.get();
      if (old2 != null) {
        namesLookup.remove(old2);
        namedPut(newName, old2);
      }
    }
    for (String param : toRemove) catalog.remove(param);
  }
コード例 #16
0
 public void testDescendingSubMapContents2() {
   ConcurrentNavigableMap map = dmap5();
   SortedMap sm = map.subMap(m2, m3);
   assertEquals(1, sm.size());
   assertEquals(m2, sm.firstKey());
   assertEquals(m2, sm.lastKey());
   assertFalse(sm.containsKey(m1));
   assertTrue(sm.containsKey(m2));
   assertFalse(sm.containsKey(m3));
   assertFalse(sm.containsKey(m4));
   assertFalse(sm.containsKey(m5));
   Iterator i = sm.keySet().iterator();
   Object k;
   k = (Integer) (i.next());
   assertEquals(m2, k);
   assertFalse(i.hasNext());
   Iterator j = sm.keySet().iterator();
   j.next();
   j.remove();
   assertFalse(map.containsKey(m2));
   assertEquals(4, map.size());
   assertEquals(0, sm.size());
   assertTrue(sm.isEmpty());
   assertSame(sm.remove(m3), null);
   assertEquals(4, map.size());
 }
コード例 #17
0
 public synchronized boolean put(final String key, String value) {
   String oldvalue = properties.get(key);
   if (value != null && value.length() == 0) {
     value = null;
   }
   if (!((oldvalue == null && (value == null || value.equals(defaults.get(key))))
       || (value != null && oldvalue != null && oldvalue.equals(value)))) {
     if (value == null) {
       properties.remove(key);
     } else {
       properties.put(key, value);
     }
     try {
       save();
     } catch (IOException e) {
       System.out.println(
           tr(
               "Warning: failed to persist preferences to ''{0}''",
               getPreferenceFile().getAbsoluteFile()));
     }
     firePrefrenceChanged(key, oldvalue, value);
     return true;
   }
   return false;
 }
コード例 #18
0
  @Test
  public void testAssignMigrations() {
    servers.clear();
    servers.put(
        new TServerInstance(HostAndPort.fromParts("127.0.0.1", 1234), "a"), new FakeTServer());
    servers.put(
        new TServerInstance(HostAndPort.fromParts("127.0.0.1", 1235), "b"), new FakeTServer());
    servers.put(
        new TServerInstance(HostAndPort.fromParts("127.0.0.1", 1236), "c"), new FakeTServer());
    List<KeyExtent> metadataTable = new ArrayList<KeyExtent>();
    String table = "t1";
    metadataTable.add(makeExtent(table, null, null));
    table = "t2";
    metadataTable.add(makeExtent(table, "a", null));
    metadataTable.add(makeExtent(table, null, "a"));
    table = "t3";
    metadataTable.add(makeExtent(table, "a", null));
    metadataTable.add(makeExtent(table, "b", "a"));
    metadataTable.add(makeExtent(table, "c", "b"));
    metadataTable.add(makeExtent(table, "d", "c"));
    metadataTable.add(makeExtent(table, "e", "d"));
    metadataTable.add(makeExtent(table, null, "e"));
    Collections.sort(metadataTable);

    TestDefaultLoadBalancer balancer = new TestDefaultLoadBalancer();

    SortedMap<TServerInstance, TabletServerStatus> current =
        new TreeMap<TServerInstance, TabletServerStatus>();
    for (Entry<TServerInstance, FakeTServer> entry : servers.entrySet()) {
      current.put(entry.getKey(), entry.getValue().getStatus(entry.getKey()));
    }
    assignTablets(metadataTable, servers, current, balancer);

    // Verify that the counts on the tables are correct
    Map<String, Integer> expectedCounts = new HashMap<String, Integer>();
    expectedCounts.put("t1", 1);
    expectedCounts.put("t2", 1);
    expectedCounts.put("t3", 2);
    checkBalance(metadataTable, servers, expectedCounts);

    // Rebalance once
    for (Entry<TServerInstance, FakeTServer> entry : servers.entrySet()) {
      current.put(entry.getKey(), entry.getValue().getStatus(entry.getKey()));
    }

    // Nothing should happen, we are balanced
    ArrayList<TabletMigration> out = new ArrayList<TabletMigration>();
    balancer.getMigrations(current, out);
    assertEquals(out.size(), 0);

    // Take down a tabletServer
    TServerInstance first = current.keySet().iterator().next();
    current.remove(first);
    FakeTServer remove = servers.remove(first);

    // reassign offline extents
    assignTablets(remove.extents, servers, current, balancer);
    checkBalance(metadataTable, servers, null);
  }
コード例 #19
0
ファイル: ResourceClass.java プロジェクト: objectledge/coral
 /**
  * Removes an attribute from this resource class.
  *
  * @param attr an attribute.
  * @throws EntityDoesNotExistException if the class does not declare the attribute.
  */
 public void deleteAttribute(Attribute attr) throws EntityDoesNotExistException {
   if (!attributes.containsKey(attr.getName())) {
     throw new EntityDoesNotExistException(
         "class " + getName() + " does not declare attribute " + "named " + attr.getName());
   }
   attributes.remove(attr.getName());
   attr.setDeclaringClass(null);
 }
コード例 #20
0
 /**
  * @param cytobandResultset Removes cytobandResultset to this CopyNumberResultsContainer object.
  */
 public void removeCytobandResultset(CytobandResultset cytobandResultset) {
   if (cytobandResultset != null && cytobandResultset.getCytoband() != null) {
     cytobands.remove(cytobandResultset.getCytoband().toString());
     if (cytobandResultset.getReporterNames() != null) {
       reporterNames.removeAll(cytobandResultset.getReporterNames());
     }
   }
 }
コード例 #21
0
  /**
   * Flush the nodes in order, from the lowest level to highest level. As a flush dirties its
   * parent, add it to the dirty map, thereby cascading the writes up the tree. If flushAll wasn't
   * specified, we need only cascade up to the highest level that existed before the checkpointing
   * started.
   *
   * <p>Note that all but the top level INs and the BINDeltas are logged provisionally. That's
   * because we don't need to process lower INs because the higher INs will end up pointing at them.
   */
  private void flushDirtyNodes(boolean flushAll, boolean allowDeltas, boolean flushExtraLevel)
      throws DatabaseException {

    LogManager logManager = envImpl.getLogManager();

    SortedMap dirtyMap = selectDirtyINs(flushAll, flushExtraLevel);

    while (dirtyMap.size() > 0) {

      /* Work on one level's worth of nodes in ascending level order. */
      Integer currentLevel = (Integer) dirtyMap.firstKey();
      boolean logProvisionally = (currentLevel.intValue() != highestFlushLevel);

      Set nodeSet = (Set) dirtyMap.get(currentLevel);
      Iterator iter = nodeSet.iterator();

      /* Flush all those nodes */
      while (iter.hasNext()) {
        IN target = (IN) iter.next();
        target.latch();
        boolean triedToFlush = false;

        /*
         * Only flush the ones that are still dirty -- some
         * may have been written out by the evictor. Also
         * check if the db is still valid -- since INs of
         * deleted databases are left on the in-memory tree
         * until the evictor lazily clears them out, there may
         * be dead INs around.
         */
        if (target.getDirty() && (!target.getDatabase().getIsDeleted())) {
          flushIN(target, logManager, dirtyMap, logProvisionally, allowDeltas);
          triedToFlush = true;
        } else {
          target.releaseLatch();
        }

        Tracer.trace(
            Level.FINE,
            envImpl,
            "Checkpointer: node="
                + target.getNodeId()
                + " level="
                + Integer.toHexString(target.getLevel())
                + " flushed="
                + triedToFlush);
      }

      /* We're done with this level. */
      dirtyMap.remove(currentLevel);

      /* We can stop at this point. */
      if (currentLevel.intValue() == highestFlushLevel) {
        break;
      }
    }
  }
コード例 #22
0
 /**
  * Set a named variable (variables names are not case-sensitive). If the value is null, the
  * variable is removed.
  */
 public MathEval setVariable(String nam, Double val) {
   validateName(nam);
   if (val == null) {
     variables.remove(nam);
   } else {
     variables.put(nam, val);
   }
   return this;
 }
コード例 #23
0
ファイル: Portfolio.java プロジェクト: simonwrafter/OMXInvest
 public double remove(String omxId) throws ParserConfigurationException {
   if (stockmap.containsKey(omxId)) {
     events.addEvent("Stock removed from portfolio", omxId, invest.getShortName(omxId));
     updateLatestBuy();
     updateLatestSell();
     return stockmap.remove(omxId);
   }
   return 0;
 }
コード例 #24
0
  /** Add a segment with a map */
  public void addSegment(short startCode, short endCode, char[] map) {
    if (map.length != (endCode - startCode) + 1) {
      throw new IllegalArgumentException("Wrong number of entries in map");
    }

    Segment s = new Segment(startCode, endCode, true);
    // make sure we remove any old entries
    segments.remove(s);
    segments.put(s, map);
  }
コード例 #25
0
 /** Decrease the count of running tasks of a certain task runner */
 private synchronized void decreaseConcurrency(int volumeId) {
   if (diskVolumeLoads.containsKey(volumeId)) {
     Integer concurrency = diskVolumeLoads.get(volumeId);
     if (concurrency > 0) {
       diskVolumeLoads.put(volumeId, concurrency - 1);
     } else {
       if (volumeId > REMOTE && !unassignedTaskForEachVolume.containsKey(volumeId)) {
         diskVolumeLoads.remove(volumeId);
       }
     }
   }
 }
コード例 #26
0
    private synchronized void removeTaskAttempt(int volumeId, TaskAttempt taskAttempt) {
      if (!unassignedTaskForEachVolume.containsKey(volumeId)) return;

      LinkedHashSet<TaskAttempt> tasks = unassignedTaskForEachVolume.get(volumeId);
      if (tasks.remove(taskAttempt)) {
        remainTasksNum.getAndDecrement();
      }

      if (tasks.isEmpty()) {
        unassignedTaskForEachVolume.remove(volumeId);
        if (volumeId > REMOTE) {
          diskVolumeLoads.remove(volumeId);
        }
      }
    }
コード例 #27
0
ファイル: ModulesManager.java プロジェクト: pczerkas/Pydev
 public void popTemporaryModule(String moduleName, int handle) {
   synchronized (lockTemporaryModules) {
     SortedMap<Integer, IModule> stack = temporaryModules.get(moduleName);
     try {
       if (stack != null) {
         stack.remove(handle);
         if (stack.size() == 0) {
           temporaryModules.remove(moduleName);
         }
       }
     } catch (Throwable e) {
       Log.log(e);
     }
   }
 }
コード例 #28
0
 @Override
 public void fail(final Object o) {
   if (o instanceof KafkaMessageId) {
     final KafkaMessageId id = (KafkaMessageId) o;
     // delegate decision of replaying the message to failure policy
     if (_failHandler.shouldReplay(id)) {
       LOG.debug("kafka message id {} failed in topology, adding to buffer again", id);
       _queue.add(id);
     } else {
       LOG.debug("kafka message id {} failed in topology, delegating failure to policy", id);
       // remove message from pending; _failHandler will take action if needed
       _failHandler.fail(id, _inProgress.remove(id));
     }
   }
 }
コード例 #29
0
    public IContainer next() {
      String key = containers.firstKey();
      IContainer result = containers.get(key);
      containers.remove(key);
      key += "/";

      // Remove child containers
      SortedMap<String, IContainer> childs = containers.tailMap(key);
      for (Iterator<String> it = childs.keySet().iterator(); it.hasNext(); ) {
        if (it.next().startsWith(key)) it.remove();
        else break;
      }

      return result;
    }
コード例 #30
0
  /** Cleanup references to committed transactions that are no longer needed. */
  synchronized void removeUnNeededCommitedTransactions() {
    Integer minStartSeqNumber = getMinStartSequenceNumber();
    if (minStartSeqNumber == null) {
      minStartSeqNumber = Integer.MAX_VALUE; // Remove all
    }

    int numRemoved = 0;
    // Copy list to avoid conc update exception
    for (Entry<Integer, TransactionState> entry :
        new LinkedList<Entry<Integer, TransactionState>>(
            commitedTransactionsBySequenceNumber.entrySet())) {
      if (entry.getKey() >= minStartSeqNumber) {
        break;
      }
      numRemoved =
          numRemoved
              + (commitedTransactionsBySequenceNumber.remove(entry.getKey()) == null ? 0 : 1);
      numRemoved++;
    }

    if (LOG.isDebugEnabled()) {
      StringBuilder debugMessage = new StringBuilder();
      if (numRemoved > 0) {
        debugMessage.append("Removed [").append(numRemoved).append("] commited transactions");

        if (minStartSeqNumber == Integer.MAX_VALUE) {
          debugMessage.append(" with any sequence number.");
        } else {
          debugMessage.append(" with sequence lower than [").append(minStartSeqNumber).append("].");
        }
        if (!commitedTransactionsBySequenceNumber.isEmpty()) {
          debugMessage
              .append(" Still have [")
              .append(commitedTransactionsBySequenceNumber.size())
              .append("] left.");
        } else {
          debugMessage.append(" None left.");
        }
        LOG.debug(debugMessage.toString());
      } else if (commitedTransactionsBySequenceNumber.size() > 0) {
        debugMessage
            .append("Could not remove any transactions, and still have ")
            .append(commitedTransactionsBySequenceNumber.size())
            .append(" left");
        LOG.debug(debugMessage.toString());
      }
    }
  }