| /* |
| * 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 com.sun.corba.se.impl.activation; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.ObjectInputStream; |
| import java.io.ObjectOutputStream; |
| import java.io.Serializable; |
| import java.util.Properties; |
| import java.util.Hashtable; |
| import java.util.Enumeration; |
| import java.util.Vector; |
| |
| import org.omg.CORBA.CompletionStatus; |
| import org.omg.CORBA.INITIALIZE; |
| import org.omg.CORBA.INTERNAL; |
| import org.omg.CORBA.SystemException; |
| |
| import com.sun.corba.se.spi.activation.BadServerDefinition; |
| import com.sun.corba.se.spi.activation.RepositoryPackage.ServerDef; |
| import com.sun.corba.se.spi.activation._RepositoryImplBase; |
| import com.sun.corba.se.spi.activation.ServerAlreadyRegistered; |
| import com.sun.corba.se.spi.activation.ServerAlreadyInstalled; |
| import com.sun.corba.se.spi.activation.ServerAlreadyUninstalled; |
| import com.sun.corba.se.spi.activation.ServerNotRegistered; |
| import com.sun.corba.se.spi.legacy.connection.LegacyServerSocketEndPointInfo; |
| import com.sun.corba.se.spi.transport.SocketOrChannelAcceptor; |
| import com.sun.corba.se.spi.orb.ORB; |
| import com.sun.corba.se.impl.orbutil.ORBConstants; |
| |
| import com.sun.corba.se.spi.logging.CORBALogDomains; |
| import com.sun.corba.se.impl.logging.ActivationSystemException; |
| |
| /** |
| * |
| * @author Rohit Garg |
| * @since JDK1.2 |
| */ |
| public class RepositoryImpl extends _RepositoryImplBase |
| implements Serializable |
| { |
| |
| // added serialver computed by the tool |
| private static final long serialVersionUID = 8458417785209341858L; |
| |
| RepositoryImpl(ORB orb, File dbDir, boolean debug) |
| { |
| this.debug = debug ; |
| this.orb = orb; |
| wrapper = ActivationSystemException.get( orb, CORBALogDomains.ORBD_REPOSITORY ) ; |
| |
| // if databse does not exist, create it otherwise read it in |
| File dbFile = new File(dbDir, "servers.db"); |
| if (!dbFile.exists()) { |
| db = new RepositoryDB(dbFile); |
| db.flush(); |
| } else { |
| try { |
| FileInputStream fis = new FileInputStream(dbFile); |
| ObjectInputStream ois = new ObjectInputStream(fis); |
| db = (RepositoryDB) ois.readObject(); |
| ois.close(); |
| } catch (Exception e) { |
| throw wrapper.cannotReadRepositoryDb( e ) ; |
| } |
| } |
| |
| // export the repository |
| orb.connect(this); |
| } |
| |
| private String printServerDef( ServerDef sd ) |
| { |
| return "ServerDef[applicationName=" + sd.applicationName + |
| " serverName=" + sd.serverName + |
| " serverClassPath=" + sd.serverClassPath + |
| " serverArgs=" + sd. serverArgs + |
| " serverVmArgs=" + sd.serverVmArgs + |
| "]" ; |
| } |
| |
| public int registerServer(ServerDef serverDef, int theServerId) |
| throws ServerAlreadyRegistered |
| { |
| int serverId; |
| DBServerDef server = null; |
| |
| synchronized (db) { |
| |
| // check if server already registered |
| Enumeration enumeration = db.serverTable.elements(); |
| while (enumeration.hasMoreElements()) { |
| server = (DBServerDef) enumeration.nextElement(); |
| if (serverDef.applicationName.equals(server.applicationName)) { |
| if (debug) |
| System.out.println( |
| "RepositoryImpl: registerServer called " + |
| "to register ServerDef " + |
| printServerDef( serverDef ) + |
| " with " + ((theServerId==illegalServerId) ? |
| "a new server Id" : ("server Id " + theServerId)) + |
| " FAILED because it is already registered." ) ; |
| |
| throw (new ServerAlreadyRegistered(server.id)); |
| } |
| } |
| |
| // generate a new server id |
| if (theServerId == illegalServerId) |
| serverId = db.incrementServerIdCounter(); |
| else |
| serverId = theServerId; |
| |
| // add server def to the database |
| server = new DBServerDef(serverDef, serverId); |
| db.serverTable.put(new Integer(serverId), server); |
| db.flush(); |
| |
| if (debug) |
| if (theServerId==illegalServerId) |
| System.out.println( "RepositoryImpl: registerServer called " + |
| "to register ServerDef " + printServerDef( serverDef ) + |
| " with new serverId " + serverId ) ; |
| else |
| System.out.println( "RepositoryImpl: registerServer called " + |
| "to register ServerDef " + printServerDef( serverDef ) + |
| " with assigned serverId " + serverId ) ; |
| |
| return serverId; |
| } |
| } |
| |
| public int registerServer(ServerDef serverDef) |
| throws ServerAlreadyRegistered, BadServerDefinition |
| { |
| // verify that the entry is valid |
| LegacyServerSocketEndPointInfo endpoint = |
| orb.getLegacyServerSocketManager() |
| .legacyGetEndpoint(LegacyServerSocketEndPointInfo.BOOT_NAMING); |
| int initSvcPort = ((SocketOrChannelAcceptor)endpoint) |
| .getServerSocket().getLocalPort(); |
| ServerTableEntry entry = new ServerTableEntry( wrapper, |
| illegalServerId, serverDef, (int) initSvcPort, "", true, debug ); |
| |
| switch (entry.verify()) { |
| case ServerMain.OK: |
| break; |
| case ServerMain.MAIN_CLASS_NOT_FOUND: |
| throw new BadServerDefinition("main class not found."); |
| case ServerMain.NO_MAIN_METHOD: |
| throw new BadServerDefinition("no main method found."); |
| case ServerMain.APPLICATION_ERROR: |
| throw new BadServerDefinition("server application error."); |
| default: |
| throw new BadServerDefinition("unknown Exception."); |
| } |
| |
| return registerServer(serverDef, illegalServerId); |
| } |
| |
| public void unregisterServer(int serverId) throws ServerNotRegistered { |
| |
| DBServerDef server = null; |
| Integer id = new Integer(serverId); |
| |
| synchronized (db) { |
| |
| // check to see if the server is registered |
| server = (DBServerDef) db.serverTable.get(id); |
| if (server == null) { |
| if (debug) |
| System.out.println( |
| "RepositoryImpl: unregisterServer for serverId " + |
| serverId + " called: server not registered" ) ; |
| |
| throw (new ServerNotRegistered()); |
| } |
| |
| // remove server from the database |
| db.serverTable.remove(id); |
| db.flush(); |
| } |
| |
| if (debug) |
| System.out.println( |
| "RepositoryImpl: unregisterServer for serverId " + serverId + |
| " called" ) ; |
| } |
| |
| private DBServerDef getDBServerDef(int serverId) throws ServerNotRegistered |
| { |
| Integer id = new Integer(serverId); |
| DBServerDef server = (DBServerDef) db.serverTable.get(id); |
| |
| if (server == null) |
| throw new ServerNotRegistered( serverId ); |
| |
| return server ; |
| } |
| |
| public ServerDef getServer(int serverId) throws ServerNotRegistered |
| { |
| DBServerDef server = getDBServerDef( serverId ) ; |
| |
| ServerDef serverDef = new ServerDef(server.applicationName, server.name, |
| server.classPath, server.args, server.vmArgs); |
| |
| if (debug) |
| System.out.println( |
| "RepositoryImpl: getServer for serverId " + serverId + |
| " returns " + printServerDef( serverDef ) ) ; |
| |
| return serverDef; |
| } |
| |
| public boolean isInstalled(int serverId) throws ServerNotRegistered { |
| DBServerDef server = getDBServerDef( serverId ) ; |
| return server.isInstalled ; |
| } |
| |
| public void install( int serverId ) |
| throws ServerNotRegistered, ServerAlreadyInstalled |
| { |
| DBServerDef server = getDBServerDef( serverId ) ; |
| |
| if (server.isInstalled) |
| throw new ServerAlreadyInstalled( serverId ) ; |
| else { |
| server.isInstalled = true ; |
| db.flush() ; |
| } |
| } |
| |
| public void uninstall( int serverId ) |
| throws ServerNotRegistered, ServerAlreadyUninstalled |
| { |
| DBServerDef server = getDBServerDef( serverId ) ; |
| |
| if (!server.isInstalled) |
| throw new ServerAlreadyUninstalled( serverId ) ; |
| else { |
| server.isInstalled = false ; |
| db.flush() ; |
| } |
| } |
| |
| public int[] listRegisteredServers() { |
| synchronized (db) { |
| int i=0; |
| |
| int servers[] = new int[db.serverTable.size()]; |
| |
| Enumeration enumeration = db.serverTable.elements(); |
| |
| while (enumeration.hasMoreElements()) { |
| DBServerDef server = (DBServerDef) enumeration.nextElement(); |
| servers[i++] = server.id; |
| } |
| |
| if (debug) { |
| StringBuffer sb = new StringBuffer() ; |
| for (int ctr=0; ctr<servers.length; ctr++) { |
| sb.append( ' ' ) ; |
| sb.append( servers[ctr] ) ; |
| } |
| |
| System.out.println( |
| "RepositoryImpl: listRegisteredServers returns" + |
| sb.toString() ) ; |
| } |
| |
| return servers; |
| } |
| } |
| |
| public int getServerID(String applicationName) throws ServerNotRegistered { |
| synchronized (db) { |
| int result = -1 ; |
| |
| for (Enumeration serverIds = db.serverTable.keys(); |
| serverIds.hasMoreElements();) |
| { |
| Integer nextServerId = (Integer) serverIds.nextElement(); |
| DBServerDef dbServerDef = |
| (DBServerDef) db.serverTable.get(nextServerId); |
| |
| if (dbServerDef.applicationName.equals(applicationName)) { |
| result = nextServerId.intValue(); |
| break ; |
| } |
| } |
| |
| if (debug) |
| System.out.println("RepositoryImpl: getServerID for " + |
| applicationName + " is " + result ) ; |
| |
| if (result == -1) { |
| throw (new ServerNotRegistered()); |
| } else { |
| return result ; |
| } |
| } |
| } |
| |
| public String[] getApplicationNames() { |
| synchronized (db) { |
| Vector v = new Vector(); |
| for (Enumeration serverIds = db.serverTable.keys(); |
| serverIds.hasMoreElements();) |
| { |
| Integer nextServerId = (Integer) serverIds.nextElement(); |
| |
| DBServerDef dbServerDef = (DBServerDef)db.serverTable.get( |
| nextServerId); |
| |
| if (!dbServerDef.applicationName.equals("")) |
| v.addElement( dbServerDef.applicationName ) ; |
| } |
| |
| String[] apps = new String[v.size()]; |
| for (int i = 0; i < v.size(); i++) { |
| apps[i] = (String)v.elementAt(i); |
| } |
| |
| if (debug) { |
| StringBuffer sb = new StringBuffer() ; |
| for (int ctr=0; ctr<apps.length; ctr++) { |
| sb.append( ' ' ) ; |
| sb.append( apps[ctr] ) ; |
| } |
| |
| System.out.println( "RepositoryImpl: getApplicationNames returns " + |
| sb.toString() ) ; |
| } |
| |
| return apps; |
| } |
| } |
| /** |
| * Typically the Repositoy is created within the ORBd VM but it can |
| * be independently started as well. |
| */ |
| public static void main(String args[]) { |
| boolean debug = false ; |
| for (int ctr=0; ctr<args.length; ctr++) |
| if (args[ctr].equals("-debug")) |
| debug = true ; |
| |
| try { |
| // See Bug 4396928 for more information about why we are |
| // initializing the ORBClass to PIORB (now ORBImpl, but see the bug). |
| Properties props = new Properties(); |
| props.put("org.omg.CORBA.ORBClass", |
| "com.sun.corba.se.impl.orb.ORBImpl"); |
| ORB orb = (ORB) ORB.init(args, props); |
| |
| // create the repository object |
| String db = System.getProperty( ORBConstants.DB_PROPERTY, |
| ORBConstants.DEFAULT_DB_NAME ); |
| RepositoryImpl repository = new RepositoryImpl(orb, new File(db), |
| debug); |
| |
| // wait for shutdown |
| orb.run(); |
| } catch (Exception ex) { |
| ex.printStackTrace(); |
| } |
| } |
| |
| transient private boolean debug = false; |
| |
| final static int illegalServerId = -1; |
| |
| transient private RepositoryDB db = null; |
| |
| transient ORB orb = null; |
| |
| transient ActivationSystemException wrapper ; |
| |
| class RepositoryDB implements Serializable |
| { |
| File db; |
| Hashtable serverTable; |
| Integer serverIdCounter; |
| |
| RepositoryDB(File dbFile) { |
| |
| db = dbFile; |
| |
| // initialize the Server Id counter and hashtable. |
| // the lower id range is reserved for system servers |
| serverTable = new Hashtable(255); |
| serverIdCounter = new Integer(256); |
| } |
| |
| int incrementServerIdCounter() |
| { |
| int value = serverIdCounter.intValue(); |
| serverIdCounter = new Integer(++value); |
| |
| return value; |
| } |
| |
| void flush() |
| { |
| try { |
| db.delete(); |
| FileOutputStream fos = new FileOutputStream(db); |
| ObjectOutputStream oos = new ObjectOutputStream(fos); |
| oos.writeObject(this); |
| oos.flush(); |
| oos.close(); |
| } catch (Exception ex) { |
| throw wrapper.cannotWriteRepositoryDb( ex ) ; |
| } |
| } |
| } |
| |
| class DBServerDef implements Serializable |
| { |
| public String toString() { |
| return "DBServerDef(applicationName=" + applicationName + |
| ", name=" + name + |
| ", classPath=" + classPath + |
| ", args=" + args + |
| ", vmArgs=" + vmArgs + |
| ", id=" + id + |
| ", isInstalled=" + isInstalled + ")" ; |
| } |
| |
| DBServerDef(ServerDef server, int server_id) { |
| applicationName = server.applicationName ; |
| name = server.serverName; |
| classPath = server.serverClassPath; |
| args = server.serverArgs; |
| vmArgs = server.serverVmArgs; |
| id = server_id; |
| isInstalled = false ; |
| } |
| |
| String applicationName; |
| String name; |
| String classPath; |
| String args; |
| String vmArgs; |
| boolean isInstalled ; |
| int id; |
| } |
| } |