interprocess/commander/agrpc/commander.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: commander.proto

package agrpc

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	math "math"
)

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

type RespStatus struct {
	StatusCode           int32    `protobuf:"varint,1,opt,name=statusCode,proto3" json:"statusCode,omitempty"`
	ErrMessage           string   `protobuf:"bytes,2,opt,name=errMessage,proto3" json:"errMessage,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RespStatus) Reset()         { *m = RespStatus{} }
func (m *RespStatus) String() string { return proto.CompactTextString(m) }
func (*RespStatus) ProtoMessage()    {}
func (*RespStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{0}
}

func (m *RespStatus) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RespStatus.Unmarshal(m, b)
}
func (m *RespStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RespStatus.Marshal(b, m, deterministic)
}
func (m *RespStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RespStatus.Merge(m, src)
}
func (m *RespStatus) XXX_Size() int {
	return xxx_messageInfo_RespStatus.Size(m)
}
func (m *RespStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_RespStatus.DiscardUnknown(m)
}

var xxx_messageInfo_RespStatus proto.InternalMessageInfo

func (m *RespStatus) GetStatusCode() int32 {
	if m != nil {
		return m.StatusCode
	}
	return 0
}

func (m *RespStatus) GetErrMessage() string {
	if m != nil {
		return m.ErrMessage
	}
	return ""
}

type TaskError struct {
	ErrorCode            string   `protobuf:"bytes,1,opt,name=errorCode,proto3" json:"errorCode,omitempty"`
	ErrorSubCode         string   `protobuf:"bytes,2,opt,name=errorSubCode,proto3" json:"errorSubCode,omitempty"`
	ErrorMessage         string   `protobuf:"bytes,3,opt,name=errorMessage,proto3" json:"errorMessage,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskError) Reset()         { *m = TaskError{} }
func (m *TaskError) String() string { return proto.CompactTextString(m) }
func (*TaskError) ProtoMessage()    {}
func (*TaskError) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{1}
}

func (m *TaskError) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskError.Unmarshal(m, b)
}
func (m *TaskError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskError.Marshal(b, m, deterministic)
}
func (m *TaskError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskError.Merge(m, src)
}
func (m *TaskError) XXX_Size() int {
	return xxx_messageInfo_TaskError.Size(m)
}
func (m *TaskError) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskError.DiscardUnknown(m)
}

var xxx_messageInfo_TaskError proto.InternalMessageInfo

func (m *TaskError) GetErrorCode() string {
	if m != nil {
		return m.ErrorCode
	}
	return ""
}

func (m *TaskError) GetErrorSubCode() string {
	if m != nil {
		return m.ErrorSubCode
	}
	return ""
}

func (m *TaskError) GetErrorMessage() string {
	if m != nil {
		return m.ErrorMessage
	}
	return ""
}

type TaskOutput struct {
	Index                int32    `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	Output               string   `protobuf:"bytes,2,opt,name=output,proto3" json:"output,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskOutput) Reset()         { *m = TaskOutput{} }
func (m *TaskOutput) String() string { return proto.CompactTextString(m) }
func (*TaskOutput) ProtoMessage()    {}
func (*TaskOutput) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{2}
}

func (m *TaskOutput) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskOutput.Unmarshal(m, b)
}
func (m *TaskOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskOutput.Marshal(b, m, deterministic)
}
func (m *TaskOutput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskOutput.Merge(m, src)
}
func (m *TaskOutput) XXX_Size() int {
	return xxx_messageInfo_TaskOutput.Size(m)
}
func (m *TaskOutput) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskOutput.DiscardUnknown(m)
}

var xxx_messageInfo_TaskOutput proto.InternalMessageInfo

func (m *TaskOutput) GetIndex() int32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *TaskOutput) GetOutput() string {
	if m != nil {
		return m.Output
	}
	return ""
}

