private static AsyncEventQueueFactory getInitialAsyncEventQueueFactory(boolean isParallel, Integer maxMemory, Integer batchSize, boolean isPersistent, String diskStoreName) { AsyncEventQueueFactory factory = cache.createAsyncEventQueueFactory(); factory.setBatchSize(batchSize); factory.setPersistent(isPersistent); factory.setDiskStoreName(diskStoreName); factory.setMaximumQueueMemory(maxMemory); factory.setParallel(isParallel); return factory; }
/** * Processes events by recording their latencies. */ @Override public boolean processEvents(List<AsyncEvent> events) { synchronized (eventsMap) { for (AsyncEvent event : events) { this.eventsMap.put(event.getKey(), event.getDeserializedValue()); } } return true; }
@Override public AsyncEventQueue getAsyncEventQueue(String id) { for (AsyncEventQueue asyncEventQueue : this.asyncEventQueues) { if (asyncEventQueue.getId().equals(id)) { return asyncEventQueue; } } return null; }
public void configureAsyncEventQueue(AsyncEventQueue asyncQueueCreation) { gatewaySenderAttributes.batchSize = asyncQueueCreation.getBatchSize(); gatewaySenderAttributes.batchTimeInterval = asyncQueueCreation.getBatchTimeInterval(); gatewaySenderAttributes.isBatchConflationEnabled = asyncQueueCreation.isBatchConflationEnabled(); gatewaySenderAttributes.isPersistenceEnabled = asyncQueueCreation.isPersistent(); gatewaySenderAttributes.diskStoreName = asyncQueueCreation.getDiskStoreName(); gatewaySenderAttributes.isDiskSynchronous = asyncQueueCreation.isDiskSynchronous(); gatewaySenderAttributes.maximumQueueMemory = asyncQueueCreation.getMaximumQueueMemory(); gatewaySenderAttributes.isParallel = asyncQueueCreation.isParallel(); gatewaySenderAttributes.isBucketSorted = ((AsyncEventQueueCreation) asyncQueueCreation).isBucketSorted(); gatewaySenderAttributes.dispatcherThreads = asyncQueueCreation.getDispatcherThreads(); gatewaySenderAttributes.policy = asyncQueueCreation.getOrderPolicy(); gatewaySenderAttributes.eventFilters = asyncQueueCreation.getGatewayEventFilters(); gatewaySenderAttributes.eventSubstitutionFilter = asyncQueueCreation.getGatewayEventSubstitutionFilter(); gatewaySenderAttributes.isForInternalUse = true; gatewaySenderAttributes.forwardExpirationDestroy = asyncQueueCreation.isForwardExpirationDestroy(); }
public static void createConcurrentAsyncEventQueue(String asyncChannelId, boolean isParallel, Integer maxMemory, Integer batchSize, boolean isConflation, boolean isPersistent, String diskStoreName, boolean isDiskSynchronous, int dispatcherThreads, OrderPolicy policy) { createDiskStore(asyncChannelId, diskStoreName); AsyncEventListener asyncEventListener = new MyAsyncEventListener(); AsyncEventQueueFactory factory = getInitialAsyncEventQueueFactory(isParallel, maxMemory, batchSize, isPersistent, diskStoreName); factory.setDiskSynchronous(isDiskSynchronous); factory.setBatchConflationEnabled(isConflation); factory.setOrderPolicy(policy); AsyncEventQueue asyncChannel = factory.create(asyncChannelId, asyncEventListener); }
public static void createAsyncEventQueue(String asyncChannelId, boolean isParallel, Integer maxMemory, Integer batchSize, boolean isConflation, boolean isPersistent, String diskStoreName, boolean isDiskSynchronous, int numDispatcherThreads, final AsyncEventListener asyncEventListener) { createDiskStore(asyncChannelId, diskStoreName); AsyncEventQueueFactory factory = getInitialAsyncEventQueueFactory(isParallel, maxMemory, batchSize, isPersistent, diskStoreName); factory.setDiskSynchronous(isDiskSynchronous); factory.setBatchConflationEnabled(isConflation); // set dispatcher threads factory.setDispatcherThreads(numDispatcherThreads); // Set GatewayEventSubstitutionFilter AsyncEventQueue asyncChannel = factory.create(asyncChannelId, asyncEventListener); }
/** * Create an async-event-queue with the given name. * For a partitioned region a parallel queue is created. * Otherwise a serial queue is created. */ private void createAsyncEventQueue(Cache cache, String queueName, boolean isPartitioned) { AsyncEventQueueFactory asyncEventQueueFactory = cache.createAsyncEventQueueFactory(); asyncEventQueueFactory.setParallel(isPartitioned); asyncEventQueueFactory.create(queueName, new JdbcAsyncWriter()); }
public static AsyncEventListener getAsyncEventListener(String asyncEventQueueId) { AsyncEventListener theListener = null; Set<AsyncEventQueue> asyncEventQueues = cache.getAsyncEventQueues(); for (AsyncEventQueue asyncQueue : asyncEventQueues) { if (asyncEventQueueId.equals(asyncQueue.getId())) { return asyncQueue.getAsyncEventListener(); } } return null; }
public static int getAsyncEventQueueSize(String asyncEventQueueId) { AsyncEventQueue theQueue = null; Set<AsyncEventQueue> asyncEventQueues = cache.getAsyncEventQueues(); for (AsyncEventQueue asyncQueue : asyncEventQueues) { if (asyncEventQueueId.equals(asyncQueue.getId())) { theQueue = asyncQueue; } } assertNotNull(theQueue); return theQueue.size(); }
public static void createAsyncEventQueueWithListener2(String asyncChannelId, boolean isParallel, Integer maxMemory, Integer batchSize, boolean isPersistent, String diskStoreName) { createDiskStore(asyncChannelId, diskStoreName); AsyncEventListener asyncEventListener = new MyAsyncEventListener2(); AsyncEventQueueFactory factory = getInitialAsyncEventQueueFactory(isParallel, maxMemory, batchSize, isPersistent, diskStoreName); // set dispatcher threads factory.setDispatcherThreads(numDispatcherThreadsForTheRun); AsyncEventQueue asyncChannel = factory.create(asyncChannelId, asyncEventListener); }
private AsyncEvent createMockEvent(Operation op) { AsyncEvent event = mock(AsyncEvent.class); when(event.getOperation()).thenReturn(op); when(event.getRegion()).thenReturn(region); return event; }
@Override public boolean processEvents(List<AsyncEvent> events) { for (AsyncEvent event : events) { this.eventsMap.put(event.getKey(), event); } return true; }
protected String getDiskStoreName(final AsyncEventQueue queue) { return StringUtils.defaultIfBlank(queue.getDiskStoreName(), DiskStoreDetails.DEFAULT_DISK_STORE_NAME); }
protected boolean isUsingDiskStore(final AsyncEventQueue queue, final DiskStore diskStore) { return (queue.isPersistent() && ObjectUtils.equals(getDiskStoreName(queue), diskStore.getName())); }
/** * precondition: DefaultQuery.setPdxReadSerialized(true) */ private PdxInstance getPdxInstance(AsyncEvent event) { Object value = event.getDeserializedValue(); if (!(value instanceof PdxInstance)) { value = CopyHelper.copy(value); } return (PdxInstance) value; } }
public static void verifySubstitutionFilterToDataInvocations(String asyncEventQueueId, int expectedToDataInvoations) { AsyncEventQueue queue = cache.getAsyncEventQueue(asyncEventQueueId); assertNotNull(queue); // Verify the GatewayEventSubstitutionFilter has been invoked the appropriate number of times SizeableGatewayEventSubstitutionFilter filter = (SizeableGatewayEventSubstitutionFilter) queue.getGatewayEventSubstitutionFilter(); assertNotNull(filter); assertEquals(expectedToDataInvoations, filter.getNumToDataInvocations()); }
/** * Processes events by recording their latencies. */ @Override public boolean processEvents(List<AsyncEvent> events) { for (AsyncEvent event : events) { this.eventsMap.put(event.getKey(), event.getDeserializedValue()); } return true; }
@Override public AsyncEventQueue getAsyncEventQueue(String id) { for (AsyncEventQueue asyncEventQueue : this.allAsyncEventQueues) { if (asyncEventQueue.getId().equals(id)) { return asyncEventQueue; } } return null; }
@Override public boolean processEvents(List<AsyncEvent> events) { int i = 0; for (AsyncEvent event : events) { i++; if (!exceptionThrown && i == 40) { i = 0; exceptionThrown = true; throw new Error("TestError"); } if (exceptionThrown) { eventsMap.put((Long) event.getKey(), event); } } return true; }
@Override public synchronized boolean processEvents(List<AsyncEvent> events) { for (AsyncEvent event : events) { if (eventsMap.containsKey(event.getKey())) { logger.debug("This is a duplicate event --> {}", event.getKey()); } eventsMap.put(event.getKey(), event.getDeserializedValue()); logger.debug("Received an event --> {}", event.getKey()); } return true; }