/** * Invalidate a key in region REGION_NAME. The keys to invalidate are specified in keyIntervals. * * @return true if all keys to be invalidated have been completed. */ protected boolean invalidate() { SharedCounters sc = CQUtilBB.getBB().getSharedCounters(); long nextKey = sc.incrementAndRead(CQUtilBB.LASTKEY_INVALIDATE); if (!keyIntervals.keyInRange(KeyIntervals.INVALIDATE, nextKey)) { Log.getLogWriter().info("All existing keys invalidated; returning from invalidate"); return true; } Object key = NameFactory.getObjectNameForCounter(nextKey); Log.getLogWriter().info("Invalidating " + key); checkContainsValueForKey(key, true, "before invalidate"); try { aRegion.invalidate(key); Log.getLogWriter() .info( "Done invalidating " + key + ", num remaining: " + (keyIntervals.getLastKey(KeyIntervals.INVALIDATE) - nextKey)); } catch (TimeoutException e) { throw new TestException(TestHelper.getStackTrace(e)); } catch (EntryNotFoundException e) { throw new TestException(TestHelper.getStackTrace(e)); } return (nextKey >= keyIntervals.getLastKey(KeyIntervals.INVALIDATE)); }
/** * Update an existing key in region REGION_NAME. The keys to update are specified in keyIntervals. * * @return true if all keys to be updated have been completed. */ protected boolean updateExistingKey() { long nextKey = CQUtilBB.getBB().getSharedCounters().incrementAndRead(CQUtilBB.LASTKEY_UPDATE_EXISTING_KEY); if (!keyIntervals.keyInRange(KeyIntervals.UPDATE_EXISTING_KEY, nextKey)) { Log.getLogWriter().info("All existing keys updated; returning from updateExistingKey"); return true; } Object key = NameFactory.getObjectNameForCounter(nextKey); QueryObject existingValue = (QueryObject) aRegion.get(key); if (existingValue == null) throw new TestException("Get of key " + key + " returned unexpected " + existingValue); QueryObject newValue = existingValue.modifyWithNewInstance(QueryObject.NEGATE, 0, true); newValue.extra = key; // encode the key in the object for later validation if (existingValue.aPrimitiveLong < 0) throw new TestException( "Trying to update a key which was already updated: " + existingValue.toStringFull()); Log.getLogWriter() .info("Updating existing key " + key + " with value " + TestHelper.toString(newValue)); aRegion.put(key, newValue); Log.getLogWriter() .info( "Done updating existing key " + key + " with value " + TestHelper.toString(newValue) + ", num remaining: " + (keyIntervals.getLastKey(KeyIntervals.UPDATE_EXISTING_KEY) - nextKey)); return (nextKey >= keyIntervals.getLastKey(KeyIntervals.UPDATE_EXISTING_KEY)); }
/** * Run method for this thread: if this thread is set to stop, then stop a VM and wait for it to * stop. If this thread is set to start then start a VM and wait for it to start. Any errors are * placed in the blackboard errStr. */ public void run() { try { Log.getLogWriter().info("Started " + getName()); try { if (stop) { ClientVmMgr.stop( "Test is synchronously stopping " + targetVm + " with " + ClientVmMgr.toStopModeString(stopMode), stopMode, ClientVmMgr.ON_DEMAND, targetVm); } VMotionUtil.doVMotion(targetVm); if (start) { ClientVmMgr.start("Test is synchronously starting " + targetVm, targetVm); } } catch (hydra.ClientVmNotFoundException e) { Log.getLogWriter() .info("Caught in thread " + getName() + ":" + TestHelper.getStackTrace(e)); StopStartBB.getBB().getSharedMap().put(StopStartBB.errKey, TestHelper.getStackTrace(e)); } } catch (Throwable e) { Log.getLogWriter().info("Caught in thread " + getName() + ":" + TestHelper.getStackTrace(e)); StopStartBB.getBB().getSharedMap().put(StopStartBB.errKey, TestHelper.getStackTrace(e)); } Log.getLogWriter().info(getName() + " terminating"); }
/** * Destroy a key in region REGION_NAME. The keys to destroy are specified in keyIntervals. * * @return true if all keys to be destroyed have been completed. */ protected boolean destroy() { SharedCounters sc = CQUtilBB.getBB().getSharedCounters(); long nextKey = sc.incrementAndRead(CQUtilBB.LASTKEY_DESTROY); if (!keyIntervals.keyInRange(KeyIntervals.DESTROY, nextKey)) { Log.getLogWriter().info("All destroys completed; returning from destroy"); return true; } Object key = NameFactory.getObjectNameForCounter(nextKey); Log.getLogWriter().info("Destroying " + key); checkContainsValueForKey(key, true, "before destroy"); try { aRegion.destroy(key); Log.getLogWriter() .info( "Done Destroying " + key + ", num remaining: " + (keyIntervals.getLastKey(KeyIntervals.DESTROY) - nextKey)); } catch (CacheWriterException e) { throw new TestException(TestHelper.getStackTrace(e)); } catch (TimeoutException e) { throw new TestException(TestHelper.getStackTrace(e)); } catch (EntryNotFoundException e) { throw new TestException(TestHelper.getStackTrace(e)); } return (nextKey >= keyIntervals.getLastKey(KeyIntervals.DESTROY)); }
/** * Do a get on a key in region REGION_NAME. Keys to get are specified in keyIntervals. * * @return true if all keys to have get performaed have been completed. */ protected boolean get() { SharedCounters sc = CQUtilBB.getBB().getSharedCounters(); long nextKey = sc.incrementAndRead(CQUtilBB.LASTKEY_GET); if (!keyIntervals.keyInRange(KeyIntervals.GET, nextKey)) { Log.getLogWriter().info("All gets completed; returning from get"); return true; } Object key = NameFactory.getObjectNameForCounter(nextKey); Log.getLogWriter().info("Getting " + key); try { Object existingValue = aRegion.get(key); Log.getLogWriter() .info( "Done getting " + key + ", num remaining: " + (keyIntervals.getLastKey(KeyIntervals.GET) - nextKey)); if (existingValue == null) throw new TestException("Get of key " + key + " returned unexpected " + existingValue); } catch (TimeoutException e) { throw new TestException(TestHelper.getStackTrace(e)); } catch (CacheLoaderException e) { throw new TestException(TestHelper.getStackTrace(e)); } return (nextKey >= keyIntervals.getLastKey(KeyIntervals.GET)); }
/** Start all cqs running for this VM, and create a CQHistory instance for each CQ. */ private void startCQsWithHistory() { initializeQueryService(); CqAttributesFactory cqFac = new CqAttributesFactory(); cqFac.addCqListener(new CQHistoryListener()); cqFac.addCqListener(new CQGatherListener()); CqAttributes cqAttr = cqFac.create(); Iterator it = queryMap.keySet().iterator(); while (it.hasNext()) { String queryName = (String) (it.next()); String query = (String) (queryMap.get(queryName)); try { CqQuery cq = qService.newCq(queryName, query, cqAttr); CQHistory history = new CQHistory(cq.getName()); CQHistoryListener.recordHistory(history); Log.getLogWriter() .info( "Creating CQ with name " + queryName + ": " + query + ", cq attributes: " + cqAttr); Log.getLogWriter().info("Calling executeWithInitialResults on " + cq); CqResults rs = cq.executeWithInitialResults(); SelectResults sr = CQUtil.getSelectResults(rs); if (sr == null) { throw new TestException( "For cq " + cq + " with name " + cq.getName() + " executeWithInitialResults returned " + sr); } Log.getLogWriter() .info( "Done calling executeWithInitializResults on " + cq + " with name " + queryName + ", select results size is " + sr.size()); history.setSelectResults(sr); logNumOps(); // log the select results List srList = sr.asList(); StringBuffer aStr = new StringBuffer(); aStr.append("SelectResults returned from " + queryName + " is\n"); for (int i = 0; i < srList.size(); i++) { aStr.append(srList.get(i) + "\n"); } Log.getLogWriter().info(aStr.toString()); } catch (CqExistsException e) { throw new TestException(TestHelper.getStackTrace(e)); } catch (RegionNotFoundException e) { throw new TestException(TestHelper.getStackTrace(e)); } catch (CqException e) { throw new TestException(TestHelper.getStackTrace(e)); } } }
/** * Waits for a List of threads concurrently stopping and starting Vms to finish, as returned by * {@link #stopStartAsync(List,List)}. Resets the niceKill blackboard entry for each vm is set to * false. * * @param targetVmList A list of hydra.ClientVmInfos to stop then restart. * @param threadList A parallel list of threads on whom to wait. */ public static void joinStopStart(List targetVmList, List threadList) { Log.getLogWriter().info("Joining stop/start threads..."); // wait for all threads to complete the stop and start for (int i = 0; i < threadList.size(); i++) { HydraSubthread aThread = (HydraSubthread) (threadList.get(i)); try { aThread.join(); } catch (InterruptedException e) { throw new TestException(TestHelper.getStackTrace(e)); } Object err = StopStartBB.getBB().getSharedMap().get(StopStartBB.errKey); if (err != null) { throw new TestException(err.toString()); } } // reset the blackboard entries for (int i = 0; i < targetVmList.size(); i++) { ClientVmInfo targetVm = (ClientVmInfo) (targetVmList.get(i)); StopStartBB.getBB() .getSharedMap() .put(StopStartVMs.NiceKillInProgress + targetVm.getVmid(), new Boolean(false)); } Log.getLogWriter().info("Done joining stop/start threads..."); }
private static String generatePayPalNonce(BraintreeGateway gateway, QueryString payload) { String encodedClientToken = gateway.clientToken().generate(); String clientToken = TestHelper.decodeClientToken(encodedClientToken); String authorizationFingerprint = extractParamFromJson("authorizationFingerprint", clientToken); Configuration configuration = gateway.getConfiguration(); String url = configuration.getBaseURL() + configuration.getMerchantPath() + "/client_api/v1/payment_methods/paypal_accounts"; payload .append("authorization_fingerprint", authorizationFingerprint) .append("shared_customer_identifier_type", "testing") .append("shared_customer_identifier", "test-identifier") .append("paypal_account[options][validate]", "false"); String responseBody; String nonce = ""; try { responseBody = HttpHelper.post(url, payload.toString()); nonce = extractParamFromJson("nonce", responseBody); } catch (Exception e) { throw new RuntimeException(e); } return nonce; }
/** Check for the the proper number of afterRemoteRegionCrashEvents */ public static void checkAfterRemoteRegionCrashEvents() { long numCrashEvents = ListenerBB.getBB().getSharedCounters().read(ListenerBB.numAfterRemoteRegionCrashEvents); long numVMsInDS = SplitBrainBB.getBB().getSharedCounters().read(SplitBrainBB.NumVMsInDS); long numVMsStopped = SplitBrainBB.getBB().getSharedCounters().read(SplitBrainBB.NumVMsStopped); // the number of expected crash events is: each vm that did not receive a forced disconnect gets // an event for the vm(s) that did receive a forced disconnect, plus the vm(s) that received // that // forced disconnect get an event for each of the surviving vms that have that region defined. // lynn - waiting for specification as to how many crash events to expect // long numExpectedCrashEvents = 2 * (numVMsInDS - numVMsStopped); long numExpectedCrashEvents = numVMsInDS - numVMsStopped; Log.getLogWriter() .info( "numVMsInDS: " + numVMsInDS + ", numVMsStopped: " + numVMsStopped + ", numExpectedCrashEvents: " + numExpectedCrashEvents); TestHelper.waitForCounter( ListenerBB.getBB(), "ListenerBB.numAfterRemoteRegionCrashEvents", ListenerBB.numAfterRemoteRegionCrashEvents, numExpectedCrashEvents, true, -1, 2000); }
public static String generateUnlockedNonce( BraintreeGateway gateway, String customerId, String creditCardNumber) { ClientTokenRequest request = new ClientTokenRequest(); if (customerId != null) { request = request.customerId(customerId); } String encodedClientToken = gateway.clientToken().generate(request); String clientToken = TestHelper.decodeClientToken(encodedClientToken); String authorizationFingerprint = extractParamFromJson("authorizationFingerprint", clientToken); Configuration configuration = gateway.getConfiguration(); String url = configuration.getBaseURL() + configuration.getMerchantPath() + "/client_api/nonces.json"; QueryString payload = new QueryString(); payload .append("authorization_fingerprint", authorizationFingerprint) .append("shared_customer_identifier_type", "testing") .append("shared_customer_identifier", "test-identifier") .append("credit_card[number]", creditCardNumber) .append("credit_card[expiration_month]", "11") .append("share", "true") .append("credit_card[expiration_year]", "2099"); String responseBody; String nonce = ""; try { responseBody = HttpHelper.post(url, payload.toString()); nonce = extractParamFromJson("nonce", responseBody); } catch (Exception e) { throw new RuntimeException(e); } return nonce; }
public static String generateNonceForCreditCard( BraintreeGateway gateway, CreditCardRequest creditCardRequest, String customerId, boolean validate) { ClientTokenRequest clientTokenRequest = new ClientTokenRequest().customerId(customerId); String encodedClientToken = gateway.clientToken().generate(clientTokenRequest); String clientToken = TestHelper.decodeClientToken(encodedClientToken); String authorizationFingerprint = extractParamFromJson("authorizationFingerprint", clientToken); Configuration configuration = gateway.getConfiguration(); String url = configuration.getBaseURL() + configuration.getMerchantPath() + "/client_api/v1/payment_methods/credit_cards"; QueryString payload = new QueryString(); payload .append("authorization_fingerprint", authorizationFingerprint) .append("shared_customer_identifier_type", "testing") .append("shared_customer_identifier", "fake_identifier") .append("credit_card[options][validate]", new Boolean(validate).toString()); String responseBody; String nonce = ""; try { String payloadString = payload.toString(); payloadString += "&" + creditCardRequest.toQueryString(); responseBody = HttpHelper.post(url, payloadString); nonce = extractParamFromJson("nonce", responseBody); } catch (Exception e) { throw new RuntimeException(e); } return nonce; }
/** * Do operations on the REGION_NAME's keys using keyIntervals to specify which keys get which * operations. This will return when all operations in all intervals have completed. * * @param availableOps - Bits which are true correspond to the operations that should be executed. */ public void doOps(BitSet availableOps) { boolean useTransactions = getInitialImage.InitImagePrms.useTransactions(); while (availableOps.cardinality() != 0) { int whichOp = getOp(availableOps, operations.length); boolean doneWithOps = false; if (useTransactions) { TxHelper.begin(); } switch (whichOp) { case ADD_NEW_KEY: doneWithOps = addNewKey(); break; case INVALIDATE: doneWithOps = invalidate(); break; case DESTROY: doneWithOps = destroy(); break; case UPDATE_EXISTING_KEY: doneWithOps = updateExistingKey(); break; case GET: doneWithOps = get(); break; case LOCAL_INVALIDATE: doneWithOps = localInvalidate(); break; case LOCAL_DESTROY: doneWithOps = localDestroy(); break; default: { throw new TestException("Unknown operation " + whichOp); } } if (useTransactions) { try { TxHelper.commit(); } catch (CommitConflictException e) { // currently not expecting any conflicts ... throw new TestException( "Unexpected CommitConflictException " + TestHelper.getStackTrace(e)); } } if (doneWithOps) { Log.getLogWriter().info("Done with operation " + whichOp); availableOps.clear(whichOp); } if (sleepBetweenOps) { Log.getLogWriter().info("Sleeping between ops for " + SLEEP_BETWEEN_OPS_MILLIS + " millis"); MasterController.sleepForMs(SLEEP_BETWEEN_OPS_MILLIS); } } }
public void reduce(GFKey key, Iterable<PEIWritable> values, Context context) throws IOException, InterruptedException { // For a particular key ... process all records and output what we would have expected in this // concKnownKeys test // Note that we either // 1. do a single create // 2. create + update // 3. create + destroy // look at all ops ... and output either // 1. create // 2. create (with value from update) // 3. do nothing (overall result is destroy, so do not create the entry in the gemfire // validation region String keyStr = (String) key.getKey(); ValueHolder updateValue = null; ValueHolder createValue = null; boolean destroyed = false; System.out.println("KnownKeysMRv2.reduce() invoked with " + keyStr); for (PEIWritable value : values) { PersistedEventImpl event = value.getEvent(); Operation op = event.getOperation(); ValueHolder vh = null; if (op.isDestroy()) { destroyed = true; } else { try { vh = (ValueHolder) event.getDeserializedValue(); } catch (ClassNotFoundException e) { System.out.println( "KnownKeysMRv2.map() caught " + e + " : " + TestHelper.getStackTrace(e)); } if (op.isUpdate()) { updateValue = vh; } else { createValue = vh; } } System.out.println( "KnownKeysMRv2.reduce() record: " + op.toString() + ": key = " + keyStr + " and op " + op.toString()); } if (!destroyed) { if (updateValue != null) { context.write(key.getKey(), updateValue); } else { context.write(key.getKey(), createValue); } } }
@Test public void testIgnoreElements() { Observable<Integer> observable = Observable.just(1, 2, 3).ignoreElements(); Subscriber<Object> observer = TestHelper.mockSubscriber(); observable.subscribe(observer); verify(observer, never()).onNext(any(Integer.class)); verify(observer, never()).onError(any(Throwable.class)); verify(observer, times(1)).onComplete(); }
@Test public void testMaterializeDematerializeChaining() { Observable<Integer> obs = Observable.just(1); Observable<Integer> chained = obs.materialize().dematerialize(); Subscriber<Integer> observer = TestHelper.mockSubscriber(); chained.subscribe(observer); verify(observer, times(1)).onNext(1); verify(observer, times(1)).onComplete(); verify(observer, times(0)).onError(any(Throwable.class)); }
@Test public void testContainsWithEmptyObservable() { Observable<Boolean> observable = Observable.<String>empty().contains("a"); Subscriber<Object> observer = TestHelper.mockSubscriber(); observable.subscribe(observer); verify(observer, times(1)).onNext(false); verify(observer, never()).onNext(true); verify(observer, never()).onError(org.mockito.Matchers.any(Throwable.class)); verify(observer, times(1)).onComplete(); }
@Test public void testContains() { Observable<Boolean> observable = Observable.just("a", "b", "c").contains("b"); // FIXME nulls not allowed, changed to "c" Subscriber<Boolean> observer = TestHelper.mockSubscriber(); observable.subscribe(observer); verify(observer, times(1)).onNext(true); verify(observer, never()).onNext(false); verify(observer, never()).onError(org.mockito.Matchers.any(Throwable.class)); verify(observer, times(1)).onComplete(); }
@Test public void testContainsWithInexistence() { Observable<Boolean> observable = Observable.just("a", "b").contains("c"); // FIXME null values are not allowed, removed Subscriber<Object> observer = TestHelper.mockSubscriber(); observable.subscribe(observer); verify(observer, times(1)).onNext(false); verify(observer, never()).onNext(true); verify(observer, never()).onError(org.mockito.Matchers.any(Throwable.class)); verify(observer, times(1)).onComplete(); }
// Identity mapper (log and write out processed key/value pairs, the value is the // PersistedEventImpl) public void map(GFKey key, PersistedEventImpl value, Context context) throws IOException, InterruptedException { String keyStr = (String) key.getKey(); Operation op = value.getOperation(); ValueHolder entryValue = null; System.out.println("map method invoked with " + keyStr + " " + op.toString()); try { entryValue = (ValueHolder) value.getDeserializedValue(); } catch (ClassNotFoundException e) { System.out.println("KnownKeysMRv2.map() caught " + e + " : " + TestHelper.getStackTrace(e)); } context.write(key, new PEIWritable(value)); }
@Test @Ignore("null values are not allowed") public void testContainsWithNull() { Observable<Boolean> observable = Observable.just("a", "b", null).contains(null); Subscriber<Object> observer = TestHelper.mockSubscriber(); observable.subscribe(observer); verify(observer, times(1)).onNext(true); verify(observer, never()).onNext(false); verify(observer, never()).onError(org.mockito.Matchers.any(Throwable.class)); verify(observer, times(1)).onComplete(); }
@Test public void testCreate() { Observable<String> observable = Observable.just("one", "two", "three"); Subscriber<String> observer = TestHelper.mockSubscriber(); observable.subscribe(observer); verify(observer, times(1)).onNext("one"); verify(observer, times(1)).onNext("two"); verify(observer, times(1)).onNext("three"); verify(observer, never()).onError(any(Throwable.class)); verify(observer, times(1)).onComplete(); }
@Test public void testOfType() { Observable<String> observable = Observable.just(1, "abc", false, 2L).ofType(String.class); Subscriber<Object> observer = TestHelper.mockSubscriber(); observable.subscribe(observer); verify(observer, never()).onNext(1); verify(observer, times(1)).onNext("abc"); verify(observer, never()).onNext(false); verify(observer, never()).onNext(2L); verify(observer, never()).onError(org.mockito.Matchers.any(Throwable.class)); verify(observer, times(1)).onComplete(); }
/** * Check that the value of the given key is expected as an updated value. Throw an error if any * problems. * * @param key The key to check. * @param value The value for the key. * @param logStr Used if throwing an error due to an unexpected value. */ protected void checkUpdatedValue(Object key, Object value) { if (value instanceof QueryObject) { QueryObject qo = (QueryObject) value; long keyCounter = NameFactory.getCounterForName(key); if (qo.aPrimitiveLong > 0) { // this value has not been updated; updates are negative throw new TestException( "Expected QueryObject for key " + key + " to contain negative values (indicating it was updated), but the value for this key is " + qo.toStringFull()); } } else { throw new TestException( "Expected value " + TestHelper.toString(value) + " to be a QueryObject"); } }
/** * Create a region with the given region description name. * * @param regDescriptName The name of a region description. */ protected void initializeRegion(String regDescriptName) { CacheHelper.createCache("cache1"); String key = VmIDStr + RemoteTestModule.getMyVmid(); String xmlFile = key + ".xml"; try { CacheHelper.generateCacheXmlFile("cache1", regDescriptName, xmlFile); } catch (HydraRuntimeException e) { if (e.toString().indexOf("Cache XML file was already created") >= 0) { // this can occur when reinitializing after a stop-start because // the cache xml file is written during the first init tasks } else { throw new TestException(TestHelper.getStackTrace(e)); } } aRegion = RegionHelper.createRegion(regDescriptName); }
@Test public void testJustWithScheduler() { TestScheduler scheduler = new TestScheduler(); Observable<Integer> observable = Observable.fromArray(1, 2).subscribeOn(scheduler); Subscriber<Integer> observer = TestHelper.mockSubscriber(); observable.subscribe(observer); scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onNext(1); inOrder.verify(observer, times(1)).onNext(2); inOrder.verify(observer, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); }
@Ignore // FIXME throwing is not allowed from the create?! @Test public void testOnSubscribeFails() { Subscriber<String> observer = TestHelper.mockSubscriber(); final RuntimeException re = new RuntimeException("bad impl"); Observable<String> o = Observable.create( s -> { throw re; }); o.subscribe(observer); verify(observer, times(0)).onNext(anyString()); verify(observer, times(0)).onComplete(); verify(observer, times(1)).onError(re); }
protected void initializeQueryService() { try { String usingPool = TestConfig.tab().stringAt(CQUtilPrms.QueryServiceUsingPool, "false"); boolean queryServiceUsingPool = Boolean.valueOf(usingPool).booleanValue(); if (queryServiceUsingPool) { Pool pool = PoolHelper.createPool(CQUtilPrms.getQueryServicePoolName()); qService = pool.getQueryService(); Log.getLogWriter() .info("Initializing QueryService using Pool. PoolName: " + pool.getName()); } else { qService = CacheHelper.getCache().getQueryService(); Log.getLogWriter().info("Initializing QueryService using Cache."); } } catch (Exception e) { throw new TestException(TestHelper.getStackTrace(e)); } }
/** * Check that the value of the given key is expected for this test. Throw an error if any * problems. * * @param key The key to check. * @param value The value for the key. * @param logStr Used if throwing an error due to an unexpected value. */ protected void checkValue(Object key, Object value) { if (value instanceof QueryObject) { QueryObject qo = (QueryObject) value; long keyCounter = NameFactory.getCounterForName(key); if (keyCounter != qo.aPrimitiveLong) { // just pick one field from the QueryObject to test; use aPrimitiveLong throw new TestException( "Inconsistent QueryObject for key " + key + ":" + qo.toStringFull()); } } else { throw new TestException( "For key " + key + ", expected value " + TestHelper.toString(value) + " to be a QueryObject"); } }
/** * Load a region with keys and values. The number of keys and values is specified by the total * number of keys in keyIntervals. This can be invoked by several threads to accomplish the work. */ public void loadRegion() { final long LOG_INTERVAL_MILLIS = 10000; int numKeysToCreate = keyIntervals.getNumKeys(); long lastLogTime = System.currentTimeMillis(); long startTime = System.currentTimeMillis(); SharedCounters sc = CQUtilBB.getBB().getSharedCounters(); do { long shouldAddCount = CQUtilBB.getBB().getSharedCounters().incrementAndRead(CQUtilBB.SHOULD_ADD_COUNT); if (shouldAddCount > numKeysToCreate) { String aStr = "In loadRegion, shouldAddCount is " + shouldAddCount + ", numOriginalKeysCreated is " + sc.read(CQUtilBB.NUM_ORIGINAL_KEYS_CREATED) + ", numKeysToCreate is " + numKeysToCreate + ", region size is " + aRegion.size(); Log.getLogWriter().info(aStr); NameBB.getBB().printSharedCounters(); throw new StopSchedulingTaskOnClientOrder(aStr); } Object key = NameFactory.getNextPositiveObjectName(); QueryObject value = getValueToAdd(key); value.extra = key; Log.getLogWriter().info("Creating with put, key " + key + ", value " + value.toStringFull()); aRegion.put(key, value); sc.increment(CQUtilBB.NUM_ORIGINAL_KEYS_CREATED); if (System.currentTimeMillis() - lastLogTime > LOG_INTERVAL_MILLIS) { Log.getLogWriter() .info( "Added " + NameFactory.getPositiveNameCounter() + " out of " + numKeysToCreate + " entries into " + TestHelper.regionToString(aRegion, false)); lastLogTime = System.currentTimeMillis(); } } while ((minTaskGranularitySec == -1) || (System.currentTimeMillis() - startTime < minTaskGranularityMS)); }
public static String generateEuropeBankAccountNonce(BraintreeGateway gateway, Customer customer) { SEPAClientTokenRequest request = new SEPAClientTokenRequest(); request.customerId(customer.getId()); request.mandateType(EuropeBankAccount.MandateType.BUSINESS); request.mandateAcceptanceLocation("Rostock, Germany"); String encodedClientToken = gateway.clientToken().generate(request); String clientToken = TestHelper.decodeClientToken(encodedClientToken); String authorizationFingerprint = extractParamFromJson("authorizationFingerprint", clientToken); Configuration configuration = gateway.getConfiguration(); String url = configuration.getBaseURL() + configuration.getMerchantPath() + "/client_api/v1/sepa_mandates"; QueryString payload = new QueryString(); payload .append("authorization_fingerprint", authorizationFingerprint) .append("sepa_mandate[locale]", "de-DE") .append("sepa_mandate[bic]", "DEUTDEFF") .append("sepa_mandate[iban]", "DE89370400440532013000") .append("sepa_mandate[accountHolderName]", "Bob Holder") .append("sepa_mandate[billingAddress][streetAddress]", "123 Currywurst Way") .append("sepa_mandate[billingAddress][extendedAddress]", "Lager Suite") .append("sepa_mandate[billingAddress][firstName]", "Wilhelm") .append("sepa_mandate[billingAddress][lastName]", "Dix") .append("sepa_mandate[billingAddress][locality]", "Frankfurt") .append("sepa_mandate[billingAddress][postalCode]", "60001") .append("sepa_mandate[billingAddress][countryCodeAlpha2]", "DE") .append("sepa_mandate[billingAddress][region]", "Hesse"); String responseBody; String nonce = ""; try { responseBody = HttpHelper.post(url, payload.toString()); nonce = extractParamFromJson("nonce", responseBody); } catch (Exception e) { throw new RuntimeException(e); } return nonce; }