package yadcc.scheduler

Get desktop application:
View/edit binary Protocol Buffers messages

//////////////////////////////////////////////////// Called by serving daemon (compilation servant). // ////////////////////////////////////////////////////

rpc Heartbeat (HeartbeatRequest, HeartbeatResponse)
scheduler.proto:254
Called periodically by daemons to report their states.
message HeartbeatRequest
scheduler.proto:64
- string token = 13
  The scheduler only accepts requests carrying a recognized token.
- uint32 next_heartbeat_in_ms = 7
  Expected time of next heartbeat.
  An interval less than 10s is suggested.
- uint32 version = 11
  Version of this daemon.
- string location = 1
  IP:port of the reporting servant.
- uint32 num_processors = 10
  Number of processors.
- uint32 current_load = 4
  Current load average
- ServantPriority servant_priority = 14
- uint32 not_accepting_task_reason = 12
  The reason why `capacity` is zero.
  @sa: NotAcceptingTaskReason
- uint32 capacity = 3
  Maximum number of task concurrency this node is willing to provide.
- uint64 total_memory_in_bytes = 15
  Total memory of this node.
- uint64 memory_available_in_bytes = 16
  Available memory.
- repeated EnvironmentDesc env_descs = 6
  Compilers recognizes by this servant.
- repeated RunningTask running_tasks = 17
  The desc of running tasks on servant. This help scheduler to collect all running tasks of cluster, avoiding unnecessary compilations and cluster overload.
message HeartbeatResponse
scheduler.proto:122
- repeated string acceptable_tokens = 2
  Tokens that should be accepted by this daemon. This is in no way related to the token provided in the request. This one is used for accessing daemons, while the latter is used for accessing scheduler. Usually there's only one entry in this list. There can be more if we're rolling out a new one. The delegate daemon periodically requests a token from the scheduler via `GetConfig`
- repeated uint64 expired_tasks = 1
  IDs in `running_tasks` of the request that the scheduler think is dead. Usually this means the task submitter failed to sent keep-alive in a timely manner. The caller is free to instantly terminate tasks listed here without further negotiation.
rpc GetConfig (GetConfigRequest, GetConfigResponse)
scheduler.proto:262
Called periodically to obtain configurations such token to access other serving daemons.
message GetConfigRequest
scheduler.proto:143
- string token = 1
  Token to access scheduler.
message GetConfigResponse
scheduler.proto:147
- string serving_daemon_token = 1
  Token to access other daemons.
rpc WaitForStartingTask (WaitForStartingTaskRequest, WaitForStartingTaskResponse)
scheduler.proto:273
Apply for distributing one or more compilation tasks. This method returns a list of servant to do actual compilation. Unless there's no quota available, this method never blocks. However, this method can return less quota than requested if the system under heavy load. Each grant can be applied to exactly one compilation task. If the client believes it has more task to run in the near future, it can "prefetch" some quota.
message WaitForStartingTaskRequest
scheduler.proto:181
- string token = 6
- uint32 milliseconds_to_wait = 1
  Milliseonds the caller would like to wait before the scheduler fails this request with `STATUS_NO_QUOTA_AVAILABLE`. This value is NOT the same as RPC timeout. The latter should be greater than this timeout.
  An duration less than 10s is suggested.
- optional EnvironmentDesc env_desc = 2
  Tasks grant requested.
- uint32 immediate_reqs = 3
- uint32 prefetch_reqs = 4
- uint32 next_keep_alive_in_ms = 5
  The caller should call `KeepTaskAlive` in this time period.
  An interval less than 10s is suggested.
- uint32 min_version = 7
  Minimal version of daemon is requested.
message WaitForStartingTaskResponse
scheduler.proto:203
- repeated StartingTaskGrant grants = 1
  Quota allocated to the caller. Note that this array does not need to have exactly `desired_quota` elements. If the system is under heavy load, this method can return with less quota than requested.
