Tabnine Logo
Versioned.<init>
Code IndexAdd Tabnine to your IDE (free)

How to use
voldemort.versioning.Versioned
constructor

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

origin: voldemort/voldemort

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);
}
origin: voldemort/voldemort

@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);
  }
}
origin: voldemort/voldemort

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

/**
 * 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());
}
origin: voldemort/voldemort

  @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();
  }
};
origin: voldemort/voldemort

@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;
}
origin: voldemort/voldemort

@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;
}
origin: voldemort/voldemort

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)));
}
origin: voldemort/voldemort

  @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()));
  }
};
origin: voldemort/voldemort

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
    }
  }
}
origin: voldemort/voldemort

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());
  }
}
origin: voldemort/voldemort

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());
}
origin: voldemort/voldemort

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);
  }
}
origin: voldemort/voldemort

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());
}
origin: voldemort/voldemort

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);
  }
}
origin: voldemort/voldemort

@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"));
}
origin: voldemort/voldemort

@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));
}
origin: voldemort/voldemort

@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"));
}
origin: voldemort/voldemort

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);
}
origin: voldemort/voldemort

@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()));
}
voldemort.versioningVersioned<init>

Popular methods of Versioned

  • getValue
  • getVersion
  • setObject
  • value
  • 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

  • Reactive rest calls using spring rest template
  • getExternalFilesDir (Context)
  • getSharedPreferences (Context)
  • startActivity (Activity)
  • Container (java.awt)
    A generic Abstract Window Toolkit(AWT) container object is a component that can contain other AWT co
  • BufferedImage (java.awt.image)
    The BufferedImage subclass describes an java.awt.Image with an accessible buffer of image data. All
  • File (java.io)
    An "abstract" representation of a file system entity identified by a pathname. The pathname may be a
  • FileWriter (java.io)
    A specialized Writer that writes to a file in the file system. All write requests made by calling me
  • Scanner (java.util)
    A parser that parses a text string of primitive types and strings with the help of regular expressio
  • LoggerFactory (org.slf4j)
    The LoggerFactory is a utility class producing Loggers for various logging APIs, most notably for lo
  • Top Sublime Text plugins
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now