1. /*

  2.  * @(#)ShutdownUtilDelegate.java	1.18 04/01/13

  3.  *

  4.  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. package com.sun.corba.se.internal.iiop;

  8. 

  9. import org.omg.CORBA.*;

  10. import java.util.*;

  11. import java.rmi.*;

  12. import java.io.*;

  13. import org.omg.CORBA.portable.OutputStream;

  14. import org.omg.CORBA.portable.UnknownException;

  15. import javax.transaction.TransactionRequiredException;

  16. import javax.transaction.TransactionRolledbackException;

  17. import javax.transaction.InvalidTransactionException;

  18. 

  19. import javax.rmi.CORBA.Tie;

  20. 

  21. import com.sun.corba.se.internal.util.Utility;

  22. import com.sun.corba.se.internal.orbutil.*;

  23. import com.sun.corba.se.internal.core.ORBVersionImpl;

  24. import com.sun.corba.se.internal.core.ORBVersion;

  25. import com.sun.corba.se.internal.core.ClientSubcontract;

  26. 

  27. public class ShutdownUtilDelegate extends com.sun.corba.se.internal.javax.rmi.CORBA.Util

  28. {

  29.     static ShutdownUtilDelegate instance = null;

  30. 

  31.     public ShutdownUtilDelegate() {

  32.         instance = this;

  33.     }

  34. 

  35.     public boolean isLocal(javax.rmi.CORBA.Stub stub) throws RemoteException {

  36. 

  37.         try {

  38. 	    org.omg.CORBA.portable.Delegate delegate = stub._get_delegate() ;

  39.             if (delegate instanceof ClientSubcontract)

  40. 	       return ((ClientSubcontract)delegate).useLocalInvocation( stub ) ;

  41.             else

  42.                return delegate.is_local( stub );

  43.         } catch (SystemException e) {

  44.             throw javax.rmi.CORBA.Util.mapSystemException(e);

  45.         }

  46.     }

  47. 

  48.     protected void unregisterTargetsForORB(ORB orb) {

  49.         super.unregisterTargetsForORB(orb);

  50.     }

  51. 

  52.     /**

  53.      * Maps a SystemException to a RemoteException.

  54.      * @param ex the SystemException to map.

  55.      * @return the mapped exception.

  56.      */

  57.     public RemoteException mapSystemException(SystemException ex) {

  58. 

  59.         if (ex instanceof UnknownException) {

  60.             Throwable orig = ((UnknownException)ex).originalEx;

  61.             if (orig instanceof Error) {

  62.                 return new ServerError("Error occurred in server thread",(Error)orig);

  63.             } else if (orig instanceof RemoteException) {

  64.                 return new ServerException("RemoteException occurred in server thread",(Exception)orig);

  65.             } else if (orig instanceof RuntimeException) {

  66.                 throw (RuntimeException) orig;

  67.             }

  68.         }

  69. 

  70.         // Build the message string...

  71. 

  72.         String name = ex.getClass().getName();

  73.         String corbaName = name.substring(name.lastIndexOf('.')+1);

  74.         String status;

  75.         switch (ex.completed.value()) {

  76.         case CompletionStatus._COMPLETED_YES:

  77.             status = "Yes";

  78.             break;

  79.         case CompletionStatus._COMPLETED_NO:

  80.             status = "No";

  81.             break;

  82.         case CompletionStatus._COMPLETED_MAYBE:

  83.         default:

  84.             status = "Maybe";

  85.             break;

  86.         }

  87.         String message = "CORBA "+corbaName+" "+ex.minor+" "+status;

  88. 

  89.         // Now map to the correct RemoteException type...

  90. 

  91.         if (ex instanceof COMM_FAILURE) {

  92.             return new MarshalException(message, ex);

  93.         } else if (ex instanceof INV_OBJREF) {

  94.             RemoteException newEx = new NoSuchObjectException(message);

  95.             newEx.detail = ex;

  96.             return newEx;

  97.         } else if (ex instanceof NO_PERMISSION) {

  98.             return new AccessException(message, ex);

  99.         } else if (ex instanceof MARSHAL) {

  100.             return new MarshalException(message, ex);

  101.         } else if (ex instanceof OBJECT_NOT_EXIST) {

  102.             RemoteException newEx = new NoSuchObjectException(message);

  103.             newEx.detail = ex;

  104.             return newEx;

  105.         } else if (ex instanceof TRANSACTION_REQUIRED) {

  106.             RemoteException newEx = new TransactionRequiredException(message);

  107.             newEx.detail = ex;

  108.             return newEx;

  109.         } else if (ex instanceof TRANSACTION_ROLLEDBACK) {

  110.             RemoteException newEx = new TransactionRolledbackException(message);

  111.             newEx.detail = ex;

  112.             return newEx;

  113.         } else if (ex instanceof INVALID_TRANSACTION) {

  114.             RemoteException newEx = new InvalidTransactionException(message);

  115.             newEx.detail = ex;

  116.             return newEx;

  117.         } else if (ex instanceof BAD_PARAM) {

  118. 

  119.             Exception inner = ex;

  120. 

  121.             // Pre-Merlin Sun ORBs used the incorrect minor code for

  122.             // this case.  See Java to IDL ptc-00-01-08 1.4.8.

  123.             if (ex.minor == MinorCodes.LEGACY_SUN_NOT_SERIALIZABLE ||

  124.                 ex.minor == MinorCodes.NOT_SERIALIZABLE) {

  125. 

  126.                 if (ex.getMessage() != null)

  127.                     inner = new NotSerializableException(ex.getMessage());

  128.                 else

  129.                     inner = new NotSerializableException();

  130.             }

  131. 

  132.             return new MarshalException(message,inner);

  133.         }

  134. 

  135.         // Just map to a generic RemoteException...

  136. 

  137.         return new RemoteException(message, ex);

  138.     }

  139. 

  140. 

  141.     // Duplicated from the se delegate superclass.  The subtle

  142.     // difference is that it uses ORBUtility instead of Utility.

  143.     // This is required since we can't assume that the Utility

  144.     // version we're running with (may be from the JDK) has

  145.     // the throwNotSerializableForCorba method that takes a

  146.     // String parameter (added for JDK 1.4/J2EE 1.3).

  147. 

  148.     // Warning: Assumes Utility.autoConnect is available

  149. 

  150.     /**

  151.      * Writes any java.lang.Object as a CORBA any.

  152.      * @param out the stream in which to write the any.

  153.      * @param obj the object to write as an any.

  154.      */

  155.     public void writeAny(org.omg.CORBA.portable.OutputStream out, 

  156.                          java.lang.Object obj) {

  157. 

  158.         org.omg.CORBA.ORB orb = out.orb();

  159. 

  160.         // Create Any

  161.         Any any = orb.create_any();

  162. 

  163.         // Make sure we have a connected object...

  164. 

  165.         java.lang.Object newObj = Utility.autoConnect(obj,orb,false);

  166. 

  167.         if (newObj instanceof org.omg.CORBA.Object) {

  168.             any.insert_Object((org.omg.CORBA.Object)newObj);

  169.         } else {

  170.             if (newObj == null) {

  171.                 // Handle the null case, including backwards

  172.                 // compatibility issues

  173.                 any.insert_Value(null, createTypeCodeForNull(orb));

  174.             } else {

  175.                 if (newObj instanceof Serializable) {

  176.                     // If they're our Any and ORB implementations,

  177.                     // we may want to do type code related versioning.

  178.                     TypeCode tc = createTypeCode((Serializable)newObj, any, orb);

  179.                     if (tc == null)

  180.                         any.insert_Value((Serializable)newObj);

  181.                     else

  182.                         any.insert_Value((Serializable)newObj, tc);

  183.                 } else if (newObj instanceof Remote) {

  184.                     ORBUtility.throwNotSerializableForCorba(newObj.getClass().getName());

  185.                 } else {

  186.                     ORBUtility.throwNotSerializableForCorba(newObj.getClass().getName());

  187.                 }

  188.             }

  189.         }

  190. 

  191.         //d11638 Write the Any

  192.         out.write_any(any);

  193.     }

  194. 

  195.     /**

  196.      * When using our own ORB and Any implementations, we need to get

  197.      * the ORB version and create the type code appropriately.  This is

  198.      * to overcome a bug in which the JDK 1.3.x ORBs used a tk_char

  199.      * rather than a tk_wchar to describe a Java char field.

  200.      *

  201.      * This only works in RMI-IIOP with Util.writeAny since we actually

  202.      * know what ORB and stream we're writing with when we insert

  203.      * the value.

  204.      *

  205.      * Returns null if it wasn't possible to create the TypeCode (means

  206.      * it wasn't our ORB or Any implementation).

  207.      *

  208.      * This does not handle null objs.

  209.      */

  210.     private TypeCode createTypeCode(Serializable obj,

  211.                                     org.omg.CORBA.Any any,

  212.                                     org.omg.CORBA.ORB orb) {

  213. 

  214.         if (any instanceof com.sun.corba.se.internal.corba.AnyImpl &&

  215.             orb instanceof com.sun.corba.se.internal.corba.ORB) {

  216. 

  217.             com.sun.corba.se.internal.corba.AnyImpl anyImpl

  218.                 = (com.sun.corba.se.internal.corba.AnyImpl)any;

  219. 

  220.             com.sun.corba.se.internal.corba.ORB ourORB

  221.                 = (com.sun.corba.se.internal.corba.ORB)orb;

  222. 

  223.             return anyImpl.createTypeCodeForClass(obj.getClass(), ourORB);

  224. 

  225.         } else

  226.             return null;

  227.     }

  228. 

  229.     /**

  230.      * This is used to create the TypeCode for a null reference.

  231.      * It also handles backwards compatibility with JDK 1.3.x.

  232.      *

  233.      * This method will not return null.

  234.      */

  235.     private TypeCode createTypeCodeForNull(org.omg.CORBA.ORB orb) {

  236.         if (orb instanceof com.sun.corba.se.internal.corba.ORB) {

  237. 

  238.             com.sun.corba.se.internal.corba.ORB ourORB

  239.                 = (com.sun.corba.se.internal.corba.ORB)orb;

  240. 

  241.             // Preserve backwards compatibility with Kestrel and Ladybird

  242.             // by not fully implementing interop issue resolution 3857,

  243.             // and returning a null TypeCode with a tk_value TCKind.

  244.             // If we're not talking to Kestrel or Ladybird, fall through

  245.             // to the abstract interface case (also used for foreign ORBs).

  246.             if (!ORBVersionImpl.FOREIGN.equals(ourORB.getORBVersion()) &&

  247.                 ORBVersionImpl.NEWER.compareTo(ourORB.getORBVersion()) > 0) {

  248. 

  249.                 return orb.get_primitive_tc(TCKind.tk_value);

  250.             }

  251.         }

  252. 

  253.         // Use tk_abstract_interface as detailed in the resolution

  254. 

  255.         // REVISIT: Define this in IDL and get the ID in generated code

  256.         String abstractBaseID = "IDL:omg.org/CORBA/AbstractBase:1.0";

  257. 

  258.         return orb.create_abstract_interface_tc(abstractBaseID, "");

  259.     }

  260. }