Struct google_api_proto::google::devtools::remoteworkers::v1test2::bots_client::BotsClient

pub struct BotsClient<T> { /* private fields */ }

Design doc: https://goo.gl/oojM5H

Loosely speaking, the Bots interface monitors a collection of workers (think of them as “computers” for a moment). This collection is known as a “farm,” and its purpose is to perform work on behalf of a client.

Each worker runs a small program known as a “bot” that allows it to be controlled by the server. This interface contains only methods that are called by the bots themselves; admin functionality is out of scope for this interface.

More precisely, we use the term “worker” to refer to the physical “thing” running the bot. We use the term “worker,” and not “machine” or “computer,” since a worker may consist of more than one machine - e.g., a computer with multiple attached devices, or even a cluster of computers, with only one of them running the bot. Conversely, a single machine may host several bots, in which case each bot has a “worker” corresponding to the slice of the machine being managed by that bot.

The main resource in the Bots interface is not, surprisingly, a Bot - it is a BotSession, which represents a period of time in which a bot is in continuous contact with the server (see the BotSession message for more information). The parent of a bot session can be thought of as an instance of a farm. That is, one endpoint may be able to manage many farms for many users. For example, for a farm managed through GCP, the parent resource will typically take the form “projects/{project_id}”. This is referred to below as “the farm resource.”

Implementations

impl<T> BotsClient<T>

where T: GrpcService<BoxBody>, T::Error: Into<StdError>, T::ResponseBody: Body<Data = Bytes> + Send + 'static, <T::ResponseBody as Body>::Error: Into<StdError> + Send,

pub fn new(inner: T) -> Self

pub fn with_origin(inner: T, origin: Uri) -> Self

pub fn with_interceptor<F>( inner: T, interceptor: F, ) -> BotsClient<InterceptedService<T, F>>

where F: Interceptor, T::ResponseBody: Default, T: Service<Request<BoxBody>, Response = Response<<T as GrpcService<BoxBody>>::ResponseBody>>, <T as Service<Request<BoxBody>>>::Error: Into<StdError> + Send + Sync,

pub fn send_compressed(self, encoding: CompressionEncoding) -> Self

Compress requests with the given encoding.

This requires the server to support it otherwise it might respond with an error.

pub fn accept_compressed(self, encoding: CompressionEncoding) -> Self

Enable decompressing responses.

pub fn max_decoding_message_size(self, limit: usize) -> Self

Limits the maximum size of a decoded message.

Default: 4MB

pub fn max_encoding_message_size(self, limit: usize) -> Self

Limits the maximum size of an encoded message.

Default: usize::MAX

pub async fn create_bot_session( &mut self, request: impl IntoRequest<CreateBotSessionRequest>, ) -> Result<Response<BotSession>, Status>

CreateBotSession is called when the bot first joins the farm, and establishes a session ID to ensure that multiple machines do not register using the same name accidentally.

pub async fn update_bot_session( &mut self, request: impl IntoRequest<UpdateBotSessionRequest>, ) -> Result<Response<BotSession>, Status>

UpdateBotSession must be called periodically by the bot (on a schedule determined by the server) to let the server know about its status, and to pick up new lease requests from the server.

Trait Implementations

impl<T: Clone> Clone for BotsClient<T>

fn clone(&self) -> BotsClient<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for BotsClient<T>

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

Formats the value using the given formatter.