How to use

Versioned

in

voldemort.versioning

private Versioned<byte[]> incremented(Versioned<byte[]> versioned, int nodeId) {
  return new Versioned<byte[]>(versioned.getValue(),
                 ((VectorClock) versioned.getVersion()).incremented(nodeId,
                                          time.getMilliseconds()));
}

public Version putSysStore(K key, V value) {
  Version version = null;
  try {
    if(logger.isDebugEnabled()) {
      logger.debug("Invoking Put for key : " + key + " on store name : " + this.storeName);
    }
    Versioned<V> versioned = getSysStore(key);
    if(versioned == null)
      versioned = Versioned.value(value, new VectorClock());
    else
      versioned.setObject(value);
    this.sysStore.put(key, versioned, null);
    version = versioned.getVersion();
  } catch(Exception e) {
    if(logger.isDebugEnabled()) {
      logger.debug("Exception caught during putSysStore: " + e);
    }
  }
  return version;
}

@Override
public void put(K key, Versioned<V> value, T transforms) throws VoldemortException {
  value = value.cloneVersioned();
  VectorClock clock = (VectorClock) value.getVersion();
  clock.incrementVersion(nodeId, time.getMilliseconds());
  super.put(key, value, transforms);
}

public UpdateElementById(VListKey<K> key, Versioned<E> element) {
  _key = key;
  _element = element.getValue();
  _version = element.getVersion();
}

/**
 * Create a clone of this Versioned object such that the object pointed to
 * is the same, but the VectorClock and Versioned wrapper is a shallow copy.
 */
public Versioned<T> cloneVersioned() {
  return new Versioned<T>(this.getValue(), this.version.clone());
}

@Override
public void update(StoreClient<Map<String, Object>, Map<String, Object>> storeClient) {
  if(numCalls > 0) {
    // TODO jko maybe delete this if unnecessary
    Versioned<Map<String, Object>> nextNodeMap = storeClient.get(_key.mapValue());
    if(nextNodeMap == null)
      throw new ObsoleteVersionException("possible concurrent modification");
    _listNode = new Versioned<VListNode<E>>(VListNode.<E> valueOf(nextNodeMap.getValue()),
                        nextNodeMap.getVersion());
  }
  VListNode<E> nodeValue = _listNode.getValue();
  _listNode.setObject(new VListNode<E>(nodeValue.getValue(),
                     nodeValue.getId(),
                     _newId,
                     nodeValue.getNextId(),
                     true));
  Map<String, Object> nextNodeMap = _listNode.getValue().mapValue();
  storeClient.put(_key.mapValue(), nextNodeMap);
  numCalls++;
}

/**
 * An empty Versioned<V> value object is created and passed on to the actual
 * put operation. It defers the task of obtaining the existing Vector clock
 * to the Receiver of this request.
 */
@Override
public Version put(K key, V value) {
  return put(key, new Versioned<V>(value));
}

@Override
public void put(ByteArray key, Versioned<byte[]> value, byte[] transforms)
    throws VoldemortException {
  if(valueCompressionStrategy != null)
    value = inflateValue(value);
  Versioned<byte[]> result = Versioned.value(valueFromViewSchema(key,
                                  value.getValue(),
                                  transforms),
                        value.getVersion());
  if(valueCompressionStrategy != null)
    result = deflateValue(result);
  target.put(key, result, null);
}

@SuppressWarnings("unchecked")
public List<StoreDefinition> getRebalancingSourceStores() {
  // acquire read lock
  readLock.lock();
  try {
    return (List<StoreDefinition>) metadataCache.get(REBALANCING_SOURCE_STORES_XML)
                          .getValue();
  } finally {
    readLock.unlock();
  }
}

public synchronized void fetchAndUpdateRemoteMetadata(int nodeId, String key, String value) {
  VectorClock currentClock = (VectorClock) getRemoteMetadata(nodeId, key).getVersion();
  updateRemoteMetadata(nodeId,
             key,
             new Versioned<String>(Boolean.toString(false),
                        currentClock.incremented(nodeId, 1)));
}

  @Override
  public void doOperation(int index) {
    try {
      String key = Integer.toString(index);
      List<Versioned<byte[]>> vs = store.get(key, null);
      VectorClock version;
      if(vs.size() == 0)
        version = new VectorClock();
      else
        version = (VectorClock) vs.get(0).getVersion();
      version.incrementVersion(0, 847584375);
      store.put(key, Versioned.value(value, version), null);
    } catch(ObsoleteVersionException e) {
      // do nothing
    } catch(RuntimeException e) {
      e.printStackTrace();
      throw e;
    }
  }
}, recents, numValues, cacheHitRatio);

