FileManager (starrocks-bdb-je 18.3.17 API)

java.lang.Object
- com.sleepycat.je.log.FileManager

```
public class FileManager
extends Object
```
The FileManager presents the abstraction of one contiguous file. It doles out LSNs.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`FileManager.DefaultRandomAccessFile` The RandomAccessFile for production use.
`static interface`	`FileManager.FileFactory` The factory interface for creating RandomAccessFiles.
`static class`	`FileManager.FileMode`

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`BAD_SUFFIX`
`static String`	`BUP_SUFFIX`
`static String`	`DEL_SUFFIX`
`static FileManager.FileFactory`	`fileFactory` The factory instance used to create RandomAccessFiles.
`static String`	`JE_SUFFIX`
`static boolean`	`LOGWRITE_EXCEPTION_TESTING`
`static long`	`N_BAD_WRITES`
`static long`	`STOP_ON_WRITE_COUNT`
`static boolean`	`THROW_ON_WRITE`
`static String`	`TMP_SUFFIX`
`boolean`	`VERIFY_CHECKSUMS`
`static long`	`WRITE_COUNT`

Constructor Summary

Constructors
Constructor and Description
`FileManager(EnvironmentImpl envImpl, File dbEnvHome, boolean readOnly)` Set up the file cache and initialize the file manager to point to the beginning of the log.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`checkEnvHomePermissions(boolean rdOnly)` Ensure that if the environment home dir is on readonly media or in a readonly directory that the environment has been opened for readonly access.
`void`	`clear()` Close all file handles and empty the cache.
`void`	`close()` Clear the file lock.
`boolean`	`deleteFile(long fileNum)` Delete log file NNNNNNNN.
`boolean`	`filesExist()`
`static int`	`firstLogEntryOffset()` Return the offset of the first log entry after the file header.
`void`	`force(Set<Long> fileNums)` Fsync this set of log files.
`void`	`forceNewLogFile()` Set the flag that causes a new file to be written before the next write.
`File[]`	`gatherDataDirs()`
`Long[]`	`getAllFileNumbers()` Get all JE file numbers.
`FileManager.FileMode`	`getAppropriateReadWriteMode()`
`long`	`getCurrentFileNum()` Returns the highest (current) file number.
`FileHandle`	`getFileHandle(long fileNum)` Return a read only file handle that corresponds to this file number.
`long`	`getFileHeaderPrevOffset(long fileNum)`
`Timestamp`	`getFileHeaderTimestamp(long fileNum)`
`int`	`getFileLogVersion(long fileNum)` Returns the log version for the given file.
`static String`	`getFileName(long fileNum)`
`static String`	`getFileName(long fileNum, String suffix)`
`Long`	`getFirstFileNum()` public for cleaner.
`Long`	`getFollowingFileNum(long curFile, boolean forward)` Get the next file number before/after currentFileNum.
`String`	`getFullFileName(long fileNum)`
`String`	`getFullFileName(long fileNum, String suffix)`
`String`	`getFullFileName(String fileName)`
`Long`	`getLastFileNum()`
`long`	`getLastUsedLsn()` Return the last allocated LSN in the log.
`long`	`getNextLsn()` Return the next available LSN in the log.
`Long`	`getNumFromName(String fileName)` Get the file number from a file name.
`String`	`getPartialFileName(long fileNum)`
`boolean`	`getReadOnly()`
`boolean`	`hasQueuedWrites()` Returns whether anything is in the write queue.
`boolean`	`isFileValid(long fileNum)` For assertions that check whether a file is valid or has been deleted via log cleaning.
`String[]`	`listFileNames(long minFileNumber, long maxFileNumber)` Find .jdb files which are >= the minimimum file number and <= the maximum file number.
`static String[]`	`listFiles(File envDirFile, String[] suffixes, boolean envMultiSubDir)` Find JE files, flavor for unit test support.
`File[]`	`listJDBFiles()`
`File[]`	`listJDBFilesInternalMultiDir(com.sleepycat.je.log.JEFileFilter fileFilter)`
`File[]`	`listJDBFilesInternalSingleDir(com.sleepycat.je.log.JEFileFilter fileFilter)`
`boolean`	`lockEnvironment(boolean rdOnly, boolean exclusive)` Lock the environment.
`void`	`makeInvisible(long fileNum, List<Long> lsns)` Mark the specified log entries as invisible and obsolete.
`boolean`	`noteFsyncTime(long fSyncMs)` Update fsync statistics given that an fsync was performed which took the specified amount of time in milliseconds.
`RandomAccessFile`	`openFileReadWrite(String fullPath)` Opens an existing file for read-write access.
`void`	`releaseExclusiveLock()`
`boolean`	`renameFile(long fileNum, String newSuffix)`
`File`	`renameFile(long fileNum, String newSuffix, String subDir)` Rename this file to NNNNNNNN.suffix.
`void`	`setIncludeDeletedFiles(boolean includeDeletedFiles)`
`void`	`setLastPosition(long nextAvailableLsn, long lastUsedLsn, long prevOffset)` Set the file manager's "end of log".
`void`	`setSyncAtFileEnd(boolean sync)` May be used to disable sync at file end to speed unit tests.
`void`	`startFileCacheWarmer(long recoveryStartLsn)`
`void`	`testWriteQueueLock()` For unit testing only.
`void`	`testWriteQueueUnlock()` For unit testing only.
`void`	`truncateLog(long fileNum, long offset)`
`void`	`truncateSingleFile(long fileNum, long offset)` Truncate a log at this position.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - WRITE_COUNT
```
public static long WRITE_COUNT
```
  - STOP_ON_WRITE_COUNT