type TaskRes struct {
	ExitCode             int32      `protobuf:"varint,1,opt,name=exitCode,proto3" json:"exitCode,omitempty"`
	TaskStatus           int32      `protobuf:"varint,2,opt,name=taskStatus,proto3" json:"taskStatus,omitempty"`
	TaskError            *TaskError `protobuf:"bytes,3,opt,name=taskError,proto3" json:"taskError,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *TaskRes) Reset()         { *m = TaskRes{} }
func (m *TaskRes) String() string { return proto.CompactTextString(m) }
func (*TaskRes) ProtoMessage()    {}
func (*TaskRes) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{3}
}

func (m *TaskRes) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskRes.Unmarshal(m, b)
}
func (m *TaskRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskRes.Marshal(b, m, deterministic)
}
func (m *TaskRes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskRes.Merge(m, src)
}
func (m *TaskRes) XXX_Size() int {
	return xxx_messageInfo_TaskRes.Size(m)
}
func (m *TaskRes) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskRes.DiscardUnknown(m)
}

var xxx_messageInfo_TaskRes proto.InternalMessageInfo

func (m *TaskRes) GetExitCode() int32 {
	if m != nil {
		return m.ExitCode
	}
	return 0
}

func (m *TaskRes) GetTaskStatus() int32 {
	if m != nil {
		return m.TaskStatus
	}
	return 0
}

func (m *TaskRes) GetTaskError() *TaskError {
	if m != nil {
		return m.TaskError
	}
	return nil
}

type HandshakeReq struct {
	Endpoint             string   `protobuf:"bytes,1,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
	HandshakeToken       string   `protobuf:"bytes,2,opt,name=handshakeToken,proto3" json:"handshakeToken,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *HandshakeReq) Reset()         { *m = HandshakeReq{} }
func (m *HandshakeReq) String() string { return proto.CompactTextString(m) }
func (*HandshakeReq) ProtoMessage()    {}
func (*HandshakeReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{4}
}

func (m *HandshakeReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HandshakeReq.Unmarshal(m, b)
}
func (m *HandshakeReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HandshakeReq.Marshal(b, m, deterministic)
}
func (m *HandshakeReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HandshakeReq.Merge(m, src)
}
func (m *HandshakeReq) XXX_Size() int {
	return xxx_messageInfo_HandshakeReq.Size(m)
}
func (m *HandshakeReq) XXX_DiscardUnknown() {
	xxx_messageInfo_HandshakeReq.DiscardUnknown(m)
}

var xxx_messageInfo_HandshakeReq proto.InternalMessageInfo

func (m *HandshakeReq) GetEndpoint() string {
	if m != nil {
		return m.Endpoint
	}
	return ""
}

func (m *HandshakeReq) GetHandshakeToken() string {
	if m != nil {
		return m.HandshakeToken
	}
	return ""
}

type HandshakeResp struct {
	Status               *RespStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *HandshakeResp) Reset()         { *m = HandshakeResp{} }
func (m *HandshakeResp) String() string { return proto.CompactTextString(m) }
func (*HandshakeResp) ProtoMessage()    {}
func (*HandshakeResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{5}
}

func (m *HandshakeResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HandshakeResp.Unmarshal(m, b)
}
func (m *HandshakeResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HandshakeResp.Marshal(b, m, deterministic)
}
func (m *HandshakeResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HandshakeResp.Merge(m, src)
}
func (m *HandshakeResp) XXX_Size() int {
	return xxx_messageInfo_HandshakeResp.Size(m)
}
func (m *HandshakeResp) XXX_DiscardUnknown() {
	xxx_messageInfo_HandshakeResp.DiscardUnknown(m)
}

var xxx_messageInfo_HandshakeResp proto.InternalMessageInfo

func (m *HandshakeResp) GetStatus() *RespStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type PingReq struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PingReq) Reset()         { *m = PingReq{} }
func (m *PingReq) String() string { return proto.CompactTextString(m) }
func (*PingReq) ProtoMessage()    {}
func (*PingReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{6}
}

func (m *PingReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PingReq.Unmarshal(m, b)
}
func (m *PingReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PingReq.Marshal(b, m, deterministic)
}
func (m *PingReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PingReq.Merge(m, src)
}
func (m *PingReq) XXX_Size() int {
	return xxx_messageInfo_PingReq.Size(m)
}
func (m *PingReq) XXX_DiscardUnknown() {
	xxx_messageInfo_PingReq.DiscardUnknown(m)
}

var xxx_messageInfo_PingReq proto.InternalMessageInfo

type PingResp struct {
	Status               *RespStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *PingResp) Reset()         { *m = PingResp{} }
func (m *PingResp) String() string { return proto.CompactTextString(m) }
func (*PingResp) ProtoMessage()    {}
func (*PingResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{7}
}

func (m *PingResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PingResp.Unmarshal(m, b)
}
func (m *PingResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PingResp.Marshal(b, m, deterministic)
}
func (m *PingResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PingResp.Merge(m, src)
}
func (m *PingResp) XXX_Size() int {
	return xxx_messageInfo_PingResp.Size(m)
}
func (m *PingResp) XXX_DiscardUnknown() {
	xxx_messageInfo_PingResp.DiscardUnknown(m)
}

var xxx_messageInfo_PingResp proto.InternalMessageInfo

func (m *PingResp) GetStatus() *RespStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type ConnectFromAgentReq struct {
	SupportedApiVersion  string   `protobuf:"bytes,1,opt,name=SupportedApiVersion,proto3" json:"SupportedApiVersion,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ConnectFromAgentReq) Reset()         { *m = ConnectFromAgentReq{} }
func (m *ConnectFromAgentReq) String() string { return proto.CompactTextString(m) }
func (*ConnectFromAgentReq) ProtoMessage()    {}
func (*ConnectFromAgentReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{8}
}

func (m *ConnectFromAgentReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConnectFromAgentReq.Unmarshal(m, b)
}
func (m *ConnectFromAgentReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConnectFromAgentReq.Marshal(b, m, deterministic)
}
func (m *ConnectFromAgentReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnectFromAgentReq.Merge(m, src)
}
func (m *ConnectFromAgentReq) XXX_Size() int {
	return xxx_messageInfo_ConnectFromAgentReq.Size(m)
}
func (m *ConnectFromAgentReq) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnectFromAgentReq.DiscardUnknown(m)
}

var xxx_messageInfo_ConnectFromAgentReq proto.InternalMessageInfo

func (m *ConnectFromAgentReq) GetSupportedApiVersion() string {
	if m != nil {
		return m.SupportedApiVersion
	}
	return ""
}

