runner.pb.go

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

package runner

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	empty "github.com/golang/protobuf/ptypes/empty"
	grpc "google.golang.org/grpc"
	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 LogResponseMsg_Container_Request_Line_Source int32

const (
	LogResponseMsg_Container_Request_Line_STDOUT LogResponseMsg_Container_Request_Line_Source = 0
	LogResponseMsg_Container_Request_Line_STDERR LogResponseMsg_Container_Request_Line_Source = 1
)

var LogResponseMsg_Container_Request_Line_Source_name = map[int32]string{
	0: "STDOUT",
	1: "STDERR",
}

var LogResponseMsg_Container_Request_Line_Source_value = map[string]int32{
	"STDOUT": 0,
	"STDERR": 1,
}

func (x LogResponseMsg_Container_Request_Line_Source) String() string {
	return proto.EnumName(LogResponseMsg_Container_Request_Line_Source_name, int32(x))
}

func (LogResponseMsg_Container_Request_Line_Source) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_48eceea7e2abc593, []int{12, 0, 0, 0, 0}
}

// Request to allocate a slot for a call
type TryCall struct {
	ModelsCallJson       string            `protobuf:"bytes,1,opt,name=models_call_json,json=modelsCallJson,proto3" json:"models_call_json,omitempty"`
	SlotHashId           string            `protobuf:"bytes,2,opt,name=slot_hash_id,json=slotHashId,proto3" json:"slot_hash_id,omitempty"`
	Extensions           map[string]string `protobuf:"bytes,3,rep,name=extensions,proto3" json:"extensions,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_TryCall proto.InternalMessageInfo

func (m *TryCall) GetModelsCallJson() string {
	if m != nil {
		return m.ModelsCallJson
	}
	return ""
}

func (m *TryCall) GetSlotHashId() string {
	if m != nil {
		return m.SlotHashId
	}
	return ""
}

func (m *TryCall) GetExtensions() map[string]string {
	if m != nil {
		return m.Extensions
	}
	return nil
}

// Data sent C2S and S2C - as soon as the runner sees the first of these it
// will start running. If empty content, there must be one of these with eof.
// The runner will send these for the body of the response, AFTER it has sent
// a CallEnding message.
type DataFrame struct {
	Data                 []byte   `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	Eof                  bool     `protobuf:"varint,2,opt,name=eof,proto3" json:"eof,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DataFrame proto.InternalMessageInfo

func (m *DataFrame) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *DataFrame) GetEof() bool {
	if m != nil {
		return m.Eof
	}
	return false
}

type HttpHeader struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_HttpHeader proto.InternalMessageInfo

func (m *HttpHeader) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *HttpHeader) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type HttpRespMeta struct {
	StatusCode           int32         `protobuf:"varint,1,opt,name=status_code,json=statusCode,proto3" json:"status_code,omitempty"`
	Headers              []*HttpHeader `protobuf:"bytes,2,rep,name=headers,proto3" json:"headers,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_HttpRespMeta proto.InternalMessageInfo

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

func (m *HttpRespMeta) GetHeaders() []*HttpHeader {
	if m != nil {
		return m.Headers
	}
	return nil
}

// Call has started to finish - data might not be here yet and it will be sent
// as DataFrames.
type CallResultStart struct {
	// Types that are valid to be assigned to Meta:
	//	*CallResultStart_Http
	Meta                 isCallResultStart_Meta `protobuf_oneof:"meta"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

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

var xxx_messageInfo_CallResultStart proto.InternalMessageInfo

type isCallResultStart_Meta interface {
	isCallResultStart_Meta()
}

type CallResultStart_Http struct {
	Http *HttpRespMeta `protobuf:"bytes,100,opt,name=http,proto3,oneof"`
}

func (*CallResultStart_Http) isCallResultStart_Meta() {}

func (m *CallResultStart) GetMeta() isCallResultStart_Meta {
	if m != nil {
		return m.Meta
	}
	return nil
}

func (m *CallResultStart) GetHttp() *HttpRespMeta {
	if x, ok := m.GetMeta().(*CallResultStart_Http); ok {
		return x.Http
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*CallResultStart) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*CallResultStart_Http)(nil),
	}
}

// Call has really finished, it might have completed or crashed
type CallFinished struct {
	Success              bool     `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	Details              string   `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"`
	ErrorCode            int32    `protobuf:"varint,3,opt,name=errorCode,proto3" json:"errorCode,omitempty"`
	ErrorStr             string   `protobuf:"bytes,4,opt,name=errorStr,proto3" json:"errorStr,omitempty"`
	CreatedAt            string   `protobuf:"bytes,5,opt,name=createdAt,proto3" json:"createdAt,omitempty"`
	StartedAt            string   `protobuf:"bytes,6,opt,name=startedAt,proto3" json:"startedAt,omitempty"`
	CompletedAt          string   `protobuf:"bytes,7,opt,name=completedAt,proto3" json:"completedAt,omitempty"`
	SchedulerDuration    int64    `protobuf:"varint,8,opt,name=schedulerDuration,proto3" json:"schedulerDuration,omitempty"`
	ExecutionDuration    int64    `protobuf:"varint,9,opt,name=executionDuration,proto3" json:"executionDuration,omitempty"`
	ErrorUser            bool     `protobuf:"varint,10,opt,name=errorUser,proto3" json:"errorUser,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CallFinished proto.InternalMessageInfo

func (m *CallFinished) GetSuccess() bool {
	if m != nil {
		return m.Success
	}
	return false
}

func (m *CallFinished) GetDetails() string {
	if m != nil {
		return m.Details
	}
	return ""
}

func (m *CallFinished) GetErrorCode() int32 {
	if m != nil {
		return m.ErrorCode
	}
	return 0
}

func (m *CallFinished) GetErrorStr() string {
	if m != nil {
		return m.ErrorStr
	}
	return ""
}

func (m *CallFinished) GetCreatedAt() string {
	if m != nil {
		return m.CreatedAt
	}
	return ""
}

func (m *CallFinished) GetStartedAt() string {
	if m != nil {
		return m.StartedAt
	}
	return ""
}

func (m *CallFinished) GetCompletedAt() string {
	if m != nil {
		return m.CompletedAt
	}
	return ""
}

func (m *CallFinished) GetSchedulerDuration() int64 {
	if m != nil {
		return m.SchedulerDuration
	}
	return 0
}

func (m *CallFinished) GetExecutionDuration() int64 {
	if m != nil {
		return m.ExecutionDuration
	}
	return 0
}

func (m *CallFinished) GetErrorUser() bool {
	if m != nil {
		return m.ErrorUser
	}
	return false
}

type ClientMsg struct {
	// Types that are valid to be assigned to Body:
	//	*ClientMsg_Try
	//	*ClientMsg_Data
	Body                 isClientMsg_Body `protobuf_oneof:"body"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

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

var xxx_messageInfo_ClientMsg proto.InternalMessageInfo

type isClientMsg_Body interface {
	isClientMsg_Body()
}

type ClientMsg_Try struct {
	Try *TryCall `protobuf:"bytes,1,opt,name=try,proto3,oneof"`
}

type ClientMsg_Data struct {
	Data *DataFrame `protobuf:"bytes,2,opt,name=data,proto3,oneof"`
}

func (*ClientMsg_Try) isClientMsg_Body() {}

func (*ClientMsg_Data) isClientMsg_Body() {}

func (m *ClientMsg) GetBody() isClientMsg_Body {
	if m != nil {
		return m.Body
	}
	return nil
}

func (m *ClientMsg) GetTry() *TryCall {
	if x, ok := m.GetBody().(*ClientMsg_Try); ok {
		return x.Try
	}
	return nil
}

func (m *ClientMsg) GetData() *DataFrame {
	if x, ok := m.GetBody().(*ClientMsg_Data); ok {
		return x.Data
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ClientMsg) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ClientMsg_Try)(nil),
		(*ClientMsg_Data)(nil),
	}
}

