remoteworkers

type AdminTemp struct {

	// The admin action; see `Command` for legal values.
	Command AdminTemp_Command `` /* 129-byte string literal not displayed */
	// The argument to the admin action; see `Command` for semantics.
	Arg string `protobuf:"bytes,2,opt,name=arg,proto3" json:"arg,omitempty"`
	// contains filtered or unexported fields
}

type AdminTemp_Command int32

type BotSession struct {

	// The bot session name, as selected by the server. Output only during a call
	// to CreateBotSession.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// A unique bot ID within the farm used to persistently identify this bot over
	// time (i.e., over multiple sessions). This ID must be unique within a
	// farm. Typically, the bot ID will be the same as the name of the primary
	// device in the worker (e.g., what you'd get from typing `uname -n` on *nix),
	// but this is not required since a single device may allow multiple bots to
	// run on it, each with access to different resources. What is important is
	// that this ID is meaningful to humans, who might need to hunt a physical
	// machine down to fix it.
	//
	// When CreateBotSession is successfully called with a bot_id, all prior
	// sessions with the same ID are invalidated. If a bot attempts to update an
	// invalid session, the server must reject that request, and may also
	// quarantine the other bot with the same bot IDs (ie, stop sending it new
	// leases and alert an admin).
	BotId string `protobuf:"bytes,2,opt,name=bot_id,json=botId,proto3" json:"bot_id,omitempty"`
	// The status of the bot. This must be populated in every call to
	// UpdateBotSession.
	Status BotStatus `protobuf:"varint,3,opt,name=status,proto3,enum=google.devtools.remoteworkers.v1test2.BotStatus" json:"status,omitempty"`
	// A description of the worker hosting this bot. The Worker message is used
	// here in the Status context (see Worker for more information).  If multiple
	// bots are running on the worker, this field should only describe the
	// resources accessible from this bot.
	//
	// During the call to CreateBotSession, the server may make arbitrary changes
	// to the worker's `server_properties` field (see that field for more
	// information). Otherwise, this field is input-only.
	Worker *Worker `protobuf:"bytes,4,opt,name=worker,proto3" json:"worker,omitempty"`
	// A list of all leases that are a part of this session. See the Lease message
	// for details.
	Leases []*Lease `protobuf:"bytes,5,rep,name=leases,proto3" json:"leases,omitempty"`
	// The time at which this bot session will expire, unless the bot calls
	// UpdateBotSession again. Output only.
	ExpireTime *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=expire_time,json=expireTime,proto3" json:"expire_time,omitempty"`
	// The version of the bot code currently running. The server may use this
	// information to issue an admin action to tell the bot to update itself.
	Version string `protobuf:"bytes,7,opt,name=version,proto3" json:"version,omitempty"`
	// contains filtered or unexported fields
}

type BotStatus int32

type BotsClient interface {
	// 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.
	CreateBotSession(ctx context.Context, in *CreateBotSessionRequest, opts ...grpc.CallOption) (*BotSession, error)
	// 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.
	UpdateBotSession(ctx context.Context, in *UpdateBotSessionRequest, opts ...grpc.CallOption) (*BotSession, error)
}

type BotsServer interface {
	// 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.
	CreateBotSession(context.Context, *CreateBotSessionRequest) (*BotSession, error)
	// 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.
	UpdateBotSession(context.Context, *UpdateBotSessionRequest) (*BotSession, error)
	// contains filtered or unexported methods
}

type CancelReservationIntent int32

type CancelReservationRequest struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The intent indicates if a task can be cancelled based on its state. If set
	// to ANY then assigned tasks may be cancelled. Otherwise, the task must be
	// pending.
	Intent CancelReservationIntent `` /* 133-byte string literal not displayed */
	// contains filtered or unexported fields
}

type CancelReservationResponse struct {
	Result CancelResult `protobuf:"varint,1,opt,name=result,proto3,enum=google.devtools.remoteworkers.v1test2.CancelResult" json:"result,omitempty"`
	// contains filtered or unexported fields
}

type CancelResult int32

type Constraint struct {

	// The name of the property to which this constraint applies.
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The set of values, at least one of which must be reported by the worker to
	// be eligible to execute the reservation.
	AllowedValues []string `protobuf:"bytes,2,rep,name=allowed_values,json=allowedValues,proto3" json:"allowed_values,omitempty"`
	// contains filtered or unexported fields
}

type CreateBotSessionRequest struct {

	// The farm resource.
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// The bot session to create. Server-assigned fields like name must be unset.
	BotSession *BotSession `protobuf:"bytes,2,opt,name=bot_session,json=botSession,proto3" json:"bot_session,omitempty"`
	// contains filtered or unexported fields
}

