Search in sources :

Example 1 with UnicastRef

use of sun.rmi.server.UnicastRef in project jdk8u_jdk by JetBrains.

the class LocateRegistry method getRegistry.

/**
     * Returns a locally created remote reference to the remote object
     * <code>Registry</code> on the specified <code>host</code> and
     * <code>port</code>.  Communication with this remote registry will
     * use the supplied <code>RMIClientSocketFactory</code> <code>csf</code>
     * to create <code>Socket</code> connections to the registry on the
     * remote <code>host</code> and <code>port</code>.
     *
     * @param host host for the remote registry
     * @param port port on which the registry accepts requests
     * @param csf  client-side <code>Socket</code> factory used to
     *      make connections to the registry.  If <code>csf</code>
     *      is null, then the default client-side <code>Socket</code>
     *      factory will be used in the registry stub.
     * @return reference (a stub) to the remote registry
     * @exception RemoteException if the reference could not be created
     * @since 1.2
     */
public static Registry getRegistry(String host, int port, RMIClientSocketFactory csf) throws RemoteException {
    Registry registry = null;
    if (port <= 0)
        port = Registry.REGISTRY_PORT;
    if (host == null || host.length() == 0) {
        // that the RegistryImpl's checkAccess will not fail.
        try {
            host = java.net.InetAddress.getLocalHost().getHostAddress();
        } catch (Exception e) {
            // If that failed, at least try "" (localhost) anyway...
            host = "";
        }
    }
    /*
         * Create a proxy for the registry with the given host, port, and
         * client socket factory.  If the supplied client socket factory is
         * null, then the ref type is a UnicastRef, otherwise the ref type
         * is a UnicastRef2.  If the property
         * java.rmi.server.ignoreStubClasses is true, then the proxy
         * returned is an instance of a dynamic proxy class that implements
         * the Registry interface; otherwise the proxy returned is an
         * instance of the pregenerated stub class for RegistryImpl.
         **/
    LiveRef liveRef = new LiveRef(new ObjID(ObjID.REGISTRY_ID), new TCPEndpoint(host, port, csf, null), false);
    RemoteRef ref = (csf == null) ? new UnicastRef(liveRef) : new UnicastRef2(liveRef);
    return (Registry) Util.createProxy(RegistryImpl.class, ref, false);
}
Also used : RegistryImpl(sun.rmi.registry.RegistryImpl) TCPEndpoint(sun.rmi.transport.tcp.TCPEndpoint) LiveRef(sun.rmi.transport.LiveRef) ObjID(java.rmi.server.ObjID) RemoteRef(java.rmi.server.RemoteRef) UnicastRef2(sun.rmi.server.UnicastRef2) UnicastRef(sun.rmi.server.UnicastRef) RemoteException(java.rmi.RemoteException)

Example 2 with UnicastRef

use of sun.rmi.server.UnicastRef in project jdk8u_jdk by JetBrains.

the class InterfaceHash method main.

