/* * Copyright (c) 1997, 2003, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code 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 * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package sun.rmi.server; import java.io.IOException;import java.io.ObjectInput;import java.io.ObjectOutput;import java.lang.reflect.Proxy;import java.net.MalformedURLException;import java.net.URL;import java.rmi.*;import java.rmi.activation.*;import java.rmi.server.Operation;import java.rmi.server.RMIClassLoader;import java.rmi.server.RemoteCall;import java.rmi.server.RemoteObject;import java.rmi.server.RemoteObjectInvocationHandler;import java.rmi.server.RemoteRef;import java.rmi.server.RemoteStub; public class ActivatableRef implements RemoteRef {     private static final long serialVersionUID = 7579060052569229166L;     protected ActivationID id;    protected RemoteRef ref;    transient boolean force = false;     private static final int MAX_RETRIES = 3;    private static final String versionComplaint =        "activation requires 1.2 stubs";     /**     * Create a new (empty) ActivatableRef     */    public ActivatableRef()    {}     /**     * Create a ActivatableRef with the specified id     */    public ActivatableRef(ActivationID id, RemoteRef ref)    {        this.id = id;        this.ref = ref;    }     /**     * Returns the stub for the remote object whose class is     * specified in the activation descriptor. The ActivatableRef     * in the resulting stub has its activation id set to the     * activation id supplied as the second argument.     */    public static Remote getStub(ActivationDesc desc, ActivationID id)        throws StubNotFoundException    {        String className = desc.getClassName();         try {            Class cl =                RMIClassLoader.loadClass(desc.getLocation(), className);            RemoteRef clientRef = new ActivatableRef(id, null);            return Util.createProxy(cl, clientRef, false);         } catch (IllegalArgumentException e) {            throw new StubNotFoundException(                "class implements an illegal remote interface", e);         } catch (ClassNotFoundException e) {            throw new StubNotFoundException("unable to load class: " +                                            className, e);        } catch (MalformedURLException e) {            throw new StubNotFoundException("malformed URL", e);        }    }     /**     * Invoke method on remote object. This method delegates remote     * method invocation to the underlying ref type.  If the     * underlying reference is not known (is null), then the object     * must be activated first.  If an attempt at method invocation     * fails, the object should force reactivation.  Method invocation     * must preserve "at most once" call semantics.  In RMI, "at most     * once" applies to parameter deserialization at the remote site     * and the remote object's method execution.  "At most once" does     * not apply to parameter serialization at the client so the     * parameters of a call don't need to be buffered in anticipation     * of call retry. Thus, a method call is only be retried if the     * initial method invocation does not execute at all at the server     * (including parameter deserialization).     */    public Object invoke(Remote obj,                         java.lang.reflect.Method method,                         Object[] params,                         long opnum)        throws Exception    {         boolean force = false;        RemoteRef localRef;        Exception exception = null;         /*         * Attempt object activation if active ref is unknown.         * Throws a RemoteException if object can't be activated.         */        synchronized (this) {            if (ref == null) {                localRef = activate(force);                force = true;            } else {                localRef = ref;            }        }         for (int retries = MAX_RETRIES; retries > 0; retries--) {             try {                return localRef.invoke(obj, method, params, opnum);            } catch (NoSuchObjectException e) {                /*                 * Object is not active in VM; retry call                 */                exception = e;            } catch (ConnectException e) {                /*                 * Failure during connection setup; retry call                 */                exception = e;            } catch (UnknownHostException e) {                /*                 * Failure during connection setup; retry call.                 */                exception = e;            } catch (ConnectIOException e) {                /*                 * Failure setting up multiplexed connection or reusing                 * cached connection; retry call                 */                exception = e;            } catch (MarshalException e) {                /*                 * Failure during parameter serialization; call may                 * have reached server, so call retry not possible.                 */                throw e;            } catch (ServerError e) {                /*                 * Call reached server; propagate remote exception.                 */                throw e;            } catch (ServerException e) {                /*                 * Call reached server; propagate remote exception                 */                throw e;            } catch (RemoteException e) {                /*                 * This is a catch-all for other RemoteExceptions.                 * UnmarshalException being the only one relevant.                 *                 * StubNotFoundException should never show up because                 * it is generally thrown when attempting to locate                 * a stub.                 *                 * UnexpectedException should never show up because                 * it is only thrown by a stub and would be wrapped                 * in a ServerException if it was propagated by a                 * remote call.                 */                synchronized (this) {                    if (localRef == ref) {                        ref = null;     // this may be overly conservative                    }                }                 throw e;            }             if (retries > 1) {                /*                 * Activate object, since object could not be reached.                 */                synchronized (this) {                    if (localRef.remoteEquals(ref) || ref == null) {                        RemoteRef newRef = activate(force);                         if (newRef.remoteEquals(localRef) &&                            exception instanceof NoSuchObjectException &&                            force == false) {                            /*                             * If last exception was NoSuchObjectException,                             * then old value of ref is definitely wrong,                             * so make sure that it is different.                             */                            newRef = activate(true);                        }                         localRef = newRef;                        force = true;                    } else {                        localRef = ref;                        force = false;                    }                }            }        }         /*         * Retries unsuccessful, so throw last exception         */        throw exception;    }     /**     * private method to obtain the ref for a call.     */    private synchronized RemoteRef getRef()        throws RemoteException    {        if (ref == null) {            ref = activate(false);        }         return ref;    }     /**     * private method to activate the remote object.     *     * NOTE: the caller must be synchronized on "this" before     * calling this method.     */    private RemoteRef activate(boolean force)        throws RemoteException    {        assert Thread.holdsLock(this);         ref = null;        try {            /*             * Activate the object and retrieve the remote reference             * from inside the stub returned as the result. Then             * set this activatable ref's internal ref to be the             * ref inside the ref of the stub. In more clear terms,             * the stub returned from the activate call contains an             * ActivatableRef. We need to set the ref in *this*             * ActivatableRef to the ref inside the ActivatableRef             * retrieved from the stub. The ref type embedded in the             * ActivatableRef is typically a UnicastRef.             */             Remote proxy = id.activate(force);            ActivatableRef newRef = null;             if (proxy instanceof RemoteStub) {                newRef = (ActivatableRef) ((RemoteStub) proxy).getRef();            } else {                /*                 * Assume that proxy is an instance of a dynamic proxy                 * class.  If that assumption is not correct, or either of                 * the casts below fails, the resulting exception will be                 * wrapped in an ActivateFailedException below.                 */                RemoteObjectInvocationHandler handler =                    (RemoteObjectInvocationHandler)                    Proxy.getInvocationHandler(proxy);                newRef = (ActivatableRef) handler.getRef();            }            ref = newRef.ref;            return ref;         } catch (ConnectException e) {            throw new ConnectException("activation failed", e);        } catch (RemoteException e) {            throw new ConnectIOException("activation failed", e);        } catch (UnknownObjectException e) {            throw new NoSuchObjectException("object not registered");        } catch (ActivationException e) {            throw new ActivateFailedException("activation failed", e);        }    }     /**     * This call is used by the old 1.1 stub protocol and is     * unsupported since activation requires 1.2 stubs.     */    public synchronized RemoteCall newCall(RemoteObject obj,                                           Operation[] ops,                                           int opnum,                                           long hash)        throws RemoteException    {        throw new UnsupportedOperationException(versionComplaint);    }     /**     * This call is used by the old 1.1 stub protocol and is     * unsupported since activation requires 1.2 stubs.     */    public void invoke(RemoteCall call) throws Exception    {        throw new UnsupportedOperationException(versionComplaint);    }     /**     * This call is used by the old 1.1 stub protocol and is     * unsupported since activation requires 1.2 stubs.     */    public void done(RemoteCall call) throws RemoteException {        throw new UnsupportedOperationException(versionComplaint);    }     /**     * Returns the class of the ref type to be serialized     */    public String getRefClass(ObjectOutput out)    {        return "ActivatableRef";    }     /**     * Write out external representation for remote ref.     */    public void writeExternal(ObjectOutput out) throws IOException    {        RemoteRef localRef = ref;         out.writeObject(id);        if (localRef == null) {            out.writeUTF("");        } else {            out.writeUTF(localRef.getRefClass(out));            localRef.writeExternal(out);        }    }     /**     * Read in external representation for remote ref.     * @exception ClassNotFoundException If the class for an object     * being restored cannot be found.     */    public void readExternal(ObjectInput in)        throws IOException, ClassNotFoundException    {        id = (ActivationID)in.readObject();        ref = null;        String className = in.readUTF();         if (className.equals("")) return;         try {            Class refClass = Class.forName(RemoteRef.packagePrefix + "." +                                           className);            ref = (RemoteRef)refClass.newInstance();            ref.readExternal(in);        } catch (InstantiationException e) {            throw new UnmarshalException("Unable to create remote reference",                                         e);        } catch (IllegalAccessException e) {            throw new UnmarshalException("Illegal access creating remote reference");        }    }     //----------------------------------------------------------------------;    /**     * Method from object, forward from RemoteObject     */    public String remoteToString() {        return Util.getUnqualifiedName(getClass()) +                " [remoteRef: " + ref + "]";    }     /**     * default implementation of hashCode for remote objects     */    public int remoteHashCode() {        return id.hashCode();    }     /** default implementation of equals for remote objects     */    public boolean remoteEquals(RemoteRef ref) {        if (ref instanceof ActivatableRef)            return id.equals(((ActivatableRef)ref).id);        return false;    }}