type CreateReservationRequest struct {
	Parent      string       `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	Reservation *Reservation `protobuf:"bytes,2,opt,name=reservation,proto3" json:"reservation,omitempty"`
	// contains filtered or unexported fields
}

type Device struct {

	// The handle can be thought of as the "name" of the device, and must be
	// unique within a Worker.
	//
	// In the Status context, the handle should be some human-understandable name,
	// perhaps corresponding to a label physically written on the device to make
	// it easy to locate. In the Request context, the name should be the
	// *logical* name expected by the task. The bot is responsible for mapping the
	// logical name expected by the task to a machine-readable name that the task
	// can actually use, such as a USB address. The method by which this mapping
	// is communicated to the task is not covered in this API.
	Handle string `protobuf:"bytes,1,opt,name=handle,proto3" json:"handle,omitempty"`
	// Properties of this device that don't change based on the tasks that are
	// running on it, e.g. OS, CPU architecture, etc.
	//
	// Keys may be repeated, and have the following interpretation:
	//
	//   - Status context: the device can support *any* the listed values. For
	//     example, an "ISA" property might include "x86", "x86-64" and "sse4".
	//
	//   - Request context: the device *must* support *all* of the listed values.
	Properties []*Device_Property `protobuf:"bytes,2,rep,name=properties,proto3" json:"properties,omitempty"`
	// contains filtered or unexported fields
}

type Device_Property struct {

	// For general information on keys, see the documentation to `Worker`.
	//
	// The current set of standard keys are:
	//
	// * os: a human-readable description of the OS. Examples include `linux`,
	// `ubuntu` and `ubuntu 14.04` (note that a bot may advertise itself as more
	// than one). This will be replaced in the future by more well-structured
	// keys and values to represent OS variants.
	//
	// * has-docker: "true" if the bot has Docker installed. This will be
	// replaced in the future by a more structured message for Docker support.
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The property's value.
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type GetReservationRequest struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// If non-zero, GetReservation will attempt to wait for the reservation's
	// state to become COMPLETED for up to this amount of time, though this is not
	// guaranteed.
	WaitSeconds int64 `protobuf:"varint,2,opt,name=wait_seconds,json=waitSeconds,proto3" json:"wait_seconds,omitempty"`
	// contains filtered or unexported fields
}

type Lease struct {

	// A short string uniquely identifing the lease within this bot session.
	Id string `protobuf:"bytes,7,opt,name=id,proto3" json:"id,omitempty"`
	// The actual work to be performed, if any. May be omitted by the server if
	// the lease is not in the `PENDING` state. The message must be meaningful to
	// the bot. Output only (must only be set by the server).
	Payload *anypb.Any `protobuf:"bytes,8,opt,name=payload,proto3" json:"payload,omitempty"`
	// Any result the bot wishes to provide about the lease. Must not be changed
	// after the first call with the lease in the `COMPLETED` or `CANCELLED`
	// state. Input only (must only be set by the bot, will not be echoed by the
	// server).
	Result *anypb.Any `protobuf:"bytes,9,opt,name=result,proto3" json:"result,omitempty"`
	// The state of the lease. See LeaseState for more information.
	State LeaseState `protobuf:"varint,2,opt,name=state,proto3,enum=google.devtools.remoteworkers.v1test2.LeaseState" json:"state,omitempty"`
	// The final status of the lease (should be populated by the bot if the state
	// is completed). This is the status of the lease, not of any task represented
	// by the lease. For example, if the bot could not accept the lease because it
	// asked for some resource the bot didn't have, this status will be
	// FAILED_PRECONDITION. But if the assignment in the lease didn't execute
	// correctly, this field will be `OK` while the failure of the assignment must
	// communicated via the `result` field.
	Status *status.Status `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	// The requirements that are being claimed by this lease. This field may be
	// omitted by the server if the lease is not pending.
	Requirements *Worker `protobuf:"bytes,4,opt,name=requirements,proto3" json:"requirements,omitempty"`
	// The time at which this lease expires. The server *may* extend this over
	// time, but due to race conditions, the bot is not *required* to respect any
	// expiry date except the first one.
	ExpireTime *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=expire_time,json=expireTime,proto3" json:"expire_time,omitempty"`
	// DEPRECATED. The assignment should be provided to the bot via the `payload`
	// field. Clients that wish to use a simple name (such as a queue of work
	// provided elsewhere) should define a custom message type and encode it into
	// `payload`.
	//
	// Deprecated: Marked as deprecated in go.chromium.org/luci/swarming/internal/remoteworkers/bots.proto.
	Assignment string `protobuf:"bytes,1,opt,name=assignment,proto3" json:"assignment,omitempty"`
	// DEPRECATED. Use `payload` instead.
	//
	// Deprecated: Marked as deprecated in go.chromium.org/luci/swarming/internal/remoteworkers/bots.proto.
	InlineAssignment *anypb.Any `protobuf:"bytes,6,opt,name=inline_assignment,json=inlineAssignment,proto3" json:"inline_assignment,omitempty"`
	// contains filtered or unexported fields
}