```
public static long STOP_ON_WRITE_COUNT
```
  - N_BAD_WRITES
```
public static long N_BAD_WRITES
```
  - THROW_ON_WRITE
```
public static boolean THROW_ON_WRITE
```
  - JE_SUFFIX
```
public static final String JE_SUFFIX
```
    See Also:
    
    Constant Field Values
  - DEL_SUFFIX
```
public static final String DEL_SUFFIX
```
    See Also:
    
    Constant Field Values
  - BAD_SUFFIX
```
public static final String BAD_SUFFIX
```
    See Also:
    
    Constant Field Values
  - TMP_SUFFIX
```
public static final String TMP_SUFFIX
```
    See Also:
    
    Constant Field Values
  - BUP_SUFFIX
```
public static final String BUP_SUFFIX
```
    See Also:
    
    Constant Field Values
  - VERIFY_CHECKSUMS
```
public boolean VERIFY_CHECKSUMS
```
  - LOGWRITE_EXCEPTION_TESTING
```
public static final boolean LOGWRITE_EXCEPTION_TESTING
```
  - fileFactory
```
public static FileManager.FileFactory fileFactory
```
    The factory instance used to create RandomAccessFiles. This field is intentionally public and non-static so it may be set by tests. See FileFactory.
- Constructor Detail
  - FileManager
```
public FileManager(EnvironmentImpl envImpl,
                   File dbEnvHome,
                   boolean readOnly)
            throws EnvironmentLockedException
```
    Set up the file cache and initialize the file manager to point to the beginning of the log.
    
    Parameters:
    
    dbEnvHome - environment home directory
    
    Throws:
    
    IllegalArgumentException - via Environment ctor
    
    EnvironmentLockedException - via Environment ctor
- Method Detail
  - setLastPosition
```
public void setLastPosition(long nextAvailableLsn,
                            long lastUsedLsn,
                            long prevOffset)
```
    Set the file manager's "end of log".
    
    Parameters:
    
    nextAvailableLsn - LSN to be used for the next log entry
    
    lastUsedLsn - last LSN to have a valid entry, may be null
    
    prevOffset - value to use for the prevOffset of the next entry. If the beginning of the file, this is 0.
  - setSyncAtFileEnd
```
public void setSyncAtFileEnd(boolean sync)
```
    May be used to disable sync at file end to speed unit tests. Must only be used for unit testing, since log corruption may result.
  - getFirstFileNum
```
public Long getFirstFileNum()
```
    public for cleaner.
    
    Returns:
    
    the number of the first file in this environment.
  - getReadOnly
```
public boolean getReadOnly()
```
  - getLastFileNum
```
public Long getLastFileNum()
```
    Returns:
    
    the number of the last file in this environment.
  - getCurrentFileNum
```
public long getCurrentFileNum()
```
    Returns the highest (current) file number. Note that this is unsynchronized, so if it is called outside the log write latch it is only valid as an approximation.
  - isFileValid
```
public boolean isFileValid(long fileNum)
```
    For assertions that check whether a file is valid or has been deleted via log cleaning.
  - setIncludeDeletedFiles
