How to use

voldemort.versioning.Versioned

constructor

protected Versioned<byte[]> generateVersionedValue(int length) {
  // generate random bytes for values of given lenght
  byte[] value = new byte[length];
  random.nextBytes(value);
  return new Versioned<byte[]>(value);
}

@Override
public void put(K key, Versioned<byte[]> value, byte[] transforms) throws VoldemortException {
  try {
    getInnerStore().put(key,
              new Versioned<byte[]>(IOUtils.toByteArray(new GZIPInputStream(new ByteArrayInputStream(value.getValue()))),
                         value.getVersion()),
              transforms);
  } catch(IOException e) {
    throw new VoldemortException(e);
  }
}

private void initSystemRoutingStrategies(Cluster cluster) {
  HashMap<String, RoutingStrategy> routingStrategyMap = createRoutingStrategyMap(cluster,
                                          makeStoreDefinitionMap(getSystemStoreDefList()));
  this.metadataCache.put(SYSTEM_ROUTING_STRATEGY_KEY,
              new Versioned<Object>(routingStrategyMap));
}

/**
 * Get the ver
 * 
 * @param id
 * @return
 */
public Versioned<E> getVersionedById(int id) {
  Versioned<VListNode<E>> listNode = getListNode(id);
  if(listNode == null)
    throw new IndexOutOfBoundsException();
  return new Versioned<E>(listNode.getValue().getValue(), listNode.getVersion());
}

  @Override
  protected Pair<ByteArray, Versioned<byte[]>> computeNext() {
    while(entrySetItr.hasNext()) {
      Entry<ByteArray, byte[]> entry = entrySetItr.next();
      return new Pair<ByteArray, Versioned<byte[]>>(entry.getKey(),
                             new Versioned<byte[]>(entry.getValue()));
    }
    return endOfData();
  }
};

@Override
protected Set<Pair<ByteArray, Versioned<byte[]>>> createEntries() {
  Set<Pair<ByteArray, Versioned<byte[]>>> entrySet = new HashSet<Pair<ByteArray, Versioned<byte[]>>>();
  for(Entry<ByteArray, byte[]> entry: ServerTestUtils.createRandomKeyValuePairs(TEST_KEYS)
                            .entrySet()) {
    entrySet.add(new Pair<ByteArray, Versioned<byte[]>>(entry.getKey(),
                              new Versioned<byte[]>(entry.getValue())));
  }
  return entrySet;
}

@Override
protected Set<Pair<ByteArray, Versioned<byte[]>>> createEntries() {
  Set<Pair<ByteArray, Versioned<byte[]>>> entrySet = new HashSet<Pair<ByteArray, Versioned<byte[]>>>();
  for(Entry<ByteArray, byte[]> entry: ServerTestUtils.createRandomKeyValuePairs(TEST_KEYS)
                            .entrySet()) {
    entrySet.add(new Pair<ByteArray, Versioned<byte[]>>(entry.getKey(),
                              new Versioned<byte[]>(entry.getValue())));
  }
  return entrySet;
}

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
  protected Pair<ByteArray, Versioned<byte[]>> computeNext() {
    if(Math.random() > FAIL_PROBABILITY) {
      throw new VoldemortException("Failing Iterator.");
    }
    if(!innerIterator.hasNext())
      return endOfData();
    Entry<ByteArray, byte[]> entry = innerIterator.next();
    return new Pair<ByteArray, Versioned<byte[]>>(entry.getKey(),
                           new Versioned<byte[]>(entry.getValue()));
  }
};

private void putAlltoStore() {
  for(Entry<ByteArray, byte[]> entry: ServerTestUtils.createRandomKeyValuePairs(TEST_KEYS)
                            .entrySet()) {
    try {
      failingStorageEngine.put(entry.getKey(),
                   new Versioned<byte[]>(entry.getValue()),
                   null);
    } catch(Exception e) {
      // ignore
    }
  }
}

public Versioned<E> peekVersioned() {
  Versioned<VListNode<E>> node = getListNode(0);
  if(node == null) {
    return null;
  } else {
    return new Versioned<E>(node.getValue().getValue(), node.getVersion());
  }
}

