feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/java/rmi/registry/LocateRegistry.java

@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) 1996, 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 java.rmi.registry;
+
+import java.rmi.RemoteException;
+import java.rmi.server.ObjID;
+import java.rmi.server.RMIClientSocketFactory;
+import java.rmi.server.RMIServerSocketFactory;
+import java.rmi.server.RemoteRef;
+import java.rmi.server.UnicastRemoteObject;
+import sun.rmi.registry.RegistryImpl;
+import sun.rmi.server.UnicastRef2;
+import sun.rmi.server.UnicastRef;
+import sun.rmi.server.Util;
+import sun.rmi.transport.LiveRef;
+import sun.rmi.transport.tcp.TCPEndpoint;
+
+/**
+ * <code>LocateRegistry</code> is used to obtain a reference to a bootstrap
+ * remote object registry on a particular host (including the local host), or
+ * to create a remote object registry that accepts calls on a specific port.
+ *
+ * <p> Note that a <code>getRegistry</code> call does not actually make a
+ * connection to the remote host.  It simply creates a local reference to
+ * the remote registry and will succeed even if no registry is running on
+ * the remote host.  Therefore, a subsequent method invocation to a remote
+ * registry returned as a result of this method may fail.
+ *
+ * @author  Ann Wollrath
+ * @author  Peter Jones
+ * @since   JDK1.1
+ * @see     java.rmi.registry.Registry
+ */
+public final class LocateRegistry {
+
+    /**
+     * Private constructor to disable public construction.
+     */
+    private LocateRegistry() {}
+
+    /**
+     * Returns a reference to the the remote object <code>Registry</code> for
+     * the local host on the default registry port of 1099.
+     *
+     * @return reference (a stub) to the remote object registry
+     * @exception RemoteException if the reference could not be created
+     * @since JDK1.1
+     */
+    public static Registry getRegistry()
+        throws RemoteException
+    {
+        return getRegistry(null, Registry.REGISTRY_PORT);
+    }
+
+    /**
+     * Returns a reference to the the remote object <code>Registry</code> for
+     * the local host on the specified <code>port</code>.
+     *
+     * @param port port on which the registry accepts requests
+     * @return reference (a stub) to the remote object registry
+     * @exception RemoteException if the reference could not be created
+     * @since JDK1.1
+     */
+    public static Registry getRegistry(int port)
+        throws RemoteException
+    {
+        return getRegistry(null, port);
+    }
+
+    /**
+     * Returns a reference to the remote object <code>Registry</code> on the
+     * specified <code>host</code> on the default registry port of 1099.  If
+     * <code>host</code> is <code>null</code>, the local host is used.
+     *
+     * @param host host for the remote registry
+     * @return reference (a stub) to the remote object registry
+     * @exception RemoteException if the reference could not be created
+     * @since JDK1.1
+     */
+    public static Registry getRegistry(String host)
+        throws RemoteException
+    {
+        return getRegistry(host, Registry.REGISTRY_PORT);
+    }
+
+    /**
+     * Returns a reference to the remote object <code>Registry</code> on the
+     * specified <code>host</code> and <code>port</code>. If <code>host</code>
+     * is <code>null</code>, the local host is used.
+     *
+     * @param host host for the remote registry
+     * @param port port on which the registry accepts requests
+     * @return reference (a stub) to the remote object registry
+     * @exception RemoteException if the reference could not be created
+     * @since JDK1.1
+     */
+    public static Registry getRegistry(String host, int port)
+        throws RemoteException
+    {
+        return getRegistry(host, port, null);
+    }
+
+    /**
+     * 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) {
+            // If host is blank (as returned by "file:" URL in 1.0.2 used in
+            // java.rmi.Naming), try to convert to real local host name so
+            // 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);
+    }
+
+    /**
+     * Creates and exports a <code>Registry</code> instance on the local
+     * host that accepts requests on the specified <code>port</code>.
+     *
+     * <p>The <code>Registry</code> instance is exported as if the static
+     * {@link UnicastRemoteObject#exportObject(Remote,int)
+     * UnicastRemoteObject.exportObject} method is invoked, passing the
+     * <code>Registry</code> instance and the specified <code>port</code> as
+     * arguments, except that the <code>Registry</code> instance is
+     * exported with a well-known object identifier, an {@link ObjID}
+     * instance constructed with the value {@link ObjID#REGISTRY_ID}.
+     *
+     * @param port the port on which the registry accepts requests
+     * @return the registry
+     * @exception RemoteException if the registry could not be exported
+     * @since JDK1.1
+     **/
+    public static Registry createRegistry(int port) throws RemoteException {
+        return new RegistryImpl(port);
+    }
+
+    /**
+     * Creates and exports a <code>Registry</code> instance on the local
+     * host that uses custom socket factories for communication with that
+     * instance.  The registry that is created listens for incoming
+     * requests on the given <code>port</code> using a
+     * <code>ServerSocket</code> created from the supplied
+     * <code>RMIServerSocketFactory</code>.
+     *
+     * <p>The <code>Registry</code> instance is exported as if
+     * the static {@link
+     * UnicastRemoteObject#exportObject(Remote,int,RMIClientSocketFactory,RMIServerSocketFactory)
+     * UnicastRemoteObject.exportObject} method is invoked, passing the
+     * <code>Registry</code> instance, the specified <code>port</code>, the
+     * specified <code>RMIClientSocketFactory</code>, and the specified
+     * <code>RMIServerSocketFactory</code> as arguments, except that the
+     * <code>Registry</code> instance is exported with a well-known object
+     * identifier, an {@link ObjID} instance constructed with the value
+     * {@link ObjID#REGISTRY_ID}.
+     *
+     * @param port port on which the registry accepts requests
+     * @param csf  client-side <code>Socket</code> factory used to
+     *      make connections to the registry
+     * @param ssf  server-side <code>ServerSocket</code> factory
+     *      used to accept connections to the registry
+     * @return the registry
+     * @exception RemoteException if the registry could not be exported
+     * @since 1.2
+     **/
+    public static Registry createRegistry(int port,
+                                          RMIClientSocketFactory csf,
+                                          RMIServerSocketFactory ssf)
+        throws RemoteException
+    {
+        return new RegistryImpl(port, csf, ssf);
+    }
+}

