Name:      Global.java

Project:   xmlBlaster.org

Copyright: xmlBlaster.org, see xmlBlaster-LICENSE file

Comment:   Properties for xmlBlaster

------------------------------------------------------------------------------*/

* Global variables to avoid singleton.

* <p>

* Each Global instance holds all configuration and helper objects for

* exactly one XmlBlasterAccess client instance. It is like a local

* stack for a connection.

* </p>

* <p>

* Use one instance of this for each XmlBlasterAccess client connection to xmlBlaster.

* </p>

* <p>

* A Global instance is still usable after a call to its shutdown() method,

* it can be used again in another XmlBlasterAccess instance.

* </p>

*

* @see org.xmlBlaster.test.classtest.GlobalTest

*/

   private static Logger log = Logger.getLogger(Global.class.getName());

   private static boolean logIsInitialized;

   private volatile static Global firstInstance;

   /** The amount of physical RAM of this machine.

    * Set by JmxWrappter.java, else 0

    * @since JDK 1.5

    */

   public static long totalPhysicalMemorySize;

   /** Number of bytes this JVM can allocate max, the -Xmx???M setting

    * Set by JmxWrappter.java

    * (defaults to Runtime.getRuntime().maxMemory())

    * @since JDK 1.5

    */

   public static long heapMemoryUsage = Runtime.getRuntime().maxMemory();

   /** The max number of file descriptors this JVM may use

    * Set by JmxWrappter.java, else 0

    * @since JDK 1.5

    */

   public static long maxFileDescriptorCount;

   /** Version string, please change for new releases (4 digits) */

   private String versionDefault = "2.0.0";

   /** This will be replaced by build.xml with the current version */

   private String version = "@version@";

   /** This will be replaced by build.xml with the current subversion revision number */

   private String revisionNumber = "@revision.number@";

   /** This will be replaced by build.xml with the build timestamp */

   private String buildTimestamp = "@build.timestamp@";

   /** This will be replaced by build.xml with the compiling JDK vendor */

   private String buildJavaVendor = "@build.java.vendor@";

   /** This will be replaced by build.xml with the compiling JDK version */

   private String buildJavaVersion = "@build.java.version@";

   protected String ME = "Global";

   protected String ip_addr = null;

   protected String id = "";

   private volatile String instanceId;

   protected volatile Property property = null;

   protected String errorText = null;

   protected ContextNode contextNode;

   protected ContextNode scopeContextNode;

   protected String cbHostname = null;

   protected String addressNormalized = null;

   /** The xmlBlaster class loader factory */

   private ClassLoaderFactory classLoaderFactory = null;

   protected /*final*/ Map nativeCallbackDriverMap;

   /** Store objects in the scope of one client connection or server instance */

   protected /*final*/ Map objectMap;

   /** Helper to synchronize objectMap access */

   public final Object objectMapMonitor = new Object();

   protected volatile Address bootstrapAddress;

   protected PluginLoader clientSecurityLoader;

   protected volatile QueuePluginManager queuePluginManager;

   protected volatile DispatchPluginManager dispatchPluginManager;

   protected volatile ProtocolPluginManager protocolPluginManager;

   protected volatile CbServerPluginManager cbServerPluginManager;

   private volatile HttpIORServer httpServer;  // xmlBlaster publishes his AuthServer IOR

   protected Hashtable logChannels = new Hashtable();

   protected SAXParserFactory saxFactory;

   protected DocumentBuilderFactory docBuilderFactory;

   protected TransformerFactory transformerFactory;

   /** Must be loaded in runlevel 0 or 1 before any access as not synchronized */

   protected I_Checkpoint checkpointPlugin;

   protected volatile I_MsgKeyFactory msgKeyFactory;

   protected volatile I_QueryKeyFactory queryKeyFactory;

   protected volatile I_ConnectQosFactory connectQosFactory;

   protected volatile I_DisconnectQosFactory disconnectQosFactory;

   protected volatile I_MsgQosFactory msgQosFactory;

   protected volatile I_QueryQosFactory queryQosFactory;

   protected volatile I_StatusQosFactory statusQosFactory;

   protected volatile Timeout pingTimer;

   protected volatile Timeout burstModeTimer;

   protected volatile Timeout messageTimer;

   protected volatile Timeout jdbcConnectionPoolTimer;

   protected volatile DispatchWorkerPool dispatchWorkerPool;

   protected static int counter = 0;

   private volatile PluginManagerBase pluginManager;

   private volatile PluginRegistry pluginRegistry;

   /** The client handle to access xmlBlaster */

   protected volatile I_XmlBlasterAccess xmlBlasterAccess;

   protected boolean isDoingShutdown = false;

   /** set to allow wipe out the persistence on restarts */

   protected boolean wipeOutDB = false;

   //** the entry factory to be used */

   protected I_EntryFactory entryFactory;

   /** JMX notification sequence number. */

   protected long sequenceNumber = 1;

   private Map weakRegistry = new WeakHashMap<Object, Object>();

  

   /**

    * Constructs an initial Global object,

    * same as Global(null, true, true)

    */

   public Global() {

      this(null, true, false);

   }

   /**

    * Constructs an initial Global object which is initialized

    * by your properties (without leading '-'),

    * same as Global(args, true, true)

    */

   public Global(Properties props) {

      this(Property.propsToArgs(props));

   }

   /**

    * Constructs an initial Global object which is initialized

    * by your args array (usually the command line args).

    * Same as Global(args, true, true)

    */

   public Global(String[] args)

   {

      this(args, true, false);

   }

   public Global(String[] args, boolean loadPropFile, boolean checkInstance) {

      this(args, loadPropFile, checkInstance, true);

   }

  

   /**

    * Constructs an initial Global object which is initialized

    * by your args array (usually the command line args).

    *

    * <p>By setting loadPropFile to false it is possible to create a Global

    * which does not automatically search out the xmlBlaster.properties file,

    * which is good when you want to start xmlBlaster in an embedded environment.

    * <p>It is possible to later load the property file if one wants, here is one

    * way to do it:</p>

    * <pre>

         Property p = glob.getProperty();

         Properties prop = new Properties();

         FileInfo i = p.findPath("xmlBlaster.properties");

         InputStream is = i.getInputStream();

         prop.load(is);

         String[] ar = Property.propsToArgs(prop);

         p.addArgs2Props( ar != null ? ar : new String[0] );

       </pre>

     <p>It is also possible to load an entire second property file or find it

        with some other algorithm byte using the same pattern as above, just

        don't use findPath, but some other code.</p>

    * @param args args array (usually the command line args).

    * @param loadPropFile if automatic loading of xmlBlaster.properties should be done.

    */

   public Global(String[] args, boolean loadPropFile, boolean checkInstance, boolean doReplace)

   {

      counter++;

      if (checkInstance == true) {

         if (firstInstance != null) {

            System.out.println("######Global args constructor invoked again, try Global.instance()");

            Thread.dumpStack();

         }

      }

      synchronized (Global.class) {

         if (firstInstance == null)

            firstInstance = this;

      }

      initProps(args,loadPropFile, doReplace);

      initId();

      nativeCallbackDriverMap = Collections.synchronizedMap(new HashMap());

      objectMap = new HashMap();

      try { // since JKD 1.4:

         URL url = initLogManager(args);

         if (url != null)

            log.info("Configuring JDK 1.4 logging with configuration '" + url.toString() + "'");

      }

      catch (XmlBlasterException e) {

         System.err.println("Configuring JDK 1.4 logging output failed: " + e.toString());

      }

   }

   public static int getCounter() { return counter; }

   /**

    * @return the JmxWrapper used to manage the MBean resources

    */

    public final JmxWrapper getJmxWrapper() throws XmlBlasterException {

      return JmxWrapper.getInstance(this);

   }

   /**

    * Check if JMX is activated.

    * @return true if JMX is in use

    */

   public boolean isJmxActivated() {

      try {

         return getJmxWrapper().isActivated();

      }

      catch (XmlBlasterException e) {

         return false;

      }

   }

   /**

    * Send an administrative notification.

    */

   public void sendNotification(NotificationBroadcasterSupport source,

          String msg, String attributeName,

          String attributeType, Object oldValue, Object newValue) {

      // Avoid any log.warning or log.severe to prevent looping alert events

      if (isJmxActivated()) {

         Notification n = new AttributeChangeNotification(source,

            sequenceNumber++,

            System.currentTimeMillis(),

            msg,

            attributeName,

            attributeType,

            oldValue,

            newValue);

         source.sendNotification(n);

      }

   }

   /**

    * JMX support.

    * Start xmlBlaster with <code>java -Dcom.sun.management.jmxremote org.xmlBlaster.Main</code>

    * You can access xmlBlaster from 'jconsole' delivered with JDK1.5 or above.

    * The root node is always the cluster node id.

    * @param contextNode Used to retrieve a unique instance name for the given MBean

    * @param mbean the MBean object instance

    * @return The object name used to register or null on error

    * @since 1.0.5

    * @see http://www.xmlblaster.org/xmlBlaster/doc/requirements/admin.jmx.html

    */

   public JmxMBeanHandle registerMBean(ContextNode contextNode, Object mbean) throws XmlBlasterException {

      return getJmxWrapper().registerMBean(contextNode, mbean);

   }

   /**

    * Unregister a JMX MBean.

    * Never throws any exception

    * @param objectName The object you got from registerMBean() of type ObjectName,

    *                   if null nothing happens

    */

   public void unregisterMBean(Object objectName) {

      if (objectName == null) return;

      try {

         if (objectName instanceof JmxMBeanHandle)

            getJmxWrapper().unregisterMBean((JmxMBeanHandle)objectName);

         else

            getJmxWrapper().unregisterMBean((ObjectName)objectName);

      }

      catch (XmlBlasterException e) {

         log.warning("unregisterMBean(" + objectName.toString() + ") failed: " + e.toString());

      }

      catch (Throwable e) {

         log.severe("unregisterMBean(" + objectName.toString() + ") failed: " + e.toString());

      }

   }

  

   public boolean isRegisteredMBean(ContextNode ctxNode) throws XmlBlasterException {

      return getJmxWrapper().isRegistered(ctxNode);

   }

   /**

    * See @version@ which will be replaced by build.xml with the current version

    * @return e.g. "0.79f"

    */

   public String getVersion() {

      if (version.indexOf("@") == -1) // Check if replaced

         return version;

      return versionDefault;

   }

   /**

    * See @revision.number@ which will be replaced by build.xml with the current subversion revision

    * @return e.g. "12702" or "12702M". If no subversion is available getVersion() is returned

    */

   public String getRevisionNumber() {

      if (this.revisionNumber.indexOf("@") == -1 && !"${revision.number}".equals(this.revisionNumber)) // Check if replaced

         return this.revisionNumber;

      return versionDefault;

   }

   /**

    * Combination from getVersion() and getRevisionNumber().

    * @return e.g. "0.91 #12702"

    */

   public String getReleaseId() {

      if (!getVersion().equals(getRevisionNumber()))

         return getVersion() + " #" + getRevisionNumber();

      return getVersion();

   }

   /**

    * See @build.timestamp@ which will be replaced by build.xml with the current timestamp

    * @return e.g. "06/17/2002 01:38 PM"

    */

   public String getBuildTimestamp() {

      return buildTimestamp;

   }

   /**

    * @return e.g. "1.3.1-beta"

    */

   public String getBuildJavaVendor() {

      return buildJavaVendor;

   }

   /**

    * @return e.g. "1.3.1-beta"

    */

   public String getBuildJavaVersion() {

      return buildJavaVersion;

   }

   /**

    * Blocks until a key on the keyboard is hit.

    * Consumes multiple hits (for Windows DOS box)

    * @param str If not null it will be printed on console with System.out

    * @return The int pressed (for example 49 for '1')

    */

   public static int waitOnKeyboardHit(String str) {

      if (str != null) {

         System.out.println(str);

      }

      int ret = 0;

      try {

         ret = System.in.read();

         int num = System.in.available();

         for(int i=0; i<num; i++)

            System.in.read();

      } catch(java.io.IOException e) {}

      return ret;

   }

   /**

    * Our identifier, the cluster node we want connect to

    */

   protected void initId() {

      this.id = getProperty().get("server.node.id", (String)null);

      if (this.id == null)

         this.id = getProperty().get("cluster.node.id", "xmlBlaster");  // fallback

      if (this.id == null && getBootstrapAddress().getBootstrapPort() > 0) {

         this.id = getBootstrapAddress().getBootstrapHostname() + ":" + getBootstrapAddress().getBootstrapPort();

      }

   }

   protected void shallowCopy(org.xmlBlaster.util.Global utilGlob)

   {

      this.ip_addr = utilGlob.ip_addr;

      this.id = utilGlob.id;

      this.property = utilGlob.property;

      this.errorText = utilGlob.errorText;

      this.cbHostname =  utilGlob.cbHostname;

      this.nativeCallbackDriverMap = utilGlob.nativeCallbackDriverMap;

      this.objectMap = utilGlob.objectMap;

      this.bootstrapAddress = utilGlob.bootstrapAddress;

      this.clientSecurityLoader = utilGlob.clientSecurityLoader;

      this.logChannels = utilGlob.logChannels;

   }

   /**

    * private, called from constructor

    * @param args arguments to initilize the property with.

    * @param loadPropFile if loading of xmlBlaster.properties

    *        file should be done, if false no loading of the file is done.

    * @return -1 on error

    * @exception If no Property instance can be created

    */

   private int initProps(String[] args, boolean loadPropFile, boolean doReplace) {

      if (property == null) {

         synchronized (Property.class) {

            if (property == null) {

               try {

                  if (loadPropFile)

                     property = new Property("xmlBlaster.properties", true, args, doReplace);

                  else

                     property = new Property(null, true, args, doReplace);

               }

               catch (XmlBlasterException e) {

                  errorText = ME + ": Error in xmlBlaster.properties: " + e.toString();

                  System.err.println(errorText);

                  try {

                     property = new Property(null, true, args, doReplace);  // initialize without properties file!

                  }

                  catch (XmlBlasterException e2) {

                     errorText = ME + " ERROR: " + e2.toString();

                     System.err.println(errorText);

                     try {

                        property = new Property(null, true, new String[0], doReplace);  // initialize without args

                     }

                     catch (XmlBlasterException e3) {

                        errorText = ME + " ERROR: " + e3.toString();

                        System.err.println(errorText);

                        e3.printStackTrace();

                        throw new IllegalArgumentException("Can't create Property instance: " + errorText);

                     }

                  }

                  return -1;

               }

            }

         }

      }

      return 0;

   }

   /**

    * Configure JDK 1.4 java.util.logging (only once per JVM-Classloader, multiple Global instances share the same).

    * </p>

    * Switch off xmlBlaster specific logging:

    * <pre>

    * xmlBlaster/java.util.logging=false

    * </pre>

    * </p>

    * Lookup a specific logging.properties:

    * <pre>

    * java.util.logging.config.file=logging.properties

    * </pre>

    * @return The used configuration file (can be used for user notification) or null

    * @throws XmlBlasterException if redirection fails

    */

   private URL initLogManager(String[] args) throws XmlBlasterException {

      if (args == null) return null;

      if (logIsInitialized) return null;

      final String propertyName = "java.util.logging.config.file";

      if ("false".equals(getProperty().get("xmlBlaster/java.util.logging", (String)null))) {

         logIsInitialized = true;

         System.out.println("Switched off logging configuration with 'xmlBlaster/java.util.logging=false'");

         return null;

      }

      FileLocator fl = new FileLocator(this);

      URL url = fl.findFileInXmlBlasterSearchPath(propertyName, "logging.properties");

      if (url == null) {

         throw new XmlBlasterException(this, ErrorCode.RESOURCE_CONFIGURATION,

         "Global", "Can't find java.util.logging.config.file=logging.properties");

      }

      try {

         InputStream in = url.openStream();

         LogManager logManager = LogManager.getLogManager();

         logManager.readConfiguration(in);

         in.close();

         // init from command line (or xmlBlaster.properties)

         synchronized (Global.class) {

            if (!logIsInitialized) {

               Map map = this.property.getPropertiesForContextNode(this.contextNode, ContextNode.LOGGING_MARKER_TAG, "__default");

               String defVal = (String)map.get("__default");

               if (defVal != null) {

                  try {

                     Level defaultLevel = Level.parse(defVal);

                     Logger defLogger = logManager.getLogger("");

                     if (defLogger != null) {

                        defLogger.setLevel(defaultLevel);

                        log.info("Setting default log level to '" + defaultLevel.getName() + "'");

                     }

                     else

                        log.warning("Setting default log level to '" + defaultLevel.getName() + "' failed since default log level is null");

                  }

                  catch (Throwable ex) {

                     log.warning("An exception occured when parsing '" + defVal + "' as a log level");

                  }

               }

               Iterator iter = map.entrySet().iterator();

               Logger defLogger = logManager.getLogger("");

               // Handler[] tmpHandlers = defLogger.getHandlers();

               // Handler[] refHandlers = new Handler[tmpHandlers.length];

               Handler[] refHandlers = defLogger.getHandlers();

               for (int i=0; i < refHandlers.length; i++) {

                  refHandlers[i].setLevel(Level.FINEST);

                  Formatter formatter = refHandlers[i].getFormatter();

                  if (formatter instanceof XbFormatter) {

                     XbFormatter xb = (XbFormatter)formatter;

                     xb.setGlobal(this);

                  }

               }

               while (iter.hasNext()) {

                  Map.Entry entry = (Map.Entry)iter.next();

                  String key = (String)entry.getKey();

                  String val = (String)entry.getValue();

                  try {

                     Level level = Level.parse(val);

                     Logger tmpLogger = Logger.getLogger(key);

                     if (tmpLogger != null) {

                        tmpLogger.setLevel(level);

                        tmpLogger.setUseParentHandlers(false);

                        for (int i=0; i < refHandlers.length; i++) {

                           // handlers[i].setLevel(level);

                           tmpLogger.addHandler(refHandlers[i]);

                        }

                        log.info("Setting log level for '" + key + "' to '" + level.getName() + "'");

                     }

                     else

                        log.info("Setting log level for '" + key + "' to '" + level.getName() + "' failed since logger was null");

                  }

                  catch (Throwable ex) {

                     log.warning("An exception occured when parsing '" + val + "' as a log level for '" + key + "'");

                  }

               }

               logIsInitialized = true;

            }

         }

         return url;

      }

      catch (Exception e) {

         throw new XmlBlasterException(this, ErrorCode.RESOURCE_CONFIGURATION,

                   "Global.initLogManager", url.toString(), e);

      }

   }

   /**

    * Get the current loglevel.

    *

    * @param loggerName e.g. "logging" or "/node/heron/logging/org.xmlBlaster.util.Timestamp"

    * @return The logging level, for example "WARNING" or "FINE"

    */

    public Level getLogLevel(String loggerName) throws XmlBlasterException {

       if (loggerName == null || loggerName.length() < 1)

          throw new XmlBlasterException(this, ErrorCode.USER_CONFIGURATION, ME, "Illegal loglevel syntax '" + loggerName + "'");

       if (log != null) log.fine("Please implement me");

       return Level.INFO;

       try {

          int start = loggerName.indexOf("[");

          if (start == -1) {

             start = loggerName.indexOf("/"); // JMX interpretes [ as index, so we use info/core syntax there

          }

          if (start != -1) { // Syntax is for example "info[core]"

             int end = loggerName.indexOf("]");

             if (end == -1 ) {

                end = loggerName.length();    // info/auth

             }

             if (start < 1 || end == -1 || end <= (start+1)) {

                throw new XmlBlasterException(this, ErrorCode.USER_CONFIGURATION, ME, "Illegal loglevel syntax '" + loggerName + "'");

             }

             String key = loggerName.substring(start+1, end);

             Object obj = logChannels.get(key);

             if (obj == null)

                throw new XmlBlasterException(this, ErrorCode.USER_CONFIGURATION, ME, "LogChannel '" + key + "' is not known");

             LogChannel log = (LogChannel)obj;

             return log.isLoglevelEnabled(loggerName.substring(0, start));

          }

          return logDefault.isLoglevelEnabled(loggerName);

       }

       catch (JUtilsException e) {

          throw new XmlBlasterException(this, ErrorCode.INTERNAL_UNKNOWN, ME, "", e);

       }

*/

    }

    /**

     * Changes the given logger to given level.

     * @param loggerName e.g. "logging" or "logging/org.xmlBlaster.util.StopWatch"

     * @param level For example "FINE"

     * @return The set level

     * @exception XmlBlasterException if your bool is strange

     */

   public Level changeLogLevel(String loggerName, Level level) throws XmlBlasterException {

      Logger logger = Logger.getLogger(loggerName);

      logger.setLevel(level);

      return level;

   }

   /**

    * Calls init(String[] args), the props keys have no leading "-".

    * @return 1 Show usage, 0 OK, -1 error

    */

   public int init(Map props) {

      return init(Property.propsToArgs(props));

   }

   /**

    * The args key needs a leading "-".

    * @return 1 Show usage, 0 OK, -1 error

    */

   public int init(String[] args)

   {

      args = (args==null) ? new String[0] : args;

      if (args.length > 0) {

         this.bootstrapAddress = null;   // clear cached address

         // shutdownHttpServer(); Should be done as well if address changes?

      }

      try {

         property.addArgs2Props(args);

         initId();

         try { // since JKD 1.4:

            URL url = initLogManager(args);

            if (url != null)

               log.info("Configuring JDK 1.4 logging with configuration '" + url.toString() + "'");

         }

         catch (XmlBlasterException e) {

            System.err.println("Configuring JDK 1.4 logging output failed: " + e.toString());

         }

         return property.wantsHelp() ? 1 : 0;

      }

      catch (XmlBlasterException e) {

         errorText = ME + " ERROR: " + e.toString();

         System.err.println(errorText); // Log probably not initialized yet.

         return -1;

      }

   }

   /**

    * Allows you to query if user wants help.

    * @return true If '-help' or '-?' was passed to us

    */

   public final boolean wantsHelp() {

      return property.wantsHelp();

   }

   /**

    * @return If not null there was an error during construction / initialization

    */

   public String getErrorText() {

      return this.errorText;

   }

   /**

    * @return 1 Show usage, 0 OK

    */

   public int init(java.applet.Applet applet) {

      property.setApplet(applet);

      return property.wantsHelp() ? 1 : 0;

   }

   /**

    * The unique name of this instance.

    * @return Can be null during startup

    */

   public ContextNode getContextNode() {

      return this.contextNode;

   }

   /**

    * The unique name of this instance.

    * @param contextNode The new node id

    */

   public void setContextNode(ContextNode contextNode) {

      this.contextNode = contextNode;

   }

   /**

    * Helper for the time being to be used on client side by

    * services like SmtpClient.

    * Is filled by XmlBlasterAccess with for example "/node/heron/client/joe/session/1"

    * @return

    */

   public ContextNode getScopeContextNode() {

      if (this.scopeContextNode == null) return getContextNode();

      return this.scopeContextNode;

   }

   public void setScopeContextNode(ContextNode contextNode) {

      this.scopeContextNode = contextNode;

   }

   /**

    * Check where we are, on client or on server side?

    * engine.Global overwrites this

    * @return false As we are util.Global and running client side

    */

   public boolean isServerSide() {

      return false;

   }

   /**

    * @return null on client side

    */

   public NodeId getNodeId() {

      return null;

   }

   /**

    * Access the unique local id (as a String),

    * on client side typically the loginName with the public sessionId,

    * on server side the server instance unique id.

    * @return ""

    */

   public String getId() {

      return this.id;

   }

   /**

    * Same as getId() but all 'special characters' are stripped

    * so you can use it for file names.

    * @return ""

    */

   public String getStrippedId() {

      return getStrippedString(getId());

   }

  

   /**

    * @return for XBSTORE.XBNODE, typically the cluster.node.id

    */

   public String getDatabaseNodeStr() {

      return getStrippedId();

   }

  

   /**

    * Utility method to strip any string, all characters which prevent

    * to be used for e.g. file names are replaced.

    * <p>

    * This conversion is used for file names and for the administrative

    * hierarchy e.g. "/node/heron/client/joe" is OK but 'http://xy:8080' instead of 'heron' is not

    * </p>

    * @param text e.g. "http://www.xmlBlaster.org:/home\\x"

    * @return e.g. "http_www_xmlBlaster_org_homex"

    */

   public static final String getStrippedString(String text) {

      if (text == null) return null;

      String strippedId = ReplaceVariable.replaceAll(text, "/", "");

      // JMX does not like commas, but we can't introduce this change in 1.0.5

      // as the persistent queue names would change and this is not backward compatible

      //strippedId = ReplaceVariable.replaceAll(strippedId, ",", "_");

      strippedId = ReplaceVariable.replaceAll(strippedId, " ", "_");

      strippedId = ReplaceVariable.replaceAll(strippedId, ".", "_");

      strippedId = ReplaceVariable.replaceAll(strippedId, ":", "_");

      strippedId = ReplaceVariable.replaceAll(strippedId, "[", "_");

      strippedId = ReplaceVariable.replaceAll(strippedId, "]", "_");

      return ReplaceVariable.replaceAll(strippedId, "\\", "");

   }

   /**

    * @see org.xmlBlaster.util.admin.extern.JmxWrapper#validateJmxValue(String)

    */

   public final String validateJmxValue(String value) {

      return JmxWrapper.validateJmxValue(value);

   }

   /**

    * Currently set by enging.Global, used server side only.

    * @param a unique id

    */

   public synchronized void setId(String id) {

      if (id == null) return;

      this.id = id;

      if (getStrippedId() == null) return;

      if (this.contextNode == null) {

         String instanceName = validateJmxValue(getStrippedId());

         this.contextNode = new ContextNode(ContextNode.CLUSTER_MARKER_TAG, instanceName, ContextNode.ROOT_NODE);

      }

      else {

         this.contextNode.setInstanceName(getStrippedId());

      }

   }

   /**

    * Is coded in derived engine.Global

    */

   public String getLogPrefixDashed() {

      return "";

   }

   /**

    * Is coded in derived engine.Global

    */

   public String getLogPrefix() {

      return "";

   }

   /**

    * Global access to the default 'global' instance.

    * If you have parameters (e.g. from the main() mehtod) you should

    * initialize Global first before using instance():

    * <pre>

    *    public static void main(String[] args) {

    *       new Global(args);

    *       ...

    *    }

    *

    *    //later you can get this initialized instance with:

    *    Global glob = Global.instance();

    *    ...

    * </pre>

    * <p>

    * Note that you should avoid to use Global.instance() and preferably

    * use the global which describes your current context, e.g. the specific

    * client connection like xmlBlasterAccess.getGlobal().

    * Use global.getClone(String[]) to create a new Global instance.

    * </p>