p

riff

monix

package monix

Ordering
  1. Alphabetic
Visibility
  1. Public
  2. All

Type Members

  1. class InfiniteConcurrentSubject[A] extends AnyRef
  2. trait LowPriorityRiffMonixImplicits extends AnyRef
  3. case class MonixClient[A](inputSubscriber: Observer[RaftMessage[A]], raftNodeLogResults: Observable[LogAppendResult])(implicit evidence$1: ClassTag[A], sched: Scheduler) extends RaftClient[Observable, A] with LowPriorityRiffMonixImplicits with Product with Serializable

    An implementation of RaftClient which will push incoming data into the input for the node (i.e.

    An implementation of RaftClient which will push incoming data into the input for the node (i.e. the inputSubscriber)

    inputSubscriber

    the input into a riff.raft.node.RaftMessageHandler

    raftNodeLogResults

    the output of the log to which the inputSubscriber feeds in order to detect overwritten log entries

  4. class MonixClock extends RaftClock
  5. class ObservableCache extends AnyRef

    Similar to a replay observable

  6. class ObservableRaftEndpoint[A] extends AnyRef

    This should be the main entry for a Raft node when using Monix.

    This should be the main entry for a Raft node when using Monix.

    It represents the pieces required to communicate with other Raft nodes in the cluster, whether they be backed by monix or not.

  7. class ObservableState extends RoleCallback

    Provides a means to represent a riff.raft.node.RaftNode's role as an Observable:

    Provides a means to represent a riff.raft.node.RaftNode's role as an Observable:

    val node : RaftNode[A] = ...
val obs = ObservableState()
node.withRoleCallback(obs)

// get events of this node's idea of who the leader is and its role
obs.subscribe(...)
  8. class ObservableTimerCallback extends TimerCallback[Unit]

    Provides a means to observe the nodes timeouts

Value Members

  1. object EventSource

    Contains a function for applying a log type A to a state S, and persisting that state.

    Contains a function for applying a log type A to a state S, and persisting that state.

    For example, the log entries may be Strings and the State 'S' could be Set[String]. Or perhaps the log entries are a sealed trait of CRUD operations, and the State is the database.

    If the State itself is too big to fit in memory, then it could just be a cache over top a persistent storage.

    If you don't want to persist the state and just e.g. event source from the beginning of the log, then this all becomes a lot easier (just a one-liner, folding A over the state S).

  2. object InfiniteConcurrentSubject
  3. object LowPriorityRiffMonixImplicits extends LowPriorityRiffMonixImplicits
  4. object MonixClock
  5. object ObservableRaftEndpoint
  6. object ObservableState
  7. object RaftPipeMonix extends LowPriorityRiffMonixImplicits
  8. object RiffSchedulers

Ungrouped