type RunnerMsg struct {
	// Types that are valid to be assigned to Body:
	//	*RunnerMsg_ResultStart
	//	*RunnerMsg_Data
	//	*RunnerMsg_Finished
	Body                 isRunnerMsg_Body `protobuf_oneof:"body"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

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

var xxx_messageInfo_RunnerMsg proto.InternalMessageInfo

type isRunnerMsg_Body interface {
	isRunnerMsg_Body()
}

type RunnerMsg_ResultStart struct {
	ResultStart *CallResultStart `protobuf:"bytes,1,opt,name=result_start,json=resultStart,proto3,oneof"`
}

type RunnerMsg_Data struct {
	Data *DataFrame `protobuf:"bytes,2,opt,name=data,proto3,oneof"`
}

type RunnerMsg_Finished struct {
	Finished *CallFinished `protobuf:"bytes,3,opt,name=finished,proto3,oneof"`
}

func (*RunnerMsg_ResultStart) isRunnerMsg_Body() {}

func (*RunnerMsg_Data) isRunnerMsg_Body() {}

func (*RunnerMsg_Finished) isRunnerMsg_Body() {}

func (m *RunnerMsg) GetBody() isRunnerMsg_Body {
	if m != nil {
		return m.Body
	}
	return nil
}

func (m *RunnerMsg) GetResultStart() *CallResultStart {
	if x, ok := m.GetBody().(*RunnerMsg_ResultStart); ok {
		return x.ResultStart
	}
	return nil
}

func (m *RunnerMsg) GetData() *DataFrame {
	if x, ok := m.GetBody().(*RunnerMsg_Data); ok {
		return x.Data
	}
	return nil
}

func (m *RunnerMsg) GetFinished() *CallFinished {
	if x, ok := m.GetBody().(*RunnerMsg_Finished); ok {
		return x.Finished
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*RunnerMsg) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*RunnerMsg_ResultStart)(nil),
		(*RunnerMsg_Data)(nil),
		(*RunnerMsg_Finished)(nil),
	}
}

type RunnerStatus struct {
	Active               int32    `protobuf:"varint,2,opt,name=active,proto3" json:"active,omitempty"`
	Failed               bool     `protobuf:"varint,3,opt,name=failed,proto3" json:"failed,omitempty"`
	Id                   string   `protobuf:"bytes,4,opt,name=id,proto3" json:"id,omitempty"`
	Details              string   `protobuf:"bytes,5,opt,name=details,proto3" json:"details,omitempty"`
	ErrorCode            int32    `protobuf:"varint,6,opt,name=errorCode,proto3" json:"errorCode,omitempty"`
	ErrorStr             string   `protobuf:"bytes,7,opt,name=errorStr,proto3" json:"errorStr,omitempty"`
	CreatedAt            string   `protobuf:"bytes,8,opt,name=createdAt,proto3" json:"createdAt,omitempty"`
	StartedAt            string   `protobuf:"bytes,9,opt,name=startedAt,proto3" json:"startedAt,omitempty"`
	CompletedAt          string   `protobuf:"bytes,10,opt,name=completedAt,proto3" json:"completedAt,omitempty"`
	Cached               bool     `protobuf:"varint,11,opt,name=cached,proto3" json:"cached,omitempty"`
	RequestsReceived     uint64   `protobuf:"varint,12,opt,name=requestsReceived,proto3" json:"requestsReceived,omitempty"`
	RequestsHandled      uint64   `protobuf:"varint,13,opt,name=requestsHandled,proto3" json:"requestsHandled,omitempty"`
	KdumpsOnDisk         uint64   `protobuf:"varint,14,opt,name=kdumpsOnDisk,proto3" json:"kdumpsOnDisk,omitempty"`
	SchedulerDuration    int64    `protobuf:"varint,15,opt,name=schedulerDuration,proto3" json:"schedulerDuration,omitempty"`
	ExecutionDuration    int64    `protobuf:"varint,16,opt,name=executionDuration,proto3" json:"executionDuration,omitempty"`
	IsNetworkDisabled    bool     `protobuf:"varint,17,opt,name=isNetworkDisabled,proto3" json:"isNetworkDisabled,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_RunnerStatus proto.InternalMessageInfo

func (m *RunnerStatus) GetActive() int32 {
	if m != nil {
		return m.Active
	}
	return 0
}

func (m *RunnerStatus) GetFailed() bool {
	if m != nil {
		return m.Failed
	}
	return false
}

func (m *RunnerStatus) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *RunnerStatus) GetDetails() string {
	if m != nil {
		return m.Details
	}
	return ""
}

