How to use

value

method

in

voldemort.versioning.Versioned

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

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);
}

@Override
public void setUp() {
  target1.put("hello", Versioned.value("world"), null);
  Integer[] values1 = { 1, 2, 3, 4, 5, 6, 7, 8 };
  Integer[] values2 = { 100, 200, 300, 400, 500, 600, 700 };
  target2.put(1, Versioned.value(Arrays.asList(values1)), null);
  target2.put(100, Versioned.value(Arrays.asList(values2)), null);
}

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;
}

  public void run() {
    while(keepRunning.get()) {
      byte[] bytes = Integer.toString(count.getAndIncrement()).getBytes();
      store.put(new ByteArray(bytes), Versioned.value(bytes), null);
      count.incrementAndGet();
    }
  }
});

public static List<Versioned<byte[]>> fromByteArray(byte[] bytes) {
  if(bytes.length < 1)
    throw new VoldemortException("Invalid value length: " + bytes.length);
  if(bytes[0] != VERSION)
    throw new VoldemortException("Unexpected version number in value: " + bytes[0]);
  int pos = 1;
  List<Versioned<byte[]>> vals = new ArrayList<Versioned<byte[]>>(2);
  while(pos < bytes.length) {
    VectorClock clock = new VectorClock(bytes, pos);
    pos += clock.sizeInBytes();
    int valueSize = ByteUtils.readInt(bytes, pos);
    pos += ByteUtils.SIZE_OF_INT;
    byte[] val = new byte[valueSize];
    System.arraycopy(bytes, pos, val, 0, valueSize);
    pos += valueSize;
    vals.add(Versioned.value(val, clock));
  }
  if(pos != bytes.length)
    throw new VoldemortException((bytes.length - pos)
                   + " straggling bytes found in value (this should not be possible)!");
  return vals;
}

private Versioned<Slop> randomSlop(String name, int nodeId) {
  return Versioned.value(new Slop(name,
                  Operation.PUT,
                  TestUtils.randomBytes(10),
                  TestUtils.randomBytes(10),
                  nodeId,
                  new Date()));
}

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 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);
}

public void testPutWithTransforms() {
  Integer[] values1 = { 9, 90, 10, 15, 25, 106 };
  Integer[] filter1 = { 1, 10 };
  Versioned<List<Integer>> values = Versioned.value(Arrays.asList(values1));
  VectorClock clock = (VectorClock) values.getVersion();
  clock.incrementVersion(0, System.currentTimeMillis());
  view.put(1, Versioned.value(values.getValue(), clock), Arrays.asList(filter1));
  assertEquals(10, view.get(1, Arrays.asList(filter1)).get(0).getValue().size());
  Integer[] filter2 = { 5, 10 };
  assertEquals(6, view.get(1, Arrays.asList(filter2)).get(0).getValue().size());
  Version updatedVersion = view.get(1, Arrays.asList(filter2)).get(0).getVersion();
  Integer[] filter3 = { 1, 50 };
  Integer[] values2 = { 90, 15, 25, 106 };
  clock = (VectorClock) updatedVersion;
  VectorClock clock1 = clock.incremented(0, System.currentTimeMillis());
  view.put(1, Versioned.value(Arrays.asList(values2), clock1), Arrays.asList(filter3));
  assertEquals(12, view.get(1, Arrays.asList(filter3)).get(0).getValue().size());
}

  @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);

public void testPut() {
  valView.put("abc", Versioned.value("cde"), null);
  assertEquals("c", target1.get("abc", null).get(0).getValue());
}

/**
 * Util function to test getAll with one node down
 * 
 * @param store The Routed store object used to perform the put and getall
 * @throws Exception
 */
private void getAllWithNodeDown(Store<ByteArray, byte[], byte[]> store) throws Exception {
  Map<ByteArray, byte[]> expectedValues = Maps.newHashMap();
  for(byte i = 1; i < 11; ++i) {
    ByteArray key = new ByteArray(new byte[] { i });
    byte[] value = new byte[] { (byte) (i + 50) };
    store.put(key, Versioned.value(value), null);
    expectedValues.put(key, value);
  }
  recordException(failureDetector, cluster.getNodes().iterator().next());
  Map<ByteArray, List<Versioned<byte[]>>> all = store.getAll(expectedValues.keySet(), null);
  assertEquals(expectedValues.size(), all.size());
  for(Map.Entry<ByteArray, List<Versioned<byte[]>>> mapEntry: all.entrySet()) {
    byte[] value = expectedValues.get(mapEntry.getKey());
    assertEquals(new ByteArray(value), new ByteArray(mapEntry.getValue().get(0).getValue()));
  }
}

  @Override
  protected Pair<ByteArray, Versioned<byte[]>> computeNext() {
    Pair<ByteArray, Versioned<byte[]>> p = inner.next();
    Versioned<byte[]> newVal = Versioned.value(valueToViewSchema(p.getFirst(),
                                   p.getSecond().getValue(),
                                   null),
                          p.getSecond().getVersion());
    return Pair.create(p.getFirst(), newVal);
  }
}