private Versioned<byte[]> inflateValue(Versioned<byte[]> versioned) throws VoldemortException {
  byte[] inflatedData = null;
  try {
    inflatedData = valueCompressionStrategy.inflate(versioned.getValue());
  } catch(IOException e) {
    throw new VoldemortException(e);
  }
  return new Versioned<byte[]>(inflatedData, versioned.getVersion());
}

private void putWithTimeStamp(int start, int end, long milliseconds) {
  for (int i = start; i < end; i++) {
    ByteArray b = new ByteArray(Integer.toString(i).getBytes());
    VectorClock clock = new VectorClock(milliseconds);
    Versioned<byte[]> value = new Versioned<byte[]>(b.get(), clock);
    engine.put(b, value, null);
  }
}

public void testNoPressureBehavior() {
  StorageEngine<ByteArray, byte[], byte[]> engine = getStorageEngine();
  byte[] bytes = "abc".getBytes();
  ByteArray key = new ByteArray(bytes);
  engine.put(key, new Versioned<byte[]>(bytes), null);
  List<Versioned<byte[]>> found = engine.get(key, null);
  assertEquals(1, found.size());
}

private void populateSlops(List<Versioned<Slop>> slops) {
  for(Versioned<Slop> slop: slops) {
    VectorClock clock = TestUtils.getClock(1);
    NodeValue<ByteArray, byte[]> nodeValue = new NodeValue<ByteArray, byte[]>(PURGE_SERVER_ID,
                                         slop.getValue()
                                           .makeKey(),
                                         new Versioned<byte[]>(slopSerializer.toBytes(slop.getValue()),
                                                    clock));
    adminClient.storeOps.putNodeKeyValue("slop", nodeValue);
  }
}

@Test
public void testPutIfNotObsolete() {
  client.putIfNotObsolete("k", new Versioned<String>("v"));
  assertEquals("PUT of non-obsolete version should succeed.", "v", client.getValue("k"));
  assertFalse(client.putIfNotObsolete("k", new Versioned<String>("v2")));
  assertEquals("Failed PUT should not change the value stored.", "v", client.getValue("k"));
}

@Test
public void testEmptyByteArray() throws Exception {
  Store<ByteArray, byte[], byte[]> store = getStore();
  Versioned<byte[]> bytes = new Versioned<byte[]>(new byte[0]);
  store.put(new ByteArray(new byte[0]), bytes, null);
  List<Versioned<byte[]>> found = store.get(new ByteArray(new byte[0]), null);
  assertEquals("Incorrect number of results.", 1, found.size());
  assertEquals("Get doesn't equal put.", bytes, found.get(0));
}

@Override
@Test
public void testPutIfNotObsolete() {
  VectorClock vc = new VectorClock();
  vc.incrementVersion(this.nodeId, System.currentTimeMillis());
  VectorClock initialVC = vc.clone();
  client.putIfNotObsolete("k", new Versioned<String>("v", vc));
  assertEquals("PUT of non-obsolete version should succeed.", "v", client.getValue("k"));
  assertFalse(client.putIfNotObsolete("k", new Versioned<String>("v2", initialVC)));
  assertEquals("Failed PUT should not change the value stored.", "v", client.getValue("k"));
}

public static MetadataStore createMetadataStore(Cluster cluster,
                        List<StoreDefinition> storeDefs,
                        int nodeId) {
  Store<String, String, String> innerStore = new InMemoryStorageEngine<String, String, String>("inner-store");
  innerStore.put(MetadataStore.CLUSTER_KEY,
          new Versioned<String>(new ClusterMapper().writeCluster(cluster)),
          null);
  innerStore.put(MetadataStore.STORES_KEY,
          new Versioned<String>(new StoreDefinitionsMapper().writeStoreList(storeDefs)),
          null);
  return MetadataStore.createInMemoryMetadataStore(innerStore, nodeId);
}

@Test
public void testPutIncrementsVersion() throws Exception {
  Store<ByteArray, byte[], byte[]> store = getStore();
  VectorClock clock = new VectorClock();
  VectorClock copy = clock.clone();
  store.put(aKey, new Versioned<byte[]>(getValue(), clock), aTransform);
  List<Versioned<byte[]>> found = store.get(aKey, aTransform);
  assertEquals("Invalid number of items found.", 1, found.size());
  assertEquals("Version not incremented properly",
         Occurred.BEFORE,
         copy.compare(found.get(0).getVersion()));
}