AvroSchemaManager

Instance Constructors

new AvroSchemaManager(connector: Connector, endianness: ByteOrder)

connector
the connector used to retrieve and persist schemas
endianness
the endianness that will be used to persist and parse fingerprint bytes, it won't affect how avro payload is written, that is up to the darwin user

Abstract Value Members

abstract def getAll: Seq[(Long, Schema)]

Retrieves all registered schemas
Retrieves all registered schemas
returns
A Sequence of (ID, Schema)
abstract def getSchema(id: Long): Option[Schema]

Extracts the Schema from its ID.
Extracts the Schema from its ID.
id
a Long representing an ID
returns
the Schema associated to the input ID
abstract def registerAll(schemas: Seq[Schema]): Seq[(Long, Schema)]

Checks if all the input Schema elements are already in the cache.
Checks if all the input Schema elements are already in the cache. Then, it performs an insert on the storage for all the elements not found on the cache, and then returns each input schema paired with its ID.
schemas
all the Schema that should be registered
returns
a sequence of pairs of the input schemas associated with their IDs
abstract def reload(): AvroSchemaManager

Reloads all the schemas from the previously configured storage.

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def extractId(avroSingleObjectEncoded: ByteBuffer): Long

Extracts the schema ID from the avro single-object encoded ByteBuffer, the ByteBuffer position will be after the header when this method returns
Extracts the schema ID from the avro single-object encoded ByteBuffer, the ByteBuffer position will be after the header when this method returns
avroSingleObjectEncoded
avro single-object encoded byte array
returns
the schema ID extracted from the input data
def extractId(inputStream: InputStream): Either[Array[Byte], Long]

Extracts the schema ID from the avro single-object encoded at the head of this input stream.
Extracts the schema ID from the avro single-object encoded at the head of this input stream. The input stream will have 10 bytes consumed if the first two bytes correspond to the single object encoded header, or zero bytes consumed if the InputStream supports marking; if it doesn't, the first bytes (up to 2) will be consumed and returned in the Left part of the Either.
inputStream
avro single-object encoded input stream
returns
the schema ID extracted from the input data
def extractId(array: Array[Byte]): Long

Extracts the schema ID from the avro single-object encoded byte array
Extracts the schema ID from the avro single-object encoded byte array
array
avro single-object encoded byte array
returns
the schema ID extracted from the input data
def extractSchema(array: Array[Byte]): Either[Exception, Schema]

Extracts the schema from the avro single-object encoded in the input array.
Extracts the schema from the avro single-object encoded in the input array.
array
avro single-object encoded array
returns
the schema ID extracted from the input data
def extractSchema(inputStream: InputStream): Either[Array[Byte], Schema]

Extracts the schema from the avro single-object encoded at the head of this input stream.
Extracts the schema from the avro single-object encoded at the head of this input stream. The input stream will have 10 bytes consumed if the first two bytes correspond to the single object encoded header, or zero bytes consumed if the InputStream supports marking; if it doesn't, the first bytes (up to 2) will be consumed and returned in the Left part of the Either
inputStream
avro single-object encoded input stream
returns
the schema ID extracted from the input data
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def generateAvroSingleObjectEncoded(byteStream: OutputStream, schemaId: Long)(avroWriter: (OutputStream) ⇒ OutputStream): OutputStream

Writes to the given OutputStream the Single Object Encoding header then calls the avroWriter function to possibly add data to the stream and finally returns the OutputStream
Writes to the given OutputStream the Single Object Encoding header then calls the avroWriter function to possibly add data to the stream and finally returns the OutputStream
byteStream
the stream to write to
schemaId
id of the schema used to encode the payload
avroWriter
function that will be called to add user generated avro to the stream
returns
the input OutputStream
def generateAvroSingleObjectEncoded(byteStream: OutputStream, avroValue: Array[Byte], schemaId: Long): OutputStream

Writes to the given OutputStream the Single Object Encoding header then the avroValue and returns the OutputStream
Writes to the given OutputStream the Single Object Encoding header then the avroValue and returns the OutputStream
byteStream
the stream to write to
avroValue
the value to be written to the stream
schemaId
id of the schema used to encode the payload
returns
the input OutputStream
def generateAvroSingleObjectEncoded(avroPayload: Array[Byte], schema: Schema): Array[Byte]

Create an array that creates a Single-Object encoded byte array.
Create an array that creates a Single-Object encoded byte array. By specifications the encoded array is obtained concatenating the V1_HEADER, the schema id and the avro-encoded payload.
avroPayload
avro-serialized payload
schema
the schema used to encode the payload
returns
a Single-Object encoded byte array
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getEndianness(): ByteOrder

