From b2db64e8e97ce29f353c8af891eb0675a0400673 Mon Sep 17 00:00:00 2001 From: Chris Martin Date: Fri, 23 Feb 2024 09:14:43 +0000 Subject: [PATCH 1/2] Better Resolved Query API (#3419) * wip Signed-off-by: Chris Martin * wip Signed-off-by: Chris Martin * wip Signed-off-by: Chris Martin * wip Signed-off-by: Chris Martin * test pass Signed-off-by: Chris Martin * test pass Signed-off-by: Chris Martin * pass config through Signed-off-by: Chris Martin * rename to JobDetails Signed-off-by: Chris Martin * lint Signed-off-by: Chris Martin * lint Signed-off-by: Chris Martin * exclude job Signed-off-by: Chris Martin * don't use time.Now in tests Signed-off-by: Chris Martin * fix tests Signed-off-by: Chris Martin * use a single transaction when fetching runs and jobs Signed-off-by: Chris Martin * lint Signed-off-by: Chris Martin --------- Signed-off-by: Chris Martin Co-authored-by: Chris Martin --- .../DotNet/Armada.Client/ClientGenerated.cs | 12 + .../ArmadaProject.Io.Client.csproj | 1 + client/python/tests/unit/test_gen.py | 185 - config/armada/config.yaml | 1 + internal/armada/configuration/types.go | 5 +- internal/armada/queryapi/database/models.go | 1 + internal/armada/queryapi/database/query.sql | 14 +- .../armada/queryapi/database/query.sql.go | 145 +- internal/armada/queryapi/database/sql.yaml | 4 +- internal/armada/queryapi/query_api.go | 205 +- internal/armada/queryapi/query_api_test.go | 393 +- internal/armada/queryapi/util.go | 22 + internal/armada/server.go | 7 +- pkg/api/api.swagger.go | 6 +- pkg/api/api.swagger.json | 6 +- pkg/api/job.pb.go | 3369 +++++++++++++++++ pkg/api/job.proto | 83 + pkg/api/queryapi.pb.go | 700 ---- pkg/api/queryapi.proto | 34 - pkg/api/submit.pb.go | 345 +- pkg/api/submit.proto | 4 + scripts/build-python-client.sh | 4 +- 22 files changed, 4349 insertions(+), 1197 deletions(-) delete mode 100644 client/python/tests/unit/test_gen.py create mode 100644 internal/armada/queryapi/util.go create mode 100644 pkg/api/job.pb.go create mode 100644 pkg/api/job.proto delete mode 100644 pkg/api/queryapi.pb.go delete mode 100644 pkg/api/queryapi.proto diff --git a/client/DotNet/Armada.Client/ClientGenerated.cs b/client/DotNet/Armada.Client/ClientGenerated.cs index be33f32670c..8eab118a450 100644 --- a/client/DotNet/Armada.Client/ClientGenerated.cs +++ b/client/DotNet/Armada.Client/ClientGenerated.cs @@ -1786,6 +1786,18 @@ public enum ApiJobState [System.Runtime.Serialization.EnumMember(Value = @"UNKNOWN")] UNKNOWN = 5, + [System.Runtime.Serialization.EnumMember(Value = @"SUBMITTED")] + SUBMITTED = 6, + + [System.Runtime.Serialization.EnumMember(Value = @"LEASED")] + LEASED = 7, + + [System.Runtime.Serialization.EnumMember(Value = @"PREEMPTED")] + PREEMPTED = 8, + + [System.Runtime.Serialization.EnumMember(Value = @"CANCELLED")] + CANCELLED = 9, + } [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "10.0.27.0 (Newtonsoft.Json v12.0.0.0)")] diff --git a/client/DotNet/ArmadaProject.Io.Client/ArmadaProject.Io.Client.csproj b/client/DotNet/ArmadaProject.Io.Client/ArmadaProject.Io.Client.csproj index a90120412c6..087bf7581b0 100644 --- a/client/DotNet/ArmadaProject.Io.Client/ArmadaProject.Io.Client.csproj +++ b/client/DotNet/ArmadaProject.Io.Client/ArmadaProject.Io.Client.csproj @@ -37,6 +37,7 @@ /> q.maxQueryItems { + return nil, fmt.Errorf("request contained more than %d jobIds", q.maxQueryItems) + } + + detailsById := make(map[string]*api.JobDetails) + + err := pgx.BeginTxFunc(ctx, q.db, pgx.TxOptions{ + IsoLevel: pgx.RepeatableRead, + AccessMode: pgx.ReadOnly, + DeferrableMode: pgx.Deferrable, + }, func(tx pgx.Tx) error { + queries := database.New(tx) + + // Fetch the Job Rows + resultRows, err := queries.GetJobDetails(ctx, req.JobIds) + if err != nil { + return err + } + + jobsWithRuns := make([]string, 0, len(resultRows)) + decompressor := q.decompressorFactory() + for _, row := range resultRows { + var jobSpec *api.Job = nil + if req.ExpandJobSpec { + jobSpec, err = protoutil.DecompressAndUnmarshall[*api.Job](row.JobSpec, &api.Job{}, decompressor) + if err != nil { + return err + } + } + apiJobState, ok := JobStateMap[row.State] + if !ok { + apiJobState = api.JobState_UNKNOWN + } + detailsById[row.JobID] = &api.JobDetails{ + JobId: row.JobID, + Queue: row.Queue, + Jobset: row.Jobset, + Namespace: NilStringToString(row.Namespace), + State: apiJobState, + SubmittedTs: DbTimeToGoTime(row.Submitted), + CancelTs: DbTimeToGoTime(row.Cancelled), + CancelReason: NilStringToString(row.CancelReason), + LastTransitionTs: DbTimeToGoTime(row.LastTransitionTime), + LatestRunId: NilStringToString(row.LatestRunID), + JobSpec: jobSpec, + } + if req.GetExpandJobRun() && row.LatestRunID != nil { + jobsWithRuns = append(jobsWithRuns, row.JobID) + } + } + // Fetch the Job run details in a separate query. + // We do this because each job can have many runs and so we don;t want to duplicate the job data for each run + if len(jobsWithRuns) > 0 { + runResultRows, err := queries.GetJobRunsByJobIds(ctx, jobsWithRuns) + if err != nil { + return err + } + runsByJob := make(map[string][]*api.JobRunDetails, len(resultRows)) + for _, row := range runResultRows { + jobRuns, ok := runsByJob[row.JobID] + if !ok { + jobRuns = []*api.JobRunDetails{} + } + jobRuns = append(jobRuns, parseJobDetails(row)) + runsByJob[row.JobID] = jobRuns + } + + for jobId, jobDetails := range detailsById { + runs, ok := runsByJob[jobId] + if ok { + jobDetails.JobRuns = runs + } + } + } + return nil + }) + + return &api.JobDetailsResponse{ + JobDetails: detailsById, + }, err +} + +func (q *QueryApi) GetJobRunDetails(ctx context.Context, req *api.JobRunDetailsRequest) (*api.JobRunDetailsResponse, error) { + if len(req.RunIds) > q.maxQueryItems { + return nil, fmt.Errorf("request contained more than %d RunIds", q.maxQueryItems) + } + + queries := database.New(q.db) + resultRows, err := queries.GetJobRunsByRunIds(ctx, req.RunIds) + if err != nil { + return nil, err + } + detailsById := make(map[string]*api.JobRunDetails, len(resultRows)) + for _, row := range resultRows { + detailsById[row.RunID] = parseJobDetails(row) + } + return &api.JobRunDetailsResponse{ + JobRunDetails: detailsById, + }, nil } func (q *QueryApi) GetJobStatus(ctx context.Context, req *api.JobStatusRequest) (*api.JobStatusResponse, error) { + if len(req.JobIds) > q.maxQueryItems { + return nil, fmt.Errorf("request contained more than %d jobIds", q.maxQueryItems) + } + queries := database.New(q.db) - queryResult, err := queries.GetJobState(ctx, req.JobId) + queryResult, err := queries.GetJobStates(ctx, req.JobIds) if err != nil { return nil, err } - status := int16(-1) - if len(queryResult) > 0 { - status = queryResult[0] + dbStatusById := make(map[string]int16, len(queryResult)) + for _, dbRow := range queryResult { + dbStatusById[dbRow.JobID] = dbRow.State } - apiStatus, ok := JobStateMap[status] - if !ok { - apiStatus = api.JobStatus_UNKNOWN + + apiStatusById := make(map[string]api.JobState, len(queryResult)) + for _, jobId := range req.JobIds { + dbStatus, ok := dbStatusById[jobId] + if ok { + apiStatus, ok := JobStateMap[dbStatus] + if !ok { + apiStatus = api.JobState_UNKNOWN // We know about this job but we can't map its state + } + apiStatusById[jobId] = apiStatus + } else { + apiStatusById[jobId] = api.JobState_UNKNOWN // We don't know about this job + } } + return &api.JobStatusResponse{ - JobId: req.JobId, - JobStatus: apiStatus, + JobStates: apiStatusById, }, nil } + +func parseJobDetails(row database.JobRun) *api.JobRunDetails { + runState, ok := JobRunStateMap[row.JobRunState] + if !ok { + runState = api.JobRunState_RUN_STATE_UNKNOWN + } + return &api.JobRunDetails{ + RunId: row.RunID, + JobId: row.JobID, + State: runState, + Cluster: row.Cluster, + Node: NilStringToString(row.Node), + LeasedTs: DbTimeToGoTime(row.Leased), + PendingTs: DbTimeToGoTime(row.Pending), + StartedTs: DbTimeToGoTime(row.Started), + FinishedTs: DbTimeToGoTime(row.Finished), + } +} diff --git a/internal/armada/queryapi/query_api_test.go b/internal/armada/queryapi/query_api_test.go index 9279b1c3d44..7ffa7b03fc4 100644 --- a/internal/armada/queryapi/query_api_test.go +++ b/internal/armada/queryapi/query_api_test.go @@ -1,53 +1,280 @@ package queryapi import ( - "context" "testing" "time" + "github.com/jackc/pgx/v5/pgtype" "github.com/jackc/pgx/v5/pgxpool" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "k8s.io/utils/pointer" + "github.com/armadaproject/armada/internal/armada/queryapi/database" + "github.com/armadaproject/armada/internal/common/armadacontext" + "github.com/armadaproject/armada/internal/common/compress" + dbcommon "github.com/armadaproject/armada/internal/common/database" "github.com/armadaproject/armada/internal/common/database/lookout" "github.com/armadaproject/armada/pkg/api" ) +const ( + defaultMaxQueryItems = 100 +) + +var ( + baseTime, _ = time.Parse("2006-01-02T15:04:05.000Z", "2022-03-01T15:04:05.000Z") + testDecompressor = func() compress.Decompressor { return &compress.NoOpDecompressor{} } +) + +func TestGetJobDetails(t *testing.T) { + ctx, cancel := armadacontext.WithTimeout(armadacontext.Background(), 30*time.Second) + defer cancel() + + job1 := newJob("job1", lookout.JobQueuedOrdinal) + job2 := newJob("job2", lookout.JobRunningOrdinal) + job2.LatestRunID = pointer.String("run1") + + testJobs := []database.Job{job1, job2} + + testJobRuns := []database.JobRun{ + newJobRun("job2", "run1", lookout.JobRunRunningOrdinal, baseTime), + newJobRun("job2", "run2", lookout.JobRunLeaseReturnedOrdinal, baseTime.Add(-1*time.Minute)), + } + + // setup job db + tests := map[string]struct { + request *api.JobDetailsRequest + expectedResponse *api.JobDetailsResponse + }{ + "single job": { + request: &api.JobDetailsRequest{ + JobIds: []string{"job1"}, + }, + expectedResponse: &api.JobDetailsResponse{ + JobDetails: map[string]*api.JobDetails{ + "job1": newJobDetails("job1", api.JobState_QUEUED, ""), + }, + }, + }, + "multiple jobs": { + request: &api.JobDetailsRequest{ + JobIds: []string{"job1", "job2"}, + }, + expectedResponse: &api.JobDetailsResponse{ + JobDetails: map[string]*api.JobDetails{ + "job1": newJobDetails("job1", api.JobState_QUEUED, ""), + "job2": newJobDetails("job2", api.JobState_RUNNING, "run1"), + }, + }, + }, + "no jobs": { + request: &api.JobDetailsRequest{ + JobIds: []string{}, + }, + expectedResponse: &api.JobDetailsResponse{ + JobDetails: map[string]*api.JobDetails{}, + }, + }, + "non existent job": { + request: &api.JobDetailsRequest{ + JobIds: []string{"this job doesn't exist!"}, + }, + expectedResponse: &api.JobDetailsResponse{ + JobDetails: map[string]*api.JobDetails{}, + }, + }, + "ask for run but no run available": { + request: &api.JobDetailsRequest{ + JobIds: []string{"job1"}, + ExpandJobRun: true, + }, + expectedResponse: &api.JobDetailsResponse{ + JobDetails: map[string]*api.JobDetails{ + "job1": newJobDetails("job1", api.JobState_QUEUED, ""), + }, + }, + }, + "ask for runs": { + request: &api.JobDetailsRequest{ + JobIds: []string{"job2"}, + ExpandJobRun: true, + }, + expectedResponse: &api.JobDetailsResponse{ + JobDetails: map[string]*api.JobDetails{ + "job2": newJobDetails( + "job2", + api.JobState_RUNNING, + "run1", + newJobRunDetails("job2", "run1", api.JobRunState_RUN_STATE_RUNNING, baseTime), + newJobRunDetails("job2", "run2", api.JobRunState_RUNS_STATE_LEASE_RETURNED, baseTime.Add(-1*time.Minute))), + }, + }, + }, + } + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + err := lookout.WithLookoutDb(func(db *pgxpool.Pool) error { + err := dbcommon.UpsertWithTransaction(ctx, db, "job", testJobs) + require.NoError(t, err) + err = dbcommon.UpsertWithTransaction(ctx, db, "job_run", testJobRuns) + require.NoError(t, err) + queryApi := New(db, defaultMaxQueryItems, testDecompressor) + resp, err := queryApi.GetJobDetails(ctx, tc.request) + require.NoError(t, err) + assert.Equal(t, tc.expectedResponse, resp) + return nil + }) + assert.NoError(t, err) + }) + } +} + +func TestGetJobRunDetails(t *testing.T) { + ctx, cancel := armadacontext.WithTimeout(armadacontext.Background(), 30*time.Second) + defer cancel() + + testJobs := []database.Job{ + newJob("job1", lookout.JobRunningOrdinal), + } + + testJobRuns := []database.JobRun{ + newJobRun("job1", "run1", lookout.JobRunRunningOrdinal, baseTime), + newJobRun("job1", "run2", lookout.JobRunLeaseReturnedOrdinal, baseTime.Add(-1*time.Minute)), + } + + // setup job db + tests := map[string]struct { + request *api.JobRunDetailsRequest + expectedResponse *api.JobRunDetailsResponse + }{ + "single run": { + request: &api.JobRunDetailsRequest{ + RunIds: []string{"run1"}, + }, + expectedResponse: &api.JobRunDetailsResponse{ + JobRunDetails: map[string]*api.JobRunDetails{ + "run1": newJobRunDetails("job1", "run1", api.JobRunState_RUN_STATE_RUNNING, baseTime), + }, + }, + }, + "multiple runs": { + request: &api.JobRunDetailsRequest{ + RunIds: []string{"run1", "run2"}, + }, + expectedResponse: &api.JobRunDetailsResponse{ + JobRunDetails: map[string]*api.JobRunDetails{ + "run1": newJobRunDetails("job1", "run1", api.JobRunState_RUN_STATE_RUNNING, baseTime), + "run2": newJobRunDetails("job1", "run2", api.JobRunState_RUNS_STATE_LEASE_RETURNED, baseTime.Add(-1*time.Minute)), + }, + }, + }, + "no runs": { + request: &api.JobRunDetailsRequest{ + RunIds: []string{"not a valid run"}, + }, + expectedResponse: &api.JobRunDetailsResponse{ + JobRunDetails: map[string]*api.JobRunDetails{}, + }, + }, + "empty runs": { + request: &api.JobRunDetailsRequest{ + RunIds: []string{}, + }, + expectedResponse: &api.JobRunDetailsResponse{ + JobRunDetails: map[string]*api.JobRunDetails{}, + }, + }, + } + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + err := lookout.WithLookoutDb(func(db *pgxpool.Pool) error { + err := dbcommon.UpsertWithTransaction(ctx, db, "job", testJobs) + require.NoError(t, err) + err = dbcommon.UpsertWithTransaction(ctx, db, "job_run", testJobRuns) + require.NoError(t, err) + queryApi := New(db, defaultMaxQueryItems, testDecompressor) + resp, err := queryApi.GetJobRunDetails(ctx, tc.request) + require.NoError(t, err) + assert.Equal(t, tc.expectedResponse, resp) + return nil + }) + assert.NoError(t, err) + }) + } +} + func TestGetJobStatus(t *testing.T) { - ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + ctx, cancel := armadacontext.WithTimeout(armadacontext.Background(), 30*time.Second) defer cancel() + testdata := []database.Job{ + newJob("leasedJob", lookout.JobLeasedOrdinal), + newJob("runningJob", lookout.JobRunningOrdinal), + newJob("succeededJob", lookout.JobSucceededOrdinal), + } // setup job db tests := map[string]struct { - jobId string + jobIds []string expectedResponse *api.JobStatusResponse }{ "leased job": { - jobId: "leasedJob", - expectedResponse: &api.JobStatusResponse{JobId: "leasedJob", JobStatus: api.JobStatus_LEASED}, + jobIds: []string{"leasedJob"}, + expectedResponse: &api.JobStatusResponse{ + JobStates: map[string]api.JobState{ + "leasedJob": api.JobState_LEASED, + }, + }, }, "running job": { - jobId: "runningJob", - expectedResponse: &api.JobStatusResponse{JobId: "runningJob", JobStatus: api.JobStatus_RUNNING}, + jobIds: []string{"runningJob"}, + expectedResponse: &api.JobStatusResponse{ + JobStates: map[string]api.JobState{ + "runningJob": api.JobState_RUNNING, + }, + }, + }, + "succeeded job": { + jobIds: []string{"succeededJob"}, + expectedResponse: &api.JobStatusResponse{ + JobStates: map[string]api.JobState{ + "succeededJob": api.JobState_SUCCEEDED, + }, + }, }, - "completed job": { - jobId: "completedJob", - expectedResponse: &api.JobStatusResponse{JobId: "completedJob", JobStatus: api.JobStatus_SUCCEEDED}, + "multiple jobs": { + jobIds: []string{"succeededJob", "runningJob"}, + expectedResponse: &api.JobStatusResponse{ + JobStates: map[string]api.JobState{ + "succeededJob": api.JobState_SUCCEEDED, + "runningJob": api.JobState_RUNNING, + }, + }, }, "missing job": { - jobId: "missingJob", - expectedResponse: &api.JobStatusResponse{JobId: "missingJob", JobStatus: api.JobStatus_UNKNOWN}, + jobIds: []string{"missingJob"}, + expectedResponse: &api.JobStatusResponse{ + JobStates: map[string]api.JobState{ + "missingJob": api.JobState_UNKNOWN, + }, + }, + }, + "no jobs": { + jobIds: []string{}, + expectedResponse: &api.JobStatusResponse{ + JobStates: map[string]api.JobState{}, + }, }, } for name, tc := range tests { t.Run(name, func(t *testing.T) { err := lookout.WithLookoutDb(func(db *pgxpool.Pool) error { - queryApi := New(db) - err := insertTestData(ctx, db) + err := dbcommon.UpsertWithTransaction(ctx, db, "job", testdata) require.NoError(t, err) - resp, err := queryApi.GetJobStatus(context.Background(), &api.JobStatusRequest{JobId: tc.jobId}) + queryApi := New(db, defaultMaxQueryItems, testDecompressor) + resp, err := queryApi.GetJobStatus(ctx, &api.JobStatusRequest{JobIds: tc.jobIds}) require.NoError(t, err) - assert.Equal(t, resp, tc.expectedResponse) + assert.Equal(t, tc.expectedResponse, resp) return nil }) assert.NoError(t, err) @@ -55,62 +282,90 @@ func TestGetJobStatus(t *testing.T) { } } -func insertTestData(ctx context.Context, db *pgxpool.Pool) error { - err := insertJob(ctx, db, "leasedJob", lookout.JobLeasedOrdinal) - if err != nil { - return err +func newJob(jobId string, state int16) database.Job { + return database.Job{ + JobID: jobId, + Queue: "testQueue", + Owner: "testOwner", + Jobset: "testJobset", + Cpu: 0, + Memory: 0, + EphemeralStorage: 0, + Gpu: 0, + Priority: 0, + Submitted: pgtype.Timestamp{ + Time: baseTime, + Valid: true, + }, + Cancelled: pgtype.Timestamp{}, + State: state, + LastTransitionTime: pgtype.Timestamp{ + Time: baseTime, + Valid: true, + }, + LastTransitionTimeSeconds: 0, + JobSpec: []byte{}, + Duplicate: false, + PriorityClass: nil, + LatestRunID: nil, + CancelReason: nil, + Namespace: pointer.String("testNamespace"), + Annotations: nil, } - err = insertJob(ctx, db, "runningJob", lookout.JobRunningOrdinal) - if err != nil { - return err +} + +func newJobRun(jobId, runId string, state int16, leased time.Time) database.JobRun { + return database.JobRun{ + RunID: runId, + JobID: jobId, + Cluster: "testCluster", + Node: pointer.String("testNode"), + Pending: pgtype.Timestamp{ + Time: baseTime, + Valid: true, + }, + Started: pgtype.Timestamp{ + Time: baseTime, + Valid: true, + }, + Finished: pgtype.Timestamp{}, + JobRunState: state, + Error: nil, + ExitCode: nil, + Leased: pgtype.Timestamp{ + Time: leased, + Valid: true, + }, } - err = insertJob(ctx, db, "completedJob", lookout.JobSucceededOrdinal) - if err != nil { - return err +} + +func newJobDetails(jobId string, state api.JobState, latestRunId string, runs ...*api.JobRunDetails) *api.JobDetails { + return &api.JobDetails{ + JobId: jobId, + Queue: "testQueue", + Jobset: "testJobset", + Namespace: "testNamespace", + State: state, + SubmittedTs: &baseTime, + CancelTs: nil, + CancelReason: "", + LastTransitionTs: &baseTime, + LatestRunId: latestRunId, + JobSpec: nil, + JobRuns: runs, } - return nil } -func insertJob(ctx context.Context, db *pgxpool.Pool, jobId string, state int16) error { - // Prepare the SQL query - sql := `INSERT INTO job(job_id, queue, owner, jobset, cpu, memory, ephemeral_storage, gpu, priority, submitted, state, last_transition_time, last_transition_time_seconds, job_spec, duplicate) - VALUES($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)` - - // Prepare dummy values - queue := " " - owner := " " - jobset := " " - cpu := int64(0) - memory := int64(0) - ephemeralStorage := int64(0) - gpu := int64(0) - priority := int64(0) - submitted := time.Now() - lastTransitionTime := time.Now() - lastTransitionTimeSeconds := int64(0) - jobSpec := []byte{} - duplicate := false - - // Execute the query with the prepared dummy values - _, err := db.Exec( - ctx, - sql, - jobId, - queue, - owner, - jobset, - cpu, - memory, - ephemeralStorage, - gpu, - priority, - submitted, - state, - lastTransitionTime, - lastTransitionTimeSeconds, - jobSpec, - duplicate) - - // Return any error that might have occurred during the execution - return err +func newJobRunDetails(jobId string, runId string, state api.JobRunState, leased time.Time) *api.JobRunDetails { + return &api.JobRunDetails{ + RunId: runId, + JobId: jobId, + State: state, + Cluster: "testCluster", + Node: "testNode", + LeasedTs: &leased, + PendingTs: &baseTime, + StartedTs: &baseTime, + FinishedTs: nil, + } } diff --git a/internal/armada/queryapi/util.go b/internal/armada/queryapi/util.go new file mode 100644 index 00000000000..239af87ba23 --- /dev/null +++ b/internal/armada/queryapi/util.go @@ -0,0 +1,22 @@ +package queryapi + +import ( + "time" + + "github.com/jackc/pgx/v5/pgtype" +) + +func NilStringToString(s *string) string { + if s == nil { + return "" + } + return *s +} + +func DbTimeToGoTime(t pgtype.Timestamp) *time.Time { + if !t.Valid { + return nil + } + tt := t.Time.UTC() + return &tt +} diff --git a/internal/armada/server.go b/internal/armada/server.go index 8061ab12b7a..8b49ca20dfb 100644 --- a/internal/armada/server.go +++ b/internal/armada/server.go @@ -262,8 +262,11 @@ func Serve(ctx *armadacontext.Context, config *configuration.ArmadaConfig, healt if err != nil { return errors.WithMessage(err, "error creating QueryApi postgres pool") } - queryapiServer := queryapi.New(queryDb) - api.RegisterQueryApiServer(grpcServer, queryapiServer) + queryapiServer := queryapi.New( + queryDb, + config.QueryApi.MaxQueryItems, + func() compress.Decompressor { return compress.NewZlibDecompressor() }) + api.RegisterJobsServer(grpcServer, queryapiServer) } api.RegisterSubmitServer(grpcServer, pulsarSubmitServer) diff --git a/pkg/api/api.swagger.go b/pkg/api/api.swagger.go index 43c6eb818e9..0f338497a6b 100644 --- a/pkg/api/api.swagger.go +++ b/pkg/api/api.swagger.go @@ -1296,7 +1296,11 @@ func SwaggerJsonTemplate() string { " \"RUNNING\",\n" + " \"SUCCEEDED\",\n" + " \"FAILED\",\n" + - " \"UNKNOWN\"\n" + + " \"UNKNOWN\",\n" + + " \"SUBMITTED\",\n" + + " \"LEASED\",\n" + + " \"PREEMPTED\",\n" + + " \"CANCELLED\"\n" + " ]\n" + " },\n" + " \"apiJobSubmitRequest\": {\n" + diff --git a/pkg/api/api.swagger.json b/pkg/api/api.swagger.json index d750bd1bfbb..963593816f5 100644 --- a/pkg/api/api.swagger.json +++ b/pkg/api/api.swagger.json @@ -1285,7 +1285,11 @@ "RUNNING", "SUCCEEDED", "FAILED", - "UNKNOWN" + "UNKNOWN", + "SUBMITTED", + "LEASED", + "PREEMPTED", + "CANCELLED" ] }, "apiJobSubmitRequest": { diff --git a/pkg/api/job.pb.go b/pkg/api/job.pb.go new file mode 100644 index 00000000000..f53f246e9c8 --- /dev/null +++ b/pkg/api/job.pb.go @@ -0,0 +1,3369 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: pkg/api/job.proto + +package api + +import ( + context "context" + fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + reflect "reflect" + strings "strings" + time "time" + + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" + _ "github.com/gogo/protobuf/types" + github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf +var _ = time.Kitchen + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type JobRunState int32 + +const ( + JobRunState_RUN_STATE_UNKNOWN JobRunState = 0 + JobRunState_RUN_STATE_LEASED JobRunState = 1 + JobRunState_RUN_STATE_PENDING JobRunState = 2 + JobRunState_RUN_STATE_RUNNING JobRunState = 3 + JobRunState_RUN_STATE_SUCCEEDED JobRunState = 4 + JobRunState_RUN_STATE_FAILED JobRunState = 5 + JobRunState_RUN_STATE_PREEMPTED JobRunState = 6 + JobRunState_RUN_STATE_CANCELLED JobRunState = 7 + JobRunState_RUN_STATE_LEASE_EXPIRED JobRunState = 8 + JobRunState_RUNS_STATE_LEASE_RETURNED JobRunState = 9 +) + +var JobRunState_name = map[int32]string{ + 0: "RUN_STATE_UNKNOWN", + 1: "RUN_STATE_LEASED", + 2: "RUN_STATE_PENDING", + 3: "RUN_STATE_RUNNING", + 4: "RUN_STATE_SUCCEEDED", + 5: "RUN_STATE_FAILED", + 6: "RUN_STATE_PREEMPTED", + 7: "RUN_STATE_CANCELLED", + 8: "RUN_STATE_LEASE_EXPIRED", + 9: "RUNS_STATE_LEASE_RETURNED", +} + +var JobRunState_value = map[string]int32{ + "RUN_STATE_UNKNOWN": 0, + "RUN_STATE_LEASED": 1, + "RUN_STATE_PENDING": 2, + "RUN_STATE_RUNNING": 3, + "RUN_STATE_SUCCEEDED": 4, + "RUN_STATE_FAILED": 5, + "RUN_STATE_PREEMPTED": 6, + "RUN_STATE_CANCELLED": 7, + "RUN_STATE_LEASE_EXPIRED": 8, + "RUNS_STATE_LEASE_RETURNED": 9, +} + +func (x JobRunState) String() string { + return proto.EnumName(JobRunState_name, int32(x)) +} + +func (JobRunState) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_e45f6b75bfad87a4, []int{0} +} + +type JobRunDetails struct { + RunId string `protobuf:"bytes,1,opt,name=run_id,json=runId,proto3" json:"runId,omitempty"` + JobId string `protobuf:"bytes,2,opt,name=job_id,json=jobId,proto3" json:"jobId,omitempty"` + State JobRunState `protobuf:"varint,3,opt,name=state,proto3,enum=api.JobRunState" json:"state,omitempty"` + Cluster string `protobuf:"bytes,4,opt,name=cluster,proto3" json:"cluster,omitempty"` + Node string `protobuf:"bytes,5,opt,name=node,proto3" json:"node,omitempty"` + LeasedTs *time.Time `protobuf:"bytes,7,opt,name=leased_ts,json=leasedTs,proto3,stdtime" json:"leasedTs,omitempty"` + PendingTs *time.Time `protobuf:"bytes,8,opt,name=pending_ts,json=pendingTs,proto3,stdtime" json:"pendingTs,omitempty"` + StartedTs *time.Time `protobuf:"bytes,9,opt,name=started_ts,json=startedTs,proto3,stdtime" json:"startedTs,omitempty"` + FinishedTs *time.Time `protobuf:"bytes,10,opt,name=finished_ts,json=finishedTs,proto3,stdtime" json:"finishedTs,omitempty"` +} + +func (m *JobRunDetails) Reset() { *m = JobRunDetails{} } +func (*JobRunDetails) ProtoMessage() {} +func (*JobRunDetails) Descriptor() ([]byte, []int) { + return fileDescriptor_e45f6b75bfad87a4, []int{0} +} +func (m *JobRunDetails) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *JobRunDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_JobRunDetails.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *JobRunDetails) XXX_Merge(src proto.Message) { + xxx_messageInfo_JobRunDetails.Merge(m, src) +} +func (m *JobRunDetails) XXX_Size() int { + return m.Size() +} +func (m *JobRunDetails) XXX_DiscardUnknown() { + xxx_messageInfo_JobRunDetails.DiscardUnknown(m) +} + +var xxx_messageInfo_JobRunDetails proto.InternalMessageInfo + +func (m *JobRunDetails) GetRunId() string { + if m != nil { + return m.RunId + } + return "" +} + +func (m *JobRunDetails) GetJobId() string { + if m != nil { + return m.JobId + } + return "" +} + +func (m *JobRunDetails) GetState() JobRunState { + if m != nil { + return m.State + } + return JobRunState_RUN_STATE_UNKNOWN +} + +func (m *JobRunDetails) GetCluster() string { + if m != nil { + return m.Cluster + } + return "" +} + +func (m *JobRunDetails) GetNode() string { + if m != nil { + return m.Node + } + return "" +} + +func (m *JobRunDetails) GetLeasedTs() *time.Time { + if m != nil { + return m.LeasedTs + } + return nil +} + +func (m *JobRunDetails) GetPendingTs() *time.Time { + if m != nil { + return m.PendingTs + } + return nil +} + +func (m *JobRunDetails) GetStartedTs() *time.Time { + if m != nil { + return m.StartedTs + } + return nil +} + +func (m *JobRunDetails) GetFinishedTs() *time.Time { + if m != nil { + return m.FinishedTs + } + return nil +} + +type JobDetails struct { + JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"jobId,omitempty"` + Queue string `protobuf:"bytes,2,opt,name=queue,proto3" json:"queue,omitempty"` + Jobset string `protobuf:"bytes,3,opt,name=jobset,proto3" json:"jobset,omitempty"` + Namespace string `protobuf:"bytes,4,opt,name=namespace,proto3" json:"namespace,omitempty"` + State JobState `protobuf:"varint,5,opt,name=state,proto3,enum=api.JobState" json:"state,omitempty"` + SubmittedTs *time.Time `protobuf:"bytes,6,opt,name=submitted_ts,json=submittedTs,proto3,stdtime" json:"submittedTs,omitempty"` + CancelTs *time.Time `protobuf:"bytes,7,opt,name=cancel_ts,json=cancelTs,proto3,stdtime" json:"cancelTs,omitempty"` + CancelReason string `protobuf:"bytes,8,opt,name=cancel_reason,json=cancelReason,proto3" json:"cancelReason,omitempty"` + LastTransitionTs *time.Time `protobuf:"bytes,9,opt,name=last_transition_ts,json=lastTransitionTs,proto3,stdtime" json:"lastTransitionTs,omitempty"` + LatestRunId string `protobuf:"bytes,10,opt,name=latest_run_id,json=latestRunId,proto3" json:"latestRunId,omitempty"` + JobSpec *Job `protobuf:"bytes,11,opt,name=job_spec,json=jobSpec,proto3" json:"jobSpec,omitempty"` + JobRuns []*JobRunDetails `protobuf:"bytes,12,rep,name=job_runs,json=jobRuns,proto3" json:"jobRuns,omitempty"` +} + +func (m *JobDetails) Reset() { *m = JobDetails{} } +func (*JobDetails) ProtoMessage() {} +func (*JobDetails) Descriptor() ([]byte, []int) { + return fileDescriptor_e45f6b75bfad87a4, []int{1} +} +func (m *JobDetails) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *JobDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_JobDetails.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *JobDetails) XXX_Merge(src proto.Message) { + xxx_messageInfo_JobDetails.Merge(m, src) +} +func (m *JobDetails) XXX_Size() int { + return m.Size() +} +func (m *JobDetails) XXX_DiscardUnknown() { + xxx_messageInfo_JobDetails.DiscardUnknown(m) +} + +var xxx_messageInfo_JobDetails proto.InternalMessageInfo + +func (m *JobDetails) GetJobId() string { + if m != nil { + return m.JobId + } + return "" +} + +func (m *JobDetails) GetQueue() string { + if m != nil { + return m.Queue + } + return "" +} + +func (m *JobDetails) GetJobset() string { + if m != nil { + return m.Jobset + } + return "" +} + +func (m *JobDetails) GetNamespace() string { + if m != nil { + return m.Namespace + } + return "" +} + +func (m *JobDetails) GetState() JobState { + if m != nil { + return m.State + } + return JobState_QUEUED +} + +func (m *JobDetails) GetSubmittedTs() *time.Time { + if m != nil { + return m.SubmittedTs + } + return nil +} + +func (m *JobDetails) GetCancelTs() *time.Time { + if m != nil { + return m.CancelTs + } + return nil +} + +func (m *JobDetails) GetCancelReason() string { + if m != nil { + return m.CancelReason + } + return "" +} + +func (m *JobDetails) GetLastTransitionTs() *time.Time { + if m != nil { + return m.LastTransitionTs + } + return nil +} + +func (m *JobDetails) GetLatestRunId() string { + if m != nil { + return m.LatestRunId + } + return "" +} + +func (m *JobDetails) GetJobSpec() *Job { + if m != nil { + return m.JobSpec + } + return nil +} + +func (m *JobDetails) GetJobRuns() []*JobRunDetails { + if m != nil { + return m.JobRuns + } + return nil +} + +type JobDetailsRequest struct { + JobIds []string `protobuf:"bytes,1,rep,name=job_ids,json=jobIds,proto3" json:"jobIds,omitempty"` + ExpandJobSpec bool `protobuf:"varint,2,opt,name=expand_job_spec,json=expandJobSpec,proto3" json:"expandJobSpec,omitempty"` + ExpandJobRun bool `protobuf:"varint,3,opt,name=expand_job_run,json=expandJobRun,proto3" json:"expandJobRun,omitempty"` +} + +func (m *JobDetailsRequest) Reset() { *m = JobDetailsRequest{} } +func (*JobDetailsRequest) ProtoMessage() {} +func (*JobDetailsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e45f6b75bfad87a4, []int{2} +} +func (m *JobDetailsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *JobDetailsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_JobDetailsRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *JobDetailsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_JobDetailsRequest.Merge(m, src) +} +func (m *JobDetailsRequest) XXX_Size() int { + return m.Size() +} +func (m *JobDetailsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_JobDetailsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_JobDetailsRequest proto.InternalMessageInfo + +func (m *JobDetailsRequest) GetJobIds() []string { + if m != nil { + return m.JobIds + } + return nil +} + +func (m *JobDetailsRequest) GetExpandJobSpec() bool { + if m != nil { + return m.ExpandJobSpec + } + return false +} + +func (m *JobDetailsRequest) GetExpandJobRun() bool { + if m != nil { + return m.ExpandJobRun + } + return false +} + +type JobDetailsResponse struct { + JobDetails map[string]*JobDetails `protobuf:"bytes,1,rep,name=job_details,json=jobDetails,proto3" json:"jobDetails,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (m *JobDetailsResponse) Reset() { *m = JobDetailsResponse{} } +func (*JobDetailsResponse) ProtoMessage() {} +func (*JobDetailsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e45f6b75bfad87a4, []int{3} +} +func (m *JobDetailsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *JobDetailsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_JobDetailsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *JobDetailsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_JobDetailsResponse.Merge(m, src) +} +func (m *JobDetailsResponse) XXX_Size() int { + return m.Size() +} +func (m *JobDetailsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_JobDetailsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_JobDetailsResponse proto.InternalMessageInfo + +func (m *JobDetailsResponse) GetJobDetails() map[string]*JobDetails { + if m != nil { + return m.JobDetails + } + return nil +} + +type JobRunDetailsResponse struct { + JobRunDetails map[string]*JobRunDetails `protobuf:"bytes,1,rep,name=job_run_details,json=jobRunDetails,proto3" json:"jobRunDetails,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (m *JobRunDetailsResponse) Reset() { *m = JobRunDetailsResponse{} } +func (*JobRunDetailsResponse) ProtoMessage() {} +func (*JobRunDetailsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e45f6b75bfad87a4, []int{4} +} +func (m *JobRunDetailsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *JobRunDetailsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_JobRunDetailsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *JobRunDetailsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_JobRunDetailsResponse.Merge(m, src) +} +func (m *JobRunDetailsResponse) XXX_Size() int { + return m.Size() +} +func (m *JobRunDetailsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_JobRunDetailsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_JobRunDetailsResponse proto.InternalMessageInfo + +func (m *JobRunDetailsResponse) GetJobRunDetails() map[string]*JobRunDetails { + if m != nil { + return m.JobRunDetails + } + return nil +} + +type JobRunDetailsRequest struct { + RunIds []string `protobuf:"bytes,1,rep,name=run_ids,json=runIds,proto3" json:"runIds,omitempty"` +} + +func (m *JobRunDetailsRequest) Reset() { *m = JobRunDetailsRequest{} } +func (*JobRunDetailsRequest) ProtoMessage() {} +func (*JobRunDetailsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e45f6b75bfad87a4, []int{5} +} +func (m *JobRunDetailsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *JobRunDetailsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_JobRunDetailsRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *JobRunDetailsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_JobRunDetailsRequest.Merge(m, src) +} +func (m *JobRunDetailsRequest) XXX_Size() int { + return m.Size() +} +func (m *JobRunDetailsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_JobRunDetailsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_JobRunDetailsRequest proto.InternalMessageInfo + +func (m *JobRunDetailsRequest) GetRunIds() []string { + if m != nil { + return m.RunIds + } + return nil +} + +type JobStatusRequest struct { + JobIds []string `protobuf:"bytes,1,rep,name=job_ids,json=jobIds,proto3" json:"jobIds,omitempty"` +} + +func (m *JobStatusRequest) Reset() { *m = JobStatusRequest{} } +func (*JobStatusRequest) ProtoMessage() {} +func (*JobStatusRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e45f6b75bfad87a4, []int{6} +} +func (m *JobStatusRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *JobStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_JobStatusRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *JobStatusRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_JobStatusRequest.Merge(m, src) +} +func (m *JobStatusRequest) XXX_Size() int { + return m.Size() +} +func (m *JobStatusRequest) XXX_DiscardUnknown() { + xxx_messageInfo_JobStatusRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_JobStatusRequest proto.InternalMessageInfo + +func (m *JobStatusRequest) GetJobIds() []string { + if m != nil { + return m.JobIds + } + return nil +} + +type JobStatusResponse struct { + JobStates map[string]JobState `protobuf:"bytes,1,rep,name=job_states,json=jobStates,proto3" json:"jobStates,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=api.JobState"` +} + +func (m *JobStatusResponse) Reset() { *m = JobStatusResponse{} } +func (*JobStatusResponse) ProtoMessage() {} +func (*JobStatusResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e45f6b75bfad87a4, []int{7} +} +func (m *JobStatusResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *JobStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_JobStatusResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *JobStatusResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_JobStatusResponse.Merge(m, src) +} +func (m *JobStatusResponse) XXX_Size() int { + return m.Size() +} +func (m *JobStatusResponse) XXX_DiscardUnknown() { + xxx_messageInfo_JobStatusResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_JobStatusResponse proto.InternalMessageInfo + +func (m *JobStatusResponse) GetJobStates() map[string]JobState { + if m != nil { + return m.JobStates + } + return nil +} + +func init() { + proto.RegisterEnum("api.JobRunState", JobRunState_name, JobRunState_value) + proto.RegisterType((*JobRunDetails)(nil), "api.JobRunDetails") + proto.RegisterType((*JobDetails)(nil), "api.JobDetails") + proto.RegisterType((*JobDetailsRequest)(nil), "api.JobDetailsRequest") + proto.RegisterType((*JobDetailsResponse)(nil), "api.JobDetailsResponse") + proto.RegisterMapType((map[string]*JobDetails)(nil), "api.JobDetailsResponse.JobDetailsEntry") + proto.RegisterType((*JobRunDetailsResponse)(nil), "api.JobRunDetailsResponse") + proto.RegisterMapType((map[string]*JobRunDetails)(nil), "api.JobRunDetailsResponse.JobRunDetailsEntry") + proto.RegisterType((*JobRunDetailsRequest)(nil), "api.JobRunDetailsRequest") + proto.RegisterType((*JobStatusRequest)(nil), "api.JobStatusRequest") + proto.RegisterType((*JobStatusResponse)(nil), "api.JobStatusResponse") + proto.RegisterMapType((map[string]JobState)(nil), "api.JobStatusResponse.JobStatesEntry") +} + +func init() { proto.RegisterFile("pkg/api/job.proto", fileDescriptor_e45f6b75bfad87a4) } + +var fileDescriptor_e45f6b75bfad87a4 = []byte{ + // 1215 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xcd, 0x6e, 0xdb, 0x46, + 0x10, 0x36, 0x2d, 0xcb, 0x96, 0x46, 0x96, 0x4d, 0x6f, 0xec, 0x58, 0x51, 0x1a, 0xd1, 0x50, 0xd1, + 0xc6, 0x0d, 0x12, 0x09, 0x50, 0x51, 0x20, 0x48, 0x11, 0x34, 0xb6, 0xc5, 0x06, 0x72, 0x53, 0xd5, + 0xa0, 0xa4, 0xfe, 0xa1, 0x85, 0x40, 0x4a, 0x1b, 0x85, 0x8a, 0x44, 0x32, 0xdc, 0x65, 0x50, 0x03, + 0x3d, 0xf4, 0xd2, 0x43, 0x6f, 0x79, 0x89, 0xbe, 0x4b, 0x7b, 0x0b, 0x7a, 0xca, 0xa5, 0x6a, 0x6b, + 0x1f, 0x0a, 0xe8, 0xd4, 0x47, 0x28, 0xb8, 0x4b, 0x52, 0x4b, 0xca, 0x86, 0xdc, 0xde, 0xc4, 0x6f, + 0x66, 0x3e, 0xee, 0xcc, 0x7c, 0x33, 0x4b, 0xc1, 0x96, 0xf3, 0x7c, 0x50, 0xd5, 0x1d, 0xb3, 0x3a, + 0xb4, 0x8d, 0x8a, 0xe3, 0xda, 0xd4, 0x46, 0x29, 0xdd, 0x31, 0x8b, 0xf7, 0x06, 0x26, 0x7d, 0xe6, + 0x19, 0x95, 0x9e, 0x3d, 0xae, 0x0e, 0xec, 0x81, 0x5d, 0x65, 0x36, 0xc3, 0x7b, 0xca, 0x9e, 0xd8, + 0x03, 0xfb, 0xc5, 0x63, 0x8a, 0xdb, 0x21, 0x0d, 0xf1, 0x8c, 0xb1, 0x49, 0x03, 0x54, 0x19, 0xd8, + 0xf6, 0x60, 0x84, 0x67, 0xb1, 0xd4, 0x1c, 0x63, 0x42, 0xf5, 0xb1, 0xc3, 0x1d, 0xca, 0xbf, 0xaf, + 0x40, 0xfe, 0xd8, 0x36, 0x34, 0xcf, 0xaa, 0x63, 0xaa, 0x9b, 0x23, 0x82, 0xee, 0xc0, 0xaa, 0xeb, + 0x59, 0x5d, 0xb3, 0x5f, 0x90, 0xf6, 0xa4, 0xfd, 0xec, 0xe1, 0xb5, 0xe9, 0x44, 0xd9, 0x74, 0x3d, + 0xab, 0xd1, 0xbf, 0x6b, 0x8f, 0x4d, 0x8a, 0xc7, 0x0e, 0x3d, 0xd5, 0xd2, 0x0c, 0xf0, 0x7d, 0x87, + 0xb6, 0xe1, 0xfb, 0x2e, 0xcf, 0x7c, 0x87, 0xb6, 0x11, 0xf7, 0x65, 0x00, 0xfa, 0x10, 0xd2, 0x84, + 0xea, 0x14, 0x17, 0x52, 0x7b, 0xd2, 0xfe, 0x46, 0x4d, 0xae, 0xe8, 0x8e, 0x59, 0xe1, 0xaf, 0x6e, + 0xf9, 0x38, 0x0f, 0x66, 0x2e, 0x62, 0x30, 0x03, 0x50, 0x15, 0xd6, 0x7a, 0x23, 0x8f, 0x50, 0xec, + 0x16, 0x56, 0xd8, 0x9b, 0x76, 0xa6, 0x13, 0x65, 0x2b, 0x80, 0x04, 0xf7, 0xd0, 0x0b, 0xbd, 0x0b, + 0x2b, 0x96, 0xdd, 0xc7, 0x85, 0x34, 0xf3, 0x46, 0xd3, 0x89, 0xb2, 0xe1, 0x3f, 0x0b, 0xae, 0xcc, + 0x8e, 0x5a, 0x90, 0x1d, 0x61, 0x9d, 0xe0, 0x7e, 0x97, 0x92, 0xc2, 0xda, 0x9e, 0xb4, 0x9f, 0xab, + 0x15, 0x2b, 0xbc, 0x68, 0x95, 0xb0, 0x68, 0x95, 0x76, 0x58, 0xb4, 0xc3, 0xe2, 0x74, 0xa2, 0x20, + 0x1e, 0xd0, 0x26, 0x33, 0xb2, 0x57, 0x7f, 0x28, 0x92, 0x96, 0x09, 0x71, 0xf4, 0x39, 0x80, 0x83, + 0xad, 0xbe, 0x69, 0x0d, 0x7c, 0xd6, 0xcc, 0x42, 0xd6, 0x9b, 0xd3, 0x89, 0x72, 0x2d, 0x88, 0x98, + 0xa3, 0xcd, 0x46, 0x06, 0x9f, 0x97, 0x50, 0xdd, 0xa5, 0xfc, 0xb4, 0xd9, 0xab, 0xf1, 0x06, 0x11, + 0xf3, 0xbc, 0x91, 0x01, 0x7d, 0x05, 0xb9, 0xa7, 0xa6, 0x65, 0x92, 0x67, 0x9c, 0x18, 0x16, 0x12, + 0xbf, 0x35, 0x9d, 0x28, 0xdb, 0x61, 0xc8, 0x1c, 0x33, 0xcc, 0x2c, 0xe5, 0x9f, 0x57, 0x01, 0x8e, + 0x6d, 0x43, 0x10, 0x57, 0x20, 0x18, 0x69, 0xa1, 0x60, 0xde, 0x83, 0xf4, 0x0b, 0x0f, 0x7b, 0x58, + 0xd4, 0x16, 0x03, 0x44, 0x57, 0x06, 0xa0, 0xbb, 0x8c, 0x96, 0x60, 0xca, 0xc4, 0x95, 0x3d, 0xdc, + 0x9e, 0x4e, 0x14, 0x99, 0x23, 0x82, 0x73, 0xe0, 0x83, 0x3e, 0x80, 0xac, 0xa5, 0x8f, 0x31, 0x71, + 0xf4, 0x1e, 0x0e, 0xe4, 0xb4, 0xeb, 0x57, 0x2a, 0x02, 0x85, 0x98, 0x99, 0x27, 0xba, 0x1f, 0x0a, + 0x38, 0xcd, 0x04, 0x9c, 0x0f, 0x05, 0xbc, 0x58, 0xbd, 0xdf, 0xc0, 0x3a, 0x9f, 0xca, 0xa0, 0x73, + 0xab, 0x0b, 0x0b, 0x7c, 0x6b, 0x3a, 0x51, 0x76, 0xa2, 0x98, 0xb9, 0x0a, 0xe7, 0x04, 0x93, 0x2f, + 0xe1, 0x9e, 0x6e, 0xf5, 0xf0, 0xe8, 0x3f, 0x48, 0x98, 0x07, 0xcc, 0x4b, 0x38, 0xc4, 0xd1, 0x47, + 0x90, 0x0f, 0x48, 0x5d, 0xac, 0x13, 0xdb, 0x62, 0x2a, 0xce, 0xb2, 0xe0, 0xeb, 0xdc, 0xa0, 0x31, + 0x5c, 0x48, 0x76, 0x5d, 0xc4, 0xd1, 0x08, 0xd0, 0x48, 0x27, 0xb4, 0x4b, 0x5d, 0xdd, 0x22, 0x26, + 0x35, 0x6d, 0xeb, 0x6a, 0x9a, 0x2d, 0x4f, 0x27, 0x4a, 0xd1, 0x8f, 0x6c, 0x47, 0x81, 0x73, 0xc7, + 0x94, 0x93, 0x76, 0xf4, 0x10, 0xf2, 0x23, 0x9d, 0x62, 0x42, 0xbb, 0xc1, 0xee, 0x02, 0x76, 0xdc, + 0x1b, 0x7e, 0x19, 0xb9, 0x41, 0x4b, 0x6c, 0xb0, 0x9c, 0x00, 0xa3, 0x07, 0x90, 0xf1, 0x65, 0x49, + 0x1c, 0xdc, 0x2b, 0xe4, 0xd8, 0x11, 0x33, 0x61, 0x77, 0xf9, 0xa6, 0x19, 0xda, 0x46, 0xcb, 0xc1, + 0x3d, 0x71, 0xd3, 0x04, 0x10, 0xaa, 0xf3, 0x58, 0xd7, 0xb3, 0x48, 0x61, 0x7d, 0x2f, 0xb5, 0x9f, + 0xab, 0x21, 0x61, 0xb5, 0x05, 0xc2, 0x8f, 0x58, 0x34, 0xcf, 0x22, 0x09, 0x16, 0x1f, 0x2a, 0xff, + 0x2a, 0xc1, 0xd6, 0x6c, 0x4e, 0x34, 0xfc, 0xc2, 0xc3, 0x84, 0xa2, 0x7b, 0xb0, 0xc6, 0xc7, 0x85, + 0x14, 0xa4, 0xbd, 0x94, 0x20, 0xec, 0x46, 0x9f, 0x24, 0x84, 0xdd, 0xe8, 0x13, 0x74, 0x04, 0x9b, + 0xf8, 0x3b, 0x47, 0xb7, 0xfa, 0xdd, 0x28, 0x1b, 0x7f, 0x76, 0x32, 0x6c, 0x11, 0xec, 0x72, 0xd3, + 0xf1, 0x5c, 0x26, 0xf9, 0x98, 0x01, 0x3d, 0x82, 0x0d, 0x81, 0xc4, 0xf5, 0x2c, 0x36, 0x53, 0x19, + 0xde, 0xfa, 0xc8, 0x55, 0xf3, 0x62, 0xad, 0x17, 0xf1, 0xf2, 0x3f, 0x12, 0x20, 0x31, 0x17, 0xe2, + 0xd8, 0x16, 0xc1, 0xc8, 0x80, 0x9c, 0xcf, 0xd8, 0xe7, 0x30, 0x4b, 0x28, 0x57, 0xbb, 0x1d, 0xd6, + 0x2a, 0xe1, 0x2d, 0x40, 0xaa, 0x45, 0xdd, 0xd3, 0xc3, 0x82, 0xbf, 0x72, 0x86, 0x11, 0x28, 0xbc, + 0x1c, 0x66, 0x68, 0xf1, 0x25, 0x6c, 0x26, 0x02, 0xd1, 0xdb, 0x90, 0x7a, 0x8e, 0x4f, 0x83, 0x7d, + 0xb3, 0x35, 0x9d, 0x28, 0xf9, 0xe7, 0xf8, 0x54, 0x08, 0xf7, 0xad, 0xe8, 0x01, 0xa4, 0x5f, 0xea, + 0xa3, 0x60, 0xd7, 0xe4, 0x6a, 0x9b, 0x89, 0x53, 0xf1, 0xe9, 0x66, 0x1e, 0xe2, 0x74, 0x33, 0xe0, + 0xc1, 0xf2, 0x7d, 0xa9, 0xfc, 0xd3, 0x32, 0xec, 0xc4, 0x1a, 0x1e, 0x65, 0xed, 0xc2, 0x66, 0x50, + 0xc7, 0x44, 0xe6, 0xf7, 0xe6, 0x55, 0x22, 0x26, 0x3f, 0x43, 0x79, 0xfe, 0xac, 0x85, 0x43, 0x11, + 0x17, 0x5b, 0x18, 0x33, 0x14, 0xbf, 0x67, 0xf5, 0x4f, 0x30, 0x5c, 0xad, 0x10, 0x0f, 0xe3, 0x85, + 0xb8, 0x48, 0xca, 0x8b, 0x6a, 0xa1, 0xc2, 0x76, 0x22, 0xab, 0x48, 0xcc, 0x7c, 0x38, 0x63, 0x62, + 0x66, 0x1f, 0x12, 0x31, 0x31, 0x73, 0xa4, 0x7c, 0x00, 0x72, 0xb0, 0x5c, 0xbd, 0xff, 0x39, 0x0f, + 0xe5, 0xbf, 0xf9, 0x50, 0x85, 0x1c, 0x41, 0x47, 0xbe, 0x05, 0x60, 0xe3, 0xe1, 0xaf, 0xe6, 0xb0, + 0x19, 0xef, 0x88, 0xcb, 0xdc, 0x8b, 0x35, 0x82, 0xad, 0xf7, 0xa0, 0x09, 0xec, 0x9a, 0x18, 0x86, + 0x98, 0x78, 0x4d, 0x44, 0x60, 0x91, 0xc0, 0x46, 0x3c, 0xea, 0x6a, 0x85, 0xbf, 0x2f, 0x16, 0xfe, + 0xe2, 0xdb, 0xe5, 0xf2, 0x9a, 0xdf, 0xf9, 0x71, 0x19, 0x72, 0xc2, 0xb7, 0x14, 0xda, 0x81, 0x2d, + 0xad, 0xd3, 0xec, 0xb6, 0xda, 0x07, 0x6d, 0xb5, 0xdb, 0x69, 0x7e, 0xd2, 0xfc, 0xec, 0x8b, 0xa6, + 0xbc, 0x84, 0xb6, 0x41, 0x9e, 0xc1, 0x4f, 0xd4, 0x83, 0x96, 0x5a, 0x97, 0xa5, 0xb8, 0xf3, 0x89, + 0xda, 0xac, 0x37, 0x9a, 0x8f, 0xe5, 0xe5, 0x38, 0xac, 0x75, 0x9a, 0x4d, 0x1f, 0x4e, 0xa1, 0x5d, + 0xb8, 0x36, 0x83, 0x5b, 0x9d, 0xa3, 0x23, 0x55, 0xad, 0xab, 0x75, 0x79, 0x25, 0x4e, 0xfe, 0xf1, + 0x41, 0xe3, 0x89, 0x5a, 0x97, 0xd3, 0x71, 0xf7, 0x13, 0x4d, 0x55, 0x3f, 0x3d, 0x69, 0xab, 0x75, + 0x79, 0x35, 0x6e, 0x38, 0x3a, 0x68, 0x1e, 0xa9, 0x4f, 0xfc, 0x88, 0x35, 0x74, 0x13, 0x76, 0x13, + 0x87, 0xec, 0xaa, 0x5f, 0x9e, 0x34, 0x34, 0xb5, 0x2e, 0x67, 0xd0, 0x2d, 0xb8, 0xa1, 0x75, 0x9a, + 0xad, 0x98, 0x55, 0x53, 0xdb, 0x1d, 0xad, 0xa9, 0xd6, 0xe5, 0x6c, 0xed, 0x37, 0x09, 0x56, 0x8e, + 0x6d, 0xc3, 0xbf, 0x10, 0xd6, 0x1f, 0x63, 0x1a, 0x35, 0x14, 0xed, 0x24, 0x1b, 0xcc, 0x04, 0x55, + 0xbc, 0x7e, 0x71, 0xdf, 0xd1, 0x23, 0xc8, 0xf3, 0xf0, 0xf0, 0xc3, 0xe5, 0xfa, 0xdc, 0x9e, 0xe2, + 0x04, 0xbb, 0x97, 0xec, 0x2f, 0xd4, 0x00, 0x99, 0x33, 0x08, 0x9f, 0xd6, 0x37, 0x2e, 0x1a, 0x79, + 0xce, 0x53, 0xbc, 0x7c, 0x1b, 0x1c, 0x36, 0xde, 0xfc, 0x55, 0x5a, 0xfa, 0xe1, 0xac, 0x24, 0xfd, + 0x72, 0x56, 0x92, 0x5e, 0x9f, 0x95, 0xa4, 0x3f, 0xcf, 0x4a, 0xd2, 0xab, 0xf3, 0xd2, 0xd2, 0xeb, + 0xf3, 0xd2, 0xd2, 0x9b, 0xf3, 0xd2, 0xd2, 0xd7, 0xb7, 0x85, 0xff, 0x0a, 0xba, 0x3b, 0xd6, 0xfb, + 0xba, 0xe3, 0xda, 0x43, 0xdc, 0xa3, 0xc1, 0x53, 0x35, 0xf8, 0x73, 0x60, 0xac, 0xb2, 0x1b, 0xf7, + 0xfd, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xea, 0xf3, 0xe5, 0xaf, 0x75, 0x0c, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// JobsClient is the client API for Jobs service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type JobsClient interface { + GetJobStatus(ctx context.Context, in *JobStatusRequest, opts ...grpc.CallOption) (*JobStatusResponse, error) + GetJobDetails(ctx context.Context, in *JobDetailsRequest, opts ...grpc.CallOption) (*JobDetailsResponse, error) + GetJobRunDetails(ctx context.Context, in *JobRunDetailsRequest, opts ...grpc.CallOption) (*JobRunDetailsResponse, error) +} + +type jobsClient struct { + cc *grpc.ClientConn +} + +func NewJobsClient(cc *grpc.ClientConn) JobsClient { + return &jobsClient{cc} +} + +func (c *jobsClient) GetJobStatus(ctx context.Context, in *JobStatusRequest, opts ...grpc.CallOption) (*JobStatusResponse, error) { + out := new(JobStatusResponse) + err := c.cc.Invoke(ctx, "/api.Jobs/GetJobStatus", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *jobsClient) GetJobDetails(ctx context.Context, in *JobDetailsRequest, opts ...grpc.CallOption) (*JobDetailsResponse, error) { + out := new(JobDetailsResponse) + err := c.cc.Invoke(ctx, "/api.Jobs/GetJobDetails", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *jobsClient) GetJobRunDetails(ctx context.Context, in *JobRunDetailsRequest, opts ...grpc.CallOption) (*JobRunDetailsResponse, error) { + out := new(JobRunDetailsResponse) + err := c.cc.Invoke(ctx, "/api.Jobs/GetJobRunDetails", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// JobsServer is the server API for Jobs service. +type JobsServer interface { + GetJobStatus(context.Context, *JobStatusRequest) (*JobStatusResponse, error) + GetJobDetails(context.Context, *JobDetailsRequest) (*JobDetailsResponse, error) + GetJobRunDetails(context.Context, *JobRunDetailsRequest) (*JobRunDetailsResponse, error) +} + +// UnimplementedJobsServer can be embedded to have forward compatible implementations. +type UnimplementedJobsServer struct { +} + +func (*UnimplementedJobsServer) GetJobStatus(ctx context.Context, req *JobStatusRequest) (*JobStatusResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetJobStatus not implemented") +} +func (*UnimplementedJobsServer) GetJobDetails(ctx context.Context, req *JobDetailsRequest) (*JobDetailsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetJobDetails not implemented") +} +func (*UnimplementedJobsServer) GetJobRunDetails(ctx context.Context, req *JobRunDetailsRequest) (*JobRunDetailsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetJobRunDetails not implemented") +} + +func RegisterJobsServer(s *grpc.Server, srv JobsServer) { + s.RegisterService(&_Jobs_serviceDesc, srv) +} + +func _Jobs_GetJobStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(JobStatusRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(JobsServer).GetJobStatus(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/api.Jobs/GetJobStatus", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(JobsServer).GetJobStatus(ctx, req.(*JobStatusRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Jobs_GetJobDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(JobDetailsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(JobsServer).GetJobDetails(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/api.Jobs/GetJobDetails", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(JobsServer).GetJobDetails(ctx, req.(*JobDetailsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Jobs_GetJobRunDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(JobRunDetailsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(JobsServer).GetJobRunDetails(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/api.Jobs/GetJobRunDetails", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(JobsServer).GetJobRunDetails(ctx, req.(*JobRunDetailsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Jobs_serviceDesc = grpc.ServiceDesc{ + ServiceName: "api.Jobs", + HandlerType: (*JobsServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "GetJobStatus", + Handler: _Jobs_GetJobStatus_Handler, + }, + { + MethodName: "GetJobDetails", + Handler: _Jobs_GetJobDetails_Handler, + }, + { + MethodName: "GetJobRunDetails", + Handler: _Jobs_GetJobRunDetails_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "pkg/api/job.proto", +} + +func (m *JobRunDetails) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *JobRunDetails) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *JobRunDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.FinishedTs != nil { + n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.FinishedTs, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.FinishedTs):]) + if err1 != nil { + return 0, err1 + } + i -= n1 + i = encodeVarintJob(dAtA, i, uint64(n1)) + i-- + dAtA[i] = 0x52 + } + if m.StartedTs != nil { + n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.StartedTs, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.StartedTs):]) + if err2 != nil { + return 0, err2 + } + i -= n2 + i = encodeVarintJob(dAtA, i, uint64(n2)) + i-- + dAtA[i] = 0x4a + } + if m.PendingTs != nil { + n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.PendingTs, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.PendingTs):]) + if err3 != nil { + return 0, err3 + } + i -= n3 + i = encodeVarintJob(dAtA, i, uint64(n3)) + i-- + dAtA[i] = 0x42 + } + if m.LeasedTs != nil { + n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.LeasedTs, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.LeasedTs):]) + if err4 != nil { + return 0, err4 + } + i -= n4 + i = encodeVarintJob(dAtA, i, uint64(n4)) + i-- + dAtA[i] = 0x3a + } + if len(m.Node) > 0 { + i -= len(m.Node) + copy(dAtA[i:], m.Node) + i = encodeVarintJob(dAtA, i, uint64(len(m.Node))) + i-- + dAtA[i] = 0x2a + } + if len(m.Cluster) > 0 { + i -= len(m.Cluster) + copy(dAtA[i:], m.Cluster) + i = encodeVarintJob(dAtA, i, uint64(len(m.Cluster))) + i-- + dAtA[i] = 0x22 + } + if m.State != 0 { + i = encodeVarintJob(dAtA, i, uint64(m.State)) + i-- + dAtA[i] = 0x18 + } + if len(m.JobId) > 0 { + i -= len(m.JobId) + copy(dAtA[i:], m.JobId) + i = encodeVarintJob(dAtA, i, uint64(len(m.JobId))) + i-- + dAtA[i] = 0x12 + } + if len(m.RunId) > 0 { + i -= len(m.RunId) + copy(dAtA[i:], m.RunId) + i = encodeVarintJob(dAtA, i, uint64(len(m.RunId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *JobDetails) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *JobDetails) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *JobDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.JobRuns) > 0 { + for iNdEx := len(m.JobRuns) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.JobRuns[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintJob(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x62 + } + } + if m.JobSpec != nil { + { + size, err := m.JobSpec.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintJob(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x5a + } + if len(m.LatestRunId) > 0 { + i -= len(m.LatestRunId) + copy(dAtA[i:], m.LatestRunId) + i = encodeVarintJob(dAtA, i, uint64(len(m.LatestRunId))) + i-- + dAtA[i] = 0x52 + } + if m.LastTransitionTs != nil { + n6, err6 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.LastTransitionTs, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.LastTransitionTs):]) + if err6 != nil { + return 0, err6 + } + i -= n6 + i = encodeVarintJob(dAtA, i, uint64(n6)) + i-- + dAtA[i] = 0x4a + } + if len(m.CancelReason) > 0 { + i -= len(m.CancelReason) + copy(dAtA[i:], m.CancelReason) + i = encodeVarintJob(dAtA, i, uint64(len(m.CancelReason))) + i-- + dAtA[i] = 0x42 + } + if m.CancelTs != nil { + n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.CancelTs, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.CancelTs):]) + if err7 != nil { + return 0, err7 + } + i -= n7 + i = encodeVarintJob(dAtA, i, uint64(n7)) + i-- + dAtA[i] = 0x3a + } + if m.SubmittedTs != nil { + n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.SubmittedTs, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.SubmittedTs):]) + if err8 != nil { + return 0, err8 + } + i -= n8 + i = encodeVarintJob(dAtA, i, uint64(n8)) + i-- + dAtA[i] = 0x32 + } + if m.State != 0 { + i = encodeVarintJob(dAtA, i, uint64(m.State)) + i-- + dAtA[i] = 0x28 + } + if len(m.Namespace) > 0 { + i -= len(m.Namespace) + copy(dAtA[i:], m.Namespace) + i = encodeVarintJob(dAtA, i, uint64(len(m.Namespace))) + i-- + dAtA[i] = 0x22 + } + if len(m.Jobset) > 0 { + i -= len(m.Jobset) + copy(dAtA[i:], m.Jobset) + i = encodeVarintJob(dAtA, i, uint64(len(m.Jobset))) + i-- + dAtA[i] = 0x1a + } + if len(m.Queue) > 0 { + i -= len(m.Queue) + copy(dAtA[i:], m.Queue) + i = encodeVarintJob(dAtA, i, uint64(len(m.Queue))) + i-- + dAtA[i] = 0x12 + } + if len(m.JobId) > 0 { + i -= len(m.JobId) + copy(dAtA[i:], m.JobId) + i = encodeVarintJob(dAtA, i, uint64(len(m.JobId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *JobDetailsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *JobDetailsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *JobDetailsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ExpandJobRun { + i-- + if m.ExpandJobRun { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if m.ExpandJobSpec { + i-- + if m.ExpandJobSpec { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if len(m.JobIds) > 0 { + for iNdEx := len(m.JobIds) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.JobIds[iNdEx]) + copy(dAtA[i:], m.JobIds[iNdEx]) + i = encodeVarintJob(dAtA, i, uint64(len(m.JobIds[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *JobDetailsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *JobDetailsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *JobDetailsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.JobDetails) > 0 { + for k := range m.JobDetails { + v := m.JobDetails[k] + baseI := i + if v != nil { + { + size, err := v.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintJob(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i -= len(k) + copy(dAtA[i:], k) + i = encodeVarintJob(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = encodeVarintJob(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *JobRunDetailsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *JobRunDetailsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *JobRunDetailsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.JobRunDetails) > 0 { + for k := range m.JobRunDetails { + v := m.JobRunDetails[k] + baseI := i + if v != nil { + { + size, err := v.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintJob(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i -= len(k) + copy(dAtA[i:], k) + i = encodeVarintJob(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = encodeVarintJob(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *JobRunDetailsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *JobRunDetailsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *JobRunDetailsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.RunIds) > 0 { + for iNdEx := len(m.RunIds) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.RunIds[iNdEx]) + copy(dAtA[i:], m.RunIds[iNdEx]) + i = encodeVarintJob(dAtA, i, uint64(len(m.RunIds[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *JobStatusRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *JobStatusRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *JobStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.JobIds) > 0 { + for iNdEx := len(m.JobIds) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.JobIds[iNdEx]) + copy(dAtA[i:], m.JobIds[iNdEx]) + i = encodeVarintJob(dAtA, i, uint64(len(m.JobIds[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *JobStatusResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *JobStatusResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *JobStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.JobStates) > 0 { + for k := range m.JobStates { + v := m.JobStates[k] + baseI := i + i = encodeVarintJob(dAtA, i, uint64(v)) + i-- + dAtA[i] = 0x10 + i -= len(k) + copy(dAtA[i:], k) + i = encodeVarintJob(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = encodeVarintJob(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func encodeVarintJob(dAtA []byte, offset int, v uint64) int { + offset -= sovJob(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *JobRunDetails) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.RunId) + if l > 0 { + n += 1 + l + sovJob(uint64(l)) + } + l = len(m.JobId) + if l > 0 { + n += 1 + l + sovJob(uint64(l)) + } + if m.State != 0 { + n += 1 + sovJob(uint64(m.State)) + } + l = len(m.Cluster) + if l > 0 { + n += 1 + l + sovJob(uint64(l)) + } + l = len(m.Node) + if l > 0 { + n += 1 + l + sovJob(uint64(l)) + } + if m.LeasedTs != nil { + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.LeasedTs) + n += 1 + l + sovJob(uint64(l)) + } + if m.PendingTs != nil { + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.PendingTs) + n += 1 + l + sovJob(uint64(l)) + } + if m.StartedTs != nil { + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.StartedTs) + n += 1 + l + sovJob(uint64(l)) + } + if m.FinishedTs != nil { + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.FinishedTs) + n += 1 + l + sovJob(uint64(l)) + } + return n +} + +func (m *JobDetails) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.JobId) + if l > 0 { + n += 1 + l + sovJob(uint64(l)) + } + l = len(m.Queue) + if l > 0 { + n += 1 + l + sovJob(uint64(l)) + } + l = len(m.Jobset) + if l > 0 { + n += 1 + l + sovJob(uint64(l)) + } + l = len(m.Namespace) + if l > 0 { + n += 1 + l + sovJob(uint64(l)) + } + if m.State != 0 { + n += 1 + sovJob(uint64(m.State)) + } + if m.SubmittedTs != nil { + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.SubmittedTs) + n += 1 + l + sovJob(uint64(l)) + } + if m.CancelTs != nil { + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.CancelTs) + n += 1 + l + sovJob(uint64(l)) + } + l = len(m.CancelReason) + if l > 0 { + n += 1 + l + sovJob(uint64(l)) + } + if m.LastTransitionTs != nil { + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.LastTransitionTs) + n += 1 + l + sovJob(uint64(l)) + } + l = len(m.LatestRunId) + if l > 0 { + n += 1 + l + sovJob(uint64(l)) + } + if m.JobSpec != nil { + l = m.JobSpec.Size() + n += 1 + l + sovJob(uint64(l)) + } + if len(m.JobRuns) > 0 { + for _, e := range m.JobRuns { + l = e.Size() + n += 1 + l + sovJob(uint64(l)) + } + } + return n +} + +func (m *JobDetailsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.JobIds) > 0 { + for _, s := range m.JobIds { + l = len(s) + n += 1 + l + sovJob(uint64(l)) + } + } + if m.ExpandJobSpec { + n += 2 + } + if m.ExpandJobRun { + n += 2 + } + return n +} + +func (m *JobDetailsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.JobDetails) > 0 { + for k, v := range m.JobDetails { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + l += 1 + sovJob(uint64(l)) + } + mapEntrySize := 1 + len(k) + sovJob(uint64(len(k))) + l + n += mapEntrySize + 1 + sovJob(uint64(mapEntrySize)) + } + } + return n +} + +func (m *JobRunDetailsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.JobRunDetails) > 0 { + for k, v := range m.JobRunDetails { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + l += 1 + sovJob(uint64(l)) + } + mapEntrySize := 1 + len(k) + sovJob(uint64(len(k))) + l + n += mapEntrySize + 1 + sovJob(uint64(mapEntrySize)) + } + } + return n +} + +func (m *JobRunDetailsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.RunIds) > 0 { + for _, s := range m.RunIds { + l = len(s) + n += 1 + l + sovJob(uint64(l)) + } + } + return n +} + +func (m *JobStatusRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.JobIds) > 0 { + for _, s := range m.JobIds { + l = len(s) + n += 1 + l + sovJob(uint64(l)) + } + } + return n +} + +func (m *JobStatusResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.JobStates) > 0 { + for k, v := range m.JobStates { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovJob(uint64(len(k))) + 1 + sovJob(uint64(v)) + n += mapEntrySize + 1 + sovJob(uint64(mapEntrySize)) + } + } + return n +} + +func sovJob(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozJob(x uint64) (n int) { + return sovJob(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *JobRunDetails) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&JobRunDetails{`, + `RunId:` + fmt.Sprintf("%v", this.RunId) + `,`, + `JobId:` + fmt.Sprintf("%v", this.JobId) + `,`, + `State:` + fmt.Sprintf("%v", this.State) + `,`, + `Cluster:` + fmt.Sprintf("%v", this.Cluster) + `,`, + `Node:` + fmt.Sprintf("%v", this.Node) + `,`, + `LeasedTs:` + strings.Replace(fmt.Sprintf("%v", this.LeasedTs), "Timestamp", "types.Timestamp", 1) + `,`, + `PendingTs:` + strings.Replace(fmt.Sprintf("%v", this.PendingTs), "Timestamp", "types.Timestamp", 1) + `,`, + `StartedTs:` + strings.Replace(fmt.Sprintf("%v", this.StartedTs), "Timestamp", "types.Timestamp", 1) + `,`, + `FinishedTs:` + strings.Replace(fmt.Sprintf("%v", this.FinishedTs), "Timestamp", "types.Timestamp", 1) + `,`, + `}`, + }, "") + return s +} +func (this *JobDetails) String() string { + if this == nil { + return "nil" + } + repeatedStringForJobRuns := "[]*JobRunDetails{" + for _, f := range this.JobRuns { + repeatedStringForJobRuns += strings.Replace(f.String(), "JobRunDetails", "JobRunDetails", 1) + "," + } + repeatedStringForJobRuns += "}" + s := strings.Join([]string{`&JobDetails{`, + `JobId:` + fmt.Sprintf("%v", this.JobId) + `,`, + `Queue:` + fmt.Sprintf("%v", this.Queue) + `,`, + `Jobset:` + fmt.Sprintf("%v", this.Jobset) + `,`, + `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`, + `State:` + fmt.Sprintf("%v", this.State) + `,`, + `SubmittedTs:` + strings.Replace(fmt.Sprintf("%v", this.SubmittedTs), "Timestamp", "types.Timestamp", 1) + `,`, + `CancelTs:` + strings.Replace(fmt.Sprintf("%v", this.CancelTs), "Timestamp", "types.Timestamp", 1) + `,`, + `CancelReason:` + fmt.Sprintf("%v", this.CancelReason) + `,`, + `LastTransitionTs:` + strings.Replace(fmt.Sprintf("%v", this.LastTransitionTs), "Timestamp", "types.Timestamp", 1) + `,`, + `LatestRunId:` + fmt.Sprintf("%v", this.LatestRunId) + `,`, + `JobSpec:` + strings.Replace(fmt.Sprintf("%v", this.JobSpec), "Job", "Job", 1) + `,`, + `JobRuns:` + repeatedStringForJobRuns + `,`, + `}`, + }, "") + return s +} +func (this *JobDetailsRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&JobDetailsRequest{`, + `JobIds:` + fmt.Sprintf("%v", this.JobIds) + `,`, + `ExpandJobSpec:` + fmt.Sprintf("%v", this.ExpandJobSpec) + `,`, + `ExpandJobRun:` + fmt.Sprintf("%v", this.ExpandJobRun) + `,`, + `}`, + }, "") + return s +} +func (this *JobDetailsResponse) String() string { + if this == nil { + return "nil" + } + keysForJobDetails := make([]string, 0, len(this.JobDetails)) + for k, _ := range this.JobDetails { + keysForJobDetails = append(keysForJobDetails, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForJobDetails) + mapStringForJobDetails := "map[string]*JobDetails{" + for _, k := range keysForJobDetails { + mapStringForJobDetails += fmt.Sprintf("%v: %v,", k, this.JobDetails[k]) + } + mapStringForJobDetails += "}" + s := strings.Join([]string{`&JobDetailsResponse{`, + `JobDetails:` + mapStringForJobDetails + `,`, + `}`, + }, "") + return s +} +func (this *JobRunDetailsResponse) String() string { + if this == nil { + return "nil" + } + keysForJobRunDetails := make([]string, 0, len(this.JobRunDetails)) + for k, _ := range this.JobRunDetails { + keysForJobRunDetails = append(keysForJobRunDetails, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForJobRunDetails) + mapStringForJobRunDetails := "map[string]*JobRunDetails{" + for _, k := range keysForJobRunDetails { + mapStringForJobRunDetails += fmt.Sprintf("%v: %v,", k, this.JobRunDetails[k]) + } + mapStringForJobRunDetails += "}" + s := strings.Join([]string{`&JobRunDetailsResponse{`, + `JobRunDetails:` + mapStringForJobRunDetails + `,`, + `}`, + }, "") + return s +} +func (this *JobRunDetailsRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&JobRunDetailsRequest{`, + `RunIds:` + fmt.Sprintf("%v", this.RunIds) + `,`, + `}`, + }, "") + return s +} +func (this *JobStatusRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&JobStatusRequest{`, + `JobIds:` + fmt.Sprintf("%v", this.JobIds) + `,`, + `}`, + }, "") + return s +} +func (this *JobStatusResponse) String() string { + if this == nil { + return "nil" + } + keysForJobStates := make([]string, 0, len(this.JobStates)) + for k, _ := range this.JobStates { + keysForJobStates = append(keysForJobStates, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForJobStates) + mapStringForJobStates := "map[string]JobState{" + for _, k := range keysForJobStates { + mapStringForJobStates += fmt.Sprintf("%v: %v,", k, this.JobStates[k]) + } + mapStringForJobStates += "}" + s := strings.Join([]string{`&JobStatusResponse{`, + `JobStates:` + mapStringForJobStates + `,`, + `}`, + }, "") + return s +} +func valueToStringJob(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *JobRunDetails) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: JobRunDetails: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JobRunDetails: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RunId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RunId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JobId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.JobId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + m.State = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.State |= JobRunState(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Cluster = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Node = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LeasedTs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LeasedTs == nil { + m.LeasedTs = new(time.Time) + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.LeasedTs, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PendingTs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PendingTs == nil { + m.PendingTs = new(time.Time) + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.PendingTs, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartedTs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StartedTs == nil { + m.StartedTs = new(time.Time) + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.StartedTs, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FinishedTs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FinishedTs == nil { + m.FinishedTs = new(time.Time) + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.FinishedTs, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipJob(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthJob + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *JobDetails) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: JobDetails: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JobDetails: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JobId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.JobId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Queue", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Queue = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Jobset", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Jobset = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Namespace = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + m.State = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.State |= JobState(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubmittedTs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SubmittedTs == nil { + m.SubmittedTs = new(time.Time) + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.SubmittedTs, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CancelTs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CancelTs == nil { + m.CancelTs = new(time.Time) + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.CancelTs, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CancelReason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CancelReason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LastTransitionTs == nil { + m.LastTransitionTs = new(time.Time) + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.LastTransitionTs, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LatestRunId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LatestRunId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JobSpec", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.JobSpec == nil { + m.JobSpec = &Job{} + } + if err := m.JobSpec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JobRuns", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.JobRuns = append(m.JobRuns, &JobRunDetails{}) + if err := m.JobRuns[len(m.JobRuns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipJob(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthJob + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *JobDetailsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: JobDetailsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JobDetailsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JobIds", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.JobIds = append(m.JobIds, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ExpandJobSpec", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ExpandJobSpec = bool(v != 0) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ExpandJobRun", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ExpandJobRun = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipJob(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthJob + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *JobDetailsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: JobDetailsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JobDetailsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JobDetails", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.JobDetails == nil { + m.JobDetails = make(map[string]*JobDetails) + } + var mapkey string + var mapvalue *JobDetails + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthJob + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthJob + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthJob + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthJob + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &JobDetails{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipJob(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthJob + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.JobDetails[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipJob(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthJob + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *JobRunDetailsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: JobRunDetailsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JobRunDetailsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JobRunDetails", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.JobRunDetails == nil { + m.JobRunDetails = make(map[string]*JobRunDetails) + } + var mapkey string + var mapvalue *JobRunDetails + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthJob + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthJob + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthJob + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthJob + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &JobRunDetails{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipJob(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthJob + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.JobRunDetails[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipJob(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthJob + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *JobRunDetailsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: JobRunDetailsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JobRunDetailsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RunIds", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RunIds = append(m.RunIds, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipJob(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthJob + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *JobStatusRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: JobStatusRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JobStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JobIds", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.JobIds = append(m.JobIds, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipJob(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthJob + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *JobStatusResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: JobStatusResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JobStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JobStates", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthJob + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthJob + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.JobStates == nil { + m.JobStates = make(map[string]JobState) + } + var mapkey string + var mapvalue JobState + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthJob + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthJob + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowJob + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapvalue |= JobState(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else { + iNdEx = entryPreIndex + skippy, err := skipJob(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthJob + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.JobStates[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipJob(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthJob + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipJob(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowJob + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowJob + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowJob + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthJob + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupJob + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthJob + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthJob = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowJob = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupJob = fmt.Errorf("proto: unexpected end of group") +) diff --git a/pkg/api/job.proto b/pkg/api/job.proto new file mode 100644 index 00000000000..be1063412a6 --- /dev/null +++ b/pkg/api/job.proto @@ -0,0 +1,83 @@ +syntax = 'proto3'; +package api; +option go_package = "github.com/armadaproject/armada/pkg/api"; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; +import "pkg/api/submit.proto"; +import "google/protobuf/timestamp.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.stringer_all) = true; + +enum JobRunState { + RUN_STATE_UNKNOWN = 0; + RUN_STATE_LEASED = 1; + RUN_STATE_PENDING = 2; + RUN_STATE_RUNNING = 3; + RUN_STATE_SUCCEEDED = 4; + RUN_STATE_FAILED = 5; + RUN_STATE_PREEMPTED = 6; + RUN_STATE_CANCELLED = 7; + RUN_STATE_LEASE_EXPIRED = 8; + RUNS_STATE_LEASE_RETURNED = 9; +} + +message JobRunDetails { + string run_id = 1; + string job_id = 2; + JobRunState state = 3; + string cluster = 4; + string node = 5; + google.protobuf.Timestamp leased_ts = 7 [(gogoproto.stdtime) = true]; + google.protobuf.Timestamp pending_ts = 8 [(gogoproto.stdtime) = true]; + google.protobuf.Timestamp started_ts = 9 [(gogoproto.stdtime) = true]; + google.protobuf.Timestamp finished_ts = 10 [(gogoproto.stdtime) = true]; +} + + +message JobDetails { + string job_id = 1; + string queue = 2; + string jobset = 3; + string namespace = 4; + JobState state = 5; + google.protobuf.Timestamp submitted_ts = 6 [(gogoproto.stdtime) = true]; + google.protobuf.Timestamp cancel_ts = 7 [(gogoproto.stdtime) = true]; + string cancel_reason = 8; + google.protobuf.Timestamp last_transition_ts = 9 [(gogoproto.stdtime) = true]; + string latest_run_id = 10; + Job job_spec = 11; // Only filled in if expand_job_spec is true + repeated JobRunDetails job_runs = 12; // Only filled in if expand_job_run is true; +} + +message JobDetailsRequest { + repeated string job_ids = 1; + bool expand_job_spec = 2; + bool expand_job_run = 3; +} + +message JobDetailsResponse { + map job_details = 1; +} + +message JobRunDetailsResponse { + map job_run_details = 1; +} + +message JobRunDetailsRequest { + repeated string run_ids = 1; +} + +message JobStatusRequest{ + repeated string job_ids = 1; +} + +message JobStatusResponse{ + map job_states = 1; +} + +service Jobs { + rpc GetJobStatus (JobStatusRequest) returns (JobStatusResponse); + rpc GetJobDetails (JobDetailsRequest) returns (JobDetailsResponse); + rpc GetJobRunDetails (JobRunDetailsRequest) returns (JobRunDetailsResponse); +} diff --git a/pkg/api/queryapi.pb.go b/pkg/api/queryapi.pb.go deleted file mode 100644 index a5351c629e6..00000000000 --- a/pkg/api/queryapi.pb.go +++ /dev/null @@ -1,700 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: pkg/api/queryapi.proto - -package api - -import ( - context "context" - fmt "fmt" - io "io" - math "math" - math_bits "math/bits" - reflect "reflect" - strings "strings" - - _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" - grpc "google.golang.org/grpc" - codes "google.golang.org/grpc/codes" - status "google.golang.org/grpc/status" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package - -type JobStatus int32 - -const ( - JobStatus_UNKNOWN JobStatus = 0 - JobStatus_SUBMITTED JobStatus = 1 - JobStatus_QUEUED JobStatus = 2 - JobStatus_LEASED JobStatus = 3 - JobStatus_PENDING JobStatus = 4 - JobStatus_RUNNING JobStatus = 5 - JobStatus_SUCCEEDED JobStatus = 6 - JobStatus_FAILED JobStatus = 7 - JobStatus_PREEMPTED JobStatus = 8 - JobStatus_CANCELLED JobStatus = 9 -) - -var JobStatus_name = map[int32]string{ - 0: "UNKNOWN", - 1: "SUBMITTED", - 2: "QUEUED", - 3: "LEASED", - 4: "PENDING", - 5: "RUNNING", - 6: "SUCCEEDED", - 7: "FAILED", - 8: "PREEMPTED", - 9: "CANCELLED", -} - -var JobStatus_value = map[string]int32{ - "UNKNOWN": 0, - "SUBMITTED": 1, - "QUEUED": 2, - "LEASED": 3, - "PENDING": 4, - "RUNNING": 5, - "SUCCEEDED": 6, - "FAILED": 7, - "PREEMPTED": 8, - "CANCELLED": 9, -} - -func (x JobStatus) String() string { - return proto.EnumName(JobStatus_name, int32(x)) -} - -func (JobStatus) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_4ef0e77b55b97342, []int{0} -} - -type JobStatusRequest struct { - JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"jobId,omitempty"` -} - -func (m *JobStatusRequest) Reset() { *m = JobStatusRequest{} } -func (*JobStatusRequest) ProtoMessage() {} -func (*JobStatusRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_4ef0e77b55b97342, []int{0} -} -func (m *JobStatusRequest) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *JobStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_JobStatusRequest.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *JobStatusRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_JobStatusRequest.Merge(m, src) -} -func (m *JobStatusRequest) XXX_Size() int { - return m.Size() -} -func (m *JobStatusRequest) XXX_DiscardUnknown() { - xxx_messageInfo_JobStatusRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_JobStatusRequest proto.InternalMessageInfo - -func (m *JobStatusRequest) GetJobId() string { - if m != nil { - return m.JobId - } - return "" -} - -type JobStatusResponse struct { - JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"jobId,omitempty"` - JobStatus JobStatus `protobuf:"varint,2,opt,name=job_status,json=jobStatus,proto3,enum=queryapi.JobStatus" json:"jobStatus,omitempty"` -} - -func (m *JobStatusResponse) Reset() { *m = JobStatusResponse{} } -func (*JobStatusResponse) ProtoMessage() {} -func (*JobStatusResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_4ef0e77b55b97342, []int{1} -} -func (m *JobStatusResponse) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *JobStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_JobStatusResponse.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *JobStatusResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_JobStatusResponse.Merge(m, src) -} -func (m *JobStatusResponse) XXX_Size() int { - return m.Size() -} -func (m *JobStatusResponse) XXX_DiscardUnknown() { - xxx_messageInfo_JobStatusResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_JobStatusResponse proto.InternalMessageInfo - -func (m *JobStatusResponse) GetJobId() string { - if m != nil { - return m.JobId - } - return "" -} - -func (m *JobStatusResponse) GetJobStatus() JobStatus { - if m != nil { - return m.JobStatus - } - return JobStatus_UNKNOWN -} - -func init() { - proto.RegisterEnum("queryapi.JobStatus", JobStatus_name, JobStatus_value) - proto.RegisterType((*JobStatusRequest)(nil), "queryapi.JobStatusRequest") - proto.RegisterType((*JobStatusResponse)(nil), "queryapi.JobStatusResponse") -} - -func init() { proto.RegisterFile("pkg/api/queryapi.proto", fileDescriptor_4ef0e77b55b97342) } - -var fileDescriptor_4ef0e77b55b97342 = []byte{ - // 409 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0x3d, 0x6f, 0xd3, 0x40, - 0x18, 0xc7, 0x7d, 0x85, 0xba, 0xf1, 0xf1, 0x76, 0x38, 0x12, 0x54, 0x41, 0xba, 0x56, 0x5d, 0xa8, - 0x2a, 0x88, 0xa5, 0xb2, 0x23, 0xf9, 0xe5, 0x88, 0x4c, 0xd3, 0x23, 0xb5, 0x6b, 0x21, 0xb1, 0x20, - 0xbb, 0x31, 0xc6, 0x46, 0xe6, 0xae, 0xf6, 0x79, 0xc8, 0xc6, 0x07, 0x60, 0x40, 0x7c, 0x2a, 0xc6, - 0x8c, 0x99, 0x22, 0x70, 0xb6, 0x7c, 0x0a, 0x74, 0x4e, 0x62, 0x32, 0x64, 0x61, 0xbb, 0xdf, 0x3d, - 0xcf, 0xff, 0x27, 0x3f, 0xbe, 0x07, 0x3e, 0xe1, 0x5f, 0x12, 0x23, 0xe4, 0xa9, 0x71, 0x5b, 0xc5, - 0xc5, 0x24, 0xe4, 0x69, 0x9f, 0x17, 0x4c, 0x30, 0xbd, 0xb3, 0xe1, 0xde, 0xcb, 0x24, 0x15, 0x9f, - 0xab, 0xa8, 0x7f, 0xc3, 0x72, 0x23, 0x61, 0x09, 0x33, 0x9a, 0x86, 0xa8, 0xfa, 0xd4, 0x50, 0x03, - 0xcd, 0x69, 0x15, 0x3c, 0x79, 0x0d, 0xd1, 0x5b, 0x16, 0xf9, 0x22, 0x14, 0x55, 0xe9, 0xc5, 0xb7, - 0x55, 0x5c, 0x0a, 0xfd, 0x0c, 0xaa, 0x19, 0x8b, 0x3e, 0xa6, 0xe3, 0x43, 0x70, 0x0c, 0x4e, 0x35, - 0xab, 0xbb, 0x9c, 0x1f, 0x3d, 0xca, 0x58, 0xe4, 0x8e, 0x5f, 0xb0, 0x3c, 0x15, 0x71, 0xce, 0xc5, - 0xc4, 0xdb, 0x6f, 0x2e, 0x4e, 0xbe, 0x03, 0xf8, 0x78, 0x4b, 0x50, 0x72, 0xf6, 0xb5, 0x8c, 0xff, - 0xc7, 0xa0, 0x5f, 0x40, 0x28, 0x7b, 0xcb, 0xc6, 0x70, 0xb8, 0x77, 0x0c, 0x4e, 0x1f, 0x9e, 0x77, - 0xfb, 0xed, 0x7c, 0xad, 0xdc, 0x7a, 0xba, 0x9c, 0x1f, 0x75, 0xb3, 0x0d, 0x6e, 0x89, 0xb4, 0xf6, - 0xf2, 0xec, 0x27, 0x80, 0x5a, 0x9b, 0xd0, 0xef, 0xc1, 0x83, 0x80, 0x5e, 0xd0, 0x77, 0xef, 0x29, - 0x52, 0xf4, 0x07, 0x50, 0xf3, 0x03, 0xeb, 0xd2, 0xbd, 0xbe, 0x26, 0x0e, 0x02, 0x3a, 0x84, 0xea, - 0x55, 0x40, 0x02, 0xe2, 0xa0, 0x3d, 0x79, 0x1e, 0x12, 0xd3, 0x27, 0x0e, 0xba, 0x23, 0x33, 0x23, - 0x42, 0x1d, 0x97, 0x0e, 0xd0, 0x5d, 0x09, 0x5e, 0x40, 0xa9, 0x84, 0xfd, 0x95, 0xc0, 0xb6, 0x09, - 0x71, 0x88, 0x83, 0x54, 0x19, 0x7a, 0x63, 0xba, 0x43, 0xe2, 0xa0, 0x03, 0x59, 0x1a, 0x79, 0x84, - 0x5c, 0x8e, 0xa4, 0xbb, 0x23, 0xd1, 0x36, 0xa9, 0x4d, 0x86, 0xb2, 0xaa, 0x9d, 0xfb, 0xb0, 0x73, - 0x25, 0xc7, 0x31, 0x79, 0xaa, 0x0f, 0xe0, 0xfd, 0x41, 0x2c, 0xfe, 0x7d, 0x62, 0x6f, 0xc7, 0xa4, - 0xeb, 0x77, 0xe8, 0x3d, 0xdb, 0x59, 0x5b, 0xfd, 0x62, 0xcb, 0x9d, 0xfd, 0xc1, 0xca, 0xb7, 0x1a, - 0x83, 0x5f, 0x35, 0x06, 0xd3, 0x1a, 0x83, 0xdf, 0x35, 0x06, 0x3f, 0x16, 0x58, 0x99, 0x2e, 0xb0, - 0x32, 0x5b, 0x60, 0xe5, 0xc3, 0xf3, 0xad, 0x4d, 0x08, 0x8b, 0x3c, 0x1c, 0x87, 0xbc, 0x60, 0x59, - 0x7c, 0x23, 0xd6, 0x64, 0xac, 0x77, 0x29, 0x52, 0x9b, 0x55, 0x78, 0xf5, 0x37, 0x00, 0x00, 0xff, - 0xff, 0x14, 0xa6, 0x2d, 0x24, 0x5d, 0x02, 0x00, 0x00, -} - -// Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the grpc package it is being compiled against. -const _ = grpc.SupportPackageIsVersion4 - -// QueryApiClient is the client API for QueryApi service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type QueryApiClient interface { - GetJobStatus(ctx context.Context, in *JobStatusRequest, opts ...grpc.CallOption) (*JobStatusResponse, error) -} - -type queryApiClient struct { - cc *grpc.ClientConn -} - -func NewQueryApiClient(cc *grpc.ClientConn) QueryApiClient { - return &queryApiClient{cc} -} - -func (c *queryApiClient) GetJobStatus(ctx context.Context, in *JobStatusRequest, opts ...grpc.CallOption) (*JobStatusResponse, error) { - out := new(JobStatusResponse) - err := c.cc.Invoke(ctx, "/queryapi.QueryApi/GetJobStatus", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -// QueryApiServer is the server API for QueryApi service. -type QueryApiServer interface { - GetJobStatus(context.Context, *JobStatusRequest) (*JobStatusResponse, error) -} - -// UnimplementedQueryApiServer can be embedded to have forward compatible implementations. -type UnimplementedQueryApiServer struct { -} - -func (*UnimplementedQueryApiServer) GetJobStatus(ctx context.Context, req *JobStatusRequest) (*JobStatusResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetJobStatus not implemented") -} - -func RegisterQueryApiServer(s *grpc.Server, srv QueryApiServer) { - s.RegisterService(&_QueryApi_serviceDesc, srv) -} - -func _QueryApi_GetJobStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(JobStatusRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(QueryApiServer).GetJobStatus(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/queryapi.QueryApi/GetJobStatus", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(QueryApiServer).GetJobStatus(ctx, req.(*JobStatusRequest)) - } - return interceptor(ctx, in, info, handler) -} - -var _QueryApi_serviceDesc = grpc.ServiceDesc{ - ServiceName: "queryapi.QueryApi", - HandlerType: (*QueryApiServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "GetJobStatus", - Handler: _QueryApi_GetJobStatus_Handler, - }, - }, - Streams: []grpc.StreamDesc{}, - Metadata: "pkg/api/queryapi.proto", -} - -func (m *JobStatusRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *JobStatusRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *JobStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.JobId) > 0 { - i -= len(m.JobId) - copy(dAtA[i:], m.JobId) - i = encodeVarintQueryapi(dAtA, i, uint64(len(m.JobId))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *JobStatusResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *JobStatusResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *JobStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.JobStatus != 0 { - i = encodeVarintQueryapi(dAtA, i, uint64(m.JobStatus)) - i-- - dAtA[i] = 0x10 - } - if len(m.JobId) > 0 { - i -= len(m.JobId) - copy(dAtA[i:], m.JobId) - i = encodeVarintQueryapi(dAtA, i, uint64(len(m.JobId))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func encodeVarintQueryapi(dAtA []byte, offset int, v uint64) int { - offset -= sovQueryapi(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *JobStatusRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.JobId) - if l > 0 { - n += 1 + l + sovQueryapi(uint64(l)) - } - return n -} - -func (m *JobStatusResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.JobId) - if l > 0 { - n += 1 + l + sovQueryapi(uint64(l)) - } - if m.JobStatus != 0 { - n += 1 + sovQueryapi(uint64(m.JobStatus)) - } - return n -} - -func sovQueryapi(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozQueryapi(x uint64) (n int) { - return sovQueryapi(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (this *JobStatusRequest) String() string { - if this == nil { - return "nil" - } - s := strings.Join([]string{`&JobStatusRequest{`, - `JobId:` + fmt.Sprintf("%v", this.JobId) + `,`, - `}`, - }, "") - return s -} -func (this *JobStatusResponse) String() string { - if this == nil { - return "nil" - } - s := strings.Join([]string{`&JobStatusResponse{`, - `JobId:` + fmt.Sprintf("%v", this.JobId) + `,`, - `JobStatus:` + fmt.Sprintf("%v", this.JobStatus) + `,`, - `}`, - }, "") - return s -} -func valueToStringQueryapi(v interface{}) string { - rv := reflect.ValueOf(v) - if rv.IsNil() { - return "nil" - } - pv := reflect.Indirect(rv).Interface() - return fmt.Sprintf("*%v", pv) -} -func (m *JobStatusRequest) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowQueryapi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: JobStatusRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: JobStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field JobId", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowQueryapi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthQueryapi - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthQueryapi - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.JobId = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipQueryapi(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthQueryapi - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *JobStatusResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowQueryapi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: JobStatusResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: JobStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field JobId", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowQueryapi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthQueryapi - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthQueryapi - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.JobId = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field JobStatus", wireType) - } - m.JobStatus = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowQueryapi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.JobStatus |= JobStatus(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipQueryapi(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthQueryapi - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipQueryapi(dAtA []byte) (n int, err error) { - l := len(dAtA) - iNdEx := 0 - depth := 0 - for iNdEx < l { - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowQueryapi - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - wireType := int(wire & 0x7) - switch wireType { - case 0: - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowQueryapi - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - iNdEx++ - if dAtA[iNdEx-1] < 0x80 { - break - } - } - case 1: - iNdEx += 8 - case 2: - var length int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowQueryapi - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - length |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if length < 0 { - return 0, ErrInvalidLengthQueryapi - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupQueryapi - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthQueryapi - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthQueryapi = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowQueryapi = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupQueryapi = fmt.Errorf("proto: unexpected end of group") -) diff --git a/pkg/api/queryapi.proto b/pkg/api/queryapi.proto deleted file mode 100644 index 8809eb4f810..00000000000 --- a/pkg/api/queryapi.proto +++ /dev/null @@ -1,34 +0,0 @@ -syntax = 'proto3'; - -package queryapi; -option go_package = "github.com/armadaproject/armada/pkg/api"; - -import "github.com/gogo/protobuf/gogoproto/gogo.proto"; -option (gogoproto.goproto_stringer_all) = false; -option (gogoproto.stringer_all) = true; - -enum JobStatus { - UNKNOWN = 0; - SUBMITTED = 1; - QUEUED = 2; - LEASED = 3; - PENDING = 4; - RUNNING = 5; - SUCCEEDED = 6; - FAILED = 7; - PREEMPTED = 8; - CANCELLED = 9; -} - -message JobStatusRequest{ - string job_id = 1; -} - -message JobStatusResponse{ - string job_id = 1; - JobStatus job_status = 2; -} - -service QueryApi { - rpc GetJobStatus (JobStatusRequest) returns (JobStatusResponse); -} diff --git a/pkg/api/submit.pb.go b/pkg/api/submit.pb.go index 6e36c9acd8f..3af7b788f02 100644 --- a/pkg/api/submit.pb.go +++ b/pkg/api/submit.pb.go @@ -97,6 +97,10 @@ const ( JobState_SUCCEEDED JobState = 3 JobState_FAILED JobState = 4 JobState_UNKNOWN JobState = 5 + JobState_SUBMITTED JobState = 6 + JobState_LEASED JobState = 7 + JobState_PREEMPTED JobState = 8 + JobState_CANCELLED JobState = 9 ) var JobState_name = map[int32]string{ @@ -106,6 +110,10 @@ var JobState_name = map[int32]string{ 3: "SUCCEEDED", 4: "FAILED", 5: "UNKNOWN", + 6: "SUBMITTED", + 7: "LEASED", + 8: "PREEMPTED", + 9: "CANCELLED", } var JobState_value = map[string]int32{ @@ -115,6 +123,10 @@ var JobState_value = map[string]int32{ "SUCCEEDED": 3, "FAILED": 4, "UNKNOWN": 5, + "SUBMITTED": 6, + "LEASED": 7, + "PREEMPTED": 8, + "CANCELLED": 9, } func (x JobState) String() string { @@ -1901,171 +1913,174 @@ func init() { func init() { proto.RegisterFile("pkg/api/submit.proto", fileDescriptor_e998bacb27df16c1) } var fileDescriptor_e998bacb27df16c1 = []byte{ - // 2616 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0x4b, 0x6f, 0x1b, 0xd7, - 0xf5, 0xd7, 0x90, 0x12, 0x25, 0x1e, 0x52, 0x12, 0x75, 0x45, 0x49, 0x23, 0x5a, 0x21, 0x99, 0xc9, - 0x3f, 0xfe, 0xd3, 0x42, 0x42, 0xc6, 0x4a, 0x83, 0xca, 0x6e, 0x00, 0xc3, 0x94, 0x68, 0x5b, 0x8e, - 0xa3, 0x28, 0x54, 0x94, 0x47, 0x51, 0x94, 0x19, 0x72, 0xae, 0xa8, 0x91, 0xc8, 0x99, 0xf1, 0xcc, - 0x50, 0x86, 0x5b, 0x04, 0x08, 0x8a, 0x02, 0xdd, 0x1a, 0xe8, 0xae, 0xfd, 0x06, 0xe9, 0xa6, 0x1f, - 0x23, 0xcb, 0x00, 0xdd, 0xa4, 0x1b, 0xa6, 0xb5, 0xfb, 0x00, 0xb8, 0xeb, 0xbe, 0x8b, 0xe2, 0x9e, - 0x3b, 0xc3, 0xb9, 0xc3, 0x87, 0x1e, 0x8e, 0x9d, 0x6e, 0xba, 0xd3, 0xfd, 0xdd, 0xf3, 0xbc, 0x73, - 0xee, 0x79, 0x5c, 0x11, 0xd2, 0xd6, 0x49, 0xb3, 0xa4, 0x5a, 0x7a, 0xc9, 0xe9, 0xd4, 0xdb, 0xba, - 0x5b, 0xb4, 0x6c, 0xd3, 0x35, 0x49, 0x54, 0xb5, 0xf4, 0xcc, 0x95, 0xa6, 0x69, 0x36, 0x5b, 0xb4, - 0x84, 0x50, 0xbd, 0x73, 0x58, 0xa2, 0x6d, 0xcb, 0x7d, 0xcc, 0x29, 0x32, 0xb9, 0xc1, 0x4d, 0x57, - 0x6f, 0x53, 0xc7, 0x55, 0xdb, 0x96, 0x47, 0xa0, 0x9c, 0x6c, 0x3a, 0x45, 0xdd, 0x44, 0xd9, 0x0d, - 0xd3, 0xa6, 0xa5, 0xd3, 0xeb, 0xa5, 0x26, 0x35, 0xa8, 0xad, 0xba, 0x54, 0xf3, 0x68, 0x0a, 0x02, - 0x8d, 0x41, 0xdd, 0x47, 0xa6, 0x7d, 0xa2, 0x1b, 0xcd, 0x51, 0x94, 0x6b, 0x9e, 0x3a, 0x46, 0xa9, - 0x1a, 0x86, 0xe9, 0xaa, 0xae, 0x6e, 0x1a, 0x8e, 0xb7, 0xfb, 0x66, 0x53, 0x77, 0x8f, 0x3a, 0xf5, - 0x62, 0xc3, 0x6c, 0x97, 0x9a, 0x66, 0xd3, 0x0c, 0xac, 0x62, 0x2b, 0x5c, 0xe0, 0x5f, 0x1e, 0x79, - 0xdf, 0xe7, 0x23, 0xaa, 0xb6, 0xdc, 0x23, 0x8e, 0x2a, 0xbd, 0x38, 0xa4, 0xef, 0x9b, 0xf5, 0x7d, - 0x3c, 0x87, 0x2a, 0x7d, 0xd8, 0xa1, 0x8e, 0xbb, 0xe3, 0xd2, 0x36, 0xd9, 0x80, 0x19, 0xcb, 0xd6, - 0x4d, 0x5b, 0x77, 0x1f, 0xcb, 0x52, 0x5e, 0x2a, 0x48, 0xe5, 0xe5, 0x5e, 0x37, 0x47, 0x7c, 0xec, - 0x0d, 0xb3, 0xad, 0xbb, 0x78, 0x34, 0xd5, 0x3e, 0x1d, 0x79, 0x07, 0xe2, 0x86, 0xda, 0xa6, 0x8e, - 0xa5, 0x36, 0xa8, 0x1c, 0xcd, 0x4b, 0x85, 0x78, 0x79, 0xa5, 0xd7, 0xcd, 0x2d, 0xf6, 0x41, 0x81, - 0x2b, 0xa0, 0x24, 0x6f, 0x43, 0xbc, 0xd1, 0xd2, 0xa9, 0xe1, 0xd6, 0x74, 0x4d, 0x9e, 0x41, 0x36, - 0xd4, 0xc5, 0xc1, 0x1d, 0x4d, 0xd4, 0xe5, 0x63, 0x64, 0x1f, 0x62, 0x2d, 0xb5, 0x4e, 0x5b, 0x8e, - 0x3c, 0x99, 0x8f, 0x16, 0x12, 0x1b, 0xaf, 0x17, 0x55, 0x4b, 0x2f, 0x8e, 0x72, 0xa5, 0xf8, 0x00, - 0xe9, 0x2a, 0x86, 0x6b, 0x3f, 0x2e, 0xa7, 0x7b, 0xdd, 0x5c, 0x8a, 0x33, 0x0a, 0x62, 0x3d, 0x51, - 0xa4, 0x09, 0x09, 0xe1, 0x9c, 0xe5, 0x29, 0x94, 0xbc, 0x3e, 0x5e, 0xf2, 0xed, 0x80, 0x98, 0x8b, - 0x5f, 0xed, 0x75, 0x73, 0x4b, 0x82, 0x08, 0x41, 0x87, 0x28, 0x99, 0xfc, 0x46, 0x82, 0xb4, 0x4d, - 0x1f, 0x76, 0x74, 0x9b, 0x6a, 0x35, 0xc3, 0xd4, 0x68, 0xcd, 0x73, 0x26, 0x86, 0x2a, 0xaf, 0x8f, - 0x57, 0x59, 0xf5, 0xb8, 0x76, 0x4d, 0x8d, 0x8a, 0x8e, 0x29, 0xbd, 0x6e, 0x6e, 0xcd, 0x1e, 0xda, - 0x0c, 0x0c, 0x90, 0xa5, 0x2a, 0x19, 0xde, 0x27, 0x1f, 0xc0, 0x8c, 0x65, 0x6a, 0x35, 0xc7, 0xa2, - 0x0d, 0x39, 0x92, 0x97, 0x0a, 0x89, 0x8d, 0x2b, 0x45, 0x1e, 0xa0, 0x68, 0x03, 0x0b, 0xe2, 0xe2, - 0xe9, 0xf5, 0xe2, 0x9e, 0xa9, 0xed, 0x5b, 0xb4, 0x81, 0xdf, 0x73, 0xc1, 0xe2, 0x8b, 0x90, 0xec, - 0x69, 0x0f, 0x24, 0x7b, 0x10, 0xf7, 0x05, 0x3a, 0xf2, 0x34, 0xba, 0x73, 0xa6, 0x44, 0x1e, 0x56, - 0x7c, 0xe1, 0x84, 0xc2, 0xca, 0xc3, 0xc8, 0x16, 0x4c, 0xeb, 0x46, 0xd3, 0xa6, 0x8e, 0x23, 0xc7, - 0x51, 0x1e, 0x41, 0x41, 0x3b, 0x1c, 0xdb, 0x32, 0x8d, 0x43, 0xbd, 0x59, 0x5e, 0x62, 0x86, 0x79, - 0x64, 0x82, 0x14, 0x9f, 0x93, 0xdc, 0x81, 0x19, 0x87, 0xda, 0xa7, 0x7a, 0x83, 0x3a, 0x32, 0x08, - 0x52, 0xf6, 0x39, 0xe8, 0x49, 0x41, 0x63, 0x7c, 0x3a, 0xd1, 0x18, 0x1f, 0x63, 0x31, 0xee, 0x34, - 0x8e, 0xa8, 0xd6, 0x69, 0x51, 0x5b, 0x4e, 0x04, 0x31, 0xde, 0x07, 0xc5, 0x18, 0xef, 0x83, 0x64, - 0x07, 0x16, 0x1e, 0x76, 0x68, 0x87, 0xd6, 0x5c, 0xb7, 0x55, 0x73, 0x68, 0xc3, 0x34, 0x34, 0x47, - 0x4e, 0xe6, 0xa5, 0x42, 0xb4, 0xfc, 0x4a, 0xaf, 0x9b, 0x5b, 0xc5, 0xcd, 0x8f, 0xdc, 0xd6, 0x3e, - 0xdf, 0x12, 0x84, 0xcc, 0x0f, 0x6c, 0x65, 0x54, 0x48, 0x08, 0x1f, 0x9e, 0xbc, 0x06, 0xd1, 0x13, - 0xca, 0xef, 0x68, 0xbc, 0xbc, 0xd0, 0xeb, 0xe6, 0x66, 0x4f, 0xa8, 0x78, 0x3d, 0xd9, 0x2e, 0xb9, - 0x06, 0x53, 0xa7, 0x6a, 0xab, 0x43, 0xf1, 0x13, 0xc7, 0xcb, 0x8b, 0xbd, 0x6e, 0x6e, 0x1e, 0x01, - 0x81, 0x90, 0x53, 0xdc, 0x8c, 0x6c, 0x4a, 0x99, 0x43, 0x48, 0x0d, 0x86, 0xf6, 0x4b, 0xd1, 0xd3, - 0x86, 0x95, 0x31, 0xf1, 0xfc, 0x32, 0xd4, 0x29, 0xff, 0x8a, 0xc2, 0x6c, 0x28, 0x6a, 0xc8, 0x4d, - 0x98, 0x74, 0x1f, 0x5b, 0x14, 0xd5, 0xcc, 0x6d, 0xa4, 0xc4, 0xb8, 0xfa, 0xe8, 0xb1, 0x45, 0x31, - 0x5d, 0xcc, 0x31, 0x8a, 0x50, 0xac, 0x23, 0x0f, 0x53, 0x6e, 0x99, 0xb6, 0xeb, 0xc8, 0x91, 0x7c, - 0xb4, 0x30, 0xcb, 0x95, 0x23, 0x20, 0x2a, 0x47, 0x80, 0x7c, 0x1e, 0xce, 0x2b, 0x51, 0x8c, 0xbf, - 0xd7, 0x86, 0xa3, 0xf8, 0xf9, 0x13, 0xca, 0x0d, 0x48, 0xb8, 0x2d, 0xa7, 0x46, 0x0d, 0xb5, 0xde, - 0xa2, 0x9a, 0x3c, 0x99, 0x97, 0x0a, 0x33, 0x65, 0xb9, 0xd7, 0xcd, 0xa5, 0x5d, 0x76, 0xa2, 0x88, - 0x0a, 0xbc, 0x10, 0xa0, 0x98, 0x7e, 0xa9, 0xed, 0xd6, 0x58, 0x42, 0x96, 0xa7, 0x84, 0xf4, 0x4b, - 0x6d, 0x77, 0x57, 0x6d, 0xd3, 0x50, 0xfa, 0xf5, 0x30, 0x72, 0x0b, 0x66, 0x3b, 0x0e, 0xad, 0x35, - 0x5a, 0x1d, 0xc7, 0xa5, 0xf6, 0xce, 0x9e, 0x1c, 0x43, 0x8d, 0x99, 0x5e, 0x37, 0xb7, 0xdc, 0x71, - 0xe8, 0x96, 0x8f, 0x0b, 0xcc, 0x49, 0x11, 0xff, 0xa1, 0x42, 0x4c, 0x71, 0x61, 0x36, 0x74, 0xc5, - 0xc9, 0xe6, 0x88, 0x4f, 0xee, 0x51, 0xe0, 0x27, 0x27, 0xc3, 0x9f, 0xfc, 0xd2, 0x1f, 0x5c, 0xf9, - 0xb3, 0x04, 0xa9, 0xc1, 0xf4, 0xcd, 0xf8, 0xf1, 0x2e, 0x7b, 0x0e, 0x22, 0x3f, 0x02, 0x22, 0x3f, - 0x02, 0xe4, 0x47, 0x00, 0xc7, 0x66, 0xbd, 0xe6, 0x50, 0xac, 0x89, 0x91, 0xe0, 0xa3, 0x1c, 0x9b, - 0xf5, 0x7d, 0x3a, 0x50, 0x13, 0x7d, 0x8c, 0x68, 0xb0, 0xc0, 0xb8, 0x6c, 0xae, 0xaf, 0xc6, 0x08, - 0xfc, 0x60, 0x5b, 0x1d, 0x5b, 0x51, 0x78, 0xfe, 0x39, 0x36, 0xeb, 0x02, 0x16, 0xca, 0x3f, 0x03, - 0x5b, 0xca, 0xbf, 0xb9, 0x6f, 0x5b, 0xaa, 0xd1, 0xa0, 0x2d, 0xdf, 0xb7, 0x75, 0x88, 0x31, 0xd5, - 0xba, 0x26, 0x3a, 0x77, 0x6c, 0xd6, 0x43, 0x96, 0x4e, 0x21, 0xf0, 0x9c, 0xce, 0xf5, 0x4f, 0x2f, - 0x7a, 0xee, 0xe9, 0xbd, 0x09, 0xd3, 0xdc, 0x18, 0xde, 0x1c, 0xc4, 0x79, 0xd5, 0x47, 0xe5, 0xa1, - 0xaa, 0xcf, 0x11, 0xf2, 0x06, 0xc4, 0x6c, 0xaa, 0x3a, 0xa6, 0xe1, 0x45, 0x3f, 0x52, 0x73, 0x44, - 0xa4, 0xe6, 0x88, 0xf2, 0x77, 0x09, 0x16, 0xef, 0xa3, 0x51, 0xe1, 0x13, 0x08, 0x7b, 0x25, 0x5d, - 0xd6, 0xab, 0xc8, 0xb9, 0x5e, 0xdd, 0x82, 0xd8, 0xa1, 0xde, 0x72, 0xa9, 0x8d, 0x27, 0x90, 0xd8, - 0x58, 0xe8, 0x7f, 0x52, 0xea, 0xde, 0xc1, 0x0d, 0x6e, 0x39, 0x27, 0x12, 0x2d, 0xe7, 0x88, 0xe0, - 0xe7, 0xe4, 0x05, 0xfc, 0x7c, 0x0f, 0x92, 0xa2, 0x6c, 0xf2, 0x13, 0x88, 0x39, 0xae, 0xea, 0x52, - 0x47, 0x96, 0xf2, 0xd1, 0xc2, 0xdc, 0xc6, 0x6c, 0x5f, 0x3d, 0x43, 0xb9, 0x30, 0x4e, 0x20, 0x0a, - 0xe3, 0x88, 0xf2, 0xdd, 0x3c, 0x44, 0xef, 0x9b, 0x75, 0x92, 0x87, 0x48, 0xff, 0x70, 0x52, 0xbd, - 0x6e, 0x2e, 0xa9, 0x8b, 0xc7, 0x12, 0xd1, 0xb5, 0x70, 0x33, 0x38, 0x7b, 0xc1, 0x66, 0xf0, 0xa5, - 0x47, 0x54, 0xa8, 0xb3, 0x9d, 0xbe, 0x70, 0x67, 0x5b, 0xee, 0x37, 0xa9, 0xbc, 0x71, 0x49, 0xfb, - 0x67, 0x76, 0x89, 0x9e, 0xf4, 0xe3, 0x70, 0xed, 0x80, 0xf0, 0x75, 0x7e, 0xfe, 0x8a, 0x71, 0x3a, - 0xa6, 0x03, 0x4d, 0xa0, 0x82, 0x7c, 0x5f, 0xc1, 0x8b, 0x6e, 0x38, 0xaf, 0xc1, 0x94, 0xf9, 0xc8, - 0xa0, 0xb6, 0xd7, 0xe9, 0xe3, 0xa9, 0x23, 0x20, 0x9e, 0x3a, 0x02, 0x84, 0xc2, 0x15, 0xde, 0x34, - 0xe1, 0xd2, 0x39, 0xd2, 0xad, 0x5a, 0xc7, 0xa1, 0x76, 0xad, 0x69, 0x9b, 0x1d, 0xcb, 0x91, 0xe7, - 0xf1, 0x6e, 0x5f, 0xed, 0x75, 0x73, 0x0a, 0x92, 0x7d, 0xe0, 0x53, 0x1d, 0x38, 0xd4, 0xbe, 0x8b, - 0x34, 0x82, 0x4c, 0x79, 0x1c, 0x0d, 0xf9, 0xb5, 0x04, 0x57, 0x1b, 0x66, 0xdb, 0x62, 0x75, 0x98, - 0x6a, 0xb5, 0xb3, 0x54, 0x2e, 0xe6, 0xa5, 0x42, 0xb2, 0xfc, 0x56, 0xaf, 0x9b, 0x7b, 0x23, 0xe0, - 0xf8, 0xf0, 0x7c, 0xe5, 0xca, 0xf9, 0xd4, 0xa1, 0x89, 0x6b, 0xf2, 0x82, 0x13, 0x97, 0xd8, 0xbd, - 0x4f, 0xbd, 0xf0, 0xee, 0x3d, 0xf9, 0x22, 0xba, 0xf7, 0xdf, 0x49, 0x90, 0xf7, 0xfa, 0x60, 0xdd, - 0x68, 0xd6, 0x6c, 0xea, 0x98, 0x1d, 0xbb, 0x41, 0x6b, 0x5e, 0x68, 0xb4, 0xa9, 0xe1, 0x3a, 0xf2, - 0x12, 0xda, 0x5e, 0x18, 0xa5, 0xa9, 0xea, 0x31, 0x54, 0x05, 0xfa, 0xf2, 0xd5, 0xaf, 0xbb, 0xb9, - 0x89, 0x5e, 0x37, 0x97, 0x0d, 0x24, 0x8f, 0xa2, 0xab, 0x9e, 0xb3, 0x4f, 0x76, 0x60, 0xba, 0x61, - 0x53, 0x36, 0x72, 0x63, 0x03, 0x93, 0xd8, 0xc8, 0x14, 0xf9, 0xcc, 0x5d, 0xf4, 0x87, 0xe9, 0xe2, - 0x47, 0xfe, 0x88, 0x5f, 0x5e, 0xf4, 0x94, 0xfa, 0x2c, 0x4f, 0xbe, 0xcb, 0x49, 0x55, 0x7f, 0x21, - 0x4e, 0x29, 0x73, 0x2f, 0x64, 0x4a, 0x49, 0x7d, 0x8f, 0x29, 0xe5, 0x67, 0x90, 0x38, 0xd9, 0x74, - 0x6a, 0xbe, 0x41, 0x0b, 0x28, 0xea, 0x55, 0xf1, 0x78, 0x83, 0x97, 0x07, 0x76, 0xc8, 0x9e, 0x95, - 0xbc, 0x63, 0x3c, 0xd9, 0x74, 0x76, 0x86, 0x4c, 0x84, 0x00, 0x65, 0x29, 0x89, 0x49, 0xf7, 0xb4, - 0xc9, 0x64, 0x7c, 0x98, 0x78, 0x76, 0xf7, 0xe5, 0x7a, 0xeb, 0x01, 0xb9, 0x1e, 0x1a, 0x9e, 0xad, - 0xd2, 0xdf, 0x6f, 0xb6, 0x5a, 0xfe, 0xdf, 0x6c, 0xf5, 0x83, 0xce, 0x56, 0xff, 0x90, 0x60, 0xf9, - 0x3e, 0xeb, 0x14, 0xbd, 0xdc, 0xa4, 0xff, 0x82, 0xfa, 0x9d, 0x91, 0xd0, 0x8e, 0x49, 0x17, 0x68, - 0xc7, 0x5e, 0x7a, 0x31, 0x7f, 0x17, 0x92, 0x06, 0x7d, 0x54, 0x1b, 0x48, 0xb6, 0x58, 0x37, 0x0d, - 0xfa, 0x68, 0x6f, 0x38, 0xdf, 0x26, 0x04, 0x58, 0xf9, 0x43, 0x04, 0x56, 0x86, 0x1c, 0x75, 0x2c, - 0xd3, 0x70, 0x28, 0xf9, 0xbd, 0x04, 0xb2, 0x1d, 0x6c, 0xe0, 0x27, 0x66, 0x19, 0xaf, 0xd3, 0x72, - 0xb9, 0xef, 0x89, 0x8d, 0x1b, 0x7e, 0x61, 0x1d, 0x25, 0xa0, 0x58, 0x1d, 0x60, 0xae, 0x72, 0x5e, - 0x5e, 0x71, 0x5f, 0xef, 0x75, 0x73, 0xaf, 0xda, 0xa3, 0x29, 0x04, 0x6b, 0x57, 0xc6, 0x90, 0x64, - 0x6c, 0x58, 0x3b, 0x4b, 0xfe, 0x4b, 0x09, 0x0b, 0x03, 0x96, 0x84, 0xa1, 0x83, 0x7b, 0x89, 0xef, - 0x8b, 0x97, 0x19, 0x18, 0xae, 0xc1, 0x14, 0xb5, 0x6d, 0xd3, 0x16, 0x75, 0x22, 0x20, 0x92, 0x22, - 0xa0, 0x7c, 0x01, 0x0b, 0x43, 0xfa, 0xc8, 0x11, 0x10, 0x3e, 0x17, 0xf1, 0xb5, 0x37, 0x18, 0xf1, - 0xef, 0x91, 0x19, 0x1c, 0x8c, 0x02, 0x1b, 0xcb, 0xd9, 0x5e, 0x37, 0x97, 0xc1, 0xf1, 0x27, 0x00, - 0xc5, 0x93, 0x4e, 0x0d, 0xee, 0x29, 0x5f, 0xc6, 0x60, 0x0a, 0x0b, 0x3c, 0xb9, 0x0a, 0x93, 0x38, - 0x50, 0x73, 0xef, 0x70, 0xa8, 0x34, 0xc2, 0xc3, 0x34, 0xee, 0x93, 0x0a, 0xcc, 0xfb, 0x81, 0x58, - 0x3b, 0x54, 0x1b, 0xae, 0xe7, 0xa5, 0x54, 0x5e, 0xeb, 0x75, 0x73, 0xb2, 0xbf, 0x75, 0x07, 0x77, - 0x04, 0xe6, 0xb9, 0xf0, 0x0e, 0x9b, 0xff, 0xb1, 0x4f, 0xe1, 0x6d, 0x0b, 0x0e, 0x7d, 0x71, 0x9e, - 0x75, 0x19, 0xcc, 0xdb, 0x0d, 0x31, 0xeb, 0x06, 0x28, 0xbb, 0x0e, 0xd8, 0xdd, 0xf8, 0xbc, 0x7c, - 0x64, 0xc2, 0xeb, 0x80, 0xf8, 0x10, 0x73, 0x42, 0x80, 0x09, 0x85, 0xf9, 0x7e, 0x49, 0x6f, 0xe9, - 0x6d, 0xdd, 0xf5, 0x9f, 0x4d, 0xb3, 0x78, 0xb0, 0x78, 0x18, 0xfd, 0x1a, 0xfe, 0x00, 0x09, 0x78, - 0x34, 0xa3, 0x7f, 0x76, 0x68, 0x43, 0xf4, 0x2f, 0xbc, 0x43, 0xf6, 0x21, 0x61, 0x51, 0xbb, 0xad, - 0x3b, 0x0e, 0x76, 0xc1, 0xfc, 0x99, 0x74, 0x59, 0x50, 0xb1, 0x17, 0xec, 0x72, 0xdb, 0x05, 0x72, - 0xd1, 0x76, 0x01, 0xce, 0xfc, 0x53, 0x82, 0x84, 0xc0, 0x47, 0xaa, 0x30, 0xe3, 0x74, 0xea, 0xc7, - 0xb4, 0xd1, 0xbf, 0xad, 0xd9, 0xd1, 0x1a, 0x8a, 0xfb, 0x9c, 0xcc, 0xab, 0xc4, 0x1e, 0x4f, 0xa8, - 0x12, 0x7b, 0x18, 0xde, 0x17, 0x6a, 0xd7, 0xf9, 0xa3, 0x81, 0x7f, 0x5f, 0x18, 0x10, 0xba, 0x2f, - 0x0c, 0xc8, 0x7c, 0x06, 0xd3, 0x9e, 0x5c, 0x16, 0x3d, 0x27, 0xba, 0xa1, 0x89, 0xd1, 0xc3, 0xd6, - 0x62, 0xf4, 0xb0, 0x75, 0x3f, 0xca, 0x22, 0x67, 0x47, 0x59, 0x46, 0x87, 0xc5, 0x11, 0xdf, 0xe0, - 0x39, 0x6e, 0xbc, 0x74, 0xee, 0x8d, 0xaf, 0x40, 0x1c, 0xcf, 0xeb, 0x81, 0xee, 0xb8, 0x64, 0x13, - 0x62, 0x98, 0x73, 0xfd, 0xf3, 0x84, 0xe0, 0x3c, 0x79, 0x15, 0xe0, 0xbb, 0x62, 0x15, 0xe0, 0x88, - 0x72, 0x00, 0x84, 0xcf, 0xd7, 0x2d, 0x21, 0x51, 0x91, 0x5b, 0x30, 0xdb, 0xe0, 0x28, 0xd5, 0x84, - 0x82, 0x82, 0xcf, 0x4e, 0xfd, 0x8d, 0x70, 0x59, 0x49, 0x8a, 0xb8, 0x72, 0x03, 0xe6, 0x51, 0xfb, - 0x5d, 0xda, 0x7f, 0x96, 0xb9, 0xe0, 0x4d, 0x55, 0x6e, 0x81, 0xbc, 0xef, 0xda, 0x54, 0x6d, 0xeb, - 0x46, 0x73, 0x50, 0xc6, 0x6b, 0x10, 0x35, 0x3a, 0x6d, 0x14, 0x31, 0xcb, 0x0f, 0xd2, 0xe8, 0xb4, - 0xc5, 0x83, 0x34, 0x3a, 0x6d, 0xe5, 0x5d, 0x20, 0xc8, 0xb7, 0x4d, 0x5b, 0xd4, 0xa5, 0x97, 0x55, - 0xff, 0x95, 0x04, 0xc0, 0x07, 0xf2, 0x1d, 0xe3, 0xd0, 0xbc, 0x70, 0x7e, 0xb9, 0x01, 0x09, 0x3c, - 0x51, 0xad, 0x76, 0x6c, 0x62, 0x14, 0x4a, 0x85, 0x29, 0x9e, 0x18, 0x38, 0x7c, 0xdf, 0x0c, 0x85, - 0x22, 0x04, 0x28, 0x63, 0x6d, 0x51, 0xd5, 0xf1, 0x59, 0xa3, 0x01, 0x2b, 0x87, 0x07, 0x59, 0x03, - 0x54, 0x79, 0x04, 0x8b, 0xe8, 0xea, 0x81, 0xa5, 0xa9, 0x6e, 0x50, 0x1f, 0xdf, 0x11, 0x5f, 0xc0, - 0xc2, 0xd1, 0x70, 0x56, 0xc1, 0xbe, 0x44, 0xfe, 0xef, 0x80, 0x5c, 0x56, 0xdd, 0xc6, 0xd1, 0x28, - 0xed, 0x9f, 0xc1, 0xec, 0xa1, 0xaa, 0xb7, 0xfc, 0x11, 0xcf, 0x8f, 0x49, 0x39, 0xb0, 0x22, 0xcc, - 0xc0, 0xc3, 0x8a, 0xb3, 0x7c, 0x38, 0x18, 0xa7, 0x49, 0x11, 0xef, 0xfb, 0xbb, 0x85, 0xc3, 0xc0, - 0x7f, 0xcb, 0xdf, 0x01, 0xed, 0xe7, 0xfb, 0x1b, 0x66, 0xb8, 0x84, 0xbf, 0x09, 0x88, 0x57, 0x0c, - 0xed, 0x7d, 0xd5, 0x3e, 0xa1, 0xb6, 0xf2, 0x44, 0x82, 0xa5, 0xf0, 0xcd, 0x78, 0x9f, 0x3a, 0x8e, - 0xda, 0xa4, 0xe4, 0xc7, 0x97, 0xf3, 0xff, 0xde, 0x44, 0xf0, 0xde, 0x12, 0xa5, 0x86, 0xe6, 0xfd, - 0x43, 0x6a, 0x0e, 0xd9, 0xfa, 0xfa, 0xf8, 0xfd, 0xa2, 0x62, 0x36, 0xbc, 0x37, 0x51, 0x65, 0xf4, - 0xe5, 0x69, 0x98, 0xa2, 0xa7, 0xd4, 0x70, 0xd7, 0x33, 0x90, 0x10, 0x9e, 0xf1, 0x49, 0x02, 0xa6, - 0xbd, 0x65, 0x6a, 0x62, 0xfd, 0x1a, 0x24, 0x84, 0xf7, 0x5e, 0x92, 0x84, 0x19, 0xd6, 0x1f, 0xef, - 0x99, 0xb6, 0x9b, 0x9a, 0x60, 0xab, 0x7b, 0x54, 0xd5, 0x5a, 0x8c, 0x54, 0x5a, 0xff, 0x14, 0x66, - 0xfc, 0x07, 0x2e, 0x02, 0x10, 0xfb, 0xf0, 0xa0, 0x72, 0x50, 0xd9, 0x4e, 0x4d, 0x30, 0x79, 0x7b, - 0x95, 0xdd, 0xed, 0x9d, 0xdd, 0xbb, 0x29, 0x89, 0x2d, 0xaa, 0x07, 0xbb, 0xbb, 0x6c, 0x11, 0x21, - 0xb3, 0x10, 0xdf, 0x3f, 0xd8, 0xda, 0xaa, 0x54, 0xb6, 0x2b, 0xdb, 0xa9, 0x28, 0x63, 0xba, 0x73, - 0x7b, 0xe7, 0x41, 0x65, 0x3b, 0x35, 0xc9, 0xe8, 0x0e, 0x76, 0xdf, 0xdb, 0xfd, 0xe0, 0x93, 0xdd, - 0xd4, 0xd4, 0xc6, 0x1f, 0x67, 0x20, 0xc6, 0x3b, 0x0e, 0xf2, 0x31, 0x00, 0xff, 0x0b, 0x2f, 0xdd, - 0xd2, 0xc8, 0x87, 0xda, 0xcc, 0xf2, 0xe8, 0x36, 0x45, 0x59, 0xfd, 0xd5, 0x9f, 0xfe, 0xf6, 0xdb, - 0xc8, 0xa2, 0x32, 0x57, 0x3a, 0xbd, 0x5e, 0x3a, 0x36, 0xeb, 0xde, 0x7f, 0xb4, 0x6f, 0x4a, 0xeb, - 0xe4, 0x13, 0x00, 0x9e, 0x41, 0xc3, 0x72, 0x43, 0xaf, 0x96, 0x99, 0x15, 0x84, 0x87, 0x33, 0xed, - 0xb0, 0x60, 0x9e, 0x46, 0x99, 0xe0, 0x9f, 0x43, 0xb2, 0x2f, 0x78, 0x9f, 0xba, 0x44, 0x16, 0x1e, - 0x22, 0xc3, 0xd2, 0x97, 0x87, 0xa6, 0xe9, 0x0a, 0xfb, 0x5c, 0xca, 0x1a, 0x0a, 0x5f, 0x56, 0x16, - 0x3c, 0xe1, 0x0e, 0x75, 0x05, 0xf9, 0x06, 0xa4, 0xc4, 0xe6, 0x18, 0xcd, 0xbf, 0x32, 0xba, 0x6d, - 0xe6, 0x6a, 0xd6, 0xce, 0xea, 0xa9, 0x95, 0x1c, 0x2a, 0x5b, 0x55, 0xd2, 0xbe, 0x27, 0x42, 0x7f, - 0x4c, 0x99, 0xbe, 0xbb, 0x90, 0xe0, 0x17, 0x81, 0x77, 0x6e, 0x42, 0x94, 0x8e, 0x75, 0x20, 0x8d, - 0x32, 0xe7, 0x94, 0x38, 0x93, 0x89, 0x21, 0xcb, 0x04, 0x35, 0x20, 0x29, 0x08, 0x72, 0xc8, 0x5c, - 0x20, 0x89, 0x55, 0xc3, 0xcc, 0x2b, 0xb8, 0x1e, 0x77, 0x5f, 0x95, 0xff, 0x43, 0xa1, 0x59, 0x65, - 0x95, 0x09, 0xad, 0x33, 0x2a, 0xaa, 0x95, 0xf8, 0xf3, 0x82, 0x77, 0x83, 0x99, 0x92, 0x5d, 0x48, - 0xf0, 0x34, 0x75, 0x71, 0x6b, 0xaf, 0xa0, 0xe0, 0xa5, 0x4c, 0xaa, 0x6f, 0x6d, 0xe9, 0x97, 0xac, - 0x38, 0x7c, 0xe1, 0x19, 0x2d, 0xc8, 0x3b, 0xdf, 0xe8, 0x70, 0x8e, 0xf4, 0x8d, 0xce, 0x84, 0x8c, - 0xee, 0x20, 0x8d, 0x60, 0xf4, 0xa7, 0x90, 0xe0, 0x55, 0x8f, 0x1b, 0xbd, 0x12, 0xe8, 0x08, 0x15, - 0xc3, 0xb1, 0x1e, 0xc8, 0xa8, 0x85, 0xac, 0x0f, 0x79, 0x40, 0xee, 0xc0, 0xcc, 0x5d, 0xea, 0x72, - 0xb1, 0xe9, 0x40, 0x6c, 0x50, 0x9b, 0x33, 0xc2, 0x09, 0xf9, 0x72, 0xc8, 0xb0, 0x1c, 0x0d, 0xe2, - 0xbe, 0x1c, 0x87, 0x70, 0x9f, 0xc7, 0x55, 0xfb, 0x4c, 0x66, 0xc4, 0xb6, 0x97, 0xf2, 0x94, 0x0c, - 0x6a, 0x48, 0x13, 0x22, 0x9e, 0x07, 0x3f, 0x88, 0xb7, 0x24, 0x72, 0x13, 0x62, 0xf7, 0xf0, 0xe7, - 0x17, 0x64, 0x8c, 0xa7, 0x19, 0x7e, 0x99, 0x38, 0xd1, 0xd6, 0x11, 0x6d, 0x9c, 0xf4, 0xb3, 0xf3, - 0xe7, 0xdf, 0xfe, 0x35, 0x3b, 0xf1, 0xe5, 0xd3, 0xac, 0xf4, 0xf5, 0xd3, 0xac, 0xf4, 0xcd, 0xd3, - 0xac, 0xf4, 0x97, 0xa7, 0x59, 0xe9, 0xc9, 0xb3, 0xec, 0xc4, 0x37, 0xcf, 0xb2, 0x13, 0xdf, 0x3e, - 0xcb, 0x4e, 0xfc, 0xf4, 0xff, 0x85, 0x5f, 0x84, 0xa8, 0x76, 0x5b, 0xd5, 0x54, 0xcb, 0x36, 0x59, - 0x3f, 0xe9, 0xad, 0x4a, 0xde, 0x4f, 0x40, 0xbe, 0x8a, 0xa4, 0x6f, 0x23, 0xb0, 0xc7, 0xb7, 0x8b, - 0x3b, 0x66, 0xf1, 0xb6, 0xa5, 0xd7, 0x63, 0x68, 0xcb, 0xdb, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, - 0x75, 0xfa, 0x87, 0xf8, 0x1f, 0x23, 0x00, 0x00, + // 2658 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0x4d, 0x6f, 0x1b, 0xc7, + 0xf9, 0xd7, 0x92, 0x12, 0x25, 0x3e, 0xa4, 0x24, 0x6a, 0x44, 0xc9, 0x6b, 0xda, 0x21, 0x99, 0xcd, + 0x3f, 0xfe, 0xd3, 0x42, 0x42, 0xc6, 0x4a, 0x83, 0xda, 0x6e, 0x00, 0xc3, 0x94, 0x68, 0x9b, 0x8e, + 0xad, 0x28, 0xa4, 0x95, 0x34, 0x45, 0x51, 0x66, 0xc9, 0x1d, 0x51, 0x2b, 0x91, 0xbb, 0x9b, 0xdd, + 0xa5, 0x0c, 0xb7, 0x08, 0x10, 0x14, 0x05, 0x7a, 0x4d, 0xd1, 0x5b, 0xfb, 0x0d, 0xd2, 0x4b, 0x3f, + 0x46, 0x8e, 0x01, 0x7a, 0x49, 0x2f, 0x4c, 0x6b, 0xf7, 0x05, 0xe0, 0xad, 0xf7, 0x1e, 0x8a, 0x79, + 0x66, 0x97, 0x3b, 0xcb, 0x17, 0xbd, 0x38, 0x76, 0x7a, 0xe9, 0x4d, 0xf3, 0x9b, 0xe7, 0x75, 0xf6, + 0x99, 0xe7, 0x65, 0x44, 0x48, 0x5b, 0x47, 0xed, 0x92, 0x6a, 0xe9, 0x25, 0xa7, 0xd7, 0xec, 0xea, + 0x6e, 0xd1, 0xb2, 0x4d, 0xd7, 0x24, 0x51, 0xd5, 0xd2, 0x33, 0x97, 0xda, 0xa6, 0xd9, 0xee, 0xd0, + 0x12, 0x42, 0xcd, 0xde, 0x7e, 0x89, 0x76, 0x2d, 0xf7, 0x09, 0xa7, 0xc8, 0xe4, 0x46, 0x37, 0x5d, + 0xbd, 0x4b, 0x1d, 0x57, 0xed, 0x5a, 0x1e, 0x81, 0x72, 0x74, 0xdd, 0x29, 0xea, 0x26, 0xca, 0x6e, + 0x99, 0x36, 0x2d, 0x1d, 0x5f, 0x2b, 0xb5, 0xa9, 0x41, 0x6d, 0xd5, 0xa5, 0x9a, 0x47, 0x53, 0x10, + 0x68, 0x0c, 0xea, 0x3e, 0x36, 0xed, 0x23, 0xdd, 0x68, 0x4f, 0xa2, 0xbc, 0xec, 0xa9, 0x63, 0x94, + 0xaa, 0x61, 0x98, 0xae, 0xea, 0xea, 0xa6, 0xe1, 0x78, 0xbb, 0x6f, 0xb6, 0x75, 0xf7, 0xa0, 0xd7, + 0x2c, 0xb6, 0xcc, 0x6e, 0xa9, 0x6d, 0xb6, 0xcd, 0xc0, 0x2a, 0xb6, 0xc2, 0x05, 0xfe, 0xe5, 0x91, + 0x0f, 0x7d, 0x3e, 0xa0, 0x6a, 0xc7, 0x3d, 0xe0, 0xa8, 0x32, 0x88, 0x43, 0xfa, 0xbe, 0xd9, 0xac, + 0xe3, 0x39, 0xd4, 0xe8, 0xa7, 0x3d, 0xea, 0xb8, 0x55, 0x97, 0x76, 0xc9, 0x26, 0x2c, 0x58, 0xb6, + 0x6e, 0xda, 0xba, 0xfb, 0x44, 0x96, 0xf2, 0x52, 0x41, 0x2a, 0xaf, 0x0f, 0xfa, 0x39, 0xe2, 0x63, + 0x6f, 0x98, 0x5d, 0xdd, 0xc5, 0xa3, 0xa9, 0x0d, 0xe9, 0xc8, 0x3b, 0x10, 0x37, 0xd4, 0x2e, 0x75, + 0x2c, 0xb5, 0x45, 0xe5, 0x68, 0x5e, 0x2a, 0xc4, 0xcb, 0x17, 0x06, 0xfd, 0xdc, 0xea, 0x10, 0x14, + 0xb8, 0x02, 0x4a, 0xf2, 0x36, 0xc4, 0x5b, 0x1d, 0x9d, 0x1a, 0x6e, 0x43, 0xd7, 0xe4, 0x05, 0x64, + 0x43, 0x5d, 0x1c, 0xac, 0x6a, 0xa2, 0x2e, 0x1f, 0x23, 0x75, 0x88, 0x75, 0xd4, 0x26, 0xed, 0x38, + 0xf2, 0x6c, 0x3e, 0x5a, 0x48, 0x6c, 0xbe, 0x5e, 0x54, 0x2d, 0xbd, 0x38, 0xc9, 0x95, 0xe2, 0x03, + 0xa4, 0xab, 0x18, 0xae, 0xfd, 0xa4, 0x9c, 0x1e, 0xf4, 0x73, 0x29, 0xce, 0x28, 0x88, 0xf5, 0x44, + 0x91, 0x36, 0x24, 0x84, 0x73, 0x96, 0xe7, 0x50, 0xf2, 0xc6, 0x74, 0xc9, 0xb7, 0x03, 0x62, 0x2e, + 0xfe, 0xe2, 0xa0, 0x9f, 0x5b, 0x13, 0x44, 0x08, 0x3a, 0x44, 0xc9, 0xe4, 0xd7, 0x12, 0xa4, 0x6d, + 0xfa, 0x69, 0x4f, 0xb7, 0xa9, 0xd6, 0x30, 0x4c, 0x8d, 0x36, 0x3c, 0x67, 0x62, 0xa8, 0xf2, 0xda, + 0x74, 0x95, 0x35, 0x8f, 0x6b, 0xc7, 0xd4, 0xa8, 0xe8, 0x98, 0x32, 0xe8, 0xe7, 0x2e, 0xdb, 0x63, + 0x9b, 0x81, 0x01, 0xb2, 0x54, 0x23, 0xe3, 0xfb, 0xe4, 0x7d, 0x58, 0xb0, 0x4c, 0xad, 0xe1, 0x58, + 0xb4, 0x25, 0x47, 0xf2, 0x52, 0x21, 0xb1, 0x79, 0xa9, 0xc8, 0x03, 0x14, 0x6d, 0x60, 0x41, 0x5c, + 0x3c, 0xbe, 0x56, 0xdc, 0x35, 0xb5, 0xba, 0x45, 0x5b, 0xf8, 0x3d, 0x57, 0x2c, 0xbe, 0x08, 0xc9, + 0x9e, 0xf7, 0x40, 0xb2, 0x0b, 0x71, 0x5f, 0xa0, 0x23, 0xcf, 0xa3, 0x3b, 0x27, 0x4a, 0xe4, 0x61, + 0xc5, 0x17, 0x4e, 0x28, 0xac, 0x3c, 0x8c, 0x6c, 0xc1, 0xbc, 0x6e, 0xb4, 0x6d, 0xea, 0x38, 0x72, + 0x1c, 0xe5, 0x11, 0x14, 0x54, 0xe5, 0xd8, 0x96, 0x69, 0xec, 0xeb, 0xed, 0xf2, 0x1a, 0x33, 0xcc, + 0x23, 0x13, 0xa4, 0xf8, 0x9c, 0xe4, 0x0e, 0x2c, 0x38, 0xd4, 0x3e, 0xd6, 0x5b, 0xd4, 0x91, 0x41, + 0x90, 0x52, 0xe7, 0xa0, 0x27, 0x05, 0x8d, 0xf1, 0xe9, 0x44, 0x63, 0x7c, 0x8c, 0xc5, 0xb8, 0xd3, + 0x3a, 0xa0, 0x5a, 0xaf, 0x43, 0x6d, 0x39, 0x11, 0xc4, 0xf8, 0x10, 0x14, 0x63, 0x7c, 0x08, 0x92, + 0x2a, 0xac, 0x7c, 0xda, 0xa3, 0x3d, 0xda, 0x70, 0xdd, 0x4e, 0xc3, 0xa1, 0x2d, 0xd3, 0xd0, 0x1c, + 0x39, 0x99, 0x97, 0x0a, 0xd1, 0xf2, 0x2b, 0x83, 0x7e, 0xee, 0x22, 0x6e, 0x3e, 0x72, 0x3b, 0x75, + 0xbe, 0x25, 0x08, 0x59, 0x1e, 0xd9, 0xca, 0xa8, 0x90, 0x10, 0x3e, 0x3c, 0x79, 0x0d, 0xa2, 0x47, + 0x94, 0xdf, 0xd1, 0x78, 0x79, 0x65, 0xd0, 0xcf, 0x2d, 0x1e, 0x51, 0xf1, 0x7a, 0xb2, 0x5d, 0x72, + 0x15, 0xe6, 0x8e, 0xd5, 0x4e, 0x8f, 0xe2, 0x27, 0x8e, 0x97, 0x57, 0x07, 0xfd, 0xdc, 0x32, 0x02, + 0x02, 0x21, 0xa7, 0xb8, 0x19, 0xb9, 0x2e, 0x65, 0xf6, 0x21, 0x35, 0x1a, 0xda, 0x2f, 0x45, 0x4f, + 0x17, 0x2e, 0x4c, 0x89, 0xe7, 0x97, 0xa1, 0x4e, 0xf9, 0x57, 0x14, 0x16, 0x43, 0x51, 0x43, 0x6e, + 0xc2, 0xac, 0xfb, 0xc4, 0xa2, 0xa8, 0x66, 0x69, 0x33, 0x25, 0xc6, 0xd5, 0xa3, 0x27, 0x16, 0xc5, + 0x74, 0xb1, 0xc4, 0x28, 0x42, 0xb1, 0x8e, 0x3c, 0x4c, 0xb9, 0x65, 0xda, 0xae, 0x23, 0x47, 0xf2, + 0xd1, 0xc2, 0x22, 0x57, 0x8e, 0x80, 0xa8, 0x1c, 0x01, 0xf2, 0x49, 0x38, 0xaf, 0x44, 0x31, 0xfe, + 0x5e, 0x1b, 0x8f, 0xe2, 0xe7, 0x4f, 0x28, 0x37, 0x20, 0xe1, 0x76, 0x9c, 0x06, 0x35, 0xd4, 0x66, + 0x87, 0x6a, 0xf2, 0x6c, 0x5e, 0x2a, 0x2c, 0x94, 0xe5, 0x41, 0x3f, 0x97, 0x76, 0xd9, 0x89, 0x22, + 0x2a, 0xf0, 0x42, 0x80, 0x62, 0xfa, 0xa5, 0xb6, 0xdb, 0x60, 0x09, 0x59, 0x9e, 0x13, 0xd2, 0x2f, + 0xb5, 0xdd, 0x1d, 0xb5, 0x4b, 0x43, 0xe9, 0xd7, 0xc3, 0xc8, 0x2d, 0x58, 0xec, 0x39, 0xb4, 0xd1, + 0xea, 0xf4, 0x1c, 0x97, 0xda, 0xd5, 0x5d, 0x39, 0x86, 0x1a, 0x33, 0x83, 0x7e, 0x6e, 0xbd, 0xe7, + 0xd0, 0x2d, 0x1f, 0x17, 0x98, 0x93, 0x22, 0xfe, 0x7d, 0x85, 0x98, 0xe2, 0xc2, 0x62, 0xe8, 0x8a, + 0x93, 0xeb, 0x13, 0x3e, 0xb9, 0x47, 0x81, 0x9f, 0x9c, 0x8c, 0x7f, 0xf2, 0x73, 0x7f, 0x70, 0xe5, + 0xcf, 0x12, 0xa4, 0x46, 0xd3, 0x37, 0xe3, 0xc7, 0xbb, 0xec, 0x39, 0x88, 0xfc, 0x08, 0x88, 0xfc, + 0x08, 0x90, 0x1f, 0x00, 0x1c, 0x9a, 0xcd, 0x86, 0x43, 0xb1, 0x26, 0x46, 0x82, 0x8f, 0x72, 0x68, + 0x36, 0xeb, 0x74, 0xa4, 0x26, 0xfa, 0x18, 0xd1, 0x60, 0x85, 0x71, 0xd9, 0x5c, 0x5f, 0x83, 0x11, + 0xf8, 0xc1, 0x76, 0x71, 0x6a, 0x45, 0xe1, 0xf9, 0xe7, 0xd0, 0x6c, 0x0a, 0x58, 0x28, 0xff, 0x8c, + 0x6c, 0x29, 0xff, 0xe6, 0xbe, 0x6d, 0xa9, 0x46, 0x8b, 0x76, 0x7c, 0xdf, 0x36, 0x20, 0xc6, 0x54, + 0xeb, 0x9a, 0xe8, 0xdc, 0xa1, 0xd9, 0x0c, 0x59, 0x3a, 0x87, 0xc0, 0x73, 0x3a, 0x37, 0x3c, 0xbd, + 0xe8, 0xa9, 0xa7, 0xf7, 0x26, 0xcc, 0x73, 0x63, 0x78, 0x73, 0x10, 0xe7, 0x55, 0x1f, 0x95, 0x87, + 0xaa, 0x3e, 0x47, 0xc8, 0x1b, 0x10, 0xb3, 0xa9, 0xea, 0x98, 0x86, 0x17, 0xfd, 0x48, 0xcd, 0x11, + 0x91, 0x9a, 0x23, 0xca, 0xdf, 0x25, 0x58, 0xbd, 0x8f, 0x46, 0x85, 0x4f, 0x20, 0xec, 0x95, 0x74, + 0x5e, 0xaf, 0x22, 0xa7, 0x7a, 0x75, 0x0b, 0x62, 0xfb, 0x7a, 0xc7, 0xa5, 0x36, 0x9e, 0x40, 0x62, + 0x73, 0x65, 0xf8, 0x49, 0xa9, 0x7b, 0x07, 0x37, 0xb8, 0xe5, 0x9c, 0x48, 0xb4, 0x9c, 0x23, 0x82, + 0x9f, 0xb3, 0x67, 0xf0, 0xf3, 0x3d, 0x48, 0x8a, 0xb2, 0xc9, 0x8f, 0x20, 0xe6, 0xb8, 0xaa, 0x4b, + 0x1d, 0x59, 0xca, 0x47, 0x0b, 0x4b, 0x9b, 0x8b, 0x43, 0xf5, 0x0c, 0xe5, 0xc2, 0x38, 0x81, 0x28, + 0x8c, 0x23, 0xca, 0xb7, 0xcb, 0x10, 0xbd, 0x6f, 0x36, 0x49, 0x1e, 0x22, 0xc3, 0xc3, 0x49, 0x0d, + 0xfa, 0xb9, 0xa4, 0x2e, 0x1e, 0x4b, 0x44, 0xd7, 0xc2, 0xcd, 0xe0, 0xe2, 0x19, 0x9b, 0xc1, 0x97, + 0x1e, 0x51, 0xa1, 0xce, 0x76, 0xfe, 0xcc, 0x9d, 0x6d, 0x79, 0xd8, 0xa4, 0xf2, 0xc6, 0x25, 0xed, + 0x9f, 0xd9, 0x39, 0x7a, 0xd2, 0x0f, 0xc3, 0xb5, 0x03, 0xc2, 0xd7, 0xf9, 0xf9, 0x2b, 0xc6, 0xf1, + 0x94, 0x0e, 0x34, 0x81, 0x0a, 0xf2, 0x43, 0x05, 0x2f, 0xba, 0xe1, 0xbc, 0x0a, 0x73, 0xe6, 0x63, + 0x83, 0xda, 0x5e, 0xa7, 0x8f, 0xa7, 0x8e, 0x80, 0x78, 0xea, 0x08, 0x10, 0x0a, 0x97, 0x78, 0xd3, + 0x84, 0x4b, 0xe7, 0x40, 0xb7, 0x1a, 0x3d, 0x87, 0xda, 0x8d, 0xb6, 0x6d, 0xf6, 0x2c, 0x47, 0x5e, + 0xc6, 0xbb, 0x7d, 0x65, 0xd0, 0xcf, 0x29, 0x48, 0xf6, 0xbe, 0x4f, 0xb5, 0xe7, 0x50, 0xfb, 0x2e, + 0xd2, 0x08, 0x32, 0xe5, 0x69, 0x34, 0xe4, 0x57, 0x12, 0x5c, 0x69, 0x99, 0x5d, 0x8b, 0xd5, 0x61, + 0xaa, 0x35, 0x4e, 0x52, 0xb9, 0x9a, 0x97, 0x0a, 0xc9, 0xf2, 0x5b, 0x83, 0x7e, 0xee, 0x8d, 0x80, + 0xe3, 0x83, 0xd3, 0x95, 0x2b, 0xa7, 0x53, 0x87, 0x26, 0xae, 0xd9, 0x33, 0x4e, 0x5c, 0x62, 0xf7, + 0x3e, 0xf7, 0xc2, 0xbb, 0xf7, 0xe4, 0x8b, 0xe8, 0xde, 0x7f, 0x27, 0x41, 0xde, 0xeb, 0x83, 0x75, + 0xa3, 0xdd, 0xb0, 0xa9, 0x63, 0xf6, 0xec, 0x16, 0x6d, 0x78, 0xa1, 0xd1, 0xa5, 0x86, 0xeb, 0xc8, + 0x6b, 0x68, 0x7b, 0x61, 0x92, 0xa6, 0x9a, 0xc7, 0x50, 0x13, 0xe8, 0xcb, 0x57, 0xbe, 0xea, 0xe7, + 0x66, 0x06, 0xfd, 0x5c, 0x36, 0x90, 0x3c, 0x89, 0xae, 0x76, 0xca, 0x3e, 0xa9, 0xc2, 0x7c, 0xcb, + 0xa6, 0x6c, 0xe4, 0xc6, 0x06, 0x26, 0xb1, 0x99, 0x29, 0xf2, 0x99, 0xbb, 0xe8, 0x0f, 0xd3, 0xc5, + 0x47, 0xfe, 0x88, 0x5f, 0x5e, 0xf5, 0x94, 0xfa, 0x2c, 0x5f, 0x7c, 0x9b, 0x93, 0x6a, 0xfe, 0x42, + 0x9c, 0x52, 0x96, 0x5e, 0xc8, 0x94, 0x92, 0xfa, 0x0e, 0x53, 0xca, 0x4f, 0x21, 0x71, 0x74, 0xdd, + 0x69, 0xf8, 0x06, 0xad, 0xa0, 0xa8, 0x57, 0xc5, 0xe3, 0x0d, 0x5e, 0x1e, 0xd8, 0x21, 0x7b, 0x56, + 0xf2, 0x8e, 0xf1, 0xe8, 0xba, 0x53, 0x1d, 0x33, 0x11, 0x02, 0x94, 0xa5, 0x24, 0x26, 0xdd, 0xd3, + 0x26, 0x93, 0xe9, 0x61, 0xe2, 0xd9, 0x3d, 0x94, 0xeb, 0xad, 0x47, 0xe4, 0x7a, 0x68, 0x78, 0xb6, + 0x4a, 0x7f, 0xb7, 0xd9, 0x6a, 0xfd, 0x7f, 0xb3, 0xd5, 0xf7, 0x3a, 0x5b, 0xfd, 0x43, 0x82, 0xf5, + 0xfb, 0xac, 0x53, 0xf4, 0x72, 0x93, 0xfe, 0x73, 0xea, 0x77, 0x46, 0x42, 0x3b, 0x26, 0x9d, 0xa1, + 0x1d, 0x7b, 0xe9, 0xc5, 0xfc, 0x5d, 0x48, 0x1a, 0xf4, 0x71, 0x63, 0x24, 0xd9, 0x62, 0xdd, 0x34, + 0xe8, 0xe3, 0xdd, 0xf1, 0x7c, 0x9b, 0x10, 0x60, 0xe5, 0x0f, 0x11, 0xb8, 0x30, 0xe6, 0xa8, 0x63, + 0x99, 0x86, 0x43, 0xc9, 0xef, 0x25, 0x90, 0xed, 0x60, 0x03, 0x3f, 0x31, 0xcb, 0x78, 0xbd, 0x8e, + 0xcb, 0x7d, 0x4f, 0x6c, 0xde, 0xf0, 0x0b, 0xeb, 0x24, 0x01, 0xc5, 0xda, 0x08, 0x73, 0x8d, 0xf3, + 0xf2, 0x8a, 0xfb, 0xfa, 0xa0, 0x9f, 0x7b, 0xd5, 0x9e, 0x4c, 0x21, 0x58, 0x7b, 0x61, 0x0a, 0x49, + 0xc6, 0x86, 0xcb, 0x27, 0xc9, 0x7f, 0x29, 0x61, 0x61, 0xc0, 0x9a, 0x30, 0x74, 0x70, 0x2f, 0xf1, + 0x7d, 0xf1, 0x3c, 0x03, 0xc3, 0x55, 0x98, 0xa3, 0xb6, 0x6d, 0xda, 0xa2, 0x4e, 0x04, 0x44, 0x52, + 0x04, 0x94, 0xcf, 0x60, 0x65, 0x4c, 0x1f, 0x39, 0x00, 0xc2, 0xe7, 0x22, 0xbe, 0xf6, 0x06, 0x23, + 0xfe, 0x3d, 0x32, 0xa3, 0x83, 0x51, 0x60, 0x63, 0x39, 0x3b, 0xe8, 0xe7, 0x32, 0x38, 0xfe, 0x04, + 0xa0, 0x78, 0xd2, 0xa9, 0xd1, 0x3d, 0xe5, 0xf3, 0x18, 0xcc, 0x61, 0x81, 0x27, 0x57, 0x60, 0x16, + 0x07, 0x6a, 0xee, 0x1d, 0x0e, 0x95, 0x46, 0x78, 0x98, 0xc6, 0x7d, 0x52, 0x81, 0x65, 0x3f, 0x10, + 0x1b, 0xfb, 0x6a, 0xcb, 0xf5, 0xbc, 0x94, 0xca, 0x97, 0x07, 0xfd, 0x9c, 0xec, 0x6f, 0xdd, 0xc1, + 0x1d, 0x81, 0x79, 0x29, 0xbc, 0xc3, 0xe6, 0x7f, 0xec, 0x53, 0x78, 0xdb, 0x82, 0x43, 0x5f, 0x9c, + 0x67, 0x5d, 0x06, 0xf3, 0x76, 0x43, 0xcc, 0xba, 0x01, 0xca, 0xae, 0x03, 0x76, 0x37, 0x3e, 0x2f, + 0x1f, 0x99, 0xf0, 0x3a, 0x20, 0x3e, 0xc6, 0x9c, 0x10, 0x60, 0x42, 0x61, 0x79, 0x58, 0xd2, 0x3b, + 0x7a, 0x57, 0x77, 0xfd, 0x67, 0xd3, 0x2c, 0x1e, 0x2c, 0x1e, 0xc6, 0xb0, 0x86, 0x3f, 0x40, 0x02, + 0x1e, 0xcd, 0xe8, 0x9f, 0x1d, 0xda, 0x10, 0xfd, 0x0b, 0xef, 0x90, 0x3a, 0x24, 0x2c, 0x6a, 0x77, + 0x75, 0xc7, 0xc1, 0x2e, 0x98, 0x3f, 0x93, 0xae, 0x0b, 0x2a, 0x76, 0x83, 0x5d, 0x6e, 0xbb, 0x40, + 0x2e, 0xda, 0x2e, 0xc0, 0x99, 0x7f, 0x4a, 0x90, 0x10, 0xf8, 0x48, 0x0d, 0x16, 0x9c, 0x5e, 0xf3, + 0x90, 0xb6, 0x86, 0xb7, 0x35, 0x3b, 0x59, 0x43, 0xb1, 0xce, 0xc9, 0xbc, 0x4a, 0xec, 0xf1, 0x84, + 0x2a, 0xb1, 0x87, 0xe1, 0x7d, 0xa1, 0x76, 0x93, 0x3f, 0x1a, 0xf8, 0xf7, 0x85, 0x01, 0xa1, 0xfb, + 0xc2, 0x80, 0xcc, 0xc7, 0x30, 0xef, 0xc9, 0x65, 0xd1, 0x73, 0xa4, 0x1b, 0x9a, 0x18, 0x3d, 0x6c, + 0x2d, 0x46, 0x0f, 0x5b, 0x0f, 0xa3, 0x2c, 0x72, 0x72, 0x94, 0x65, 0x74, 0x58, 0x9d, 0xf0, 0x0d, + 0x9e, 0xe3, 0xc6, 0x4b, 0xa7, 0xde, 0xf8, 0x0a, 0xc4, 0xf1, 0xbc, 0x1e, 0xe8, 0x8e, 0x4b, 0xae, + 0x43, 0x0c, 0x73, 0xae, 0x7f, 0x9e, 0x10, 0x9c, 0x27, 0xaf, 0x02, 0x7c, 0x57, 0xac, 0x02, 0x1c, + 0x51, 0xf6, 0x80, 0xf0, 0xf9, 0xba, 0x23, 0x24, 0x2a, 0x72, 0x0b, 0x16, 0x5b, 0x1c, 0xa5, 0x9a, + 0x50, 0x50, 0xf0, 0xd9, 0x69, 0xb8, 0x11, 0x2e, 0x2b, 0x49, 0x11, 0x57, 0x6e, 0xc0, 0x32, 0x6a, + 0xbf, 0x4b, 0x87, 0xcf, 0x32, 0x67, 0xbc, 0xa9, 0xca, 0x2d, 0x90, 0xeb, 0xae, 0x4d, 0xd5, 0xae, + 0x6e, 0xb4, 0x47, 0x65, 0xbc, 0x06, 0x51, 0xa3, 0xd7, 0x45, 0x11, 0x8b, 0xfc, 0x20, 0x8d, 0x5e, + 0x57, 0x3c, 0x48, 0xa3, 0xd7, 0x55, 0xde, 0x05, 0x82, 0x7c, 0xdb, 0xb4, 0x43, 0x5d, 0x7a, 0x5e, + 0xf5, 0x5f, 0x4a, 0x00, 0x7c, 0x20, 0xaf, 0x1a, 0xfb, 0xe6, 0x99, 0xf3, 0xcb, 0x0d, 0x48, 0xe0, + 0x89, 0x6a, 0x8d, 0x43, 0x13, 0xa3, 0x50, 0x2a, 0xcc, 0xf1, 0xc4, 0xc0, 0xe1, 0xfb, 0x66, 0x28, + 0x14, 0x21, 0x40, 0x19, 0x6b, 0x87, 0xaa, 0x8e, 0xcf, 0x1a, 0x0d, 0x58, 0x39, 0x3c, 0xca, 0x1a, + 0xa0, 0xca, 0x63, 0x58, 0x45, 0x57, 0xf7, 0x2c, 0x4d, 0x75, 0x83, 0xfa, 0xf8, 0x8e, 0xf8, 0x02, + 0x16, 0x8e, 0x86, 0x93, 0x0a, 0xf6, 0x39, 0xf2, 0x7f, 0x0f, 0xe4, 0xb2, 0xea, 0xb6, 0x0e, 0x26, + 0x69, 0xff, 0x18, 0x16, 0xf7, 0x55, 0xbd, 0xe3, 0x8f, 0x78, 0x7e, 0x4c, 0xca, 0x81, 0x15, 0x61, + 0x06, 0x1e, 0x56, 0x9c, 0xe5, 0x83, 0xd1, 0x38, 0x4d, 0x8a, 0xf8, 0xd0, 0xdf, 0x2d, 0x1c, 0x06, + 0xfe, 0x5b, 0xfe, 0x8e, 0x68, 0x3f, 0xdd, 0xdf, 0x30, 0xc3, 0x39, 0xfc, 0x4d, 0x40, 0xbc, 0x62, + 0x68, 0x0f, 0x55, 0xfb, 0x88, 0xda, 0xca, 0x17, 0x12, 0xac, 0x85, 0x6f, 0xc6, 0x43, 0xea, 0x38, + 0x6a, 0x9b, 0x92, 0x1f, 0x9e, 0xcf, 0xff, 0x7b, 0x33, 0xc1, 0x7b, 0x4b, 0x94, 0x1a, 0x9a, 0xf7, + 0x0f, 0xa9, 0x25, 0x64, 0x1b, 0xea, 0xe3, 0xf7, 0x8b, 0x8a, 0xd9, 0xf0, 0xde, 0x4c, 0x8d, 0xd1, + 0x97, 0xe7, 0x61, 0x8e, 0x1e, 0x53, 0xc3, 0xdd, 0xc8, 0x40, 0x42, 0x78, 0xc6, 0x27, 0x09, 0x98, + 0xf7, 0x96, 0xa9, 0x99, 0x8d, 0xab, 0x90, 0x10, 0xde, 0x7b, 0x49, 0x12, 0x16, 0x58, 0x7f, 0xbc, + 0x6b, 0xda, 0x6e, 0x6a, 0x86, 0xad, 0xee, 0x51, 0x55, 0xeb, 0x30, 0x52, 0x69, 0xe3, 0x37, 0x12, + 0x2c, 0xf8, 0x2f, 0x5c, 0x04, 0x20, 0xf6, 0xc1, 0x5e, 0x65, 0xaf, 0xb2, 0x9d, 0x9a, 0x61, 0x02, + 0x77, 0x2b, 0x3b, 0xdb, 0xd5, 0x9d, 0xbb, 0x29, 0x89, 0x2d, 0x6a, 0x7b, 0x3b, 0x3b, 0x6c, 0x11, + 0x21, 0x8b, 0x10, 0xaf, 0xef, 0x6d, 0x6d, 0x55, 0x2a, 0xdb, 0x95, 0xed, 0x54, 0x94, 0x31, 0xdd, + 0xb9, 0x5d, 0x7d, 0x50, 0xd9, 0x4e, 0xcd, 0x32, 0xba, 0xbd, 0x9d, 0xf7, 0x76, 0xde, 0xff, 0x68, + 0x27, 0x35, 0xc7, 0xe9, 0xca, 0x0f, 0xab, 0x8f, 0x1e, 0x55, 0xb6, 0x53, 0x31, 0x46, 0xf7, 0xa0, + 0x72, 0xbb, 0x5e, 0xd9, 0x4e, 0xcd, 0xb3, 0xad, 0xdd, 0x5a, 0xa5, 0xf2, 0x70, 0x97, 0x6d, 0x2d, + 0xb0, 0xe5, 0xd6, 0xed, 0x9d, 0xad, 0xca, 0x03, 0x26, 0x25, 0xbe, 0xf9, 0xc7, 0x05, 0x88, 0xf1, + 0x5e, 0x85, 0x7c, 0x08, 0xc0, 0xff, 0xc2, 0xeb, 0xba, 0x36, 0xf1, 0x89, 0x37, 0xb3, 0x3e, 0xb9, + 0xc1, 0x51, 0x2e, 0xfe, 0xf2, 0x4f, 0x7f, 0xfb, 0x6d, 0x64, 0x55, 0x59, 0x2a, 0x1d, 0x5f, 0x2b, + 0x1d, 0x9a, 0x4d, 0xef, 0x7f, 0xe1, 0x37, 0xa5, 0x0d, 0xf2, 0x11, 0x00, 0xcf, 0xbd, 0x61, 0xb9, + 0xa1, 0xf7, 0xce, 0xcc, 0x05, 0x84, 0xc7, 0x73, 0xf4, 0xb8, 0x60, 0x9e, 0x80, 0x99, 0xe0, 0x9f, + 0x41, 0x72, 0x28, 0xb8, 0x4e, 0x5d, 0x22, 0x0b, 0x4f, 0x98, 0x61, 0xe9, 0xeb, 0x63, 0x73, 0x78, + 0x85, 0x7d, 0x68, 0xe5, 0x32, 0x0a, 0x5f, 0x57, 0x56, 0x3c, 0xe1, 0x0e, 0x75, 0x05, 0xf9, 0x06, + 0xa4, 0xc4, 0xb6, 0x1a, 0xcd, 0xbf, 0x34, 0xb9, 0xe1, 0xe6, 0x6a, 0x2e, 0x9f, 0xd4, 0x8d, 0x2b, + 0x39, 0x54, 0x76, 0x51, 0x49, 0xfb, 0x9e, 0x08, 0x9d, 0x35, 0x65, 0xfa, 0xee, 0x42, 0x82, 0x5f, + 0x21, 0xde, 0xf3, 0x09, 0xf1, 0x3d, 0xd5, 0x81, 0x34, 0xca, 0x5c, 0x52, 0xe2, 0x4c, 0x26, 0x06, + 0x3b, 0x13, 0xd4, 0x82, 0xa4, 0x20, 0xc8, 0x21, 0x4b, 0x81, 0x24, 0x56, 0x47, 0x33, 0xaf, 0xe0, + 0x7a, 0xda, 0x4d, 0x57, 0xfe, 0x0f, 0x85, 0x66, 0x95, 0x8b, 0x4c, 0x68, 0x93, 0x51, 0x51, 0xad, + 0xc4, 0x1f, 0x26, 0xbc, 0xbb, 0xcf, 0x94, 0xec, 0x40, 0x82, 0x27, 0xb8, 0xb3, 0x5b, 0x7b, 0x09, + 0x05, 0xaf, 0x65, 0x52, 0x43, 0x6b, 0x4b, 0xbf, 0x60, 0x65, 0xe5, 0x33, 0xcf, 0x68, 0x41, 0xde, + 0xe9, 0x46, 0x87, 0xb3, 0xab, 0x6f, 0x74, 0x26, 0x64, 0x74, 0x0f, 0x69, 0x04, 0xa3, 0x7f, 0x0c, + 0x09, 0x5e, 0x2f, 0xb9, 0xd1, 0x17, 0x02, 0x1d, 0xa1, 0x32, 0x3a, 0xd5, 0x03, 0x19, 0xb5, 0x90, + 0x8d, 0x31, 0x0f, 0xc8, 0x1d, 0x58, 0xb8, 0x4b, 0x5d, 0x2e, 0x36, 0x1d, 0x88, 0x0d, 0xaa, 0x7a, + 0x46, 0x38, 0x21, 0x5f, 0x0e, 0x19, 0x97, 0xa3, 0x41, 0xdc, 0x97, 0xe3, 0x10, 0xee, 0xf3, 0xb4, + 0x3e, 0x21, 0x93, 0x99, 0xb0, 0xed, 0x25, 0x4b, 0x25, 0x83, 0x1a, 0xd2, 0x84, 0x88, 0xe7, 0xc1, + 0x0f, 0xe2, 0x2d, 0x89, 0xdc, 0x84, 0xd8, 0x3d, 0xfc, 0xe1, 0x06, 0x99, 0xe2, 0x69, 0x86, 0x5f, + 0x26, 0x4e, 0xb4, 0x75, 0x40, 0x5b, 0x47, 0xc3, 0xbc, 0xfe, 0xc9, 0x37, 0x7f, 0xcd, 0xce, 0x7c, + 0xfe, 0x34, 0x2b, 0x7d, 0xf5, 0x34, 0x2b, 0x7d, 0xfd, 0x34, 0x2b, 0xfd, 0xe5, 0x69, 0x56, 0xfa, + 0xe2, 0x59, 0x76, 0xe6, 0xeb, 0x67, 0xd9, 0x99, 0x6f, 0x9e, 0x65, 0x67, 0x7e, 0xf2, 0xff, 0xc2, + 0x6f, 0x49, 0x54, 0xbb, 0xab, 0x6a, 0xaa, 0x65, 0x9b, 0xac, 0x13, 0xf5, 0x56, 0x25, 0xef, 0xc7, + 0x23, 0x5f, 0x46, 0xd2, 0xb7, 0x11, 0xd8, 0xe5, 0xdb, 0xc5, 0xaa, 0x59, 0xbc, 0x6d, 0xe9, 0xcd, + 0x18, 0xda, 0xf2, 0xf6, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x60, 0xca, 0x90, 0x21, 0x59, 0x23, + 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/pkg/api/submit.proto b/pkg/api/submit.proto index 0044bc5a23d..160cafda737 100644 --- a/pkg/api/submit.proto +++ b/pkg/api/submit.proto @@ -94,6 +94,10 @@ enum JobState { SUCCEEDED = 3; FAILED = 4; UNKNOWN = 5; + SUBMITTED = 6; + LEASED = 7; + PREEMPTED = 8; + CANCELLED = 9; } message Job { diff --git a/scripts/build-python-client.sh b/scripts/build-python-client.sh index d8cf2143fa9..9e2bece9a24 100755 --- a/scripts/build-python-client.sh +++ b/scripts/build-python-client.sh @@ -3,7 +3,7 @@ # make the python package armada.client, not pkg.api mkdir -p proto/armada -cp pkg/api/event.proto pkg/api/submit.proto pkg/api/health.proto pkg/api/queryapi.proto proto/armada +cp pkg/api/event.proto pkg/api/submit.proto pkg/api/health.proto pkg/api/job.proto proto/armada sed -i 's/\([^\/]\)pkg\/api/\1armada/g' proto/armada/*.proto # generate python stubs @@ -11,7 +11,7 @@ cd proto python3 -m grpc_tools.protoc -I. --plugin=protoc-gen-mypy=$(which protoc-gen-mypy) --python_out=../client/python/armada_client --grpc_python_out=../client/python/armada_client --mypy_out=../client/python/armada_client \ google/api/annotations.proto \ google/api/http.proto \ - armada/event.proto armada/submit.proto armada/health.proto armada/queryapi.proto \ + armada/event.proto armada/submit.proto armada/health.proto armada/job.proto \ github.com/gogo/protobuf/gogoproto/gogo.proto \ k8s.io/api/core/v1/generated.proto \ k8s.io/apimachinery/pkg/api/resource/generated.proto \ From 921c19f33ab55f8b5242f184b8390b70fc31692d Mon Sep 17 00:00:00 2001 From: Chris Martin Date: Fri, 23 Feb 2024 11:58:06 +0000 Subject: [PATCH 2/2] New Python Client Release (#3420) --- client/python/pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/client/python/pyproject.toml b/client/python/pyproject.toml index 63f981e517c..5850c71e67b 100644 --- a/client/python/pyproject.toml +++ b/client/python/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "armada_client" -version = "0.2.8" +version = "0.2.9" description = "Armada gRPC API python client" readme = "README.md" requires-python = ">=3.7"