package yadcc.daemon.cloud

Get desktop application:
View/edit binary Protocol Buffers messages

• rpc QueueCxxCompilationTask (QueueCxxCompilationTaskRequest, QueueCxxCompilationTaskResponse)

  daemon.proto:198

  Queue a C/C++ compilation task. The execution of this task might be delayed if the daemon is suffering from a temporarily overload. In case there are already too many tasks queued, this method may reject further tasks actively.

  message QueueCxxCompilationTaskRequest

  daemon.proto:93

  • string token = 1

    Obtained from `scheduler.GetConfig`.

  • uint64 task_grant_id = 2

    Grant for running this task. This ID is allocated by the scheduler.

  • optional EnvironmentDesc env_desc = 3

    Desired compilation environment.

  • string source_path = 4

    Path of the source to be compiled.

  • string invocation_arguments = 5

    Neither `gcc` nor `g++` would appear here. Given that `-x XXX` (i.e., source language) is provided, whether we'll be calling `gcc` or `g++` is not significant.

  • uint32 compression_algorithm = 6

    Algorithm for compressing the preprocessed source code.

    @sa: CompressionAlgorithm

  • bool disallow_cache_fill = 7

    If set, we won't fill the cache on completion.

  message QueueCxxCompilationTaskResponse

  daemon.proto:133

  • uint64 task_id = 1

• rpc ReferenceTask (ReferenceTaskRequest, ReferenceTaskResponse)

  daemon.proto:207

  Indicate to some client wait for the task. If compilation task is already submited on cluster, we should attach this task and add task reference count. Now that if the compilation task comlete on other workflow，the compilation result won't be cleaned utill all the client dereference it.

  message ReferenceTaskRequest

  daemon.proto:137

  • string token = 2

    Obtained from `scheduler.GetConfig`.

  • uint64 task_id = 1

  message ReferenceTaskResponse

  daemon.proto:143

  (message has no fields)

• rpc WaitForCompilationOutput (WaitForCompilationOutputRequest, WaitForCompilationOutputResponse)

  daemon.proto:219

  For compilation task that takes a long time, it would be impossible to return the compilation result from `QueueXxxCompilationTask`. This is required to avoid RPC timeout. In this case, task ID returned by `QueueXxxCompilationTask` can be used to query compilation result (in long-polling fashion) until the compilation itself actually completes. TODO(luobogao): Make this method act in "batch" way, so that it can wait for any pending tasks submitted by the caller.

  message WaitForCompilationOutputRequest

  daemon.proto:145

  • string token = 4

    Obtained from `scheduler.GetConfig`.

  • uint64 task_id = 1

  • uint32 milliseconds_to_wait = 2

    Up to 10s.

  • repeated uint32 acceptable_compression_algorithms = 3

  • uint32 version = 5

  message WaitForCompilationOutputResponse

  daemon.proto:154

  • uint32 status = 1

    @sa: CompilationTaskStatus

  • int32 exit_code = 2

    Compiler exit code.

  • bytes output = 5

    Whatever written to `stdout` / `stderr` by the compiler. I have no idea why, yet these two fields can contain non-utf8 characters. Therefore `string` may not be used here.

  • bytes error = 3

  • optional google.protobuf.Any extra_info = 7

    Language-specific information, @sa: `XxxCompilationInfo`.

  • uint32 compression_algorithm = 4

    Algorithm for compressing the object file (compilation result).

• rpc FreeTask (FreeTaskRequest, FreeTaskResponse)

  daemon.proto:231

  Free resources related to task. Note that even if this method is not called. The daemon would free completed tasks that has completed for a certain period. Well-behaving daemons should call this to free others' resources timely. The reason why we don't do this in `WaitForCompilationOutput` is for handling possible RPC failure. If we free the task there and that RPC fails, the compilation resource we devoted to this task is wasted.

  message FreeTaskRequest

  daemon.proto:182

  • string token = 2

    Obtained from `scheduler.GetConfig`.

  • uint64 task_id = 1

  message FreeTaskResponse

  daemon.proto:188

  NOTHING.

  (message has no fields)

• COMPILATION_TASK_STATUS_UNKNOWN = 0

• COMPILATION_TASK_STATUS_FAILED = 1

  Failed to run the compiler.

• COMPILATION_TASK_STATUS_RUNNING = 2

  The compiler is running.

• COMPILATION_TASK_STATUS_DONE = 3

  Compilation is done, either successfully or with an error.

• COMPILATION_TASK_STATUS_NOT_FOUND = 4

  The task ID is unknown to us.

• COMPRESSION_ALGORITHM_UNKNOWN = 0

• COMPRESSION_ALGORITHM_NONE = 1

  Not supported yet. Unlikely to be supported in the future, either.

• COMPRESSION_ALGORITHM_ZSTD = 2

  Prefered.

@sa: `RpcClientController.ErrorCode()``

• STATUS_UNKNOWN = 0

  `rpc.STATUS_SUCCESS`, actually.

• STATUS_HEAVILY_LOADED = 1001

  This is different from `STATUS_OVERLOADED`. If this status valus is returned, the situation is still managable, and there is no need to kick this node from the compiler cluster.

• STATUS_ENVIRONMENT_NOT_AVAILABLE = 1002

  Not quite possible but if the daemon does not recognize the requested compilation environment, this error can be returned.

• STATUS_ACCESS_DENIED = 1003

  Token invalid?

• STATUS_TASK_NOT_FOUND = 1004

  No task found.

• STATUS_INVALID_ARGUMENT = 1005

  Invalid argument.

• STATUS_DISTRIBUTED_FILE_SYSTEM_IO = 1006

  Failed to access yadcc-fs.