jdkSrc/jdk8/java/rmi/registry/Registry.java

@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 1996, 2001, 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 java.rmi.registry;
+
+import java.rmi.AccessException;
+import java.rmi.AlreadyBoundException;
+import java.rmi.NotBoundException;
+import java.rmi.Remote;
+import java.rmi.RemoteException;
+
+/**
+ * <code>Registry</code> is a remote interface to a simple remote
+ * object registry that provides methods for storing and retrieving
+ * remote object references bound with arbitrary string names.  The
+ * <code>bind</code>, <code>unbind</code>, and <code>rebind</code>
+ * methods are used to alter the name bindings in the registry, and
+ * the <code>lookup</code> and <code>list</code> methods are used to
+ * query the current name bindings.
+ *
+ * <p>In its typical usage, a <code>Registry</code> enables RMI client
+ * bootstrapping: it provides a simple means for a client to obtain an
+ * initial reference to a remote object.  Therefore, a registry's
+ * remote object implementation is typically exported with a
+ * well-known address, such as with a well-known {@link
+ * java.rmi.server.ObjID#REGISTRY_ID ObjID} and TCP port number
+ * (default is {@link #REGISTRY_PORT 1099}).
+ *
+ * <p>The {@link LocateRegistry} class provides a programmatic API for
+ * constructing a bootstrap reference to a <code>Registry</code> at a
+ * remote address (see the static <code>getRegistry</code> methods)
+ * and for creating and exporting a <code>Registry</code> in the
+ * current VM on a particular local address (see the static
+ * <code>createRegistry</code> methods).
+ *
+ * <p>A <code>Registry</code> implementation may choose to restrict
+ * access to some or all of its methods (for example, methods that
+ * mutate the registry's bindings may be restricted to calls
+ * originating from the local host).  If a <code>Registry</code>
+ * method chooses to deny access for a given invocation, its
+ * implementation may throw {@link java.rmi.AccessException}, which
+ * (because it extends {@link java.rmi.RemoteException}) will be
+ * wrapped in a {@link java.rmi.ServerException} when caught by a
+ * remote client.
+ *
+ * <p>The names used for bindings in a <code>Registry</code> are pure
+ * strings, not parsed.  A service which stores its remote reference
+ * in a <code>Registry</code> may wish to use a package name as a
+ * prefix in the name binding to reduce the likelihood of name
+ * collisions in the registry.
+ *
+ * @author      Ann Wollrath
+ * @author      Peter Jones
+ * @since       JDK1.1
+ * @see         LocateRegistry
+ */
+public interface Registry extends Remote {
+
+    /** Well known port for registry. */
+    public static final int REGISTRY_PORT = 1099;
+
+    /**
+     * Returns the remote reference bound to the specified
+     * <code>name</code> in this registry.
+     *
+     * @param   name the name for the remote reference to look up
+     *
+     * @return  a reference to a remote object
+     *
+     * @throws  NotBoundException if <code>name</code> is not currently bound
+     *
+     * @throws  RemoteException if remote communication with the
+     * registry failed; if exception is a <code>ServerException</code>
+     * containing an <code>AccessException</code>, then the registry
+     * denies the caller access to perform this operation
+     *
+     * @throws  AccessException if this registry is local and it denies
+     * the caller access to perform this operation
+     *
+     * @throws  NullPointerException if <code>name</code> is <code>null</code>
+     */
+    public Remote lookup(String name)
+        throws RemoteException, NotBoundException, AccessException;
+
+    /**
+     * Binds a remote reference to the specified <code>name</code> in
+     * this registry.
+     *
+     * @param   name the name to associate with the remote reference
+     * @param   obj a reference to a remote object (usually a stub)
+     *
+     * @throws  AlreadyBoundException if <code>name</code> is already bound
+     *
+     * @throws  RemoteException if remote communication with the
+     * registry failed; if exception is a <code>ServerException</code>
+     * containing an <code>AccessException</code>, then the registry
+     * denies the caller access to perform this operation (if
+     * originating from a non-local host, for example)
+     *
+     * @throws  AccessException if this registry is local and it denies
+     * the caller access to perform this operation
+     *
+     * @throws  NullPointerException if <code>name</code> is
+     * <code>null</code>, or if <code>obj</code> is <code>null</code>
+     */
+    public void bind(String name, Remote obj)
+        throws RemoteException, AlreadyBoundException, AccessException;
+
+    /**
+     * Removes the binding for the specified <code>name</code> in
+     * this registry.
+     *
+     * @param   name the name of the binding to remove
+     *
+     * @throws  NotBoundException if <code>name</code> is not currently bound
+     *
+     * @throws  RemoteException if remote communication with the
+     * registry failed; if exception is a <code>ServerException</code>
+     * containing an <code>AccessException</code>, then the registry
+     * denies the caller access to perform this operation (if
+     * originating from a non-local host, for example)
+     *
+     * @throws  AccessException if this registry is local and it denies
+     * the caller access to perform this operation
+     *
+     * @throws  NullPointerException if <code>name</code> is <code>null</code>
+     */
+    public void unbind(String name)
+        throws RemoteException, NotBoundException, AccessException;
+
+    /**
+     * Replaces the binding for the specified <code>name</code> in
+     * this registry with the supplied remote reference.  If there is
+     * an existing binding for the specified <code>name</code>, it is
+     * discarded.
+     *
+     * @param   name the name to associate with the remote reference
+     * @param   obj a reference to a remote object (usually a stub)
+     *
+     * @throws  RemoteException if remote communication with the
+     * registry failed; if exception is a <code>ServerException</code>
+     * containing an <code>AccessException</code>, then the registry
+     * denies the caller access to perform this operation (if
+     * originating from a non-local host, for example)
+     *
+     * @throws  AccessException if this registry is local and it denies
+     * the caller access to perform this operation
+     *
+     * @throws  NullPointerException if <code>name</code> is
+     * <code>null</code>, or if <code>obj</code> is <code>null</code>
+     */
+    public void rebind(String name, Remote obj)
+        throws RemoteException, AccessException;
+
+    /**
+     * Returns an array of the names bound in this registry.  The
+     * array will contain a snapshot of the names bound in this
+     * registry at the time of the given invocation of this method.
+     *
+     * @return  an array of the names bound in this registry
+     *
+     * @throws  RemoteException if remote communication with the
+     * registry failed; if exception is a <code>ServerException</code>
+     * containing an <code>AccessException</code>, then the registry
+     * denies the caller access to perform this operation
+     *
+     * @throws  AccessException if this registry is local and it denies
+     * the caller access to perform this operation
+     */
+    public String[] list() throws RemoteException, AccessException;
+}