type LeaseState int32

type PubSubMetadata struct {

	// The topic_id is the name of the topic that the pubsub service will publish.
	// The subscriber should be subscribing to the topic_id.
	TopicId string `protobuf:"bytes,1,opt,name=topic_id,json=topicId,proto3" json:"topic_id,omitempty"`
	// The publisher_id is the id that the pubsub service will use when publishing
	// the topic identified by the topic_id.
	PublisherId string `protobuf:"bytes,2,opt,name=publisher_id,json=publisherId,proto3" json:"publisher_id,omitempty"`
	// contains filtered or unexported fields
}

type Reservation struct {

	// The full reservation resource in the form of
	// "{parent}/reservations/{reservation}". The {reservation} component must be
	// a globally unique random identifier, e.g.  UUID. This component must be set
	// in the CreateReservation request.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// A message describing what the worker should do.
	Payload *anypb.Any `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
	// Any result provided by the worker. Output only.
	Result *anypb.Any `protobuf:"bytes,3,opt,name=result,proto3" json:"result,omitempty"`
	// The state of the reservation - see ReservationState for more information.
	// Output only.
	State ReservationState `protobuf:"varint,4,opt,name=state,proto3,enum=google.devtools.remoteworkers.v1test2.ReservationState" json:"state,omitempty"`
	// If `state` is COMPLETED, this is the final status of the reservation.
	// Typically, this will be OK if a worker was successfully assigned - if the
	// worker failed to do work, that failure will be reported in the `result`
	// field, not here.
	// Output only.
	Status *status.Status `protobuf:"bytes,5,opt,name=status,proto3" json:"status,omitempty"`
	// The constraints that a worker must satisfy to be eligible to execute this
	// reservation.
	Constraints []*Constraint `protobuf:"bytes,13,rep,name=constraints,proto3" json:"constraints,omitempty"`
	// The time after which the client no longer cares about this reservation. The
	// lease must be *completed* by this time, not started. expire_time is
	// enforced independently of other timeouts like queuing_timeout and
	// execution_timeout.
	ExpireTime *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=expire_time,json=expireTime,proto3" json:"expire_time,omitempty"`
	// Limits how long the reservation can be queued before being killed. Has no
	// effect once the reservation begins execution. queuing_timeout is enforced
	// independently of other timeouts like expire_time and execution_timeout.
	QueuingTimeout *durationpb.Duration `protobuf:"bytes,14,opt,name=queuing_timeout,json=queuingTimeout,proto3" json:"queuing_timeout,omitempty"`
	// Limits how long a reservation is allowed to run. Does not include any time
	// the reservation was queued. execution_timeout is enforced independently of
	// other timeouts like expire_time and queuing_timeout.
	ExecutionTimeout *durationpb.Duration `protobuf:"bytes,15,opt,name=execution_timeout,json=executionTimeout,proto3" json:"execution_timeout,omitempty"`
	// The priority (relative importance) of this reservation. Generally, a lower
	// value means that the reservation should be run sooner than reservations
	// having a greater priority value, but the interpretation of a given value is
	// server-dependent. A priority of 0 means the *default* priority. Priorities
	// may be positive or negative, and such reservations should run later or
	// sooner than reservations having the default priority, respectively. The
	// particular semantics of this field is up to the server. In particular,
	// every server will have their own supported range of priorities, and will
	// decide how these map into scheduling policy.
	Priority int32 `protobuf:"varint,8,opt,name=priority,proto3" json:"priority,omitempty"`
	// The pubsub_metadata field is a PubSubMetadata message containing topic_id
	// and publisher_id. If this message is provided, then the pubsub service will
	// be used to publish a Reservation message to the topic_id using the
	// publisher_id. The published Reservation message will contain the
	// reservation ID along with basic status info about the result. The
	// subscriber will then need to call GetReservation RPC to get more details.
	PubsubMetadata *PubSubMetadata `protobuf:"bytes,9,opt,name=pubsub_metadata,json=pubsubMetadata,proto3" json:"pubsub_metadata,omitempty"`
	// The assigned_bot_id field is a string message of the name of the machine
	// tasked with executing a Reservation. This is a necessary debugging field
	// for Reservation users that control their own workers.
	AssignedBotId string `protobuf:"bytes,10,opt,name=assigned_bot_id,json=assignedBotId,proto3" json:"assigned_bot_id,omitempty"`
	// The name of the machine that should execute the Reservation.
	RequestedBotId string `protobuf:"bytes,12,opt,name=requested_bot_id,json=requestedBotId,proto3" json:"requested_bot_id,omitempty"`
	// Identifies the group that this reservation belongs to. For example, if this
	// reservation represents one of several actions to be performed as part of a
	// particular job, the group ID may be the ID of that job.
	GroupId string `protobuf:"bytes,11,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
	// contains filtered or unexported fields
}

type ReservationState int32

type ReservationsClient interface {
	// Creates a new reservation and enqueues it for submissions.
	CreateReservation(ctx context.Context, in *CreateReservationRequest, opts ...grpc.CallOption) (*Reservation, error)
	// Retrieves a reservation, along with its results if it's completed. Can
	// optionally wait for completion as well.
	GetReservation(ctx context.Context, in *GetReservationRequest, opts ...grpc.CallOption) (*Reservation, error)
	// Attempts to cancel a reservation. If it is successful, the reservation's
	// state will change to COMPLETED and its status code to CANCELLED.
	CancelReservation(ctx context.Context, in *CancelReservationRequest, opts ...grpc.CallOption) (*CancelReservationResponse, error)
}

type ReservationsServer interface {
	// Creates a new reservation and enqueues it for submissions.
	CreateReservation(context.Context, *CreateReservationRequest) (*Reservation, error)
	// Retrieves a reservation, along with its results if it's completed. Can
	// optionally wait for completion as well.
	GetReservation(context.Context, *GetReservationRequest) (*Reservation, error)
	// Attempts to cancel a reservation. If it is successful, the reservation's
	// state will change to COMPLETED and its status code to CANCELLED.
	CancelReservation(context.Context, *CancelReservationRequest) (*CancelReservationResponse, error)
	// contains filtered or unexported methods
}

type UnimplementedBotsServer struct {
}

type UnimplementedReservationsServer struct {
}

type UnsafeBotsServer interface {
	// contains filtered or unexported methods
}

type UnsafeReservationsServer interface {
	// contains filtered or unexported methods
}

type UpdateBotSessionRequest struct {

	// The bot session name. Must match bot_session.name.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The bot session resource to update.
	BotSession *BotSession `protobuf:"bytes,2,opt,name=bot_session,json=botSession,proto3" json:"bot_session,omitempty"`
	// The fields on the bot that should be updated. See the BotSession resource
	// for which fields are updatable by which caller.
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,3,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// contains filtered or unexported fields
}

type Worker struct {

	// A list of devices; the first device is the primary device. See the `Device`
	// message for more information.
	Devices []*Device `protobuf:"bytes,1,rep,name=devices,proto3" json:"devices,omitempty"`
	// 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.
	Properties []*Worker_Property `protobuf:"bytes,2,rep,name=properties,proto3" json:"properties,omitempty"`
	// 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 interpreted 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.
	Configs []*Worker_Config `protobuf:"bytes,3,rep,name=configs,proto3" json:"configs,omitempty"`
	// Implementation-dependent metadata about the worker. Both servers and bots
	// may define messages which can be encoded here; bots are free to provide
	// metadata in multiple formats, and servers are free to choose one or more
	// of the values to process and ignore others. In particular, it is *not*
	// considered an error for the bot to provide the server with a field that it
	// doesn't know about.
	Metadata []*anypb.Any `protobuf:"bytes,4,rep,name=metadata,proto3" json:"metadata,omitempty"`
	// contains filtered or unexported fields
}

type Worker_Config struct {

	// For general information on keys, see the documentation to `Worker`.
	//
	// The current set of standard keys are:
	//
	// * DockerImage: the image of the container. When being reported by the
	// bot, the empty value should always be included if the bot is able to pull
	// its own images; the bot may optionally *also* report images that are
	// present in its cache. When being requested in a lease, the value is the
	// URI of the image (eg `gcr.io/user/image@sha256:hash`).
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The configuration's value.
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type Worker_Property struct {

	// For general information on keys, see the documentation to `Worker`.
	//
	// The current set of standard keys are:
	//
	// * pool: different workers can be reserved for different purposes. For
	// example, an admin might want to segregate long-running integration tests
	// from short-running unit tests, so unit tests will always get some
	// throughput. To support this, the server can assign different values for
	// `pool` (such as "itest" and "utest") to different workers, and then have
	// jobs request workers from those pools.
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The property's value.
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}