```
public void setIncludeDeletedFiles(boolean includeDeletedFiles)
```
  - getAllFileNumbers
```
public Long[] getAllFileNumbers()
```
    Get all JE file numbers.
    
    Returns:
    
    an array of all JE file numbers.
  - getFollowingFileNum
```
public Long getFollowingFileNum(long curFile,
                                boolean forward)
```
    Get the next file number before/after currentFileNum.
    
    Parameters:
    
    curFile - the file we're at right now. Note that it may not exist, if it's been cleaned and renamed.
    
    forward - if true, we want the next larger file, if false we want the previous file
    
    Returns:
    
    null if there is no following file, or if filenum doesn't exist
  - filesExist
```
public boolean filesExist()
```
    Returns:
    
    true if there are any files at all.
  - getNumFromName
```
public Long getNumFromName(String fileName)
```
    Get the file number from a file name.
    
    Parameters:
    
    fileName - the file name
    
    Returns:
    
    the file number
  - listFileNames
```
public String[] listFileNames(long minFileNumber,
                              long maxFileNumber)
```
    Find .jdb files which are >= the minimimum file number and <= the maximum file number. Return names sorted in ascending fashion.
    
    Returns:
    
    array of file names
  - listFiles
```
public static String[] listFiles(File envDirFile,
                                 String[] suffixes,
                                 boolean envMultiSubDir)
```
    Find JE files, flavor for unit test support.
    
    Parameters:
    
    suffixes - which type of file we're looking for
    
    Returns:
    
    array of file names
  - listJDBFiles
```
public File[] listJDBFiles()
```
  - listJDBFilesInternalSingleDir
```
public File[] listJDBFilesInternalSingleDir(com.sleepycat.je.log.JEFileFilter fileFilter)
```
  - listJDBFilesInternalMultiDir
```
public File[] listJDBFilesInternalMultiDir(com.sleepycat.je.log.JEFileFilter fileFilter)
```
  - gatherDataDirs
```
public File[] gatherDataDirs()
```
  - getFullFileName
```
public String getFullFileName(long fileNum)
```
  - getFullFileName
```
public String getFullFileName(long fileNum,
                              String suffix)
```
    Returns:
    
    the full file name and path for this file name.
  - getPartialFileName
```
public String getPartialFileName(long fileNum)
```
    Returns:
    
    the file name relative to the env home directory.
  - getFullFileName
```
public String getFullFileName(String fileName)
```
  - getFileName
```
public static String getFileName(long fileNum,
                                 String suffix)
```
    Returns:
    
    the file name for the nth file.
  - getFileName
```
public static String getFileName(long fileNum)
```
    Returns:
    
    the file name for the nth log (*.jdb) file.
  - renameFile
```
public boolean renameFile(long fileNum,
                          String newSuffix)
                   throws IOException,
                          DatabaseException
```
    Returns:
    
    true if successful, false if File.renameTo returns false, which can occur on Windows if the file was recently closed.
    
    Throws:
    
    IOException
    
    DatabaseException
  - renameFile
```
public File renameFile(long fileNum,
                       String newSuffix,
                       String subDir)
                throws IOException
```
    Rename this file to NNNNNNNN.suffix. If that file already exists, try NNNNNNNN.suffix.1, etc. Used for deleting files or moving corrupt files aside.
    
    Parameters:
    
    fileNum - the file we want to move
    
    newSuffix - the new file suffix
    
    subDir - the data directory sub-directory to rename the file into. The subDir must already exist. May be null to leave the file in its current data directory.
    
    Returns:
    
    renamed File if successful, or null if File.renameTo returns false, which can occur on Windows if the file was recently closed.
    
    Throws:
    
    IOException
  - deleteFile
```
public boolean deleteFile(long fileNum)
                   throws IOException,
                          DatabaseException
```
    Delete log file NNNNNNNN.
    
    Parameters:
    
    fileNum - the file we want to move
    
    Returns:
    
    true if successful, false if File.delete returns false, which can occur on Windows if the file was recently closed.
    
    Throws:
    
    IOException
    
    DatabaseException
  - openFileReadWrite
