| /* |
| * Copyright (c) 2000, 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. |
| */ |
| |
| #include "Interceptors.idl" |
| |
| module PortableActivationIDL { |
| /** Possible values for endpointType argument on Server.getEndpoint() |
| * If you change the value of this constant then update |
| * core.EndPoint accordingly. It has a duplicate definition |
| * to avoid a compilation dependency. |
| */ |
| const string IIOP_CLEAR_TEXT = "IIOP_CLEAR_TEXT"; |
| |
| /** Raised if getEndpoint is called on a server callback object for |
| * an invalid endpoint type |
| */ |
| exception NoSuchEndPoint {} ; |
| |
| /** Raised if an attempt is made to retrieve ports corresponding to |
| * non-registered ORB |
| */ |
| exception InvalidORBid {} ; |
| |
| /** Raised if an operation is attempted against an invalid server ID. |
| */ |
| exception ServerNotRegistered { |
| PortableInterceptor::ServerId serverId ; |
| }; |
| |
| /** Raised if an operation is attempted for a server that is not running, |
| * and the server is required to be running for the operation. |
| */ |
| exception ServerNotActive { |
| PortableInterceptor::ServerId serverId ; |
| }; |
| |
| /** Raised if an operation is attempted against a server that is in a |
| * hold down state. A server becomes held down if it fails to activate |
| * within 10 seconds. |
| */ |
| exception ServerHeldDown { |
| PortableInterceptor::ServerId serverId ; |
| }; |
| |
| /** Raised if an attempt is made to activate a server that is already |
| * running. |
| */ |
| exception ServerAlreadyActive{ |
| PortableInterceptor::ServerId serverId ; |
| }; |
| |
| /** Raised if an attempt is made to register a serverdef with the |
| * same applicationName as an existing serverdef. |
| */ |
| exception ServerAlreadyRegistered { |
| PortableInterceptor::ServerId serverId; |
| }; |
| |
| /** Raised if an attempt is made to install a server that is currently |
| * installed. Note that a newly created server starts out in an uninstalled |
| * state. |
| */ |
| exception ServerAlreadyInstalled { |
| PortableInterceptor::ServerId serverId; |
| } ; |
| |
| /** Raised if an attempt is made to uninstall a server that is currently |
| * uninstalled. Note that a newly created server starts out in an |
| * uninstalled |
| * state. |
| */ |
| exception ServerAlreadyUninstalled { |
| PortableInterceptor::ServerId serverId; |
| } ; |
| |
| /** Raised if an attempt is made to register an invalid serverdef. |
| */ |
| exception BadServerDefinition { |
| string reason; |
| }; |
| |
| /** Raised if an attempt is made to register endpoints for the |
| * same ORB again |
| */ |
| exception ORBAlreadyRegistered { |
| PortableInterceptor::ORBId orbId; |
| }; |
| |
| /** Type of TCP port number, used in structures that describe |
| * transport endpoints. The valid range is actually 0-65535, but |
| * we use a long here to avoid signed/unsigned conversion headaches |
| * in Java. |
| */ |
| typedef long TCPPort ; |
| |
| /** Sequence of server Ids, used for queries about servers. |
| */ |
| typedef sequence<PortableInterceptor::ServerId> ServerIds; |
| |
| /** End point information for one particular kind of port associated with an |
| * an ORB. This is only used in the |
| * Activator interface, which must always run on the same host as the daemon, |
| * therefore we do not need the host name here. |
| */ |
| struct EndPointInfo { |
| string endpointType; |
| TCPPort port; |
| }; |
| |
| /** A list of endpoint information for a particular ORB. |
| */ |
| typedef sequence<EndPointInfo> EndpointInfoList; |
| |
| /** struct contain ORB and port info for a particular type of endpoint. |
| * This is only used in the |
| * Activator interface, which must always run on the same host as the daemon, |
| * therefore we do not need the host name here. |
| */ |
| struct ORBPortInfo { |
| PortableInterceptor::ORBId orbId; |
| TCPPort port; |
| }; |
| |
| /** A list of ORB and port information for a particular endpoint type. |
| */ |
| typedef sequence<ORBPortInfo> ORBPortInfoList; |
| |
| /** A list of ORB IDs. |
| */ |
| typedef sequence<PortableInterceptor::ORBId> ORBidList; |
| |
| /** Server callback interface, passed to Activator in registerServer method. |
| */ |
| interface ServerProxy { |
| /** Shutdown this server. Returns after orb.shutdown() completes. |
| */ |
| void shutdown(); |
| |
| /** Install the server. Returns after the install hook completes |
| * execution in the server. |
| */ |
| void install(); |
| |
| /** Uninstall the server. Returns after the uninstall hook |
| * completes execution. |
| */ |
| void uninstall(); |
| }; |
| |
| /** ORB callback interface, passed to Activator in registerORB method. |
| */ |
| interface ORBProxy { |
| /** Method used to cause ORB to activate the named adapter, if possible. |
| * This will cause the named POA to register itself with the activator as |
| * a side effect. This should always happen before this call can complete. |
| * This method returns true if adapter activation succeeded, otherwise it |
| * returns false. |
| */ |
| boolean activate_adapter( in PortableInterceptor::AdapterName name ) ; |
| } ; |
| |
| interface Activator { |
| /******************************************************* |
| * Server State Change Methods |
| ********************************************************/ |
| |
| /** A new ORB started server registers itself with the Activator |
| */ |
| void registerServer(in PortableInterceptor::ServerId serverId, in ServerProxy serverObj) |
| raises (ServerNotRegistered); |
| |
| /** A server is shutting down that was started by this activator. |
| * Complete termination of the server is detected by the death of the |
| * process implementing the server. |
| */ |
| void serverGoingDown( in PortableInterceptor::ServerId serverId ) ; |
| |
| /** Called whenever an ORB instance is created. This registers |
| * the transport endpoints and the ORB proxy callback object. |
| * Note that we cannot detect when an ORB shuts down, although |
| * all of the POA shutdowns should still be reported. |
| */ |
| void registerORB( in PortableInterceptor::ServerId serverId, in PortableInterceptor::ORBId orbId, |
| in ORBProxy orb, in EndpointInfoList endPointInfo) |
| raises (ServerNotRegistered,NoSuchEndPoint, ORBAlreadyRegistered) ; |
| |
| /** Construct or find an ORBD object template corresponding to the |
| * server's object template and return it. Called whenever a |
| * persistent POA is created. |
| */ |
| PortableInterceptor::ObjectReferenceTemplate registerPOA( |
| in PortableInterceptor::ServerId serverId, in PortableInterceptor::ORBId orbId, |
| in PortableInterceptor::ObjectReferenceTemplate poaTemplate ) ; |
| |
| /** Called whenever a POA is destroyed. |
| */ |
| void poaDestroyed( |
| in PortableInterceptor::ServerId serverId, in PortableInterceptor::ORBId orbId, |
| in PortableInterceptor::ObjectReferenceTemplate poaTemplate ) ; |
| |
| /******************************************************* |
| * Server Control Methods |
| ********************************************************/ |
| |
| /** If the server is not running, start it up. This is allowed |
| * whether or not the server has been installed. |
| */ |
| void activate(in PortableInterceptor::ServerId serverId) |
| raises (ServerAlreadyActive, ServerNotRegistered, ServerHeldDown); |
| |
| /** If the server is running, shut it down |
| */ |
| void shutdown(in PortableInterceptor::ServerId serverId) |
| raises (ServerNotActive, ServerNotRegistered); |
| |
| /** Invoke the server install hook. If the server is not |
| * currently running, this method will activate it. |
| */ |
| void install(in PortableInterceptor::ServerId serverId) |
| raises (ServerNotRegistered, ServerHeldDown, |
| ServerAlreadyInstalled); |
| |
| /** Invoke the server uninstall hook. If the server is not |
| * currently running, this method will activate it. |
| * After this hook completes, the server may still be running. |
| */ |
| void uninstall(in PortableInterceptor::ServerId serverId) |
| raises (ServerNotRegistered, ServerHeldDown, |
| ServerAlreadyUninstalled); |
| |
| /******************************************************* |
| * Accessors |
| ********************************************************/ |
| |
| /** list active servers |
| */ |
| ServerIds getActiveServers(); |
| |
| /** list all registered ORBs for a server |
| */ |
| ORBidList getORBNames(in PortableInterceptor::ServerId serverId) |
| raises (ServerNotRegistered); |
| |
| /** Find the server template that corresponds to the ORBD's |
| * adapter id. |
| */ |
| PortableInterceptor::ObjectReferenceTemplate lookupPOATemplate( |
| in PortableInterceptor::ServerId serverId, in PortableInterceptor::ORBId orbId, |
| in PortableInterceptor::AdapterName orbAdapterName ) ; |
| }; |
| |
| interface Locator { |
| /** struct to return the list of endpoints for a server for a specific |
| * endpoint type. |
| */ |
| struct ServerLocationPerType { |
| string hostname; |
| ORBPortInfoList ports; |
| }; |
| |
| /** struct to return the list of endpoints for a server for a specific |
| * ORB |
| */ |
| struct ServerLocationPerORB { |
| string hostname; |
| EndpointInfoList ports; |
| }; |
| |
| /** locate server - returns the port with a specific type for all registered |
| * ORBs of an active server. |
| * Starts the server if it is not already running. |
| */ |
| ServerLocationPerType locateServer( |
| in PortableInterceptor::ServerId serverId, |
| in string endPoint) |
| raises(NoSuchEndPoint, ServerNotRegistered, ServerHeldDown); |
| |
| /** locate server - returns all ports registered with a specified ORB for |
| * an active server |
| * Starts the server if it is not already running. |
| */ |
| ServerLocationPerORB locateServerForORB( |
| in PortableInterceptor::ServerId serverId, |
| in PortableInterceptor::ORBId orbId) |
| raises(InvalidORBid, ServerNotRegistered, ServerHeldDown); |
| |
| /** get the port for the endpoint of the locator |
| */ |
| TCPPort getEndpoint(in string endPointType) |
| raises(NoSuchEndPoint); |
| |
| /** Useful from external BadServerIdHandlers which need |
| * to pick a particular port type. |
| */ |
| TCPPort getServerPortForType( |
| in ServerLocationPerORB location, |
| in string endPointType) |
| raises(NoSuchEndPoint); |
| }; |
| |
| /** Interface used to combine the Activator and Locator when both are |
| * implemented together in the same process, as is currently the case |
| * for our implementation. |
| */ |
| interface ServerManager : Activator, Locator { }; |
| |
| /** Interface used to support binding references in the bootstrap name |
| * service. |
| */ |
| interface InitialNameService { |
| exception NameAlreadyBound {}; |
| |
| /** bind initial name |
| */ |
| void bind ( |
| in string name, |
| in Object obj, |
| in boolean isPersistant) raises (NameAlreadyBound); |
| }; |
| |
| interface Repository { |
| /** server program definition. |
| */ |
| struct ServerDef { |
| string applicationName; // alias used for servers with identical |
| // serverName values. |
| string serverName; // Class name of server's main class. |
| string serverClassPath; // class path used to run the server. |
| string serverArgs; // arguments passed to the server |
| string serverVmArgs; // arguments passed to the server's Java VM1 |
| boolean isInstalled; // Whether or not the server has been installed |
| }; |
| |
| /** register server definition. |
| * This returns the serverId of the server. A newly created server is |
| * always uninstalled. |
| */ |
| PortableInterceptor::ServerId registerServer (in ServerDef serverDef) |
| raises (ServerAlreadyRegistered, BadServerDefinition); |
| |
| /** unregister server definition |
| */ |
| void unregisterServer (in PortableInterceptor::ServerId serverId) |
| raises (ServerNotRegistered); |
| |
| /** get server definition |
| */ |
| ServerDef getServer(in PortableInterceptor::ServerId serverId) |
| raises (ServerNotRegistered); |
| |
| /** Return whether the server has been installed |
| */ |
| boolean isInstalled( in PortableInterceptor::ServerId serverId ) |
| raises (ServerNotRegistered); |
| |
| /** Mark the server as being installed. Raises ServerAlreadyInstalled |
| * if the server is currently marked as installed. |
| */ |
| void install( in PortableInterceptor::ServerId serverId ) |
| raises (ServerNotRegistered, ServerAlreadyInstalled) ; |
| |
| /** Mark the server as being uninstalled. Raises ServerAlreadyUninstalled |
| * if the server is currently marked as uninstalled. |
| */ |
| void uninstall( in PortableInterceptor::ServerId serverId ) |
| raises (ServerNotRegistered, ServerAlreadyUninstalled) ; |
| |
| /** list registered servers |
| */ |
| ServerIds listRegisteredServers (); |
| |
| /** Type used for a list of application names |
| */ |
| typedef sequence<string> AppNames ; |
| |
| /** Returns list of ALL applicationNames defined in ServerDefs of registered |
| * servers. |
| */ |
| AppNames getApplicationNames(); |
| |
| /** Find the ServerID associated with the given application name. |
| */ |
| PortableInterceptor::ServerId getServerID( in string applicationName ) |
| raises (ServerNotRegistered) ; |
| }; |
| }; |