1  /*
     2   * Licensed to the Apache Software Foundation (ASF) under one or more
     3   *  contributor license agreements.  The ASF licenses this file to You
     4   * under the Apache License, Version 2.0 (the "License"); you may not
     5   * use this file except in compliance with the License.
     6   * You may obtain a copy of the License at
     7   *
     8   *     http://www.apache.org/licenses/LICENSE-2.0
     9   *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.  For additional information regarding
    15   * copyright in this work, please see the NOTICE file in the top level
    16   * directory of this distribution.
    17   */
    18  
    19  package org.apache.roller.weblogger.business.startup;
    20  
    21  import java.util.List;
    22  import org.apache.commons.logging.Log;
    23  import org.apache.commons.logging.LogFactory;
    24  import org.apache.roller.weblogger.business.DatabaseProvider;
    25  import org.apache.roller.weblogger.business.MailProvider;
    26  import org.apache.roller.weblogger.config.WebloggerConfig;
    27  
    28  
    29  /**
    30   * Manages Roller Weblogger startup process.
    31   */
    32  public final class WebloggerStartup {
    33      
             /* 
    P/P       *  Method: org.apache.roller.weblogger.business.startup.WebloggerStartup__static_init
              * 
              *  Postconditions:
              *    dbInstaller == null
              *    dbProvider == null
              *    dbProviderException == null
              *    mailProvider == null
              *    init'ed(log)
              *    prepared == 0
              */
    34      private static final Log log = LogFactory.getLog(WebloggerStartup.class);
    35      
    36      private static boolean prepared = false;
    37      
    38      private static DatabaseProvider dbProvider = null;
    39      private static StartupException dbProviderException = null;
    40      
    41      private static MailProvider mailProvider = null;
    42      
    43      private static DatabaseInstaller dbInstaller = null;
    44      
    45      
    46      // non-instantiable
             /* 
    P/P       *  Method: void org.apache.roller.weblogger.business.startup.WebloggerStartup()
              */
    47      private WebloggerStartup() {}
    48      
    49      
    50      /**
    51       * Is the Roller Weblogger app properly prepared to be bootstrapped?
    52       */
    53      public static boolean isPrepared() {
                 /* 
    P/P           *  Method: bool isPrepared()
                  * 
                  *  Preconditions:
                  *    init'ed(prepared)
                  * 
                  *  Postconditions:
                  *    return_value == prepared
                  *    init'ed(return_value)
                  */
    54          return prepared;
    55      }
    56      
    57      
    58      /**
    59       * Get a reference to the currently configured DatabaseProvider.
    60       *
    61       * @return DatabaseProvider The configured database provider.
    62       * @throws IllegalStateException If the app has not been properly prepared yet.
    63       */
    64      public static DatabaseProvider getDatabaseProvider() {
                 /* 
    P/P           *  Method: DatabaseProvider getDatabaseProvider()
                  * 
                  *  Preconditions:
                  *    dbProvider != null
                  * 
                  *  Postconditions:
                  *    return_value == dbProvider
                  *    return_value != null
                  */
    65          if (dbProvider == null) {
    66              throw new IllegalStateException("Roller Weblogger has not been prepared yet");
    67          }
    68          return dbProvider;
    69      }
    70      
    71      
    72      /**
    73       * Get a reference to the exception thrown while instantiating the 
    74       * database provider, if any.
    75       *
    76       * @return StartupException Exception from db provider, or null if no exception thrown.
    77       */
    78      public static StartupException getDatabaseProviderException() {
                 /* 
    P/P           *  Method: StartupException getDatabaseProviderException()
                  * 
                  *  Preconditions:
                  *    init'ed(dbProviderException)
                  * 
                  *  Postconditions:
                  *    return_value == dbProviderException
                  *    init'ed(return_value)
                  */
    79          return dbProviderException;
    80      }
    81      
    82      
    83      /**
    84       * Get a reference to the currently configured MailProvider, if available.
    85       *
    86       * @return MailProvider The configured mail provider, or null if none configured.
    87       */
    88      public static MailProvider getMailProvider() {
                 /* 
    P/P           *  Method: MailProvider getMailProvider()
                  * 
                  *  Preconditions:
                  *    init'ed(mailProvider)
                  * 
                  *  Postconditions:
                  *    return_value == mailProvider
                  *    init'ed(return_value)
                  */
    89          return mailProvider;
    90      }
    91      
    92      
    93      /**
    94       * Does the app need to create the database tables?
    95       */
    96      public static boolean isDatabaseCreationRequired() {
                 /* 
    P/P           *  Method: bool isDatabaseCreationRequired()
                  * 
                  *  Preconditions:
                  *    dbProvider != null
                  *    init'ed(dbProvider.type)
                  *    (soft) dbProvider.dataSource != null
                  *    (soft) init'ed(dbProvider.jdbcConnectionURL)
                  *    (soft) dbProvider.props != null
                  *    (soft) dbProvider.props._tainted == 0
                  *    (soft) org/apache/roller/weblogger/business/startup/DatabaseInstaller.log != null
                  * 
                  *  Postconditions:
                  *    init'ed(return_value)
                  */
    97          return getDatabaseInstaller().isCreationRequired();
    98      }
    99      
   100      
   101      /**
   102       * Run database creation scripts.
   103       */
   104      public static List<String> createDatabase() throws StartupException {
   105          
                 /* 
    P/P           *  Method: List createDatabase()
                  * 
                  *  Preconditions:
                  *    dbProvider != null
                  *    init'ed(dbProvider.type)
                  *    org/apache/roller/weblogger/business/startup/SQLScriptRunner.log != null
                  *    (soft) dbProvider.dataSource != null
                  *    (soft) init'ed(dbProvider.jdbcConnectionURL)
                  *    (soft) dbProvider.props != null
                  *    (soft) dbProvider.props._tainted == 0
                  *    (soft) org/apache/roller/weblogger/business/startup/DatabaseInstaller.log != null
                  * 
                  *  Presumptions:
                  *    java.util.Properties:getProperty(...)@65 != null
                  * 
                  *  Postconditions:
                  *    prepared == 1
                  *    return_value == &new ArrayList(DatabaseInstaller#1)
                  *    new ArrayList(DatabaseInstaller#1) num objects == 1
                  */
   106          DatabaseInstaller installer = getDatabaseInstaller();
   107          try {
   108              installer.createDatabase();
   109              
   110              // any time we've successfully installed a db we are prepared
   111              prepared = true;
   112              
   113          } catch (StartupException se) {
   114              throw new StartupException(se.getMessage(), se.getRootCause(), installer.getMessages());
   115          }
   116          
   117          return installer.getMessages();
   118      }
   119      
   120      
   121      /**
   122       * Does the app require any upgrading?
   123       */
   124      public static boolean isDatabaseUpgradeRequired() {
                 /* 
    P/P           *  Method: bool isDatabaseUpgradeRequired()
                  * 
                  *  Preconditions:
                  *    dbProvider != null
                  *    (soft) dbProvider.dataSource != null
                  *    (soft) init'ed(dbProvider.jdbcConnectionURL)
                  *    (soft) dbProvider.props != null
                  *    (soft) dbProvider.props._tainted == 0
                  *    (soft) init'ed(dbProvider.type)
                  *    (soft) org/apache/roller/weblogger/business/startup/DatabaseInstaller.log != null
                  * 
                  *  Presumptions:
                  *    java.util.Properties:getProperty(...)@65 != null
                  * 
                  *  Postconditions:
                  *    init'ed(return_value)
                  */
   125          return getDatabaseInstaller().isUpgradeRequired();
   126      }
   127      
   128      
   129      /**
   130       * Run database upgrade work, optionally including upgrade scripts.
   131       */
   132      public static List<String> upgradeDatabase(boolean runScripts) 
   133              throws StartupException {
   134          
                 /* 
    P/P           *  Method: List upgradeDatabase(bool)
                  * 
                  *  Preconditions:
                  *    dbProvider != null
                  *    (soft) dbProvider.dataSource != null
                  *    (soft) init'ed(dbProvider.jdbcConnectionURL)
                  *    (soft) dbProvider.props != null
                  *    (soft) dbProvider.props._tainted == 0
                  *    (soft) init'ed(dbProvider.type)
                  *    (soft) org/apache/roller/weblogger/business/startup/DatabaseInstaller.log != null
                  *    (soft) org/apache/roller/weblogger/business/startup/SQLScriptRunner.log != null
                  * 
                  *  Presumptions:
                  *    java.util.Properties:getProperty(...)@65 != null
                  * 
                  *  Postconditions:
                  *    prepared == 1
                  *    return_value == &new ArrayList(DatabaseInstaller#1)
                  *    new ArrayList(DatabaseInstaller#1) num objects == 1
                  */
   135          DatabaseInstaller installer = getDatabaseInstaller();
   136          try {
   137              installer.upgradeDatabase(true);
   138              
   139              // any time we've successfully upgraded a db we are prepared
   140              prepared = true;
   141              
   142          } catch (StartupException se) {
   143              throw new StartupException(se.getMessage(), se.getRootCause(), installer.getMessages());
   144          }
   145          
   146          return installer.getMessages();
   147      }
   148      
   149      
   150      /**
   151       * Get a database installer.
   152       *
   153       * @return DatabaseInstaller A database installer.
   154       * @throws IllegalStateException If the database provider has not been properly setup yet.
   155       */
   156      private static DatabaseInstaller getDatabaseInstaller() {
                 /* 
    P/P           *  Method: DatabaseInstaller getDatabaseInstaller()
                  * 
                  *  Preconditions:
                  *    dbProvider != null
                  *    (soft) org/apache/roller/weblogger/business/startup/DatabaseInstaller.log != null
                  * 
                  *  Postconditions:
                  *    return_value == &new DatabaseInstaller(getDatabaseInstaller#1)
                  *    new ArrayList(DatabaseInstaller#1) num objects == 1
                  *    new ClasspathDatabaseScriptProvider(getDatabaseInstaller#2) num objects == 1
                  *    new DatabaseInstaller(getDatabaseInstaller#1) num objects == 1
                  *    return_value.db == dbProvider
                  *    return_value.db != null
                  *    return_value.messages == &new ArrayList(DatabaseInstaller#1)
                  *    return_value.scripts == &new ClasspathDatabaseScriptProvider(getDatabaseInstaller#2)
                  *    init'ed(return_value.version)
                  */
   157          return new DatabaseInstaller(getDatabaseProvider(), new ClasspathDatabaseScriptProvider());
   158      }
   159      
   160      
   161      /**
   162       * Run the Roller Weblogger preparation sequence.
   163       *
   164       * This sequence is what prepares the core services of the application such
   165       * as setting up the database and mail providers.
   166       */
   167      public static void prepare() throws StartupException {
   168          
   169          // setup database provider
   170          try {
                     /* 
    P/P               *  Method: void prepare()
                      * 
                      *  Preconditions:
                      *    org/apache/roller/weblogger/business/DatabaseProvider.log != null
                      *    org/apache/roller/weblogger/config/WebloggerConfig.config != null
                      *    org/apache/roller/weblogger/config/WebloggerConfig.log != null
                      *    (soft) dbProvider.props._tainted == 0
                      *    (soft) org/apache/roller/weblogger/business/startup/DatabaseInstaller.log != null
                      *    (soft) org/apache/roller/weblogger/business/startup/SQLScriptRunner.log != null
                      * 
                      *  Presumptions:
                      *    java.util.Properties:getProperty(...)@65 != null
                      *    org.apache.commons.logging.LogFactory:getLog(...)@34 != null
                      * 
                      *  Postconditions:
                      *    dbProvider == &new DatabaseProvider(prepare#1)
                      *    dbProviderException == old dbProviderException
                      *    mailProvider == One-of{&new MailProvider(prepare#2), old mailProvider}
                      *    possibly_updated(prepared)
                      *    new ArrayList(DatabaseProvider#1) num objects == 1
                      *    new DatabaseProvider(prepare#1) num objects == 1
                      *    new DatabaseProvider(prepare#1).dataSource != null
                      *    init'ed(new DatabaseProvider(prepare#1).jdbcConnectionURL)
                      *    init'ed(new DatabaseProvider(prepare#1).jdbcDriverClass)
                      *    init'ed(new DatabaseProvider(prepare#1).jdbcPassword)
                      *    ...
                      * 
                      *  Test Vectors:
                      *    java.lang.String:equals(...)@186: {0}, {1}
                      */
   171              dbProvider = new DatabaseProvider();
   172          } catch(StartupException ex) {
   173              dbProviderException = ex;
   174              throw ex;
   175          }
   176          
   177          // setup mail provider, if configured
   178          try {
   179              mailProvider = new MailProvider();
   180          } catch(StartupException ex) {
   181              log.warn("Failed to setup mail provider, continuing anways.\n"+
   182                      "Reason: "+ex.getMessage(), ex);
   183          }
   184          
   185          // now we need to deal with database install/upgrade logic
   186          if("manual".equals(WebloggerConfig.getProperty("installation.type"))) {
   187              
   188              // if we are doing manual install then all that is needed is the
   189              // app handled database upgrade work, not the db scripts
   190              DatabaseInstaller dbInstaller = getDatabaseInstaller();
   191              if(dbInstaller.isUpgradeRequired()) {
   192                  dbInstaller.upgradeDatabase(false);
   193              }
   194              
   195              prepared = true;
   196              
   197          } else {
   198              
   199              // we are in auto install mode, so see if there is any work to do
   200              DatabaseInstaller dbInstaller = getDatabaseInstaller();
   201              if(!dbInstaller.isCreationRequired() && 
   202                      !dbInstaller.isUpgradeRequired()) {
   203                  prepared = true;
   204              }
   205          }
   206          
   207      }
   208      
   209  }