func (m *RunnerStatus) GetErrorCode() int32 {
	if m != nil {
		return m.ErrorCode
	}
	return 0
}

func (m *RunnerStatus) GetErrorStr() string {
	if m != nil {
		return m.ErrorStr
	}
	return ""
}

func (m *RunnerStatus) GetCreatedAt() string {
	if m != nil {
		return m.CreatedAt
	}
	return ""
}

func (m *RunnerStatus) GetStartedAt() string {
	if m != nil {
		return m.StartedAt
	}
	return ""
}

func (m *RunnerStatus) GetCompletedAt() string {
	if m != nil {
		return m.CompletedAt
	}
	return ""
}

func (m *RunnerStatus) GetCached() bool {
	if m != nil {
		return m.Cached
	}
	return false
}

func (m *RunnerStatus) GetRequestsReceived() uint64 {
	if m != nil {
		return m.RequestsReceived
	}
	return 0
}

func (m *RunnerStatus) GetRequestsHandled() uint64 {
	if m != nil {
		return m.RequestsHandled
	}
	return 0
}

func (m *RunnerStatus) GetKdumpsOnDisk() uint64 {
	if m != nil {
		return m.KdumpsOnDisk
	}
	return 0
}

func (m *RunnerStatus) GetSchedulerDuration() int64 {
	if m != nil {
		return m.SchedulerDuration
	}
	return 0
}

