Kinesis

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 finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

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

Definition Classes
Any
lazy val logger: Logger

Attributes
protected
Definition Classes
LazyLogging
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def sink(producerName: String, inConfig: String = "kinesis", credentialsProvider: Option[AWSCredentialsProvider] = None)(implicit system: ActorSystem): Sink[ProducerEvent, Future[Done]]

Create a Sink that accepts ProducerEvents, which get published to Kinesis.
Create a Sink that accepts ProducerEvents, which get published to Kinesis.
The sink itself sends all events to an KinesisProducerActor which is configured from the system configuration for given producer name. Every message send needs to be acknowledged by the underlying producer actor.
This sink signals back pressure, if more messages than configured in throttling conf are not acknowledged. If throttling is not configured, a default value (= 1000 messages) is applied.
The sink produces a materialized value Future[Done], which is finished if all messages of the stream are send to the producer actor _and_ got acknowledged. The future fails, if the sending an event fails or upstream has failed the stream.
A minimal application conf file should look like this:
```
kinesis {
   application-name = "SampleService"
   producer-name {
      stream-name = "sample-stream"
      akka.max-outstanding-requests = 100
   }
}
```
See kinesis reference.conf for a list of all available config options.
producerName
the name of the producer in the system configuration.
inConfig
the configuration object that holds the producer config (usually kinesis).
credentialsProvider
the AWS credentials provider to use to connect.
system
the actor system.
returns
A sink that accepts ProducerEvents.
def sink(kinesisConfig: Config, producerName: String, credentialsProvider: Option[AWSCredentialsProvider])(implicit system: ActorSystem): Sink[ProducerEvent, Future[Done]]

Create a Sink that accepts ProducerEvents, which get published to Kinesis.
Create a Sink that accepts ProducerEvents, which get published to Kinesis.
The sink itself sends all events to an KinesisProducerActor which is configured from the system configuration for given producer name. Every message send needs to be acknowledged by the underlying producer actor.
This sink signals back pressure, if more messages than configured in throttling conf are not acknowledged. If throttling is not configured, a default value (= 1000 messages) is applied.
The sink produces a materialized value Future[Done], which is finished if all messages of the stream are send to the producer actor _and_ got acknowledged. The future fails, if the sending an event fails or upstream has failed the stream.
kinesisConfig
the configuration object that holds the producer config.
producerName
the name of the producer in the system configuration.
credentialsProvider
the AWS credentials provider to use to connect.
system
the actor system.
returns
A sink that accepts ProducerEvents.
def sink(producerConf: ProducerConf)(implicit system: ActorSystem): Sink[ProducerEvent, Future[Done]]

Create a Sink that accepts ProducerEvents, which get published to Kinesis.
Create a Sink that accepts ProducerEvents, which get published to Kinesis.
The sink itself sends all events to an KinesisProducerActor which is configured with given config object. Every message send needs to be acknowledged by the underlying producer actor.
This sink signals back pressure, if more messages than configured in throttling conf are not acknowledged. If throttling is not configured, a default value (= 1000 messages) is applied.
The sink produces a materialized value Future[Done], which is finished if all messages of the stream are send to the producer actor _and_ got acknowledged. The future fails, if the sending an event fails or upstream has failed the stream.
producerConf
the configuration to create KinesisProducerActor
system
the actor system.
returns
A sink that accepts ProducerEvents.
def sink(props: ⇒ Props, maxOutStanding: Int)(implicit system: ActorSystem): Sink[ProducerEvent, Future[Done]]

Create a Sink that accepts ProducerEvents, which get published to Kinesis.
Create a Sink that accepts ProducerEvents, which get published to Kinesis.
The sink itself sends all events to an actor, which is created with the given Props. Every message send needs to be acknowledged by the underlying producer actor.
This sink signals back pressure, if more than maxOutstanding messages are not acknowledged.
The sink produces a materialized value Future[Done], which is finished if all messages of the stream are send to the producer actor _and_ got acknowledged. The future fails, if the sending an event fails or upstream has failed the stream.
props
the props to create a producer actor. This is a function to work around #48.
maxOutStanding
the number of messages to send to the actor unacknowledged before back pressure is applied.
system
the actor system.
returns
A sink that accepts ProducerEvents.
def source(consumerName: String, createConsumer: (ConsumerConf, ActorRef) ⇒ ConsumerService, inConfig: String = "kinesis")(implicit system: ActorSystem): Source[CommittableEvent[ConsumerEvent], NotUsed]

