Struct Globals 

pub struct Globals {

    pub cli_options: CliOptions,
    pub config: Config,
    pub computed_config: ComputedConfig,
    pub state: Sender<State>,
    pub worker_tracker: Arc<WorkerTracker>,
    pub db_trigger: Sender<DbAssocState>,
    pub db_initialised: OnceLock<Result<(), Arc<AE>>>,
    pub http_client: Client,
    pub dns_resolver: Resolver,
    pub running: Receiver<Option<Running>>,
    pub host_retry_state: Mutex<HostStates>,
    pub scratch_dir: String,
    pub temp_dir_retain: Option<TempDir>,
    pub tera: Tera,
    pub version_info: Info,
    pub test_suppl: GlobalSupplement,
    pub last_worker_restart: RwLock<SystemTime>,
    pub next_seq: Mutex<OracleSeq>,
    pub oldest_norestart_seq: Sender<OracleSeq>,
}

Fields

cli_options: CliOptions

config: Config

computed_config: ComputedConfig

state: Sender<State>

Shared global state excluding the db

Lock hierarchy

See the docs for the global module for the rules for when you may mutate or borrow this.

worker_tracker: Arc<WorkerTracker>

db_trigger: Sender<DbAssocState>

Trigger watch for database updates

• When a db transaction modifies the DB such that a job may become processable that wasn’t previously, this watch will be signaled (even though the contained DbAssocState may not have changed).

  db_support.rs functions taking a TransactionNature ensure this.

• Additionally DbAssocState contains some information about pausing mirrored from the database.

Lock hierarchy

See the docs for the global module for the rules for when you may mutate or borrow this.

db_initialised: OnceLock<Result<(), Arc<AE>>>

Set iff we have run the db initialisation (including schema)

This is done from the Rocket liftoff fairing callback, while the rest of the program is (supposedly) waiting. We want to avoid running any normal db transactions before then. This is a booby trap which would cause us to crash (or fail tests) instead.

http_client: Client

dns_resolver: Resolver

running: Receiver<Option<Running>>

Signal for when we have started up

Lock hierarchy

See the docs for the global module for the rules for when you may mutate or borrow this.

host_retry_state: Mutex<HostStates>

Ephemeral per-host retry/success records

Lock hierarchy

See the docs for the global module for the rules for when you may lock this.

scratch_dir: String

temp_dir_retain: Option<TempDir>

tera: Tera

version_info: Info

test_suppl: GlobalSupplement

last_worker_restart: RwLock<SystemTime>

next_seq: Mutex<OracleSeq>

Connection sequence number for the next connection to come in.

This is a global so that we can determine which worker connections should be restarted across, and independently of, all active listeners (even though for now we have only one listener).

oldest_norestart_seq: Sender<OracleSeq>

Lowest connection sequence number of a connection to an Oracle worker that doesn’t need restarting. Connections to workers with sequence numbers strictly less than this should issue a ‘restart-worker’ instruction and disconnect.

Implementations

impl Globals

pub fn now_systemtime(&self) -> SystemTime

pub fn now_systemtime_inner( config: &Config, test_suppl: &GlobalSupplement, ) -> SystemTime

pub fn now(&self) -> TimeT

pub fn check_tag_recency( &self, tag_date: SystemTime, ) -> Result<IsRecentEnough, NFR>

impl Globals

pub async fn await_shutdown(&self) -> ShuttingDown

Waits for shutdown (possibly indefinitely)

Like check_shutdown this doesn’t do anything with errors

impl Globals

pub fn spawn_task_running( self: &Arc<Self>, what: impl Display, fut: impl Future<Output = TaskResult> + Send + 'static, )

Start this task when we have entered the Running state

pub fn spawn_task_immediate( self: &Arc<Self>, what: impl Display, fut: impl Future<Output = TaskResult> + Send + 'static, )

Start this task immediately

pub fn check_shutdown(&self) -> Result<(), ShuttingDown>

Checks for shutdown (but doesn’t do anything with errors)

pub async fn await_running(&self) -> Result<Running, ShuttingDown>

pub async fn http_fetch_raw(&self, url: Url) -> Result<HttpFetchedRaw, AE>

pub async fn http_fetch_json_maybe<T: DeserializeOwned>( &self, url: Url, ) -> Result<Result<T, HttpNotFound>, AE>

pub async fn http_fetch_json<T: DeserializeOwned>( &self, url: Url, ) -> Result<T, AE>

impl Globals

pub fn host_retry_state(&self) -> MutexGuard<'_, HostStates>

Trait Implementations

impl Debug for Globals

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

Formats the value using the given formatter.