```
public RandomAccessFile openFileReadWrite(String fullPath)
                                   throws FileNotFoundException
```
    Opens an existing file for read-write access. Used in exceptional circumstances where writing to an existing file is acceptable, but the file may be deleted or renamed concurrently by other threads. The latter can occur only if the file is not currently protected.
    
    Throws:
    
    FileNotFoundException
    
    See Also:
    
    fileUpdateMutex
  - getFileLogVersion
```
public int getFileLogVersion(long fileNum)
                      throws DatabaseException
```
    Returns the log version for the given file.
    
    Throws:
    
    DatabaseException
  - getFileHandle
```
public FileHandle getFileHandle(long fileNum)
                         throws FileNotFoundException,
                                ChecksumException,
                                DatabaseException
```
    Return a read only file handle that corresponds to this file number. Retrieve it from the cache or open it anew and validate the file header. This method takes a latch on this file, so that the file descriptor will be held in the cache as long as it's in use. When the user is done with the file, the latch must be released.
    
    Parameters:
    
    fileNum - which file
    
    Returns:
    
    the file handle for the existing or newly created file
    
    Throws:
    
    FileNotFoundException
    
    ChecksumException
    
    DatabaseException
  - getAppropriateReadWriteMode
```
public FileManager.FileMode getAppropriateReadWriteMode()
```
  - getFileHeaderPrevOffset
```
public long getFileHeaderPrevOffset(long fileNum)
                             throws FileNotFoundException,
                                    ChecksumException
```
    Returns:
    
    the prevOffset field stored in the file header.
    
    Throws:
    
    FileNotFoundException
    
    ChecksumException
  - getFileHeaderTimestamp
```
public Timestamp getFileHeaderTimestamp(long fileNum)
                                 throws FileNotFoundException,
                                        ChecksumException
```
    Returns:
    
    the time field stored in the file header, which is effectively the file's creation time.
    
    Throws:
    
    FileNotFoundException
    
    ChecksumException
  - hasQueuedWrites
```
public boolean hasQueuedWrites()
```
    Returns whether anything is in the write queue.
  - testWriteQueueLock
```
public void testWriteQueueLock()
```
    For unit testing only.
  - testWriteQueueUnlock
```
public void testWriteQueueUnlock()
```
    For unit testing only.
  - startFileCacheWarmer
```
public void startFileCacheWarmer(long recoveryStartLsn)
```
  - clear
```
public void clear()
           throws IOException,
                  DatabaseException
```
    Close all file handles and empty the cache.
    
    Throws:
    
    IOException
    
    DatabaseException
  - close
```
public void close()
           throws IOException
```
    Clear the file lock.
    
    Throws:
    
    IOException
  - lockEnvironment
```
public boolean lockEnvironment(boolean rdOnly,
                               boolean exclusive)
```
    Lock the environment. Return true if the lock was acquired. If exclusive is false, then this implements a single writer, multiple reader lock. If exclusive is true, then implement an exclusive lock. There is a lock file and there are two regions of the lock file: byte 0, and byte 1. Byte 0 is the exclusive writer process area of the lock file. If an environment is opened for write, then it attempts to take an exclusive write lock on byte 0. Byte 1 is the shared reader process area of the lock file. If an environment is opened for read-only, then it attempts to take a shared lock on byte 1. This is how we implement single writer, multi reader semantics. The cleaner, each time it is invoked, attempts to take an exclusive lock on byte 1. The owning process already either has an exclusive lock on byte 0, or a shared lock on byte 1. This will necessarily conflict with any shared locks on byte 1, even if it's in the same process and there are no other holders of that shared lock. So if there is only one read-only process, it will have byte 1 for shared access, and the cleaner can not run in it because it will attempt to get an exclusive lock on byte 1 (which is already locked for shared access by itself). If a write process comes along and tries to run the cleaner, it will attempt to get an exclusive lock on byte 1. If there are no other reader processes (with shared locks on byte 1), and no other writers (which are running cleaners on with exclusive locks on byte 1), then the cleaner will run.
  - releaseExclusiveLock
```
public void releaseExclusiveLock()
                          throws DatabaseException
```
    Throws:
    
    DatabaseException
  - checkEnvHomePermissions
```
public boolean checkEnvHomePermissions(boolean rdOnly)
                                throws DatabaseException
```
    Ensure that if the environment home dir is on readonly media or in a readonly directory that the environment has been opened for readonly access.
    
    Returns:
    
    true if the environment home dir is readonly.
    
    Throws:
    
    IllegalArgumentException - via Environment ctor
    
    DatabaseException
  - truncateSingleFile
