/** * Get new vector clock based on this clock but incremented on index nodeId * * @param nodeId The id of the node to increment * @return A vector clock equal on each element execept that indexed by * nodeId */ public VectorClock incremented(int nodeId, long time) { VectorClock copyClock = this.clone(); copyClock.incrementVersion(nodeId, time); return copyClock; }
public VectorClock getNewIncrementedVectorClock() { VectorClock vectorClock = new VectorClock(); vectorClock.incrementVersion(this.nodeId, System.currentTimeMillis()); return vectorClock; }
/** * Record events for the given sequence of nodes * * @param clock The VectorClock to record the events on * @param nodes The sequences of node events */ public static void increment(VectorClock clock, int... nodes) { for(int n: nodes) clock.incrementVersion((short) n, clock.getTimestamp()); }
@Override public void put(K key, Versioned<V> value, T transforms) throws VoldemortException { value = value.cloneVersioned(); VectorClock clock = (VectorClock) value.getVersion(); clock.incrementVersion(nodeId, time.getMilliseconds()); super.put(key, value, transforms); }
public void execute(Pipeline pipeline) { if(logger.isTraceEnabled()) logger.trace(pipeline.getOperation().getSimpleName() + " versioning data - was: " + versioned.getVersion()); // Okay looks like it worked, increment the version for the caller VectorClock versionedClock = (VectorClock) versioned.getVersion(); versionedClock.incrementVersion(pipelineData.getMaster().getId(), time.getMilliseconds()); if(logger.isTraceEnabled()) logger.trace(pipeline.getOperation().getSimpleName() + " versioned data - now: " + versioned.getVersion()); pipeline.addEvent(completeEvent); }
private static MetadataStore getTestMetadataStore(VoldemortConfig voldemortConfig, Cluster cluster) { ConfigurationStorageEngine metadataInnerEngine = new ConfigurationStorageEngine("metadata-config-store", voldemortConfig.getMetadataDirectory()); List<Versioned<String>> clusterXmlValue = metadataInnerEngine.get(MetadataStore.CLUSTER_KEY, null); VectorClock version = null; if(clusterXmlValue.size() <= 0) { version = new VectorClock(); } else { version = (VectorClock) clusterXmlValue.get(0).getVersion(); } int nodeId = getNodeId(voldemortConfig, cluster); version.incrementVersion(nodeId, System.currentTimeMillis()); metadataInnerEngine.put(MetadataStore.CLUSTER_KEY, new Versioned<String>(new ClusterMapper().writeCluster(cluster), version), null); return MetadataStore.createInMemoryMetadataStore(metadataInnerEngine, nodeId); }
public List<Versioned<byte[]>> generatePutWithConflictionVersions(ByteArray key) { List<Versioned<byte[]>> versionedList = new ArrayList<Versioned<byte[]>>(); VectorClock vectorClock1 = new VectorClock(); vectorClock1.incrementVersion(voldemortConfig.getNodeId(), System.currentTimeMillis()); Versioned<byte[]> value1 = new Versioned<byte[]>("valueOne".getBytes(), vectorClock1); try { // Do put this.rocksDbStore.put(key, value1, null); } catch(PersistenceFailureException pfe) { Assert.fail("initial put failed unexpectedly. Exception: " + pfe.getMessage()); } versionedList.add(value1); VectorClock vectorClock2 = new VectorClock(); vectorClock2.incrementVersion(1, System.currentTimeMillis()); Versioned<byte[]> value2 = new Versioned<byte[]>("valueTwo".getBytes(), vectorClock2); try { // Do put this.rocksDbStore.put(key, value2, null); } catch(PersistenceFailureException pfe) { Assert.fail("initial put failed unexpectedly. Exception: " + pfe.getMessage()); } versionedList.add(value2); return versionedList; }
@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 run() { try { for(int j = 0; j < 1000 && !returnedEmpty.get(); j++) { List<Versioned<byte[]>> vals = store.get(new ByteArray(keyBytes), null); if(vals.size() == 0 && j > 1) returnedEmpty.set(true); else { VectorClock v = (VectorClock) vals.get(0).getVersion(); v.incrementVersion(0, System.currentTimeMillis()); try { store.put(new ByteArray(keyBytes), new Versioned<byte[]>(valueBytes, v), null); } catch(ObsoleteVersionException e) { // Ignore these } } } } finally { latch.countDown(); } } });
private void updateStoreDef(int retentionDays) { StoreDefinition storeDef = getStoreDef(retentionDays); StoreDefinitionsMapper mapper = new StoreDefinitionsMapper(); String storeStr = mapper.writeStoreList(Arrays.asList(storeDef)); VectorClock clock = new VectorClock(System.currentTimeMillis()); clock.incrementVersion(0, System.currentTimeMillis()); Versioned<byte[]> storeSerialized = new Versioned<byte[]>(ByteUtils.getBytes(storeStr, "UTF-8"), clock); metadataStore.updateStoreDefinitions(storeSerialized); }
@Test public void testSerializationWraps() { VectorClock clock = getClock(1, 1, 2, 3, 3, 6); for(int i = 0; i < 300; i++) clock.incrementVersion(2, System.currentTimeMillis()); assertEquals("Clock does not serialize to itself.", clock, new VectorClock(clock.toBytes())); }
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()); }
/** * Basic getall test */ @Test public void testGetAll() { logger.info("\n\n******************** Testing Get All *******************\n\n"); VectorClock vectorClock1 = new VectorClock(); vectorClock1.incrementVersion(voldemortConfig.getNodeId(), System.currentTimeMillis()); ByteArray key2 = new ByteArray("key2".getBytes()); Versioned<byte[]> value2 = new Versioned<byte[]>("value2".getBytes(), vectorClock1); store.put(key2, value2, null); vectorClock1 = new VectorClock(); vectorClock1.incrementVersion(voldemortConfig.getNodeId(), System.currentTimeMillis()); ByteArray key3 = new ByteArray("key3".getBytes()); Versioned<byte[]> value3 = new Versioned<byte[]>("value3".getBytes(), vectorClock1); store.put(key3, value3, null); Map<ByteArray, List<Versioned<byte[]>>> input = new HashMap<ByteArray, List<Versioned<byte[]>>>(); List<Versioned<byte[]>> valuesList2 = new ArrayList<Versioned<byte[]>>(); valuesList2.add(value2); input.put(key2, valuesList2); List<Versioned<byte[]>> valuesList3 = new ArrayList<Versioned<byte[]>>(); valuesList3.add(value3); input.put(key3, valuesList3); Map<ByteArray, List<Versioned<byte[]>>> output = store.getAll(input.keySet(), null); assertEquals(input, output); // cleanup specific to this test case deleteCreatedKeys(key2); deleteCreatedKeys(key3); }
@BeforeClass public static void oneTimeSetUp() { storeNameStr = "test"; urlStr = "http://localhost:8085/"; config = VoldemortConfig.loadFromVoldemortHome("config/single_node_rest_server/"); key1 = "The longest key "; vectorClock = new VectorClock(); vectorClock.incrementVersion(config.getNodeId(), System.currentTimeMillis()); eTag = RestUtils.getSerializedVectorClock(vectorClock); value1 = "The longest value"; timeOut = 10000L; contentType = "text"; routingType = 2; server = new VoldemortServer(config); if(!server.isStarted()) server.start(); System.out.println("********************Starting REST Server********************"); }
public void testClone() { Versioned<Integer> v1 = getVersioned(2, 1, 2, 3); Versioned<Integer> v2 = v1.cloneVersioned(); assertEquals(v1, v2); assertTrue(v1 != v2); assertTrue(v1.getVersion() != v2.getVersion()); ((VectorClock) v2.getVersion()).incrementVersion(1, System.currentTimeMillis()); assertTrue(!v1.equals(v2)); }
@BeforeClass public static void oneTimeSetUp() { voldemortConfig = VoldemortConfig.loadFromVoldemortHome("config/single_node_rest_server/"); key = new ByteArray("key1".getBytes()); vectorClock = new VectorClock(); vectorClock.incrementVersion(voldemortConfig.getNodeId(), System.currentTimeMillis()); value = new Versioned<byte[]>("value1".getBytes(), vectorClock); server = new VoldemortServer(voldemortConfig); if(!server.isStarted()) server.start(); logger.info("********************Starting REST Server********************"); restClientConfig = new RESTClientConfig(); restClientConfig.setHttpBootstrapURL("http://localhost:8085") .setTimeoutMs(1500, TimeUnit.MILLISECONDS) .setMaxR2ConnectionPoolSize(100); clientFactory = new HttpClientFactory(); Map<String, String> properties = new HashMap<String, String>(); properties.put(HttpClientFactory.HTTP_POOL_SIZE, Integer.toString(restClientConfig.getMaxR2ConnectionPoolSize())); transportClient = clientFactory.getClient(properties); r2store = new R2Store("test", restClientConfig.getHttpBootstrapURL(), "2", transportClient, restClientConfig, 0); store = r2store; deleteCreatedKeys(key); }
@Test public void testIncrementAndSerialize() { int node = 1; VectorClock vc = getClock(node); assertEquals(node, vc.getMaxVersion()); int increments = 3000; for(int i = 0; i < increments; i++) { vc.incrementVersion(node, 45); // serialize vc = new VectorClock(vc.toBytes()); } assertEquals(increments + 1, vc.getMaxVersion()); }
@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")); }
@Override @Test public void testDeleteVersion() { VectorClock vc = new VectorClock(); vc.incrementVersion(this.nodeId, System.currentTimeMillis()); VectorClock initialVC = vc.clone(); assertFalse("Delete of non-existant key should be false.", client.delete("k", vc)); client.put("k", new Versioned<String>("v", vc)); assertFalse("Delete of a lesser version should be false.", client.delete("k", initialVC)); assertNotNull("After failed delete, value should still be there.", client.get("k")); assertTrue("Delete of k, with the current version should succeed.", client.delete("k", initialVC.incremented(this.nodeId, time.getMilliseconds()))); assertNull("After a successful delete(k), get(k) should return null.", client.get("k")); } }
@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()); }