jdkSrc/jdk8/java/rmi/registry/RegistryHandler.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 1997, 2004, 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 java.rmi.registry;
+
+import java.rmi.RemoteException;
+import java.rmi.UnknownHostException;
+
+/**
+ * <code>RegistryHandler</code> is an interface used internally by the RMI
+ * runtime in previous implementation versions.  It should never be accessed
+ * by application code.
+ *
+ * @author  Ann Wollrath
+ * @since   JDK1.1
+ * @deprecated no replacement
+ */
+@Deprecated
+public interface RegistryHandler {
+
+    /**
+     * Returns a "stub" for contacting a remote registry
+     * on the specified host and port.
+     *
+     * @deprecated no replacement.  As of the Java 2 platform v1.2, RMI no
+     * longer uses the <code>RegistryHandler</code> to obtain the registry's
+     * stub.
+     * @param host name of remote registry host
+     * @param port remote registry port
+     * @return remote registry stub
+     * @throws RemoteException if a remote error occurs
+     * @throws UnknownHostException if unable to resolve given hostname
+     */
+    @Deprecated
+    Registry registryStub(String host, int port)
+        throws RemoteException, UnknownHostException;
+
+    /**
+     * Constructs and exports a Registry on the specified port.
+     * The port must be non-zero.
+     *
+     * @deprecated no replacement.  As of the Java 2 platform v1.2, RMI no
+     * longer uses the <code>RegistryHandler</code> to obtain the registry's
+     * implementation.
+     * @param port port to export registry on
+     * @return registry stub
+     * @throws RemoteException if a remote error occurs
+     */
+    @Deprecated
+    Registry registryImpl(int port) throws RemoteException;
+}