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