global.java

java开源的企业总线.xmlBlaster

    * @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) {
      if (property == null) {
         synchronized (Property.class) {
            if (property == null) {
               try {
                  if (loadPropFile)
                     property = new Property("xmlBlaster.properties", true, args, true);
                  else
                     property = new Property(null, true, args, true);
               }
               catch (XmlBlasterException e) {
                  errorText = ME + ": Error in xmlBlaster.properties: " + e.toString();
                  System.err.println(errorText);
                  try {
                     property = new Property(null, true, args, true);  // 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], true);  // 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 + "'");
       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;