RWStrategy (Blazegraph Database Platform 2.1.5 API)

java.lang.Object
- com.bigdata.rawstore.AbstractRawStore
- - com.bigdata.journal.RWStrategy

All Implemented Interfaces:

ICounterSetAccess, IBufferStrategy, IHABufferStrategy, IAddressManager, IAllocationManagerStore, IMRMW, IMROW, IRawStore, IStreamStore, IAllocationManager, IHistoryManager, IRWStrategy
```
public class RWStrategy
extends AbstractRawStore
implements IBufferStrategy, IHABufferStrategy, IRWStrategy
```
A highly scalable persistent IBufferStrategy wrapping the RWStore which may be used as the backing store for a Journal.
The RWStore manages allocation slots. This can translate into an enormous space savings on the disk for large data sets (when compared to the WORM) since old revisions of B+Tree nodes and leaves may be recycled efficiently.
History
The RWStrategy supports access to historical commit states in combination with the history retention policy of the ITransactionService.
Compatibility
The RWStore uses a distinct binary layout on the disk based which is not directly compatible with the WORM binary storage layer. The WORM and the RWStore uses the same file header and root blocks. However, the RWStore defines some fields in the root blocks which are not used by the WORM store such as the metabits info. In addition, some of the root block fields defined by the WORM store are not used by the RWStore.

Author:

Martyn Cutcher

See Also:
RWStore.Options

