Commit 668f76e9 authored by nobody's avatar nobody
Browse files

This commit was manufactured by cvs2svn to create tag 'JORAM_4_3_31'.

parent fee1a525
/*
* JORAM: Java(TM) Open Reliable Asynchronous Messaging
* Copyright (C) 2008 - ScalAgent Distributed Technologies
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA.
*
*/
package fr.dyade.aaa.jndi2.ha;
import java.net.ServerSocket;
import java.util.StringTokenizer;
import java.util.Vector;
import org.objectweb.util.monolog.api.BasicLevel;
import fr.dyade.aaa.agent.AgentId;
import fr.dyade.aaa.agent.AgentServer;
import fr.dyade.aaa.jndi2.distributed.ReplicationEntryPoint;
import fr.dyade.aaa.jndi2.distributed.ReplicationManager;
import fr.dyade.aaa.jndi2.server.AgentEntryPoint;
import fr.dyade.aaa.jndi2.server.Container;
import fr.dyade.aaa.jndi2.server.Trace;
public class HADistributedJndiServer {
private static HATcpServer tcpServer;
public static void init(String args, boolean firstTime) throws Exception {
if (Trace.logger.isLoggable(BasicLevel.DEBUG))
Trace.logger.log(BasicLevel.DEBUG, "HADistributedJndiServer.init(" +
args + ',' + firstTime + ')');
StringTokenizer st = new StringTokenizer(args);
String portS = st.nextToken();
int port = Integer.parseInt(portS);
Vector list = new Vector();
while (st.hasMoreTokens()) {
String idS = st.nextToken();
Short id = Short.valueOf(idS);
list.addElement(id);
}
short[] serverIds = new short[list.size()];
for (int i = 0; i < list.size(); i++) {
serverIds[i] =
((Short)list.elementAt(i)).shortValue();
}
// Create the socket here in order to throw an exception
// if the socket can't be created (even if firstTime is false).
ServerSocket serverSocket = new ServerSocket(port);
tcpServer = new HATcpServer(
serverSocket,
3,
getDefault());
tcpServer.start();
if (firstTime) {
ReplicationManager manager =
new ReplicationManager(serverIds);
AgentEntryPoint agentEP = new AgentEntryPoint();
agentEP.setRequestManager(manager);
ReplicationEntryPoint replicationEP = new ReplicationEntryPoint();
replicationEP.setRequestManager(manager);
HARequestManager haManager = new HARequestManager();
haManager.setRequestManager(manager);
HAEntryPoint haEP = new HAEntryPoint();
haEP.setHARequestManager(haManager);
Container container = new Container();
container.addEntryPoint(agentEP);
container.addEntryPoint(replicationEP);
container.addEntryPoint(haEP);
container.setLifeCycleListener(haManager);
container.setBagSerializer(haManager);
manager.setContainer(container);
container.deploy();
}
}
/**
* Stops the <code>JndiServer</code> service.
*/
public static void stopService() {
tcpServer.stop();
}
/**
* Returns the default JndiServer id on the local agent server.
*
* @return the <code>AgentId</code> of the JndiServer
*/
public static AgentId getDefault() {
return getDefault(AgentServer.getServerId());
}
/**
* Returns the default JndiServer id on the given agent server.
*
* @param serverId the id of the agent server
* @return the <code>AgentId</code> of the JndiServer
*/
public static AgentId getDefault(short serverId) {
return new AgentId(
serverId, serverId,
AgentId.LocalJndiServiceStamp);
}
}
/*
* JORAM: Java(TM) Open Reliable Asynchronous Messaging
* Copyright (C) 2001 - 2007 ScalAgent Distributed Technologies
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA.
*
* Initial developer(s): David Feliot
* Contributor(s): Nicolas Tachker (ScalAgent)
*/
package fr.dyade.aaa.jndi2.hascn;
import java.util.Hashtable;
import javax.naming.Binding;
import javax.naming.CompoundName;
import javax.naming.Context;
import javax.naming.ContextNotEmptyException;
import javax.naming.Name;
import javax.naming.NameAlreadyBoundException;
import javax.naming.NameClassPair;
import javax.naming.NameNotFoundException;
import javax.naming.NameParser;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.NotContextException;
import javax.naming.OperationNotSupportedException;
import javax.naming.spi.InitialContextFactory;
import javax.naming.spi.ResolveResult;
import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;
import fr.dyade.aaa.jndi2.haclient.HANamingContextFactory;
/**
* Context implementation for the "hascn:comp" namespace.
* Package must be named .../hascn (See Initial Context)
* Most operations consist of retrieving the actual CompNamingContext
* and sending it the operation for processing.
*/
public class hascnURLContext implements Context {
public final static Logger logger;
static {
logger = fr.dyade.aaa.util.Debug.getLogger("fr.dyade.aaa.jndi2.hascn");
}
static private final String URL_PREFIX = "hascn:comp/";
//static private final String ENV_PREFIX = "env";
private Hashtable myEnv;
private InitialContextFactory namingFactory;
/**
* Constructor
*/
public hascnURLContext(Hashtable env) throws NamingException {
if (logger.isLoggable(BasicLevel.DEBUG))
logger.log(BasicLevel.DEBUG,
"hascnURLContext.<init>(" + env + ')');
if (env != null) {
// clone env to be able to change it.
myEnv = (Hashtable)env.clone();
String factoryClassName = (String)myEnv.get("hascn.naming.factory.class");
if (factoryClassName == null) {
namingFactory = new HANamingContextFactory();
} else {
try {
Class factoryClass = Class.forName(factoryClassName);
namingFactory =
(InitialContextFactory)factoryClass.newInstance();
} catch (Exception exc) {
NamingException ne = new NamingException();
ne.setRootCause(exc);
throw ne;
}
}
}
}
/*
* get name without the url prefix
*/
private String getRelativeName(String name) throws NamingException {
// We suppose that all names must be prefixed as this
if (!name.startsWith(URL_PREFIX)) {
throw new NameNotFoundException("Invalid name:" + name);
}
name = name.substring(URL_PREFIX.length());
return name;
}
/*
* Resolve the name inside the javaURLContext
* Result must be a Context + the name in this Context
*/
private ResolveResult findContextFor(String name) throws NamingException {
String rname = getRelativeName(name);
Context context = null;
if (rname.equals("")) {
// null name refers to this context
context = new hascnURLContext(myEnv);
} else {
// other names are component independant
context = namingFactory.getInitialContext(myEnv);
}
// Check context is not null to avoid nullPointerException
if (context == null) {
throw new NameNotFoundException("No context for this component");
}
// Build a ResolveResult object to return
ResolveResult r = new ResolveResult(context, rname);
return r;
}
// ------------------------------------------------------------------
// Context implementation
// ------------------------------------------------------------------
/**
* Retrieves the named object.
*
* @param name the name of the object to look up
* @return the object bound to name
* @throws NamingException if a naming exception is encountered
*/
public Object lookup(Name name) throws NamingException {
// Just use the string version for now.
return lookup(name.toString());
}
/**
* Retrieves the named object.
*
* @param name the name of the object to look up
* @return the object bound to name
* @throws NamingException if a naming exception is encountered
*/
public Object lookup(String name) throws NamingException {
if (logger.isLoggable(BasicLevel.DEBUG))
logger.log(BasicLevel.DEBUG,
"hascnURLContext.lookup(" + name + ')');
// Name empty: returns a new instance of this context.
if (name.equals("")) {
return new hascnURLContext(myEnv);
}
// Retrieve the correct context to resolve the reminding name
ResolveResult r = findContextFor(name);
Context ctx = (Context) r.getResolvedObj();
String rname = r.getRemainingName().toString();
Object o = ctx.lookup(rname);
return o;
////////////////////////////
// Resolve the name in its proper context
//return ctx.lookup(rname);
}
/**
* Binds a name to an object.
*
* @param name the name to bind; may not be empty
* @param obj the object to bind; possibly null
* @throws NameAlreadyBoundException if name is already bound
* @throws javax.naming.directory.InvalidAttributesException
* if object did not supply all mandatory attributes
* @throws NamingException if a naming exception is encountered
*
* @see #bind(String, Object)
* @see #rebind(Name, Object)
* @see javax.naming.directory.DirContext#bind(Name, Object,
* javax.naming.directory.Attributes)
*/
public void bind(Name name, Object obj) throws NamingException {
// Just use the string version for now.
bind(name.toString(), obj);
}
/**
* Binds a name to an object.
* All intermediate contexts and the target context (that named by all
* but terminal atomic component of the name) must already exist.
*
* @param name
* the name to bind; may not be empty
* @param obj
* the object to bind; possibly null
* @throws NameAlreadyBoundException if name is already bound
* @throws javax.naming.directory.InvalidAttributesException
* if object did not supply all mandatory attributes
* @throws NamingException if a naming exception is encountered
*/
public void bind(String name, Object obj) throws NamingException {
// Retrieve the correct context for this name
ResolveResult r = findContextFor(name);
Context ctx = (Context) r.getResolvedObj();
String rname = r.getRemainingName().toString();
// Bind the name in its proper context
ctx.bind(rname, obj);
}
/**
* Binds a name to an object, overwriting any existing binding.
* All intermediate contexts and the target context (that named by all
* but terminal atomic component of the name) must already exist.
*
* If the object is a DirContext, any existing attributes
* associated with the name are replaced with those of the object.
* Otherwise, any existing attributes associated with the name remain
* unchanged.
*
* @param name
* the name to bind; may not be empty
* @param obj
* the object to bind; possibly null
* @throws javax.naming.directory.InvalidAttributesException
* if object did not supply all mandatory attributes
* @throws NamingException if a naming exception is encountered
*
*/
public void rebind(Name name, Object obj) throws NamingException {
// Just use the string version for now.
rebind(name.toString(), obj);
}
/**
* Binds a name to an object, overwriting any existing binding.
* See {@link #rebind(Name, Object)} for details.
*
* @param name
* the name to bind; may not be empty
* @param obj
* the object to bind; possibly null
* @throws javax.naming.directory.InvalidAttributesException
* if object did not supply all mandatory attributes
* @throws NamingException if a naming exception is encountered
*/
public void rebind(String name, Object obj) throws NamingException {
// Retrieve the correct context for this name
ResolveResult r = findContextFor(name);
Context ctx = (Context) r.getResolvedObj();
String rname = r.getRemainingName().toString();
// Rebind the name in its proper context
ctx.rebind(rname, obj);
}
/**
* Unbinds the named object.
* Removes the terminal atomic name in name
* from the target context--that named by all but the terminal
* atomic part of name.
*
* This method is idempotent.
* It succeeds even if the terminal atomic name
* is not bound in the target context, but throws
* NameNotFoundException
* if any of the intermediate contexts do not exist.
*
* Any attributes associated with the name are removed.
* Intermediate contexts are not changed.
*
* @param name
* the name to unbind; may not be empty
* @throws NameNotFoundException if an intermediate context does not exist
* @throws NamingException if a naming exception is encountered
* @see #unbind(String)
*/
public void unbind(Name name) throws NamingException {
// Just use the string version for now.
unbind(name.toString());
}
/**
* Unbinds the named object.
* See {@link #unbind(Name)} for details.
*
* @param name
* the name to unbind; may not be empty
* @throws NameNotFoundException if an intermediate context does not exist
* @throws NamingException if a naming exception is encountered
*/
public void unbind(String name) throws NamingException {
// Retrieve the correct context for this name
ResolveResult r = findContextFor(name);
Context ctx = (Context) r.getResolvedObj();
String rname = r.getRemainingName().toString();
// Unbind the name in its proper context
ctx.unbind(rname);
}
/**
* Binds a new name to the object bound to an old name, and unbinds
* the old name. This operation is not supported (read only env.)
*
* @param oldName
* the name of the existing binding; may not be empty
* @param newName
* the name of the new binding; may not be empty
* @throws NamingException if a naming exception is encountered
*/
public void rename(Name oldName, Name newName) throws NamingException {
// Just use the string version for now.
rename(oldName.toString(), newName.toString());
}
/**
* Binds a new name to the object bound to an old name, and unbinds
* the old name. Not supported.
*
* @param oldName
* the name of the existing binding; may not be empty
* @param newName
* the name of the new binding; may not be empty
* @throws NamingException if a naming exception is encountered
*/
public void rename(String oldName, String newName) throws NamingException {
throw new OperationNotSupportedException("Rename not supported in hascn:comp in " + this.getClass().getName());
}
/**
* Enumerates the names bound in the named context, along with the
* class names of objects bound to them.
* The contents of any subcontexts are not included.
*
* If a binding is added to or removed from this context,
* its effect on an enumeration previously returned is undefined.
*
* @param name
* the name of the context to list
* @return an enumeration of the names and class names of the
* bindings in this context. Each element of the
* enumeration is of type NameClassPair.
* @throws NamingException if a naming exception is encountered
*
* @see #list(String)
* @see #listBindings(Name)
* @see NameClassPair
*/
public NamingEnumeration list(Name name) throws NamingException {
// Just use the string version for now.
return list(name.toString());
}
/**
* Enumerates the names bound in the named context, along with the
* class names of objects bound to them.
* See {@link #list(Name)} for details.
*
* @param name
* the name of the context to list
* @return an enumeration of the names and class names of the
* bindings in this context. Each element of the
* enumeration is of type NameClassPair.
* @throws NamingException if a naming exception is encountered
*/
public NamingEnumeration list(String name) throws NamingException {
// Retrieve the correct context to resolve the reminding name
ResolveResult r = findContextFor(name);
Context ctx = (Context) r.getResolvedObj();
String rname = r.getRemainingName().toString();
// List the correct Context
return ctx.list(rname);
}
/**
* Enumerates the names bound in the named context, along with the
* objects bound to them.
* The contents of any subcontexts are not included.
*
* If a binding is added to or removed from this context,
* its effect on an enumeration previously returned is undefined.
*
* @param name
* the name of the context to list
* @return an enumeration of the bindings in this context.
* Each element of the enumeration is of type
* Binding.
* @throws NamingException if a naming exception is encountered
*
* @see #listBindings(String)
* @see #list(Name)
* @see Binding
*/
public NamingEnumeration listBindings(Name name) throws NamingException {
// Just use the string version for now.
return listBindings(name.toString());
}
/**
* Enumerates the names bound in the named context, along with the
* objects bound to them.
* See {@link #listBindings(Name)} for details.
*
* @param name
* the name of the context to list
* @return an enumeration of the bindings in this context.
* Each element of the enumeration is of type
* Binding.
* @throws NamingException if a naming exception is encountered
*/
public NamingEnumeration listBindings(String name) throws NamingException {
// Retrieve the correct context to resolve the reminding name
ResolveResult r = findContextFor(name);
Context ctx = (Context) r.getResolvedObj();
String rname = r.getRemainingName().toString();
// List the correct Context
return ctx.listBindings(rname);
}
/**
* Destroys the named context and removes it from the namespace.
* Any attributes associated with the name are also removed.
* Intermediate contexts are not destroyed.
*
* This method is idempotent.
* It succeeds even if the terminal atomic name
* is not bound in the target context, but throws
* NameNotFoundException
* if any of the intermediate contexts do not exist.
*
* In a federated naming system, a context from one naming system
* may be bound to a name in another. One can subsequently
* look up and perform operations on the foreign context using a
* composite name. However, an attempt destroy the context using
* this composite name will fail with
* NotContextException, because the foreign context is not
* a "subcontext" of the context in which it is bound.
* Instead, use unbind() to remove the
* binding of the foreign context. Destroying the foreign context
* requires that the destroySubcontext() be performed
* on a context from the foreign context's "native" naming system.
*
* @param name
* the name of the context to be destroyed; may not be empty
* @throws NameNotFoundException if an intermediate context does not exist
* @throws NotContextException if the name is bound but does not name a
* context, or does not name a context of the appropriate type
* @throws ContextNotEmptyException if the named context is not empty
* @throws NamingException if a naming exception is encountered
*
* @see #destroySubcontext(String)
*/
public void destroySubcontext(Name name) throws NamingException {
// Just use the string version for now.
destroySubcontext(name.toString());
}
/**
* Destroys the named context and removes it from the namespace.
* See {@link #destroySubcontext(Name)} for details.
*
* @param name
* the name of the context to be destroyed; may not be empty
* @throws NameNotFoundException if an intermediate context does not exist
* @throws NotContextException if the name is bound but does not name a
* context, or does not name a context of the appropriate type