How to get rid of the Exceptions

Question

When I tried to open the client i.e User interface which is MainMenuApp received NO_PERMISSION CORBA exception while attempting to get an initial reference to the mvcf_ControllerFactory from the FactoryFinder. Software defect that should be addressed is that the UI did not recover after catching the exception and required a restart of the UI to connect.
The problem is that cleanWorkspace() in CorbaAdapter doesn't have any failover logic in it at all. The adapter is assumed to be good and if it is not cleanWorkspace() attempts to use a factory that doesn't exist. This throws an uncaught NullPointerException that blows out to MainMenuApp where it is interpreted as a fatal exception and prevents the main menu from starting. So please help me in writing the failover logic in CorbaAdapter
The code for cleanWorkspace is
* Cleans up the entire logical positions workspace.
* @throws AdapterException UserError or Error occured
public synchronized void cleanWorkspace() throws AdapterException
cut_ContextInitData cid = getContextInitData();
cid.clientId = "*";
MVC2CleanWorkspaceCmd cmd = new MVC2CleanWorkspaceCmd(cid);
execute(cmd);
I am giving the whole logic of Corba Adapter. This might help:
package com.ge.trans.tms.comm;
import java.util.*;
import org.omg.CORBA.CompletionStatus;
import com.beasys.Tobj.FactoryFinder;
import com.ge.trans.tms.ui.util.ExceptionHandler;
import com.ge.trans.tms.util.Log;
import com.ge.trans.tms.util.StringUtils;
import com.ge.trans.tms.forms.mainmenu.Globals;
import pds.cut_IDLCommon.cut_ContextInitData;
import pds.cut_IDLCommon.cut_ValidationResult;
import pds.cut_IDLContainers.cut_KeyValuePair;
import pds.cut_IDLContainers.cut_KeyValueSequenceHolder;
import pds.cut_IDLContainers.cut_StringSeqSeqHolder;
import pds.cut_IDLContainers.cut_StringSequenceHolder;
import pds.cut_IDLExceptions.cut_Error;
import pds.cut_IDLExceptions.cut_InternalError;
import pds.cut_IDLExceptions.cut_UserError;
import pds.cut_IDLExceptions.cut_ModelNotFoundError;
import pds.cut_IDLExceptions.cut_DBDeadlockError;
import pds.mvct.mvct_ParentTableInfo;
import com.ge.trans.tms.util.BM;
import pds.mvcs_ControllerFactory;
import pds.mvcs_ControllerFactoryHelper;
import pds.mvcs_ControllerProxy;
* Title: CorbaAdapter Description: This class provides a generic, 100% java
* interface for its clients (UI for example) to create, query, and modify
* remote data models. The methods in this class foward client requests through
* calls on generated Java/Corba client stubs with disregard to the server-side
* controller/model objects location or language implementation. This is
* currently the only portal for the clients to communicate with the
* server-side model/controller framework. Therefore, this class should mirror
* the complete model/controller interface as provide in the mvcs_Controller
* idl. This class provides constructors that hide all Corba initialization and
* messaging implementation from its clients.
public class CorbaAdapter extends AbstractAdapter
protected String factoryDomainSuffix = "MVC";
private mvcs_ControllerFactory factory;
private mvcs_ControllerProxy controller;
public synchronized mvcs_ControllerProxy getController()
return controller;
protected String getFactoryDomainSuffix() {
return _factoryDomainSuffix;
* Constructor Initializes the connection and generic factory finder. This
* constructor should be used when the cleint does not want to immediately
* create a new handle (controller) to a new or existing model. <p>
* Preconditions: none
* @param domain
* @param listener <p>
* Postconditions: If domain is null, then
* AdapterConstants.DEFAULT_DOMAIN will be used as the domain name. If
* listener is null, neither the caller or any other client will
* receive error messages
public CorbaAdapter(
String domain,
MessageListener listener,
ConnectionListener connectionListener,
boolean uniqueConnection ) throws AdapterException
this(domain, listener, connectionListener, uniqueConnection, true);
public CorbaAdapter(
String domain,
MessageListener listener,
ConnectionListener connectionListener,
boolean uniqueConnection,
boolean geoAdapter ) throws AdapterException
super( listener );
setDomain( domain );
_geoPartitioned = geoAdapter;
//flag to stop retrying after failure to find factory
this.uniqueConnection = uniqueConnection;
String param = System.getProperty(AdapterConstants.POOLED_CONNECTION);
if((param != null) && (param.equals("true"))) {
this.pooledConnection = true;
initialize();
protected Connection makeConnection() throws Exception
Connection connection = null;
if( !pooledConnection )
connection = (CorbaConnection)ConnectionFactory.getDefaultConnection(
new ConnectionListener[] { this, additionalConnectionListener } );
else
String tempDomain = "";
if(domain.equals("LOGICAL_POSITION")) {
tempDomain = "MVC_LOGICAL_POSITION";
} else {
tempDomain = domain;
connection = (CorbaConnection)
PooledConnectionFactory.instance().getPooledConnection(tempDomain);
if(connection != null) {
connection.addConnectionListeners(
new ConnectionListener[] { this, additionalConnectionListener } );
return connection;
* clients should never call this method as this is a the destructor for
* this class and should only be called by the system before the garbage
* collector sweeps away this object NOTE: there is no guarantee when the
* system will call this method, so if a resource is in short supply,
* manage that resource another way
protected void finalize()
if(Log.isEnterEnabled())Log.enter( CorbaAdapter.class, "Entering finalize..." );
// cannot enusre all clients call cleanup fromt their code
// so do this is defensive programming
cleanup();
if(Log.isLeaveEnabled())Log.leave( CorbaAdapter.class, "Leaving finalize..." );
/** This should only be called when the adapter knows that it's
* current connection has been repaired and the adapater's current
* workspace (remote stub) needs to be initialized using the new connection
* (IOR for new server).
* This method should only be called from another which has a lock on the
* current connection. Currently this method is only called from
* verifyConnectionStatus().
private boolean convertController()
if ( controller == null ) {
Log.error(CorbaAdapter.class, "convertController()",
"CONVERT_CONTROLLER CALLED WITH CONTROLLER == NULL",
new Exception("Fix Me"));
MVC2ConvertControllerCmd cmd = new MVC2ConvertControllerCmd();
execute(cmd);
return (((String) cmd.getReturnValue()).equals(AdapterConstants.SUCCESS));
* Initializes an existing adapter to a new controller/model.
* @return AdapterConstants.ERROR or AdapterConstants.SUCCESS
public synchronized String setController()
AbstractCmd cmd = new MVC2SetControllerCmd();
execute(cmd);
Log.debug (getClass (), "returning from set controller :"+(String) cmd.getReturnValue());
return ((String) cmd.getReturnValue());
* Initializes an existing adapter to a new controller/existing model using
* the current domain name and user data <p>
* Preconditions:
* @param domainName must represent a valid domain name
* @param businessKey must represent a valid business key of an existing
* model in the database. <p>
* Postconditions: If the adapter has a initailized controller it is
* uninitialized notifies registered MessageListener if businessKey
* does not represent a valid model that already exists in the
* database. notifies registered UIIFatalMessageListener of all fatal
* server errors
* @return Description of the Return Value
* @returns AdapterConstants.SUCCESS or AdapterConstants.ERROR
public synchronized String setController(Map businessKey)
AbstractCmd cmd = new MVC2SetControllerCmd(businessKey);
execute(cmd);
Log.debug (getClass (), "returning from set controller bus key:"+(String) cmd.getReturnValue());
return ((String) cmd.getReturnValue());
private boolean clientInitialized()
return clientInitialized( true );
private boolean clientInitialized( boolean remoteStub )
forceConnectionChange = false;
if(getController()==null)
Log.info(CorbaAdapter.class,
"clientInitialized()",
"(getController()==null):'"+(getController()==null)+"'");
// obtain lock on used by this adapter and its' connection
// before checking any values that could be changed by a shared
// connection in another thread
synchronized( this.adapterConnectionMonitor )
if( !this.connectionRepaired && !this.connectionBroken )
if( !healthyConnection )
Log.debug(CorbaAdapter.class,
"clientInitialized()",
"connectionRepaired:'"+connectionRepaired+"' "+
"connectionBroken:'"+connectionBroken+"' "+
"healthyConnection:'"+healthyConnection+"' "+
"calling fireFatalErrorHandler with 'AdapterConstants.NULL_CONNECTION'");
fireFatalErrorHandler( AdapterConstants.NULL_CONNECTION );
return false;
else if( !healthyRemoteFactory )
Log.debug(CorbaAdapter.class,
"clientInitialized()",
"connectionRepaired:'"+connectionRepaired+"' "+
"connectionBroken:'"+connectionBroken+"' "+
"healthyRemoteFactory:'"+healthyRemoteFactory+"' "+
"calling fireFatalErrorHandler with 'AdapterConstants.NULL_REMOTE_FACTORY'");
fireFatalErrorHandler( AdapterConstants.NULL_REMOTE_FACTORY );
return false;
else if( remoteStub && !healthyRemoteStub )
Log.debug(CorbaAdapter.class,
"clientInitialized()",
"connectionRepaired:'"+connectionRepaired+"' "+
"connectionBroken:'"+connectionBroken+"' "+
"remoteStub:'"+remoteStub+"' "+
"healthyRemoteStub:'"+healthyRemoteStub+"' "+
"calling fireFatalErrorHandler with 'AdapterConstants.NULL_REMOTE_STUB'");
fireFatalErrorHandler( AdapterConstants.NULL_REMOTE_STUB );
return false;
return true;
} // release lock on used by this adapter and its' connection
* This method should be called when the client has finished working with
* the controller. <p>
* Preconditions: controller (domain specific remote stub) must be
* initialized. <p>
* Postconditions: Cleans up any session state and removes the client's
* workspace from existence. After this method is called, the client will
* no longer be able to make calls on the controller without obtaining
* another controller reference and re-initializing. Any changes made by
* the client since calling commitChanges() are lost (i.e., the client is
* responsible for calling commitChanges() before exiting).
* @return AdapterConstants.SUCCESS or AdapterConstants.ERROR
public synchronized String exit()
AbstractCmd cmd = new MVC2ExitCmd();
execute(cmd);
String returnValue = (String) cmd.getReturnValue();
if(returnValue.equals(AdapterConstants.SUCCESS))
controller = null;
healthyRemoteStub = false;
return returnValue;
* Reports whether adapters controller is currently initialized
* @return The active value
public synchronized boolean isActive()
// obtain lock used by this adapter so that another method can NOT be
// called on this adapter instance from another thread at the same
// time
synchronized( this.adapterConnectionMonitor )
return ( controller != null );
* Preconditions: the controller is initialized Postconditions: Returns the
* domain name from the model we are controlling. <p>
* notifies registered UIIFatalMessageListener of all fatal server errors
* @return The domainName value or AdapterConstants.ERROR
public synchronized String getDomainName() // throws cut_InternalError
AbstractCmd cmd = new MVC2GetDomainNameCmd();
execute(cmd);
return ((String) cmd.getReturnValue());
* Preconditions: the controller is initialized Postconditions: Returns a
* "user context," set by the user of this controller and otherwise not
* used by the mvc2 framework. Context is data only kept in the controller
* (if at all) and not the model. <p>
* notifies registered UIIFatalMessageListener of all fatal server errors
* @return The context value or AdapterConstants.ERROR
public synchronized String getContext() // throws cut_InternalError
AbstractCmd cmd = new MVC2GetContextCmd();
execute(cmd);
return ((String) cmd.getReturnValue());
* Preconditions: the controller is initialized
* @param value saved as a "user context," set by the user of this
* controller and used by domain or customer derived controllers. <p>
* notifies registered UIIFatalMessageListener of all fatal server
* errors
* @return AdapterConstants.ERROR or AdapterConstants.SUCCESS
public synchronized String setContext( String value )
AbstractCmd cmd = new MVC2SetContextCmd(value);
execute(cmd);
return ((String) cmd.getReturnValue());
* Sets a key on the server.
* @param property key to set
* @param value value
* @return String retruned by service provider or Adapter.ERROR
public synchronized String setValue( String key, String value )
AbstractCmd cmd = new MVC2SetValueCmd(key, value);
execute(cmd);
return ((String) cmd.getReturnValue());
* Preconditions: the controller has been initialized
* @param property is a valid property of the model <p>
* Postconditions: notifies registered UIMessageListeners if property
* is not valid notifies registered UIIFatalMessageListener(s) of any
* fatal server errors
* @return The value value
* @returns the current value of the specified property or
* AdapterConstants.ERROR
public synchronized String getValue( String property ) // throws cut_InternalError
AbstractCmd cmd = new MVC2GetValueCmd(property);
execute(cmd);
return ((String) cmd.getReturnValue());
* Preconditions: the controller has been initialized and propertyValueMap
* is not null All properties given is propertyValueMap are valid
* properties of the model.
* Postconditions: All values for the properties in the map are added to
* the map.
* @param propertyValueMap each KeyValuePair element will have its value
* set based on its key notifies registered UIMessageListeners if any
* property given in the map is not a valid property of the model. If
* this happens, the map is unchanged. notifies registered
* UIIFatalMessageListener(s) of any fatal server errors
* @return The values value
* @returns AdapterConstants.SUCCESS or
* AdapterConstants.ERROR
public synchronized String getValues( Map propertyValueMap )
AbstractCmd cmd = new MVC2GetValuesCmd(propertyValueMap);
execute(cmd);
return ((String) cmd.getReturnValue());
* Preconditions: controller has been initialized and propertyValueMap is
* not null <p>
* Postconditions: All properties and their associated values are added to
* the propertyValueMap. Prior contents of the map are NOT erased.
* @param propertyValueMap will be cleared then filled with KeyValuePair
* object references notifies registered UIIFatalMessageListener(s) of
* any fatal server errors <p>
* @return The allValues value
* @returns AdapterConstants.SUCCESS or
* AdapterConstants.ERROR NOTE: The actual definition of what "all
* values" mean is left to the designers of the UI and the Controller
* but should reflect what is in the models' metamodel
public synchronized String getAllValues( Map propertyValueMap )
AbstractCmd cmd = new MVC2GetAllValuesCmd(propertyValueMap);
execute(cmd);
return ((String) cmd.getReturnValue());
* Invoke a method on controller.
* @param method Method to invoke on controller
* @param values input/output values sent and returned from controller
* @return String from service on success or AdapterConstrants.ERROR
public synchronized String invokeMethod( String method, List values )
AbstractCmd cmd = new MVC2InvokeMethodCmd(method, values);
execute(cmd);
return (String) cmd.getReturnValue();
* Preconditions: the controller has been initialized Postconditions:
* Validates the state of the model for committing, copies the transient
* model to the persistent model, and commits it to the database. <p>
* reports a user error(s) to registered MessageListener s if the state of
* the model is not a valid one for commiting. reports all fatal server
* errors to registered UIIFatalMessageListener s <p>
* @return Description of the Return Value
* @returns AdapterConstants.ERROR or AdapterConstants.SUCCESS
public synchronized String commitChanges()
AbstractCmd cmd = new MVC2CommitChangesCmd();
execute(cmd);
return ((String) cmd.getReturnValue());
* Preconditions: the controller has been initialized. Postconditions:
* Aborts all changes to the model since commitChanges() was last called.
* <p>
* reports all fatal server errors to registered UIIFatalMessageListener s
* <p>
* @return Description of the Return Value
* @returns AdapterConstants.ERROR or AdapterConstants.SUCCESS
public synchronized String abortChanges()
AbstractCmd cmd = new MVC2AbortChangesCmd();
execute(cmd);
return ((String) cmd.getReturnValue());
* Preconditions: the controller has been initialized and columnName is not
* null
* @param tableName must be a valid table of the model.
* @param columnName is a valid column in the table of the model.
* @param rowNum is a valid row in the table of the model.
* @param parents used if the table is a subtable of another table, its
* parent table(s) info must be specified and must be valid. If the
* table is not a subtable, then parents should be empty. <p>
* Postconditions: <p>
* asserts columnName or rowNum have valid values for the table asserts
* the information in parents is valid and complete; reports to
* registered MessageListener s if the table is not a table of the
* model
* @return The tableValue value
* @todo talk to Kelly because an invalid table name should
* not be a user error but a programming error reports all fatal server
* errors to registered UIIFatalMessageListener s <p>
* @returns the value of the table element located in the
* specified column at the specified row or AdapterConstants.ERROR
public synchronized String getTableValue(
String tableName,
String columnName,
int rowNum,
ParentTableInfo[] parents )
AbstractCmd cmd = new MVC2GetTableValueCmd(tableName, columnName, rowNum, parents);
execute(cmd);
return ((String) cmd.getReturnValue());
* @param tableId The new tableValue value
* @param columnName The new tableValue value
* @param row The new tableValue value
* @param value The new tableValue value
* @return Description of the Return Value
* @see setTableValue(String tableName, String columnName,
* int rowNum, String value, ParentTableInfo[] parents) for method
* contract
public synchronized String setTableValue(
String tableId,
String columnName,
int row,
String value )
return setTableValue( tableId, columnName, row, value,
( ( ParentTableInfo[] ) null ) );
* Preconditions: asserts the controller has been initialized and
* columnName is not null
* @param tableName must be a valid table of the model.
* @param columnName is a valid column in the table of the model.
* @param rowNum is a valid row in the table of the model.
* @param value is a valid value of the tables column and row (cell)
* @param parents used if the table is a subtable of another table, its
* parent table(s) info must be specified and must be valid. If the
* table is not a subtable, then parents should be empty. <p>
* Postconditions: Sets the value of the table cell located in the
* specified column at the specified rowNum to the new value. <p>
* asserts both the columnName or rowNum have valid values for the
* table asserts the information in parents is valid and complete
* reports to registered MessageListener s if the table is not a table
* of the model and if the value is not a valid value for the cell of
* the table reports all fatal server errors to registered
* UIIFatalMessageListener s
* @return Description of the Return Value
* @returns the value that the table cell is set to or
* AdapterConstants.ERROR
public synchronized String setTableValue(
String tableName,
String columnName,
int rowNum,
String value,
ParentTableInfo[] parents )
AbstractCmd cmd = new MVC2SetTableValueCmd(tableName, columnName,
rowNum, value, parents);
execute(cmd);
return ((String) cmd.getReturnValue());
* Preconditions: the controller has been initialized and tableName is not
* null
* @param tableName must be a valid table of the model.
* @param parents used if the table is a subtable of another table, its
* parent table(s) info must be specified and must be valid. If the
* table is not a subtable, then parents should be empty. <p>
* Postconditions: <p>
* asserts the information in parents argument is valid and complete.
* reports to registered MessageListener s if table is not a valid
* table reports all fatal server errors to registered
* UIIFatalMessageListener s
* @return The numberOfRows value
* @returns the number of rows in the table if successful, else -1
public synchronized int getNumberOfRows(
String tableName,
ParentTableInfo[] parents )
AbstractCmd cmd = new MVC2GetNumberOfRowsCmd(tableName, parents);
execute(cmd);
Object returnValue = cmd.getReturnValue();
if(returnValue.equals(AdapterConstants.ERROR))
return -1;
return ((Integer) cmd.getReturnValue()).intValue();
* Preconditions: the controller has been initialized and tableName is not
* null
* @param tableName must be a valid table of the model.
* @param parents used if the table is a subtable of another table,
* its parent table(s) info must be specified and must be valid. If the
* table is not a subtable, then parents should be empty.
* @param rowPosition represents the (zero-based) position where you want
* the new row <p>
* Postconditions: Adds one row to the table at the specified position.
* <p>
* asserts that the rowPosition is within range to add to the table
* asserts that the information in parents is valid and complete.
* reports to registered MessageListener s if table is not a valid
* table and if it is not valid to add the row to the specified
* position reports all fatal server errors to registered
* UIIFatalMessageListener s
* @return Description of the Return Value
* @returns the new row number of the inserted row if
* successful, else -1
public synchronized int addRow(
String tableName,
int rowPosition,
ParentTableInfo[] parents )
AbstractCmd cmd = new MVC2AddRowCmd(tableName, rowPosition, parents);
execute(cmd);
return ((Integer) cmd.getReturnValue()).intValue();
* Preconditions: the controller has been initialized, tableName is not
* null, and rowsToDelete is not null or empty
* @param tableName must be a valid table of the model.
* @param parents used if the table is a subtable of another table,
* its parent table(s) info must be specified and must be valid. If the
* table is not a subtable, then parents should be empty.
* @param rowsToDelete all rows specified in this container must exist in
* the table 'tableName' <p>
* Postconditions: Deletes all rows specified in rowsToDelete from the
* table. <p>
* asserts all row indexes in rowsToDelete are valid asserts the
* information in parents argument is valid and complete reports to
* registered MessageListener s if the 'tableName' is not a valid table
* of the model and if it is not valid to delete the rows at the
* specified positions reports all fatal server errors to registered
* UIIFatalMessageListener s
* @return Description of the Return Value
* @returns AdapterConstants.SUCCESS or AdapterConstants.ERROR
public synchronized String deleteRows(
String tableName,
int[] rowsToDelete,
ParentTableInfo[] parents )
AbstractCmd cmd = new MVC2DeleteRowsCmd(tableName, rowsToDelete, parents);
execute(cmd);
return ((String) cmd.getReturnValue());
* This method retrieves all values for a specified row. The value in each
* column is retrieved and stored in the row container. The row container
* is column ordered. Prior contents in the row container are lost as the
* container is initialized within this method. <p>
* Preconditions: the controller has been initialized and the container
* 'row' is not null
* @param tableName must be a valid table of the model.
* @param rowPosition represents a valid row in the table.
* @param parents used if the table is a subtable of another table,
* its parent table(s) info must be specified and must be valid. If the
* table is not a subtable, then parents should be empty.
* @param row container which will be filled with the specified
* table rows values <p>
* Postconditions: asserts that rowPosition is valid (i.e not out of
* range) asserts the information in parents argument is valid and
* complete asserts that the container row is a valid as an
* input/output parameter (i.e. not null) reports to registered
* MessageListener s if tableName is not a valid table of the model
* reports all fatal server errors to registered
* UIIFatalMessageListener s
* @return The row value
* @returns AdapterConstants.SUCCESS or AdapterConstants.ERROR
* <p>
* NOTE: All columns and all rows have zero-based indices.
public synchronized String getRow(
String tableName,
int rowPosition,
List row,
ParentTableInfo[] parents )
AbstractCmd cmd = new MVC2GetRowCmd(tableName, rowPosition, row, paren

Answer 1

Please can u answer it fast