github.com/pachyderm/pachyderm@v1.13.4/src/client/admin/v1_7/pps/pps.proto

syntax = "proto3";

package pps_1_7;
option go_package = "github.com/pachyderm/pachyderm/src/client/admin/v1_7/pps";

import "google/protobuf/empty.proto";
import "google/protobuf/timestamp.proto";
import "google/protobuf/duration.proto";

import "gogoproto/gogo.proto";

import "client/admin/v1_7/pfs/pfs.proto";

message Secret {
  // Name must be the name of the secret in kubernetes.
  string name = 1;
  // Key of the secret to load into env_var, this field only has meaning if EnvVar != "".
  string key = 4;
  string mount_path = 2;
  string env_var = 3;
}

message Transform {
  string image = 1;
  repeated string cmd = 2;
  map<string, string> env = 3;
  repeated Secret secrets = 4;
  repeated string image_pull_secrets = 9;
  repeated string stdin = 5;
  repeated int64 accept_return_code = 6;
  bool debug = 7;
  string user = 10;
  string working_dir = 11;
}

message Egress {
  string URL = 1;
}

message Job {
  string id = 1 [(gogoproto.customname) = "ID"];
}

enum JobState {
  JOB_STARTING = 0;
  JOB_RUNNING = 1;
  JOB_FAILURE = 2;
  JOB_SUCCESS = 3;
  JOB_KILLED = 4;
}

message Service {
  int32 internal_port = 1;
  int32 external_port = 2;
  string ip = 3 [(gogoproto.customname) = "IP"];
}

message AtomInput {
  reserved 7;
  string name = 1;
  string repo = 2;
  string branch = 3;
  string commit = 4;
  string glob = 5;
  bool lazy = 6;
  // EmptyFiles, if true, will cause files from this atom to be presented as
  // empty files. This is useful in shuffle pipelines where you want to read
  // the names of files and reorganize them using symlinks.
  bool empty_files = 8;
}

message CronInput {
  string name = 1;
  string repo = 2;
  string commit = 3;
  string spec = 4;
  google.protobuf.Timestamp start = 5;
}

message GitInput {
  string name = 1;
  string url = 2 [(gogoproto.customname) = "URL"];
  string branch = 3;
  string commit = 4;
}

message Input {
  AtomInput atom = 1;
  repeated Input cross = 2;
  repeated Input union = 3;
  CronInput cron = 4;
  GitInput git = 5;
}

message JobInput {
  string name = 4;
  pfs_1_7.Commit commit = 1;
  string glob = 2;
  bool lazy = 3;
}

message ParallelismSpec {
  reserved 1;

  // Starts the pipeline/job with a 'constant' workers, unless 'constant' is
  // zero. If 'constant' is zero (which is the zero value of ParallelismSpec),
  // then Pachyderm will choose the number of workers that is started,
  // (currently it chooses the number of workers in the cluster)
  uint64 constant = 2;

  // Starts the pipeline/job with number of workers equal to 'coefficient' * N,
  // where N is the number of nodes in the kubernetes cluster.
  //
  // For example, if each Kubernetes node has four CPUs, you might set
  // 'coefficient' to four, so that there are four Pachyderm workers per
  // Kubernetes node, and each Pachyderm worker gets one CPU. If you want to
  // reserve half the nodes in your cluster for other tasks, you might set
  // 'coefficient' to 0.5.
  double coefficient = 3;
}

// HashTreeSpec sets the number of shards into which pps splits a pipeline's
// output commits (sharded commits are implemented in Pachyderm 1.8+ only)
message HashtreeSpec {
  uint64 constant = 1;
}

message InputFile {
  // This file's absolute path within its pfs repo.
  string path = 4;

  // This file's hash
  bytes hash = 5;
}

message Datum {
  // ID is the hash computed from all the files
  string id = 1 [(gogoproto.customname) = "ID"];
  Job job = 2;
}

enum DatumState {
    FAILED = 0;
    SUCCESS = 1;
    SKIPPED = 2;
    STARTING = 3;
}

message DatumInfo {
  Datum datum = 1;
  DatumState state = 2;
  ProcessStats stats = 3;
  pfs_1_7.File pfs_state = 4;
  repeated pfs_1_7.FileInfo data = 5;
}

