Struct cargo::core::compiler::job_queue::job_state::JobState

pub struct JobState<'a, 'gctx> {
    messages: Arc<Queue<Message>>,
    output: Option<&'a DiagDedupe<'gctx>>,
    id: JobId,
    rmeta_required: Cell<bool>,
    _marker: PhantomData<&'a ()>,
}

A JobState is constructed by JobQueue::run and passed to Job::run. It includes everything necessary to communicate between the main thread and the execution of the job.

The job may execute on either a dedicated thread or the main thread. If the job executes on the main thread, the output field must be set to prevent a deadlock.

Fields

messages: Arc<Queue<Message>>

Channel back to the main thread to coordinate messages and such.

When the output field is Some, care must be taken to avoid calling push_bounded on the message queue to prevent a deadlock.

output: Option<&'a DiagDedupe<'gctx>>

Normally output is sent to the job queue with backpressure. When the job is fresh however we need to immediately display the output to prevent a deadlock as the output messages are processed on the same thread as they are sent from. output defines where to output in this case.

Currently the Shell inside GlobalContext is wrapped in a RefCell and thus can’t be passed between threads. This means that it isn’t possible for multiple output messages to be interleaved. In the future, it may be wrapped in a Mutex instead. In this case interleaving is still prevented as the lock would be held for the whole printing of an output message.

id: JobId

The job id that this state is associated with, used when sending messages back to the main thread.

rmeta_required: Cell<bool>

Whether or not we’re expected to have a call to rmeta_produced. Once that method is called this is dynamically set to false to prevent sending a double message later on.

_marker: PhantomData<&'a ()>

Implementations

impl<'a, 'gctx> JobState<'a, 'gctx>

pub(super) fn new( id: JobId, messages: Arc<Queue<Message>>, output: Option<&'a DiagDedupe<'gctx>>, rmeta_required: bool ) -> Self

pub fn running(&self, cmd: &ProcessBuilder)

pub fn build_plan( &self, module_name: String, cmd: ProcessBuilder, filenames: Arc<Vec<OutputFile>> )

pub fn stdout(&self, stdout: String) -> CargoResult<()>

pub fn stderr(&self, stderr: String) -> CargoResult<()>

pub fn emit_diag( &self, level: String, diag: String, fixable: bool ) -> CargoResult<()>

See Message::Diagnostic and Message::WarningCount.

pub fn warning(&self, warning: String) -> CargoResult<()>

See Message::Warning.

pub fn rmeta_produced(&self)

A method used to signal to the coordinator thread that the rmeta file for an rlib has been produced. This is only called for some rmeta builds when required, and can be called at any time before a job ends. This should only be called once because a metadata file can only be produced once!

pub(super) fn run_to_finish(self, job: Job)

Drives a Job to finish. This ensures that a Message::Finish is sent even if our job panics.

pub fn future_incompat_report(&self, report: Vec<FutureBreakageItem>)

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes