Struct Options 

pub struct Options {
    pub http: Http,
    pub query: Option<Query>,
    pub submit: Option<Submit>,
    pub status: Option<Status>,
    pub catchup: Option<Catchup>,
    pub config: Option<Config>,
    pub hotshot_events: Option<HotshotEvents>,
    pub explorer: Option<Explorer>,
    pub light_client: Option<LightClient>,
    pub storage_fs: Option<Options>,
    pub storage_sql: Option<Options>,
}

Fields

http: Http

query: Option<Query>

submit: Option<Submit>

status: Option<Status>

catchup: Option<Catchup>

config: Option<Config>

hotshot_events: Option<HotshotEvents>

explorer: Option<Explorer>

light_client: Option<LightClient>

storage_fs: Option<Options>

storage_sql: Option<Options>

Implementations

impl Options

pub fn with_port(port: u16) -> Self

Default options for running a web server on the given port.

pub fn query_sql(self, query: Query, storage: Options) -> Self

Add a query API module backed by a Postgres database.

pub fn query_fs(self, query: Query, storage: Options) -> Self

Add a query API module backed by the file system.

pub fn submit(self, opt: Submit) -> Self

Add a submit API module.

pub fn status(self, opt: Status) -> Self

Add a status API module.

pub fn catchup(self, opt: Catchup) -> Self

Add a catchup API module.

pub fn config(self, opt: Config) -> Self

Add a config API module.

pub fn hotshot_events(self, opt: HotshotEvents) -> Self

Add a Hotshot events streaming API module.

pub fn explorer(self, opt: Explorer) -> Self

Add an explorer API module.

pub fn light_client(self, opt: LightClient) -> Self

Add a light client API module.

pub fn has_query_module(&self) -> bool

Whether these options will run the query API.

pub async fn serve<N, P, F, V: Versions + 'static>( self, init_context: F, ) -> Result<SequencerContext<N, P, V>>

where N: ConnectedNetwork<PubKey>, P: SequencerPersistence, F: FnOnce(Box<dyn Metrics>, Box<dyn EventConsumer>, Option<RequestResponseStorage>) -> BoxFuture<'static, Result<SequencerContext<N, P, V>>>,

Start the server.

The function init_context is used to create a sequencer context from a metrics object and optional saved consensus state. The metrics object is created from the API data source, so that consensus will populuate metrics that can then be read and served by the API.

async fn init_app_modules<N, P, D, V: Versions>( &self, ds: D, state: ApiState<N, P, V>, bind_version: SequencerApiVersion, ) -> Result<(Box<dyn Metrics>, Arc<ExtensibleDataSource<D, ApiState<N, P, V>>>, App<AppState<ExtensibleDataSource<D, ApiState<N, P, V>>>, Error>)>

where N: ConnectedNetwork<PubKey>, P: SequencerPersistence, D: SequencerDataSource + CatchupStorage + Send + Sync + 'static,

async fn init_with_query_module_fs<N, P, V: Versions + 'static>( &self, query_opt: Query, mod_opt: Options, state: ApiState<N, P, V>, tasks: &mut TaskList, bind_version: SequencerApiVersion, ) -> Result<(Box<dyn Metrics>, Box<dyn EventConsumer>, Option<RequestResponseStorage>)>

where N: ConnectedNetwork<PubKey>, P: SequencerPersistence,

async fn init_with_query_module_sql<N, P, V: Versions + 'static>( self, query_opt: Query, mod_opt: Options, state: ApiState<N, P, V>, tasks: &mut TaskList, bind_version: SequencerApiVersion, ) -> Result<(Box<dyn Metrics>, Box<dyn EventConsumer>, Option<RequestResponseStorage>)>

where N: ConnectedNetwork<PubKey>, P: SequencerPersistence,

fn init_hotshot_modules<N, P, S>(&self, app: &mut App<S, Error>) -> Result<()>

where S: 'static + Send + Sync + ReadState, P: SequencerPersistence, S::State: Send + Sync + SubmitDataSource<N, P> + StateSignatureDataSource<N> + NodeStateDataSource + CatchupDataSource + HotShotConfigDataSource, N: ConnectedNetwork<PubKey>,

Initialize the modules for interacting with HotShot.

This function adds the submit, state, and state_signature API modules to the given app. These modules only require a HotShot handle as state, and thus they work with any data source, so initialization is the same no matter what mode the service is running in.

fn init_hotshot_events_module<S>(&self, app: &mut App<S, Error>) -> Result<()>

where S: 'static + Send + Sync + ReadState, S::State: Send + Sync + EventsSource<SeqTypes>,

Initialize the hotshot events API module if enabled.

This function adds the hotshot events API module to the given app if the hotshot_events option is enabled. This module requires the app state to implement EventsSource.

fn listen<S, E, ApiVer>( &self, port: u16, app: App<S, E>, bind_version: ApiVer, ) -> impl Future<Output = Result<()>>

where S: Send + Sync + 'static, E: Send + Sync + Error, ApiVer: StaticVersionType + 'static,

Trait Implementations

impl Clone for Options

fn clone(&self) -> Options

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Options

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Http> for Options

fn from(http: Http) -> Self

Converts to this type from the input type.