message Aggregate {
  int64 count = 1;
  double mean = 2;
  double stddev = 3;
  double fifth_percentile = 4;
  double ninety_fifth_percentile = 5;
}

message ProcessStats {
  google.protobuf.Duration download_time = 1;
  google.protobuf.Duration process_time = 2;
  google.protobuf.Duration upload_time = 3;
  uint64 download_bytes = 4;
  uint64 upload_bytes = 5;
}

message AggregateProcessStats {
  Aggregate download_time = 1;
  Aggregate process_time = 2;
  Aggregate upload_time = 3;
  Aggregate download_bytes = 4;
  Aggregate upload_bytes = 5;
}

message WorkerStatus {
  string worker_id = 1 [(gogoproto.customname) = "WorkerID"];
  string job_id = 2 [(gogoproto.customname) = "JobID"];
  repeated InputFile data = 3;
  // Started is the time processing on the current datum began.
  google.protobuf.Timestamp started = 4;
  ProcessStats stats = 5;
  int64 queue_size = 6;
}

// ResourceSpec describes the amount of resources that pipeline pods should
// request from kubernetes, for scheduling.
message ResourceSpec {
  // The number of CPUs each worker needs (partial values are allowed, and
  // encouraged)
  float cpu = 1;

  // The amount of memory each worker needs (in bytes, with allowed
  // SI suffixes (M, K, G, Mi, Ki, Gi, etc).
  string memory = 2;

  // The number of GPUs each worker needs.
  int64 gpu = 3;

  // The amount of ephemeral storage each worker needs (in bytes, with allowed
  // SI suffixes (M, K, G, Mi, Ki, Gi, etc).
  string disk = 4;
}

// EtcdJobInfo is the portion of the JobInfo that gets stored in etcd during
// job execution. It contains fields which change over the lifetime of the job
// but aren't used in the execution of the job.
message EtcdJobInfo {
  Job job = 1;
  Pipeline pipeline = 2;
  pfs_1_7.Commit output_commit = 3;
  // Job restart count (e.g. due to datum failure)
  uint64 restart = 4;

  // Counts of how many times we processed or skipped a datum
  int64 data_processed = 5;
  int64 data_skipped = 6;
  int64 data_total = 7;
  int64 data_failed = 8;

  // Download/process/upload time and download/upload bytes
  ProcessStats stats = 9;

  pfs_1_7.Commit stats_commit = 10;
  JobState state = 11;
  string reason = 12;
  google.protobuf.Timestamp started = 13;
  google.protobuf.Timestamp finished = 14;
}

message JobInfo {
  reserved 4, 5;
  Job job = 1;
  Transform transform = 2;
  Pipeline pipeline = 3;
  uint64 pipeline_version = 13;
  ParallelismSpec parallelism_spec = 12;
  Egress egress = 15;
  Job parent_job = 6;
  google.protobuf.Timestamp started = 7;
  google.protobuf.Timestamp finished = 8;
  pfs_1_7.Commit output_commit = 9;
  JobState state = 10;
  string reason = 35;  // reason explains why the job is in the current state
  Service service = 14;
  pfs_1_7.Repo output_repo = 18;
  string output_branch = 17;
  uint64 restart = 20;
  int64 data_processed = 22;
  int64 data_skipped = 30;
  int64 data_failed = 40;
  int64 data_total = 23;
  ProcessStats stats = 31;
  repeated WorkerStatus worker_status = 24;
  ResourceSpec resource_requests = 25;
  ResourceSpec resource_limits = 36;
  Input input = 26;
  pfs_1_7.BranchInfo new_branch = 27;
  bool incremental = 28;
  pfs_1_7.Commit stats_commit = 29;
  bool enable_stats = 32;
  string salt = 33;
  bool batch = 34;
  ChunkSpec chunk_spec = 37;
  google.protobuf.Duration datum_timeout = 38;
  google.protobuf.Duration job_timeout = 39;
  int64 datum_tries = 41;
  SchedulingSpec scheduling_spec = 42;
  string pod_spec = 43;
}

