Struct PicoContext

#[repr(C)]
pub struct PicoContext {
    pub plugin_name: FfiSafeStr,
    pub service_name: FfiSafeStr,
    pub plugin_version: FfiSafeStr,
    /* private fields */
}

Context of current instance. Produced by picodata.

Fields

plugin_name: FfiSafeStr

service_name: FfiSafeStr

plugin_version: FfiSafeStr

Implementations

impl PicoContext

pub fn new(is_master: bool) -> PicoContext

pub unsafe fn clone(&self) -> Self

Safety

Note: this is for internal use only. Plugin developers should never be copying pico context.

pub fn is_master(&self) -> bool

Return true if the current instance is a replicaset leader.

pub fn worker_manager(&self) -> ServiceWorkerManager

👎Deprecated: use register_job, register_tagged_job or cancel_background_jobs_by_tag directly instead

Return ServiceWorkerManager for current service.

pub fn register_metrics_callback( &self, callback: impl Fn() -> String, ) -> Result<(), BoxError>

pub fn register_job<F>(&self, job: F) -> Result<(), BoxError>

where F: FnOnce(CancellationToken) + 'static,

Add a new job to the execution. Job work life cycle will be tied to the service life cycle; this means that job will be canceled just before service is stopped.

Arguments

• job: callback that will be executed in separated fiber. Note that it is your responsibility to organize job graceful shutdown, see a background::CancellationToken for details.

Examples

use std::time::Duration;
use picodata_plugin::background::CancellationToken;


// this job will print "hello" every second,
// and print "bye" after being canceled
fn hello_printer(cancel: CancellationToken) {
    while cancel.wait_timeout(Duration::from_secs(1)).is_err() {
        println!("hello!");
    }
    println!("job cancelled, bye!")
}
context.register_job(hello_printer).unwrap();

pub fn register_tagged_job<F>(&self, job: F, tag: &str) -> Result<(), BoxError>

where F: FnOnce(CancellationToken) + 'static,

Same as Self::register_job but caller may provide a special tag. This tag may be used for manual job cancellation using Self::cancel_tagged_jobs.

Arguments

• job: callback that will be executed in separated fiber
• tag: tag, that will be related to a job, single tag may be related to the multiple jobs

pub fn cancel_tagged_jobs( &self, tag: &str, timeout: Duration, ) -> Result<(), BoxError>

Cancel all jobs related to the given tag. This function return after all related jobs will be gracefully shutdown or after timeout duration.

Returns error with code TarantoolErrorCode::Timeout in case some jobs didn’t finish within timeout.

May also theoretically return error with code ErrorCode::NoSuchService in case the service doesn’t exist anymore (highly unlikely).

See also Self::register_tagged_job.

pub fn set_jobs_shutdown_timeout(&self, timeout: Duration)

In case when jobs were canceled by picodata use this function for determine a shutdown timeout - time duration that picodata uses to ensure that all jobs gracefully end.

By default, 5-second timeout are used.

pub fn make_service_id(&self) -> ServiceId

pub fn plugin_name(&self) -> &str

pub fn service_name(&self) -> &str

pub fn plugin_version(&self) -> &str

Trait Implementations

impl Debug for PicoContext

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

Formats the value using the given formatter.

impl<'a> From<&'a PicoContext> for RouteBuilder<'a>

fn from(context: &'a PicoContext) -> Self

Converts to this type from the input type.

impl GetStaticEquivalent_ for PicoContext

type StaticEquivalent = _static_PicoContext

The 'static equivalent of Self

impl StableAbi for PicoContext

const LAYOUT: &'static TypeLayout

The layout of the type provided by implementors.

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

const ABI_CONSTS: AbiConsts = _

const-equivalents of the associated types.