mirror of
https://github.com/criyle/go-judge.git
synced 2025-09-26 22:39:12 +08:00
1469 lines
37 KiB
Go
1469 lines
37 KiB
Go
// Code generated by protoc-gen-go. DO NOT EDIT.
|
|
// versions:
|
|
// protoc-gen-go v1.36.6
|
|
// protoc v6.31.1
|
|
// source: request.proto
|
|
|
|
//go:build !protoopaque
|
|
|
|
package pb
|
|
|
|
import (
|
|
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
|
|
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
|
|
_ "google.golang.org/protobuf/types/gofeaturespb"
|
|
emptypb "google.golang.org/protobuf/types/known/emptypb"
|
|
reflect "reflect"
|
|
unsafe "unsafe"
|
|
)
|
|
|
|
const (
|
|
// Verify that this generated code is sufficiently up-to-date.
|
|
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
|
|
// Verify that runtime/protoimpl is sufficiently up-to-date.
|
|
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
|
|
)
|
|
|
|
type Request struct {
|
|
state protoimpl.MessageState `protogen:"hybrid.v1"`
|
|
RequestID string `protobuf:"bytes,1,opt,name=requestID" json:"requestID,omitempty"`
|
|
Cmd []*Request_CmdType `protobuf:"bytes,2,rep,name=cmd" json:"cmd,omitempty"`
|
|
PipeMapping []*Request_PipeMap `protobuf:"bytes,3,rep,name=pipeMapping" json:"pipeMapping,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Request) Reset() {
|
|
*x = Request{}
|
|
mi := &file_request_proto_msgTypes[0]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Request) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Request) ProtoMessage() {}
|
|
|
|
func (x *Request) ProtoReflect() protoreflect.Message {
|
|
mi := &file_request_proto_msgTypes[0]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
func (x *Request) GetRequestID() string {
|
|
if x != nil {
|
|
return x.RequestID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Request) GetCmd() []*Request_CmdType {
|
|
if x != nil {
|
|
return x.Cmd
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request) GetPipeMapping() []*Request_PipeMap {
|
|
if x != nil {
|
|
return x.PipeMapping
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request) SetRequestID(v string) {
|
|
x.RequestID = v
|
|
}
|
|
|
|
func (x *Request) SetCmd(v []*Request_CmdType) {
|
|
x.Cmd = v
|
|
}
|
|
|
|
func (x *Request) SetPipeMapping(v []*Request_PipeMap) {
|
|
x.PipeMapping = v
|
|
}
|
|
|
|
type Request_builder struct {
|
|
_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.
|
|
|
|
RequestID string
|
|
Cmd []*Request_CmdType
|
|
PipeMapping []*Request_PipeMap
|
|
}
|
|
|
|
func (b0 Request_builder) Build() *Request {
|
|
m0 := &Request{}
|
|
b, x := &b0, m0
|
|
_, _ = b, x
|
|
x.RequestID = b.RequestID
|
|
x.Cmd = b.Cmd
|
|
x.PipeMapping = b.PipeMapping
|
|
return m0
|
|
}
|
|
|
|
type Request_LocalFile struct {
|
|
state protoimpl.MessageState `protogen:"hybrid.v1"`
|
|
Src string `protobuf:"bytes,1,opt,name=src" json:"src,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Request_LocalFile) Reset() {
|
|
*x = Request_LocalFile{}
|
|
mi := &file_request_proto_msgTypes[1]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Request_LocalFile) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Request_LocalFile) ProtoMessage() {}
|
|
|
|
func (x *Request_LocalFile) ProtoReflect() protoreflect.Message {
|
|
mi := &file_request_proto_msgTypes[1]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
func (x *Request_LocalFile) GetSrc() string {
|
|
if x != nil {
|
|
return x.Src
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Request_LocalFile) SetSrc(v string) {
|
|
x.Src = v
|
|
}
|
|
|
|
type Request_LocalFile_builder struct {
|
|
_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.
|
|
|
|
Src string
|
|
}
|
|
|
|
func (b0 Request_LocalFile_builder) Build() *Request_LocalFile {
|
|
m0 := &Request_LocalFile{}
|
|
b, x := &b0, m0
|
|
_, _ = b, x
|
|
x.Src = b.Src
|
|
return m0
|
|
}
|
|
|
|
type Request_MemoryFile struct {
|
|
state protoimpl.MessageState `protogen:"hybrid.v1"`
|
|
Content []byte `protobuf:"bytes,1,opt,name=content" json:"content,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Request_MemoryFile) Reset() {
|
|
*x = Request_MemoryFile{}
|
|
mi := &file_request_proto_msgTypes[2]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Request_MemoryFile) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Request_MemoryFile) ProtoMessage() {}
|
|
|
|
func (x *Request_MemoryFile) ProtoReflect() protoreflect.Message {
|
|
mi := &file_request_proto_msgTypes[2]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
func (x *Request_MemoryFile) GetContent() []byte {
|
|
if x != nil {
|
|
return x.Content
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request_MemoryFile) SetContent(v []byte) {
|
|
if v == nil {
|
|
v = []byte{}
|
|
}
|
|
x.Content = v
|
|
}
|
|
|
|
type Request_MemoryFile_builder struct {
|
|
_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.
|
|
|
|
Content []byte
|
|
}
|
|
|
|
func (b0 Request_MemoryFile_builder) Build() *Request_MemoryFile {
|
|
m0 := &Request_MemoryFile{}
|
|
b, x := &b0, m0
|
|
_, _ = b, x
|
|
x.Content = b.Content
|
|
return m0
|
|
}
|
|
|
|
type Request_CachedFile struct {
|
|
state protoimpl.MessageState `protogen:"hybrid.v1"`
|
|
FileID string `protobuf:"bytes,1,opt,name=fileID" json:"fileID,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Request_CachedFile) Reset() {
|
|
*x = Request_CachedFile{}
|
|
mi := &file_request_proto_msgTypes[3]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Request_CachedFile) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Request_CachedFile) ProtoMessage() {}
|
|
|
|
func (x *Request_CachedFile) ProtoReflect() protoreflect.Message {
|
|
mi := &file_request_proto_msgTypes[3]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
func (x *Request_CachedFile) GetFileID() string {
|
|
if x != nil {
|
|
return x.FileID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Request_CachedFile) SetFileID(v string) {
|
|
x.FileID = v
|
|
}
|
|
|
|
type Request_CachedFile_builder struct {
|
|
_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.
|
|
|
|
FileID string
|
|
}
|
|
|
|
func (b0 Request_CachedFile_builder) Build() *Request_CachedFile {
|
|
m0 := &Request_CachedFile{}
|
|
b, x := &b0, m0
|
|
_, _ = b, x
|
|
x.FileID = b.FileID
|
|
return m0
|
|
}
|
|
|
|
type Request_PipeCollector struct {
|
|
state protoimpl.MessageState `protogen:"hybrid.v1"`
|
|
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
|
|
Max int64 `protobuf:"varint,2,opt,name=max" json:"max,omitempty"`
|
|
Pipe bool `protobuf:"varint,3,opt,name=pipe" json:"pipe,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Request_PipeCollector) Reset() {
|
|
*x = Request_PipeCollector{}
|
|
mi := &file_request_proto_msgTypes[4]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Request_PipeCollector) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Request_PipeCollector) ProtoMessage() {}
|
|
|
|
func (x *Request_PipeCollector) ProtoReflect() protoreflect.Message {
|
|
mi := &file_request_proto_msgTypes[4]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
func (x *Request_PipeCollector) GetName() string {
|
|
if x != nil {
|
|
return x.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Request_PipeCollector) GetMax() int64 {
|
|
if x != nil {
|
|
return x.Max
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Request_PipeCollector) GetPipe() bool {
|
|
if x != nil {
|
|
return x.Pipe
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *Request_PipeCollector) SetName(v string) {
|
|
x.Name = v
|
|
}
|
|
|
|
func (x *Request_PipeCollector) SetMax(v int64) {
|
|
x.Max = v
|
|
}
|
|
|
|
func (x *Request_PipeCollector) SetPipe(v bool) {
|
|
x.Pipe = v
|
|
}
|
|
|
|
type Request_PipeCollector_builder struct {
|
|
_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.
|
|
|
|
Name string
|
|
Max int64
|
|
Pipe bool
|
|
}
|
|
|
|
func (b0 Request_PipeCollector_builder) Build() *Request_PipeCollector {
|
|
m0 := &Request_PipeCollector{}
|
|
b, x := &b0, m0
|
|
_, _ = b, x
|
|
x.Name = b.Name
|
|
x.Max = b.Max
|
|
x.Pipe = b.Pipe
|
|
return m0
|
|
}
|
|
|
|
type Request_File struct {
|
|
state protoimpl.MessageState `protogen:"hybrid.v1"`
|
|
// Types that are valid to be assigned to File:
|
|
//
|
|
// *Request_File_Local
|
|
// *Request_File_Memory
|
|
// *Request_File_Cached
|
|
// *Request_File_Pipe
|
|
// *Request_File_StreamIn
|
|
// *Request_File_StreamOut
|
|
File isRequest_File_File `protobuf_oneof:"file"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Request_File) Reset() {
|
|
*x = Request_File{}
|
|
mi := &file_request_proto_msgTypes[5]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Request_File) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Request_File) ProtoMessage() {}
|
|
|
|
func (x *Request_File) ProtoReflect() protoreflect.Message {
|
|
mi := &file_request_proto_msgTypes[5]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
func (x *Request_File) GetFile() isRequest_File_File {
|
|
if x != nil {
|
|
return x.File
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request_File) GetLocal() *Request_LocalFile {
|
|
if x != nil {
|
|
if x, ok := x.File.(*Request_File_Local); ok {
|
|
return x.Local
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request_File) GetMemory() *Request_MemoryFile {
|
|
if x != nil {
|
|
if x, ok := x.File.(*Request_File_Memory); ok {
|
|
return x.Memory
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request_File) GetCached() *Request_CachedFile {
|
|
if x != nil {
|
|
if x, ok := x.File.(*Request_File_Cached); ok {
|
|
return x.Cached
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request_File) GetPipe() *Request_PipeCollector {
|
|
if x != nil {
|
|
if x, ok := x.File.(*Request_File_Pipe); ok {
|
|
return x.Pipe
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request_File) GetStreamIn() *emptypb.Empty {
|
|
if x != nil {
|
|
if x, ok := x.File.(*Request_File_StreamIn); ok {
|
|
return x.StreamIn
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request_File) GetStreamOut() *emptypb.Empty {
|
|
if x != nil {
|
|
if x, ok := x.File.(*Request_File_StreamOut); ok {
|
|
return x.StreamOut
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request_File) SetLocal(v *Request_LocalFile) {
|
|
if v == nil {
|
|
x.File = nil
|
|
return
|
|
}
|
|
x.File = &Request_File_Local{v}
|
|
}
|
|
|
|
func (x *Request_File) SetMemory(v *Request_MemoryFile) {
|
|
if v == nil {
|
|
x.File = nil
|
|
return
|
|
}
|
|
x.File = &Request_File_Memory{v}
|
|
}
|
|
|
|
func (x *Request_File) SetCached(v *Request_CachedFile) {
|
|
if v == nil {
|
|
x.File = nil
|
|
return
|
|
}
|
|
x.File = &Request_File_Cached{v}
|
|
}
|
|
|
|
func (x *Request_File) SetPipe(v *Request_PipeCollector) {
|
|
if v == nil {
|
|
x.File = nil
|
|
return
|
|
}
|
|
x.File = &Request_File_Pipe{v}
|
|
}
|
|
|
|
func (x *Request_File) SetStreamIn(v *emptypb.Empty) {
|
|
if v == nil {
|
|
x.File = nil
|
|
return
|
|
}
|
|
x.File = &Request_File_StreamIn{v}
|
|
}
|
|
|
|
func (x *Request_File) SetStreamOut(v *emptypb.Empty) {
|
|
if v == nil {
|
|
x.File = nil
|
|
return
|
|
}
|
|
x.File = &Request_File_StreamOut{v}
|
|
}
|
|
|
|
func (x *Request_File) HasFile() bool {
|
|
if x == nil {
|
|
return false
|
|
}
|
|
return x.File != nil
|
|
}
|
|
|
|
func (x *Request_File) HasLocal() bool {
|
|
if x == nil {
|
|
return false
|
|
}
|
|
_, ok := x.File.(*Request_File_Local)
|
|
return ok
|
|
}
|
|
|
|
func (x *Request_File) HasMemory() bool {
|
|
if x == nil {
|
|
return false
|
|
}
|
|
_, ok := x.File.(*Request_File_Memory)
|
|
return ok
|
|
}
|
|
|
|
func (x *Request_File) HasCached() bool {
|
|
if x == nil {
|
|
return false
|
|
}
|
|
_, ok := x.File.(*Request_File_Cached)
|
|
return ok
|
|
}
|
|
|
|
func (x *Request_File) HasPipe() bool {
|
|
if x == nil {
|
|
return false
|
|
}
|
|
_, ok := x.File.(*Request_File_Pipe)
|
|
return ok
|
|
}
|
|
|
|
func (x *Request_File) HasStreamIn() bool {
|
|
if x == nil {
|
|
return false
|
|
}
|
|
_, ok := x.File.(*Request_File_StreamIn)
|
|
return ok
|
|
}
|
|
|
|
func (x *Request_File) HasStreamOut() bool {
|
|
if x == nil {
|
|
return false
|
|
}
|
|
_, ok := x.File.(*Request_File_StreamOut)
|
|
return ok
|
|
}
|
|
|
|
func (x *Request_File) ClearFile() {
|
|
x.File = nil
|
|
}
|
|
|
|
func (x *Request_File) ClearLocal() {
|
|
if _, ok := x.File.(*Request_File_Local); ok {
|
|
x.File = nil
|
|
}
|
|
}
|
|
|
|
func (x *Request_File) ClearMemory() {
|
|
if _, ok := x.File.(*Request_File_Memory); ok {
|
|
x.File = nil
|
|
}
|
|
}
|
|
|
|
func (x *Request_File) ClearCached() {
|
|
if _, ok := x.File.(*Request_File_Cached); ok {
|
|
x.File = nil
|
|
}
|
|
}
|
|
|
|
func (x *Request_File) ClearPipe() {
|
|
if _, ok := x.File.(*Request_File_Pipe); ok {
|
|
x.File = nil
|
|
}
|
|
}
|
|
|
|
func (x *Request_File) ClearStreamIn() {
|
|
if _, ok := x.File.(*Request_File_StreamIn); ok {
|
|
x.File = nil
|
|
}
|
|
}
|
|
|
|
func (x *Request_File) ClearStreamOut() {
|
|
if _, ok := x.File.(*Request_File_StreamOut); ok {
|
|
x.File = nil
|
|
}
|
|
}
|
|
|
|
const Request_File_File_not_set_case case_Request_File_File = 0
|
|
const Request_File_Local_case case_Request_File_File = 1
|
|
const Request_File_Memory_case case_Request_File_File = 2
|
|
const Request_File_Cached_case case_Request_File_File = 3
|
|
const Request_File_Pipe_case case_Request_File_File = 4
|
|
const Request_File_StreamIn_case case_Request_File_File = 5
|
|
const Request_File_StreamOut_case case_Request_File_File = 6
|
|
|
|
func (x *Request_File) WhichFile() case_Request_File_File {
|
|
if x == nil {
|
|
return Request_File_File_not_set_case
|
|
}
|
|
switch x.File.(type) {
|
|
case *Request_File_Local:
|
|
return Request_File_Local_case
|
|
case *Request_File_Memory:
|
|
return Request_File_Memory_case
|
|
case *Request_File_Cached:
|
|
return Request_File_Cached_case
|
|
case *Request_File_Pipe:
|
|
return Request_File_Pipe_case
|
|
case *Request_File_StreamIn:
|
|
return Request_File_StreamIn_case
|
|
case *Request_File_StreamOut:
|
|
return Request_File_StreamOut_case
|
|
default:
|
|
return Request_File_File_not_set_case
|
|
}
|
|
}
|
|
|
|
type Request_File_builder struct {
|
|
_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.
|
|
|
|
// Fields of oneof File:
|
|
Local *Request_LocalFile
|
|
Memory *Request_MemoryFile
|
|
Cached *Request_CachedFile
|
|
Pipe *Request_PipeCollector
|
|
// streamIn only valid in streaming RPC
|
|
StreamIn *emptypb.Empty
|
|
// streamOut only valid in streaming RPC
|
|
StreamOut *emptypb.Empty
|
|
// -- end of File
|
|
}
|
|
|
|
func (b0 Request_File_builder) Build() *Request_File {
|
|
m0 := &Request_File{}
|
|
b, x := &b0, m0
|
|
_, _ = b, x
|
|
if b.Local != nil {
|
|
x.File = &Request_File_Local{b.Local}
|
|
}
|
|
if b.Memory != nil {
|
|
x.File = &Request_File_Memory{b.Memory}
|
|
}
|
|
if b.Cached != nil {
|
|
x.File = &Request_File_Cached{b.Cached}
|
|
}
|
|
if b.Pipe != nil {
|
|
x.File = &Request_File_Pipe{b.Pipe}
|
|
}
|
|
if b.StreamIn != nil {
|
|
x.File = &Request_File_StreamIn{b.StreamIn}
|
|
}
|
|
if b.StreamOut != nil {
|
|
x.File = &Request_File_StreamOut{b.StreamOut}
|
|
}
|
|
return m0
|
|
}
|
|
|
|
type case_Request_File_File protoreflect.FieldNumber
|
|
|
|
func (x case_Request_File_File) String() string {
|
|
md := file_request_proto_msgTypes[5].Descriptor()
|
|
if x == 0 {
|
|
return "not set"
|
|
}
|
|
return protoimpl.X.MessageFieldStringOf(md, protoreflect.FieldNumber(x))
|
|
}
|
|
|
|
type isRequest_File_File interface {
|
|
isRequest_File_File()
|
|
}
|
|
|
|
type Request_File_Local struct {
|
|
Local *Request_LocalFile `protobuf:"bytes,1,opt,name=local,oneof"`
|
|
}
|
|
|
|
type Request_File_Memory struct {
|
|
Memory *Request_MemoryFile `protobuf:"bytes,2,opt,name=memory,oneof"`
|
|
}
|
|
|
|
type Request_File_Cached struct {
|
|
Cached *Request_CachedFile `protobuf:"bytes,3,opt,name=cached,oneof"`
|
|
}
|
|
|
|
type Request_File_Pipe struct {
|
|
Pipe *Request_PipeCollector `protobuf:"bytes,4,opt,name=pipe,oneof"`
|
|
}
|
|
|
|
type Request_File_StreamIn struct {
|
|
// streamIn only valid in streaming RPC
|
|
StreamIn *emptypb.Empty `protobuf:"bytes,5,opt,name=streamIn,oneof"`
|
|
}
|
|
|
|
type Request_File_StreamOut struct {
|
|
// streamOut only valid in streaming RPC
|
|
StreamOut *emptypb.Empty `protobuf:"bytes,6,opt,name=streamOut,oneof"`
|
|
}
|
|
|
|
func (*Request_File_Local) isRequest_File_File() {}
|
|
|
|
func (*Request_File_Memory) isRequest_File_File() {}
|
|
|
|
func (*Request_File_Cached) isRequest_File_File() {}
|
|
|
|
func (*Request_File_Pipe) isRequest_File_File() {}
|
|
|
|
func (*Request_File_StreamIn) isRequest_File_File() {}
|
|
|
|
func (*Request_File_StreamOut) isRequest_File_File() {}
|
|
|
|
type Request_CmdType struct {
|
|
state protoimpl.MessageState `protogen:"hybrid.v1"`
|
|
Args []string `protobuf:"bytes,1,rep,name=args" json:"args,omitempty"`
|
|
Env []string `protobuf:"bytes,2,rep,name=env" json:"env,omitempty"`
|
|
Files []*Request_File `protobuf:"bytes,3,rep,name=files" json:"files,omitempty"`
|
|
Tty bool `protobuf:"varint,13,opt,name=tty" json:"tty,omitempty"`
|
|
CpuTimeLimit uint64 `protobuf:"varint,4,opt,name=cpuTimeLimit" json:"cpuTimeLimit,omitempty"`
|
|
ClockTimeLimit uint64 `protobuf:"varint,5,opt,name=clockTimeLimit" json:"clockTimeLimit,omitempty"`
|
|
MemoryLimit uint64 `protobuf:"varint,6,opt,name=memoryLimit" json:"memoryLimit,omitempty"`
|
|
StackLimit uint64 `protobuf:"varint,12,opt,name=stackLimit" json:"stackLimit,omitempty"`
|
|
ProcLimit uint64 `protobuf:"varint,7,opt,name=procLimit" json:"procLimit,omitempty"`
|
|
CpuRateLimit uint64 `protobuf:"varint,15,opt,name=cpuRateLimit" json:"cpuRateLimit,omitempty"`
|
|
CpuSetLimit string `protobuf:"bytes,17,opt,name=cpuSetLimit" json:"cpuSetLimit,omitempty"`
|
|
DataSegmentLimit bool `protobuf:"varint,16,opt,name=dataSegmentLimit" json:"dataSegmentLimit,omitempty"`
|
|
AddressSpaceLimit bool `protobuf:"varint,19,opt,name=addressSpaceLimit" json:"addressSpaceLimit,omitempty"`
|
|
CopyIn map[string]*Request_File `protobuf:"bytes,8,rep,name=copyIn" json:"copyIn,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
|
|
Symlinks map[string]string `protobuf:"bytes,18,rep,name=symlinks" json:"symlinks,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
|
|
CopyOut []*Request_CmdCopyOutFile `protobuf:"bytes,9,rep,name=copyOut" json:"copyOut,omitempty"`
|
|
CopyOutCached []*Request_CmdCopyOutFile `protobuf:"bytes,10,rep,name=copyOutCached" json:"copyOutCached,omitempty"`
|
|
CopyOutDir string `protobuf:"bytes,11,opt,name=copyOutDir" json:"copyOutDir,omitempty"`
|
|
CopyOutMax uint64 `protobuf:"varint,14,opt,name=copyOutMax" json:"copyOutMax,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Request_CmdType) Reset() {
|
|
*x = Request_CmdType{}
|
|
mi := &file_request_proto_msgTypes[6]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Request_CmdType) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Request_CmdType) ProtoMessage() {}
|
|
|
|
func (x *Request_CmdType) ProtoReflect() protoreflect.Message {
|
|
mi := &file_request_proto_msgTypes[6]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
func (x *Request_CmdType) GetArgs() []string {
|
|
if x != nil {
|
|
return x.Args
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request_CmdType) GetEnv() []string {
|
|
if x != nil {
|
|
return x.Env
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request_CmdType) GetFiles() []*Request_File {
|
|
if x != nil {
|
|
return x.Files
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request_CmdType) GetTty() bool {
|
|
if x != nil {
|
|
return x.Tty
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *Request_CmdType) GetCpuTimeLimit() uint64 {
|
|
if x != nil {
|
|
return x.CpuTimeLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Request_CmdType) GetClockTimeLimit() uint64 {
|
|
if x != nil {
|
|
return x.ClockTimeLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Request_CmdType) GetMemoryLimit() uint64 {
|
|
if x != nil {
|
|
return x.MemoryLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Request_CmdType) GetStackLimit() uint64 {
|
|
if x != nil {
|
|
return x.StackLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Request_CmdType) GetProcLimit() uint64 {
|
|
if x != nil {
|
|
return x.ProcLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Request_CmdType) GetCpuRateLimit() uint64 {
|
|
if x != nil {
|
|
return x.CpuRateLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Request_CmdType) GetCpuSetLimit() string {
|
|
if x != nil {
|
|
return x.CpuSetLimit
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Request_CmdType) GetDataSegmentLimit() bool {
|
|
if x != nil {
|
|
return x.DataSegmentLimit
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *Request_CmdType) GetAddressSpaceLimit() bool {
|
|
if x != nil {
|
|
return x.AddressSpaceLimit
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *Request_CmdType) GetCopyIn() map[string]*Request_File {
|
|
if x != nil {
|
|
return x.CopyIn
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request_CmdType) GetSymlinks() map[string]string {
|
|
if x != nil {
|
|
return x.Symlinks
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request_CmdType) GetCopyOut() []*Request_CmdCopyOutFile {
|
|
if x != nil {
|
|
return x.CopyOut
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request_CmdType) GetCopyOutCached() []*Request_CmdCopyOutFile {
|
|
if x != nil {
|
|
return x.CopyOutCached
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request_CmdType) GetCopyOutDir() string {
|
|
if x != nil {
|
|
return x.CopyOutDir
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Request_CmdType) GetCopyOutMax() uint64 {
|
|
if x != nil {
|
|
return x.CopyOutMax
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Request_CmdType) SetArgs(v []string) {
|
|
x.Args = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetEnv(v []string) {
|
|
x.Env = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetFiles(v []*Request_File) {
|
|
x.Files = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetTty(v bool) {
|
|
x.Tty = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetCpuTimeLimit(v uint64) {
|
|
x.CpuTimeLimit = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetClockTimeLimit(v uint64) {
|
|
x.ClockTimeLimit = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetMemoryLimit(v uint64) {
|
|
x.MemoryLimit = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetStackLimit(v uint64) {
|
|
x.StackLimit = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetProcLimit(v uint64) {
|
|
x.ProcLimit = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetCpuRateLimit(v uint64) {
|
|
x.CpuRateLimit = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetCpuSetLimit(v string) {
|
|
x.CpuSetLimit = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetDataSegmentLimit(v bool) {
|
|
x.DataSegmentLimit = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetAddressSpaceLimit(v bool) {
|
|
x.AddressSpaceLimit = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetCopyIn(v map[string]*Request_File) {
|
|
x.CopyIn = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetSymlinks(v map[string]string) {
|
|
x.Symlinks = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetCopyOut(v []*Request_CmdCopyOutFile) {
|
|
x.CopyOut = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetCopyOutCached(v []*Request_CmdCopyOutFile) {
|
|
x.CopyOutCached = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetCopyOutDir(v string) {
|
|
x.CopyOutDir = v
|
|
}
|
|
|
|
func (x *Request_CmdType) SetCopyOutMax(v uint64) {
|
|
x.CopyOutMax = v
|
|
}
|
|
|
|
type Request_CmdType_builder struct {
|
|
_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.
|
|
|
|
Args []string
|
|
Env []string
|
|
Files []*Request_File
|
|
Tty bool
|
|
CpuTimeLimit uint64
|
|
ClockTimeLimit uint64
|
|
MemoryLimit uint64
|
|
StackLimit uint64
|
|
ProcLimit uint64
|
|
CpuRateLimit uint64
|
|
CpuSetLimit string
|
|
DataSegmentLimit bool
|
|
AddressSpaceLimit bool
|
|
CopyIn map[string]*Request_File
|
|
Symlinks map[string]string
|
|
CopyOut []*Request_CmdCopyOutFile
|
|
CopyOutCached []*Request_CmdCopyOutFile
|
|
CopyOutDir string
|
|
CopyOutMax uint64
|
|
}
|
|
|
|
func (b0 Request_CmdType_builder) Build() *Request_CmdType {
|
|
m0 := &Request_CmdType{}
|
|
b, x := &b0, m0
|
|
_, _ = b, x
|
|
x.Args = b.Args
|
|
x.Env = b.Env
|
|
x.Files = b.Files
|
|
x.Tty = b.Tty
|
|
x.CpuTimeLimit = b.CpuTimeLimit
|
|
x.ClockTimeLimit = b.ClockTimeLimit
|
|
x.MemoryLimit = b.MemoryLimit
|
|
x.StackLimit = b.StackLimit
|
|
x.ProcLimit = b.ProcLimit
|
|
x.CpuRateLimit = b.CpuRateLimit
|
|
x.CpuSetLimit = b.CpuSetLimit
|
|
x.DataSegmentLimit = b.DataSegmentLimit
|
|
x.AddressSpaceLimit = b.AddressSpaceLimit
|
|
x.CopyIn = b.CopyIn
|
|
x.Symlinks = b.Symlinks
|
|
x.CopyOut = b.CopyOut
|
|
x.CopyOutCached = b.CopyOutCached
|
|
x.CopyOutDir = b.CopyOutDir
|
|
x.CopyOutMax = b.CopyOutMax
|
|
return m0
|
|
}
|
|
|
|
type Request_CmdCopyOutFile struct {
|
|
state protoimpl.MessageState `protogen:"hybrid.v1"`
|
|
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
|
|
Optional bool `protobuf:"varint,2,opt,name=optional" json:"optional,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Request_CmdCopyOutFile) Reset() {
|
|
*x = Request_CmdCopyOutFile{}
|
|
mi := &file_request_proto_msgTypes[7]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Request_CmdCopyOutFile) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Request_CmdCopyOutFile) ProtoMessage() {}
|
|
|
|
func (x *Request_CmdCopyOutFile) ProtoReflect() protoreflect.Message {
|
|
mi := &file_request_proto_msgTypes[7]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
func (x *Request_CmdCopyOutFile) GetName() string {
|
|
if x != nil {
|
|
return x.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Request_CmdCopyOutFile) GetOptional() bool {
|
|
if x != nil {
|
|
return x.Optional
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *Request_CmdCopyOutFile) SetName(v string) {
|
|
x.Name = v
|
|
}
|
|
|
|
func (x *Request_CmdCopyOutFile) SetOptional(v bool) {
|
|
x.Optional = v
|
|
}
|
|
|
|
type Request_CmdCopyOutFile_builder struct {
|
|
_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.
|
|
|
|
Name string
|
|
Optional bool
|
|
}
|
|
|
|
func (b0 Request_CmdCopyOutFile_builder) Build() *Request_CmdCopyOutFile {
|
|
m0 := &Request_CmdCopyOutFile{}
|
|
b, x := &b0, m0
|
|
_, _ = b, x
|
|
x.Name = b.Name
|
|
x.Optional = b.Optional
|
|
return m0
|
|
}
|
|
|
|
type Request_PipeMap struct {
|
|
state protoimpl.MessageState `protogen:"hybrid.v1"`
|
|
In *Request_PipeMap_PipeIndex `protobuf:"bytes,1,opt,name=in" json:"in,omitempty"`
|
|
Out *Request_PipeMap_PipeIndex `protobuf:"bytes,2,opt,name=out" json:"out,omitempty"`
|
|
Proxy bool `protobuf:"varint,3,opt,name=proxy" json:"proxy,omitempty"`
|
|
Name string `protobuf:"bytes,4,opt,name=name" json:"name,omitempty"`
|
|
Max uint64 `protobuf:"varint,5,opt,name=max" json:"max,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Request_PipeMap) Reset() {
|
|
*x = Request_PipeMap{}
|
|
mi := &file_request_proto_msgTypes[8]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Request_PipeMap) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Request_PipeMap) ProtoMessage() {}
|
|
|
|
func (x *Request_PipeMap) ProtoReflect() protoreflect.Message {
|
|
mi := &file_request_proto_msgTypes[8]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
func (x *Request_PipeMap) GetIn() *Request_PipeMap_PipeIndex {
|
|
if x != nil {
|
|
return x.In
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request_PipeMap) GetOut() *Request_PipeMap_PipeIndex {
|
|
if x != nil {
|
|
return x.Out
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Request_PipeMap) GetProxy() bool {
|
|
if x != nil {
|
|
return x.Proxy
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *Request_PipeMap) GetName() string {
|
|
if x != nil {
|
|
return x.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Request_PipeMap) GetMax() uint64 {
|
|
if x != nil {
|
|
return x.Max
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Request_PipeMap) SetIn(v *Request_PipeMap_PipeIndex) {
|
|
x.In = v
|
|
}
|
|
|
|
func (x *Request_PipeMap) SetOut(v *Request_PipeMap_PipeIndex) {
|
|
x.Out = v
|
|
}
|
|
|
|
func (x *Request_PipeMap) SetProxy(v bool) {
|
|
x.Proxy = v
|
|
}
|
|
|
|
func (x *Request_PipeMap) SetName(v string) {
|
|
x.Name = v
|
|
}
|
|
|
|
func (x *Request_PipeMap) SetMax(v uint64) {
|
|
x.Max = v
|
|
}
|
|
|
|
func (x *Request_PipeMap) HasIn() bool {
|
|
if x == nil {
|
|
return false
|
|
}
|
|
return x.In != nil
|
|
}
|
|
|
|
func (x *Request_PipeMap) HasOut() bool {
|
|
if x == nil {
|
|
return false
|
|
}
|
|
return x.Out != nil
|
|
}
|
|
|
|
func (x *Request_PipeMap) ClearIn() {
|
|
x.In = nil
|
|
}
|
|
|
|
func (x *Request_PipeMap) ClearOut() {
|
|
x.Out = nil
|
|
}
|
|
|
|
type Request_PipeMap_builder struct {
|
|
_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.
|
|
|
|
In *Request_PipeMap_PipeIndex
|
|
Out *Request_PipeMap_PipeIndex
|
|
Proxy bool
|
|
Name string
|
|
Max uint64
|
|
}
|
|
|
|
func (b0 Request_PipeMap_builder) Build() *Request_PipeMap {
|
|
m0 := &Request_PipeMap{}
|
|
b, x := &b0, m0
|
|
_, _ = b, x
|
|
x.In = b.In
|
|
x.Out = b.Out
|
|
x.Proxy = b.Proxy
|
|
x.Name = b.Name
|
|
x.Max = b.Max
|
|
return m0
|
|
}
|
|
|
|
type Request_PipeMap_PipeIndex struct {
|
|
state protoimpl.MessageState `protogen:"hybrid.v1"`
|
|
Index int32 `protobuf:"varint,1,opt,name=index" json:"index,omitempty"`
|
|
Fd int32 `protobuf:"varint,2,opt,name=fd" json:"fd,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *Request_PipeMap_PipeIndex) Reset() {
|
|
*x = Request_PipeMap_PipeIndex{}
|
|
mi := &file_request_proto_msgTypes[11]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *Request_PipeMap_PipeIndex) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*Request_PipeMap_PipeIndex) ProtoMessage() {}
|
|
|
|
func (x *Request_PipeMap_PipeIndex) ProtoReflect() protoreflect.Message {
|
|
mi := &file_request_proto_msgTypes[11]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
func (x *Request_PipeMap_PipeIndex) GetIndex() int32 {
|
|
if x != nil {
|
|
return x.Index
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Request_PipeMap_PipeIndex) GetFd() int32 {
|
|
if x != nil {
|
|
return x.Fd
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Request_PipeMap_PipeIndex) SetIndex(v int32) {
|
|
x.Index = v
|
|
}
|
|
|
|
func (x *Request_PipeMap_PipeIndex) SetFd(v int32) {
|
|
x.Fd = v
|
|
}
|
|
|
|
type Request_PipeMap_PipeIndex_builder struct {
|
|
_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.
|
|
|
|
Index int32
|
|
Fd int32
|
|
}
|
|
|
|
func (b0 Request_PipeMap_PipeIndex_builder) Build() *Request_PipeMap_PipeIndex {
|
|
m0 := &Request_PipeMap_PipeIndex{}
|
|
b, x := &b0, m0
|
|
_, _ = b, x
|
|
x.Index = b.Index
|
|
x.Fd = b.Fd
|
|
return m0
|
|
}
|
|
|
|
var File_request_proto protoreflect.FileDescriptor
|
|
|
|
const file_request_proto_rawDesc = "" +
|
|
"\n" +
|
|
"\rrequest.proto\x12\x02pb\x1a\x1bgoogle/protobuf/empty.proto\x1a!google/protobuf/go_features.proto\"\x8f\x0e\n" +
|
|
"\aRequest\x12\x1c\n" +
|
|
"\trequestID\x18\x01 \x01(\tR\trequestID\x12%\n" +
|
|
"\x03cmd\x18\x02 \x03(\v2\x13.pb.Request.CmdTypeR\x03cmd\x125\n" +
|
|
"\vpipeMapping\x18\x03 \x03(\v2\x13.pb.Request.PipeMapR\vpipeMapping\x1a\x1d\n" +
|
|
"\tLocalFile\x12\x10\n" +
|
|
"\x03src\x18\x01 \x01(\tR\x03src\x1a&\n" +
|
|
"\n" +
|
|
"MemoryFile\x12\x18\n" +
|
|
"\acontent\x18\x01 \x01(\fR\acontent\x1a$\n" +
|
|
"\n" +
|
|
"CachedFile\x12\x16\n" +
|
|
"\x06fileID\x18\x01 \x01(\tR\x06fileID\x1aI\n" +
|
|
"\rPipeCollector\x12\x12\n" +
|
|
"\x04name\x18\x01 \x01(\tR\x04name\x12\x10\n" +
|
|
"\x03max\x18\x02 \x01(\x03R\x03max\x12\x12\n" +
|
|
"\x04pipe\x18\x03 \x01(\bR\x04pipe\x1a\xc0\x02\n" +
|
|
"\x04File\x12-\n" +
|
|
"\x05local\x18\x01 \x01(\v2\x15.pb.Request.LocalFileH\x00R\x05local\x120\n" +
|
|
"\x06memory\x18\x02 \x01(\v2\x16.pb.Request.MemoryFileH\x00R\x06memory\x120\n" +
|
|
"\x06cached\x18\x03 \x01(\v2\x16.pb.Request.CachedFileH\x00R\x06cached\x12/\n" +
|
|
"\x04pipe\x18\x04 \x01(\v2\x19.pb.Request.PipeCollectorH\x00R\x04pipe\x124\n" +
|
|
"\bstreamIn\x18\x05 \x01(\v2\x16.google.protobuf.EmptyH\x00R\bstreamIn\x126\n" +
|
|
"\tstreamOut\x18\x06 \x01(\v2\x16.google.protobuf.EmptyH\x00R\tstreamOutB\x06\n" +
|
|
"\x04file\x1a\xef\x06\n" +
|
|
"\aCmdType\x12\x12\n" +
|
|
"\x04args\x18\x01 \x03(\tR\x04args\x12\x10\n" +
|
|
"\x03env\x18\x02 \x03(\tR\x03env\x12&\n" +
|
|
"\x05files\x18\x03 \x03(\v2\x10.pb.Request.FileR\x05files\x12\x10\n" +
|
|
"\x03tty\x18\r \x01(\bR\x03tty\x12\"\n" +
|
|
"\fcpuTimeLimit\x18\x04 \x01(\x04R\fcpuTimeLimit\x12&\n" +
|
|
"\x0eclockTimeLimit\x18\x05 \x01(\x04R\x0eclockTimeLimit\x12 \n" +
|
|
"\vmemoryLimit\x18\x06 \x01(\x04R\vmemoryLimit\x12\x1e\n" +
|
|
"\n" +
|
|
"stackLimit\x18\f \x01(\x04R\n" +
|
|
"stackLimit\x12\x1c\n" +
|
|
"\tprocLimit\x18\a \x01(\x04R\tprocLimit\x12\"\n" +
|
|
"\fcpuRateLimit\x18\x0f \x01(\x04R\fcpuRateLimit\x12 \n" +
|
|
"\vcpuSetLimit\x18\x11 \x01(\tR\vcpuSetLimit\x12*\n" +
|
|
"\x10dataSegmentLimit\x18\x10 \x01(\bR\x10dataSegmentLimit\x12,\n" +
|
|
"\x11addressSpaceLimit\x18\x13 \x01(\bR\x11addressSpaceLimit\x127\n" +
|
|
"\x06copyIn\x18\b \x03(\v2\x1f.pb.Request.CmdType.CopyInEntryR\x06copyIn\x12=\n" +
|
|
"\bsymlinks\x18\x12 \x03(\v2!.pb.Request.CmdType.SymlinksEntryR\bsymlinks\x124\n" +
|
|
"\acopyOut\x18\t \x03(\v2\x1a.pb.Request.CmdCopyOutFileR\acopyOut\x12@\n" +
|
|
"\rcopyOutCached\x18\n" +
|
|
" \x03(\v2\x1a.pb.Request.CmdCopyOutFileR\rcopyOutCached\x12\x1e\n" +
|
|
"\n" +
|
|
"copyOutDir\x18\v \x01(\tR\n" +
|
|
"copyOutDir\x12\x1e\n" +
|
|
"\n" +
|
|
"copyOutMax\x18\x0e \x01(\x04R\n" +
|
|
"copyOutMax\x1aK\n" +
|
|
"\vCopyInEntry\x12\x10\n" +
|
|
"\x03key\x18\x01 \x01(\tR\x03key\x12&\n" +
|
|
"\x05value\x18\x02 \x01(\v2\x10.pb.Request.FileR\x05value:\x028\x01\x1a;\n" +
|
|
"\rSymlinksEntry\x12\x10\n" +
|
|
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
|
|
"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\x1a@\n" +
|
|
"\x0eCmdCopyOutFile\x12\x12\n" +
|
|
"\x04name\x18\x01 \x01(\tR\x04name\x12\x1a\n" +
|
|
"\boptional\x18\x02 \x01(\bR\boptional\x1a\xd8\x01\n" +
|
|
"\aPipeMap\x12-\n" +
|
|
"\x02in\x18\x01 \x01(\v2\x1d.pb.Request.PipeMap.PipeIndexR\x02in\x12/\n" +
|
|
"\x03out\x18\x02 \x01(\v2\x1d.pb.Request.PipeMap.PipeIndexR\x03out\x12\x14\n" +
|
|
"\x05proxy\x18\x03 \x01(\bR\x05proxy\x12\x12\n" +
|
|
"\x04name\x18\x04 \x01(\tR\x04name\x12\x10\n" +
|
|
"\x03max\x18\x05 \x01(\x04R\x03max\x1a1\n" +
|
|
"\tPipeIndex\x12\x14\n" +
|
|
"\x05index\x18\x01 \x01(\x05R\x05index\x12\x0e\n" +
|
|
"\x02fd\x18\x02 \x01(\x05R\x02fdB)Z\x1dgithub.com/criyle/go-judge/pb\x92\x03\a\xd2>\x02\x10\x02\b\x02b\beditionsp\xe8\a"
|
|
|
|
var file_request_proto_msgTypes = make([]protoimpl.MessageInfo, 12)
|
|
var file_request_proto_goTypes = []any{
|
|
(*Request)(nil), // 0: pb.Request
|
|
(*Request_LocalFile)(nil), // 1: pb.Request.LocalFile
|
|
(*Request_MemoryFile)(nil), // 2: pb.Request.MemoryFile
|
|
(*Request_CachedFile)(nil), // 3: pb.Request.CachedFile
|
|
(*Request_PipeCollector)(nil), // 4: pb.Request.PipeCollector
|
|
(*Request_File)(nil), // 5: pb.Request.File
|
|
(*Request_CmdType)(nil), // 6: pb.Request.CmdType
|
|
(*Request_CmdCopyOutFile)(nil), // 7: pb.Request.CmdCopyOutFile
|
|
(*Request_PipeMap)(nil), // 8: pb.Request.PipeMap
|
|
nil, // 9: pb.Request.CmdType.CopyInEntry
|
|
nil, // 10: pb.Request.CmdType.SymlinksEntry
|
|
(*Request_PipeMap_PipeIndex)(nil), // 11: pb.Request.PipeMap.PipeIndex
|
|
(*emptypb.Empty)(nil), // 12: google.protobuf.Empty
|
|
}
|
|
var file_request_proto_depIdxs = []int32{
|
|
6, // 0: pb.Request.cmd:type_name -> pb.Request.CmdType
|
|
8, // 1: pb.Request.pipeMapping:type_name -> pb.Request.PipeMap
|
|
1, // 2: pb.Request.File.local:type_name -> pb.Request.LocalFile
|
|
2, // 3: pb.Request.File.memory:type_name -> pb.Request.MemoryFile
|
|
3, // 4: pb.Request.File.cached:type_name -> pb.Request.CachedFile
|
|
4, // 5: pb.Request.File.pipe:type_name -> pb.Request.PipeCollector
|
|
12, // 6: pb.Request.File.streamIn:type_name -> google.protobuf.Empty
|
|
12, // 7: pb.Request.File.streamOut:type_name -> google.protobuf.Empty
|
|
5, // 8: pb.Request.CmdType.files:type_name -> pb.Request.File
|
|
9, // 9: pb.Request.CmdType.copyIn:type_name -> pb.Request.CmdType.CopyInEntry
|
|
10, // 10: pb.Request.CmdType.symlinks:type_name -> pb.Request.CmdType.SymlinksEntry
|
|
7, // 11: pb.Request.CmdType.copyOut:type_name -> pb.Request.CmdCopyOutFile
|
|
7, // 12: pb.Request.CmdType.copyOutCached:type_name -> pb.Request.CmdCopyOutFile
|
|
11, // 13: pb.Request.PipeMap.in:type_name -> pb.Request.PipeMap.PipeIndex
|
|
11, // 14: pb.Request.PipeMap.out:type_name -> pb.Request.PipeMap.PipeIndex
|
|
5, // 15: pb.Request.CmdType.CopyInEntry.value:type_name -> pb.Request.File
|
|
16, // [16:16] is the sub-list for method output_type
|
|
16, // [16:16] is the sub-list for method input_type
|
|
16, // [16:16] is the sub-list for extension type_name
|
|
16, // [16:16] is the sub-list for extension extendee
|
|
0, // [0:16] is the sub-list for field type_name
|
|
}
|
|
|
|
func init() { file_request_proto_init() }
|
|
func file_request_proto_init() {
|
|
if File_request_proto != nil {
|
|
return
|
|
}
|
|
file_request_proto_msgTypes[5].OneofWrappers = []any{
|
|
(*Request_File_Local)(nil),
|
|
(*Request_File_Memory)(nil),
|
|
(*Request_File_Cached)(nil),
|
|
(*Request_File_Pipe)(nil),
|
|
(*Request_File_StreamIn)(nil),
|
|
(*Request_File_StreamOut)(nil),
|
|
}
|
|
type x struct{}
|
|
out := protoimpl.TypeBuilder{
|
|
File: protoimpl.DescBuilder{
|
|
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
|
RawDescriptor: unsafe.Slice(unsafe.StringData(file_request_proto_rawDesc), len(file_request_proto_rawDesc)),
|
|
NumEnums: 0,
|
|
NumMessages: 12,
|
|
NumExtensions: 0,
|
|
NumServices: 0,
|
|
},
|
|
GoTypes: file_request_proto_goTypes,
|
|
DependencyIndexes: file_request_proto_depIdxs,
|
|
MessageInfos: file_request_proto_msgTypes,
|
|
}.Build()
|
|
File_request_proto = out.File
|
|
file_request_proto_goTypes = nil
|
|
file_request_proto_depIdxs = nil
|
|
}
|