rpc KeepTaskAlive (KeepTaskAliveRequest, KeepTaskAliveResponse)
scheduler.proto:280
For long-running compilation tasks. The grant (or, "lease", if that terms makes you feel better) timeout set in the initial request is likely to be too short. In this case the client should renew its grant periodically by calling this method.
message KeepTaskAliveRequest
scheduler.proto:212
- string token = 6
- repeated uint64 task_grant_ids = 1
- uint32 next_keep_alive_in_ms = 5
  The caller should call `KeepTaskAlive` again in this time period.
  An interval less than 10s is suggested.
message KeepTaskAliveResponse
scheduler.proto:221
- repeated bool statuses = 1
rpc FreeTask (FreeTaskRequest, FreeTaskResponse)
scheduler.proto:294
The daemon should call this after it finishes its compilation to return the quota to global quota pool. Failing to call this method is not catastrophic, though. So long as the client does not renew its grant inefinitely, the grant will expire sooner or later. Once the grant expires, we're back to normal. Actually I believe the scheduler and the servant can cooperate to drop a grant actively once the compilation is done. This way we don't have to count on client not to keep renewing its least to work correctly. Well-behaved client should pair this call with its acquisition.
message FreeTaskRequest
scheduler.proto:225
- string token = 2
- repeated uint64 task_grant_ids = 1
message FreeTaskResponse
scheduler.proto:231
(message has no fields)
rpc GetRunningTasks (GetRunningTasksRequest, GetRunningTasksResponse)
scheduler.proto:297
Get all running compile tasks.
message GetRunningTasksRequest
scheduler.proto:240
NOTHING.
(message has no fields)
message GetRunningTasksResponse
scheduler.proto:244
- repeated RunningTask running_tasks = 1

@sa: Enumeration with the same name in `daemon/cloud/execution_engine.h`.

NOT_ACCEPTING_TASK_REASON_UNKNOWN = 0
NOT_ACCEPTING_TASK_REASON_USER_INSTRUCTED = 1
Keep them in sync with `daemon/cloud/execution_engine.h`.
NOT_ACCEPTING_TASK_REASON_POOR_MACHINE = 2
NOT_ACCEPTING_TASK_REASON_CGROUPS_PRESENT = 3
NOT_ACCEPTING_TASK_REASON_BEHIND_NAT = 4
NOT_ACCEPTING_TASK_REASON_NOT_VERIFIED = 100
Solely used by this IDL.

Used in: GetRunningTasksResponse, HeartbeatRequest

uint64 servant_task_id = 1
uint64 task_grant_id = 2
string servant_location = 3
string task_digest = 7

Defines priority when selecting servant. The scheduler usually prefer to assign task to servant with higher priority.

Used in: HeartbeatRequest

SERVANT_PRIORITY_UNKNOWN = 0
SERVANT_PRIORITY_DEDICATED = 1
Dedicated servant. QoS of them are somewhat guaranteed.
SERVANT_PRIORITY_USER = 2
Users who volunteer their CPUs (if not otherwise ruled out by other factors. @sa: `NotAcceptingTaskReason`.)

Only servant who is able to provide such environment is returned.

uint32 reason = 1
@sa: StartingTaskReason

Describes a newly-allocated task quota.

Used in: WaitForStartingTaskResponse

