use of com.arjuna.ats.internal.jts.orbspecific.interposition.resources.strict.ServerStrictTopLevelAction in project narayana by jbosstm.
the class ServerTopLevelStrictUnitTest method test.
@Test
public void test() throws Exception {
ControlImple cont = new ControlImple(null, null);
Control theControl = cont.getControl();
ArjunaTransactionImple tx = cont.getImplHandle();
ServerControl sc = new ServerControl(tx.get_uid(), theControl, tx, theControl.get_coordinator(), theControl.get_terminator());
ServerStrictTopLevelAction act = new ServerStrictTopLevelAction(sc, true);
assertTrue(act.interposeResource());
assertTrue(act.type() != null);
}
use of com.arjuna.ats.internal.jts.orbspecific.interposition.resources.strict.ServerStrictTopLevelAction in project narayana by jbosstm.
the class StrictInterposition method checkHierarchy.
/*
* In a single threaded environment we could walk down the hierarchy, aborting
* any actions which are no longer valid, and creating any new ones. However,
* in a multi-threaded environment, a thread can make a call from any point in
* the client's hierarchy, and multiple client threads can invoke the same
* server object. So, in general we cannot do this optimisation. We must
* maintain the entire tree until portions of it have explicitly been termined.
*
* Once we find the point in the new hierarchy which deviates from our current
* representation, we begin to assemble a new subtree in much the same way
* as we did for creating a completely new hierarchy.
*/
/*
* Also we would like to just register one resource to represent the entire
* hierarchy, but this has problems: since threads can invoke operations at
* any point in a hierarchy, we end up with multiple resources at top-level
* for the same transaction. Each will try to commit the top-level transaction!
* In this implementation, the first to do so will garbage collect the root
* of the hierarchy, and probably cause the subsequent ones to fail! There is
* also the problem with many cross-process calls for the *same* transaction.
* So, we register *one* resource for each level of the hierarchy *when it is
* required*, i.e., as the previous transaction terminates, and remove
* terminated transaction resources when they occur. This means that at
* top-level we only have a single resource to commit. There are the same
* number of cross-process invocations. However, we also maintain the entire
* hierarchy at the server, so if it makes subsequent invocations, the right
* hierarchy gets sent out!
*/
protected synchronized ControlImple checkHierarchy(ServerTopLevelAction hier, PropagationContext context) {
ServerControl control = null;
// top-level transaction
ServerResource currentAction = hier;
int depth = context.parents.length;
// index of the new transactions in the hierarchy
int differenceIndex = -1;
if (depth == 0) {
/*
* There are no transactions in the context other than the current
* transaction, which must therefore be top-level. We already have
* the control to return. However, make sure it has registered
* itself with the "real" transaction.
*/
ServerStrictTopLevelAction tx = (ServerStrictTopLevelAction) hier;
tx.interposeResource();
// top-level transaction's control
control = tx.control();
} else {
ServerResource nestedAction = null;
for (// don't check depth-1 as it is current action!
int i = (int) depth - 2; // don't check depth-1 as it is current action!
i >= 0; // don't check depth-1 as it is current action!
i--) {
nestedAction = currentAction.getChild(Utility.otidToUid(context.parents[i].otid));
if (// point of difference, so stop trawling hierarchy
nestedAction == null) {
// remember for later so that we can add new actions.
differenceIndex = i;
break;
} else {
/*
* currentAction *always* points to the last known
* good transaction in our hierarchy.
*/
currentAction = nestedAction;
}
}
if (differenceIndex != -1) {
control = currentAction.control();
Coordinator tmpCoord = null;
Terminator tmpTerm = null;
for (int j = differenceIndex; j >= 0; j--) {
tmpCoord = context.parents[j].coord;
tmpTerm = context.parents[j].term;
control = ServerFactory.create_subtransaction(Utility.otidToUid(context.parents[j].otid), tmpCoord, tmpTerm, control);
nestedAction = new ServerStrictNestedAction(control, false);
if (!nestedAction.valid()) {
try {
// does dispose as well!
((ServerStrictNestedAction) nestedAction).rollback();
nestedAction = null;
} catch (Exception e) {
}
throw new TRANSACTION_ROLLEDBACK();
}
currentAction.addChild((ServerStrictNestedAction) nestedAction);
currentAction = nestedAction;
}
} else {
/*
* Hierarchies may be identical.
* Remember to check!
*/
}
Uid currentUid = Utility.otidToUid(context.current.otid);
/*
* currentAction points to the parent of the 'current'
* transaction, i.e., the last element in the TransIdentity
* structure. So, ask it if the sent hierarchy's child is
* one of its children.
*/
nestedAction = currentAction.getChild(currentUid);
if (nestedAction == null) {
/*
* Different notion of current in sent hierarchy.
* So, add it to the hierarchy here.
*/
control = currentAction.control();
/*
* Now deal with the current transaction.
*/
TransIdentity currentID = context.current;
control = ServerFactory.create_subtransaction(currentUid, currentID.coord, currentID.term, control);
nestedAction = new ServerStrictNestedAction(control, true);
if (!nestedAction.valid()) {
try {
// does dispose as well!
((ServerStrictNestedAction) nestedAction).rollback();
nestedAction = null;
} catch (Exception e) {
}
throw new TRANSACTION_ROLLEDBACK();
}
currentAction.addChild((ServerStrictNestedAction) nestedAction);
} else {
/*
* Same current, so get its control and return it.
* Remember to make sure it has registered itself with
* the "real" transaction.
*/
nestedAction.interposeResource();
control = nestedAction.control();
}
}
if (jtsLogger.logger.isTraceEnabled())
compareHierarchies(context, hier);
return control;
}
use of com.arjuna.ats.internal.jts.orbspecific.interposition.resources.strict.ServerStrictTopLevelAction in project narayana by jbosstm.
the class StrictInterposition method createHierarchy.
protected synchronized ControlImple createHierarchy(PropagationContext ctx, Uid currentUid) throws SystemException {
/*
* Start at the parent and work our way down to "current". The current
* transaction is not in the IDL sequence, but sent as separate field
* of the propagation context. This tends to make the code more
* complex than it would be if the entire hierarchy was represented in
* one place.
*/
/*
* We only ever register the current transaction with its parent, and
* as each transaction commits, it registers its parent with the
* "real" parent.
*/
int depth = ctx.parents.length;
ServerResource action = null;
Coordinator tmpCoord = null;
Terminator tmpTerm = null;
if (depth == 0) {
tmpCoord = ctx.current.coord;
tmpTerm = ctx.current.term;
} else {
tmpCoord = ctx.parents[depth - 1].coord;
tmpTerm = ctx.parents[depth - 1].term;
}
if (// terminator my correctory be null
tmpCoord == null)
return null;
ServerControl control = ServerFactory.create_transaction(currentUid, null, null, tmpCoord, tmpTerm, ctx.timeout);
action = new ServerStrictTopLevelAction(control, ((depth == 0) ? true : false));
if (!action.valid()) {
try {
// does dispose as well!
((ServerStrictTopLevelAction) action).rollback();
action = null;
} catch (Exception e) {
}
throw new TRANSACTION_ROLLEDBACK();
}
ServerTopLevelAction newElement = (ServerStrictTopLevelAction) action;
_head.add(newElement);
if (// current is a nested transaction
depth > 0) {
/*
* Now deal with any nested transactions.
* As we create, register with the original transactions.
*/
ServerResource nestedAction = null;
for (int i = depth - 2; i >= 0; i--) {
tmpCoord = ctx.parents[i].coord;
tmpTerm = ctx.parents[i].term;
control = ServerFactory.create_subtransaction(Utility.otidToUid(ctx.parents[i].otid), tmpCoord, tmpTerm, control);
// not current, so don't register
nestedAction = new ServerStrictNestedAction(control, false);
if (!nestedAction.valid()) {
try {
// does dispose as well!
((ServerStrictNestedAction) nestedAction).rollback_subtransaction();
nestedAction = null;
} catch (Exception e) {
}
throw new TRANSACTION_ROLLEDBACK();
}
/*
* Add transaction resource to list.
*/
action.addChild((ServerStrictNestedAction) nestedAction);
action = nestedAction;
}
/*
* Now deal with current transaction. If there is
* only one transaction we do nothing.
*/
tmpCoord = ctx.current.coord;
tmpTerm = ctx.current.term;
control = ServerFactory.create_subtransaction(Utility.otidToUid(ctx.current.otid), tmpCoord, tmpTerm, control);
// current, so register
nestedAction = new ServerStrictNestedAction(control, true);
if (!nestedAction.valid()) {
try {
// does dispose as well!
((ServerStrictNestedAction) nestedAction).rollback_subtransaction();
nestedAction = null;
} catch (Exception e) {
}
throw new TRANSACTION_ROLLEDBACK();
}
action.addChild((ServerStrictNestedAction) nestedAction);
}
if (jtsLogger.logger.isTraceEnabled())
compareHierarchies(ctx, newElement);
return control;
}
Aggregations