enum WorkerState {
  POD_RUNNING = 0;
  POD_SUCCESS = 1;
  POD_FAILED = 2;
}

message Worker {
  string name = 1;
  WorkerState state = 2;
}

message JobInfos {
  repeated JobInfo job_info = 1;
}

message Pipeline {
  string name = 1;
}

message PipelineInput {
  string name = 5;
  pfs_1_7.Repo repo = 1;
  string branch = 2;
  string glob = 3;
  bool lazy = 4;
  pfs_1_7.Commit from = 6;
}

enum PipelineState {
  // When the pipeline is not ready to be triggered by commits.
  // This happens when either 1) a pipeline has been created but not
  // yet picked up by a PPS server, or 2) the pipeline does not have
  // any inputs and is meant to be triggered manually
  PIPELINE_STARTING = 0;
  // After this pipeline is picked up by a pachd node.  This is the normal
  // state of a pipeline.
  PIPELINE_RUNNING = 1;
  // After some error caused runPipeline to exit, but before the
  // pipeline is re-run.  This is when the exponential backoff is
  // in effect.
  PIPELINE_RESTARTING = 2;
  // We have retried too many times and we have given up on this pipeline.
  PIPELINE_FAILURE = 3;
  // The pipeline has been explicitly paused by the user.
  PIPELINE_PAUSED = 4;
  // The pipeline is fully functional, but there are no commits to process.
  PIPELINE_STANDBY = 5;
}

// EtcdPipelineInfo is proto that Pachd stores in etcd for each pipeline. It
// tracks the state of the pipeline, and points to its metadata in PFS (and,
// by pointing to a PFS commit, de facto tracks the pipeline's version)
message EtcdPipelineInfo {
  PipelineState state = 1;
  string reason = 4;
  pfs_1_7.Commit spec_commit = 2;
  map<int32, int32> job_counts = 3;
  string auth_token = 5;
}

message PipelineInfo {
  reserved 3, 4, 26;
  string id = 17 [(gogoproto.customname) = "ID"];
  Pipeline pipeline = 1;
  uint64 version = 11;
  Transform transform = 2;
  ParallelismSpec parallelism_spec = 10;
	HashtreeSpec hashtree_spec = 42;
  Egress egress = 15;
  google.protobuf.Timestamp created_at = 6;

  // state indicates the current state of the pipeline. This is not stored in
  // PFS along with the rest of this data structure--PPS.InspectPipeline fills
  // it in
  PipelineState state = 7;
  // same for stopped field
  bool stopped = 38;
  string recent_error = 8;

  // job_counts indicates the number of jobs within this pipeline in a given
  // state. This is not stored in PFS along with the rest of this data
  // structure--PPS.InspectPipeline fills it in
  map<int32, int32> job_counts = 9;
  string output_branch = 16;
  google.protobuf.Duration scale_down_threshold = 18;
  ResourceSpec resource_requests = 19;
  ResourceSpec resource_limits = 31;
  Input input = 20;
  string description = 21;
  bool incremental = 22;
  string cache_size = 23;
  bool enable_stats = 24;
  string salt = 25;
  bool batch = 27;

  // reason includes any error messages associated with a failed pipeline
  string reason = 28;
  int64 max_queue_size = 29;
  Service service = 30;
  ChunkSpec chunk_spec = 32;
  google.protobuf.Duration datum_timeout = 33;
  google.protobuf.Duration job_timeout = 34;
  string githook_url = 35 [(gogoproto.customname) = "GithookURL"];
  pfs_1_7.Commit spec_commit = 36;
  bool standby = 37;
  int64 datum_tries = 39;
  SchedulingSpec scheduling_spec = 40;
  string pod_spec = 41;
}

message PipelineInfos {
  repeated PipelineInfo pipeline_info = 1;
}

message CreateJobRequest {
  reserved 3, 4, 1, 10, 7, 9, 8, 12, 11, 13, 14, 21, 15, 16, 17, 18, 19, 20, 22, 23, 24;
  Pipeline pipeline = 2;
  pfs_1_7.Commit output_commit = 25;
}

message InspectJobRequest {
  // Callers should set either Job or OutputCommit, not both.
  Job job = 1;
  pfs_1_7.Commit output_commit = 3;
  bool block_state = 2; // block until state is either JOB_STATE_FAILURE or JOB_STATE_SUCCESS
}

