Package org.apache.derby.io

Examples of org.apache.derby.io.StorageRandomAccessFile


        throw StandardException.newException(
                        SQLState.LOG_EXCEED_MAX_LOG_FILE_NUMBER,
                        new Long(maxLogFileNumber));
            }

      StorageRandomAccessFile newLog = null// the new log file
      try
      {
        // if the log file exist and cannot be deleted, cannot
        // switch log right now
                if (privExists(newLogFile) && !privDelete(newLogFile))
        {
          logErrMsg(MessageService.getTextMessage(
                        MessageId.LOG_NEW_LOGFILE_EXIST,
              newLogFile.getPath()));
          return;
        }

        try
        {
                    newLog =   privRandomAccessFile(newLogFile, "rw");
        }
        catch (IOException ioe)
        {
          newLog = null;
        }

                if (newLog == null || !privCanWrite(newLogFile))
        {
          if (newLog != null)
            newLog.close();
          newLog = null;

          return;
        }

        if (initLogFile(newLog, logFileNumber+1,
                LogCounter.makeLogInstantAsLong(logFileNumber, endPosition)))
        {

          // New log file init ok, close the old one and
          // switch over, after this point, need to shutdown the
          // database if any error crops up
          switchedOver = true;

          // write out an extra 0 at the end to mark the end of the log
          // file.
         
          logOut.writeEndMarker(0);

          endPosition += 4;
          //set that we are in log switch to prevent flusher
          //not requesting  to switch log again
          inLogSwitch = true;
          // flush everything including the int we just wrote
          flush(logFileNumber, endPosition);
         
         
          // simulate out of log error after the switch over
          if (SanityManager.DEBUG)
          {
            if (SanityManager.DEBUG_ON(TEST_SWITCH_LOG_FAIL2))
              throw new IOException("TestLogSwitchFail2");
          }


          logOut.close();    // close the old log file
         
          logWrittenFromLastCheckPoint += endPosition;

          endPosition = newLog.getFilePointer();
          lastFlush = endPosition;
         
          if(isWriteSynced)
          {
            //extend the file by wring zeros to it
            preAllocateNewLogFile(newLog);
            newLog.close();
            newLog = openLogFileInWriteMode(newLogFile);
            newLog.seek(endPosition);
          }

          logOut = new LogAccessFile(this, newLog, logBufferSize);
          newLog = null;


          if (SanityManager.DEBUG)
          {
            if (endPosition != LOG_FILE_HEADER_SIZE)
              SanityManager.THROWASSERT(
                      "new log file has unexpected size" +
                       + endPosition);
          }
          logFileNumber++;

          if (SanityManager.DEBUG)
          {
            SanityManager.ASSERT(endPosition == LOG_FILE_HEADER_SIZE,
                       "empty log file has wrong size");
          }

        }
        else  // something went wrong, delete the half baked file
        {
          newLog.close();
          newLog = null;

          if (privExists(newLogFile))
              privDelete(newLogFile);
          newLogFile = null;

          logErrMsg(MessageService.getTextMessage(
                        MessageId.LOG_CANNOT_CREATE_NEW,
                        newLogFile.getPath()));
         }

      }
      catch (IOException ioe)
      {

        inLogSwitch = false;
        // switching log file is an optional operation and there is no direct user
        // control.  Just sends a warning message to whomever, if any,
        // system adminstrator there may be

                logErrMsg(MessageService.getTextMessage(
                    MessageId.LOG_CANNOT_CREATE_NEW_DUETO,
                    newLogFile.getPath(),
                    ioe.toString()));

        try
        {
          if (newLog != null)
          {
            newLog.close();
            newLog = null;
          }
        }
        catch (IOException ioe2) {}
View Full Code Here


    <P> MT- synchronized by caller
  */
  boolean writeControlFile(StorageFile logControlFileName, long value)
     throws IOException, StandardException
  {
    StorageRandomAccessFile logControlFile = null;

    ByteArrayOutputStream baos = new ByteArrayOutputStream(64);
    DataOutputStream daos = new DataOutputStream(baos);

    daos.writeInt(fid);

    // so that when this db is booted by 1.1x and 1.2x JBMS, a IOException
    // stack trace rather than some error message that tells
    // the user to delete the database will show up.
    daos.writeInt(OBSOLETE_LOG_VERSION_NUMBER);
    daos.writeLong(value);

    if (onDiskMajorVersion == 0) {
      onDiskMajorVersion = jbmsVersion.getMajorVersion();
      onDiskMinorVersion = jbmsVersion.getMinorVersion();
      onDiskBeta = jbmsVersion.isBeta();
    }

    // previous to 1.3, that's all we wrote. 
    // from 1.3 and onward, also write out the JBMSVersion
    daos.writeInt(onDiskMajorVersion);
    daos.writeInt(onDiskMinorVersion);

    // For 2.0 beta we added the build number and the isBeta indication.
    // (5 bytes from our first spare long)
    daos.writeInt(jbmsVersion.getBuildNumberAsInt());

    byte flags = 0;
    if (onDiskBeta)
            flags |= IS_BETA_FLAG;
       
        // When database is booted with derby.system.durability=test,
        // this mode does not guarantee that
        // - database will recover
        // - committed transactions will not be lost
        // - database will be in a consistent state
        // Hence necessary to keep track of this state so we don't
        // waste time resolving issues in such cases.
        // wasDBInDurabilityTestModeNoSync has information if database was
        // previously booted at any time in this mode
        if (logNotSynced || wasDBInDurabilityTestModeNoSync)
            flags |= IS_DURABILITY_TESTMODE_NO_SYNC_FLAG;
     daos.writeByte(flags);

    //
    // write some spare bytes after 2.0 we have 3 + 2(8) spare bytes.
     long spare = 0;
      
    daos.writeByte(0);
    daos.writeByte(0);
        daos.writeByte(0);
    daos.writeLong(spare);
    daos.flush();
    // write the checksum for the control data written
    checksum.reset();
    checksum.update(baos.toByteArray(), 0, baos.size());
    daos.writeLong(checksum.getValue());
    daos.flush();

    try
    {
            checkCorrupt();

      try
      {
                logControlFile = privRandomAccessFile(logControlFileName, "rw");
      }
      catch (IOException ioe)
      {
        logControlFile = null;
        return false;
      }

            if (!privCanWrite(logControlFileName))
        return false;

      if (SanityManager.DEBUG)
      {
        if (SanityManager.DEBUG_ON(TEST_LOG_FULL))
          testLogFull();
      }

      logControlFile.seek(0);
      logControlFile.write(baos.toByteArray());
            syncFile(logControlFile);
            logControlFile.close();

      // write the same data to mirror control file
      try
      {
        logControlFile =
                    privRandomAccessFile(getMirrorControlFileName(), "rw");
      }
      catch (IOException ioe)
      {
        logControlFile = null;
        return false;
      }

      logControlFile.seek(0);
      logControlFile.write(baos.toByteArray());
            syncFile(logControlFile);

    }
    finally
    {
      if (logControlFile != null)
        logControlFile.close();
    }

    return true;

  }
View Full Code Here

    <P> MT- read only
  */
  private long readControlFile(StorageFile logControlFileName, Properties startParams)
     throws IOException, StandardException
  {
    StorageRandomAccessFile logControlFile = null;
    ByteArrayInputStream bais = null;
        DataInputStream dais = null;
    logControlFile =  privRandomAccessFile(logControlFileName, "r");
    boolean upgradeNeeded = false;
    long value = LogCounter.INVALID_LOG_INSTANT;
    long onDiskChecksum = 0;
    long controlFilelength = logControlFile.length();
    byte barray[] = null;

    try
    {
      // The length of the file is less than the minimum in any version
            // It is possibly hosed , no point in reading data from this file
            // skip reading checksum  control file is before 1.5
            if (controlFilelength < 16)
        onDiskChecksum = -1;
      else if (controlFilelength == 16)
      {
        barray = new byte[16];
        logControlFile.readFully(barray);
      }else if (controlFilelength > 16)
            {
        barray = new byte[(int) logControlFile.length() - 8];
        logControlFile.readFully(barray);
        onDiskChecksum = logControlFile.readLong();
        if (onDiskChecksum !=0 )
        {
          checksum.reset();
          checksum.update(barray, 0, barray.length);
        }
      }

      if ( onDiskChecksum == checksum.getValue() || onDiskChecksum ==0)
      {

        bais = new ByteArrayInputStream(barray);
        dais = new DataInputStream(bais);

        if (dais.readInt() != fid)
              {
                  throw StandardException.newException(
                          SQLState.LOG_INCOMPATIBLE_FORMAT, dataDirectory);
              }
 
        int obsoleteVersion = dais.readInt();
        value = dais.readLong();
 
        if (SanityManager.DEBUG)
        {
          if (SanityManager.DEBUG_ON(LogToFile.DBG_FLAG))
                      SanityManager.DEBUG(LogToFile.DBG_FLAG,
                          "log control file ckp instance = " +
                          LogCounter.toDebugString(value));
        }
 
 
        // from version 1.5 onward, we added an int for storing JBMS
        // version and an int for storing checkpoint interval
        // and log switch interval
        onDiskMajorVersion = dais.readInt();
        onDiskMinorVersion = dais.readInt();
        int dbBuildNumber = dais.readInt();
        int flags = dais.readByte();
       
        // check if the database was booted previously at any time with
                // derby.system.durability=test mode
                // If yes, then on a boot error we report that this setting is
                // probably the cause for the error and also log a warning
                // in the derby.log that this mode was set previously
                wasDBInDurabilityTestModeNoSync =
                    (flags & IS_DURABILITY_TESTMODE_NO_SYNC_FLAG) != 0;

                if (SanityManager.DEBUG) {
                    if (SanityManager.DEBUG_ON(LogToFile.DBG_FLAG))
                        SanityManager.DEBUG(LogToFile.DBG_FLAG,
                        "log control file, was derby.system.durability set to test = " +
                        wasDBInDurabilityTestModeNoSync);
                }
                   
       
        onDiskBeta = (flags & IS_BETA_FLAG) != 0;
        if (onDiskBeta)
        {
          // if is beta, can only be booted by exactly the same
          // version
          if (!jbmsVersion.isBeta() ||
            onDiskMajorVersion != jbmsVersion.getMajorVersion() ||
            onDiskMinorVersion != jbmsVersion.getMinorVersion())
          {
            boolean forceBetaUpgrade = false;
            if (SanityManager.DEBUG)
            {
              // give ourselves an out for this beta check for debugging purposes
              if (SanityManager.DEBUG_ON("forceBetaUpgrade"))
              {
                Monitor.logMessage("WARNING !! : forcing beta upgrade.");
                forceBetaUpgrade =true;
              }
            }

            if (!forceBetaUpgrade)
                      {
              throw StandardException.newException(
                              SQLState.LOG_CANNOT_UPGRADE_BETA,
                              dataDirectory,
                ProductVersionHolder.simpleVersionString(onDiskMajorVersion, onDiskMinorVersion, onDiskBeta));
                      }
          }
        }
         
 
        // JBMS_VERSION must be numbered in a way so that it is ever
        // increasing.  We are backwards compatible but not forwards
        // compatible
        //
        if (onDiskMajorVersion > jbmsVersion.getMajorVersion() ||
          (onDiskMajorVersion == jbmsVersion.getMajorVersion() &&
           onDiskMinorVersion > jbmsVersion.getMinorVersion()))
        {
          // don't need to worry about point release, no format
          // upgrade is allowed.
          throw StandardException.newException(
                          SQLState.LOG_INCOMPATIBLE_VERSION,
                          dataDirectory,
              ProductVersionHolder.simpleVersionString(onDiskMajorVersion, onDiskMinorVersion, onDiskBeta));
        }

        // Ensure that upgrade has been requested for a major or minor upgrade
        // maintaince (point) versions should not require an upgrade.
        if ((onDiskMajorVersion != jbmsVersion.getMajorVersion()) ||
          (onDiskMinorVersion != jbmsVersion.getMinorVersion()))
        {
          upgradeNeeded = true;
        }
        // if checksum is zeros in  version > 3.5 file is hosed
        // except incase of upgrade from versions <= 3.5
        if (onDiskChecksum == 0 &&
          (!(onDiskMajorVersion <= 3 && onDiskMinorVersion <=5) ||
          onDiskMajorVersion == 0))
          value = LogCounter.INVALID_LOG_INSTANT;
      }
    }
    finally
    {
      if (logControlFile != null)
        logControlFile.close();
      if (bais != null)
        bais.close();
      if (dais != null)
        dais.close();
    }
View Full Code Here

      return null;
    }


    StorageRandomAccessFile log = null;

    try
    {
            log = privRandomAccessFile(fileName, "r");

      // verify that the log file is of the right format
      if (!verifyLogFormat(log, filenum))
      {
        if (SanityManager.DEBUG)
        {
          if (SanityManager.DEBUG_ON(LogToFile.DBG_FLAG))
            SanityManager.DEBUG(LogToFile.DBG_FLAG, fileName.getPath() + " format mismatch");
        }

        log.close();
        log = null;
      }
      else
      {
        log.seek(filepos);
      }
    }
    catch (IOException ioe)
    {
      try
      {
        if (log != null)
        {
          log.close();
          log = null;
        }

        if (SanityManager.DEBUG)
        {
View Full Code Here

    if (SanityManager.DEBUG)
    {
      //long filenum = LogCounter.getLogFileNumber(logInstant);
      //      long filepos = LogCounter.getLogFilePosition(logInstant);
      StorageFile fileName = getLogFileName(filenum);
      StorageRandomAccessFile log = null;
      return privRandomAccessFile(fileName, "rw");
    }
   
    return null;
View Full Code Here

            /*
             * Open the highest log file and make sure log records are
             * appended at the end of it
             */

            StorageRandomAccessFile logFile = null;
            if(isWriteSynced) {
                logFile = openLogFileInWriteMode(
                              getLogFileName(logFileNumber));
            } else {
                logFile = privRandomAccessFile(getLogFileName(logFileNumber),
                                               "rw");
            }
            logOut = new LogAccessFile(this, logFile, logBufferSize);

            lastFlush = endPosition;
            logFile.seek(endPosition); // append log records at the end of
            // the file

        } catch (IOException ioe) {
            throw StandardException.newException
                (SQLState.REPLICATION_UNEXPECTED_EXCEPTION, ioe);
View Full Code Here

                isWriteSynced = false;
                return privRandomAccessFile(logFile, "rw");
            }
        }

    StorageRandomAccessFile log = privRandomAccessFile(logFile, "rwd");
    return log ;
  }
View Full Code Here

     * @exception StandardException Standard Derby exception
     */
    private boolean checkJvmSyncError(StorageFile logFile) throws IOException
    {
        boolean hasJvmSyncError = false;
        StorageRandomAccessFile rwsTest;

        // Normally this log file already exists but in case it does
        // not we open the file using "rw" mode. This is needed in
        // order to ensure that the file already exists when it is
        // opened in "rws" mode. This should succeed on all JVMs
        rwsTest = privRandomAccessFile(logFile, "rw");
        rwsTest.close();

        // Try to re-open the file in "rws" mode
        try{
            rwsTest = privRandomAccessFile(logFile, "rws");
            rwsTest.close();
        }
        catch (FileNotFoundException ex) {
            // Normally this exception should never occur. For some
            // reason currently on some Mac and FreeBSD JVM 1.4.2 and
            // 1.5 FileNotFoundException exception is thrown if a file
View Full Code Here

        throws StandardException
    {
        BasePage page = null;
        StorageFile newFile =
            dataFactory.getStorageFactory().newStorageFile(newFilePath);
        StorageRandomAccessFile newRaf = null;
        try {
            long lastPageNumber= getLastPageNumber(handle);
            newRaf = getRandomAccessFile(newFile);

            byte[] encryptionBuf = null;
            if (doEncrypt) {
                encryptionBuf = new byte[pageSize];
            }

            // Copy all the pages from the current container to the new
            // container file after processing the pages.
            for (long pageNumber = FIRST_ALLOC_PAGE_NUMBER;
                 pageNumber <= lastPageNumber; pageNumber++)
            {

                page = getLatchedPage(handle, pageNumber);
                       
                // Update the page array before writing to the disk.
                // An update consists of adding the container header, or
                // (re-)encrypting the data.
                byte[] dataToWrite = updatePageArray(pageNumber,
                                                     page.getPageArray(),
                                                     encryptionBuf,
                                                     true);
                newRaf.write(dataToWrite, 0, pageSize);

                // unlatch releases page from cache.
                page.unlatch();
                page = null;
            }

            // sync the new version of the container.
            newRaf.sync();
            newRaf.close();
            newRaf = null;
           
        }catch (IOException ioe) {
            throw StandardException.newException(
                                    SQLState.FILE_CONTAINER_EXCEPTION, ioe,
                                    getIdentity() != null ?
                                        getIdentity().toString() : "unknown",
                                    doEncrypt ? "encrypt" : "decrypt",
                                    newFilePath);
        } finally {

            if (page != null) {
                page.unlatch();
                page = null;
            }
           
            if (newRaf != null) {
                try {
                    newRaf.close();
                }catch (IOException ioe)
                {
                    newRaf = null;
                    throw StandardException.newException(
                                    SQLState.FILE_CONTAINER_EXCEPTION, ioe,
View Full Code Here

         case STUBBIFY_ACTION:
         {
             StorageFile file = privGetFileName( actionIdentity, false, false, true);
             StorageFile stub = privGetFileName( actionIdentity, true, false, false);

             StorageRandomAccessFile stubData = null;

             try
             {
                 // !!!!!
                 // bumpContainerVersion();
                 //
                 // do NOT bump the container version.  We WANT the stubbify
                 // operation to get redone every time.  This is because this
                 // operation first writes out the stub and then remove the
                 // container file.  If we bump the version, then the stub will
                 // contain the new version.  And if the system crashes right then,
                 // then we will skip the whole operation during redo even though
                 // the container file may not have been removed.  Since we don't
                 // want to have the remove happen before the stub is written, we
                 // cannot sync it and therefore cannot be sure the remove
                 // happened before the system crashed.

                 if (!stub.exists())
                 {
                     // write the header to the stub
                     stubData = stub.getRandomAccessFile( "rw");
                     stub.limitAccessToOwner();

                     writeRAFHeader(
                        actionIdentity,
                        stubData,
                                    true, /* create */
                                    true); /* sync */

                     stubData.close();
                     stubData = null;
                 }


                 // Force WAL and check for database corruption before removing file.
                 // This is one operation where the container is changed on disk
                 // directly without going thru the container cache, which otherwise
                 // would have force WAL.  Take care of it here.
                 dataFactory.flush(actionInstant);

                 // try to remove the container file
                 // fileDate is not null only if we are redoing a removeContainer
                 // (stubbify) operation.  Then fileData acutally is opened against
                 // the stub and the original container file does not exist.
                 // Then we need to close it here because this method is called by
                 // cache.remove and nobody will be able to see fileData after this.
                 privRemoveFile(file);

             }
             catch (SecurityException se)
             {
                 throw StandardException.
                     newException(SQLState.FILE_CANNOT_REMOVE_FILE, se, file,
                                  se.toString());
             }
             catch (IOException ioe)
             {
                 // exception thrown while in creating the stub.  Remove the
                 // (half-baked) stub
                 try
                 {
                     if (stubData != null)
                     {
                         stubData.close();
                         stub.delete();
                         stubData = null;
                     }

                     if (fileData != null)
View Full Code Here

TOP

Related Classes of org.apache.derby.io.StorageRandomAccessFile

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.