/* gnuServantObject.java -- Copyright (C) 2005 Free Software Foundation, Inc. This file is part of GNU Classpath. GNU Classpath is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU Classpath is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Classpath; see the file COPYING. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Linking this library statically or dynamically with other modules is making a combined work based on this library. Thus, the terms and conditions of the GNU General Public License cover the whole combination. As a special exception, the copyright holders of this library give you permission to link this library with independent modules to produce an executable, regardless of the license terms of these independent modules, and to copy and distribute the resulting executable under terms of your choice, provided that you also meet, for each linked independent module, the terms and conditions of the license of that module. An independent module is a module which is not derived from or based on this library. If you modify this library, you may extend this exception to your version of the library, but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version. */ package gnu.CORBA.Poa; import gnu.CORBA.IOR_Delegate; import gnu.CORBA.IOR_contructed_object; import org.omg.CORBA.BAD_OPERATION; import org.omg.CORBA.BAD_PARAM; import org.omg.CORBA.CompletionStatus; import org.omg.CORBA.OBJECT_NOT_EXIST; import org.omg.CORBA.OBJ_ADAPTER; import org.omg.CORBA.ORB; import org.omg.CORBA.SystemException; import org.omg.CORBA.TRANSIENT; import org.omg.CORBA.portable.InputStream; import org.omg.CORBA.portable.InvokeHandler; import org.omg.CORBA.portable.ObjectImpl; import org.omg.CORBA.portable.OutputStream; import org.omg.CORBA.portable.ResponseHandler; import org.omg.PortableServer.CurrentOperations; import org.omg.PortableServer.DynamicImplementation; import org.omg.PortableServer.ForwardRequest; import org.omg.PortableServer.ImplicitActivationPolicyValue; import org.omg.PortableServer.POA; import org.omg.PortableServer.POAManager; import org.omg.PortableServer.POAManagerPackage.State; import org.omg.PortableServer.Servant; import org.omg.PortableServer.ServantLocatorPackage.CookieHolder; import org.omg.PortableServer.ServantRetentionPolicyValue; import org.omg.PortableServer.portable.Delegate; import java.util.Arrays; /** * Represents a CORBA object, being locally served by the associated * servant. The calls to the object are forwarded to the calls to the * servant. * * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org) */ public class gnuServantObject extends ObjectImpl implements org.omg.CORBA.Object, InvokeHandler, CurrentOperations { /** * The associated servant that must also implement the * {@link InvokeHandler} interface. This value can be temporary * null if the object was created using * POA.create_reference or POA.create_reference_with_id, private to force * always to use {@link setServant}. */ private Servant servant; /** * The Id of this object. */ public final byte[] Id; /** * The poa that takes care about this object. */ public final gnuPOA poa; /** * The POA manager, used to control the work of this object. */ public final POAManager manager; /** * The orb. */ public final ORB_1_4 orb; /** * The object repository ids, if they were specified separately. * Normally, the ids are requested from the servant. */ public final String[] repository_ids; /** * Create an object with no connected servant. The servant must be * set later. * * @param a_repository_ids an array of repository ids, can be null * (then ids will be requested from the servant). * @param an_id the object id. * @param a_poa the POA. */ public gnuServantObject(String[] a_repository_ids, byte[] an_id, gnuPOA a_poa, ORB_1_4 an_orb ) { repository_ids = a_repository_ids; Id = an_id; manager = a_poa.the_POAManager(); poa = a_poa; orb = an_orb; } /** * Create a servant object, associated with the passed servant. * * @param a_servant a servant, serving this object. * @param an_id an Object Id for this object. * * @throws BAD_PARAM if the passed servant is not an * {@link InvokeHandler}. */ public gnuServantObject(Servant a_servant, byte[] an_id, ORB_1_4 an_orb, gnuPOA a_poa ) { Id = an_id; setServant(a_servant); poa = a_poa; if (poa != null) manager = poa.the_POAManager(); else manager = null; repository_ids = null; orb = an_orb; } /** * Set a servant, if it has not been previously set. * * @param a_servant a servant to set, can be null to indicate * the necessity for the subsequent activation. * * @throws BAD_PARAM if the passed servant is not an * {@link InvokeHandler} or {@link DynamicImplementation} and also * not null. */ public void setServant(Servant a_servant) { if (a_servant != null && !(a_servant instanceof InvokeHandler) && !(a_servant instanceof DynamicImplementation) ) throw new BAD_PARAM("Must be either InvokeHandler or " + "DynamicImplementation, but is " + a_servant ); servant = a_servant; } /** * Returns the associated servant. */ public Servant getServant() { return servant; } /** * Return the associated invocation handler. */ public InvokeHandler getHandler(String operation, CookieHolder cookie, boolean forwarding_allowed ) throws gnuForwardRequest { if (servant != null) return servantToHandler(servant); else { // Use servant locator to locate the servant. if (poa.servant_locator != null) { try { servant = poa.servant_locator.preinvoke(Id, poa, operation, cookie); return servantToHandler(servant); } catch (ForwardRequest forw_ex) { if (forwarding_allowed) throw new gnuForwardRequest(forw_ex.forward_reference); else { servant = ForwardedServant.create(forw_ex.forward_reference); return servantToHandler(servant); } } } else // Use servant activator to locate the servant. if (poa.applies(ImplicitActivationPolicyValue.IMPLICIT_ACTIVATION) && poa.applies(ServantRetentionPolicyValue.RETAIN) ) { try { poa.activate_object_with_id(Id, servant, forwarding_allowed); servant = poa.id_to_servant(Id); return servantToHandler(servant); } catch (gnuForwardRequest forwarded) { throw forwarded; } catch (Exception ex) { ex.printStackTrace(); BAD_OPERATION bad = new BAD_OPERATION("Unable to activate", 0x5004, CompletionStatus.COMPLETED_NO ); bad.initCause(ex); throw bad; } } else if (poa.default_servant != null) { servant = poa.default_servant; return servantToHandler(servant); } // No servant and no servant manager - throw exception. else throw new BAD_OPERATION("Unable to activate", 0x5002, CompletionStatus.COMPLETED_NO ); } } /** * Convert the servant to invocation handler. */ public InvokeHandler servantToHandler(Servant servant) { if (servant instanceof InvokeHandler) return (InvokeHandler) servant; else if (servant instanceof DynamicImplementation) return new dynImpHandler((DynamicImplementation) servant); else throw new BAD_OPERATION(servant + " must be either InvokeHandler or " + "POA DynamicImplementation" ); } /** * Create a servant object, associated with the passed servant. * Requests the object id from the servant. Depending on the * policies of the servants POA, the calls are eithe not * synchronized or synchronized on POA or ORB. * * @param a_servant a servant, serving this object. * @param an_id an Object Id for this object. */ public gnuServantObject(Servant a_servant, gnuPOA poa) { this(a_servant, a_servant._object_id(), (ORB_1_4) a_servant._orb(), poa); } /** * Delegates call to servant, passing the poa and Id. */ public String[] _ids() { if (repository_ids == null) return getServant()._all_interfaces(poa, Id); else return repository_ids; } /** * Gets a string representation. */ public String toString() { StringBuffer b = new StringBuffer("Servant object ("); for (int i = 0; i < Id.length; i++) { b.append(Integer.toHexString(Id [ i ] & 0xFF)); b.append(' '); } b.append(')'); return b.toString(); } /** * Always returns true. */ public boolean _is_local() { return true; } /** * Check if this object could be named by the given repository id. * @param idl_id the repository id to check. * * @return true if it is one of the possible repository ids of this * object. */ public boolean _is_a(String idl_id) { String[] maybe = _ids(); for (int i = 0; i < maybe.length; i++) { if (maybe [ i ].equals(idl_id)) return true; } return false; } /** * Get an ORB, associated with the servant of this object. * @return */ public ORB _orb() { return getServant()._orb(); } /** * Handle the invocation (delegates to servant). * * @throws TRANSIENT minor 0x535503e9 if the POA is in discarding mode. * @throws OBJ_ADAPTER minor 0x535503ea if the POA is inactivated. * @throws OBJECT_NOT_EXISTS minor 0x535503ec if this object is * inactivated. * * @specnote see {@link POAManagerOperations} for specnotes about * the minor codes. */ public OutputStream _invoke(String method, InputStream input, ResponseHandler r_handler ) throws SystemException { try { CookieHolder cookie = null; activeObjectMap.Obj self = poa.aom.get(Id); if (poa.servant_locator != null) { // If the servant locator is in use, it is always responsible // for providing the servant. self.servant = servant = null; cookie = new CookieHolder(); } else if (self != null && self.isDeactiveted()) { if (poa.applies(ImplicitActivationPolicyValue.IMPLICIT_ACTIVATION) && poa.servant_activator != null ) { // Reset the servant, forcing the subsequent activation. servant = null; } else throw new OBJECT_NOT_EXIST("Object deactivated", 0x535503ec, CompletionStatus.COMPLETED_NO ); } InvokeHandler handler = getHandler(method, cookie, true); Delegate d = null; try { d = servant._get_delegate(); orb.currents.put(Thread.currentThread(), this); } catch (Exception ex) { // In some cases exception is thrown if the delegate is not set. } if (d instanceof servantDelegate) { // If the delegate is already set, check maybe we can // reuse the existing instance. if (((servantDelegate) d).object != this) servant._set_delegate(new servantDelegate(servant, poa, Id)); } else { servant._set_delegate(new servantDelegate(servant, poa, Id)); } try { switch (manager.get_state().value()) { case State._ACTIVE : return handler._invoke(method, input, r_handler); case State._HOLDING : // The holding mode is implemented // relying on the holding capabilites of the network // support (if any). // TODO FIXME in more recent CORBA applications, the client // ORB can free the connection and wait for a server side // notification about the completed request. Implement this. int sleep = 5; int max = 500; // Wait till the state will be switched into some other // mode. while (manager.get_state().value() == State._HOLDING) { try { Thread.sleep(sleep); if (sleep < max) sleep = max; } catch (InterruptedException ex) { } } // Handle another mode. return _invoke(method, input, r_handler); case State._DISCARDING : throw new TRANSIENT("Discarding mode", 0x535503e9, CompletionStatus.COMPLETED_NO ); case State._INACTIVE : throw new OBJ_ADAPTER("POA deactivated", 0x535503ea, CompletionStatus.COMPLETED_NO ); default : throw new InternalError(); // No more states. } } finally { if (poa.servant_locator != null) { poa.servant_locator.postinvoke(Id, poa, method, cookie.value, servant ); servant = null; } } } finally { orb.currents.remove(Thread.currentThread()); } } /** * Compare with another object for equality, comparing the * object keys. */ public boolean equals(java.lang.Object other) { if (other instanceof gnuServantObject) { gnuServantObject o = (gnuServantObject) other; return Arrays.equals(o.Id, Id); } else return false; } /** * Get the hash code, based on the object key. */ public int hashCode() { long s = 0; int v = 1; for (int i = 0; i < Id.length; i++) { s += Id [ i ] * v; if (s > Integer.MAX_VALUE) { s = s % Integer.MAX_VALUE; v = 1; } v = v * 8; } return (int) (s % Integer.MAX_VALUE); } /** * Get the object id. */ public byte[] get_object_id() { return Id; } /** * Get POA. */ public POA get_POA() { return poa; } /** * Returns without action. */ public void _release() { } /** * Returns without action. */ public void _releaseReply(InputStream stream) { } /** * Checks if this object is equivalent to another instance. * These objects are assumed equal if they are connected to the * same orb and poa under the same Id, regardless of they * delegates. * * @param another instance to check. * @return */ public boolean _is_equivalent(org.omg.CORBA.Object other) { if (other instanceof gnuServantObject) { gnuServantObject g = (gnuServantObject) other; return orb == g.orb && poa == g.poa && Arrays.equals(Id, g.Id); } else if (other instanceof IOR_contructed_object) { IOR_contructed_object ir = ((IOR_contructed_object) other); try { IOR_Delegate ird = (IOR_Delegate) ir._get_delegate(); byte[] ior_id = poa.idFormIor(ird.getIor().key); if (ior_id != null && Arrays.equals(ior_id, Id)) return true; else return false; } catch (Exception ex) { // Non - typical delegate or very specific subclass of // IOR_constructed_object. return super._is_equivalent(other); } } return super._is_equivalent(other); } }