message ListJobRequest {
  Pipeline pipeline = 1; // nil means all pipelines
  repeated pfs_1_7.Commit input_commit = 2; // nil means all inputs
  pfs_1_7.Commit output_commit = 3;
}

message FlushJobRequest {
  repeated pfs_1_7.Commit commits = 1;
  repeated Pipeline to_pipelines = 2;
}

message DeleteJobRequest {
  Job job = 1;
}

message StopJobRequest {
  Job job = 1;
}

message GetLogsRequest {
  reserved 4;
  // The pipeline from which we want to get logs (required if the job in 'job'
  // was created as part of a pipeline. To get logs from a non-orphan job
  // without the pipeline that created it, you need to use ElasticSearch).
  Pipeline pipeline = 2;

  // The job from which we want to get logs.
  Job job = 1;

  // Names of input files from which we want processing logs. This may contain
  // multiple files, to query pipelines that contain multiple inputs. Each
  // filter may be an absolute path of a file within a pps repo, or it may be
  // a hash for that file (to search for files at specific versions)
  repeated string data_filters = 3;

  Datum datum = 6;

  // If true get logs from the master process
  bool master = 5;

  // Continue to follow new logs as they become available.
  bool follow = 7;

  // If nonzero, the number of lines from the end of the logs to return.  Note:
  // tail applies per container, so you will get tail * <number of pods> total
  // lines back.
  int64 tail = 8;
}

// LogMessage is a log line from a PPS worker, annotated with metadata
// indicating when and why the line was logged.
message LogMessage {
  // The job and pipeline for which a PFS file is being processed (if the job
  // is an orphan job, pipeline name and ID will be unset)
  string pipeline_name = 1;
  string job_id = 3 [(gogoproto.customname) = "JobID"];
  string worker_id = 7 [(gogoproto.customname) = "WorkerID"];
  string datum_id = 9 [(gogoproto.customname) = "DatumID"];
  bool master = 10;

  // The PFS files being processed (one per pipeline/job input)
  repeated InputFile data = 4;

  // User is true if log message comes from the users code.
  bool user = 8;

  // The message logged, and the time at which it was logged
  google.protobuf.Timestamp ts = 5;
  string message = 6;
}

message RestartDatumRequest {
  Job job = 1;
  repeated string data_filters = 2;
}

message InspectDatumRequest {
  Datum datum = 1;
}

message ListDatumRequest {
  Job job = 1;
  int64 page_size = 2;
  int64 page = 3;
}

message ListDatumResponse {
  repeated DatumInfo datum_infos = 1;
  int64 total_pages = 2;
  int64 page = 3;
}

// ListDatumStreamResponse is identical to ListDatumResponse, except that only
// one DatumInfo is present (as these responses are streamed)
message ListDatumStreamResponse {
  DatumInfo datum_info = 1;
  // total_pages is only set in the first response (and set to 0 in all other
  // responses)
  int64 total_pages = 2;
  // page is only set in the first response (and set to 0 in all other
  // responses)
  int64 page = 3;
}

// ChunkSpec specifies how a pipeline should chunk its datums.
message ChunkSpec {
  // number, if nonzero, specifies that each chunk should contain `number`
  // datums. Chunks may contain fewer if the total number of datums don't
  // divide evenly.
  int64 number = 1;
  // size_bytes, if nonzero, specifies a target size for each chunk of datums.
  // Chunks may be larger or smaller than size_bytes, but will usually be
  // pretty close to size_bytes in size.
  int64 size_bytes = 2;
}

message SchedulingSpec {
  map<string, string> node_selector = 1;
  string priority_class_name = 2;
}