Field Summary
- Fields inherited from interface com.bigdata.rawstore.IAddressManager
  NULL

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`abort()` Calls through to store and then to WriteCacheService.reset
`void`	`abortContext(IAllocationContext context)` Indicates that the allocation context will no longer be used and that the allocations made within the context should be discarded.
`int`	`checkDeferredFrees(AbstractJournal journal)` Lifted to provide a direct interface from the Journal so that the CommitRecordIndex can be pruned prior to store commit.
`void`	`close()` Close the store immediately.
`void`	`closeForWrites()` Operation is not supported.
`void`	`commit()` A method that removes assumptions of how a specific strategy commits data.
`void`	`computeDigest(Object snapshot, MessageDigest digest)` Compute the digest of the entire backing store (including the magic, file version, root blocks, etc).
`void`	`delete(long addr)` The default implementation is a NOP.
`void`	`delete(long addr, IAllocationContext context)` Must check whether there are existing transactions which may access this data, and if not free immediately, otherwise defer.
`void`	`deleteResources()` Deletes the backing file(s) (if any).
`void`	`destroy()` Closes the store immediately (if open) and deletes its persistent resources.
`void`	`detachContext(IAllocationContext context)` Indicates that the allocation context will no longer be used, but that the allocations made within the context should be preserved.
`void`	`force(boolean metadata)` Force the data to stable storage.
`IAddressManager`	`getAddressManager()` Return the delegate object that provides the `IAddressManager` implementation for this `IRawStore`.
`long`	`getBlockSequence()` Return the #of `WriteCache` blocks that were written out for the last write set.
`BufferMode`	`getBufferMode()` The buffer mode supported by the implementation
`int`	`getByteCount(long addr)` The length of the datum in bytes.
`Lock`	`getCommitLock()` Optionally return a `Lock` that must be used (when non- `null`) to make the `IBufferStrategy.commit()` / `IRWStrategy.postCommit()` strategy atomic.
`CounterSet`	`getCounters()` Return the performance counter hierarchy.
`long`	`getCurrentBlockSequence()` Return the then-current write cache block sequence.
`long`	`getExtent()` The current size of the journal in bytes.
`File`	`getFile()` The backing file -or- `null` if there is no backing file for the store.
`int`	`getHeaderSize()` The size of the journal header, including MAGIC, version, and both root blocks.
`long`	`getInitialExtent()` The initial extent.
`InputStream`	`getInputStream(long addr)` Return an input stream from which a previously written stream may be read back.
`long`	`getLastReleaseTime()` If history is retained this returns the time for which data was most recently released.
`long`	`getMaximumExtent()` The maximum extent allowable before a buffer overflow operation will be rejected.
`int`	`getMaxRecordSize()`
`long`	`getMetaBitsAddr()` The RWStrategy requires meta allocation info in the root block, this method is the hook to enable access.
`long`	`getMetaStartAddr()` The RWStrategy requires meta allocation info in the root block, this method is the hook to enable access.
`long`	`getNextOffset()` The next offset at which a data item would be written on the store as an offset into the user extent.
`long`	`getOffset(long addr)` The offset on the store at which the datum is stored.
`int`	`getOffsetBits()` Although the RW Store uses a latched addressing strategy it is not meaningful to make this available in this interface.
`IPSOutputStream`	`getOutputStream()` Return an output stream which can be used to write on the backing store.
`IPSOutputStream`	`getOutputStream(IAllocationContext context)` Return an output stream which can be used to write on the backing store within the given allocation context.
`long`	`getPhysicalAddress(long addr)` Determine the unencoded physical address
`IResourceMetadata`	`getResourceMetadata()` Not supported - this is available on the `AbstractJournal`.
`RWStore`	`getStore()` Return the backing `IStore`.
`StoreState`	`getStoreState()` A StoreState object references critical transient data that can be used to determine a degree of consistency between stores, specifically for an HA context.
`long`	`getUserExtent()` The size of the user data extent in bytes.
`UUID`	`getUUID()` Return the `UUID` which identifies this `IRawStore`.
`WriteCacheService`	`getWriteCacheService()` Return the `WriteCacheService` (mainly for debugging).
`boolean`	`inWriteCache(long addr)` Return `true` iff the address was in the write cache as of the moment the write cache was inspected.
`boolean`	`isCommitted(long addr)` Return true if the address is marked as committed in the `RWStore` in memory bit maps.
`boolean`	`isDirty()` Supports protocol in BigdataSailConnection to check for modifications prior to calling rollback().
`boolean`	`isFullyBuffered()` True iff the store is fully buffered (all reads are against memory).
`boolean`	`isOpen()` `true` iff the store is open.
`boolean`	`isReadOnly()` `true` iff the store does not allow writes.
`boolean`	`isStable()` True iff backed by stable storage.
`boolean`	`lockAddress(long addr)` An assert oriented method that allows a finite number of addresses to be monitored to ensure it is not freed.
`IAllocationContext`	`newAllocationContext(boolean isolated)` Creates a context to be used to isolate updates to within the context until it is released to the parent environment.
`IRawTx`	`newTx()` A hook used to support session protection by incrementing and decrementing a transaction counter within the `IStore`.
`void`	`postCommit()` Called post commit to dispose any transient commit state retained to support reset/rollback.
`void`	`postHACommit(IRootBlockView rootBlock)` Provides a trigger for synchronization of transient state after a commit.
`ByteBuffer`	`read(long addr)` Read the data (unisolated).
`ByteBuffer`	`readFromLocalStore(long addr)` Read from the local store in support of failover reads on nodes in a highly available `Quorum`.
`ByteBuffer`	`readRaw(long position, ByteBuffer transfer)` Used to support the rebuild protocol.
`ByteBuffer`	`readRootBlock(boolean rootBlock0)` Read the specified root block from the backing file.
`void`	`registerExternalCache(ConcurrentWeakValueCache<Long,ICommitter> historicalIndexCache, int byteCount)` Call made from AbstractJournal to register the cache used.
`boolean`	`requiresCommit(IRootBlockView block)` A method that removes assumptions of how a specific strategy determines whether a transaction commit is required.
`void`	`resetFromHARootBlock(IRootBlockView rootBlock)` Reload from the current root block - CAUTION : THIS IS NOT A RESET / ABORT.
`long`	`saveDeferrals()` Saves the current list of delete blocks, returning the address allocated.
`Future<Void>`	`sendHALogBuffer(IHALogRequest req, IHAWriteMessage msg, IBufferAccess b)` Send an `IHAWriteMessage` and the associated raw buffer through the write pipeline.
`Future<Void>`	`sendRawBuffer(IHARebuildRequest req, long sequence, long quorumToken, long fileExtent, long offset, int nbytes, ByteBuffer b)` Send an `IHAWriteMessage` and the associated raw buffer through the write pipeline.
`void`	`setExtentForLocalStore(long extent)` Called from HAGlue.receiveAndReplicate to ensure the correct file extent prior to any writes.
`long`	`size()` The #of application data bytes written on the store (does not count any headers or root blocks that may exist for the store).
`Object`	`snapshotAllocators()` Snapshot the allocators in preparation for computing a digest of the committed allocations.
`long`	`toAddr(int nbytes, long offset)` Converts a byte count and offset into a long integer.
`String`	`toString(long addr)` A human readable representation of the address.
`long`	`transferTo(RandomAccessFile out)` Operation is not supported.
`void`	`truncate(long extent)` Either truncates or extends the journal.
`boolean`	`useChecksums()` Return `true` if the store uses per-record checksums.
`long`	`write(ByteBuffer data)` Write the data (unisolated).
`long`	`write(ByteBuffer data, IAllocationContext context)` Overridden to integrate with the shadow allocator support of the `RWStore`.
`void`	`writeOnStream(OutputStream os, AbstractJournal.ISnapshotData snapshotData, Quorum<HAGlue,QuorumService<HAGlue>> quorum, long token)` Write a consistent snapshot of the committed state of the backing store.
`void`	`writeRawBuffer(HARebuildRequest req, IHAWriteMessage msg, ByteBuffer transfer)` Used to support the rebuild protocol
`void`	`writeRawBuffer(IHAWriteMessage msg, IBufferAccess b)` Write a buffer containing data replicated from the master onto the local persistence store.
`void`	`writeRootBlock(IRootBlockView rootBlock, ForceEnum forceOnCommit)` Write the root block onto stable storage (ie, flush it through to disk).

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

- Method Detail
  - readRootBlock
```
public ByteBuffer readRootBlock(boolean rootBlock0)
```
    Description copied from interface: IBufferStrategy
    
    Read the specified root block from the backing file.
    
    Specified by:
    
    readRootBlock in interface IBufferStrategy
  - read
