protected void setUp() throws Exception { CacheUtils.startCache(); cache = CacheUtils.getCache(); AttributesFactory attributesFactory = new AttributesFactory(); // attributesFactory.setValueConstraint(Portfolio.class); RegionAttributes regionAttributes = attributesFactory.create(); region = cache.createRegion("pos", regionAttributes); region.put("0", new Portfolio(0)); region.put("1", new Portfolio(1)); region.put("2", new Portfolio(2)); region.put("3", new Portfolio(3)); qs = cache.getQueryService(); }
/** * 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)); }
private void putData(Region region, int startRow, int numRows, byte[] qf, byte[]... families) throws IOException { for (int i = startRow; i < startRow + numRows; i++) { Put put = new Put(Bytes.toBytes("" + i)); put.setDurability(Durability.SKIP_WAL); for (byte[] family : families) { put.addColumn(family, qf, null); } region.put(put); } }
/** * 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)); }
/** * Creates a new key/value in the given region by creating a new key within the range and a random * value. * * @param aRegion The region to create the new key in. * @param exists Not used in this overridden method; this test wants to use unique keys even on * creates, so we don't do anything different here based on the value of exists. * @return An instance of Operation describing the create operation. */ @Override public Operation createEntry(Region aRegion, boolean exists) { int lower = ((Integer) (lowerKeyRange.get())).intValue(); int upper = ((Integer) (upperKeyRange.get())).intValue(); long keyIndex = TestConfig.tab().getRandGen().nextInt(lower, upper); long startKeyIndex = keyIndex; Object key = NameFactory.getObjectNameForCounter(keyIndex); boolean containsKey = aRegion.containsKey(key); while (containsKey) { // looking for a key that does not exist keyIndex++; // go to the next key if (keyIndex > upper) keyIndex = lower; if (keyIndex == startKeyIndex) { // considered all keys return null; } key = NameFactory.getObjectNameForCounter(keyIndex); containsKey = aRegion.containsKey(key); } BaseValueHolder vh = new ValueHolder(key, randomValues, new Integer(modValInitializer++)); try { Log.getLogWriter() .info( "createEntryKeyRange: putting key " + key + ", object " + vh.toString() + " in region " + aRegion.getFullPath()); aRegion.put(key, vh); Log.getLogWriter() .info( "createEntryKeyRange: done putting key " + key + ", object " + vh.toString() + " in region " + aRegion.getFullPath()); } catch (Exception e) { throw new TestException(TestHelper.getStackTrace(e)); } return new Operation(aRegion.getFullPath(), key, Operation.ENTRY_CREATE, null, vh.modVal); }
/** * Add a new key to REGION_NAME. * * @return true if all new keys have been added (specified by CQUtilPrms.numNewKeys) */ protected boolean addNewKey() { SharedCounters sc = CQUtilBB.getBB().getSharedCounters(); long numNewKeysCreated = sc.incrementAndRead(CQUtilBB.NUM_NEW_KEYS_CREATED); if (numNewKeysCreated > numNewKeys) { Log.getLogWriter().info("All new keys created; returning from addNewKey"); return true; } Object key = NameFactory.getNextPositiveObjectName(); checkContainsValueForKey(key, false, "before addNewKey"); QueryObject value = new QueryObject( NameFactory.getCounterForName(key), QueryObject.EQUAL_VALUES, -1, queryDepth); value.extra = key; // encode the key in the value for later validation Log.getLogWriter().info("Adding new key " + key + " with put"); aRegion.put(key, value); Log.getLogWriter() .info( "Done adding new key " + key + " with put, " + "num remaining: " + (numNewKeys - numNewKeysCreated)); return (numNewKeysCreated >= numNewKeys); }
/** * check distributed ops that originate in a PROXY are correctly distributed to non-proxy regions. */ private void distributedOps(DataPolicy dp, InterestPolicy ip) throws CacheException { initOtherId(); AttributesFactory af = new AttributesFactory(); af.setDataPolicy(dp); af.setSubscriptionAttributes(new SubscriptionAttributes(ip)); af.setScope(Scope.DISTRIBUTED_ACK); Region r = createRootRegion("ProxyDUnitTest", af.create()); doCreateOtherVm(); r.put("putkey", "putvalue1"); getOtherVm() .invoke( new CacheSerializableRunnable("check put") { public void run2() throws CacheException { Region r = getRootRegion("ProxyDUnitTest"); assertEquals(true, r.containsKey("putkey")); assertEquals("putvalue1", r.getEntry("putkey").getValue()); r.put("putkey", "putvalue2"); } }); assertEquals(false, r.containsKey("putkey")); assertEquals("putvalue2", r.get("putkey")); // netsearch r.invalidate("putkey"); getOtherVm() .invoke( new CacheSerializableRunnable("check invalidate") { public void run2() throws CacheException { Region r = getRootRegion("ProxyDUnitTest"); assertEquals(true, r.containsKey("putkey")); assertEquals(null, r.getEntry("putkey").getValue()); } }); assertEquals(null, r.get("putkey")); // invalid so total miss r.destroy("putkey"); getOtherVm() .invoke( new CacheSerializableRunnable("check destroy") { public void run2() throws CacheException { Region r = getRootRegion("ProxyDUnitTest"); assertEquals(false, r.containsKey("putkey")); } }); assertEquals(null, r.get("putkey")); // total miss r.create("createKey", "createValue1"); getOtherVm() .invoke( new CacheSerializableRunnable("check create") { public void run2() throws CacheException { Region r = getRootRegion("ProxyDUnitTest"); assertEquals(true, r.containsKey("createKey")); assertEquals("createValue1", r.getEntry("createKey").getValue()); } }); { Map m = new HashMap(); m.put("putAllKey1", "putAllValue1"); m.put("putAllKey2", "putAllValue2"); r.putAll(m, "putAllCallback"); } getOtherVm() .invoke( new CacheSerializableRunnable("check putAll") { public void run2() throws CacheException { Region r = getRootRegion("ProxyDUnitTest"); assertEquals(true, r.containsKey("putAllKey1")); assertEquals("putAllValue1", r.getEntry("putAllKey1").getValue()); assertEquals(true, r.containsKey("putAllKey2")); assertEquals("putAllValue2", r.getEntry("putAllKey2").getValue()); } }); r.clear(); getOtherVm() .invoke( new CacheSerializableRunnable("check clear") { public void run2() throws CacheException { Region r = getRootRegion("ProxyDUnitTest"); assertEquals(0, r.size()); } }); getOtherVm() .invoke( new CacheSerializableRunnable("install CacheWriter") { public void run2() throws CacheException { Region r = getRootRegion("ProxyDUnitTest"); AttributesMutator am = r.getAttributesMutator(); CacheWriter cw = new CacheWriterAdapter() { public void beforeCreate(EntryEvent event) throws CacheWriterException { throw new CacheWriterException("expected"); } }; am.setCacheWriter(cw); } }); try { r.put("putkey", "putvalue"); fail("expected CacheWriterException"); } catch (CacheWriterException expected) { } getOtherVm() .invoke( new CacheSerializableRunnable("check clear") { public void run2() throws CacheException { Region r = getRootRegion("ProxyDUnitTest"); assertEquals(0, r.size()); } }); assertEquals(null, r.get("loadkey")); // total miss getOtherVm() .invoke( new CacheSerializableRunnable("install CacheLoader") { public void run2() throws CacheException { Region r = getRootRegion("ProxyDUnitTest"); AttributesMutator am = r.getAttributesMutator(); am.setCacheWriter(null); // clear csche writer CacheLoader cl = new CacheLoader() { public Object load(LoaderHelper helper) throws CacheLoaderException { if (helper.getKey().equals("loadkey")) { return "loadvalue"; } else if (helper.getKey().equals("loadexception")) { throw new CacheLoaderException("expected"); } else { return null; } } public void close() {} }; am.setCacheLoader(cl); } }); assertEquals("loadvalue", r.get("loadkey")); // net load assertEquals(null, r.get("foobar")); // total miss try { r.get("loadexception"); fail("expected CacheLoaderException"); } catch (CacheLoaderException expected) { } r.destroyRegion(); getOtherVm() .invoke( new CacheSerializableRunnable("check clear") { public void run2() throws CacheException { Region r = getRootRegion("ProxyDUnitTest"); assertEquals(null, r); } }); }