func (m *RunnerStatus) GetExecutionDuration() int64 {
	if m != nil {
		return m.ExecutionDuration
	}
	return 0
}

func (m *RunnerStatus) GetIsNetworkDisabled() bool {
	if m != nil {
		return m.IsNetworkDisabled
	}
	return false
}

type ConfigMsg struct {
	Config               map[string]string `protobuf:"bytes,1,rep,name=config,proto3" json:"config,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_ConfigMsg proto.InternalMessageInfo

func (m *ConfigMsg) GetConfig() map[string]string {
	if m != nil {
		return m.Config
	}
	return nil
}

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

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

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

var xxx_messageInfo_ConfigStatus proto.InternalMessageInfo

// Collector to Runner messages
type LogRequestMsg struct {
	// Types that are valid to be assigned to Body:
	//	*LogRequestMsg_Start_
	//	*LogRequestMsg_Ack_
	Body                 isLogRequestMsg_Body `protobuf_oneof:"body"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_LogRequestMsg proto.InternalMessageInfo

type isLogRequestMsg_Body interface {
	isLogRequestMsg_Body()
}

type LogRequestMsg_Start_ struct {
	Start *LogRequestMsg_Start `protobuf:"bytes,1,opt,name=start,proto3,oneof"`
}

type LogRequestMsg_Ack_ struct {
	Ack *LogRequestMsg_Ack `protobuf:"bytes,2,opt,name=ack,proto3,oneof"`
}

func (*LogRequestMsg_Start_) isLogRequestMsg_Body() {}

func (*LogRequestMsg_Ack_) isLogRequestMsg_Body() {}

func (m *LogRequestMsg) GetBody() isLogRequestMsg_Body {
	if m != nil {
		return m.Body
	}
	return nil
}

func (m *LogRequestMsg) GetStart() *LogRequestMsg_Start {
	if x, ok := m.GetBody().(*LogRequestMsg_Start_); ok {
		return x.Start
	}
	return nil
}

func (m *LogRequestMsg) GetAck() *LogRequestMsg_Ack {
	if x, ok := m.GetBody().(*LogRequestMsg_Ack_); ok {
		return x.Ack
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*LogRequestMsg) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*LogRequestMsg_Start_)(nil),
		(*LogRequestMsg_Ack_)(nil),
	}
}

