StructuredStreamingETLActor

Type Members

type Event = akka.actor.FSM.Event[Data]

Definition Classes
FSM
type Receive = PartialFunction[Any, Unit]

Definition Classes
Actor
type State = akka.actor.FSM.State[etl.State, Data]

Definition Classes
FSM
type StateFunction = PartialFunction[Event, State]

Definition Classes
FSM
type StopEvent = akka.actor.FSM.StopEvent[etl.State, Data]

Definition Classes
FSM
type Timeout = Option[FiniteDuration]

Definition Classes
FSM
final class TransformHelper extends AnyRef

Definition Classes
FSM
type TransitionHandler = PartialFunction[(etl.State, etl.State), Unit]

Definition Classes
FSM

Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
val ->: akka.actor.FSM.->.type

Definition Classes
FSM
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
val Event: akka.actor.FSM.Event.type

Definition Classes
FSM
val StateTimeout: akka.actor.FSM.StateTimeout.type

Definition Classes
FSM
val StopEvent: akka.actor.FSM.StopEvent.type

Definition Classes
FSM
def activate(etl: StructuredStreamingETLModel, pipegraph: PipegraphModel): Try[DataFrame]

Performs activation of a StructuredStreamingETLModel returning the output data frame
Performs activation of a StructuredStreamingETLModel returning the output data frame
etl
The StructuredStreamingETLModel to activate
returns
the output dataframe

Attributes
protected
Definition Classes
ActivationSteps
def aroundPostRestart(reason: Throwable): Unit

Attributes
protected[akka]
Definition Classes
Actor
def aroundPostStop(): Unit

Attributes
protected[akka]
Definition Classes
Actor
def aroundPreRestart(reason: Throwable, message: Option[Any]): Unit

Attributes
protected[akka]
Definition Classes
Actor
def aroundPreStart(): Unit

Attributes
protected[akka]
Definition Classes
Actor
def aroundReceive(receive: akka.actor.Actor.Receive, msg: Any): Unit

Attributes
protected[akka]
Definition Classes
Actor
final def asInstanceOf[T0]: T0

Definition Classes
Any
final def cancelTimer(name: String): Unit

Definition Classes
FSM
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
implicit val context: ActorContext

Definition Classes
Actor
def createStrategy(etl: StructuredStreamingETLModel, pipegraph: PipegraphModel): Try[Option[Strategy]]

Instantiate a strategy if one is configured
Instantiate a strategy if one is configured
etl
The etl to instantiate strategy for
returns
A try holding an optional strategy

Attributes
protected
Definition Classes
ActivationSteps
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] )
val freeCodeBL: FreeCodeBL

We need access to freeCodes
We need access to freeCodes

Definition Classes
StructuredStreamingETLActor → ActivationSteps
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getLog: IndexedSeq[LogEntry[etl.State, Data]]

Attributes
protected
Definition Classes
LoggingFSM
def gossip(msg: Any)(implicit sender: ActorRef): Unit

Attributes
protected
Definition Classes
Listeners
final def goto(nextStateName: etl.State): State

Definition Classes
FSM
def hashCode(): Int

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

Definition Classes
FSM
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def isTimerActive(name: String): Boolean

Definition Classes
FSM
def listenerManagement: akka.actor.Actor.Receive

Attributes
protected
Definition Classes
Listeners
val listeners: Set[ActorRef]

Attributes
protected
Definition Classes
Listeners
def log: LoggingAdapter

Definition Classes
ActorLogging
def logDepth: Int

Definition Classes
LoggingFSM
def logTermination(reason: Reason): Unit

Attributes
protected
Definition Classes
FSM
def materialize(etl: StructuredStreamingETLModel, pipegraph: PipegraphModel, dataFrame: DataFrame): Try[StreamingQuery]

Performs materialization of a DataFrame activated from a StructuredStreamingETLModel.
Performs materialization of a DataFrame activated from a StructuredStreamingETLModel.
etl
The etl whose output dataFrame is being materialized
pipegraph
The pipegraph containing the etl
dataFrame
The DataFrame created by the activation step
returns
The Materialized StreamingQuery

