Struct google_api_proto::google::devtools::remoteworkers::v1test2::Worker

pub struct Worker {
    pub devices: Vec<Device>,
    pub properties: Vec<Property>,
    pub configs: Vec<Config>,
}

Describes a worker, which is a list of one or more devices and the connections between them. A device could be a computer, a phone, or even an accelerator like a GPU; it’s up to the farm administrator to decide how to model their farm. For example, if a farm only has one type of GPU, the GPU could be modelled as a “has_gpu” property on its host computer; if it has many subproperties itself, it might be better to model it as a separate device.

The first device in the worker is the “primary device” - that is, the device running a bot and which is responsible for actually executing commands. All other devices are considered to be attached devices, and must be controllable by the primary device.

This message (and all its submessages) can be used in two contexts:

• Status: sent by the bot to report the current capabilities of the device to allow reservation matching.
• Request: sent by a client to request a device with certain capabilities in a reservation.

Several of the fields in this message have different semantics depending on which of which of these contexts it is used. These semantics are described below.

Several messages in Worker and its submessages have the concept of keys and values, such as Worker.Property and Device.Property. All keys are simple strings, but certain keys are “standard” keys and should be broadly supported across farms and implementations; these are listed below each relevant message. Bot implementations or farm admins may add additional keys, but these SHOULD all begin with an underscore so they do not conflict with standard keys that may be added in the future.

Keys are not context sensitive.

See http://goo.gl/NurY8g for more information on the Worker message.

Fields

devices: Vec<Device>

A list of devices; the first device is the primary device. See the Device message for more information.

properties: Vec<Property>

A worker may contain “global” properties. For example, certain machines might be reserved for certain types of jobs, like short-running compilation versus long-running integration tests. This property is known as a “pool” and is not related to any one device within the worker; rather, it applies to the worker as a whole.

The behaviour of repeated keys is identical to that of Device.Property.

configs: Vec<Config>

Bots can be configured in certain ways when accepting leases. For example, many leases are executed inside a Docker container. To support this, the bot needs to be able to report that it has Docker installed (and knows how to execute something inside a container), and the task submitter needs to specify which image should be used to start the container. Similarly, a lease may be able to run as one of several users on the worker; in such cases, the bot needs to report what users are available, and the submitter needs to choose one.

Therefore, when this message is reported by the bot to the service, each key represents a type of configuration that the bot knows how to set, while each value represents a legal value for that configuration (the empty string is interpretted as a wildcard, such as for Docker images). When this message is sent by the server to the bot in the context of a lease, it represents a command to the bot to apply the setting. Keys may be repeated during reporting but not in a lease.

Trait Implementations

impl Clone for Worker

fn clone(&self) -> Worker

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Worker

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

Formats the value using the given formatter.

impl Default for Worker

fn default() -> Self

Returns the “default value” for a type.

impl Message for Worker

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode<B>(&self, buf: &mut B) -> Result<(), EncodeError>

where B: BufMut, Self: Sized,

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message to a newly allocated buffer.

fn encode_length_delimited<B>(&self, buf: &mut B) -> Result<(), EncodeError>

where B: BufMut, Self: Sized,

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode<B>(buf: B) -> Result<Self, DecodeError>

where B: Buf, Self: Default,

Decodes an instance of the message from a buffer.

fn decode_length_delimited<B>(buf: B) -> Result<Self, DecodeError>

where B: Buf, Self: Default,

Decodes a length-delimited instance of the message from the buffer.

fn merge<B>(&mut self, buf: B) -> Result<(), DecodeError>

where B: Buf, Self: Sized,

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited<B>(&mut self, buf: B) -> Result<(), DecodeError>

where B: Buf, Self: Sized,

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq for Worker

fn eq(&self, other: &Worker) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Worker