Derby - Class org.apache.derby.impl.store.raw.data.BaseDataFileFactory

   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.

*/

Provides the abstract class with most of the implementation of DataFactory and

ModuleControl shared by all the different filesystem implementations.

Currently only getContainerClass() is abstract, there are probably more

routines which should be abstract.  Also the other implementations should

probably inherit from the abstract class, rather than from the DataFileFactory

class.  Also there probably should be a generic directory and the rest of the

filesystem implementations parallel to it.

I wanted to limit the changes going into the branch and then fix

inheritance stuff in main.

that file was made to inherit from this one.

**/

    implements DataFactory, CacheableFactory, ModuleControl, ModuleSupportable, PrivilegedExceptionAction

    StorageFactory storageFactory;

    /* writableStorageFactory == (WritableStorageFactory) storageFactory if

     * storageFactory also implements WritableStorageFactory, null if the

     * storageFactory is read-only.

     */

    WritableStorageFactory writableStorageFactory;

  private     long        nextContainerId = System.currentTimeMillis();

  private     boolean         databaseEncrypted;

  private     CacheManager  pageCache;

  private     CacheManager  containerCache;

  private     LogFactory      logFactory;

  private     ProductVersionHolder jbmsVersion;

 

  private     String          jvmVersion;

 

  private     String          jarCPath;

  private     RawStoreFactory  rawStoreFactory; // associated raw store factory

  private     String      dataDirectory;   // root directory of files.

    private     boolean         throwDBlckException; // if true throw db.lck

                                                 // exception, even on systems

                                                 // where lock file is not

                                                 // guaranteed.

  private     UUID            identifier;      // unique id for locking

  private     Object          freezeSemaphore;

    // is the data store frozen - protected by freezeSemaphore

  private     boolean         isFrozen;      

    // how many writers are currently active in the data store -

    // protected by freezeSemaphore

  private     int             writersInProgress;

  private boolean removeStubsOK;

  private boolean isCorrupt;

    // the database is being created, no logging

  private boolean inCreateNoLog; 

  // lock against other JBMS opening the same database

  private StorageRandomAccessFile fileLockOnDB;

  private StorageFile exFileLock; //file handle to get exclusive lock

  private HeaderPrintWriter istream;

  private static final String LINE =

        "----------------------------------------------------------------";

    // disable syncing of data during page allocation.  DERBY-888 changes

    // the system to not require data syncing at allocation. 

    boolean dataNotSyncedAtAllocation = true;

    // disable syncing of data during checkpoint.

    boolean dataNotSyncedAtCheckpoint = false;

  // these fields can be accessed directly by subclasses if it needs a

  // different set of actions

  private PageActions       loggablePageActions;

  private AllocationActions loggableAllocActions;

  private boolean        readOnly;     // is this a read only data store

    private boolean supportsRandomAccess;

  private FileResource      fileHandler;  // my file handler, set by a

                                                // sub-class in its boot method.

  //hash table to keep track of information about dropped containers stubs

  private Hashtable droppedTableStubInfo;

  private Hashtable postRecoveryRemovedFiles;

    private EncryptData containerEncrypter;

    // PrivilegedAction actions

    private int actionCode;

    private static final int GET_TEMP_DIRECTORY_ACTION              = 1;

    private static final int REMOVE_TEMP_DIRECTORY_ACTION           = 2;

    private static final int GET_CONTAINER_PATH_ACTION              = 3;

    private static final int GET_ALTERNATE_CONTAINER_PATH_ACTION    = 4;

    private static final int FIND_MAX_CONTAINER_ID_ACTION           = 5;

    private static final int DELETE_IF_EXISTS_ACTION                = 6;

    private static final int GET_PATH_ACTION                        = 7;

    private static final int POST_RECOVERY_REMOVE_ACTION            = 8;

    private static final int REMOVE_STUBS_ACTION                    = 9;

    private static final int BOOT_ACTION                            = 10;

    private static final int GET_LOCK_ON_DB_ACTION                  = 11;

    private static final int RELEASE_LOCK_ON_DB_ACTION              = 12;

    private static final int RESTORE_DATA_DIRECTORY_ACTION          = 13;

    private static final int GET_CONTAINER_NAMES_ACTION             = 14;

    private ContainerKey    containerId;

    private boolean         stub;

    private StorageFile     actionFile;

    private UUID            myUUID;

    private UUIDFactory     uuidFactory;

    private String          databaseDirectory;

    private String          backupPath;

    private File            backupRoot;

    private String[]        bfilelist;

  /*

  ** Constructor

  */

  public BaseDataFileFactory()

    {

  }

  /*

  ** Methods of ModuleControl

  */

  public boolean canSupport(Properties startParams)

    {

    String serviceType = startParams.getProperty(PersistentService.TYPE);

    if (serviceType == null)

      return false;

    if (!handleServiceType(serviceType))

      return false;

    if (startParams.getProperty(PersistentService.ROOT) == null)

      return false;

    return true;

  }

  public void  boot(boolean create, Properties startParams)

        throws StandardException

    {

    jbmsVersion = Monitor.getMonitor().getEngineVersion();

   

    jvmVersion = buildJvmVersion();

   

    jarCPath = jarClassPath(getClass());

    dataDirectory = startParams.getProperty(PersistentService.ROOT);

    UUIDFactory uf = Monitor.getMonitor().getUUIDFactory();

    identifier = uf.createUUID();

        PersistentService ps = Monitor.getMonitor().getServiceType(this);

        try

        {

            storageFactory =

            ps.getStorageFactoryInstance(

                true,

                dataDirectory,

                startParams.getProperty(

                    Property.STORAGE_TEMP_DIRECTORY,

                    PropertyUtil.getSystemProperty(

                        Property.STORAGE_TEMP_DIRECTORY)),

                identifier.toANSIidentifier());

        }

        catch(IOException ioe)

        {

            if (create)

            {

                throw StandardException.newException(

                    SQLState.SERVICE_DIRECTORY_CREATE_ERROR,

                    ioe, dataDirectory);

            }

            else

            {

                throw StandardException.newException(

                    SQLState.DATABASE_NOT_FOUND, ioe, dataDirectory);

            }

        }

        if (storageFactory instanceof WritableStorageFactory)

            writableStorageFactory = (WritableStorageFactory) storageFactory;

        actionCode = BOOT_ACTION;

        try

        {

            AccessController.doPrivileged( this);

        }

        catch (PrivilegedActionException pae)

        {

            // BOOT_ACTION does not throw any exceptions.

        }

       

        String value =

            startParams.getProperty(Property.FORCE_DATABASE_LOCK,

                PropertyUtil.getSystemProperty(Property.FORCE_DATABASE_LOCK));

        throwDBlckException =

            Boolean.valueOf(

                (value != null ? value.trim() : value)).booleanValue();

    if (!isReadOnly())    // read only db, not interested in filelock

      getJBMSLockOnDB(identifier, uf, dataDirectory);

    //If the database is being restored/created from backup

    //the restore the data directory(seg*) from backup

    String restoreFrom =null;

    restoreFrom = startParams.getProperty(Attribute.CREATE_FROM);

    if(restoreFrom == null)

      restoreFrom = startParams.getProperty(Attribute.RESTORE_FROM);

    if(restoreFrom == null)

      restoreFrom = startParams.getProperty(Attribute.ROLL_FORWARD_RECOVERY_FROM);

    if (restoreFrom !=null)

    {

      try

            {

                // restoreFrom and createFrom operations also need to know if database

                // is encrypted

                String dataEncryption =

                    startParams.getProperty(Attribute.DATA_ENCRYPTION);

                databaseEncrypted = Boolean.valueOf(dataEncryption).booleanValue();

        restoreDataDirectory(restoreFrom);

      }

            catch(StandardException se)

      {

        releaseJBMSLockOnDB();

        throw se;

      }

    }

    logMsg(LINE);

        String readOnlyMsg = (isReadOnly())

            ? MessageService.getTextMessage(MessageId.STORE_BOOT_READONLY_MSG)

            : "";

        boolean logBootTrace = Boolean.valueOf(startParams.getProperty(Property.LOG_BOOT_TRACE,

               PropertyUtil.getSystemProperty(Property.LOG_BOOT_TRACE))).booleanValue();

        logMsg(new Date() +

         MessageService.getTextMessage(MessageId.STORE_BOOT_MSG,

                                             jbmsVersion,

                                             identifier,

                                             // cast to Object so we get object hash code

                                             dataDirectory + " " + readOnlyMsg,

                                             (Object) this.getClass().getClassLoader(),

                                             jarCPath

                                             ));

    //Log the JVM version info

    logMsg(jvmVersion);

    //Log derby.system.home It will have null value if user didn't set it

    logMsg(Property.SYSTEM_HOME_PROPERTY+"=" +

        PropertyUtil.getSystemProperty(Property.SYSTEM_HOME_PROPERTY));

   

    //Log properties related to redirection of derby.log

    String target =

      PropertyUtil.getSystemProperty(Property.ERRORLOG_FILE_PROPERTY);

    if (target != null)

      logMsg(Property.ERRORLOG_FILE_PROPERTY+"=" + target);

   

    target =

      PropertyUtil.getSystemProperty(Property.ERRORLOG_METHOD_PROPERTY);

    if (target != null)

      logMsg(Property.ERRORLOG_METHOD_PROPERTY+"=" + target);

   

    target =

      PropertyUtil.getSystemProperty(Property.ERRORLOG_FIELD_PROPERTY);

    if (target != null)

      logMsg(Property.ERRORLOG_FIELD_PROPERTY+"=" + target);

        if (logBootTrace)

           Monitor.logThrowable(new Throwable("boot trace"));

    uf = null;

    CacheFactory cf = (CacheFactory)

            Monitor.startSystemModule(

                org.apache.derby.iapi.reference.Module.CacheFactory);

        // Initialize the page cache

      int pageCacheSize = getIntParameter(

          RawStoreFactory.PAGE_CACHE_SIZE_PARAMETER,

                    null,

                    RawStoreFactory.PAGE_CACHE_SIZE_DEFAULT,

                    RawStoreFactory.PAGE_CACHE_SIZE_MINIMUM,

                    RawStoreFactory.PAGE_CACHE_SIZE_MAXIMUM);

    pageCache =

            cf.newCacheManager(

                this, "PageCache", pageCacheSize / 2, pageCacheSize);

        // Initialize the container cache

      int fileCacheSize = getIntParameter(

                    RawStoreFactory.CONTAINER_CACHE_SIZE_PARAMETER,

                    null,

                    RawStoreFactory.CONTAINER_CACHE_SIZE_DEFAULT,

                    RawStoreFactory.CONTAINER_CACHE_SIZE_MINIMUM,

                    RawStoreFactory.CONTAINER_CACHE_SIZE_MAXIMUM);

    containerCache =

            cf.newCacheManager(

                this, "ContainerCache", fileCacheSize / 2, fileCacheSize);

    if (create)

    {

      String noLog =

        startParams.getProperty(Property.CREATE_WITH_NO_LOG);

      inCreateNoLog =

                (noLog != null && Boolean.valueOf(noLog).booleanValue());

    }

    freezeSemaphore = new Object();

    droppedTableStubInfo = new Hashtable();

        // If derby.system.durability=test then set flags to disable sync of

        // data pages at allocation when file is grown, disable sync of data

        // writes during checkpoint

        if (Property.DURABILITY_TESTMODE_NO_SYNC.equalsIgnoreCase(

            PropertyUtil.getSystemProperty(Property.DURABILITY_PROPERTY)))

        {

            // - disable syncing of data during checkpoint.

            dataNotSyncedAtCheckpoint = true;

            // log message stating that derby.system.durability

            // is set to a mode, where syncs wont be forced and the

            // possible consequences of setting this mode

            Monitor.logMessage(MessageService.getTextMessage(

              MessageId.STORE_DURABILITY_TESTMODE_NO_SYNC,

              Property.DURABILITY_PROPERTY,

                Property.DURABILITY_TESTMODE_NO_SYNC));

    }

        else if (Performance.MEASURE)

        {

            // development build only feature, must by hand set the

            // Performance.MEASURE variable and rebuild.  Useful during

            // development to compare/contrast effect of syncing, release

            // users can use the above relaxed durability option to disable

            // all syncing. 

            // debug only flag - disable syncing of data during checkpoint.

            dataNotSyncedAtCheckpoint =

                PropertyUtil.getSystemBoolean(

                    Property.STORAGE_DATA_NOT_SYNCED_AT_CHECKPOINT);

            if (dataNotSyncedAtCheckpoint)

                Monitor.logMessage(

                    "Warning: " +

                    Property.STORAGE_DATA_NOT_SYNCED_AT_CHECKPOINT +

                    "set to true.");

    }

        fileHandler = new RFResource( this);

  } // end of boot

  public void  stop()

    {

    boolean OK = false;

    if (rawStoreFactory != null)

    {

      DaemonService rawStoreDaemon = rawStoreFactory.getDaemon();

      if (rawStoreDaemon != null)

        rawStoreDaemon.stop();

    }

    boolean logBootTrace = PropertyUtil.getSystemBoolean(Property.LOG_BOOT_TRACE);

    logMsg(LINE);

    logMsg(new Date() +

                MessageService.getTextMessage(

                    MessageId.STORE_SHUTDOWN_MSG,

                    getIdentifier(),

                    getRootDirectory(),

                    // print object and ide of classloader.

                    // Cast to object so we don't get just the toString()

                    // method

                    (Object) this.getClass().getClassLoader()));

 

    if (logBootTrace)

      Monitor.logThrowable(new Throwable("shutdown trace"));

     

    if (!isCorrupt)

        {

      try

            {

        if (pageCache != null && containerCache != null)

                {

          pageCache.shutdown();

          containerCache.shutdown();

          OK = true;

        }

      }

            catch (StandardException se)

            {

        se.printStackTrace(istream.getPrintWriter());

      }

    }

    removeTempDirectory();

    if (isReadOnly())    // do enough to close all files, then return

        {

            storageFactory.shutdown();

      return;

        }

    // re-enable stub removal until a better method can be found.

    // only remove stub if caches are cleaned

    if (removeStubsOK && OK) 

      removeStubs();

    releaseJBMSLockOnDB();

       

        writableStorageFactory.shutdown();

  } // end of stop

  /*

  ** CacheableFactory

  */

  public Cacheable newCacheable(CacheManager cm)

    {

    if (cm == pageCache)

        {

      StoredPage sp = new StoredPage();

      sp.setFactory(this);

      return sp;

    }

    // container cache

    return newContainerObject();

  }

  /**

    Database creation finished

    @exception StandardException Standard Derby exception policy.

  */

  public void createFinished() throws StandardException

  {

    if (!inCreateNoLog)

        {

      throw StandardException.newException(

                SQLState.FILE_DATABASE_NOT_IN_CREATE);

        }

    // the changes in cache are not logged, they have to be flushed to disk

    checkpoint();

    inCreateNoLog = false;

  }

  /*

  ** Methods of DataFactory

  */

 

  public ContainerHandle openContainer(

    RawTransaction  t,

    ContainerKey    containerId,

    LockingPolicy   locking,

    int             mode)

    throws StandardException

    {

        return openContainer(

                t, containerId, locking, mode, false /* is not dropped */);

  }

  /**

    @see DataFactory#openDroppedContainer

    @exception StandardException Standard Derby error policy

  */

  public RawContainerHandle openDroppedContainer(

    RawTransaction  t,

    ContainerKey    containerId, 

    LockingPolicy   locking,

    int             mode)

     throws StandardException 

  {

    // since we are opening a possible dropped container

    // lets not add any actions that will take palce on a commit.

    mode |= ContainerHandle.MODE_NO_ACTIONS_ON_COMMIT;

        return openContainer(

                t, containerId, locking, mode, true /* droppedOK */);

  }

  /**

    @see DataFactory#openContainer

    @exception StandardException Standard Derby error policy

  */

  private RawContainerHandle openContainer(

    RawTransaction  t,

    ContainerKey    identity,

    LockingPolicy   locking,

    int             mode,

    boolean         droppedOK)

     throws StandardException

  {

    if (SanityManager.DEBUG)

        {

      if ((mode & (ContainerHandle.MODE_READONLY | ContainerHandle.MODE_FORUPDATE))

        == (ContainerHandle.MODE_READONLY | ContainerHandle.MODE_FORUPDATE))

            {

        SanityManager.THROWASSERT("update and readonly mode specified");

            }

    }

    boolean waitForLock = ((mode & ContainerHandle.MODE_LOCK_NOWAIT) == 0);

    if ((mode & ContainerHandle.MODE_OPEN_FOR_LOCK_ONLY) != 0)

        {

      // Open a container for lock only, we don't care if it exists, is

            // deleted or anything about it. The container handle we return is

            // closed and cannot be used for fetch or update etc.

      BaseContainerHandle lockOnlyHandle = 

                new BaseContainerHandle(

                    getIdentifier(), t, identity, locking, mode);

      if (lockOnlyHandle.useContainer(true, waitForLock))

        return lockOnlyHandle;

      else

        return null;

    }

    BaseContainerHandle c;

    // see if the container exists 

    FileContainer container = (FileContainer) containerCache.find(identity);

    if (container == null)

      return null;

   

    if (identity.getSegmentId() == ContainerHandle.TEMPORARY_SEGMENT)

        {

      if (SanityManager.DEBUG)

            {

        SanityManager.ASSERT(container instanceof TempRAFContainer);

      }

      if ((mode & ContainerHandle.MODE_TEMP_IS_KEPT) ==

                    ContainerHandle.MODE_TEMP_IS_KEPT)

            {

        // if the mode is kept, then, we do not want to truncate

        mode |= ContainerHandle.MODE_UNLOGGED;

      }

            else

            {

        // this should be OK even if the table was opened read-only

        mode |=

                    (ContainerHandle.MODE_UNLOGGED |

                     ContainerHandle.MODE_TRUNCATE_ON_ROLLBACK);

      }

     

      locking =

                t.newLockingPolicy(

                    LockingPolicy.MODE_NONE,

                    TransactionController.ISOLATION_NOLOCK, true);

    }

        else

        {

      // real tables

      if (inCreateNoLog)

            {

        mode |=

                    (ContainerHandle.MODE_UNLOGGED |

                     ContainerHandle.MODE_CREATE_UNLOGGED);

            } else {

        // make sure everything is logged if logArchived is turn on

        // clear all UNLOGGED flag

        if (logFactory.logArchived() ||

                                        logFactory.inReplicationMasterMode()) {

          mode &= ~(ContainerHandle.MODE_UNLOGGED |

                ContainerHandle.MODE_CREATE_UNLOGGED);

        } else {

          // block the online backup if the container is being

          // opened in unlogged mode, if the backup is already

          // running then convert all unlogged opens to logged ones,

          // otherwise online backup copy will be inconsistent.

          if (((mode & ContainerHandle.MODE_UNLOGGED) ==

             ContainerHandle.MODE_UNLOGGED) ||

            ((mode & ContainerHandle.MODE_CREATE_UNLOGGED) ==

             ContainerHandle.MODE_CREATE_UNLOGGED))                    

          {

            if (!t.blockBackup(false)) {

              // when a backup is in progress transaction can not

                            // block the backup, so convert  unlogged opens

                            // to logged mode.

              mode &= ~(ContainerHandle.MODE_UNLOGGED |

                    ContainerHandle.MODE_CREATE_UNLOGGED);

            }

          }

        }

      }

      // if mode is UNLOGGED but not CREATE_UNLOGGED, then force the

      // container from cache when the transaction commits.  For

      // CREATE_UNLOGGED, client has the responsibility of forcing the

      // cache.

      if (((mode & ContainerHandle.MODE_UNLOGGED) ==

                    ContainerHandle.MODE_UNLOGGED) &&

        ((mode & ContainerHandle.MODE_CREATE_UNLOGGED) == 0))

            {

        mode |= ContainerHandle.MODE_FLUSH_ON_COMMIT;

      }

    }