LogStorage (Zeebe Logstreams 0.12.1 API)

All Known Implementing Classes:

FsLogStorage
```
public interface LogStorage
```
Log structured storage abstraction

Field Summary

Fields
Modifier and Type	Field and Description
`static long`	`OP_RESULT_BLOCK_SIZE_TOO_BIG` Status code returned by the `append(ByteBuffer)` operation in case the provided block is too big to write in the storage.
`static long`	`OP_RESULT_INSUFFICIENT_BUFFER_CAPACITY` Status code returned by the `read` operation only if underlying storage is block-addressable (in contrast to byte addressable).
`static long`	`OP_RESULT_INVALID_ADDR` Status code returned by the `read` operation in case the provided address is invalid and does not exist.
`static long`	`OP_RESULT_NO_DATA` Status code returned by the `read` operation in case the provided address does exist but data is not available yet.

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`long`	`append(ByteBuffer blockBuffer)` Writes a block containing one or multiple log entries in the storage and returns the address at which the block has been written.
`void`	`close()` Close the storage.
`void`	`flush()` Flushes all appended blocks to ensure that all blocks are written completely.
`long`	`getFirstBlockAddress()` Returns the address of the first block in the storage or -1 if the storage is currently empty.
`boolean`	`isByteAddressable()`
`boolean`	`isClosed()`
`boolean`	`isOpen()`
`void`	`open()` Open the storage.
`long`	`read(ByteBuffer readBuffer, long addr)` Naive implementation of the `read(ByteBuffer, long, ReadResultProcessor)` method.
`long`	`read(ByteBuffer readBuffer, long addr, ReadResultProcessor processor)` Reads bytes into the read buffer starting at addr and process the read bytes with the help of the processor.
`void`	`truncate(long address)` Truncates the log up to the given address.

- Field Detail
  - OP_RESULT_INVALID_ADDR
```
static final long OP_RESULT_INVALID_ADDR
```
    Status code returned by the read operation in case the provided address is invalid and does not exist.
    
    See Also:
    
    Constant Field Values
  - OP_RESULT_NO_DATA
```
static final long OP_RESULT_NO_DATA
```
    Status code returned by the read operation in case the provided address does exist but data is not available yet. This indicates that retrying the operation with the same parameters will eventually return data assuming that more data will be written to the log.
    
    See Also:
    
    Constant Field Values
  - OP_RESULT_INSUFFICIENT_BUFFER_CAPACITY
```
static final long OP_RESULT_INSUFFICIENT_BUFFER_CAPACITY
```
    Status code returned by the read operation only if underlying storage is block-addressable (in contrast to byte addressable). If the storage is block addressable, consumers of this API can only read complete addressable blocks of data at a time. In order to read a block, the provided read buffer must provide sufficient capacity to read at least one complete block. If sufficient capacity is not available in the read buffer to fit at least a complete block, this status code is returned.
    
    See Also:
    
    Constant Field Values
  - OP_RESULT_BLOCK_SIZE_TOO_BIG
```
static final long OP_RESULT_BLOCK_SIZE_TOO_BIG
```
    Status code returned by the append(ByteBuffer) operation in case the provided block is too big to write in the storage.
    
    See Also:
    
    Constant Field Values
- Method Detail
  - append
```
long append(ByteBuffer blockBuffer)
```
    Writes a block containing one or multiple log entries in the storage and returns the address at which the block has been written.
    Storage implementations must guarantee eventually atomicity. When this method returns, either all the bytes must be written or none at all.
    The caller of this method must guarantee that the provided block contains unfragmented log entries.
    
    Parameters:
    
    blockBuffer - the buffer containing a block of log entries to be written into storage
    
    Returns:
    
    the address at which the block has been written or error status code
  - truncate
```
void truncate(long address)
```
    Truncates the log up to the given address.
    
    Parameters:
    
    address - The address at which to truncate the log.
  - read
```
long read(ByteBuffer readBuffer,
          long addr)
```
    Naive implementation of the read(ByteBuffer, long, ReadResultProcessor) method. Does not process the bytes which are read.
    Returns an operation result status code which is either
    - positive long representing the next address at which the next block of data can be read
    - OP_RESULT_INVALID_ADDR: in case the provided address does not exist
    - OP_RESULT_NO_DATA: in case no data is (yet) available at that address
    - OP_RESULT_INSUFFICIENT_BUFFER_CAPACITY: in case the storage is block addressable and the provided buffer does not have sufficient capacity to read a whole block
    If this method returns with a positive status code, bytes will be written between the given readbuffer's Buffer.position() and Buffer.limit().
    This method is invoked concurrently by consumer threads of the log.
    Parameters:
    
    readBuffer - the buffer to read into
    
    addr - the address in the underlying storage from which bytes should be read
    
    Returns:
    
    the next address from which bytes can be read or error status code.
  - read
```
long read(ByteBuffer readBuffer,
          long addr,
          ReadResultProcessor processor)
```
    Reads bytes into the read buffer starting at addr and process the read bytes with the help of the processor.
    Returns an operation result status code which is either
    - positive long representing the next address at which the next block of data can be read
    - OP_RESULT_INVALID_ADDR: in case the provided address does not exist
    - OP_RESULT_NO_DATA: in case no data is (yet) available at that address
    - OP_RESULT_INSUFFICIENT_BUFFER_CAPACITY: in case the storage is block addressable and the provided buffer does not have sufficient capacity to read a whole block
    If this method returns with a positive status code, bytes will be written between the given readbuffer's Buffer.position() and Buffer.limit().
    This method is invoked concurrently by consumer threads of the log.
    Parameters:
    
    readBuffer - the buffer to read into
    
    addr - the address in the underlying storage from which bytes should be read
    
    processor - the processor to process the buffer and the read result
    
    Returns:
    
    the next address from which bytes can be read or error status code.
  - isByteAddressable
```
boolean isByteAddressable()
```
    Returns:
    
    true if the storage is byte addressable (each byte managed in the underlying storage can be uniquely addressed using a long addr. False in case the storage is block addressable.
  - open
```
void open()
```
    Open the storage. Called in the log conductor thread.
  - close
```
void close()
```
    Close the storage. Called in the log conductor thread.
  - isOpen
```
boolean isOpen()
```
    Returns:
    
    true, if the storage is open.
  - isClosed
```
boolean isClosed()
```
  - getFirstBlockAddress
```
long getFirstBlockAddress()
```
    Returns the address of the first block in the storage or -1 if the storage is currently empty.
  - flush
```
void flush()
    throws Exception
```
    Flushes all appended blocks to ensure that all blocks are written completely. Note that a storage implementation may do nothing if append(ByteBuffer) guarantees that all blocks are written immediately.
    
    Throws:
    
    Exception - if fails to flush all blocks

Interface LogStorage

Field Summary

Method Summary

Field Detail

OP_RESULT_INVALID_ADDR

OP_RESULT_NO_DATA

OP_RESULT_INSUFFICIENT_BUFFER_CAPACITY

OP_RESULT_BLOCK_SIZE_TOO_BIG

Method Detail

append

truncate

read

read

isByteAddressable

open

close

isOpen

isClosed

getFirstBlockAddress

flush