// Initial Logging session message sent by Collectors to Runners
type LogRequestMsg_Start struct {
	Config               map[string]string `protobuf:"bytes,1,rep,name=config,proto3" json:"config,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_LogRequestMsg_Start proto.InternalMessageInfo

func (m *LogRequestMsg_Start) GetConfig() map[string]string {
	if m != nil {
		return m.Config
	}
	return nil
}

// Acknowledgement and re-enable stream message sent by Collectors to Runners
type LogRequestMsg_Ack struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_LogRequestMsg_Ack proto.InternalMessageInfo

// Runners to Collectors
type LogResponseMsg struct {
	Data                 []*LogResponseMsg_Container `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

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

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

var xxx_messageInfo_LogResponseMsg proto.InternalMessageInfo

func (m *LogResponseMsg) GetData() []*LogResponseMsg_Container {
	if m != nil {
		return m.Data
	}
	return nil
}

// Per container log data
type LogResponseMsg_Container struct {
	ApplicationId        string                              `protobuf:"bytes,1,opt,name=applicationId,proto3" json:"applicationId,omitempty"`
	FunctionId           string                              `protobuf:"bytes,2,opt,name=functionId,proto3" json:"functionId,omitempty"`
	ContainerId          string                              `protobuf:"bytes,3,opt,name=containerId,proto3" json:"containerId,omitempty"`
	Data                 []*LogResponseMsg_Container_Request `protobuf:"bytes,4,rep,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                            `json:"-"`
	XXX_unrecognized     []byte                              `json:"-"`
	XXX_sizecache        int32                               `json:"-"`
}

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

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

var xxx_messageInfo_LogResponseMsg_Container proto.InternalMessageInfo

func (m *LogResponseMsg_Container) GetApplicationId() string {
	if m != nil {
		return m.ApplicationId
	}
	return ""
}

func (m *LogResponseMsg_Container) GetFunctionId() string {
	if m != nil {
		return m.FunctionId
	}
	return ""
}

func (m *LogResponseMsg_Container) GetContainerId() string {
	if m != nil {
		return m.ContainerId
	}
	return ""
}

func (m *LogResponseMsg_Container) GetData() []*LogResponseMsg_Container_Request {
	if m != nil {
		return m.Data
	}
	return nil
}

// Per request log data
type LogResponseMsg_Container_Request struct {
	RequestId            string                                   `protobuf:"bytes,1,opt,name=requestId,proto3" json:"requestId,omitempty"`
	Data                 []*LogResponseMsg_Container_Request_Line `protobuf:"bytes,2,rep,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                 `json:"-"`
	XXX_unrecognized     []byte                                   `json:"-"`
	XXX_sizecache        int32                                    `json:"-"`
}

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

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

var xxx_messageInfo_LogResponseMsg_Container_Request proto.InternalMessageInfo

func (m *LogResponseMsg_Container_Request) GetRequestId() string {
	if m != nil {
		return m.RequestId
	}
	return ""
}

func (m *LogResponseMsg_Container_Request) GetData() []*LogResponseMsg_Container_Request_Line {
	if m != nil {
		return m.Data
	}
	return nil
}

// Log lines
type LogResponseMsg_Container_Request_Line struct {
	Timestamp            string                                       `protobuf:"bytes,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	Source               LogResponseMsg_Container_Request_Line_Source `protobuf:"varint,2,opt,name=source,proto3,enum=LogResponseMsg_Container_Request_Line_Source" json:"source,omitempty"`
	Data                 []byte                                       `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                     `json:"-"`
	XXX_unrecognized     []byte                                       `json:"-"`
	XXX_sizecache        int32                                        `json:"-"`
}

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

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

var xxx_messageInfo_LogResponseMsg_Container_Request_Line proto.InternalMessageInfo

func (m *LogResponseMsg_Container_Request_Line) GetTimestamp() string {
	if m != nil {
		return m.Timestamp
	}
	return ""
}

func (m *LogResponseMsg_Container_Request_Line) GetSource() LogResponseMsg_Container_Request_Line_Source {
	if m != nil {
		return m.Source
	}
	return LogResponseMsg_Container_Request_Line_STDOUT
}

func (m *LogResponseMsg_Container_Request_Line) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func init() {
	proto.RegisterEnum("LogResponseMsg_Container_Request_Line_Source", LogResponseMsg_Container_Request_Line_Source_name, LogResponseMsg_Container_Request_Line_Source_value)
	proto.RegisterType((*TryCall)(nil), "TryCall")
	proto.RegisterMapType((map[string]string)(nil), "TryCall.ExtensionsEntry")
	proto.RegisterType((*DataFrame)(nil), "DataFrame")
	proto.RegisterType((*HttpHeader)(nil), "HttpHeader")
	proto.RegisterType((*HttpRespMeta)(nil), "HttpRespMeta")
	proto.RegisterType((*CallResultStart)(nil), "CallResultStart")
	proto.RegisterType((*CallFinished)(nil), "CallFinished")
	proto.RegisterType((*ClientMsg)(nil), "ClientMsg")
	proto.RegisterType((*RunnerMsg)(nil), "RunnerMsg")
	proto.RegisterType((*RunnerStatus)(nil), "RunnerStatus")
	proto.RegisterType((*ConfigMsg)(nil), "ConfigMsg")
	proto.RegisterMapType((map[string]string)(nil), "ConfigMsg.ConfigEntry")
	proto.RegisterType((*ConfigStatus)(nil), "ConfigStatus")
	proto.RegisterType((*LogRequestMsg)(nil), "LogRequestMsg")
	proto.RegisterType((*LogRequestMsg_Start)(nil), "LogRequestMsg.Start")
	proto.RegisterMapType((map[string]string)(nil), "LogRequestMsg.Start.ConfigEntry")
	proto.RegisterType((*LogRequestMsg_Ack)(nil), "LogRequestMsg.Ack")
	proto.RegisterType((*LogResponseMsg)(nil), "LogResponseMsg")
	proto.RegisterType((*LogResponseMsg_Container)(nil), "LogResponseMsg.Container")
	proto.RegisterType((*LogResponseMsg_Container_Request)(nil), "LogResponseMsg.Container.Request")
	proto.RegisterType((*LogResponseMsg_Container_Request_Line)(nil), "LogResponseMsg.Container.Request.Line")
}

func init() { proto.RegisterFile("runner.proto", fileDescriptor_48eceea7e2abc593) }

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

// RunnerProtocolClient is the client API for RunnerProtocol service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RunnerProtocolClient interface {
	Engage(ctx context.Context, opts ...grpc.CallOption) (RunnerProtocol_EngageClient, error)
	// Rather than rely on Prometheus for this, expose status that's specific to the runner lifecycle through this.
	Status(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*RunnerStatus, error)
	// Configure the remote runner by passing config data.
	ConfigureRunner(ctx context.Context, in *ConfigMsg, opts ...grpc.CallOption) (*ConfigStatus, error)
	// Logging Interface
	StreamLogs(ctx context.Context, opts ...grpc.CallOption) (RunnerProtocol_StreamLogsClient, error)
}