type ConnectFromAgentResp struct {
	Status               *RespStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	ApiVersion           string      `protobuf:"bytes,2,opt,name=apiVersion,proto3" json:"apiVersion,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *ConnectFromAgentResp) Reset()         { *m = ConnectFromAgentResp{} }
func (m *ConnectFromAgentResp) String() string { return proto.CompactTextString(m) }
func (*ConnectFromAgentResp) ProtoMessage()    {}
func (*ConnectFromAgentResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{9}
}

func (m *ConnectFromAgentResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConnectFromAgentResp.Unmarshal(m, b)
}
func (m *ConnectFromAgentResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConnectFromAgentResp.Marshal(b, m, deterministic)
}
func (m *ConnectFromAgentResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnectFromAgentResp.Merge(m, src)
}
func (m *ConnectFromAgentResp) XXX_Size() int {
	return xxx_messageInfo_ConnectFromAgentResp.Size(m)
}
func (m *ConnectFromAgentResp) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnectFromAgentResp.DiscardUnknown(m)
}

var xxx_messageInfo_ConnectFromAgentResp proto.InternalMessageInfo

func (m *ConnectFromAgentResp) GetStatus() *RespStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *ConnectFromAgentResp) GetApiVersion() string {
	if m != nil {
		return m.ApiVersion
	}
	return ""
}

type PreCheckScriptReq struct {
	SubmissionId         string   `protobuf:"bytes,1,opt,name=submissionId,proto3" json:"submissionId,omitempty"`
	CommandType          string   `protobuf:"bytes,2,opt,name=commandType,proto3" json:"commandType,omitempty"`
	Timeout              int64    `protobuf:"varint,3,opt,name=timeout,proto3" json:"timeout,omitempty"`
	WorkingDir           string   `protobuf:"bytes,4,opt,name=workingDir,proto3" json:"workingDir,omitempty"`
	UserName             string   `protobuf:"bytes,5,opt,name=userName,proto3" json:"userName,omitempty"`
	Password             string   `protobuf:"bytes,6,opt,name=password,proto3" json:"password,omitempty"`
	Annotation           string   `protobuf:"bytes,7,opt,name=annotation,proto3" json:"annotation,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PreCheckScriptReq) Reset()         { *m = PreCheckScriptReq{} }
func (m *PreCheckScriptReq) String() string { return proto.CompactTextString(m) }
func (*PreCheckScriptReq) ProtoMessage()    {}
func (*PreCheckScriptReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{10}
}

func (m *PreCheckScriptReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PreCheckScriptReq.Unmarshal(m, b)
}
func (m *PreCheckScriptReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PreCheckScriptReq.Marshal(b, m, deterministic)
}
func (m *PreCheckScriptReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PreCheckScriptReq.Merge(m, src)
}
func (m *PreCheckScriptReq) XXX_Size() int {
	return xxx_messageInfo_PreCheckScriptReq.Size(m)
}
func (m *PreCheckScriptReq) XXX_DiscardUnknown() {
	xxx_messageInfo_PreCheckScriptReq.DiscardUnknown(m)
}

var xxx_messageInfo_PreCheckScriptReq proto.InternalMessageInfo

func (m *PreCheckScriptReq) GetSubmissionId() string {
	if m != nil {
		return m.SubmissionId
	}
	return ""
}

func (m *PreCheckScriptReq) GetCommandType() string {
	if m != nil {
		return m.CommandType
	}
	return ""
}

func (m *PreCheckScriptReq) GetTimeout() int64 {
	if m != nil {
		return m.Timeout
	}
	return 0
}

func (m *PreCheckScriptReq) GetWorkingDir() string {
	if m != nil {
		return m.WorkingDir
	}
	return ""
}

func (m *PreCheckScriptReq) GetUserName() string {
	if m != nil {
		return m.UserName
	}
	return ""
}

func (m *PreCheckScriptReq) GetPassword() string {
	if m != nil {
		return m.Password
	}
	return ""
}

func (m *PreCheckScriptReq) GetAnnotation() string {
	if m != nil {
		return m.Annotation
	}
	return ""
}

type PreCheckScriptResp struct {
	Status               *RespStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	ExtraLubanParams     string      `protobuf:"bytes,2,opt,name=extraLubanParams,proto3" json:"extraLubanParams,omitempty"`
	TaskError            *TaskError  `protobuf:"bytes,3,opt,name=taskError,proto3" json:"taskError,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *PreCheckScriptResp) Reset()         { *m = PreCheckScriptResp{} }
func (m *PreCheckScriptResp) String() string { return proto.CompactTextString(m) }
func (*PreCheckScriptResp) ProtoMessage()    {}
func (*PreCheckScriptResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{11}
}

func (m *PreCheckScriptResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PreCheckScriptResp.Unmarshal(m, b)
}
func (m *PreCheckScriptResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PreCheckScriptResp.Marshal(b, m, deterministic)
}
func (m *PreCheckScriptResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PreCheckScriptResp.Merge(m, src)
}
func (m *PreCheckScriptResp) XXX_Size() int {
	return xxx_messageInfo_PreCheckScriptResp.Size(m)
}
func (m *PreCheckScriptResp) XXX_DiscardUnknown() {
	xxx_messageInfo_PreCheckScriptResp.DiscardUnknown(m)
}

var xxx_messageInfo_PreCheckScriptResp proto.InternalMessageInfo

func (m *PreCheckScriptResp) GetStatus() *RespStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *PreCheckScriptResp) GetExtraLubanParams() string {
	if m != nil {
		return m.ExtraLubanParams
	}
	return ""
}

func (m *PreCheckScriptResp) GetTaskError() *TaskError {
	if m != nil {
		return m.TaskError
	}
	return nil
}

type PrepareScriptReq struct {
	SubmissionId         string   `protobuf:"bytes,1,opt,name=submissionId,proto3" json:"submissionId,omitempty"`
	Content              string   `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PrepareScriptReq) Reset()         { *m = PrepareScriptReq{} }
func (m *PrepareScriptReq) String() string { return proto.CompactTextString(m) }
func (*PrepareScriptReq) ProtoMessage()    {}
func (*PrepareScriptReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{12}
}

func (m *PrepareScriptReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PrepareScriptReq.Unmarshal(m, b)
}
func (m *PrepareScriptReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PrepareScriptReq.Marshal(b, m, deterministic)
}
func (m *PrepareScriptReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PrepareScriptReq.Merge(m, src)
}
func (m *PrepareScriptReq) XXX_Size() int {
	return xxx_messageInfo_PrepareScriptReq.Size(m)
}
func (m *PrepareScriptReq) XXX_DiscardUnknown() {
	xxx_messageInfo_PrepareScriptReq.DiscardUnknown(m)
}

var xxx_messageInfo_PrepareScriptReq proto.InternalMessageInfo

func (m *PrepareScriptReq) GetSubmissionId() string {
	if m != nil {
		return m.SubmissionId
	}
	return ""
}

func (m *PrepareScriptReq) GetContent() string {
	if m != nil {
		return m.Content
	}
	return ""
}

type PrepareScriptResp struct {
	Status               *RespStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	TaskError            *TaskError  `protobuf:"bytes,2,opt,name=taskError,proto3" json:"taskError,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *PrepareScriptResp) Reset()         { *m = PrepareScriptResp{} }
func (m *PrepareScriptResp) String() string { return proto.CompactTextString(m) }
func (*PrepareScriptResp) ProtoMessage()    {}
func (*PrepareScriptResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{13}
}

func (m *PrepareScriptResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PrepareScriptResp.Unmarshal(m, b)
}
func (m *PrepareScriptResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PrepareScriptResp.Marshal(b, m, deterministic)
}
func (m *PrepareScriptResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PrepareScriptResp.Merge(m, src)
}
func (m *PrepareScriptResp) XXX_Size() int {
	return xxx_messageInfo_PrepareScriptResp.Size(m)
}
func (m *PrepareScriptResp) XXX_DiscardUnknown() {
	xxx_messageInfo_PrepareScriptResp.DiscardUnknown(m)
}

var xxx_messageInfo_PrepareScriptResp proto.InternalMessageInfo

func (m *PrepareScriptResp) GetStatus() *RespStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *PrepareScriptResp) GetTaskError() *TaskError {
	if m != nil {
		return m.TaskError
	}
	return nil
}

type SubmitScriptReq struct {
	SubmissionId         string   `protobuf:"bytes,1,opt,name=submissionId,proto3" json:"submissionId,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SubmitScriptReq) Reset()         { *m = SubmitScriptReq{} }
func (m *SubmitScriptReq) String() string { return proto.CompactTextString(m) }
func (*SubmitScriptReq) ProtoMessage()    {}
func (*SubmitScriptReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{14}
}

func (m *SubmitScriptReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SubmitScriptReq.Unmarshal(m, b)
}
func (m *SubmitScriptReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SubmitScriptReq.Marshal(b, m, deterministic)
}
func (m *SubmitScriptReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubmitScriptReq.Merge(m, src)
}
func (m *SubmitScriptReq) XXX_Size() int {
	return xxx_messageInfo_SubmitScriptReq.Size(m)
}
func (m *SubmitScriptReq) XXX_DiscardUnknown() {
	xxx_messageInfo_SubmitScriptReq.DiscardUnknown(m)
}

var xxx_messageInfo_SubmitScriptReq proto.InternalMessageInfo

func (m *SubmitScriptReq) GetSubmissionId() string {
	if m != nil {
		return m.SubmissionId
	}
	return ""
}

type SubmitScriptResp struct {
	Status               *RespStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	TaskError            *TaskError  `protobuf:"bytes,2,opt,name=taskError,proto3" json:"taskError,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *SubmitScriptResp) Reset()         { *m = SubmitScriptResp{} }
func (m *SubmitScriptResp) String() string { return proto.CompactTextString(m) }
func (*SubmitScriptResp) ProtoMessage()    {}
func (*SubmitScriptResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{15}
}

func (m *SubmitScriptResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SubmitScriptResp.Unmarshal(m, b)
}
func (m *SubmitScriptResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SubmitScriptResp.Marshal(b, m, deterministic)
}
func (m *SubmitScriptResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubmitScriptResp.Merge(m, src)
}
func (m *SubmitScriptResp) XXX_Size() int {
	return xxx_messageInfo_SubmitScriptResp.Size(m)
}
func (m *SubmitScriptResp) XXX_DiscardUnknown() {
	xxx_messageInfo_SubmitScriptResp.DiscardUnknown(m)
}

var xxx_messageInfo_SubmitScriptResp proto.InternalMessageInfo

func (m *SubmitScriptResp) GetStatus() *RespStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *SubmitScriptResp) GetTaskError() *TaskError {
	if m != nil {
		return m.TaskError
	}
	return nil
}

type CancelSubmittedReq struct {
	SubmissionId         string   `protobuf:"bytes,1,opt,name=submissionId,proto3" json:"submissionId,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CancelSubmittedReq) Reset()         { *m = CancelSubmittedReq{} }
func (m *CancelSubmittedReq) String() string { return proto.CompactTextString(m) }
func (*CancelSubmittedReq) ProtoMessage()    {}
func (*CancelSubmittedReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{16}
}

func (m *CancelSubmittedReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CancelSubmittedReq.Unmarshal(m, b)
}
func (m *CancelSubmittedReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CancelSubmittedReq.Marshal(b, m, deterministic)
}
func (m *CancelSubmittedReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CancelSubmittedReq.Merge(m, src)
}
func (m *CancelSubmittedReq) XXX_Size() int {
	return xxx_messageInfo_CancelSubmittedReq.Size(m)
}
func (m *CancelSubmittedReq) XXX_DiscardUnknown() {
	xxx_messageInfo_CancelSubmittedReq.DiscardUnknown(m)
}

var xxx_messageInfo_CancelSubmittedReq proto.InternalMessageInfo

func (m *CancelSubmittedReq) GetSubmissionId() string {
	if m != nil {
		return m.SubmissionId
	}
	return ""
}

type CancelSubmittedResp struct {
	Status               *RespStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *CancelSubmittedResp) Reset()         { *m = CancelSubmittedResp{} }
func (m *CancelSubmittedResp) String() string { return proto.CompactTextString(m) }
func (*CancelSubmittedResp) ProtoMessage()    {}
func (*CancelSubmittedResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{17}
}

func (m *CancelSubmittedResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CancelSubmittedResp.Unmarshal(m, b)
}
func (m *CancelSubmittedResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CancelSubmittedResp.Marshal(b, m, deterministic)
}
func (m *CancelSubmittedResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CancelSubmittedResp.Merge(m, src)
}
func (m *CancelSubmittedResp) XXX_Size() int {
	return xxx_messageInfo_CancelSubmittedResp.Size(m)
}
func (m *CancelSubmittedResp) XXX_DiscardUnknown() {
	xxx_messageInfo_CancelSubmittedResp.DiscardUnknown(m)
}

var xxx_messageInfo_CancelSubmittedResp proto.InternalMessageInfo

func (m *CancelSubmittedResp) GetStatus() *RespStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type CleanUpSubmittedReq struct {
	SubmissionId         string   `protobuf:"bytes,1,opt,name=submissionId,proto3" json:"submissionId,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CleanUpSubmittedReq) Reset()         { *m = CleanUpSubmittedReq{} }
func (m *CleanUpSubmittedReq) String() string { return proto.CompactTextString(m) }
func (*CleanUpSubmittedReq) ProtoMessage()    {}
func (*CleanUpSubmittedReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{18}
}

func (m *CleanUpSubmittedReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CleanUpSubmittedReq.Unmarshal(m, b)
}
func (m *CleanUpSubmittedReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CleanUpSubmittedReq.Marshal(b, m, deterministic)
}
func (m *CleanUpSubmittedReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CleanUpSubmittedReq.Merge(m, src)
}
func (m *CleanUpSubmittedReq) XXX_Size() int {
	return xxx_messageInfo_CleanUpSubmittedReq.Size(m)
}
func (m *CleanUpSubmittedReq) XXX_DiscardUnknown() {
	xxx_messageInfo_CleanUpSubmittedReq.DiscardUnknown(m)
}

var xxx_messageInfo_CleanUpSubmittedReq proto.InternalMessageInfo

func (m *CleanUpSubmittedReq) GetSubmissionId() string {
	if m != nil {
		return m.SubmissionId
	}
	return ""
}

type CleanUpSubmittedResp struct {
	Status               *RespStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *CleanUpSubmittedResp) Reset()         { *m = CleanUpSubmittedResp{} }
func (m *CleanUpSubmittedResp) String() string { return proto.CompactTextString(m) }
func (*CleanUpSubmittedResp) ProtoMessage()    {}
func (*CleanUpSubmittedResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{19}
}

func (m *CleanUpSubmittedResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CleanUpSubmittedResp.Unmarshal(m, b)
}
func (m *CleanUpSubmittedResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CleanUpSubmittedResp.Marshal(b, m, deterministic)
}
func (m *CleanUpSubmittedResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CleanUpSubmittedResp.Merge(m, src)
}
func (m *CleanUpSubmittedResp) XXX_Size() int {
	return xxx_messageInfo_CleanUpSubmittedResp.Size(m)
}
func (m *CleanUpSubmittedResp) XXX_DiscardUnknown() {
	xxx_messageInfo_CleanUpSubmittedResp.DiscardUnknown(m)
}

var xxx_messageInfo_CleanUpSubmittedResp proto.InternalMessageInfo

func (m *CleanUpSubmittedResp) GetStatus() *RespStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type DisposeSubmissionReq struct {
	SubmissionId         string   `protobuf:"bytes,1,opt,name=submissionId,proto3" json:"submissionId,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DisposeSubmissionReq) Reset()         { *m = DisposeSubmissionReq{} }
func (m *DisposeSubmissionReq) String() string { return proto.CompactTextString(m) }
func (*DisposeSubmissionReq) ProtoMessage()    {}
func (*DisposeSubmissionReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{20}
}

func (m *DisposeSubmissionReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DisposeSubmissionReq.Unmarshal(m, b)
}
func (m *DisposeSubmissionReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DisposeSubmissionReq.Marshal(b, m, deterministic)
}
func (m *DisposeSubmissionReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DisposeSubmissionReq.Merge(m, src)
}
func (m *DisposeSubmissionReq) XXX_Size() int {
	return xxx_messageInfo_DisposeSubmissionReq.Size(m)
}
func (m *DisposeSubmissionReq) XXX_DiscardUnknown() {
	xxx_messageInfo_DisposeSubmissionReq.DiscardUnknown(m)
}

var xxx_messageInfo_DisposeSubmissionReq proto.InternalMessageInfo

func (m *DisposeSubmissionReq) GetSubmissionId() string {
	if m != nil {
		return m.SubmissionId
	}
	return ""
}

type DisposeSubmissionResp struct {
	Status               *RespStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *DisposeSubmissionResp) Reset()         { *m = DisposeSubmissionResp{} }
func (m *DisposeSubmissionResp) String() string { return proto.CompactTextString(m) }
func (*DisposeSubmissionResp) ProtoMessage()    {}
func (*DisposeSubmissionResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{21}
}

func (m *DisposeSubmissionResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DisposeSubmissionResp.Unmarshal(m, b)
}
func (m *DisposeSubmissionResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DisposeSubmissionResp.Marshal(b, m, deterministic)
}
func (m *DisposeSubmissionResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DisposeSubmissionResp.Merge(m, src)
}
func (m *DisposeSubmissionResp) XXX_Size() int {
	return xxx_messageInfo_DisposeSubmissionResp.Size(m)
}
func (m *DisposeSubmissionResp) XXX_DiscardUnknown() {
	xxx_messageInfo_DisposeSubmissionResp.DiscardUnknown(m)
}

var xxx_messageInfo_DisposeSubmissionResp proto.InternalMessageInfo

func (m *DisposeSubmissionResp) GetStatus() *RespStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type RegisterCommanderReq struct {
	PluginName           string   `protobuf:"bytes,1,opt,name=pluginName,proto3" json:"pluginName,omitempty"`
	HandshakeToken       string   `protobuf:"bytes,2,opt,name=handshakeToken,proto3" json:"handshakeToken,omitempty"`
	Endpoint             string   `protobuf:"bytes,3,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
	SupportedApiVersion  string   `protobuf:"bytes,4,opt,name=SupportedApiVersion,proto3" json:"SupportedApiVersion,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RegisterCommanderReq) Reset()         { *m = RegisterCommanderReq{} }
func (m *RegisterCommanderReq) String() string { return proto.CompactTextString(m) }
func (*RegisterCommanderReq) ProtoMessage()    {}
func (*RegisterCommanderReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{22}
}

func (m *RegisterCommanderReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RegisterCommanderReq.Unmarshal(m, b)
}
func (m *RegisterCommanderReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RegisterCommanderReq.Marshal(b, m, deterministic)
}
func (m *RegisterCommanderReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterCommanderReq.Merge(m, src)
}
func (m *RegisterCommanderReq) XXX_Size() int {
	return xxx_messageInfo_RegisterCommanderReq.Size(m)
}
func (m *RegisterCommanderReq) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterCommanderReq.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterCommanderReq proto.InternalMessageInfo

func (m *RegisterCommanderReq) GetPluginName() string {
	if m != nil {
		return m.PluginName
	}
	return ""
}

func (m *RegisterCommanderReq) GetHandshakeToken() string {
	if m != nil {
		return m.HandshakeToken
	}
	return ""
}

func (m *RegisterCommanderReq) GetEndpoint() string {
	if m != nil {
		return m.Endpoint
	}
	return ""
}

func (m *RegisterCommanderReq) GetSupportedApiVersion() string {
	if m != nil {
		return m.SupportedApiVersion
	}
	return ""
}

type RegisterCommanderResp struct {
	Status               *RespStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *RegisterCommanderResp) Reset()         { *m = RegisterCommanderResp{} }
func (m *RegisterCommanderResp) String() string { return proto.CompactTextString(m) }
func (*RegisterCommanderResp) ProtoMessage()    {}
func (*RegisterCommanderResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{23}
}

func (m *RegisterCommanderResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RegisterCommanderResp.Unmarshal(m, b)
}
func (m *RegisterCommanderResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RegisterCommanderResp.Marshal(b, m, deterministic)
}
func (m *RegisterCommanderResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterCommanderResp.Merge(m, src)
}
func (m *RegisterCommanderResp) XXX_Size() int {
	return xxx_messageInfo_RegisterCommanderResp.Size(m)
}
func (m *RegisterCommanderResp) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterCommanderResp.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterCommanderResp proto.InternalMessageInfo

func (m *RegisterCommanderResp) GetStatus() *RespStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type WriteSubmissionOutputReq struct {
	SubmissionId         string      `protobuf:"bytes,1,opt,name=submissionId,proto3" json:"submissionId,omitempty"`
	Output               *TaskOutput `protobuf:"bytes,2,opt,name=output,proto3" json:"output,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *WriteSubmissionOutputReq) Reset()         { *m = WriteSubmissionOutputReq{} }
func (m *WriteSubmissionOutputReq) String() string { return proto.CompactTextString(m) }
func (*WriteSubmissionOutputReq) ProtoMessage()    {}
func (*WriteSubmissionOutputReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{24}
}

func (m *WriteSubmissionOutputReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_WriteSubmissionOutputReq.Unmarshal(m, b)
}
func (m *WriteSubmissionOutputReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_WriteSubmissionOutputReq.Marshal(b, m, deterministic)
}
func (m *WriteSubmissionOutputReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WriteSubmissionOutputReq.Merge(m, src)
}
func (m *WriteSubmissionOutputReq) XXX_Size() int {
	return xxx_messageInfo_WriteSubmissionOutputReq.Size(m)
}
func (m *WriteSubmissionOutputReq) XXX_DiscardUnknown() {
	xxx_messageInfo_WriteSubmissionOutputReq.DiscardUnknown(m)
}

var xxx_messageInfo_WriteSubmissionOutputReq proto.InternalMessageInfo

func (m *WriteSubmissionOutputReq) GetSubmissionId() string {
	if m != nil {
		return m.SubmissionId
	}
	return ""
}

func (m *WriteSubmissionOutputReq) GetOutput() *TaskOutput {
	if m != nil {
		return m.Output
	}
	return nil
}

type WriteSubmissionOutputResp struct {
	Status               *RespStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *WriteSubmissionOutputResp) Reset()         { *m = WriteSubmissionOutputResp{} }
func (m *WriteSubmissionOutputResp) String() string { return proto.CompactTextString(m) }
func (*WriteSubmissionOutputResp) ProtoMessage()    {}
func (*WriteSubmissionOutputResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{25}
}

func (m *WriteSubmissionOutputResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_WriteSubmissionOutputResp.Unmarshal(m, b)
}
func (m *WriteSubmissionOutputResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_WriteSubmissionOutputResp.Marshal(b, m, deterministic)
}
func (m *WriteSubmissionOutputResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WriteSubmissionOutputResp.Merge(m, src)
}
func (m *WriteSubmissionOutputResp) XXX_Size() int {
	return xxx_messageInfo_WriteSubmissionOutputResp.Size(m)
}
func (m *WriteSubmissionOutputResp) XXX_DiscardUnknown() {
	xxx_messageInfo_WriteSubmissionOutputResp.DiscardUnknown(m)
}

var xxx_messageInfo_WriteSubmissionOutputResp proto.InternalMessageInfo

func (m *WriteSubmissionOutputResp) GetStatus() *RespStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type FinalizeSubmissionStatusReq struct {
	SubmissionId         string      `protobuf:"bytes,1,opt,name=submissionId,proto3" json:"submissionId,omitempty"`
	Output               *TaskOutput `protobuf:"bytes,2,opt,name=output,proto3" json:"output,omitempty"`
	Result               *TaskRes    `protobuf:"bytes,3,opt,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *FinalizeSubmissionStatusReq) Reset()         { *m = FinalizeSubmissionStatusReq{} }
func (m *FinalizeSubmissionStatusReq) String() string { return proto.CompactTextString(m) }
func (*FinalizeSubmissionStatusReq) ProtoMessage()    {}
func (*FinalizeSubmissionStatusReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{26}
}

func (m *FinalizeSubmissionStatusReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FinalizeSubmissionStatusReq.Unmarshal(m, b)
}
func (m *FinalizeSubmissionStatusReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FinalizeSubmissionStatusReq.Marshal(b, m, deterministic)
}
func (m *FinalizeSubmissionStatusReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FinalizeSubmissionStatusReq.Merge(m, src)
}
func (m *FinalizeSubmissionStatusReq) XXX_Size() int {
	return xxx_messageInfo_FinalizeSubmissionStatusReq.Size(m)
}
func (m *FinalizeSubmissionStatusReq) XXX_DiscardUnknown() {
	xxx_messageInfo_FinalizeSubmissionStatusReq.DiscardUnknown(m)
}

var xxx_messageInfo_FinalizeSubmissionStatusReq proto.InternalMessageInfo

func (m *FinalizeSubmissionStatusReq) GetSubmissionId() string {
	if m != nil {
		return m.SubmissionId
	}
	return ""
}

func (m *FinalizeSubmissionStatusReq) GetOutput() *TaskOutput {
	if m != nil {
		return m.Output
	}
	return nil
}

func (m *FinalizeSubmissionStatusReq) GetResult() *TaskRes {
	if m != nil {
		return m.Result
	}
	return nil
}

type FinalizeSubmissionStatusResp struct {
	Status               *RespStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *FinalizeSubmissionStatusResp) Reset()         { *m = FinalizeSubmissionStatusResp{} }
func (m *FinalizeSubmissionStatusResp) String() string { return proto.CompactTextString(m) }
func (*FinalizeSubmissionStatusResp) ProtoMessage()    {}
func (*FinalizeSubmissionStatusResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_36bf467611423882, []int{27}
}

func (m *FinalizeSubmissionStatusResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FinalizeSubmissionStatusResp.Unmarshal(m, b)
}
func (m *FinalizeSubmissionStatusResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FinalizeSubmissionStatusResp.Marshal(b, m, deterministic)
}
func (m *FinalizeSubmissionStatusResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FinalizeSubmissionStatusResp.Merge(m, src)
}
func (m *FinalizeSubmissionStatusResp) XXX_Size() int {
	return xxx_messageInfo_FinalizeSubmissionStatusResp.Size(m)
}
func (m *FinalizeSubmissionStatusResp) XXX_DiscardUnknown() {
	xxx_messageInfo_FinalizeSubmissionStatusResp.DiscardUnknown(m)
}

var xxx_messageInfo_FinalizeSubmissionStatusResp proto.InternalMessageInfo

func (m *FinalizeSubmissionStatusResp) GetStatus() *RespStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

func init() {
	proto.RegisterType((*RespStatus)(nil), "commander.RespStatus")
	proto.RegisterType((*TaskError)(nil), "commander.TaskError")
	proto.RegisterType((*TaskOutput)(nil), "commander.TaskOutput")
	proto.RegisterType((*TaskRes)(nil), "commander.TaskRes")
	proto.RegisterType((*HandshakeReq)(nil), "commander.HandshakeReq")
	proto.RegisterType((*HandshakeResp)(nil), "commander.HandshakeResp")
	proto.RegisterType((*PingReq)(nil), "commander.PingReq")
	proto.RegisterType((*PingResp)(nil), "commander.PingResp")
	proto.RegisterType((*ConnectFromAgentReq)(nil), "commander.ConnectFromAgentReq")
	proto.RegisterType((*ConnectFromAgentResp)(nil), "commander.ConnectFromAgentResp")
	proto.RegisterType((*PreCheckScriptReq)(nil), "commander.PreCheckScriptReq")
	proto.RegisterType((*PreCheckScriptResp)(nil), "commander.PreCheckScriptResp")
	proto.RegisterType((*PrepareScriptReq)(nil), "commander.PrepareScriptReq")
	proto.RegisterType((*PrepareScriptResp)(nil), "commander.PrepareScriptResp")
	proto.RegisterType((*SubmitScriptReq)(nil), "commander.SubmitScriptReq")
	proto.RegisterType((*SubmitScriptResp)(nil), "commander.SubmitScriptResp")
	proto.RegisterType((*CancelSubmittedReq)(nil), "commander.CancelSubmittedReq")
	proto.RegisterType((*CancelSubmittedResp)(nil), "commander.CancelSubmittedResp")
	proto.RegisterType((*CleanUpSubmittedReq)(nil), "commander.CleanUpSubmittedReq")
	proto.RegisterType((*CleanUpSubmittedResp)(nil), "commander.CleanUpSubmittedResp")
	proto.RegisterType((*DisposeSubmissionReq)(nil), "commander.DisposeSubmissionReq")
	proto.RegisterType((*DisposeSubmissionResp)(nil), "commander.DisposeSubmissionResp")
	proto.RegisterType((*RegisterCommanderReq)(nil), "commander.RegisterCommanderReq")
	proto.RegisterType((*RegisterCommanderResp)(nil), "commander.RegisterCommanderResp")
	proto.RegisterType((*WriteSubmissionOutputReq)(nil), "commander.WriteSubmissionOutputReq")
	proto.RegisterType((*WriteSubmissionOutputResp)(nil), "commander.WriteSubmissionOutputResp")
	proto.RegisterType((*FinalizeSubmissionStatusReq)(nil), "commander.FinalizeSubmissionStatusReq")
	proto.RegisterType((*FinalizeSubmissionStatusResp)(nil), "commander.FinalizeSubmissionStatusResp")
}

func init() {
	proto.RegisterFile("commander.proto", fileDescriptor_36bf467611423882)
}

var fileDescriptor_36bf467611423882 = []byte{
	// 1034 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0xdd, 0x6e, 0x1b, 0x45,
	0x14, 0xae, 0x93, 0xd8, 0xae, 0x4f, 0xd2, 0x26, 0x19, 0x3b, 0xb0, 0x6c, 0x42, 0x88, 0x16, 0x54,
	0xaa, 0x4a, 0x6d, 0xc0, 0x08, 0x89, 0xf6, 0x02, 0x11, 0x9c, 0x04, 0x8a, 0x52, 0x6a, 0xad, 0x53,
	0xa8, 0xb8, 0xa9, 0xc6, 0xde, 0x23, 0x67, 0x64, 0x7b, 0x76, 0x33, 0x33, 0x4b, 0x13, 0x9e, 0x85,
	0x3b, 0x6e, 0x79, 0x04, 0xae, 0x79, 0x19, 0x5e, 0x02, 0xed, 0xec, 0x8f, 0x67, 0xed, 0xb5, 0xf1,
	0x22, 0xc1, 0x55, 0x7c, 0xfe, 0xbf, 0x6f, 0xce, 0xec, 0x39, 0x13, 0xd8, 0x1e, 0xf8, 0x93, 0x09,
	0xe5, 0x1e, 0x8a, 0x27, 0x81, 0xf0, 0x95, 0x4f, 0x1a, 0x99, 0xc2, 0xb9, 0x00, 0x70, 0x51, 0x06,
	0x3d, 0x45, 0x55, 0x28, 0xc9, 0x21, 0x80, 0xd4, 0xbf, 0x3a, 0xbe, 0x87, 0x56, 0xe5, 0xa8, 0xf2,
	0xb0, 0xea, 0x1a, 0x9a, 0xc8, 0x8e, 0x42, 0xbc, 0x40, 0x29, 0xe9, 0x10, 0xad, 0xb5, 0xa3, 0xca,
	0xc3, 0x86, 0x6b, 0x68, 0x9c, 0x6b, 0x68, 0x5c, 0x52, 0x39, 0x3a, 0x13, 0xc2, 0x17, 0xe4, 0x00,
	0x1a, 0x18, 0xfd, 0xc8, 0x72, 0x35, 0xdc, 0xa9, 0x82, 0x38, 0xb0, 0xa5, 0x85, 0x5e, 0xd8, 0xd7,
	0x0e, 0x71, 0xb2, 0x9c, 0x2e, 0xf3, 0x49, 0x0b, 0xae, 0x1b, 0x3e, 0x69, 0xc9, 0x67, 0x00, 0x51,
	0xc9, 0x97, 0xa1, 0x0a, 0x42, 0x45, 0x5a, 0x50, 0x65, 0xdc, 0xc3, 0x9b, 0x04, 0x7b, 0x2c, 0x90,
	0x77, 0xa0, 0xe6, 0x6b, 0x7b, 0x52, 0x25, 0x91, 0x9c, 0x5b, 0xa8, 0x47, 0xb1, 0x2e, 0x4a, 0x62,
	0xc3, 0x5d, 0xbc, 0x61, 0xca, 0xe0, 0x9d, 0xc9, 0x11, 0x6b, 0x45, 0xe5, 0x28, 0x3e, 0x23, 0x9d,
	0xa2, 0xea, 0x1a, 0x1a, 0xd2, 0x86, 0x86, 0x4a, 0x59, 0x6b, 0x8c, 0x9b, 0xed, 0xd6, 0x93, 0xe9,
	0x99, 0x67, 0x27, 0xe2, 0x4e, 0xdd, 0x1c, 0x17, 0xb6, 0xbe, 0xa5, 0xdc, 0x93, 0x57, 0x74, 0x84,
	0x2e, 0x5e, 0xeb, 0xfa, 0xdc, 0x0b, 0x7c, 0xc6, 0x55, 0x72, 0x56, 0x99, 0x4c, 0x1e, 0xc0, 0xfd,
	0xab, 0xd4, 0xf7, 0xd2, 0x1f, 0x21, 0x4f, 0x68, 0xcc, 0x68, 0x9d, 0x2f, 0xe1, 0x9e, 0x91, 0x53,
	0x06, 0xe4, 0x31, 0xd4, 0xe2, 0xe6, 0xe9, 0x94, 0x9b, 0xed, 0x3d, 0x03, 0xd5, 0xb4, 0xeb, 0x6e,
	0xe2, 0xe4, 0x34, 0xa0, 0xde, 0x65, 0x7c, 0xe8, 0xe2, 0xb5, 0xf3, 0x14, 0xee, 0xc6, 0x3f, 0xcb,
	0x67, 0xf9, 0x06, 0x9a, 0x1d, 0x9f, 0x73, 0x1c, 0xa8, 0x73, 0xe1, 0x4f, 0x4e, 0x86, 0xc8, 0x55,
	0x44, 0xf0, 0x13, 0x68, 0xf6, 0xc2, 0x20, 0xf0, 0x85, 0x42, 0xef, 0x24, 0x60, 0x3f, 0xa0, 0x90,
	0xcc, 0xe7, 0x09, 0xd7, 0x22, 0x93, 0x83, 0xd0, 0x9a, 0x4f, 0x54, 0x1a, 0x4f, 0xd4, 0x3d, 0x3a,
	0xad, 0x97, 0xdc, 0xd9, 0xa9, 0xc6, 0xf9, 0xab, 0x02, 0xbb, 0x5d, 0x81, 0x9d, 0x2b, 0x1c, 0x8c,
	0x7a, 0x03, 0xc1, 0x02, 0x0d, 0xd7, 0x81, 0x2d, 0x19, 0xf6, 0x27, 0x4c, 0x46, 0x3e, 0xcf, 0xbd,
	0x04, 0x67, 0x4e, 0x47, 0x8e, 0x60, 0x33, 0xa9, 0x7c, 0x79, 0x1b, 0xa4, 0x37, 0xd8, 0x54, 0x11,
	0x0b, 0xea, 0x8a, 0x4d, 0xd0, 0x0f, 0x95, 0xbe, 0x17, 0xeb, 0x6e, 0x2a, 0x46, 0xa8, 0xde, 0xfa,
	0x62, 0xc4, 0xf8, 0xf0, 0x94, 0x09, 0x6b, 0x23, 0x46, 0x35, 0xd5, 0x44, 0xf7, 0x21, 0x94, 0x28,
	0xbe, 0xa7, 0x13, 0xb4, 0xaa, 0xf1, 0x7d, 0x48, 0xe5, 0xc8, 0x16, 0x50, 0x29, 0xdf, 0xfa, 0xc2,
	0xb3, 0x6a, 0xb1, 0x2d, 0x95, 0x35, 0x5b, 0xce, 0x7d, 0x45, 0x55, 0xc4, 0xb6, 0x9e, 0xb0, 0xcd,
	0x34, 0xce, 0x6f, 0x15, 0x20, 0xb3, 0x6c, 0xcb, 0x9f, 0xe9, 0x23, 0xd8, 0xc1, 0x1b, 0x25, 0xe8,
	0x45, 0xd8, 0xa7, 0xbc, 0x4b, 0x05, 0x9d, 0xc8, 0x84, 0xfe, 0x9c, 0xfe, 0x5f, 0x7d, 0x1d, 0x5d,
	0xd8, 0xe9, 0x0a, 0x0c, 0xa8, 0xc0, 0x72, 0x1d, 0xb1, 0xa0, 0x3e, 0xf0, 0xb9, 0x42, 0x9e, 0x7e,
	0xe9, 0xa9, 0xe8, 0xfc, 0xac, 0x9b, 0x6c, 0x66, 0x2c, 0xcf, 0x3a, 0xc7, 0x64, 0x6d, 0x35, 0x26,
	0x9f, 0xc3, 0x76, 0x2f, 0x42, 0xa8, 0x4a, 0x11, 0x71, 0x42, 0xd8, 0xc9, 0x87, 0xfd, 0x3f, 0x68,
	0xbf, 0x00, 0xd2, 0xa1, 0x7c, 0x80, 0xe3, 0xb8, 0xb8, 0x42, 0x6f, 0x55, 0xc0, 0xa7, 0xd0, 0x9c,
	0x8b, 0x2c, 0x3f, 0x3b, 0x9e, 0x42, 0xb3, 0x33, 0x46, 0xca, 0x5f, 0x05, 0xa5, 0x01, 0x9c, 0x41,
	0x6b, 0x3e, 0xb4, 0x3c, 0x82, 0x67, 0xd0, 0x3a, 0x65, 0x32, 0xf0, 0x25, 0xf6, 0xb2, 0xec, 0xab,
	0x42, 0x38, 0x87, 0xbd, 0x82, 0xd8, 0xf2, 0x18, 0x7e, 0xaf, 0x40, 0xcb, 0xc5, 0x21, 0x93, 0x0a,
	0x45, 0x27, 0x75, 0x8c, 0x40, 0x1c, 0x02, 0x04, 0xe3, 0x70, 0xc8, 0xb8, 0x1e, 0x0b, 0x31, 0x04,
	0x43, 0xb3, 0xea, 0xa2, 0xc8, 0x2d, 0x9b, 0xf5, 0x99, 0x65, 0xb3, 0x60, 0x4e, 0x6f, 0x2c, 0x9e,
	0xd3, 0xe7, 0xb0, 0x57, 0x80, 0xb6, 0x3c, 0xed, 0x09, 0x58, 0x3f, 0x0a, 0xa6, 0x8c, 0xc3, 0x8b,
	0x97, 0xfa, 0xaa, 0x1f, 0xff, 0xe3, 0xdc, 0x96, 0xcf, 0x97, 0x9b, 0x3e, 0x11, 0xb2, 0xe5, 0xff,
	0x1d, 0xbc, 0xb7, 0xa0, 0x5c, 0x79, 0xe8, 0xbf, 0x56, 0x60, 0xff, 0x9c, 0x71, 0x3a, 0x66, 0xbf,
	0x18, 0xf9, 0x12, 0xa7, 0xff, 0x04, 0x3e, 0x79, 0x04, 0x35, 0x81, 0x32, 0x1c, 0xab, 0x64, 0xa6,
	0x92, 0x19, 0x77, 0x17, 0xa5, 0x9b, 0x78, 0x38, 0x2f, 0xe0, 0x60, 0x31, 0xba, 0xd2, 0x6c, 0xdb,
	0x7f, 0x56, 0xa1, 0x91, 0x75, 0x9a, 0x7c, 0x05, 0x8d, 0xec, 0xd5, 0x41, 0xde, 0x35, 0x22, 0xcd,
	0xf7, 0x8d, 0x6d, 0x15, 0x1b, 0x64, 0xe0, 0xdc, 0x21, 0x9f, 0xc2, 0x46, 0xf4, 0xd8, 0x20, 0x26,
	0x85, 0xe4, 0x21, 0x62, 0x37, 0xe7, 0x74, 0x3a, 0xe4, 0x15, 0xec, 0xcc, 0xbe, 0x0d, 0xc8, 0xa1,
	0xe1, 0x5a, 0xf0, 0x02, 0xb1, 0x3f, 0x58, 0x6a, 0xd7, 0x69, 0x5f, 0xc2, 0xfd, 0xfc, 0x72, 0x24,
	0x07, 0x66, 0xfd, 0xd9, 0x57, 0x82, 0xfd, 0xfe, 0x12, 0xab, 0x4e, 0x78, 0x01, 0xf7, 0x72, 0x6b,
	0x87, 0xec, 0xe7, 0x23, 0x72, 0x2b, 0xce, 0x3e, 0x58, 0x6c, 0xd4, 0xd9, 0x9e, 0xc3, 0x96, 0xb9,
	0x15, 0x88, 0x6d, 0xf8, 0xcf, 0x6c, 0x19, 0x7b, 0x7f, 0xa1, 0x4d, 0xa7, 0x72, 0x61, 0x7b, 0x66,
	0x5e, 0x13, 0x93, 0xcc, 0xfc, 0x16, 0xb0, 0x0f, 0x97, 0x99, 0xb3, 0xa6, 0xcc, 0x8c, 0xe0, 0x7c,
	0x53, 0xe6, 0x47, 0x7b, 0xbe, 0x29, 0x05, 0xf3, 0xdb, 0xb9, 0x43, 0x5e, 0xc3, 0xee, 0xdc, 0x58,
	0x25, 0x66, 0x5c, 0xd1, 0xc0, 0xb6, 0x8f, 0x96, 0x3b, 0x44, 0x99, 0xdb, 0x7f, 0xac, 0xc1, 0xe6,
	0x89, 0x94, 0x4c, 0xaa, 0xf8, 0x06, 0xbd, 0x86, 0xdd, 0xb9, 0x49, 0x96, 0xab, 0x54, 0x34, 0x95,
	0x73, 0x95, 0x0a, 0x07, 0xa1, 0x73, 0x87, 0x78, 0xb0, 0x57, 0x38, 0x6c, 0xc8, 0x87, 0x46, 0xf0,
	0xa2, 0xe9, 0x67, 0x7f, 0xf4, 0xcf, 0x4e, 0xba, 0xca, 0x04, 0xac, 0x45, 0xdf, 0x39, 0x79, 0x60,
	0xe4, 0x58, 0x32, 0xaa, 0xec, 0x8f, 0x57, 0xf2, 0x8b, 0xca, 0x7d, 0x7d, 0xf6, 0x53, 0x67, 0xc8,
	0xd4, 0x55, 0xd8, 0x8f, 0x42, 0x8e, 0xe9, 0x98, 0xdd, 0x86, 0x3c, 0xf9, 0xf3, 0x86, 0xea, 0x63,
	0x7d, 0x33, 0x18, 0x33, 0xe4, 0xea, 0x98, 0x71, 0x85, 0x22, 0x10, 0xfe, 0x00, 0xa5, 0x3c, 0xce,
	0xf2, 0x1f, 0xd3, 0xa1, 0x08, 0x06, 0xfd, 0x9a, 0xfe, 0xa7, 0xf4, 0xb3, 0xbf, 0x03, 0x00, 0x00,
	0xff, 0xff, 0x24, 0x44, 0x76, 0x29, 0xa7, 0x0e, 0x00, 0x00,
}