uint64 task_grant_id = 1
ID allocated to this task. You will need this to invoke renew operation. For the moment this ID is allocated as a monotonically increasing number sequence. Perhaps using a 128-bit random number would help in mitigating collision attack? Note that the daemons do not verify each other's token, they solely relies on what's provided by the scheduler (e.g., this ID, and (if implemented) scheduler's signature) to be safe.
string servant_location = 2
Physical location of this node. (IP:port)

Describes the reason why a task grant is acquired.

STARTING_TASK_REASON_UNKNOWN = 0
STARTING_TASK_REASON_NORMAL = 1
STARTING_TASK_REASON_PREFETCH = 2

TODO(luobogao): Some of the following status code are quite common, and can be defined in Flare to be shared by all services.

STATUS_UNKNOWN = 0
`rpc.STATUS_SUCCESS`, actually.
STATUS_NO_QUOTA_AVAILABLE = 1001
The entire system is under heavy load, and no quota can be allocated to the caller.
STATUS_NOT_IMPLEMENTED = 1002
STATUS_ACCESS_DENIED = 1003
Invalid token?
STATUS_INVALID_ARGUMENT = 1004
STATUS_VERSION_TOO_OLD = 1005
Daemon should be upgraded.
STATUS_ENVIRONMENT_NOT_AVAILABLE = 1006
No matched servant environment.

package yadcc.scheduler

service SchedulerService

rpc Heartbeat (HeartbeatRequest, HeartbeatResponse)

message HeartbeatRequest

string token = 13

uint32 next_heartbeat_in_ms = 7

uint32 version = 11

string location = 1

uint32 num_processors = 10

uint32 current_load = 4

ServantPriority servant_priority = 14

uint32 not_accepting_task_reason = 12

uint32 capacity = 3

uint64 total_memory_in_bytes = 15

uint64 memory_available_in_bytes = 16

repeated EnvironmentDesc env_descs = 6

repeated RunningTask running_tasks = 17

message HeartbeatResponse

repeated string acceptable_tokens = 2

repeated uint64 expired_tasks = 1

rpc GetConfig (GetConfigRequest, GetConfigResponse)

message GetConfigRequest

string token = 1

message GetConfigResponse

string serving_daemon_token = 1

rpc WaitForStartingTask (WaitForStartingTaskRequest, WaitForStartingTaskResponse)

message WaitForStartingTaskRequest

string token = 6

uint32 milliseconds_to_wait = 1

optional EnvironmentDesc env_desc = 2

uint32 immediate_reqs = 3

uint32 prefetch_reqs = 4

uint32 next_keep_alive_in_ms = 5

uint32 min_version = 7

message WaitForStartingTaskResponse

repeated StartingTaskGrant grants = 1

rpc KeepTaskAlive (KeepTaskAliveRequest, KeepTaskAliveResponse)

message KeepTaskAliveRequest

string token = 6

repeated uint64 task_grant_ids = 1

uint32 next_keep_alive_in_ms = 5

message KeepTaskAliveResponse

repeated bool statuses = 1

rpc FreeTask (FreeTaskRequest, FreeTaskResponse)

message FreeTaskRequest

string token = 2

repeated uint64 task_grant_ids = 1

message FreeTaskResponse

rpc GetRunningTasks (GetRunningTasksRequest, GetRunningTasksResponse)

message GetRunningTasksRequest

message GetRunningTasksResponse

repeated RunningTask running_tasks = 1

enum NotAcceptingTaskReason

NOT_ACCEPTING_TASK_REASON_UNKNOWN = 0

NOT_ACCEPTING_TASK_REASON_USER_INSTRUCTED = 1

NOT_ACCEPTING_TASK_REASON_POOR_MACHINE = 2

NOT_ACCEPTING_TASK_REASON_CGROUPS_PRESENT = 3

NOT_ACCEPTING_TASK_REASON_BEHIND_NAT = 4

NOT_ACCEPTING_TASK_REASON_NOT_VERIFIED = 100

message RunningTask

uint64 servant_task_id = 1

uint64 task_grant_id = 2

string servant_location = 3

string task_digest = 7

enum ServantPriority

SERVANT_PRIORITY_UNKNOWN = 0

SERVANT_PRIORITY_DEDICATED = 1

SERVANT_PRIORITY_USER = 2

message StartingTaskApplication

uint32 reason = 1

message StartingTaskGrant

uint64 task_grant_id = 1

string servant_location = 2

enum StartingTaskReason

STARTING_TASK_REASON_UNKNOWN = 0

STARTING_TASK_REASON_NORMAL = 1

STARTING_TASK_REASON_PREFETCH = 2

enum Status

STATUS_UNKNOWN = 0

STATUS_NO_QUOTA_AVAILABLE = 1001