type runnerProtocolClient struct {
	cc *grpc.ClientConn
}

func NewRunnerProtocolClient(cc *grpc.ClientConn) RunnerProtocolClient {
	return &runnerProtocolClient{cc}
}

func (c *runnerProtocolClient) Engage(ctx context.Context, opts ...grpc.CallOption) (RunnerProtocol_EngageClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RunnerProtocol_serviceDesc.Streams[0], "/RunnerProtocol/Engage", opts...)
	if err != nil {
		return nil, err
	}
	x := &runnerProtocolEngageClient{stream}
	return x, nil
}

type RunnerProtocol_EngageClient interface {
	Send(*ClientMsg) error
	Recv() (*RunnerMsg, error)
	grpc.ClientStream
}

type runnerProtocolEngageClient struct {
	grpc.ClientStream
}

func (x *runnerProtocolEngageClient) Send(m *ClientMsg) error {
	return x.ClientStream.SendMsg(m)
}

func (x *runnerProtocolEngageClient) Recv() (*RunnerMsg, error) {
	m := new(RunnerMsg)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *runnerProtocolClient) Status(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*RunnerStatus, error) {
	out := new(RunnerStatus)
	err := c.cc.Invoke(ctx, "/RunnerProtocol/Status", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerProtocolClient) ConfigureRunner(ctx context.Context, in *ConfigMsg, opts ...grpc.CallOption) (*ConfigStatus, error) {
	out := new(ConfigStatus)
	err := c.cc.Invoke(ctx, "/RunnerProtocol/ConfigureRunner", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runnerProtocolClient) StreamLogs(ctx context.Context, opts ...grpc.CallOption) (RunnerProtocol_StreamLogsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RunnerProtocol_serviceDesc.Streams[1], "/RunnerProtocol/StreamLogs", opts...)
	if err != nil {
		return nil, err
	}
	x := &runnerProtocolStreamLogsClient{stream}
	return x, nil
}

type RunnerProtocol_StreamLogsClient interface {
	Send(*LogRequestMsg) error
	Recv() (*LogResponseMsg, error)
	grpc.ClientStream
}

type runnerProtocolStreamLogsClient struct {
	grpc.ClientStream
}

func (x *runnerProtocolStreamLogsClient) Send(m *LogRequestMsg) error {
	return x.ClientStream.SendMsg(m)
}

func (x *runnerProtocolStreamLogsClient) Recv() (*LogResponseMsg, error) {
	m := new(LogResponseMsg)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// RunnerProtocolServer is the server API for RunnerProtocol service.
type RunnerProtocolServer interface {
	Engage(RunnerProtocol_EngageServer) error
	// Rather than rely on Prometheus for this, expose status that's specific to the runner lifecycle through this.
	Status(context.Context, *empty.Empty) (*RunnerStatus, error)
	// Configure the remote runner by passing config data.
	ConfigureRunner(context.Context, *ConfigMsg) (*ConfigStatus, error)
	// Logging Interface
	StreamLogs(RunnerProtocol_StreamLogsServer) error
}

func RegisterRunnerProtocolServer(s *grpc.Server, srv RunnerProtocolServer) {
	s.RegisterService(&_RunnerProtocol_serviceDesc, srv)
}

func _RunnerProtocol_Engage_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RunnerProtocolServer).Engage(&runnerProtocolEngageServer{stream})
}