Attributes
protected
Definition Classes
MaterializationSteps
val mlModelBl: MlModelBL

We need access to machine learning models
We need access to machine learning models

Definition Classes
StructuredStreamingETLActor → ActivationSteps
def monitor(query: StreamingQuery): Try[MonitorOutcome]

Monitors a streaming query.
Monitors a streaming query.
query
The query to be monitored
returns
The MonitorOutcome

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

Definition Classes
AnyRef
final def nextStateData: Data

Definition Classes
FSM
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def onTermination(terminationHandler: PartialFunction[StopEvent, Unit]): Unit

Definition Classes
FSM
final def onTransition(transitionHandler: TransitionHandler): Unit

Definition Classes
FSM
val pipegraph: PipegraphModel
def postRestart(reason: Throwable): Unit

Definition Classes
Actor
Annotations
@throws( classOf[java.lang.Exception] )
def postStop(): Unit

Definition Classes
FSM → Actor
def preRestart(reason: Throwable, message: Option[Any]): Unit

Definition Classes
Actor
Annotations
@throws( classOf[java.lang.Exception] )
def preStart(): Unit

Definition Classes
Actor
Annotations
@throws( classOf[java.lang.Exception] )
val processGroupBL: ProcessGroupBL

We need access to freeCodes
We need access to freeCodes

Definition Classes
StructuredStreamingETLActor → ActivationSteps
def receive: Receive

Definition Classes
FSM → Actor
implicit final val self: ActorRef

Definition Classes
Actor
final def sender(): ActorRef

Definition Classes
Actor
final def setStateTimeout(state: etl.State, timeout: Timeout): Unit

Definition Classes
FSM
final def setTimer(name: String, msg: Any, timeout: FiniteDuration, repeat: Boolean): Unit

Definition Classes
FSM
val sparkSession: SparkSession

We need a Spark Session
We need a Spark Session

Definition Classes
StructuredStreamingETLActor → MaterializationSteps → ActivationSteps
final def startWith(stateName: etl.State, stateData: Data, timeout: Timeout): Unit

Definition Classes
FSM
final def stateData: Data

Definition Classes
FSM
final def stateName: etl.State

Definition Classes
FSM
val staticReaderFactory: StaticReaderFactory

We need a static reader factory
We need a static reader factory

Definition Classes
StructuredStreamingETLActor → ActivationSteps
final def stay(): State

Definition Classes
FSM
def stop(query: StreamingQuery): Try[Unit]

Stops the streaming query
Stops the streaming query
query
The streaming query to stop
returns
The result of the stop action

Attributes
protected
Definition Classes
StoppingStep
final def stop(reason: Reason, stateData: Data): State

Definition Classes
FSM
final def stop(reason: Reason): State

Definition Classes
FSM
final def stop(): State

Definition Classes
FSM
val streamingReaderFactory: StreamingReaderFactory

We need a streaming reader factory
We need a streaming reader factory

Definition Classes
StructuredStreamingETLActor → ActivationSteps
def supervisorStrategy: SupervisorStrategy

Definition Classes
Actor
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
val telemetryActor: ActorRef
val telemetryActorFactory: TelemetryActorFactory
def toString(): String

Definition Classes
AnyRef → Any
val topicsBl: TopicBL

We need access to topics
We need access to topics

Definition Classes
StructuredStreamingETLActor → ActivationSteps
implicit final def total2pf(transitionHandler: (etl.State, etl.State) ⇒ Unit): TransitionHandler

Definition Classes
FSM
final def transform(func: StateFunction): TransformHelper

Definition Classes
FSM
def unhandled(message: Any): Unit

Definition Classes
Actor
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( ... )
final def when(stateName: etl.State, stateTimeout: FiniteDuration)(stateFunction: StateFunction): Unit

Definition Classes
FSM
final def whenUnhandled(stateFunction: StateFunction): Unit

