diff options
Diffstat (limited to 'java/JACE/netsvcs/Token/TokenAcceptor.java')
-rw-r--r-- | java/JACE/netsvcs/Token/TokenAcceptor.java | 353 |
1 files changed, 0 insertions, 353 deletions
diff --git a/java/JACE/netsvcs/Token/TokenAcceptor.java b/java/JACE/netsvcs/Token/TokenAcceptor.java deleted file mode 100644 index 53adf08753b..00000000000 --- a/java/JACE/netsvcs/Token/TokenAcceptor.java +++ /dev/null @@ -1,353 +0,0 @@ -package JACE.netsvcs.Token; - -import java.io.*; -import java.net.*; -import java.util.*; -import JACE.OS.*; -import JACE.Misc.*; -import JACE.Connection.*; -import JACE.netsvcs.Server; - -/** - * Server for the token service. Launches TokenRequestHandlers as - * connections are made. Currently, the activation strategy must be - * thread per connection since the operations are allowed to block - * during acquires, etc. - * <P> - * Two types of locks are supported by default -- Mutex and RWMutex. - * New lock types can be added from the command line without changing - * any code in the service. To do this, just create a class which - * implements the LockHandler interface. - * <P> - * When a request for a new lock comes in, a LockHandler of the corresponding - * type is created and a mapping is created between the lock name and the - * handler. Later requests reuse that mapping. - * <P> - * <B>Valid command line arguments:</B> - * <PRE> - * -f (class name):(type) Specify a LockHandler for a type of lock"); - * -p (port number) Port to listen on for clients"); - * -d Enable debugging messages"); - * </PRE> - * - *@see JACE.netsvcs.Server - *@see TokenRequestHandler - *@see LockHandler - *@see LockTypes - */ -public class TokenAcceptor extends Server -{ - protected void addDefaultFactories() throws ClassNotFoundException { - addHandlerFactory(LockTypes.MUTEX, - Class.forName("JACE.netsvcs.Token.MutexHandler")); - addHandlerFactory(LockTypes.RWLOCK, - Class.forName("JACE.netsvcs.Token.RWMutexHandler")); - } - - /** - * Default constructor. - */ - public TokenAcceptor() { - - // Set the name in case we aren't using the service configurator. - name ("Token Service"); - - lockHandlerMap_ = new Hashtable(); - handlerFactoryMap_ = new Hashtable(); - clientHandlerMap_ = new Hashtable (); - } - - /** - * Add a map between a type of lock and the factory which - * creates LockHandler instances that handle it. - * - *@see LockTypes - *@param type number representing the type of lock - *@param factory Class object for a LockHandler class - */ - public void addHandlerFactory(Integer type, Class factory) { - handlerFactoryMap_.put(type, factory); - } - - /** - * Add a map between a type of lock and the factory which - * creates LockHandler instances that handle it. - * - *@see LockTypes - *@param type number representing the type of lock - *@param factory Class object for a LockHandler class - */ - public void addHandlerFactory(int type, Class factory) { - addHandlerFactory(new Integer(type), factory); - } - - /** - * Remove the LockHandler factory which handles locks - * of the specified type. - * - *@param type type of LockHandler to cease supporting - *@return the LockHandler instance (or null if not found) - */ - public Object removeHandlerFactory(Integer type) { - return handlerFactoryMap_.remove(type); - } - - /** - * Remove the LockHandler factory which handles locks - * of the specified type. - * - *@param type type of LockHandler to cease supporting - *@return the LockHandler instance (or null if not found) - */ - public Object removeHandlerFactory(int type) { - return handlerFactoryMap_.remove(new Integer(type)); - } - - /** - * Retrieve the LockHandler corresponding to the given name - * or create a new one if it doesn't exist. This is called by - * TokenRequestHandlers. - * - *@param lockName name of the lock to retrieve or create a LockHandler for - *@param lockType type of the lock - *@return LockHandler which handles the lock with that name - */ - public LockHandler getLockHandler (String lockName, - int lockType) { - synchronized (lockHandlerMap_) { - - Object obj = lockHandlerMap_.get(lockName); - - if (obj != null) - return (LockHandler)obj; - else { - LockHandler handler = newHandler (lockType); - lockHandlerMap_.put (lockName, handler); - return handler; - } - } - } - - /** - * Create a new LockHandler of the specified type. - * - *@param type type of LockHandler to create - *@return a new LockHandler instance - */ - protected LockHandler newHandler (int type) { - ACE.DEBUG ("Creating new handler of type " + type); - Object factoryObj = handlerFactoryMap_.get(new Integer(type)); - if (factoryObj == null) - return null; - - Class factory = (Class)factoryObj; - LockHandler handler = null; - - try { - handler = (LockHandler)factory.newInstance(); - } catch (InstantiationException e) { - ACE.ERROR("Can't create a handler of type " + type); - } catch (IllegalAccessException e) { - ACE.ERROR("Handler of type " + type + - " must have a default constructor"); - } - return handler; - } - - /** - * Simple main program. See the class description for more - * information about command line arguments. - */ - public static void main(String args[]) { - TokenAcceptor ta = new TokenAcceptor(); - - ta.init(args); - } - - /** - * Create a new TokenRequestHandler instance. - */ - protected SvcHandler makeSvcHandler() - { - return new TokenRequestHandler(); - } - - /** - * Sets up the default factories so the user can override them on - * the command line, then delegates back to Server.init (String[]). - * - *@see JACE.netsvcs.Server#init - *@param args command line arguments - *@return -1 on failure, 0 on success - */ - public int init(String [] args) { - try { - addDefaultFactories (); - } catch (ClassNotFoundException e) { - ACE.ERROR ("Can't find default factory " + e.getMessage ()); - return -1; - } - - return super.init (args); - } - - /** - * Prints out the valid command line arguments. See the class - * description for more information. Called by Server.init when - * parseArgs returns -1. - */ - protected void printUsage () - { - ACE.ERROR ("Valid options:\n"); - ACE.ERROR ("-f <class name>:<type> Specify a handler for a type of lock"); - ACE.ERROR ("-p <port number> Port to listen on for clients"); - ACE.ERROR ("-d Enable debugging messages"); - } - - /** - * Parses the command line arguments. See the class description - * for more information. - * - *@param args command line arguments - *@return -1 on failure, 0 on success - */ - protected int parseArgs(String [] args) - { - int c = 0; - GetOpt opt = new GetOpt(args, "p:f:d", true); - - try { - - while ((c = opt.next ()) != -1) { - switch (c) - { - case 'd': - ACE.enableDebugging (); - ACE.DEBUG ("Debugging is enabled"); - break; - case 'p': - if (!port (opt.optarg ())) - return -1; - break; - case 'f': - if (newHandlerFactory (opt.optarg ()) < 0) - return -1; - break; - default: - ACE.ERROR("Unknown argument: " + (char)c); - return -1; - } - } - } catch (ArrayIndexOutOfBoundsException e) { - ACE.ERROR ("Option -" + (char)c + " requires an argument"); - return -1; - } - - return 0; - } - - /** - * Load the Class for the specified LockHandler and create a mapping - * from its type to the Class instance. Used to parse the command - * line pair of (class name):(type). - * - *@param nameAndType (class name):(type) pair from the command line - *@return -1 on failure, 0 on success - */ - protected int newHandlerFactory (String nameAndType) - { - int colon = nameAndType.lastIndexOf (':'); - - if (colon < 1) { - ACE.ERROR ("Invalid -f <class name>:<type num> for handler: " + - nameAndType); - return -1; - } - - int type = 0; - try { - type = Integer.parseInt (nameAndType.substring (colon + 1)); - } catch (NumberFormatException e) { - ACE.ERROR ("Invalid token type: " + e.getMessage ()); - return -1; - } - - String name = nameAndType.substring (0, colon); - - Class factory; - try { - factory = Class.forName (name); - } catch (ClassNotFoundException e) { - ACE.ERROR (e.getMessage ()); - return -1; - } - - addHandlerFactory (type, factory); - ACE.DEBUG ("New handler " + name + " with type " + type); - - return 0; - } - - /** - * Create a mapping between a client ID and a LockHandler. This is - * only used by TokenRequestHandlers in order to keep track of which - * locks a client touches. That way, if/when a client disconnects, - * all its locks can be abandoned successfully. - * - *@param clientID client identification (key in the mapping) - *@param handler LockHandler to map to (value in the mapping) - * - */ - void addClientLockHandler (String clientID, - LockHandler handler) - { - Object obj = clientHandlerMap_.get (clientID); - if (obj == null) { - // Probably won't have more than 10 locks per client ID, and the Vector - // should resize automatically even if someone does. - Vector handlerList = new Vector (10); - handlerList.addElement (handler); - clientHandlerMap_.put (clientID, handlerList); - } else { - Vector handlerList = (Vector)obj; - int alreadyThereIndex = handlerList.indexOf (handler); - if (alreadyThereIndex == -1) - handlerList.addElement (handler); - } - } - - /** - * Called by TokenRequestHandlers to remove a specified client ID - * from the client ID to LockHandler mapping. - */ - void removeClient (String clientID) - { - clientHandlerMap_.remove (clientID); - } - - /** - * Called by TokenRequestHandlers to obtain a list of all LockHandlers - * accessed by a particular client. Useful for abandoning the locks. - */ - Enumeration getClientLockHandlers (String clientID) - { - Object obj = clientHandlerMap_.get (clientID); - if (obj == null) - return null; - else - return ((Vector)obj).elements (); - } - - // These should be replaced by weak hash maps when available - - // Map consisting of (token name) to (LockHandler instance) pairs - private Hashtable lockHandlerMap_; - - // Map consisting of (Integer token type) to (Class instance for - // corresponding LockHandler class) - private Hashtable handlerFactoryMap_; - - // Map consisting of (client ID) to (Vector of LockHandler) pairs - private Hashtable clientHandlerMap_; -} - |