public <K1, V1, T1> Store<K1, V1, T1> getRawStore(String storeName, InconsistencyResolver<Versioned<V1>> resolver) { if(this.storesXml != null) return getRawStore(storeName); // Add inconsistency resolving decorator, using their inconsistency // resolver (if they gave us one) InconsistencyResolver<Versioned<V1>> secondaryResolver = new TimeBasedInconsistencyResolver(); if(resolver != null) secondaryResolver = resolver; Store store = new VersionIncrementingStore(new InMemoryStorageEngine(storeName), nodeId, time); if(isSerialized()) store = new SerializingStore(store, keySerializer, valueSerializer, transformsSerializer); Store<K1, V1, T1> consistentStore = new InconsistencyResolvingStore<K1, V1, T1>(store, new ChainedResolver<Versioned<V1>>(new VectorClockInconsistencyResolver(), secondaryResolver)); return consistentStore; }
@Override public Store<ByteArray, byte[], byte[]> getStore() throws Exception { return new InconsistencyResolvingStore<ByteArray, byte[], byte[]>(getStore(cluster, cluster.getNumberOfNodes(), cluster.getNumberOfNodes(), 4, 0), new VectorClockInconsistencyResolver<byte[]>()); }
/** * Tests that getAll works correctly with a node down in a two node cluster. */ @Test public void testGetAllWithNodeDown() throws Exception { cluster = VoldemortTestConstants.getTwoNodeCluster(); RoutedStore routedStore = getStore(cluster, 1, 2, 1, 0); Store<ByteArray, byte[], byte[]> store = new InconsistencyResolvingStore<ByteArray, byte[], byte[]>(routedStore, new VectorClockInconsistencyResolver<byte[]>()); getAllWithNodeDown(store); }
try { logger.info(workName + "Starting processing"); ChainedResolver<Versioned<byte[]>> resolver = new ChainedResolver<Versioned<byte[]>>(new VectorClockInconsistencyResolver<byte[]>(), new TimeBasedInconsistencyResolver<byte[]>()); Iterator<ByteArray> keyItr = srcAdminClient.bulkFetchOps.fetchKeys(storeInstance.getNodeIdForPartitionId(this.partitionId),
@Override public void run() { String storeName = this.storeInstance.getStoreDefinition().getName(); ChainedResolver<Versioned<byte[]>> resolver = new ChainedResolver<Versioned<byte[]>>(new VectorClockInconsistencyResolver<byte[]>(), new TimeBasedInconsistencyResolver<byte[]>()); try {
public Store<ByteArray, byte[], byte[]> getZonedStore() throws Exception { cluster = VoldemortTestConstants.getNineNodeClusterWith3Zones(); HashMap<Integer, Integer> zoneReplicationFactor = Maps.newHashMap(); zoneReplicationFactor.put(0, cluster.getNumberOfNodesInZone(0)); zoneReplicationFactor.put(1, cluster.getNumberOfNodesInZone(0)); zoneReplicationFactor.put(2, cluster.getNumberOfNodesInZone(0)); return new InconsistencyResolvingStore<ByteArray, byte[], byte[]>(getStore(cluster, cluster.getNumberOfNodes(), cluster.getNumberOfNodes(), cluster.getNumberOfZones() - 1, cluster.getNumberOfZones() - 1, 4, zoneReplicationFactor), new VectorClockInconsistencyResolver<byte[]>()); }
public static void main(String[] args) throws Exception { Store<byte[], byte[], byte[]> store = new VersionIncrementingStore<byte[], byte[], byte[]>(new InMemoryStorageEngine<byte[], byte[], byte[]>("test"), 0, new SystemTime()); store = new InconsistencyResolvingStore<byte[], byte[], byte[]>(store, new VectorClockInconsistencyResolver<byte[]>()); new MultithreadedStressTest(store, 5, 1000000, 10).testGetAndPut(); }
: resolver; clientStore = new InconsistencyResolvingStore<K, V, T>(clientStore, new ChainedResolver<Versioned<V>>(new VectorClockInconsistencyResolver<V>(), secondaryResolver)); return clientStore;
new VectorClockInconsistencyResolver<byte[]>()); this.storeRepository.addRoutedStore(store); } catch(Exception e) {
/** * Tests that getAll works correctly with a node down in a three node three * zone cluster. */ @Test public void testGetAllWithNodeDownZZZ() throws Exception { cluster = VoldemortTestConstants.getThreeNodeClusterWith3Zones(); HashMap<Integer, Integer> zoneReplicationFactor = Maps.newHashMap(); zoneReplicationFactor.put(0, cluster.getNumberOfNodesInZone(0)); zoneReplicationFactor.put(1, cluster.getNumberOfNodesInZone(0)); zoneReplicationFactor.put(2, cluster.getNumberOfNodesInZone(0)); // PR = RR = 2 // PW = RW = 3 // Zone Reads = 0 // Zone Writes = 0 // Threads = 1 RoutedStore routedStore = getStore(cluster, cluster.getNumberOfNodes() - 1, cluster.getNumberOfNodes(), 0, 0, 1, zoneReplicationFactor); Store<ByteArray, byte[], byte[]> store = new InconsistencyResolvingStore<ByteArray, byte[], byte[]>(routedStore, new VectorClockInconsistencyResolver<byte[]>()); getAllWithNodeDown(store); }
@Override public void setUp() { resolver = new VectorClockInconsistencyResolver<String>(); current = getVersioned(1, 1, 2, 3); prior = getVersioned(1, 2, 3); concurrent = getVersioned(1, 2, 3, 3); concurrent2 = getVersioned(1, 2, 3, 4); later = getVersioned(1, 1, 2, 2, 3); }
new VoldemortException()); Store<ByteArray, byte[], byte[]> store = new InconsistencyResolvingStore<ByteArray, byte[], byte[]>(routedStore, new VectorClockInconsistencyResolver<byte[]>());
new VectorClockInconsistencyResolver<byte[]>()); store.put(aKey, Versioned.value(aValue), aTransform); recordException(failureDetector, cluster.getNodes().iterator().next());
ChainedResolver<Versioned<byte[]>> resolver = new ChainedResolver<Versioned<byte[]>>(new VectorClockInconsistencyResolver<byte[]>(), new TimeBasedInconsistencyResolver<byte[]>());
new VectorClockInconsistencyResolver<byte[]>());
new VectorClockInconsistencyResolver<byte[]>());
new VectorClockInconsistencyResolver<byte[]>()); store.put(aKey, new Versioned<byte[]>(aValue), aTransform);
new ChainedResolver<Versioned<V1>>(new VectorClockInconsistencyResolver(), secondaryResolver)); return consistentStore;
new VectorClockInconsistencyResolver<byte[]>()); store.put(aKey, new Versioned<byte[]>(aValue), null);
private void testBasicOperations(int reads, int writes, int failures, int threads, RoutedStore customRoutedStore, long customSleepTime) throws Exception { RoutedStore routedStore = null; if(customRoutedStore == null) { routedStore = getStore(cluster, reads, writes, threads, failures); } else { routedStore = customRoutedStore; } Store<ByteArray, byte[], byte[]> store = new InconsistencyResolvingStore<ByteArray, byte[], byte[]>(routedStore, new VectorClockInconsistencyResolver<byte[]>()); VectorClock clock = getClock(1); Versioned<byte[]> versioned = new Versioned<byte[]>(aValue, clock); routedStore.put(aKey, versioned, aTransform); waitForOperationToComplete(customSleepTime); assertNOrMoreEqual(routedStore, cluster.getNumberOfNodes() - failures, aKey, versioned); List<Versioned<byte[]>> found = store.get(aKey, aTransform); assertEquals(1, found.size()); assertEquals(versioned, found.get(0)); waitForOperationToComplete(customSleepTime); assertNOrMoreEqual(routedStore, cluster.getNumberOfNodes() - failures, aKey, versioned); assertTrue(routedStore.delete(aKey, versioned.getVersion())); waitForOperationToComplete(customSleepTime); assertNEqual(routedStore, 0, aKey, versioned); assertTrue(!routedStore.delete(aKey, versioned.getVersion())); }