```
public ByteBuffer read(long addr)
```
    Description copied from interface: IRawStore
    
    Read the data (unisolated).
    
    Specified by:
    
    read in interface IRawStore
    
    Parameters:
    addr - A long integer that encodes both the offset from which the data will be read and the #of bytes to be read. See IAddressManager.toAddr(int, long).
    
    Returns:
    The data read. The buffer will be flipped to prepare for reading (the position will be zero and the limit will be the #of bytes read).
  - write
```
public long write(ByteBuffer data)
```
    Description copied from interface: IRawStore
    
    Write the data (unisolated).
    
    Specified by:
    
    write in interface IRawStore
    
    Parameters:
    data - The data. The bytes from the current Buffer.position() to the Buffer.limit() will be written and the Buffer.position() will be advanced to the Buffer.limit() . The caller may subsequently modify the contents of the buffer without changing the state of the store (i.e., the data are copied into the store).
    
    Returns:
    A long integer formed that encodes both the offset from which the data may be read and the #of bytes to be read. See IAddressManager.
  - write
```
public long write(ByteBuffer data,
         IAllocationContext context)
```
    Overridden to integrate with the shadow allocator support of the RWStore. Shadow allocators may be used to isolate allocation changes (both allocating slots and releasing slots) across different processes.
    
    Specified by:
    
    write in interface IAllocationManagerStore
    
    Parameters:
    data - The data.
    context - The allocation context.
    
    Returns:
    The address at which the data was written.
  - delete
```
public void delete(long addr)
```
    Description copied from class: AbstractRawStore
    
    The default implementation is a NOP.
    
    Specified by:
    
    delete in interface IRawStore
    
    Overrides:
    
    delete in class AbstractRawStore
    
    Parameters:
    addr - A long integer formed using Addr that encodes both the offset at which the data was written and the #of bytes that were written.
  - delete
```
public void delete(long addr,
          IAllocationContext context)
```
    Must check whether there are existing transactions which may access this data, and if not free immediately, otherwise defer.
    
    Specified by:
    
    delete in interface IAllocationManagerStore
    
    Parameters:
    addr - The address whose allocation is to be deleted.
    context - The allocation context.
  - detachContext
```
public void detachContext(IAllocationContext context)
```
    Description copied from interface: IAllocationManager
    
    Indicates that the allocation context will no longer be used, but that the allocations made within the context should be preserved. The allocations associated with the context are propagated to the parent allocation context. The IStore is the top-level parent of allocation contexts. The allocators associated with the allocation context are return to the global list of available allocators.
    
    Specified by:
    
    detachContext in interface IAllocationManager
    
    Parameters:
    context - The application object which serves as the allocation context.
  - abortContext
```
public void abortContext(IAllocationContext context)
```
    Description copied from interface: IAllocationManager
    
    Indicates that the allocation context will no longer be used and that the allocations made within the context should be discarded. The allocations associated with the context are discarded, as are any deletes made within the scope of that allocation context. The allocators associated with the allocation context are return to the global list of available allocators.
    
    Specified by:
    
    abortContext in interface IAllocationManager
    
    Parameters:
    context - The application object which serves as the allocation context.
  - closeForWrites
```
public void closeForWrites()
```
    Operation is not supported.
    
    Specified by:
    
    closeForWrites in interface IBufferStrategy
    
    Throws:
    
    UnsupportedOperationException - always.
  - getBufferMode
```
public BufferMode getBufferMode()
```
    Description copied from interface: IBufferStrategy
    
    The buffer mode supported by the implementation
    
    Specified by:
    
    getBufferMode in interface IBufferStrategy
    
    Returns:
    The implemented buffer mode.
  - getCounters
```
public CounterSet getCounters()
```
    Description copied from interface: IBufferStrategy
    
    Return the performance counter hierarchy.
    
    Specified by:
    
    getCounters in interface ICounterSetAccess
    
    Specified by:
    
    getCounters in interface IBufferStrategy
  - getExtent
```
public long getExtent()
```
    Description copied from interface: IBufferStrategy
    
    The current size of the journal in bytes. When the journal is backed by a disk file this is the actual size on disk of that file. The initial value for this property is set by Options.INITIAL_EXTENT.
    
    Specified by:
    
    getExtent in interface IBufferStrategy
  - getHeaderSize
```
public int getHeaderSize()
```
    Description copied from interface: IBufferStrategy
    
    The size of the journal header, including MAGIC, version, and both root blocks. This is used as an offset when computing the address of a record in an underlying file and is ignored by buffer modes that are not backed by a file (e.g., transient) or that are memory mapped (since the map is setup to skip over the header)
    
    Specified by:
    
    getHeaderSize in interface IBufferStrategy
  - getInitialExtent
```
public long getInitialExtent()
```
    Description copied from interface: IBufferStrategy
    
    The initial extent.
    
    Specified by:
    
    getInitialExtent in interface IBufferStrategy
  - getMaximumExtent
```
public long getMaximumExtent()
```
    Description copied from interface: IBufferStrategy
    
    The maximum extent allowable before a buffer overflow operation will be rejected.
    Note: The semantics here differ from those defined by Options.MAXIMUM_EXTENT. The latter specifies the threshold at which a journal will overflow (onto another journal) while this specifies the maximum size to which a buffer is allowed to grow.
    Note: This is normally zero (0L), which basically means that the maximum extent is ignored by the IBufferStrategy but respected by the AbstractJournal, resulting in a soft limit on journal overflow.
    
    Specified by:
    
    getMaximumExtent in interface IBufferStrategy
    
    Returns:
    The maximum extent permitted for the buffer -or- 0L iff no limit is imposed.
  - useChecksums
```
public boolean useChecksums()
```
    Description copied from interface: IBufferStrategy
    
    Return true if the store uses per-record checksums. When true, an additional 4 bytes are written after the record on the disk. Those bytes contain the checksum of the record.
    
    Specified by:
    
    useChecksums in interface IBufferStrategy
  - getNextOffset
```
public long getNextOffset()
```
    Description copied from interface: IBufferStrategy
    
    The next offset at which a data item would be written on the store as an offset into the user extent.
    
    Specified by:
    
    getNextOffset in interface IBufferStrategy
  - getUserExtent
```
public long getUserExtent()
```
    Description copied from interface: IBufferStrategy
    
    The size of the user data extent in bytes.
    Note: The size of the user extent is always generally smaller than the value reported by IBufferStrategy.getExtent() since the latter also reports the space allocated to the journal header and root blocks.
    
    Specified by:
    
    getUserExtent in interface IBufferStrategy
  - transferTo
```
public long transferTo(RandomAccessFile out)
                throws IOException
```
    Operation is not supported.
    
    Specified by:
    
    transferTo in interface IBufferStrategy
    
    Parameters:
    out - The file to which the buffer contents will be transferred.
    
    Returns:
    The #of bytes written.
    
    Throws:
    
    UnsupportedOperationException - always.
    
    IOException
  - truncate
```
public void truncate(long extent)
```
    Description copied from interface: IBufferStrategy
    
    Either truncates or extends the journal.
    Note: Implementations of this method MUST be synchronized so that the operation is atomic with respect to concurrent writers.
    
    Specified by:
    
    truncate in interface IBufferStrategy
    
    Parameters:
    extent - The new extent of the journal. This value represent the total extent of the journal, including any root blocks together with the user extent.
  - writeRootBlock
```
public void writeRootBlock(IRootBlockView rootBlock,
                  ForceEnum forceOnCommit)
```
    Description copied from interface: IBufferStrategy
    
    Write the root block onto stable storage (ie, flush it through to disk).
    
    Specified by:
    
    writeRootBlock in interface IBufferStrategy
    
    Parameters:
    rootBlock - The root block. Which root block is indicated by IRootBlockView.isRootBlock0().
  - close
```
public void close()
```
    Description copied from interface: IRawStore
    
    Close the store immediately.
    
    Specified by:
    
    close in interface IRawStore
  - deleteResources
```
public void deleteResources()
```
    Description copied from interface: IRawStore
    
    Deletes the backing file(s) (if any).
    
    Specified by:
    
    deleteResources in interface IRawStore
  - destroy
```
public void destroy()
```
    Description copied from interface: IRawStore
    
    Closes the store immediately (if open) and deletes its persistent resources. Does NOT throw an IllegalStateException if the store is already closed, but still deletes the backing resources.
    
    Specified by:
    
    destroy in interface IRawStore
    
    See Also:
    IRawStore.deleteResources()
  - commit
```
public void commit()
```
    Description copied from interface: IBufferStrategy
    
    A method that removes assumptions of how a specific strategy commits data. For most strategies the action is void since the client WORM DISK strategy writes data as allocated. For the Read Write Strategy more data must be managed as part of the protocol outside of the RootBlock, and this is the method that triggers that management. The caller MUST provide appropriate synchronization.
    
    Specified by:
    
    commit in interface IBufferStrategy
  - abort
```
public void abort()
```
    Calls through to store and then to WriteCacheService.reset
    
    Specified by:
    
    abort in interface IBufferStrategy
  - force
```
public void force(boolean metadata)
```
    Description copied from interface: IRawStore
    
    Force the data to stable storage. While this is NOT sufficient to guarantee an atomic commit, the data must be forced to disk as part of an atomic commit protocol.
    
    Specified by:
    
    force in interface IRawStore
    
    Parameters:
    metadata - If true, then force both the file contents and the file metadata to disk.
  - getFile
```
public File getFile()
```
    Description copied from interface: IRawStore
    
    The backing file -or- null if there is no backing file for the store.
    
    Specified by:
    
    getFile in interface IRawStore
  - getResourceMetadata
```
public IResourceMetadata getResourceMetadata()
```
    Not supported - this is available on the AbstractJournal.
    
    Specified by:
    
    getResourceMetadata in interface IRawStore
    
    Throws:
    
    UnsupportedOperationException - always
  - getUUID
```
public UUID getUUID()
```
    Description copied from interface: IRawStore
    
    Return the UUID which identifies this IRawStore. This supports IRawStore.getResourceMetadata().
    
    Specified by:
    
    getUUID in interface IRawStore
  - isFullyBuffered
```
public boolean isFullyBuffered()
```
    Description copied from interface: IRawStore
    
    True iff the store is fully buffered (all reads are against memory). Implementations MAY change the value returned by this method over the life cycle of the store, e.g., to conserve memory a store may drop or decrease its buffer if it is backed by disk.
    Note: This does not guarantee that the OS will not swap the buffer onto disk.
    
    Specified by:
    
    isFullyBuffered in interface IRawStore
  - isOpen
```
public boolean isOpen()
```
    Description copied from interface: IRawStore
    
    true iff the store is open.
    
    Specified by:
    
    isOpen in interface IRawStore
    
    Returns:
    true iff the store is open.
  - isReadOnly
```
public boolean isReadOnly()
```
    Description copied from interface: IRawStore
    
    true iff the store does not allow writes.
    
    Specified by:
    
    isReadOnly in interface IRawStore
  - isStable
```
public boolean isStable()
```
    Description copied from interface: IRawStore
    
    True iff backed by stable storage.
    
    Specified by:
    
    isStable in interface IRawStore
  - size
```
public long size()
```
    The #of application data bytes written on the store (does not count any headers or root blocks that may exist for the store).
    Overridden to return the #of bytes in the file rather than the user bytes. This is because the RWStore does not know the #of bytes of user data in each allocation slot. Therefore it is not able to keep accurrate track of the user bytes as allocation slots are cycled.
    
    Specified by:
    
    size in interface IRawStore
    
    See Also:
    (Records must store the as-written length for HA failover reads to be successful.)
  - getAddressManager
```
public IAddressManager getAddressManager()
```
    Description copied from class: AbstractRawStore
    
    Return the delegate object that provides the IAddressManager implementation for this IRawStore.
    Note: LRUNexus depends on the delegation model to retain references to the IAddressManager without causing the IRawStore to be retained. It uses the IAddressManager to decode the address in order to track the bytesOnDisk for the buffered records.
    
    Specified by:
    
    getAddressManager in interface IBufferStrategy
    
    Specified by:
    
    getAddressManager in class AbstractRawStore
  - getByteCount
```
public int getByteCount(long addr)
```
    Description copied from interface: IAddressManager
    
    The length of the datum in bytes. This must be the actual length of the record on the disk, not the length of the caller's byte[]. This is necessary in order to support transparent checksums and/or compression for records in the IRawStore.
    
    Specified by:
    
    getByteCount in interface IAddressManager
    
    Parameters:
    addr - The opaque identifier that is the within store locator for some datum.
    
    Returns:
    The offset of that datum.
  - getOffset
```
public long getOffset(long addr)
```
    Description copied from interface: IAddressManager
    
    The offset on the store at which the datum is stored. While this is often the offset of a byte into a file on disk, implementations MAY assign offsets using other strategies.
    
    Specified by:
    
    getOffset in interface IAddressManager
    
    Parameters:
    addr - The opaque identifier that is the within store locator for some datum.
    
    Returns:
    The offset of that datum.
  - toAddr
```
public long toAddr(int nbytes,
          long offset)
```
    Description copied from interface: IAddressManager
    
    Converts a byte count and offset into a long integer.
    
    Specified by:
    
    toAddr in interface IAddressManager
    
    Parameters:
    nbytes - The byte count.
    offset - The byte offset.
    
    Returns:
    The long integer.
  - toString
```
public String toString(long addr)
```
    Description copied from interface: IAddressManager
    
    A human readable representation of the address.
    
    Specified by:
    
    toString in interface IAddressManager
    
    Parameters:
    addr - The opaque identifier that is the within store locator for some datum.
    
    Returns:
    A human readable representation.
  - requiresCommit
```
public boolean requiresCommit(IRootBlockView block)
```
    A method that removes assumptions of how a specific strategy determines whether a transaction commit is required.
    The state of the provided block is not relevant since it does not hold information on recent allocations (the meta allocations will only effect the root block after a commit). This is passed through to the RWStore which examines its internal state.
    
    Specified by:
    
    requiresCommit in interface IBufferStrategy
    
    Parameters:
    block - The root block held by the client, can be checked against the state of the Buffer Strategy
    
    Returns:
    whether any modification has occurred.
  - isDirty
```
public boolean isDirty()
```
    Supports protocol in BigdataSailConnection to check for modifications prior to calling rollback().
    
    Specified by:
    
    isDirty in interface IBufferStrategy
    
    Returns:
    true if store has been modified since last commit()
  - getMetaBitsAddr
```
public long getMetaBitsAddr()
```
    Description copied from interface: IBufferStrategy
    
    The RWStrategy requires meta allocation info in the root block, this method is the hook to enable access. The metaBitsAddr is the address in the file where the metaBits that control the allocation of the allocation blocks themselves is stored.
    
    Specified by:
    
    getMetaBitsAddr in interface IBufferStrategy
    
    Returns:
    the metaBitsAddr for the root block if any
  - getMetaStartAddr
```
public long getMetaStartAddr()
```
    Description copied from interface: IBufferStrategy
    
    The RWStrategy requires meta allocation info in the root block, this method is the hook to enable access. The metaStartAddr is the address in the file where the allocation blocks are stored.
    
    Specified by:
    
    getMetaStartAddr in interface IBufferStrategy
    
    Returns:
    the metaStartAddr for the root block if any
  - getMaxRecordSize
```
public int getMaxRecordSize()
```
    Specified by:
    
    getMaxRecordSize in interface IBufferStrategy
    
    Returns:
    the maximum record size supported by this strategy
  - getOffsetBits
```
public int getOffsetBits()
```
    Although the RW Store uses a latched addressing strategy it is not meaningful to make this available in this interface.
    
    Specified by:
    
    getOffsetBits in interface IBufferStrategy
    
    Returns:
    the number of bits available in the address to define offset
  - getStore
```
public RWStore getStore()
```
    Description copied from interface: IRWStrategy
    
    Return the backing IStore.
    
    Specified by:
    
    getStore in interface IRWStrategy
  - getPhysicalAddress
```
public long getPhysicalAddress(long addr)
```
    Description copied from interface: IAddressManager
    
    Determine the unencoded physical address
    
    Specified by:
    
    getPhysicalAddress in interface IAddressManager
    
    Parameters:
    addr - The encoded address
    
    Returns:
    an unencoded address offset
  - writeRawBuffer
```
public void writeRawBuffer(IHAWriteMessage msg,
                  IBufferAccess b)
                    throws IOException,
                           InterruptedException
```
    Description copied from interface: IHABufferStrategy
    
    Write a buffer containing data replicated from the master onto the local persistence store.
    
    Specified by:
    
    writeRawBuffer in interface IHABufferStrategy
    
    Throws:
    
    IOException
    
    InterruptedException
  - sendHALogBuffer
```
public Future<Void> sendHALogBuffer(IHALogRequest req,
                           IHAWriteMessage msg,
                           IBufferAccess b)
                             throws IOException,
                                    InterruptedException
```
    Description copied from interface: IHABufferStrategy
    
    Send an IHAWriteMessage and the associated raw buffer through the write pipeline.
    
    Specified by:
    
    sendHALogBuffer in interface IHABufferStrategy
    
    Parameters:
    req - The IHALogRequest for some HALog file.
    msg - The IHAWriteMessage.
    b - The raw buffer. Bytes from position to limit will be sent. remaining() must equal IHAWriteMessageBase.getSize().
    
    Returns:
    The Future for that request.
    
    Throws:
    
    IOException
    
    InterruptedException
  - sendRawBuffer
```
public Future<Void> sendRawBuffer(IHARebuildRequest req,
                         long sequence,
                         long quorumToken,
                         long fileExtent,
                         long offset,
                         int nbytes,
                         ByteBuffer b)
                           throws IOException,
                                  InterruptedException
```
    Description copied from interface: IHABufferStrategy
    
    Send an IHAWriteMessage and the associated raw buffer through the write pipeline.
    
    Specified by:
    
    sendRawBuffer in interface IHABufferStrategy
    
    Parameters:
    req - The IHARebuildRequest to replicate the backing file to the requesting service.
    sequence - The sequence of this IHAWriteMessage (origin ZERO (0)).
    quorumToken - The quorum token of the leader, which must remain valid across the rebuild protocol.
    fileExtent - The file extent as of the moment that the leader begins to replicate the existing backing file.
    offset - The starting offset (relative to the root blocks).
    nbytes - The #of bytes to be sent.
    b - The raw buffer. The buffer will be cleared and filled with the specified data, then sent down the write pipeline.
    
    Returns:
    The Future for that request.
    
    Throws:
    
    IOException
    
    InterruptedException
  - writeOnStream
```
public void writeOnStream(OutputStream os,
                 AbstractJournal.ISnapshotData snapshotData,
                 Quorum<HAGlue,QuorumService<HAGlue>> quorum,
                 long token)
                   throws IOException,
                          QuorumException
```
    Description copied from interface: IHABufferStrategy
    
    Write a consistent snapshot of the committed state of the backing store. This method writes all data starting after the root blocks. The caller is responsible for putting down the root blocks themselves.
    Note: The caller is able to obtain both root blocks atomically, while the strategy may not be aware of the root blocks or may not be able to coordinate their atomic capture.
    Note: The caller must ensure that the resulting snapshot will be consistent either by ensuring that no writes occur or by taking a read-lock that will prevent overwrites of committed state during this operation.
    
    Specified by:
    
    writeOnStream in interface IHABufferStrategy
    
    Parameters:
    os - Where to write the data.
    quorum - The Quorum.
    token - The token that must remain valid during this operation.
    
    Throws:
    
    IOException
    
    QuorumException - if the service is not joined with the met quorum for that token at any point during the operation.
  - snapshotAllocators
```
public Object snapshotAllocators()
```
    Description copied from interface: IHABufferStrategy
    
    Snapshot the allocators in preparation for computing a digest of the committed allocations.
    
    Specified by:
    
    snapshotAllocators in interface IHABufferStrategy
    
    Returns:
    The snapshot in a format that is backing store specific -or- null if the snapshot is a NOP for the IBufferStrategy (e.g., for the WORM).
  - computeDigest
```
public void computeDigest(Object snapshot,
                 MessageDigest digest)
                   throws DigestException,
                          IOException
```
    Description copied from interface: IHABufferStrategy
    
    Compute the digest of the entire backing store (including the magic, file version, root blocks, etc).
    Note: The digest is not reliable unless you either use a snapshot or suspend writes (on the quorum) while it is computed.
    
    Specified by:
    
    computeDigest in interface IHABufferStrategy
    
    Parameters:
    snapshot - The allocator snapshot (optional). When given, the digest is computed only for the snapshot. When null it is computed for the entire file.
    
    Throws:
    
    DigestException
    
    IOException
  - readFromLocalStore
```
public ByteBuffer readFromLocalStore(long addr)
                              throws InterruptedException
```
    Description copied from interface: IHABufferStrategy
    
    Read from the local store in support of failover reads on nodes in a highly available Quorum.
    
    Specified by:
    
    readFromLocalStore in interface IHABufferStrategy
    
    Throws:
    
    InterruptedException
  - setExtentForLocalStore
```
public void setExtentForLocalStore(long extent)
                            throws IOException,
                                   InterruptedException
```
    Called from HAGlue.receiveAndReplicate to ensure the correct file extent prior to any writes. For RW this is essential as the allocation blocks for current committed data could otherwise be overwritten and the store invalidated.
    
    Specified by:
    
    setExtentForLocalStore in interface IHABufferStrategy
    
    Throws:
    
    InterruptedException
    
    IOException
    See Also:
    IHABufferStrategy.setExtentForLocalStore(long)
  - lockAddress
```
public boolean lockAddress(long addr)
```
    An assert oriented method that allows a finite number of addresses to be monitored to ensure it is not freed.
    
    Parameters:
    addr - - address to be locked
    
    Returns:
    true - for use in assert statement
  - getLastReleaseTime
```
public long getLastReleaseTime()
```
    Description copied from interface: IHistoryManager
    
    If history is retained this returns the time for which data was most recently released. No request can be made for data earlier than this.
    
    Specified by:
    
    getLastReleaseTime in interface IHistoryManager
    
    Returns:
    latest data release time
  - checkDeferredFrees
```
public int checkDeferredFrees(AbstractJournal journal)
```
    Lifted to provide a direct interface from the Journal so that the CommitRecordIndex can be pruned prior to store commit.
    
    Specified by:
    
    checkDeferredFrees in interface IHistoryManager
    
    Returns:
    number of addresses freed
    See Also:
    AbstractJournal#commitNow()
  - isCommitted
```
public boolean isCommitted(long addr)
```
    Return true if the address is marked as committed in the RWStore in memory bit maps.
    
    Specified by:
    
    isCommitted in interface IRWStrategy
    
    Parameters:
    addr - The address.
    
    Returns:
    true iff the address is currently committed.
  - inWriteCache
```
public boolean inWriteCache(long addr)
```
    Return true iff the address was in the write cache as of the moment the write cache was inspected.
    
    Parameters:
    addr - The address.
  - newTx
```
public IRawTx newTx()
```
    Description copied from interface: IHistoryManager
    
    A hook used to support session protection by incrementing and decrementing a transaction counter within the IStore. As long as a transaction is active we can not release data which is currently marked as freed but was committed at the point the session started.
    
    Specified by:
    
    newTx in interface IHistoryManager
  - registerExternalCache
```
public void registerExternalCache(ConcurrentWeakValueCache<Long,ICommitter> historicalIndexCache,
                         int byteCount)
```
    Description copied from interface: IHistoryManager
    
    Call made from AbstractJournal to register the cache used. This can then be accessed to clear entries when storage is made available for re-cycling.
    Note: It is not safe to clear at the point of the delete request since the data could still be loaded if the data is retained for a period due to a non-zero retention period or session protection.
    
    Specified by:
    
    registerExternalCache in interface IHistoryManager
  - saveDeferrals
```
public long saveDeferrals()
```
    Description copied from interface: IHistoryManager
    
    Saves the current list of delete blocks, returning the address allocated. This can be used later to retrieve the addresses of allocations to be freed.
    Writes the content of currentTxnFreeList to the store.
    These are the current buffered frees that have yet been saved into a block referenced from the deferredFreeList
    
    Specified by:
    
    saveDeferrals in interface IHistoryManager
    
    Returns:
    the address of the deferred addresses saved on the store, or zero if none.
    See Also:
    DeleteBlockCommitter
  - getInputStream
```
public InputStream getInputStream(long addr)
```
    Description copied from interface: IStreamStore
    
    Return an input stream from which a previously written stream may be read back.
    
    Specified by:
    
    getInputStream in interface IStreamStore
    
    Overrides:
    
    getInputStream in class AbstractRawStore
    
    Parameters:
    addr - The address at which the stream was written.
    
    Returns:
    an input stream for the data for provided address
  - getOutputStream
```
public IPSOutputStream getOutputStream()
```
    Description copied from interface: IStreamStore
    
    Return an output stream which can be used to write on the backing store. You can recover the address used to read back the data from the IPSOutputStream.
    
    Specified by:
    
    getOutputStream in interface IStreamStore
    
    Overrides:
    
    getOutputStream in class AbstractRawStore
    
    Returns:
    The output stream.
  - getOutputStream
```
public IPSOutputStream getOutputStream(IAllocationContext context)
```
    Description copied from interface: IAllocationManagerStore
    
    Return an output stream which can be used to write on the backing store within the given allocation context. You can recover the address used to read back the data from the IPSOutputStream.
    
    Specified by:
    
    getOutputStream in interface IAllocationManagerStore
    
    Parameters:
    context - The context within which any allocations are made by the returned IPSOutputStream.
    
    Returns:
    an output stream to stream data to and to retrieve an address to later stream the data back.
  - resetFromHARootBlock
```
public void resetFromHARootBlock(IRootBlockView rootBlock)
```
    Description copied from interface: IHABufferStrategy
    
    Reload from the current root block - CAUTION : THIS IS NOT A RESET / ABORT. The purpose of this method is to reload the root block under some very limited circumstances, specifically when the root blocks were replaced during a REBUILD or RESYNC of the backing store for HA.
    Note: This method is used when the root blocks of the leader are installed onto a follower. This can change the UUID for the backing store file. The IHABufferStrategy implementation MUST update any cached value for that UUID.
    Use IHABufferStrategy.postHACommit(IRootBlockView) rather than this method in the 2-phase commit on the follower.
    
    Specified by:
    
    resetFromHARootBlock in interface IHABufferStrategy
    
    See Also:
    Latency on followers during commit on leader
  - getBlockSequence
```
public long getBlockSequence()
```
    Description copied from interface: IHABufferStrategy
    
    Return the #of WriteCache blocks that were written out for the last write set. This is used to communicate the #of write cache blocks in the commit point back to AbstractJournal.commitNow(long). It is part of the commit protocol.
    Note: This DOES NOT reflect the current value of the block sequence counter for ongoing writes. That counter is owned by the WriteCacheService.
    
    Specified by:
    
    getBlockSequence in interface IHABufferStrategy
    
    See Also:
    WriteCacheService.resetSequence(), FIXME I would prefer to expose the {@link WriteCacheService} to the {@link AbstractJournal} and let it directly invoke {@link WriteCacheService#resetSequence()}. The current pattern requires the {@link IHABufferStrategy} implementations to track the lastBlockSequence and is messy.
  - getCurrentBlockSequence
```
public long getCurrentBlockSequence()
```
    Description copied from interface: IHABufferStrategy
    
    Return the then-current write cache block sequence.
    
    Specified by:
    
    getCurrentBlockSequence in interface IHABufferStrategy
    
    See Also:
    IHABufferStrategy.getBlockSequence()
  - readRaw
```
public ByteBuffer readRaw(long position,
                 ByteBuffer transfer)
```
    Description copied from interface: IHABufferStrategy
    
    Used to support the rebuild protocol.
    
    Specified by:
    
    readRaw in interface IHABufferStrategy
    
    Parameters:
    position - - absolute file offset
    transfer - - target buffer for read
  - writeRawBuffer
```
public void writeRawBuffer(HARebuildRequest req,
                  IHAWriteMessage msg,
                  ByteBuffer transfer)
                    throws IOException
```
    Description copied from interface: IHABufferStrategy
    
    Used to support the rebuild protocol
    
    Specified by:
    
    writeRawBuffer in interface IHABufferStrategy
    
    Throws:
    
    IOException
  - getCommitLock
```
public Lock getCommitLock()
```
    Description copied from interface: IRWStrategy
    
    Optionally return a Lock that must be used (when non- null) to make the IBufferStrategy.commit() / IRWStrategy.postCommit() strategy atomic.
    
    Specified by:
    
    getCommitLock in interface IRWStrategy
  - postCommit
```
public void postCommit()
```
    Description copied from interface: IRWStrategy
    
    Called post commit to dispose any transient commit state retained to support reset/rollback.
    Note: It is the responsibility of the commit protocol layers to wind up calling IBufferStrategy.abort() if there is a failure during the commit protocol.
    
    Specified by:
    
    postCommit in interface IRWStrategy
  - postHACommit
```
public void postHACommit(IRootBlockView rootBlock)
```
    Description copied from interface: IHABufferStrategy
    
    Provides a trigger for synchronization of transient state after a commit.
    For the RWStore this is used to resynchronize the allocators during the 2-phase commit on the follower with the delta in the allocators from the write set associated with that commit.
    
    Specified by:
    
    postHACommit in interface IHABufferStrategy
    
    Parameters:
    rootBlock - The newly installed root block.
    See Also:
    Latency on followers during commit on leader
  - getWriteCacheService
```
public WriteCacheService getWriteCacheService()
```
    Description copied from interface: IHABufferStrategy
    
    Return the WriteCacheService (mainly for debugging).
    
    Specified by:
    
    getWriteCacheService in interface IHABufferStrategy
  - getStoreState
```
public StoreState getStoreState()
```
    Description copied from interface: IHABufferStrategy
    
    A StoreState object references critical transient data that can be used to determine a degree of consistency between stores, specifically for an HA context.
    
    Specified by:
    
    getStoreState in interface IHABufferStrategy
  - newAllocationContext
```
public IAllocationContext newAllocationContext(boolean isolated)
```
    Description copied from interface: IAllocationManager
    
    Creates a context to be used to isolate updates to within the context until it is released to the parent environment.
    
    Specified by:
    
    newAllocationContext in interface IAllocationManager
    
    Returns:
    a new IAlocationContext

Class RWStrategy

History

Compatibility

Field Summary

Fields inherited from interface com.bigdata.rawstore.IAddressManager

Method Summary

Methods inherited from class java.lang.Object

Method Detail

readRootBlock

read

write

write

delete

delete

detachContext

abortContext

closeForWrites

getBufferMode

getCounters

getExtent

getHeaderSize

getInitialExtent

getMaximumExtent

useChecksums

getNextOffset

getUserExtent

transferTo

truncate

writeRootBlock

close

deleteResources

destroy

commit

abort

force

getFile

getResourceMetadata

getUUID

isFullyBuffered

isOpen

isReadOnly

isStable

size

getAddressManager

getByteCount

getOffset

toAddr

toString

requiresCommit

isDirty

getMetaBitsAddr

getMetaStartAddr

getMaxRecordSize

getOffsetBits

getStore

getPhysicalAddress

writeRawBuffer

sendHALogBuffer

sendRawBuffer

writeOnStream

snapshotAllocators

computeDigest

readFromLocalStore

setExtentForLocalStore

lockAddress

getLastReleaseTime

checkDeferredFrees

isCommitted

inWriteCache

newTx

registerExternalCache

saveDeferrals

getInputStream

getOutputStream

getOutputStream

resetFromHARootBlock

getBlockSequence

getCurrentBlockSequence

readRaw

writeRawBuffer