message CreatePipelineRequest {
  reserved 3, 4;
  Pipeline pipeline = 1;
  Transform transform = 2;
  ParallelismSpec parallelism_spec = 7;
  HashtreeSpec hashtree_spec = 31;
  Egress egress = 9;
  bool update = 5;
  string output_branch = 10;
  google.protobuf.Duration scale_down_threshold = 11;
  ResourceSpec resource_requests = 12;
  ResourceSpec resource_limits = 22;
  Input input = 13;
  string description = 14;
  bool incremental = 15;
  string cache_size = 16;
  bool enable_stats = 17;
  // Reprocess forces the pipeline to reprocess all datums.
  // It only has meaning if Update is true
  bool reprocess = 18;
  bool batch = 19;
  int64 max_queue_size = 20;
  Service service = 21;
  ChunkSpec chunk_spec = 23;
  google.protobuf.Duration datum_timeout = 24;
  google.protobuf.Duration job_timeout = 25;
  string salt = 26;
  bool standby = 27;
  int64 datum_tries = 28;
  SchedulingSpec scheduling_spec = 29;
  string pod_spec = 30;
}

message InspectPipelineRequest {
  Pipeline pipeline = 1;
}

message ListPipelineRequest {
}

message DeletePipelineRequest {
  reserved 2, 3;
  Pipeline pipeline = 1;
  bool all = 4;
  bool force = 5;
}

message StartPipelineRequest {
  Pipeline pipeline = 1;
}

message StopPipelineRequest {
  Pipeline pipeline = 1;
}

message RerunPipelineRequest {
  Pipeline pipeline = 1;
  repeated pfs_1_7.Commit exclude = 2;
  repeated pfs_1_7.Commit include = 3;
}

message GarbageCollectRequest {
    // Memory is how much memory to use in computing which objects are alive. A
    // larger number will result in more precise garbage collection (at the
    // cost of more memory usage).
    int64 memory_bytes = 1;
}
message GarbageCollectResponse {}

message ActivateAuthRequest {}
message ActivateAuthResponse {}

service API {
  rpc CreateJob(CreateJobRequest) returns (Job) {}
  rpc InspectJob(InspectJobRequest) returns (JobInfo) {}
  // ListJob returns information about current and past Pachyderm jobs. This is
  // deprecated in favor of ListJobStream
  rpc ListJob(ListJobRequest) returns (JobInfos) {}
  // ListJobStream returns information about current and past Pachyderm jobs.
  rpc ListJobStream(ListJobRequest) returns (stream JobInfo) {}
  rpc FlushJob(FlushJobRequest) returns (stream JobInfo) {}
  rpc DeleteJob(DeleteJobRequest) returns (google.protobuf.Empty) {}
  rpc StopJob(StopJobRequest) returns (google.protobuf.Empty) {}
  rpc InspectDatum(InspectDatumRequest) returns (DatumInfo) {}
  // ListDatum returns information about each datum fed to a Pachyderm job. This
  // is deprecated in favor of ListDatumStream
  rpc ListDatum(ListDatumRequest) returns (ListDatumResponse) {}
  // ListDatumStream returns information about each datum fed to a Pachyderm job
  rpc ListDatumStream(ListDatumRequest) returns (stream ListDatumStreamResponse) {}
  rpc RestartDatum(RestartDatumRequest) returns (google.protobuf.Empty) {}

  rpc CreatePipeline(CreatePipelineRequest) returns (google.protobuf.Empty) {}
  rpc InspectPipeline(InspectPipelineRequest) returns (PipelineInfo) {}
  rpc ListPipeline(ListPipelineRequest) returns (PipelineInfos) {}
  rpc DeletePipeline(DeletePipelineRequest) returns (google.protobuf.Empty) {}
  rpc StartPipeline(StartPipelineRequest) returns (google.protobuf.Empty) {}
  rpc StopPipeline(StopPipelineRequest) returns (google.protobuf.Empty) {}
  rpc RerunPipeline(RerunPipelineRequest) returns (google.protobuf.Empty) {}

  // DeleteAll deletes everything
  rpc DeleteAll(google.protobuf.Empty) returns (google.protobuf.Empty) {}
  rpc GetLogs(GetLogsRequest) returns (stream LogMessage) {}

  // Garbage collection
  rpc GarbageCollect(GarbageCollectRequest) returns (GarbageCollectResponse) {}

  // An internal call that causes PPS to put itself into an auth-enabled state
  // (all pipeline have tokens, correct permissions, etcd)
  rpc ActivateAuth(ActivateAuthRequest) returns (ActivateAuthResponse) {}
}