Derby - Class org.apache.derby.impl.services.monitor.BaseMonitor

   Licensed to the Apache Software Foundation (ASF) under one or more

   contributor license agreements.  See the NOTICE file distributed with

   this work for additional information regarding copyright ownership.

   The ASF licenses this file to you under the Apache License, Version 2.0

   (the "License"); you may not use this file except in compliance with

   the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software

   distributed under the License is distributed on an "AS IS" BASIS,

   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

   See the License for the specific language governing permissions and

   limitations under the License.

*/

  Implementation of the monitor that uses the class loader

  that the its was loaded in for all class loading.

*/

  implements ModuleFactory, BundleFinder {

  /* Fields */

  /**

    Hash table of objects that implement PersistentService keyed by their getType() method.

  */

  private HashMap serviceProviders = new HashMap();

  // Vector of class objects of implementations, found in the System, application

  // and default (modules.properties) properties

  Vector[]     implementationSets;

  private Vector    services;          // Vector of TopServices

  Properties bootProperties;    // specifc properties provided by the boot method, override everything else

  Properties applicationProperties;

  boolean inShutdown;

  // Here are the list of modules that we always boot

  private InfoStreams systemStreams;

  private ContextService contextService;

  private UUIDFactory uuidFactory;

    private TimerFactory timerFactory;

  boolean reportOn;

  private PrintStream logging;

  ThreadGroup daemonGroup;

  // anti GC stuff

  AntiGC dontGC;

  // class registry

  private InstanceGetter[]  rc1;

*/

  private InstanceGetter[]  rc2;

  /* Constructor  */

  BaseMonitor() {

    super();

    services = new Vector(0, 1);

    services.addElement(new TopService(this));  // first element is always the free-floating service

  }

  /* Methods of ModuleFactory includes BootStrap and Runnable */

  public InfoStreams getSystemStreams() {

    return systemStreams;

  }

  public void shutdown() {

    // allow only one caller to shut the monitor down

    synchronized (this) {

      if (inShutdown)

        return;

      inShutdown = true;

    }

    if (SanityManager.DEBUG && reportOn) {

      report("Shutdown request");

    }

    // Shutdown all threads by iterrupting them

    contextService.notifyAllActiveThreads((Context) null);

    for (;;) {

      TopService ts;

      int position;

      synchronized (this) {

        position = services.size()  - 1;

        if (position == 0)

          break;

        ts = (TopService) services.elementAt(position);

      }

      // push a new context manager

      ContextManager cm = contextService.newContextManager();

      try {

        // pop the default shutdown context, we are shutting down

        cm.popContext();

        contextService.setCurrentContextManager(cm);

        shutdown(ts.getService());

      } finally {

        contextService.resetCurrentContextManager(cm);

      }

    }

    ((TopService) services.elementAt(0)).shutdown();

    synchronized (dontGC) {

      dontGC.goAway = true;

      dontGC.notifyAll();

    }

    ContextService.stop();

    Monitor.clearMonitor();

  }

  /**

    Shut down a service that was started by this Monitor. Will

    cause the stop() method to be called on each loaded module.

  */

  public void shutdown(Object serviceModule) {

    if (serviceModule == null)

      return;

    TopService ts = findTopService(serviceModule);

    if (ts == null)

      return;

    // shutdown() returns false if the service is already being shutdown

    boolean removeService = true;

    try {

      removeService = ts.shutdown();

    } finally {

      synchronized (this) {

        if (removeService) {

          boolean found = services.removeElement(ts);

          if (SanityManager.DEBUG) {

            SanityManager.ASSERT(found, "service was not found " + serviceModule);

          }

        }

      }

    }

  }

  protected final void runWithState(Properties properties, PrintStream log) {

    bootProperties = properties;

    logging = log;

    // false indicates the full monitor is required, not the lite.

    if (!initialize(false))

      return;

    // if monitor is already set then the system is already

    // booted or in the process of booting or shutting down.

    if (!Monitor.setMonitor(this))

      return;

    Object msgService = MessageService.setFinder(this);

    // start a backgorund thread which keeps a reference to this

    // this monitor, and an instance of the Monitor class to ensure

    // that the monitor instance and the class is not garbage collected

    // See Sun's bug 4057924 in Java Developer Section 97/08/06

    Object[] keepItems = new Object[3];

    keepItems[0] = this;

    keepItems[1] = new Monitor();

    keepItems[2] = msgService;

    dontGC = new AntiGC(keepItems);

    Thread dontGCthread = getDaemonThread(dontGC, "antiGC", true);

    dontGCthread.start();

    if (SanityManager.DEBUG) {

      reportOn = Boolean.valueOf(PropertyUtil.getSystemProperty("derby.monitor.verbose")).booleanValue();

    }

    // Set up the application properties

    applicationProperties = readApplicationProperties();

    // The security manager may not let us get the System properties

    // object itself, although it may let us look at the properties in it.

    Properties systemProperties = null;

    if (SanityManager.DEBUG) {

      // In a production system having this call would

      // mean would we have to document it for security

      // permission reasons. Since we don't require it and

      // its a big security hole to allow external code to

      // overwrite our own implementations we just support

      // it for debugging. This means VM executions such as

      // java -Dderby.module.javaCompiler=com.ibm.db2j.impl.BasicServices.JavaCompiler.JavaLang.JLJava ...

      // would only work with a sane codeline.

      try {

        systemProperties = System.getProperties();

      } catch (SecurityException se) {

      }

    }

    Vector bootImplementations = getImplementations(bootProperties, false);

    Vector systemImplementations = null;

    Vector applicationImplementations = null;

    // TEMP - making this sanity only breaks the unit test code

    // I will fix soon, djd.

    if (true || SanityManager.DEBUG) {

      // Don't allow external code to override our implementations.

      systemImplementations = getImplementations(systemProperties, false);

      applicationImplementations = getImplementations(applicationProperties, false);

    }

    Vector defaultImplementations = getDefaultImplementations();

    int implementationCount = 0;

    if (bootImplementations != null)

      implementationCount++;

    // TEMP - making this sanity only breaks the unit test code

    if (true || SanityManager.DEBUG) {

      // Don't allow external code to override our implementations.

      if (systemImplementations != null)

        implementationCount++;

      if (applicationImplementations != null)

        implementationCount++;

    }

    if (defaultImplementations != null)

      implementationCount++;

    implementationSets = new Vector[implementationCount];

    implementationCount = 0;

    if (bootImplementations != null)

      implementationSets[implementationCount++] = bootImplementations;

   

    if (true || SanityManager.DEBUG) {

      // Don't allow external code to override our implementations.

      if (systemImplementations != null)

        implementationSets[implementationCount++] = systemImplementations;

      if (applicationImplementations != null)

        implementationSets[implementationCount++] = applicationImplementations;

    }

    if (defaultImplementations != null)

      implementationSets[implementationCount++] = defaultImplementations;

    if (SanityManager.DEBUG) {

      // Look for the derby.debug.* properties.

      if (applicationProperties != null) {

        addDebugFlags(applicationProperties.getProperty(Monitor.DEBUG_FALSE), false);

        addDebugFlags(applicationProperties.getProperty(Monitor.DEBUG_TRUE), true);

      }

      addDebugFlags(PropertyUtil.getSystemProperty(Monitor.DEBUG_FALSE), false);

      addDebugFlags(PropertyUtil.getSystemProperty(Monitor.DEBUG_TRUE), true);

    }

    try {

      systemStreams = (InfoStreams) Monitor.startSystemModule("org.apache.derby.iapi.services.stream.InfoStreams");

      if (SanityManager.DEBUG) {

        SanityManager.SET_DEBUG_STREAM(systemStreams.stream().getPrintWriter());

      }

      contextService = new ContextService();

      uuidFactory = (UUIDFactory) Monitor.startSystemModule("org.apache.derby.iapi.services.uuid.UUIDFactory");

            timerFactory = (TimerFactory)Monitor.startSystemModule("org.apache.derby.iapi.services.timer.TimerFactory");

    } catch (StandardException se) {

      // if we can't create an error log or a context then there's no point going on

      reportException(se);

      // dump any messages we have been saving ...

      dumpTempWriter(true);

      return;

    }

    // switch cover to the real error stream and

    // dump any messages we have been saving ...

    dumpTempWriter(false);

    if (SanityManager.DEBUG && reportOn) {

      dumpProperties("-- Boot Properties --", bootProperties);

      dumpProperties("-- System Properties --", systemProperties);

      dumpProperties("-- Application Properties --", applicationProperties);

    }

    // bootup all the service providers

    determineSupportedServiceProviders();

    // See if automatic booting of persistent services is required

    boolean bootAll = Boolean.valueOf(PropertyUtil.getSystemProperty(Property.BOOT_ALL)).booleanValue();

    startServices(bootProperties, bootAll);

    startServices(systemProperties, bootAll);

    startServices(applicationProperties, bootAll);

    if (bootAll) // only if automatic booting is required

      bootPersistentServices( );

  }

  public Object findService(String factoryInterface, String serviceName) {

    if (serviceName == null)

      return null;

    ProtocolKey key;

    try {

      key = ProtocolKey.create(factoryInterface, serviceName);

    } catch (StandardException se) {

      return null;

    }

    TopService myts = null;

    synchronized (this) {

      for (int i = 1; i < services.size(); i++) {

        TopService ts = (TopService) services.elementAt(i);

        if (ts.isPotentialService(key)) {

          myts = ts;

          break;

        }

      }

    }

    // the isActiveService() call may sleep

    // so don't hold the 'this' synchronization

    if (myts != null) {

      if (myts.isActiveService(key))

        return myts.getService();

    }

    return null;

  }

  public Locale getLocale(Object serviceModule) {

    TopService ts = findTopService(serviceModule);

    if (ts == null)

      return null;

    return ts.serviceLocale;

  }

  public Locale getLocaleFromString(String localeDescription)

                      throws StandardException {

    return staticGetLocaleFromString(localeDescription);

  }

  /**

    Return the name of the service that the passed in module lives in.

  */

  public String getServiceName(Object serviceModule) {

    TopService ts = findTopService(serviceModule);

    if (ts == null)

      return null;

    return ts.getServiceType().getUserServiceName(ts.getKey().getIdentifier());

  }

  /**

    Set the locale for the service *outside* of boot time.

    @exception StandardException Standard Derby error.

  */

  public Locale setLocale(Object serviceModule, String userDefinedLocale)

    throws StandardException {

    TopService ts = findTopService(serviceModule);

    if (ts == null)

      return null;

    PersistentService provider = ts.getServiceType();

    if (provider == null)

      return null;

    String serviceName = ts.getKey().getIdentifier();

    Properties properties = provider.getServiceProperties(serviceName, (Properties) null);

    properties = new UpdateServiceProperties(provider, serviceName, properties, true);

    return setLocale(properties, userDefinedLocale);

  }

  /**

    Set the locale for the service at boot time. The passed in

    properties must be the one passed to the boot method.

    @exception StandardException Standard Derby error.

  */

  public Locale setLocale(Properties serviceProperties, String userDefinedLocale)

    throws StandardException {

    Locale locale = staticGetLocaleFromString(userDefinedLocale);

    // this will write the property through to the service.properties file.

    serviceProperties.put(Property.SERVICE_LOCALE, locale.toString());

    return locale;

  }

  /**

    Return the PersistentService object for a service.

    Will return null if the service does not exist.

  */

  public PersistentService getServiceType(Object serviceModule) {

    TopService ts = findTopService(serviceModule);

    if (ts == null)

      return null;

    return ts.getServiceType();

  }

  /**

    Start a module.

    @exception StandardException se An attempt to start the module failed.

    @see ModuleFactory#startModule

  */

  public Object startModule(boolean create, Object serviceModule, String factoryInterface,

    String identifier, Properties properties) throws StandardException {

    ProtocolKey key = ProtocolKey.create(factoryInterface, identifier);

    TopService ts = findTopService(serviceModule);

    Object instance = ts.bootModule(create, serviceModule, key, properties);

    if (instance == null)

      throw Monitor.missingImplementation(factoryInterface);

    return instance;

  }

  private synchronized TopService findTopService(Object serviceModule) {

    if (serviceModule == null)

      return (TopService) services.elementAt(0);

    for (int i = 1; i < services.size(); i++) {

      TopService ts = (TopService) services.elementAt(i);

      if (ts.inService(serviceModule))

        return ts;

    }

    return null;

  }

  public Object findModule(Object serviceModule, String factoryInterface, String identifier)

  {

    ProtocolKey key;

    try {

      key = ProtocolKey.create(factoryInterface, identifier);

    } catch (StandardException se) {

      return null;

    }

    TopService ts = findTopService(serviceModule);

    if (ts == null)

      return null;

    return ts.findModule(key, true, null);

  }

  /**

    Obtain a class that supports the given identifier.

    @param fmtId identifer to associate with class

    @return a reference InstanceGetter

    @exception StandardException See Monitor.classFromIdentifier

    @see ModuleFactory#classFromIdentifier

  */

  public InstanceGetter classFromIdentifier(int fmtId)

    throws StandardException {

    String className;

    int off;

    InstanceGetter[] iga;

    InstanceGetter ig;

    try {

      off = fmtId - StoredFormatIds.MIN_TWO_BYTE_FORMAT_ID;

      iga = rc2;

      if (iga == null) {

        iga = rc2 = new InstanceGetter[RegisteredFormatIds.TwoByte.length];

      }

      ig = iga[off];

      if (ig != null) {

        return ig;

      }

      className = RegisteredFormatIds.TwoByte[off];

    } catch (ArrayIndexOutOfBoundsException aioobe) {

      className = null;

      iga = null;

      off = 0;

    }

    if (className != null) {

      Throwable t;

      try {

        Class clazz = Class.forName(className);

        // See if it is a FormatableInstanceGetter

        if (FormatableInstanceGetter.class.isAssignableFrom(clazz)) {

          FormatableInstanceGetter tfig = (FormatableInstanceGetter) clazz.newInstance();

          tfig.setFormatId(fmtId);

          return iga[off] = tfig;

        }

        return iga[off] = new ClassInfo(clazz);

      } catch (ClassNotFoundException cnfe) {

        t = cnfe;

      } catch (IllegalAccessException iae) {

        t = iae;

      } catch (InstantiationException ie) {

        t = ie;

      } catch (LinkageError le) {

        t = le;

      }

      throw StandardException.newException(SQLState.REGISTERED_CLASS_LINAKGE_ERROR,

        t, FormatIdUtil.formatIdToString(fmtId), className);

    }

    throw StandardException.newException(SQLState.REGISTERED_CLASS_NONE, FormatIdUtil.formatIdToString(fmtId));

  }

  /**

    Obtain an new instance of a class that supports the given identifier.

    @return a reference to a newly created object or null if a matching class

          cannot be found.

  */

  public Object newInstanceFromIdentifier(int identifier)

    throws StandardException {

    InstanceGetter ci = classFromIdentifier(identifier);

    Throwable t;

    try {

      Object result = ci.getNewInstance();

        if (SanityManager.DEBUG) {

          if(SanityManager.DEBUG_ON(Monitor.NEW_INSTANCE_FROM_ID_TRACE_DEBUG_FLAG))

          {

            String traceResult = "null";

            if (result != null) traceResult = "not null";

            SanityManager.DEBUG(Monitor.NEW_INSTANCE_FROM_ID_TRACE_DEBUG_FLAG,

                      "newInstanceFromIdentifier("+identifier+") "+

                      " ClassName: "+

                      result.getClass().getName() +

                      " returned "+

                      traceResult);

          }

        }

*/

      return result;

    }

    catch (InstantiationException ie) {

      t = ie;

    }

     catch (IllegalAccessException iae) {

      t = iae;

    }

    catch (InvocationTargetException ite) {

      t = ite;

    }

    catch (LinkageError le) {

      t = le;

    }

    throw StandardException.newException(SQLState.REGISTERED_CLASS_INSTANCE_ERROR,

      t, new Integer(identifier), "XX" /*ci.getClassName()*/);

  }

  private Boolean exceptionTrace;

  /**

    load a module instance.

    Look through the implementations for a module that implements the

    required factory interface and can handle the properties given.

    The module's start or create method is not called.

  */

  protected Object loadInstance(Class factoryInterface, Properties properties) {

    Object instance = null;

    Vector localImplementations = getImplementations(properties, false);

    if (localImplementations != null) {

      instance = loadInstance(localImplementations, factoryInterface, properties);

    }

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

      instance = loadInstance(implementationSets[i], factoryInterface, properties);

      if (instance != null)

        break;

    }

    return instance;

  }

  private Object loadInstance(Vector implementations, Class factoryInterface, Properties properties) {

    for (int index = 0; true; index++) {

      // find an implementation

      index = findImplementation(implementations, index, factoryInterface);

      if (index < 0)

        return null;

      // try to create an instance

      Object instance = newInstance((Class) implementations.elementAt(index));

      if (BaseMonitor.canSupport(instance, properties))

        return instance;

    }

  }

  /**

    Find a class that implements the required index, return the index

    into the implementations vecotr of that class. Returns -1 if no class

    could be found.

  */

  private static int findImplementation(Vector implementations, int startIndex, Class factoryInterface) {

    for (int i = startIndex; i < implementations.size(); i++) {

      //try {

        Class factoryClass = (Class) implementations.elementAt(i);

        if (!factoryInterface.isAssignableFrom(factoryClass)) {

          continue;

        }

        return i;

      //}

      //catch (ClassNotFoundException e) {

      //  report("Class not found " + (String) implementations.elementAt(i));

      //  continue;

      //}

    }

    return -1;

  }

  /**

  */

  private Object newInstance(String className) {

    try {

      Class factoryClass = Class.forName(className);

      return factoryClass.newInstance();

    }

    catch (ClassNotFoundException e) {

      report(className + " " + e.toString());

    }

    catch (InstantiationException e) {

      report(className + " " + e.toString());

    }

     catch (IllegalAccessException e) {

      report(className + " " + e.toString());

    }

    catch (LinkageError le) {

      report(className + " " + le.toString());

      reportException(le);

    }

    return null;

  }

  /**

  */

  private Object newInstance(Class classObject) {

    try {

      return classObject.newInstance();

    }

    catch (InstantiationException e) {

      report(classObject.getName() + " " + e.toString());

    }

     catch (IllegalAccessException e) {

      report(classObject.getName() + " " + e.toString());

    }

    catch (LinkageError le) {

      report(classObject.getName() + " " + le.toString());

      reportException(le);

    }

    return null;

  }

  public Properties getApplicationProperties() {

    return applicationProperties;

  }

  /**

    Return an array of the service identifiers that are running and

    implement the passed in protocol (java interface class name).

    @return The list of service names, if no services exist that

    implement the protocol an array with zero elements is returned.

    @see ModuleFactory#getServiceList

  */

  public String[] getServiceList(String protocol) {

    TopService ts;

    synchronized (this) {

      int count = 0;

      // count the number of services that implement the required protocol

      for (int i = 1; i < services.size(); i++) {

        ts = (TopService) services.elementAt(i);

        if (ts.isActiveService()) {

          if (ts.getKey().getFactoryInterface().getName().equals(protocol))

            count++;

        }

      }

      // and then fill in the newly allocated string array

      String[] list = new String[count];

      if (count != 0) {

        int j = 0;

        for (int i = 1; i < services.size(); i++) {

          ts = (TopService) services.elementAt(i);

          if (ts.isActiveService()) {

            if (ts.getKey().getFactoryInterface().getName().equals(protocol)) {

              list[j++] = ts.getServiceType().getUserServiceName(ts.getKey().getIdentifier());

              if (j == count)

                break;

            }

          }

        }

      }

      return list;

    }

  }

  /*

  ** non-public methods.

  */

  void dumpProperties(String title, Properties props) {

    if (SanityManager.DEBUG) {

      // this method is only called if reportOn is true, so no need to check it here

      report(title);

      if (props != null) {

        for (Enumeration e = props.propertyNames(); e.hasMoreElements(); ) {

          String key = (String) e.nextElement();

          // Get property as object in case of non-string properties

          report(key + "=" + props.getProperty(key));

        }

      }

      report("-- end --");

    }

  }

  /**

    Should only be called if reportOn is true

    apart from report/Exception().

  */

  protected void report(String message)  {

    PrintWriter tpw = getTempWriter();

    if (tpw != null)

      tpw.println(message);

    if (systemStreams != null)

      systemStreams.stream().printlnWithHeader(message);

  }

  protected void reportException(Throwable t) {

    PrintWriterGetHeader pwgh = null;

    if (systemStreams != null)

      pwgh = systemStreams.stream().getHeader();

    ErrorStringBuilder esb = new ErrorStringBuilder(pwgh);

    esb.appendln(t.getMessage());

    esb.stackTrace(t);

    report(esb.get().toString());

  }

  private void addDebugFlags(String flags, boolean set) {

    if (SanityManager.DEBUG) {

      if (flags == null)

        return;

      StringTokenizer st = new StringTokenizer(flags, ",");

      for (; st.hasMoreTokens(); ) {

        String flag = st.nextToken();

        if (set)

          SanityManager.DEBUG_SET(flag);

        else

          SanityManager.DEBUG_CLEAR(flag);

      }

    }

  }

  /**

    Look for any services in the a properties set and the application

    property set and then start them.

    A service is defined by derby.service.name=protocol

  */

  private static final String SERVICE = "derby.service.";

  public void startServices(Properties properties, boolean bootAll) {

    if (properties == null)

      return;

    for (Enumeration e = properties.propertyNames(); e.hasMoreElements(); ) {

      String key = (String) e.nextElement();

      if (key.startsWith(SERVICE)) {

        String name = key.substring(SERVICE.length());

        String protocolOrType = properties.getProperty(key);

        try {

          if (protocolOrType.equals(Monitor.SERVICE_TYPE_DIRECTORY)) {

            if (bootAll)  // only if automatic booting is required

              findProviderAndStartService(name, properties, true);

          } else {

            bootService((PersistentService) null,

              protocolOrType, name, (Properties)null, false);

          }

        } catch (StandardException se) {

          // error already in error log, just continue booting

          // for persistent services, but non-persistent ones

          // will not have put the error in the log

          if (!protocolOrType.equals(Monitor.SERVICE_TYPE_DIRECTORY))

            reportException(se);

        }

      }

    }

  }

  /**

    Start a peristent service.

    @see ModuleFactory#startPersistentService

    @see Monitor#startPersistentService

  */

  public final boolean startPersistentService(String name, Properties properties)

    throws StandardException {

    return findProviderAndStartService(name, properties, false);

  }

  /**

    Create a persistent service.

    @return The module from the service if it was created successfully, null if a service already existed.

    @exception StandardException An exception was thrown trying to create the service.

    @see Monitor#createPersistentService

  */

  public Object createPersistentService(String factoryInterface, String name, Properties properties)

    throws StandardException {

    PersistentService provider = findProviderForCreate(name);

    if (provider == null) {

      throw StandardException.newException(SQLState.PROTOCOL_UNKNOWN, name);

    }

    return bootService(provider, factoryInterface, name, properties, true);

  }

    /**

     *  Removes a PersistentService.

     *  Could be used for drop database.

       @param name : Service name to be removed.

      

    */

    public void removePersistentService(String name)

         throws StandardException

    {

        PersistentService provider=null;

    provider = findProviderForCreate(name);

        String serviceName = provider.getCanonicalServiceName(name);

        boolean removed = provider.removeServiceRoot(serviceName);

        if (removed == false)

      throw StandardException.newException(SQLState.SERVICE_DIRECTORY_REMOVE_ERROR,serviceName);

    }

  /**

    Start a non-persistent service.

    @see Monitor#startNonPersistentService

    @see ModuleFactory#startNonPersistentService

  */

  public Object startNonPersistentService(String factoryInterface, String serviceName, Properties properties)

    throws StandardException {

    return bootService((PersistentService) null, factoryInterface, serviceName, properties, false);

  }

  /**

    Create an implementation set.

    Look through the properties object for all properties that

    start with derby.module and add the value into the vector.

    If no implementations are listed in the properties object

    then null is returned.

  */

  private Vector getImplementations(Properties moduleList, boolean actualModuleList) {

    if (moduleList == null)

      return null;

    Vector implementations = actualModuleList ? new Vector(moduleList.size()) : new Vector(0,1);