Definition Classes
FSM
val writerFactory: WriterFactory

We need a writer factory
We need a writer factory

Definition Classes
StructuredStreamingETLActor → MaterializationSteps

Related Docs: object StructuredStreamingETLActor | package etl

class StructuredStreamingETLActor extends FSM[State, Data] with LoggingFSM[State, Data] with ActivationSteps with MaterializationSteps with MonitoringStep with StoppingStep

Type Members

type Event = akka.actor.FSM.Event[Data]

type Receive = PartialFunction[Any, Unit]

type State = akka.actor.FSM.State[etl.State, Data]

type StateFunction = PartialFunction[Event, State]

type StopEvent = akka.actor.FSM.StopEvent[etl.State, Data]

type Timeout = Option[FiniteDuration]

final class TransformHelper extends AnyRef

type TransitionHandler = PartialFunction[(etl.State, etl.State), Unit]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

val ->: akka.actor.FSM.->.type

final def ==(arg0: Any): Boolean

val Event: akka.actor.FSM.Event.type

val StateTimeout: akka.actor.FSM.StateTimeout.type

val StopEvent: akka.actor.FSM.StopEvent.type

def activate(etl: StructuredStreamingETLModel, pipegraph: PipegraphModel): Try[DataFrame]

def aroundPostRestart(reason: Throwable): Unit

def aroundPostStop(): Unit

def aroundPreRestart(reason: Throwable, message: Option[Any]): Unit

def aroundPreStart(): Unit

def aroundReceive(receive: akka.actor.Actor.Receive, msg: Any): Unit

final def asInstanceOf[T0]: T0

final def cancelTimer(name: String): Unit

def clone(): AnyRef

implicit val context: ActorContext

def createStrategy(etl: StructuredStreamingETLModel, pipegraph: PipegraphModel): Try[Option[Strategy]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

val freeCodeBL: FreeCodeBL

final def getClass(): Class[_]

def getLog: IndexedSeq[LogEntry[etl.State, Data]]

def gossip(msg: Any)(implicit sender: ActorRef): Unit

final def goto(nextStateName: etl.State): State

def hashCode(): Int

final def initialize(): Unit

final def isInstanceOf[T0]: Boolean

final def isTimerActive(name: String): Boolean

def listenerManagement: akka.actor.Actor.Receive

val listeners: Set[ActorRef]

def log: LoggingAdapter

def logDepth: Int

def logTermination(reason: Reason): Unit

def materialize(etl: StructuredStreamingETLModel, pipegraph: PipegraphModel, dataFrame: DataFrame): Try[StreamingQuery]

val mlModelBl: MlModelBL

def monitor(query: StreamingQuery): Try[MonitorOutcome]

final def ne(arg0: AnyRef): Boolean

final def nextStateData: Data

final def notify(): Unit

final def notifyAll(): Unit

final def onTermination(terminationHandler: PartialFunction[StopEvent, Unit]): Unit

final def onTransition(transitionHandler: TransitionHandler): Unit

val pipegraph: PipegraphModel

def postRestart(reason: Throwable): Unit

def postStop(): Unit

def preRestart(reason: Throwable, message: Option[Any]): Unit

def preStart(): Unit

val processGroupBL: ProcessGroupBL

def receive: Receive

implicit final val self: ActorRef

final def sender(): ActorRef

final def setStateTimeout(state: etl.State, timeout: Timeout): Unit

final def setTimer(name: String, msg: Any, timeout: FiniteDuration, repeat: Boolean): Unit

val sparkSession: SparkSession

final def startWith(stateName: etl.State, stateData: Data, timeout: Timeout): Unit

final def stateData: Data

final def stateName: etl.State

val staticReaderFactory: StaticReaderFactory

final def stay(): State

def stop(query: StreamingQuery): Try[Unit]

final def stop(reason: Reason, stateData: Data): State

final def stop(reason: Reason): State

final def stop(): State

val streamingReaderFactory: StreamingReaderFactory

def supervisorStrategy: SupervisorStrategy