type RunnerProtocol_EngageServer interface {
	Send(*RunnerMsg) error
	Recv() (*ClientMsg, error)
	grpc.ServerStream
}

type runnerProtocolEngageServer struct {
	grpc.ServerStream
}

func (x *runnerProtocolEngageServer) Send(m *RunnerMsg) error {
	return x.ServerStream.SendMsg(m)
}

func (x *runnerProtocolEngageServer) Recv() (*ClientMsg, error) {
	m := new(ClientMsg)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _RunnerProtocol_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerProtocolServer).Status(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/RunnerProtocol/Status",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerProtocolServer).Status(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunnerProtocol_ConfigureRunner_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConfigMsg)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunnerProtocolServer).ConfigureRunner(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/RunnerProtocol/ConfigureRunner",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunnerProtocolServer).ConfigureRunner(ctx, req.(*ConfigMsg))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunnerProtocol_StreamLogs_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RunnerProtocolServer).StreamLogs(&runnerProtocolStreamLogsServer{stream})
}

type RunnerProtocol_StreamLogsServer interface {
	Send(*LogResponseMsg) error
	Recv() (*LogRequestMsg, error)
	grpc.ServerStream
}

type runnerProtocolStreamLogsServer struct {
	grpc.ServerStream
}

func (x *runnerProtocolStreamLogsServer) Send(m *LogResponseMsg) error {
	return x.ServerStream.SendMsg(m)
}

func (x *runnerProtocolStreamLogsServer) Recv() (*LogRequestMsg, error) {
	m := new(LogRequestMsg)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _RunnerProtocol_serviceDesc = grpc.ServiceDesc{
	ServiceName: "RunnerProtocol",
	HandlerType: (*RunnerProtocolServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Status",
			Handler:    _RunnerProtocol_Status_Handler,
		},
		{
			MethodName: "ConfigureRunner",
			Handler:    _RunnerProtocol_ConfigureRunner_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Engage",
			Handler:       _RunnerProtocol_Engage_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "StreamLogs",
			Handler:       _RunnerProtocol_StreamLogs_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "runner.proto",
}