Version obsoleteVersion = ((VectorClock) versionedValue.getVersion()).clone();
versionedValue.setObject("New Value !!!");
System.out.println("************* original version : " + versionedValue.getVersion());
Version putVersion = storeClient.put("a", versionedValue);
System.out.println("************* Updated version : " + putVersion);
Versioned<String> obsoleteVersionedValue = new Versioned<String>("Obsolete value",
                                 obsoleteVersion);
try {
Versioned<String> newVersionedPut = new Versioned<String>("Yet another value !!!",
                             putVersion);
storeClient.put("a", newVersionedPut);

@Override
protected Versioned<Slop> computeNext() {
  try {
    Versioned<Slop> head = null;
    if(!shutDown) {
      head = slopQueue.take();
      if(head.equals(END)) {
        shutDown = true;
        isComplete = true;
      } else {
        slopsDone++;
        if(slopsDone % voldemortConfig.getSlopBatchSize() == 0) {
          shutDown = true;
        }
        writeThrottler.maybeThrottle(writtenLast);
        writtenLast = slopSize(head);
        deleteBatch.add(Pair.create(head.getValue().makeKey(),
                      (Version) head.getVersion()));
        return head;
      }
    }
    return endOfData();
  } catch(Exception e) {
    logger.error("Got an exception " + e);
    return endOfData();
  }
}

public void testGetAll() {
  target1.put("a", Versioned.value("a"), null);
  target1.put("b", Versioned.value("b"), null);
  Map<String, List<Versioned<String>>> found = valView.getAll(ImmutableList.of("a", "b"),
                                ImmutableMap.of("a",
                                        "concat",
                                        "b",
                                        "concat"));
  assertTrue(found.containsKey("a"));
  assertTrue(found.containsKey("b"));
  assertEquals("a42", found.get("a").get(0).getValue());
  assertEquals("b42", found.get("b").get(0).getValue());
}

@Override
public List<Version> getVersions(String key) {
  List<Versioned<String>> values = get(key, (String) null);
  List<Version> versions = new ArrayList<Version>(values.size());
  for(Versioned<?> value: values) {
    versions.add(value.getVersion());
  }
  return versions;
}

public void testClone() {
  Versioned<Integer> v1 = getVersioned(2, 1, 2, 3);
  Versioned<Integer> v2 = v1.cloneVersioned();
  assertEquals(v1, v2);
  assertTrue(v1 != v2);
  assertTrue(v1.getVersion() != v2.getVersion());
  ((VectorClock) v2.getVersion()).incrementVersion(1, System.currentTimeMillis());
  assertTrue(!v1.equals(v2));
}

public void testEquals() {
  assertEquals("Null versioneds not equal.", getVersioned(null), getVersioned(null));
  assertEquals("equal versioneds not equal.", getVersioned(1), getVersioned(1));
  assertEquals("equal versioneds not equal.", getVersioned(1, 1, 2), getVersioned(1, 1, 2));
  assertTrue("Equals values with different version are equal!",
        !getVersioned(1, 1, 2).equals(getVersioned(1, 1, 2, 2)));
  assertTrue("Different values with same version are equal!",
        !getVersioned(1, 1, 2).equals(getVersioned(2, 1, 2)));
  assertTrue("Different values with different version are equal!",
        !getVersioned(1, 1, 2).equals(getVersioned(2, 1, 1, 2)));
  // Should work for array types too!
  assertEquals("Equal arrays are not equal!",
         new Versioned<byte[]>(new byte[] { 1 }),
         new Versioned<byte[]>(new byte[] { 1 }));
}

  versioned = Versioned.value(requestWrapper.getRawValue(), new VectorClock());
else
  versioned.setObject(requestWrapper.getRawValue());

public Version put(K key, V value, Object transforms) {
  Version version = getVersionForPut(key);
  Versioned<V> versioned = Versioned.value(value, version);
  return put(key, versioned, transforms);
}

  public void run() {
    boolean done = false;
    while(!done) {
      try {
        byte[] key = Integer.toString(index).getBytes();
        List<Versioned<byte[]>> found = store.get(key, null);
        if(found.size() > 1) {
          throw new RuntimeException("Found multiple versions: " + found);
        } else if(found.size() == 1) {
          Versioned<byte[]> versioned = found.get(0);
          byte[] valueBytes = Integer.toString(MultithreadedStressTest.this.value.getAndIncrement())
                        .getBytes();
          versioned.setObject(valueBytes);
          store.put(key, versioned, null);
          done = true;
        } else if(found.size() == 0) {
          throw new RuntimeException("No values found!");
        }
      } catch(ObsoleteVersionException e) {
        obsoletes.getAndIncrement();
      } finally {
        isDone.countDown();
      }
    }
  }
});