public static void main(String[] args) throws Exception {
    System.err.println("\nRegression test for bug 4472769");
    System.err.println("\n=== verifying that J2SE registry's skeleton uses" + "\ncorrect interface hash and operation numbers:");
    Registry testImpl = LocateRegistry.createRegistry(PORT);
    System.err.println("created test registry on port " + PORT);
    RemoteRef ref = new UnicastRef(new LiveRef(new ObjID(ObjID.REGISTRY_ID), new TCPEndpoint("", PORT), false));
    Registry referenceStub = new ReferenceRegistryStub(ref);
    System.err.println("created reference registry stub: " + referenceStub);
    referenceStub.bind(NAME, referenceStub);
    System.err.println("bound name \"" + NAME + "\" in registry");
    String[] list = referenceStub.list();
    System.err.println("list of registry contents: " + Arrays.asList(list));
    if (list.length != 1 || !list[0].equals(NAME)) {
        throw new RuntimeException("TEST FAILED: unexpected list contents");
    }
    Registry result = (Registry) referenceStub.lookup(NAME);
    System.err.println("lookup of name \"" + NAME + "\" returned: " + result);
    if (!result.equals(referenceStub)) {
        throw new RuntimeException("TEST FAILED: unexpected lookup result");
    }
    referenceStub.rebind(NAME, referenceStub);
    referenceStub.unbind(NAME);
    System.err.println("unbound name \"" + NAME + "\"");
    list = referenceStub.list();
    System.err.println("list of registry contents: " + Arrays.asList(list));
    if (list.length != 0) {
        throw new RuntimeException("TEST FAILED: list not empty");
    }
    System.err.println("\n=== verifying that J2SE registry's stub uses" + "correct interface hash:");
    class FakeRemoteRef implements RemoteRef {

        long hash;

        int opnum;

        public RemoteCall newCall(RemoteObject obj, Operation[] op, int opnum, long hash) {
            this.hash = hash;
            this.opnum = opnum;
            throw new UnsupportedOperationException();
        }

        public void invoke(RemoteCall call) {
        }

        public void done(RemoteCall call) {
        }

        public Object invoke(Remote obj, Method method, Object[] args, long hash) {
            throw new UnsupportedOperationException();
        }

        public String getRefClass(java.io.ObjectOutput out) {
            return "FakeRemoteRef";
        }

        public int remoteHashCode() {
            return 1013;
        }

        public boolean remoteEquals(RemoteRef obj) {
            return false;
        }

        public String remoteToString() {
            return "FakeRemoteRef";
        }

        public void writeExternal(java.io.ObjectOutput out) {
        }

        public void readExternal(java.io.ObjectInput in) {
        }
    }
    FakeRemoteRef f = new FakeRemoteRef();
    Registry testRegistry = LocateRegistry.getRegistry(PORT);
    System.err.println("created original test registry stub: " + testRegistry);
    Class stubClass = testRegistry.getClass();
    System.err.println("test registry stub class: " + stubClass);
    Constructor cons = stubClass.getConstructor(new Class[] { RemoteRef.class });
    Registry testStub = (Registry) cons.newInstance(new Object[] { f });
    System.err.println("created new instrumented test registry stub: " + testStub);
    System.err.println("invoking bind:");
    try {
        testStub.bind(NAME, referenceStub);
    } catch (UnsupportedOperationException e) {
    }
    System.err.println("hash == " + f.hash + ", opnum == " + f.opnum);
    if (f.hash != 4905912898345647071L) {
        throw new RuntimeException("TEST FAILED: wrong interface hash");
    } else if (f.opnum != 0) {
        throw new RuntimeException("TEST FAILED: wrong operation number");
    }
    System.err.println("invoking list:");
    try {
        testStub.list();
    } catch (UnsupportedOperationException e) {
    }
    System.err.println("hash == " + f.hash + ", opnum == " + f.opnum);
    if (f.hash != 4905912898345647071L) {
        throw new RuntimeException("TEST FAILED: wrong interface hash");
    } else if (f.opnum != 1) {
        throw new RuntimeException("TEST FAILED: wrong operation number");
    }
    System.err.println("invoking lookup:");
    try {
        testStub.lookup(NAME);
    } catch (UnsupportedOperationException e) {
    }
    System.err.println("hash == " + f.hash + ", opnum == " + f.opnum);
    if (f.hash != 4905912898345647071L) {
        throw new RuntimeException("TEST FAILED: wrong interface hash");
    } else if (f.opnum != 2) {
        throw new RuntimeException("TEST FAILED: wrong operation number");
    }
    System.err.println("invoking rebind:");
    try {
        testStub.rebind(NAME, referenceStub);
    } catch (UnsupportedOperationException e) {
    }
    System.err.println("hash == " + f.hash + ", opnum == " + f.opnum);
    if (f.hash != 4905912898345647071L) {
        throw new RuntimeException("TEST FAILED: wrong interface hash");
    } else if (f.opnum != 3) {
        throw new RuntimeException("TEST FAILED: wrong operation number");
    }
    System.err.println("invoking unbind:");
    try {
        testStub.unbind(NAME);
    } catch (UnsupportedOperationException e) {
    }
    System.err.println("hash == " + f.hash + ", opnum == " + f.opnum);
    if (f.hash != 4905912898345647071L) {
        throw new RuntimeException("TEST FAILED: wrong interface hash");
    } else if (f.opnum != 4) {
        throw new RuntimeException("TEST FAILED: wrong operation number");
    }
    System.err.println("TEST PASSED");
}
Also used : Constructor(java.lang.reflect.Constructor) RemoteRef(java.rmi.server.RemoteRef) Remote(java.rmi.Remote) Registry(java.rmi.registry.Registry) LocateRegistry(java.rmi.registry.LocateRegistry) Method(java.lang.reflect.Method) TCPEndpoint(sun.rmi.transport.tcp.TCPEndpoint) LiveRef(sun.rmi.transport.LiveRef) RemoteObject(java.rmi.server.RemoteObject) ObjID(java.rmi.server.ObjID) RemoteObject(java.rmi.server.RemoteObject) UnicastRef(sun.rmi.server.UnicastRef) RemoteCall(java.rmi.server.RemoteCall)

Aggregations

ObjID (java.rmi.server.ObjID)2 RemoteRef (java.rmi.server.RemoteRef)2 UnicastRef (sun.rmi.server.UnicastRef)2 LiveRef (sun.rmi.transport.LiveRef)2 TCPEndpoint (sun.rmi.transport.tcp.TCPEndpoint)2 Constructor (java.lang.reflect.Constructor)1 Method (java.lang.reflect.Method)1 Remote (java.rmi.Remote)1 RemoteException (java.rmi.RemoteException)1 LocateRegistry (java.rmi.registry.LocateRegistry)1 Registry (java.rmi.registry.Registry)1 RemoteCall (java.rmi.server.RemoteCall)1 RemoteObject (java.rmi.server.RemoteObject)1 RegistryImpl (sun.rmi.registry.RegistryImpl)1 UnicastRef2 (sun.rmi.server.UnicastRef2)1