@Test
public void testGetVersions() throws Exception {
  List<K> keys = getKeys(2);
  K key = keys.get(0);
  V value = getValue();
  Store<K, V, T> store = getStore();
  store.put(key, Versioned.value(value), null);
  List<Versioned<V>> versioneds = store.get(key, null);
  List<Version> versions = store.getVersions(key);
  assertEquals(1, versioneds.size());
  assertTrue(versions.size() > 0);
  for(int i = 0; i < versions.size(); i++)
    assertEquals(versioneds.get(0).getVersion(), versions.get(i));
  assertEquals(0, store.getVersions(keys.get(1)).size());
}

@Test
public void testGetVersions2() throws Exception {
  List<ByteArray> keys = getKeys(2);
  ByteArray key = keys.get(0);
  byte[] value = getValue();
  Store<ByteArray, byte[], byte[]> store = getStore();
  store.put(key, Versioned.value(value), null);
  List<Versioned<byte[]>> versioneds = store.get(key, null);
  List<Version> versions = store.getVersions(key);
  assertEquals(1, versioneds.size());
  assertEquals(9, versions.size());
  for(int i = 0; i < versions.size(); i++)
    assertEquals(versioneds.get(0).getVersion(), versions.get(i));
  assertEquals(0, store.getVersions(keys.get(1)).size());
}

@Test
public void testGetVersions2ZZZ() throws Exception {
  List<ByteArray> keys = getKeys(2);
  ByteArray key = keys.get(0);
  byte[] value = getValue();
  Store<ByteArray, byte[], byte[]> store = getZonedStore();
  store.put(key, Versioned.value(value), null);
  List<Versioned<byte[]>> versioneds = store.get(key, null);
  List<Version> versions = store.getVersions(key);
  assertEquals(1, versioneds.size());
  assertEquals(9, versions.size());
  for(int i = 0; i < versions.size(); i++)
    assertEquals(versioneds.get(0).getVersion(), versions.get(i));
  assertEquals(0, store.getVersions(keys.get(1)).size());
}

@Override
@Test
public void testGetVersions() throws Exception {
  List<ByteArray> keys = getKeys(2);
  ByteArray key = keys.get(0);
  byte[] value = getValue();
  VectorClock vc = getClock(0, 0);
  Store<ByteArray, byte[], byte[]> store = getStore();
  store.put(key, Versioned.value(value, vc), null);
  List<Versioned<byte[]>> versioneds = store.get(key, null);
  List<Version> versions = store.getVersions(key);
  assertEquals(1, versioneds.size());
  assertTrue(versions.size() > 0);
  for(int i = 0; i < versions.size(); i++)
    assertEquals(versioneds.get(0).getVersion(), versions.get(i));
  assertEquals(0, store.getVersions(keys.get(1)).size());
}

/**
 * Test the new put that returns the new version
 */
@Test
public void testPutReturnVersion() {
  Version baseVersion = new VectorClock();
  Version oldVersion = null;
  Version newVersion = null;
  Versioned<String> getVersioned = null;
  String oldValue = null;
  String newValue = null;
  for(int i = 0; i < 5; i++) {
    oldValue = "value" + i;
    newValue = "value" + (i + 1);
    oldVersion = storeClient.put("key1", Versioned.value(oldValue, baseVersion));
    newVersion = storeClient.put("key1",
                   Versioned.value(newValue,
                           ((VectorClock) oldVersion).clone()));
    getVersioned = storeClient.get("key1");
    baseVersion = newVersion;
    verifyResults(oldVersion, newVersion, getVersioned, newValue);
  }
}

@Test
public void testPutVersioned() {
  client.put("k", Versioned.value("v"));
  Versioned<String> v = client.get("k");
  assertEquals("GET should return the version set by PUT.", "v", v.getValue());
  VectorClock expected = new VectorClock();
  expected.incrementVersion(nodeId, time.getMilliseconds());
  assertEquals("The version should be incremented after a put.", expected, v.getVersion());
  try {
    client.put("k", Versioned.value("v"));
    fail("Put of obsolete version should throw exception.");
  } catch(ObsoleteVersionException e) {
    // this is good
  }
  // PUT of a concurrent version should succeed
  client.put("k",
        new Versioned<String>("v2",
                   new VectorClock().incremented(nodeId + 1,
                                  time.getMilliseconds())));
  assertEquals("GET should return the new value set by PUT.", "v2", client.getValue("k"));
  assertEquals("GET should return the new version set by PUT.",
         expected.incremented(nodeId + 1, time.getMilliseconds()),
         client.get("k").getVersion());
}