voldemort.versioning.Versioned.value java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 Point p =new Point(x, y)
new Point()
MouseEvent e;e.getPoint()
Smart code suggestions by Tabnine
}

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

Popular methods of Versioned

getValue
<init>
getVersion
setObject
cloneVersioned
Create a clone of this Versioned object such that the object pointed to is the same, but the VectorC
equals
hashCode
toString

Popular in Java

Parsing JSON documents to java classes using gson
requestLocationUpdates (LocationManager)
setRequestProperty (URLConnection)
runOnUiThread (Activity)
EOFException (java.io)
Thrown when a program encounters the end of a file or stream during an input operation.
Format (java.text)
The base class for all formats. This is an abstract base class which specifies the protocol for clas
Notification (javax.management)
JOptionPane (javax.swing)
Options (org.apache.commons.cli)
Main entry-point into the library. Options represents a collection of Option objects, which describ
Location (org.springframework.beans.factory.parsing)
Class that models an arbitrary location in a Resource.Typically used to track the location of proble

How to use valuemethodin voldemort.versioning.Versioned

Best Java code snippets using voldemort.versioning.Versioned.value (Showing top 20 results out of 315)

How to use
value
method
in
voldemort.versioning.Versioned