```
public void truncateSingleFile(long fileNum,
                               long offset)
                        throws IOException,
                               DatabaseException
```
    Truncate a log at this position. Used by recovery to a timestamp utilities and by recovery to set the end-of-log position, see LastFileReader.setEndOfFile().
    This method forces a new log file to be written next, if the last file (the file truncated to) has an old version in its header. This ensures that when the log is opened by an old version of JE, a version incompatibility will be detected. [#11243]
    
    Throws:
    
    IOException
    
    DatabaseException
  - truncateLog
```
public void truncateLog(long fileNum,
                        long offset)
                 throws IOException,
                        DatabaseException
```
    Throws:
    
    IOException
    
    DatabaseException
  - makeInvisible
```
public void makeInvisible(long fileNum,
                          List<Long> lsns)
```
    Mark the specified log entries as invisible and obsolete. The entries are written here, but are fsync'ed later. If there is any problem or exception during the setting, the method will throw an EnvironmentFailureException. These changes are made directly to the file, but recently logged log entries may also be resident in the log buffers. The caller must take care to call LogManager.flush() before this method, to ensure that all entries are on disk. In addition, we must ensure that after this step, the affected log entries will only be read via a FileReader, and will not be faulted in by the LogManager. Entries may be present in the log and in the log buffers, but only the on disk version is modified by this method. The LogManager can read directly from the log buffers and may read the incorrect, non-invisible version of the log entry, rather than the invisible version from the file. This should not be an issue, because invisible log entries should be detached from the in-memory tree before they are made invisible.
    
    Parameters:
    
    fileNum - target file.
    
    lsns - The list of LSNs to make invisible, must be sorted in ascending order.
  - force
```
public void force(Set<Long> fileNums)
```
    Fsync this set of log files. Used for replication syncup rollback.
  - forceNewLogFile
```
public void forceNewLogFile()
```
    Set the flag that causes a new file to be written before the next write.
  - firstLogEntryOffset
```
public static int firstLogEntryOffset()
```
    Return the offset of the first log entry after the file header.
    
    Returns:
    
    the size in bytes of the file header log entry.
  - getNextLsn
```
public long getNextLsn()
```
    Return the next available LSN in the log. Note that this is unsynchronized, so if it is called outside the log write latch it is only valid as an approximation.
  - getLastUsedLsn
```
public long getLastUsedLsn()
```
    Return the last allocated LSN in the log. Note that this is unsynchronized, so if it is called outside the log write latch it is only valid as an approximation.
  - noteFsyncTime
```
public boolean noteFsyncTime(long fSyncMs)
```
    Update fsync statistics given that an fsync was performed which took the specified amount of time in milliseconds. Returns true if this value is a new maximum for the current statistics time period.

Class FileManager

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

WRITE_COUNT

STOP_ON_WRITE_COUNT

N_BAD_WRITES

THROW_ON_WRITE

JE_SUFFIX

DEL_SUFFIX

BAD_SUFFIX

TMP_SUFFIX

BUP_SUFFIX

VERIFY_CHECKSUMS

LOGWRITE_EXCEPTION_TESTING

fileFactory

Constructor Detail

FileManager

Method Detail

setLastPosition

setSyncAtFileEnd

getFirstFileNum

getReadOnly

getLastFileNum

getCurrentFileNum

isFileValid

setIncludeDeletedFiles

getAllFileNumbers

getFollowingFileNum

filesExist

getNumFromName

listFileNames

listFiles

listJDBFiles

listJDBFilesInternalSingleDir

listJDBFilesInternalMultiDir

gatherDataDirs

getFullFileName

getFullFileName

getPartialFileName

getFullFileName

getFileName

getFileName

renameFile

renameFile

deleteFile

openFileReadWrite

getFileLogVersion

getFileHandle

getAppropriateReadWriteMode

getFileHeaderPrevOffset

getFileHeaderTimestamp

hasQueuedWrites

testWriteQueueLock

testWriteQueueUnlock

startFileCacheWarmer

clear

close

lockEnvironment

releaseExclusiveLock

checkEnvHomePermissions

truncateSingleFile

truncateLog

makeInvisible

force

forceNewLogFile

firstLogEntryOffset

getNextLsn

getLastUsedLsn

noteFsyncTime