@Test
public void testAddObjectNotFound() throws Exception {
newTransaction();
dataService.removeObject(one);
one = new Int(1);
assertTrue(set.add(one));
dataService.removeObject(one);
newTransaction();
assertTrue(set.add(new Int(1)));
}
@SuppressWarnings("unchecked")
@Test
public void testIteratorCollectionNotFound() throws Exception {
set.add(one);
Iterator<Object> iter = set.iterator();
dataService.setBinding("iter", new ManagedSerializable(iter));
newTransaction();
DoneRemoving.init();
dataService.removeObject(set);
endTransaction();
DoneRemoving.await(1);
startTransaction();
iter = (Iterator<Object>) dataService.getBinding("iter", ManagedSerializable.class).get();
try {
iter.next();
fail("Expected ObjectNotFoundException");
} catch (ObjectNotFoundException e) {
System.err.println(e);
}
try {
iter.hasNext();
fail("Expected ObjectNotFoundException");
} catch (ObjectNotFoundException e) {
System.err.println(e);
}
try {
iter.remove();
fail("Expected an exception");
} catch (ObjectNotFoundException e) {
System.err.println(e);
} catch (IllegalStateException e) {
System.err.println(e);
}
}
@Test
public void testSizeObjectNotFound() throws Exception {
set.add(one);
newTransaction();
dataService.removeObject(one);
assertEquals(1, set.size());
newTransaction();
assertEquals(1, set.size());
}
@Test
public void testIsEmptyObjectNotFound() throws Exception {
set.add(one);
newTransaction();
dataService.removeObject(one);
assertFalse(set.isEmpty());
newTransaction();
assertFalse(set.isEmpty());
}
@Test
public void testContainsObjectNotFound() throws Exception {
set.add(one);
newTransaction();
dataService.removeObject(one);
assertFalse(set.contains(one));
newTransaction();
assertFalse(set.contains(one));
}
@Test
public void testRemoveObjectNotFound() throws Exception {
set.add(one);
newTransaction();
dataService.removeObject(one);
one = new Int(1);
assertFalse(set.remove(one));
newTransaction();
assertFalse(set.remove(one));
}
private void op(int i) throws Exception {
if (random.nextInt(5) == 0) {
DummyTransaction t = txn;
txn = null;
t.commit();
long time = System.currentTimeMillis() - txnStart;
if (time > maxTxnTime) {
maxTxnTime = time;
maxTxnTimeOps = txnOps;
}
txnStart = System.currentTimeMillis();
txnOps = 0;
createTxn();
}
txnOps++;
int start = id * (objects + objectsBuffer);
String name = getObjectName(start + random.nextInt(objects));
switch (random.nextInt(whichOperations.value)) {
case 0:
/* Get binding */
service.getBinding(name, Object.class);
break;
case 1:
/* Set bindings */
ModifiableObject obj = service.getBinding(name, ModifiableObject.class);
String name2 = getObjectName(start + random.nextInt(objects));
ModifiableObject obj2 = service.getBinding(name2, ModifiableObject.class);
service.setBinding(name, obj2);
service.setBinding(name2, obj);
break;
case 2:
/* Modify object */
service.getBinding(name, ModifiableObject.class).incrementNumber(service);
break;
case 3:
/* Create object */
/*
* Get the binding first, so the new object is created with
* proper locality.
*/
ModifiableObject object = service.getBinding(name, ModifiableObject.class);
service.removeObject(object);
object = new ModifiableObject();
service.setBinding(name, object);
BigInteger oidBlock = service.createReference(object).getId().shiftRight(32);
if (block == null || !block.equals(oidBlock)) {
block = oidBlock;
System.err.println("Thread " + id + ": create block " + block);
}
break;
default:
throw new AssertionError();
}
}
@Test
public void testClearObjectNotFound() throws Exception {
set.add(one);
newTransaction();
dataService.removeObject(one);
DoneRemoving.init();
set.clear();
assertTrue(set.isEmpty());
one = new Int(1);
set.add(one);
endTransaction();
DoneRemoving.await(1);
startTransaction();
dataService.removeObject(one);
newTransaction();
set.clear();
assertTrue(set.isEmpty());
endTransaction();
DoneRemoving.await(1);
}
/** Removes the channel server proxy and binding for the node specified during construction. */
public void run() {
String channelServerKey = getChannelServerKey(nodeId);
DataService dataService = getDataService();
try {
dataService.removeObject(dataService.getServiceBinding(channelServerKey));
} catch (NameNotBoundException e) {
// already removed
return;
} catch (ObjectNotFoundException e) {
}
dataService.removeServiceBinding(channelServerKey);
}
@Test
public void testRemoveObjectSet() throws Exception {
DoneRemoving.init();
dataService.removeObject(set);
set = null;
endTransaction();
DoneRemoving.await(1);
startTransaction();
int count = getObjectCount();
set = new ScalableHashSet<Object>();
newTransaction();
for (int i = 0; i < 50; i++) {
set.add(random.nextInt());
}
newTransaction();
dataService.removeObject(set);
set = null;
endTransaction();
DoneRemoving.await(1);
startTransaction();
assertEquals(count, getObjectCount());
}
/**
* Removes the client session server proxy and binding and also removes the protocol descriptors
* for the node specified during construction.
*/
public void run() {
String sessionServerKey = getClientSessionServerKey(nodeId);
DataService dataService = getDataService();
try {
dataService.removeObject(dataService.getServiceBinding(sessionServerKey));
getProtocolDescriptorsMap().remove(nodeId);
} catch (NameNotBoundException e) {
// already removed
return;
} catch (ObjectNotFoundException e) {
}
dataService.removeServiceBinding(sessionServerKey);
}
@Test
public void testEqualsObjectNotFound() throws Exception {
Set<Object> empty = new HashSet<Object>();
Set<Object> containsOne = new HashSet<Object>();
containsOne.add(one);
set.add(one);
newTransaction();
dataService.removeObject(one);
assertFalse(set.equals(empty));
assertFalse(set.equals(containsOne));
newTransaction();
assertFalse(set.equals(empty));
assertFalse(set.equals(containsOne));
}
@Test
public void testCopyConstructorObjectNotFound() throws Exception {
set.add(one);
newTransaction();
dataService.removeObject(one);
try {
new ScalableHashSet<Object>(set);
fail("Expected ObjectNotFoundException");
} catch (ObjectNotFoundException e) {
}
newTransaction();
try {
new ScalableHashSet<Object>(set);
fail("Expected ObjectNotFoundException");
} catch (ObjectNotFoundException e) {
}
}
@SuppressWarnings("unchecked")
@Test
public void testIteratorObjectNotFound() throws Exception {
set.add(one);
set.add(new Int(2));
Iterator<Object> iter = set.iterator();
dataService.setBinding("iter", new ManagedSerializable(iter));
newTransaction();
dataService.removeObject(one);
newTransaction();
iter = (Iterator<Object>) dataService.getBinding("iter", ManagedSerializable.class).get();
int count = 0;
while (iter.hasNext()) {
try {
assertEquals(new Int(2), iter.next());
count++;
} catch (ObjectNotFoundException e) {
}
}
assertEquals(1, count);
}
/**
* Invokes the {@code disconnected} callback on this session's {@code ClientSessionListener} (if
* present and {@code notify} is {@code true}), removes the listener and its binding (if present),
* and then removes this session and its bindings from the specified {@code dataService}. If the
* bindings have already been removed from the {@code dataService} this method takes no action.
* This method should only be called within a transaction.
*
* @param dataService a data service
* @param graceful {@code true} if disconnection is graceful, and {@code false} otherwise
* @param notify {@code true} if the {@code disconnected} callback should be invoked
* @throws TransactionException if there is a problem with the current transaction
*/
void notifyListenerAndRemoveSession(
final DataService dataService, final boolean graceful, boolean notify) {
String sessionKey = getSessionKey();
String sessionNodeKey = getSessionNodeKey();
String listenerKey = getListenerKey();
String eventQueueKey = getEventQueueKey();
/*
* Get ClientSessionListener, and remove its binding and
* wrapper if applicable. The listener may not be bound
* in the data service if: the AppListener.loggedIn callback
* either threw a non-retryable exception or returned a
* null listener, or the application removed the
* ClientSessionListener object from the data service.
*/
ClientSessionListener listener = null;
try {
ManagedObject obj = dataService.getServiceBinding(listenerKey);
dataService.removeServiceBinding(listenerKey);
if (obj instanceof ListenerWrapper) {
dataService.removeObject(obj);
listener = ((ListenerWrapper) obj).get();
} else {
listener = (ClientSessionListener) obj;
}
} catch (NameNotBoundException e) {
logger.logThrow(Level.FINE, e, "removing ClientSessionListener for session:{0} throws", this);
}
/*
* Remove event queue and associated binding.
*/
try {
ManagedObject eventQueue = dataService.getServiceBinding(eventQueueKey);
dataService.removeServiceBinding(eventQueueKey);
dataService.removeObject(eventQueue);
} catch (NameNotBoundException e) {
logger.logThrow(Level.FINE, e, "removing EventQueue for session:{0} throws", this);
}
/*
* Invoke listener's 'disconnected' callback if 'notify'
* is true and a listener exists for this client session. If the
* 'disconnected' callback throws a non-retryable exception,
* schedule a task to remove this session and its associated
* bindings without invoking the listener, and rethrow the
* exception so that the currently executing transaction aborts.
*/
if (notify && listener != null) {
try {
listener.disconnected(graceful);
} catch (RuntimeException e) {
if (!isRetryableException(e)) {
logger.logThrow(
Level.WARNING,
e,
"invoking disconnected callback on listener:{0} " + " for session:{1} throws",
listener,
this);
sessionService.scheduleTask(
new AbstractKernelRunnable() {
public void run() {
ClientSessionImpl sessionImpl = ClientSessionImpl.getSession(dataService, id);
sessionImpl.notifyListenerAndRemoveSession(dataService, graceful, false);
}
},
identity);
}
throw e;
}
}
/*
* Remove this session's state and bindings.
*/
try {
dataService.removeServiceBinding(sessionKey);
dataService.removeServiceBinding(sessionNodeKey);
dataService.removeObject(this);
} catch (NameNotBoundException e) {
logger.logThrow(Level.WARNING, e, "session binding already removed:{0}", sessionKey);
}
/*
* Remove this session's wrapper object, if it still exists.
*/
try {
dataService.removeObject(wrappedSessionRef.get());
} catch (ObjectNotFoundException e) {
// already removed
}
}