Skip to main content

## JobState

# Struct JobState

Source

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

Expand description

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.

§`lock_manager: Arc<LockManager>`

Manages locks for build units when fine grain locking is enabled.

§`warning_handling: WarningHandling`§`_marker: PhantomData<&'a ()>`

## Implementations§

Source§

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

Source

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

Source

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

Source

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

Source

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

Source

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

See `Message::Diagnostic` and `Message::WarningCount`.

Source

#### pub fn warning(&self, warning: String)

See `Message::Warning`.

Source

#### 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!

Source

#### pub fn lock_exclusive(&self, lock: &LockKey) -> CargoResult<()>

Source

#### pub fn downgrade_to_shared(&self, lock: &LockKey) -> CargoResult<()>

Source

#### pub fn on_section_timing_emitted(&self, section: SectionTiming)

Source

#### 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.

Source

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

Source

#### pub fn unused_externs(&self, unused_externs: BTreeSet<InternedString>)

The rustc emitted the list of unused `--extern` args.

This is useful for checking unused dependencies. Should only be called once, as the compiler only emits it once per compilation.

## Auto Trait Implementations§

§

### impl<'a, 'gctx> !Freeze for JobState<'a, 'gctx>

§

### impl<'a, 'gctx> !RefUnwindSafe for JobState<'a, 'gctx>

§

### impl<'a, 'gctx> !Send for JobState<'a, 'gctx>

§

### impl<'a, 'gctx> !Sync for JobState<'a, 'gctx>

§

### impl<'a, 'gctx> !UnwindSafe for JobState<'a, 'gctx>

§

### impl<'a, 'gctx> Unpin for JobState<'a, 'gctx>

§

### impl<'a, 'gctx> UnsafeUnpin for JobState<'a, 'gctx>

## Blanket Implementations§

Source§

### impl<T> Any for T
where T: 'static + ?Sized,

Source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
Source§

### impl<T> Borrow<T> for T
where T: ?Sized,

Source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

### impl<T> From<T> for T

Source§

#### fn from(t: T) -> T

Returns the argument unchanged.

§

### impl<T> Instrument for T

§

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [`Span`], returning an `Instrumented` wrapper. Read more
§

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
Source§

### impl<T, U> Into<U> for T
where U: From<T>,

Source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

Source§

### impl<T> IntoEither for T

Source§

#### fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left` is `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
Source§

#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left(&self)` returns `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
§

### impl<T> Pointable for T

§

#### const ALIGN: usize

The alignment of pointer.
§

#### type Init = T

The type for initializers.
§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

### impl<T> Same for T

Source§

#### type Output = T

Should always be `Self`
Source§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

#### type Error = Infallible

The type returned in the event of a conversion error.
Source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

### impl<T> WithSubscriber for T

§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a [`WithDispatch`] wrapper. Read more
§

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a [`WithDispatch`] wrapper. Read more

## 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: 32 bytes