returns
the configured endianness of this AvroSchemaManager instance
def getId(schema: Schema): Long

Extracts the ID from a Schema.
Extracts the ID from a Schema.
schema
a Schema with unknown ID
returns
the ID associated with the input schema
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def log: Logger

Definition Classes
Logging
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def registerAll(schemas: Iterable[Schema]): Iterable[IdSchemaPair]

JAVA API: Checks if all the input Schema elements are already in the cache.
JAVA API: Checks if all the input Schema elements are already in the cache. Then, it performs an insert on the storage for all the elements not found on the cache, and then returns each input schema paired with its ID.
schemas
all the Schema that should be registered
returns
a sequence of pairs of the input schemas associated with their IDs
def retrieveLatestSchema(identifier: String): Option[(Long, Schema)]

Retrieves the latest schema for a given string identifier (not to be confused with the fingerprint id).
Retrieves the latest schema for a given string identifier (not to be confused with the fingerprint id). This API might not be implemented by all connectors, which should return None
def retrieveSchemaAndAvroPayload(avroSingleObjectEncoded: ByteBuffer): Schema

Extracts the Schema from the ByteBuffer after the method call the ByteBuffer position will be right after the header.
Extracts the Schema from the ByteBuffer after the method call the ByteBuffer position will be right after the header.
avroSingleObjectEncoded
a ByteBuffer of a Single-Object encoded payload
returns
the avro Schema
def retrieveSchemaAndAvroPayload(avroSingleObjectEncoded: Array[Byte]): (Schema, Array[Byte])

Extracts a Tuple2 that contains the Schema and the Avro-encoded payload
Extracts a Tuple2 that contains the Schema and the Avro-encoded payload
avroSingleObjectEncoded
a byte array of a Single-Object encoded payload
returns
a pair containing the Schema and the payload of the input array
def retrieveSchemaAndPayload(avroSingleObjectEncoded: Array[Byte]): SchemaPayloadPair

Extracts a SchemaPayloadPair that contains the Schema and the Avro-encoded payload
Extracts a SchemaPayloadPair that contains the Schema and the Avro-encoded payload
avroSingleObjectEncoded
a byte array of a Single-Object encoded payload
returns
a SchemaPayloadPair containing the Schema and the payload of the input array
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def writeHeaderToStream(byteStream: OutputStream, schemaId: Long): OutputStream

Writes to the given OutputStream the Single Object Encoding header and returns the OutputStream
Writes to the given OutputStream the Single Object Encoding header and returns the OutputStream
returns
the input OutputStream

Related Doc: package manager

abstract class AvroSchemaManager extends Logging

Instance Constructors

new AvroSchemaManager(connector: Connector, endianness: ByteOrder)

Abstract Value Members

abstract def getAll: Seq[(Long, Schema)]

abstract def getSchema(id: Long): Option[Schema]

abstract def registerAll(schemas: Seq[Schema]): Seq[(Long, Schema)]

abstract def reload(): AvroSchemaManager

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def extractId(avroSingleObjectEncoded: ByteBuffer): Long

def extractId(inputStream: InputStream): Either[Array[Byte], Long]

def extractId(array: Array[Byte]): Long

def extractSchema(array: Array[Byte]): Either[Exception, Schema]

def extractSchema(inputStream: InputStream): Either[Array[Byte], Schema]

def finalize(): Unit

def generateAvroSingleObjectEncoded(byteStream: OutputStream, schemaId: Long)(avroWriter: (OutputStream) ⇒ OutputStream): OutputStream

def generateAvroSingleObjectEncoded(byteStream: OutputStream, avroValue: Array[Byte], schemaId: Long): OutputStream

def generateAvroSingleObjectEncoded(avroPayload: Array[Byte], schema: Schema): Array[Byte]

final def getClass(): Class[_]

def getEndianness(): ByteOrder

def getId(schema: Schema): Long

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def log: Logger

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def registerAll(schemas: Iterable[Schema]): Iterable[IdSchemaPair]

def retrieveLatestSchema(identifier: String): Option[(Long, Schema)]

def retrieveSchemaAndAvroPayload(avroSingleObjectEncoded: ByteBuffer): Schema

def retrieveSchemaAndAvroPayload(avroSingleObjectEncoded: Array[Byte]): (Schema, Array[Byte])

def retrieveSchemaAndPayload(avroSingleObjectEncoded: Array[Byte]): SchemaPayloadPair

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def writeHeaderToStream(byteStream: OutputStream, schemaId: Long): OutputStream

Inherited from Logging

Inherited from AnyRef

Inherited from Any

Ungrouped