Create a source by using the actor system configuration, that provides KinesisEvents.
Create a source by using the actor system configuration, that provides KinesisEvents. Please note: every KinesisEvent has to be committed during the user flow! Uncommitted events will be retransmitted after a timeout.
A minimal application conf file should look like this:
```
kinesis {
   application-name = "SampleService"
   consumer-name {
      stream-name = "sample-stream"
   }
}
```
See kinesis reference.conf for a list of all available config options.
consumerName
the name of the consumer in the application.conf.
createConsumer
factory function to create ConsumerService from eventProcessor ActorRef.
inConfig
the name of the sub-config for kinesis.
system
the actor system to use.
returns
A source of KinesisEvent objects.
def source(consumerName: String)(implicit system: ActorSystem): Source[CommittableEvent[ConsumerEvent], NotUsed]

Create a source by using the actor system configuration, that provides KinesisEvents.
Create a source by using the actor system configuration, that provides KinesisEvents. Please note: every KinesisEvent has to be committed during the user flow! Uncommitted events will be retransmitted after a timeout.
A minimal application conf file should look like this:
```
kinesis {
   application-name = "SampleService"
   consumer-name {
      stream-name = "sample-stream"
   }
}
```
See kinesis reference.conf for a list of all available config options.
consumerName
the name of the consumer in the application.conf.
system
the actor system to use.
returns
A source of KinesisEvent objects.
def source(consumerName: String, inConfig: String)(implicit system: ActorSystem): Source[CommittableEvent[ConsumerEvent], NotUsed]

Create a source by using the actor system configuration, that provides KinesisEvents.
Create a source by using the actor system configuration, that provides KinesisEvents. Please note: every KinesisEvent has to be committed during the user flow! Uncommitted events will be retransmitted after a timeout.
A minimal application conf file should look like this:
```
kinesis {
   application-name = "SampleService"
   consumer-name {
      stream-name = "sample-stream"
   }
}
```
See kinesis reference.conf for a list of all available config options.
consumerName
the name of the consumer in the application.conf.
inConfig
the name of the sub-config for kinesis.
system
the actor system to use.
returns
A source of KinesisEvent objects.
def source(consumerConf: ConsumerConf)(implicit system: ActorSystem): Source[CommittableEvent[ConsumerEvent], NotUsed]

Create a source, that provides KinesisEvents.
Create a source, that provides KinesisEvents. Please note: every KinesisEvent has to be committed during the user flow! Uncommitted events will be retransmitted after a timeout.
consumerConf
the configuration to connect to Kinesis.
system
the actor system.
returns
A source of KinesisEvent objects.
def source(consumerConf: ConsumerConf, createConsumer: (ActorRef) ⇒ ConsumerService)(implicit system: ActorSystem): Source[CommittableEvent[ConsumerEvent], NotUsed]

Create a source, that provides KinesisEvents.
Create a source, that provides KinesisEvents. Please note: every KinesisEvent has to be committed during the user flow! Uncommitted events will be retransmitted after a timeout.
consumerConf
the configuration to connect to Kinesis.
createConsumer
factory function to create ConsumerService from eventProcessor ActorRef.
system
the actor system.
returns
A source of KinesisEvent objects.
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( ... )

Related Doc: package stream

object Kinesis extends LazyLogging

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 finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

lazy val logger: Logger

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def sink(producerName: String, inConfig: String = "kinesis", credentialsProvider: Option[AWSCredentialsProvider] = None)(implicit system: ActorSystem): Sink[ProducerEvent, Future[Done]]

def sink(kinesisConfig: Config, producerName: String, credentialsProvider: Option[AWSCredentialsProvider])(implicit system: ActorSystem): Sink[ProducerEvent, Future[Done]]

def sink(producerConf: ProducerConf)(implicit system: ActorSystem): Sink[ProducerEvent, Future[Done]]

def sink(props: ⇒ Props, maxOutStanding: Int)(implicit system: ActorSystem): Sink[ProducerEvent, Future[Done]]

def source(consumerName: String, createConsumer: (ConsumerConf, ActorRef) ⇒ ConsumerService, inConfig: String = "kinesis")(implicit system: ActorSystem): Source[CommittableEvent[ConsumerEvent], NotUsed]

def source(consumerName: String)(implicit system: ActorSystem): Source[CommittableEvent[ConsumerEvent], NotUsed]

def source(consumerName: String, inConfig: String)(implicit system: ActorSystem): Source[CommittableEvent[ConsumerEvent], NotUsed]

def source(consumerConf: ConsumerConf)(implicit system: ActorSystem): Source[CommittableEvent[ConsumerEvent], NotUsed]

def source(consumerConf: ConsumerConf, createConsumer: (ActorRef) ⇒ ConsumerService)(implicit system: ActorSystem): Source[CommittableEvent[ConsumerEvent], NotUsed]

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

Inherited from LazyLogging

Inherited from AnyRef

Inherited from Any

Ungrouped