/**
* Should only be called by ColumnFamilyStore.apply via Keyspace.apply, which supplies the
* appropriate OpOrdering.
*
* <p>replayPosition should only be null if this is a secondary index, in which case it is
* *expected* to be null
*/
long put(PartitionUpdate update, UpdateTransaction indexer, OpOrder.Group opGroup) {
AtomicBTreePartition previous = partitions.get(update.partitionKey());
long initialSize = 0;
if (previous == null) {
final DecoratedKey cloneKey = allocator.clone(update.partitionKey(), opGroup);
AtomicBTreePartition empty = new AtomicBTreePartition(cfs.metadata, cloneKey, allocator);
// We'll add the columns later. This avoids wasting works if we get beaten in the putIfAbsent
previous = partitions.putIfAbsent(cloneKey, empty);
if (previous == null) {
previous = empty;
// allocate the row overhead after the fact; this saves over allocating and having to free
// after, but
// means we can overshoot our declared limit.
int overhead = (int) (cloneKey.getToken().getHeapSize() + ROW_OVERHEAD_HEAP_SIZE);
allocator.onHeap().allocate(overhead, opGroup);
initialSize = 8;
} else {
allocator.reclaimer().reclaimImmediately(cloneKey);
}
}
long[] pair = previous.addAllWithSizeDelta(update, opGroup, indexer);
minTimestamp = Math.min(minTimestamp, previous.stats().minTimestamp);
liveDataSize.addAndGet(initialSize + pair[0]);
columnsCollector.update(update.columns());
statsCollector.update(update.stats());
currentOperations.addAndGet(update.operationCount());
return pair[1];
}
public Binding addBinding(Binding newBinding) {
ResourceAddress bindAddress = newBinding.bindAddress();
String nextProtocol = bindAddress.getOption(NEXT_PROTOCOL);
if (nextProtocol == null) {
if (nullNextProtocol.compareAndSet(null, newBinding)) {
newBinding.incrementReferenceCount();
return null;
}
Binding oldBinding = nullNextProtocol.get();
if (equivalent(newBinding, oldBinding)) {
oldBinding.incrementReferenceCount();
return null;
}
return oldBinding;
}
Binding oldBinding = nextProtocols.putIfAbsent(nextProtocol, newBinding);
if (oldBinding == null) {
newBinding.incrementReferenceCount();
} else if (equivalent(newBinding, oldBinding)) {
oldBinding.incrementReferenceCount();
oldBinding = null;
}
return oldBinding;
}
/** {@inheritDoc} */
@Override
@Validate
public V putIfAbsent(@NotNull final T key, @NotNull final K subkey, V value) {
ConcurrentSkipListMap<K, V> newer = new ConcurrentSkipListMap<K, V>();
ConcurrentNavigableMap<K, V> m = map.putIfAbsent(key, newer);
if (m == null) m = newer;
return m.putIfAbsent(subkey, value);
}
/** putIfAbsent(null, x) throws NPE */
public void testPutIfAbsent1_NullPointerException() {
try {
ConcurrentNavigableMap c = map5();
c.putIfAbsent(null, "whatever");
shouldThrow();
} catch (NullPointerException success) {
}
}
public static void handleOrphan(Cluster cluster, ClusterAddressInfo address) {
Integer orphanCount = 1;
orphanCount = orphans.putIfAbsent(address, orphanCount);
orphanCount = (orphanCount == null) ? 1 : orphanCount;
orphans.put(address, orphanCount + 1);
EventRecord.caller(
ClusterState.class,
EventType.ADDRESS_STATE,
"Updated orphaned public ip address: "
+ LogUtil.dumpObject(address)
+ " count="
+ orphanCount)
.debug();
if (orphanCount > AddressingConfiguration.getInstance().getMaxKillOrphans()) {
EventRecord.caller(
ClusterState.class,
EventType.ADDRESS_STATE,
"Unassigning orphaned public ip address: "
+ LogUtil.dumpObject(address)
+ " count="
+ orphanCount)
.warn();
try {
final Address addr = Addresses.getInstance().lookup(address.getAddress());
if (addr.isPending()) {
try {
addr.clearPending();
} catch (Exception ex) {
}
}
try {
if (addr.isAssigned() && "0.0.0.0".equals(address.getInstanceIp())) {
addr.unassign().clearPending();
if (addr.isSystemOwned()) {
addr.release();
}
} else if (addr.isAssigned() && !"0.0.0.0".equals(address.getInstanceIp())) {
AsyncRequests.newRequest(new UnassignAddressCallback(address))
.sendSync(cluster.getConfiguration());
if (addr.isSystemOwned()) {
addr.release();
}
} else if (!addr.isAssigned() && addr.isAllocated() && addr.isSystemOwned()) {
addr.release();
}
} catch (ExecutionException ex) {
if (!addr.isAssigned() && addr.isAllocated() && addr.isSystemOwned()) {
addr.release();
}
}
} catch (InterruptedException ex) {
Exceptions.maybeInterrupted(ex);
} catch (NoSuchElementException ex) {
} finally {
orphans.remove(address);
}
}
}
private void resolve(DecoratedKey key, ColumnFamily cf) {
currentThroughput.addAndGet(cf.size());
currentOperations.addAndGet(
(cf.getColumnCount() == 0) ? cf.isMarkedForDelete() ? 1 : 0 : cf.getColumnCount());
ColumnFamily oldCf = columnFamilies.putIfAbsent(key, cf);
if (oldCf == null) return;
oldCf.resolve(cf);
}
private static void handleOrphan(String cluster, Address address) {
Integer orphanCount = 1;
orphanCount = orphans.putIfAbsent(address.getName(), orphanCount);
orphanCount = (orphanCount == null) ? 1 : orphanCount;
orphans.put(address.getName(), orphanCount + 1);
LOG.warn("Found orphaned public ip address: " + address + " count=" + orphanCount);
if (orphanCount > 10) {
orphans.remove(address.getName());
Clusters.dispatchClusterEvent(cluster, new UnassignAddressCallback(address));
}
}
private void registerRemoval(String id, long lifeTime, TimeUnit unit) {
ITaskManagerHook hook = taskManagerHooks.get(id);
if (hook != null) {
long removalTime = unit.toMillis(lifeTime) + System.currentTimeMillis();
// Remove current scheduled removal
Long currentRemovalTime = taskManagerRemovalBackRegister.get(hook);
if (currentRemovalTime != null) {
taskManagerRemovalRegister.remove(currentRemovalTime);
}
// Find an empty spot in the sorted map's key register
removalTime--;
do {
removalTime++;
taskManagerRemovalRegister.putIfAbsent(removalTime, hook);
} while (taskManagerRemovalRegister.get(removalTime) != hook);
// Back reference the removal
taskManagerRemovalBackRegister.put(hook, removalTime);
}
}
/** putIfAbsent does not add the pair if the key is already present */
public void testDescendingPutIfAbsent2() {
ConcurrentNavigableMap map = dmap5();
assertEquals("A", map.putIfAbsent(m1, "Z"));
}
/** putIfAbsent works when the given key is not present */
public void testDescendingPutIfAbsent() {
ConcurrentNavigableMap map = dmap5();
map.putIfAbsent(six, "Z");
assertTrue(map.containsKey(six));
}
/** putIfAbsent does not add the pair if the key is already present */
public void testPutIfAbsent2() {
ConcurrentNavigableMap map = map5();
assertEquals("A", map.putIfAbsent(one, "Z"));
}
