use of org.omg.CosTransactions.Terminator in project narayana by jbosstm.
the class GridClient method test.
@Test
public void test() throws Exception {
ORB myORB = null;
RootOA myOA = null;
myORB = ORB.getInstance("test");
myOA = OA.getRootOA(myORB);
myORB.initORB(new String[] {}, null);
myOA.initOA();
ORBManager.setORB(myORB);
ORBManager.setPOA(myOA);
TransactionFactory theOTS = null;
Control myControl = null;
grid gridVar = null;
int h = -1, w = -1, v = -1;
String gridReference = "/tmp/grid.ref";
String serverName = "Grid";
if (System.getProperty("os.name").startsWith("Windows")) {
gridReference = "C:\\temp\\grid.ref";
}
Services serv = new Services(myORB);
try {
String[] params = new String[1];
params[0] = Services.otsKind;
org.omg.CORBA.Object obj = serv.getService(Services.transactionService, params);
params = null;
theOTS = TransactionFactoryHelper.narrow(obj);
} catch (Exception e) {
fail("Unexpected bind exception: " + e);
}
System.out.println("Creating transaction.");
try {
myControl = theOTS.create(0);
} catch (Exception e) {
fail("Create call failed: " + e);
e.printStackTrace();
}
try {
gridVar = gridHelper.narrow(serv.getService(gridReference, null, Services.FILE));
} catch (Exception e) {
fail("Grid bind failed: " + e);
}
try {
h = gridVar.height();
w = gridVar.width();
} catch (Exception e) {
fail("Grid invocation failed: " + e);
}
System.out.println("height is " + h);
System.out.println("width is " + w);
try {
System.out.println("calling set");
gridVar.set(2, 4, 123, myControl);
System.out.println("calling get");
v = gridVar.get(2, 4, myControl);
} catch (Exception sysEx) {
fail("Grid set/get failed: " + sysEx);
}
// no problem setting and getting the elememt:
System.out.println("grid[2,4] is " + v);
// sanity check: make sure we got the value 123 back:
if (v != 123) {
// oops - we didn't:
fail("something went seriously wrong");
try {
myControl.get_terminator().rollback();
} catch (Exception e) {
}
} else {
System.out.println("Committing transaction.");
try {
Terminator handle = myControl.get_terminator();
handle.commit(true);
} catch (Exception sysEx) {
fail("Transaction commit error: " + sysEx);
}
}
try {
OTSManager.destroyControl(myControl);
} catch (Exception e) {
fail("Caught destroy exception: " + e);
}
myOA.destroy();
myORB.shutdown();
System.out.println("Test completed successfully.");
}
use of org.omg.CosTransactions.Terminator in project narayana by jbosstm.
the class OSIInterposition 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 may correctly be NULL
tmpCoord == null) {
return null;
}
ServerControl control = ServerFactory.create_transaction(currentUid, null, null, tmpCoord, tmpTerm, ctx.timeout);
action = new ServerOSITopLevelAction(control, ((depth == 0) ? true : false));
if (!action.valid()) {
try {
// does dispose as well!
((ServerOSITopLevelAction) action).rollback();
action = null;
} catch (Exception e) {
}
throw new TRANSACTION_ROLLEDBACK();
}
ServerTopLevelAction newElement = (ServerOSITopLevelAction) 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(OTIDMap.find(ctx.parents[i].otid), tmpCoord, tmpTerm, control);
// not current, so don't register
nestedAction = new ServerOSINestedAction(control, false);
if (!nestedAction.valid()) {
try {
// does dispose as well!
((ServerOSINestedAction) nestedAction).rollback_subtransaction();
nestedAction = null;
} catch (Exception e) {
}
throw new TRANSACTION_ROLLEDBACK();
}
/*
* Add transaction resource to list.
*/
action.addChild((ServerOSINestedAction) 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(OTIDMap.find(ctx.current.otid), tmpCoord, tmpTerm, control);
// current, so register
nestedAction = new ServerOSINestedAction(control, true);
if (!nestedAction.valid()) {
try {
// does dispose as well!
((ServerOSINestedAction) nestedAction).rollback_subtransaction();
nestedAction = null;
} catch (Exception e) {
}
throw new TRANSACTION_ROLLEDBACK();
}
action.addChild((ServerOSINestedAction) nestedAction);
}
if (jtsLogger.logger.isTraceEnabled())
compareHierarchies(ctx, newElement);
return control;
}
use of org.omg.CosTransactions.Terminator in project narayana by jbosstm.
the class OSIInterposition 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.
*/
ServerOSITopLevelAction tx = (ServerOSITopLevelAction) 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 = 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(OTIDMap.find(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(OTIDMap.find(context.parents[j].otid), tmpCoord, tmpTerm, control);
nestedAction = new ServerOSINestedAction(control, false);
if (!nestedAction.valid()) {
try {
// does dispose as well!
((ServerOSINestedAction) nestedAction).rollback();
nestedAction = null;
} catch (Exception e) {
}
throw new TRANSACTION_ROLLEDBACK();
}
currentAction.addChild((ServerOSINestedAction) nestedAction);
currentAction = nestedAction;
}
} else {
/*
* Hierarchies may be identical.
* Remember to check!
*/
}
Uid currentUid = OTIDMap.find(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 ServerOSINestedAction(control, true);
if (!nestedAction.valid()) {
try {
// does dispose as well!
((ServerOSINestedAction) nestedAction).rollback();
nestedAction = null;
} catch (Exception e) {
}
throw new TRANSACTION_ROLLEDBACK();
}
currentAction.addChild((ServerOSINestedAction) 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 org.omg.CosTransactions.Terminator in project narayana by jbosstm.
the class RestrictedInterposition method createHierarchy.
protected synchronized ControlImple createHierarchy(PropagationContext ctx, Uid tlUid) 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.
*/
int depth = ctx.parents.length;
ServerTopLevelAction tlAction = 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;
}
ServerControl control = ServerFactory.create_transaction(tlUid, null, null, tmpCoord, tmpTerm, ctx.timeout);
tlAction = new ServerRestrictedTopLevelAction(control);
if (!tlAction.valid()) {
try {
tlAction.rollback();
tlAction = null;
} catch (Exception e) {
}
throw new TRANSACTION_ROLLEDBACK();
}
ServerTopLevelAction newElement = tlAction;
super._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.
*/
ServerRestrictedNestedAction 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);
nestedAction = new ServerRestrictedNestedAction(control);
if (!nestedAction.valid()) {
try {
nestedAction.rollback();
nestedAction = null;
} catch (Exception e) {
}
throw new TRANSACTION_ROLLEDBACK();
}
/*
* Add transaction resource to list.
*/
tlAction.addChild(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);
nestedAction = new ServerRestrictedNestedAction(control);
if (!nestedAction.valid()) {
try {
nestedAction.rollback();
nestedAction = null;
} catch (Exception e) {
}
throw new TRANSACTION_ROLLEDBACK();
}
tlAction.addChild(nestedAction);
}
return control;
}
use of org.omg.CosTransactions.Terminator 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;
}
Aggregations