Source file src/github.com/Microsoft/hcsshim/cmd/containerd-shim-runhcs-v1/options/runhcs.pb.go

Documentation: github.com/Microsoft/hcsshim/cmd/containerd-shim-runhcs-v1/options

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: github.com/Microsoft/hcsshim/cmd/containerd-shim-runhcs-v1/options/runhcs.proto
     3  
     4  package options
     5  
     6  import (
     7  	fmt "fmt"
     8  	proto "github.com/gogo/protobuf/proto"
     9  	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
    10  	_ "github.com/gogo/protobuf/types"
    11  	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
    12  	io "io"
    13  	math "math"
    14  	math_bits "math/bits"
    15  	reflect "reflect"
    16  	strings "strings"
    17  	time "time"
    18  )
    19  
    20  // Reference imports to suppress errors if they are not otherwise used.
    21  var _ = proto.Marshal
    22  var _ = fmt.Errorf
    23  var _ = math.Inf
    24  var _ = time.Kitchen
    25  
    26  // This is a compile-time assertion to ensure that this generated file
    27  // is compatible with the proto package it is being compiled against.
    28  // A compilation error at this line likely means your copy of the
    29  // proto package needs to be updated.
    30  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    31  
    32  type Options_DebugType int32
    33  
    34  const (
    35  	Options_NPIPE Options_DebugType = 0
    36  	Options_FILE  Options_DebugType = 1
    37  	Options_ETW   Options_DebugType = 2
    38  )
    39  
    40  var Options_DebugType_name = map[int32]string{
    41  	0: "NPIPE",
    42  	1: "FILE",
    43  	2: "ETW",
    44  }
    45  
    46  var Options_DebugType_value = map[string]int32{
    47  	"NPIPE": 0,
    48  	"FILE":  1,
    49  	"ETW":   2,
    50  }
    51  
    52  func (x Options_DebugType) String() string {
    53  	return proto.EnumName(Options_DebugType_name, int32(x))
    54  }
    55  
    56  func (Options_DebugType) EnumDescriptor() ([]byte, []int) {
    57  	return fileDescriptor_b643df6839c75082, []int{0, 0}
    58  }
    59  
    60  type Options_SandboxIsolation int32
    61  
    62  const (
    63  	Options_PROCESS    Options_SandboxIsolation = 0
    64  	Options_HYPERVISOR Options_SandboxIsolation = 1
    65  )
    66  
    67  var Options_SandboxIsolation_name = map[int32]string{
    68  	0: "PROCESS",
    69  	1: "HYPERVISOR",
    70  }
    71  
    72  var Options_SandboxIsolation_value = map[string]int32{
    73  	"PROCESS":    0,
    74  	"HYPERVISOR": 1,
    75  }
    76  
    77  func (x Options_SandboxIsolation) String() string {
    78  	return proto.EnumName(Options_SandboxIsolation_name, int32(x))
    79  }
    80  
    81  func (Options_SandboxIsolation) EnumDescriptor() ([]byte, []int) {
    82  	return fileDescriptor_b643df6839c75082, []int{0, 1}
    83  }
    84  
    85  // Options are the set of customizations that can be passed at Create time.
    86  type Options struct {
    87  	// Enable debug tracing (sets the logrus log level to debug). This may be deprecated in the future, prefer
    88  	// log_level as this will override debug if both of them are set.
    89  	Debug bool `protobuf:"varint,1,opt,name=debug,proto3" json:"debug,omitempty"`
    90  	// debug tracing output type
    91  	DebugType Options_DebugType `protobuf:"varint,2,opt,name=debug_type,json=debugType,proto3,enum=containerd.runhcs.v1.Options_DebugType" json:"debug_type,omitempty"`
    92  	// registry key root for storage of the runhcs container state
    93  	RegistryRoot string `protobuf:"bytes,3,opt,name=registry_root,json=registryRoot,proto3" json:"registry_root,omitempty"`
    94  	// sandbox_image is the image to use for the sandbox that matches the
    95  	// sandbox_platform.
    96  	SandboxImage string `protobuf:"bytes,4,opt,name=sandbox_image,json=sandboxImage,proto3" json:"sandbox_image,omitempty"`
    97  	// sandbox_platform is a CRI setting that specifies the platform
    98  	// architecture for all sandbox's in this runtime. Values are
    99  	// 'windows/amd64' and 'linux/amd64'.
   100  	SandboxPlatform string `protobuf:"bytes,5,opt,name=sandbox_platform,json=sandboxPlatform,proto3" json:"sandbox_platform,omitempty"`
   101  	// sandbox_isolation is a CRI setting that specifies the isolation level of
   102  	// the sandbox. For Windows runtime PROCESS and HYPERVISOR are valid. For
   103  	// LCOW only HYPERVISOR is valid and default if omitted.
   104  	SandboxIsolation Options_SandboxIsolation `protobuf:"varint,6,opt,name=sandbox_isolation,json=sandboxIsolation,proto3,enum=containerd.runhcs.v1.Options_SandboxIsolation" json:"sandbox_isolation,omitempty"`
   105  	// boot_files_root_path is the path to the directory containing the LCOW
   106  	// kernel and root FS files.
   107  	BootFilesRootPath string `protobuf:"bytes,7,opt,name=boot_files_root_path,json=bootFilesRootPath,proto3" json:"boot_files_root_path,omitempty"`
   108  	// vm_processor_count is the default number of processors to create for the
   109  	// hypervisor isolated utility vm.
   110  	//
   111  	// The platform default if omitted is 2, unless the host only has a single
   112  	// core in which case it is 1.
   113  	VmProcessorCount int32 `protobuf:"varint,8,opt,name=vm_processor_count,json=vmProcessorCount,proto3" json:"vm_processor_count,omitempty"`
   114  	// vm_memory_size_in_mb is the default amount of memory to assign to the
   115  	// hypervisor isolated utility vm.
   116  	//
   117  	// The platform default is 1024MB if omitted.
   118  	VmMemorySizeInMb int32 `protobuf:"varint,9,opt,name=vm_memory_size_in_mb,json=vmMemorySizeInMb,proto3" json:"vm_memory_size_in_mb,omitempty"`
   119  	// GPUVHDPath is the path to the gpu vhd to add to the uvm
   120  	// when a container requests a gpu
   121  	GPUVHDPath string `protobuf:"bytes,10,opt,name=GPUVHDPath,proto3" json:"GPUVHDPath,omitempty"`
   122  	// scale_cpu_limits_to_sandbox indicates that container CPU limits should
   123  	// be adjusted to account for the difference in number of cores between the
   124  	// host and UVM.
   125  	ScaleCpuLimitsToSandbox bool `protobuf:"varint,11,opt,name=scale_cpu_limits_to_sandbox,json=scaleCpuLimitsToSandbox,proto3" json:"scale_cpu_limits_to_sandbox,omitempty"`
   126  	// default_container_scratch_size_in_gb is the default scratch size (sandbox.vhdx)
   127  	// to be used for containers. Every container will get a sandbox of `size_in_gb` assigned
   128  	// instead of the default of 20GB.
   129  	DefaultContainerScratchSizeInGb int32 `protobuf:"varint,12,opt,name=default_container_scratch_size_in_gb,json=defaultContainerScratchSizeInGb,proto3" json:"default_container_scratch_size_in_gb,omitempty"`
   130  	// default_vm_scratch_size_in_gb is the default scratch size (sandbox.vhdx)
   131  	// to be used for the UVM. This only applies to WCOW as LCOW doesn't mount a scratch
   132  	// specifically for the UVM.
   133  	DefaultVmScratchSizeInGb int32 `protobuf:"varint,13,opt,name=default_vm_scratch_size_in_gb,json=defaultVmScratchSizeInGb,proto3" json:"default_vm_scratch_size_in_gb,omitempty"`
   134  	// share_scratch specifies if we'd like to reuse scratch space between multiple containers.
   135  	// This currently only affects LCOW. The sandbox containers scratch space is re-used for all
   136  	// subsequent containers launched in the pod.
   137  	ShareScratch bool `protobuf:"varint,14,opt,name=share_scratch,json=shareScratch,proto3" json:"share_scratch,omitempty"`
   138  	// NCProxyAddr is the address of the network configuration proxy service. If omitted
   139  	// the network is setup locally.
   140  	NCProxyAddr string `protobuf:"bytes,15,opt,name=NCProxyAddr,proto3" json:"NCProxyAddr,omitempty"`
   141  	// log_level specifies the logrus log level for the shim. Supported values are a string representation of the
   142  	// logrus log levels: "trace", "debug", "info", "warn", "error", "fatal", "panic". This setting will override
   143  	// the `debug` field if both are specified, unless the level specified is also "debug", as these are equivalent.
   144  	LogLevel string `protobuf:"bytes,16,opt,name=log_level,json=logLevel,proto3" json:"log_level,omitempty"`
   145  	// io_retry_timeout_in_sec is the timeout in seconds for how long to try and reconnect to an upstream IO provider if a connection is lost.
   146  	// The typical example is if Containerd has restarted but is expected to come back online. A 0 for this field is interpreted as an infinite
   147  	// timeout.
   148  	IoRetryTimeoutInSec int32 `protobuf:"varint,17,opt,name=io_retry_timeout_in_sec,json=ioRetryTimeoutInSec,proto3" json:"io_retry_timeout_in_sec,omitempty"`
   149  	// default_container_annotations specifies a set of annotations that should be set for every workload container
   150  	DefaultContainerAnnotations map[string]string `protobuf:"bytes,18,rep,name=default_container_annotations,json=defaultContainerAnnotations,proto3" json:"default_container_annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
   151  	// no_inherit_host_timezone specifies to skip inheriting the hosts time zone for WCOW UVMs and instead default to
   152  	// UTC.
   153  	NoInheritHostTimezone bool `protobuf:"varint,19,opt,name=no_inherit_host_timezone,json=noInheritHostTimezone,proto3" json:"no_inherit_host_timezone,omitempty"`
   154  	// scrub_logs enables removing environment variables and other potentially sensitive information from logs
   155  	ScrubLogs            bool     `protobuf:"varint,20,opt,name=scrub_logs,json=scrubLogs,proto3" json:"scrub_logs,omitempty"`
   156  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   157  	XXX_unrecognized     []byte   `json:"-"`
   158  	XXX_sizecache        int32    `json:"-"`
   159  }
   160  
   161  func (m *Options) Reset()      { *m = Options{} }
   162  func (*Options) ProtoMessage() {}
   163  func (*Options) Descriptor() ([]byte, []int) {
   164  	return fileDescriptor_b643df6839c75082, []int{0}
   165  }
   166  func (m *Options) XXX_Unmarshal(b []byte) error {
   167  	return m.Unmarshal(b)
   168  }
   169  func (m *Options) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   170  	if deterministic {
   171  		return xxx_messageInfo_Options.Marshal(b, m, deterministic)
   172  	} else {
   173  		b = b[:cap(b)]
   174  		n, err := m.MarshalToSizedBuffer(b)
   175  		if err != nil {
   176  			return nil, err
   177  		}
   178  		return b[:n], nil
   179  	}
   180  }
   181  func (m *Options) XXX_Merge(src proto.Message) {
   182  	xxx_messageInfo_Options.Merge(m, src)
   183  }
   184  func (m *Options) XXX_Size() int {
   185  	return m.Size()
   186  }
   187  func (m *Options) XXX_DiscardUnknown() {
   188  	xxx_messageInfo_Options.DiscardUnknown(m)
   189  }
   190  
   191  var xxx_messageInfo_Options proto.InternalMessageInfo
   192  
   193  // ProcessDetails contains additional information about a process. This is the additional
   194  // info returned in the Pids query.
   195  type ProcessDetails struct {
   196  	ImageName                    string    `protobuf:"bytes,1,opt,name=image_name,json=imageName,proto3" json:"image_name,omitempty"`
   197  	CreatedAt                    time.Time `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3,stdtime" json:"created_at"`
   198  	KernelTime_100Ns             uint64    `protobuf:"varint,3,opt,name=kernel_time_100_ns,json=kernelTime100Ns,proto3" json:"kernel_time_100_ns,omitempty"`
   199  	MemoryCommitBytes            uint64    `protobuf:"varint,4,opt,name=memory_commit_bytes,json=memoryCommitBytes,proto3" json:"memory_commit_bytes,omitempty"`
   200  	MemoryWorkingSetPrivateBytes uint64    `protobuf:"varint,5,opt,name=memory_working_set_private_bytes,json=memoryWorkingSetPrivateBytes,proto3" json:"memory_working_set_private_bytes,omitempty"`
   201  	MemoryWorkingSetSharedBytes  uint64    `protobuf:"varint,6,opt,name=memory_working_set_shared_bytes,json=memoryWorkingSetSharedBytes,proto3" json:"memory_working_set_shared_bytes,omitempty"`
   202  	ProcessID                    uint32    `protobuf:"varint,7,opt,name=process_id,json=processId,proto3" json:"process_id,omitempty"`
   203  	UserTime_100Ns               uint64    `protobuf:"varint,8,opt,name=user_time_100_ns,json=userTime100Ns,proto3" json:"user_time_100_ns,omitempty"`
   204  	ExecID                       string    `protobuf:"bytes,9,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"`
   205  	XXX_NoUnkeyedLiteral         struct{}  `json:"-"`
   206  	XXX_unrecognized             []byte    `json:"-"`
   207  	XXX_sizecache                int32     `json:"-"`
   208  }
   209  
   210  func (m *ProcessDetails) Reset()      { *m = ProcessDetails{} }
   211  func (*ProcessDetails) ProtoMessage() {}
   212  func (*ProcessDetails) Descriptor() ([]byte, []int) {
   213  	return fileDescriptor_b643df6839c75082, []int{1}
   214  }
   215  func (m *ProcessDetails) XXX_Unmarshal(b []byte) error {
   216  	return m.Unmarshal(b)
   217  }
   218  func (m *ProcessDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   219  	if deterministic {
   220  		return xxx_messageInfo_ProcessDetails.Marshal(b, m, deterministic)
   221  	} else {
   222  		b = b[:cap(b)]
   223  		n, err := m.MarshalToSizedBuffer(b)
   224  		if err != nil {
   225  			return nil, err
   226  		}
   227  		return b[:n], nil
   228  	}
   229  }
   230  func (m *ProcessDetails) XXX_Merge(src proto.Message) {
   231  	xxx_messageInfo_ProcessDetails.Merge(m, src)
   232  }
   233  func (m *ProcessDetails) XXX_Size() int {
   234  	return m.Size()
   235  }
   236  func (m *ProcessDetails) XXX_DiscardUnknown() {
   237  	xxx_messageInfo_ProcessDetails.DiscardUnknown(m)
   238  }
   239  
   240  var xxx_messageInfo_ProcessDetails proto.InternalMessageInfo
   241  
   242  func init() {
   243  	proto.RegisterEnum("containerd.runhcs.v1.Options_DebugType", Options_DebugType_name, Options_DebugType_value)
   244  	proto.RegisterEnum("containerd.runhcs.v1.Options_SandboxIsolation", Options_SandboxIsolation_name, Options_SandboxIsolation_value)
   245  	proto.RegisterType((*Options)(nil), "containerd.runhcs.v1.Options")
   246  	proto.RegisterMapType((map[string]string)(nil), "containerd.runhcs.v1.Options.DefaultContainerAnnotationsEntry")
   247  	proto.RegisterType((*ProcessDetails)(nil), "containerd.runhcs.v1.ProcessDetails")
   248  }
   249  
   250  func init() {
   251  	proto.RegisterFile("github.com/Microsoft/hcsshim/cmd/containerd-shim-runhcs-v1/options/runhcs.proto", fileDescriptor_b643df6839c75082)
   252  }
   253  
   254  var fileDescriptor_b643df6839c75082 = []byte{
   255  	// 1072 bytes of a gzipped FileDescriptorProto
   256  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0x4b, 0x6f, 0xe3, 0x36,
   257  	0x17, 0xb5, 0xf2, 0xb4, 0x98, 0x97, 0xc3, 0xf8, 0xc3, 0x08, 0xc9, 0x37, 0xb6, 0x91, 0x29, 0x30,
   258  	0x19, 0x74, 0x22, 0x27, 0x69, 0x81, 0x16, 0x6d, 0xd1, 0x22, 0xb1, 0x9d, 0x89, 0x8b, 0x3c, 0x0c,
   259  	0xd9, 0xcd, 0xf4, 0xb1, 0x20, 0xf4, 0x60, 0x64, 0x22, 0x92, 0x28, 0x90, 0x94, 0x1b, 0x67, 0x55,
   260  	0xf4, 0x17, 0xf4, 0x67, 0x65, 0xd9, 0x65, 0x8b, 0x02, 0x69, 0xc7, 0xbf, 0xa4, 0x20, 0x45, 0x25,
   261  	0x33, 0x41, 0xda, 0x59, 0x74, 0x65, 0xf2, 0x9c, 0xc3, 0xc3, 0x7b, 0xaf, 0x78, 0xaf, 0xc1, 0x59,
   262  	0x48, 0xc4, 0x30, 0xf3, 0x6c, 0x9f, 0xc6, 0xcd, 0x13, 0xe2, 0x33, 0xca, 0xe9, 0x85, 0x68, 0x0e,
   263  	0x7d, 0xce, 0x87, 0x24, 0x6e, 0xfa, 0x71, 0xd0, 0xf4, 0x69, 0x22, 0x5c, 0x92, 0x60, 0x16, 0x6c,
   264  	0x4b, 0x6c, 0x9b, 0x65, 0xc9, 0xd0, 0xe7, 0xdb, 0xa3, 0xdd, 0x26, 0x4d, 0x05, 0xa1, 0x09, 0x6f,
   265  	0xe6, 0x88, 0x9d, 0x32, 0x2a, 0x28, 0xac, 0xde, 0xeb, 0x6d, 0x4d, 0x8c, 0x76, 0xd7, 0xab, 0x21,
   266  	0x0d, 0xa9, 0x12, 0x34, 0xe5, 0x2a, 0xd7, 0xae, 0xd7, 0x43, 0x4a, 0xc3, 0x08, 0x37, 0xd5, 0xce,
   267  	0xcb, 0x2e, 0x9a, 0x82, 0xc4, 0x98, 0x0b, 0x37, 0x4e, 0x73, 0xc1, 0xe6, 0xef, 0x26, 0x98, 0x3f,
   268  	0xcb, 0x6f, 0x81, 0x55, 0x30, 0x1b, 0x60, 0x2f, 0x0b, 0x2d, 0xa3, 0x61, 0x6c, 0x95, 0x9d, 0x7c,
   269  	0x03, 0x0f, 0x01, 0x50, 0x0b, 0x24, 0xc6, 0x29, 0xb6, 0xa6, 0x1a, 0xc6, 0xd6, 0xf2, 0xde, 0x73,
   270  	0xfb, 0xb1, 0x18, 0x6c, 0x6d, 0x64, 0xb7, 0xa5, 0x7e, 0x30, 0x4e, 0xb1, 0x63, 0x06, 0xc5, 0x12,
   271  	0x3e, 0x03, 0x4b, 0x0c, 0x87, 0x84, 0x0b, 0x36, 0x46, 0x8c, 0x52, 0x61, 0x4d, 0x37, 0x8c, 0x2d,
   272  	0xd3, 0x59, 0x2c, 0x40, 0x87, 0x52, 0x21, 0x45, 0xdc, 0x4d, 0x02, 0x8f, 0x5e, 0x21, 0x12, 0xbb,
   273  	0x21, 0xb6, 0x66, 0x72, 0x91, 0x06, 0xbb, 0x12, 0x83, 0x2f, 0x40, 0xa5, 0x10, 0xa5, 0x91, 0x2b,
   274  	0x2e, 0x28, 0x8b, 0xad, 0x59, 0xa5, 0x5b, 0xd1, 0x78, 0x4f, 0xc3, 0xf0, 0x07, 0xb0, 0x7a, 0xe7,
   275  	0xc7, 0x69, 0xe4, 0xca, 0xf8, 0xac, 0x39, 0x95, 0x83, 0xfd, 0xef, 0x39, 0xf4, 0xf5, 0x8d, 0xc5,
   276  	0x29, 0xa7, 0xb8, 0xf3, 0x0e, 0x81, 0x4d, 0x50, 0xf5, 0x28, 0x15, 0xe8, 0x82, 0x44, 0x98, 0xab,
   277  	0x9c, 0x50, 0xea, 0x8a, 0xa1, 0x35, 0xaf, 0x62, 0x59, 0x95, 0xdc, 0xa1, 0xa4, 0x64, 0x66, 0x3d,
   278  	0x57, 0x0c, 0xe1, 0x4b, 0x00, 0x47, 0x31, 0x4a, 0x19, 0xf5, 0x31, 0xe7, 0x94, 0x21, 0x9f, 0x66,
   279  	0x89, 0xb0, 0xca, 0x0d, 0x63, 0x6b, 0xd6, 0xa9, 0x8c, 0xe2, 0x5e, 0x41, 0xb4, 0x24, 0x0e, 0x6d,
   280  	0x50, 0x1d, 0xc5, 0x28, 0xc6, 0x31, 0x65, 0x63, 0xc4, 0xc9, 0x35, 0x46, 0x24, 0x41, 0xb1, 0x67,
   281  	0x99, 0x85, 0xfe, 0x44, 0x51, 0x7d, 0x72, 0x8d, 0xbb, 0xc9, 0x89, 0x07, 0x6b, 0x00, 0xbc, 0xea,
   282  	0x7d, 0x73, 0x7e, 0xd4, 0x96, 0x77, 0x59, 0x40, 0x05, 0xf1, 0x16, 0x02, 0xbf, 0x00, 0x1b, 0xdc,
   283  	0x77, 0x23, 0x8c, 0xfc, 0x34, 0x43, 0x11, 0x89, 0x89, 0xe0, 0x48, 0x50, 0xa4, 0xd3, 0xb2, 0x16,
   284  	0xd4, 0x47, 0x7f, 0xa2, 0x24, 0xad, 0x34, 0x3b, 0x56, 0x82, 0x01, 0xd5, 0x75, 0x80, 0x27, 0xe0,
   285  	0x83, 0x00, 0x5f, 0xb8, 0x59, 0x24, 0xd0, 0x5d, 0xdd, 0x10, 0xf7, 0x99, 0x2b, 0xfc, 0xe1, 0x5d,
   286  	0x74, 0xa1, 0x67, 0x2d, 0xaa, 0xe8, 0xea, 0x5a, 0xdb, 0x2a, 0xa4, 0xfd, 0x5c, 0x99, 0x07, 0xfb,
   287  	0xca, 0x83, 0x5f, 0x81, 0xa7, 0x85, 0xdd, 0x28, 0x7e, 0xcc, 0x67, 0x49, 0xf9, 0x58, 0x5a, 0x74,
   288  	0x1e, 0x3f, 0x34, 0x90, 0x2f, 0x65, 0xe8, 0x32, 0x5c, 0x9c, 0xb5, 0x96, 0x55, 0xfc, 0x8b, 0x0a,
   289  	0xd4, 0x62, 0xd8, 0x00, 0x0b, 0xa7, 0xad, 0x1e, 0xa3, 0x57, 0xe3, 0xfd, 0x20, 0x60, 0xd6, 0x8a,
   290  	0xaa, 0xc9, 0xdb, 0x10, 0xdc, 0x00, 0x66, 0x44, 0x43, 0x14, 0xe1, 0x11, 0x8e, 0xac, 0x8a, 0xe2,
   291  	0xcb, 0x11, 0x0d, 0x8f, 0xe5, 0x1e, 0x7e, 0x0c, 0x9e, 0x10, 0x8a, 0x18, 0x96, 0x4f, 0x56, 0x36,
   292  	0x0e, 0xcd, 0x84, 0x8c, 0x8e, 0x63, 0xdf, 0x5a, 0x55, 0xe1, 0xad, 0x11, 0xea, 0x48, 0x76, 0x90,
   293  	0x93, 0xdd, 0xa4, 0x8f, 0x7d, 0xf8, 0xb3, 0x71, 0x9f, 0xdb, 0x7d, 0xa9, 0xdc, 0x24, 0xa1, 0x42,
   294  	0xbd, 0x1b, 0x6e, 0xc1, 0xc6, 0xf4, 0xd6, 0xc2, 0xde, 0x97, 0xef, 0x6b, 0xa2, 0x77, 0x2b, 0xb8,
   295  	0x7f, 0x6f, 0xd0, 0x49, 0x64, 0xbf, 0x6c, 0x04, 0xff, 0xac, 0x80, 0x9f, 0x00, 0x2b, 0xa1, 0x88,
   296  	0x24, 0x43, 0xcc, 0x88, 0x40, 0x43, 0xca, 0x85, 0xca, 0xe0, 0x9a, 0x26, 0xd8, 0x5a, 0x53, 0x95,
   297  	0xfa, 0x5f, 0x42, 0xbb, 0x39, 0x7d, 0x44, 0xb9, 0x18, 0x68, 0x12, 0x3e, 0x05, 0x80, 0xfb, 0x2c,
   298  	0xf3, 0x50, 0x44, 0x43, 0x6e, 0x55, 0x95, 0xd4, 0x54, 0xc8, 0x31, 0x0d, 0xf9, 0xfa, 0x29, 0x68,
   299  	0xbc, 0x2f, 0x30, 0x58, 0x01, 0xd3, 0x97, 0x78, 0xac, 0xa6, 0x88, 0xe9, 0xc8, 0xa5, 0x9c, 0x2c,
   300  	0x23, 0x37, 0xca, 0xf2, 0xf1, 0x61, 0x3a, 0xf9, 0xe6, 0xb3, 0xa9, 0x4f, 0x8d, 0xcd, 0x17, 0xc0,
   301  	0xbc, 0x9b, 0x16, 0xd0, 0x04, 0xb3, 0xa7, 0xbd, 0x6e, 0xaf, 0x53, 0x29, 0xc1, 0x32, 0x98, 0x39,
   302  	0xec, 0x1e, 0x77, 0x2a, 0x06, 0x9c, 0x07, 0xd3, 0x9d, 0xc1, 0xeb, 0xca, 0xd4, 0x66, 0x13, 0x54,
   303  	0x1e, 0x36, 0x25, 0x5c, 0x00, 0xf3, 0x3d, 0xe7, 0xac, 0xd5, 0xe9, 0xf7, 0x2b, 0x25, 0xb8, 0x0c,
   304  	0xc0, 0xd1, 0x77, 0xbd, 0x8e, 0x73, 0xde, 0xed, 0x9f, 0x39, 0x15, 0x63, 0xf3, 0x8f, 0x69, 0xb0,
   305  	0xac, 0x7b, 0xaa, 0x8d, 0x85, 0x4b, 0x22, 0x2e, 0xb3, 0x53, 0x73, 0x05, 0x25, 0x6e, 0x8c, 0x75,
   306  	0x84, 0xa6, 0x42, 0x4e, 0xdd, 0x18, 0xc3, 0x16, 0x00, 0x3e, 0xc3, 0xae, 0xc0, 0x01, 0x72, 0x85,
   307  	0x0a, 0x76, 0x61, 0x6f, 0xdd, 0xce, 0x67, 0xa8, 0x5d, 0xcc, 0x50, 0x7b, 0x50, 0xcc, 0xd0, 0x83,
   308  	0xf2, 0xcd, 0x6d, 0xbd, 0xf4, 0xcb, 0x9f, 0x75, 0xc3, 0x31, 0xf5, 0xb9, 0x7d, 0x01, 0x3f, 0x04,
   309  	0xf0, 0x12, 0xb3, 0x04, 0x47, 0xaa, 0xe2, 0x68, 0x77, 0x67, 0x07, 0x25, 0x5c, 0x4d, 0xbb, 0x19,
   310  	0x67, 0x25, 0x67, 0xa4, 0xc3, 0xee, 0xce, 0xce, 0x29, 0x87, 0x36, 0x58, 0xd3, 0x1d, 0xee, 0xd3,
   311  	0x38, 0x26, 0x02, 0x79, 0x63, 0x81, 0xb9, 0x1a, 0x7b, 0x33, 0xce, 0x6a, 0x4e, 0xb5, 0x14, 0x73,
   312  	0x20, 0x09, 0x78, 0x08, 0x1a, 0x5a, 0xff, 0x23, 0x65, 0x97, 0x24, 0x09, 0x11, 0xc7, 0x02, 0xa5,
   313  	0x8c, 0x8c, 0x5c, 0x81, 0xf5, 0xe1, 0x59, 0x75, 0xf8, 0xff, 0xb9, 0xee, 0x75, 0x2e, 0xeb, 0x63,
   314  	0xd1, 0xcb, 0x45, 0xb9, 0x4f, 0x1b, 0xd4, 0x1f, 0xf1, 0x51, 0xcd, 0x13, 0x68, 0x9b, 0x39, 0x65,
   315  	0xb3, 0xf1, 0xd0, 0xa6, 0xaf, 0x34, 0xb9, 0xcb, 0x4b, 0x00, 0xf4, 0x34, 0x43, 0x24, 0x50, 0x73,
   316  	0x6f, 0xe9, 0x60, 0x69, 0x72, 0x5b, 0x37, 0x75, 0xd9, 0xbb, 0x6d, 0xc7, 0xd4, 0x82, 0x6e, 0x00,
   317  	0x9f, 0x83, 0x4a, 0xc6, 0x31, 0x7b, 0xa7, 0x2c, 0x65, 0x75, 0xc9, 0x92, 0xc4, 0xef, 0x8b, 0xf2,
   318  	0x0c, 0xcc, 0xe3, 0x2b, 0xec, 0x4b, 0x4f, 0x39, 0xec, 0xcc, 0x03, 0x30, 0xb9, 0xad, 0xcf, 0x75,
   319  	0xae, 0xb0, 0xdf, 0x6d, 0x3b, 0x73, 0x92, 0xea, 0x06, 0x07, 0xc1, 0xcd, 0x9b, 0x5a, 0xe9, 0xb7,
   320  	0x37, 0xb5, 0xd2, 0x4f, 0x93, 0x9a, 0x71, 0x33, 0xa9, 0x19, 0xbf, 0x4e, 0x6a, 0xc6, 0x5f, 0x93,
   321  	0x9a, 0xf1, 0xfd, 0xd7, 0xff, 0xfd, 0x1f, 0xf7, 0x73, 0xfd, 0xfb, 0x6d, 0xc9, 0x9b, 0x53, 0xdf,
   322  	0xfd, 0xa3, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0xba, 0x6d, 0x7b, 0x04, 0xc8, 0x07, 0x00, 0x00,
   323  }
   324  
   325  func (m *Options) Marshal() (dAtA []byte, err error) {
   326  	size := m.Size()
   327  	dAtA = make([]byte, size)
   328  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   329  	if err != nil {
   330  		return nil, err
   331  	}
   332  	return dAtA[:n], nil
   333  }
   334  
   335  func (m *Options) MarshalTo(dAtA []byte) (int, error) {
   336  	size := m.Size()
   337  	return m.MarshalToSizedBuffer(dAtA[:size])
   338  }
   339  
   340  func (m *Options) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   341  	i := len(dAtA)
   342  	_ = i
   343  	var l int
   344  	_ = l
   345  	if m.XXX_unrecognized != nil {
   346  		i -= len(m.XXX_unrecognized)
   347  		copy(dAtA[i:], m.XXX_unrecognized)
   348  	}
   349  	if m.ScrubLogs {
   350  		i--
   351  		if m.ScrubLogs {
   352  			dAtA[i] = 1
   353  		} else {
   354  			dAtA[i] = 0
   355  		}
   356  		i--
   357  		dAtA[i] = 0x1
   358  		i--
   359  		dAtA[i] = 0xa0
   360  	}
   361  	if m.NoInheritHostTimezone {
   362  		i--
   363  		if m.NoInheritHostTimezone {
   364  			dAtA[i] = 1
   365  		} else {
   366  			dAtA[i] = 0
   367  		}
   368  		i--
   369  		dAtA[i] = 0x1
   370  		i--
   371  		dAtA[i] = 0x98
   372  	}
   373  	if len(m.DefaultContainerAnnotations) > 0 {
   374  		for k := range m.DefaultContainerAnnotations {
   375  			v := m.DefaultContainerAnnotations[k]
   376  			baseI := i
   377  			i -= len(v)
   378  			copy(dAtA[i:], v)
   379  			i = encodeVarintRunhcs(dAtA, i, uint64(len(v)))
   380  			i--
   381  			dAtA[i] = 0x12
   382  			i -= len(k)
   383  			copy(dAtA[i:], k)
   384  			i = encodeVarintRunhcs(dAtA, i, uint64(len(k)))
   385  			i--
   386  			dAtA[i] = 0xa
   387  			i = encodeVarintRunhcs(dAtA, i, uint64(baseI-i))
   388  			i--
   389  			dAtA[i] = 0x1
   390  			i--
   391  			dAtA[i] = 0x92
   392  		}
   393  	}
   394  	if m.IoRetryTimeoutInSec != 0 {
   395  		i = encodeVarintRunhcs(dAtA, i, uint64(m.IoRetryTimeoutInSec))
   396  		i--
   397  		dAtA[i] = 0x1
   398  		i--
   399  		dAtA[i] = 0x88
   400  	}
   401  	if len(m.LogLevel) > 0 {
   402  		i -= len(m.LogLevel)
   403  		copy(dAtA[i:], m.LogLevel)
   404  		i = encodeVarintRunhcs(dAtA, i, uint64(len(m.LogLevel)))
   405  		i--
   406  		dAtA[i] = 0x1
   407  		i--
   408  		dAtA[i] = 0x82
   409  	}
   410  	if len(m.NCProxyAddr) > 0 {
   411  		i -= len(m.NCProxyAddr)
   412  		copy(dAtA[i:], m.NCProxyAddr)
   413  		i = encodeVarintRunhcs(dAtA, i, uint64(len(m.NCProxyAddr)))
   414  		i--
   415  		dAtA[i] = 0x7a
   416  	}
   417  	if m.ShareScratch {
   418  		i--
   419  		if m.ShareScratch {
   420  			dAtA[i] = 1
   421  		} else {
   422  			dAtA[i] = 0
   423  		}
   424  		i--
   425  		dAtA[i] = 0x70
   426  	}
   427  	if m.DefaultVmScratchSizeInGb != 0 {
   428  		i = encodeVarintRunhcs(dAtA, i, uint64(m.DefaultVmScratchSizeInGb))
   429  		i--
   430  		dAtA[i] = 0x68
   431  	}
   432  	if m.DefaultContainerScratchSizeInGb != 0 {
   433  		i = encodeVarintRunhcs(dAtA, i, uint64(m.DefaultContainerScratchSizeInGb))
   434  		i--
   435  		dAtA[i] = 0x60
   436  	}
   437  	if m.ScaleCpuLimitsToSandbox {
   438  		i--
   439  		if m.ScaleCpuLimitsToSandbox {
   440  			dAtA[i] = 1
   441  		} else {
   442  			dAtA[i] = 0
   443  		}
   444  		i--
   445  		dAtA[i] = 0x58
   446  	}
   447  	if len(m.GPUVHDPath) > 0 {
   448  		i -= len(m.GPUVHDPath)
   449  		copy(dAtA[i:], m.GPUVHDPath)
   450  		i = encodeVarintRunhcs(dAtA, i, uint64(len(m.GPUVHDPath)))
   451  		i--
   452  		dAtA[i] = 0x52
   453  	}
   454  	if m.VmMemorySizeInMb != 0 {
   455  		i = encodeVarintRunhcs(dAtA, i, uint64(m.VmMemorySizeInMb))
   456  		i--
   457  		dAtA[i] = 0x48
   458  	}
   459  	if m.VmProcessorCount != 0 {
   460  		i = encodeVarintRunhcs(dAtA, i, uint64(m.VmProcessorCount))
   461  		i--
   462  		dAtA[i] = 0x40
   463  	}
   464  	if len(m.BootFilesRootPath) > 0 {
   465  		i -= len(m.BootFilesRootPath)
   466  		copy(dAtA[i:], m.BootFilesRootPath)
   467  		i = encodeVarintRunhcs(dAtA, i, uint64(len(m.BootFilesRootPath)))
   468  		i--
   469  		dAtA[i] = 0x3a
   470  	}
   471  	if m.SandboxIsolation != 0 {
   472  		i = encodeVarintRunhcs(dAtA, i, uint64(m.SandboxIsolation))
   473  		i--
   474  		dAtA[i] = 0x30
   475  	}
   476  	if len(m.SandboxPlatform) > 0 {
   477  		i -= len(m.SandboxPlatform)
   478  		copy(dAtA[i:], m.SandboxPlatform)
   479  		i = encodeVarintRunhcs(dAtA, i, uint64(len(m.SandboxPlatform)))
   480  		i--
   481  		dAtA[i] = 0x2a
   482  	}
   483  	if len(m.SandboxImage) > 0 {
   484  		i -= len(m.SandboxImage)
   485  		copy(dAtA[i:], m.SandboxImage)
   486  		i = encodeVarintRunhcs(dAtA, i, uint64(len(m.SandboxImage)))
   487  		i--
   488  		dAtA[i] = 0x22
   489  	}
   490  	if len(m.RegistryRoot) > 0 {
   491  		i -= len(m.RegistryRoot)
   492  		copy(dAtA[i:], m.RegistryRoot)
   493  		i = encodeVarintRunhcs(dAtA, i, uint64(len(m.RegistryRoot)))
   494  		i--
   495  		dAtA[i] = 0x1a
   496  	}
   497  	if m.DebugType != 0 {
   498  		i = encodeVarintRunhcs(dAtA, i, uint64(m.DebugType))
   499  		i--
   500  		dAtA[i] = 0x10
   501  	}
   502  	if m.Debug {
   503  		i--
   504  		if m.Debug {
   505  			dAtA[i] = 1
   506  		} else {
   507  			dAtA[i] = 0
   508  		}
   509  		i--
   510  		dAtA[i] = 0x8
   511  	}
   512  	return len(dAtA) - i, nil
   513  }
   514  
   515  func (m *ProcessDetails) Marshal() (dAtA []byte, err error) {
   516  	size := m.Size()
   517  	dAtA = make([]byte, size)
   518  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   519  	if err != nil {
   520  		return nil, err
   521  	}
   522  	return dAtA[:n], nil
   523  }
   524  
   525  func (m *ProcessDetails) MarshalTo(dAtA []byte) (int, error) {
   526  	size := m.Size()
   527  	return m.MarshalToSizedBuffer(dAtA[:size])
   528  }
   529  
   530  func (m *ProcessDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   531  	i := len(dAtA)
   532  	_ = i
   533  	var l int
   534  	_ = l
   535  	if m.XXX_unrecognized != nil {
   536  		i -= len(m.XXX_unrecognized)
   537  		copy(dAtA[i:], m.XXX_unrecognized)
   538  	}
   539  	if len(m.ExecID) > 0 {
   540  		i -= len(m.ExecID)
   541  		copy(dAtA[i:], m.ExecID)
   542  		i = encodeVarintRunhcs(dAtA, i, uint64(len(m.ExecID)))
   543  		i--
   544  		dAtA[i] = 0x4a
   545  	}
   546  	if m.UserTime_100Ns != 0 {
   547  		i = encodeVarintRunhcs(dAtA, i, uint64(m.UserTime_100Ns))
   548  		i--
   549  		dAtA[i] = 0x40
   550  	}
   551  	if m.ProcessID != 0 {
   552  		i = encodeVarintRunhcs(dAtA, i, uint64(m.ProcessID))
   553  		i--
   554  		dAtA[i] = 0x38
   555  	}
   556  	if m.MemoryWorkingSetSharedBytes != 0 {
   557  		i = encodeVarintRunhcs(dAtA, i, uint64(m.MemoryWorkingSetSharedBytes))
   558  		i--
   559  		dAtA[i] = 0x30
   560  	}
   561  	if m.MemoryWorkingSetPrivateBytes != 0 {
   562  		i = encodeVarintRunhcs(dAtA, i, uint64(m.MemoryWorkingSetPrivateBytes))
   563  		i--
   564  		dAtA[i] = 0x28
   565  	}
   566  	if m.MemoryCommitBytes != 0 {
   567  		i = encodeVarintRunhcs(dAtA, i, uint64(m.MemoryCommitBytes))
   568  		i--
   569  		dAtA[i] = 0x20
   570  	}
   571  	if m.KernelTime_100Ns != 0 {
   572  		i = encodeVarintRunhcs(dAtA, i, uint64(m.KernelTime_100Ns))
   573  		i--
   574  		dAtA[i] = 0x18
   575  	}
   576  	n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt):])
   577  	if err1 != nil {
   578  		return 0, err1
   579  	}
   580  	i -= n1
   581  	i = encodeVarintRunhcs(dAtA, i, uint64(n1))
   582  	i--
   583  	dAtA[i] = 0x12
   584  	if len(m.ImageName) > 0 {
   585  		i -= len(m.ImageName)
   586  		copy(dAtA[i:], m.ImageName)
   587  		i = encodeVarintRunhcs(dAtA, i, uint64(len(m.ImageName)))
   588  		i--
   589  		dAtA[i] = 0xa
   590  	}
   591  	return len(dAtA) - i, nil
   592  }
   593  
   594  func encodeVarintRunhcs(dAtA []byte, offset int, v uint64) int {
   595  	offset -= sovRunhcs(v)
   596  	base := offset
   597  	for v >= 1<<7 {
   598  		dAtA[offset] = uint8(v&0x7f | 0x80)
   599  		v >>= 7
   600  		offset++
   601  	}
   602  	dAtA[offset] = uint8(v)
   603  	return base
   604  }
   605  func (m *Options) Size() (n int) {
   606  	if m == nil {
   607  		return 0
   608  	}
   609  	var l int
   610  	_ = l
   611  	if m.Debug {
   612  		n += 2
   613  	}
   614  	if m.DebugType != 0 {
   615  		n += 1 + sovRunhcs(uint64(m.DebugType))
   616  	}
   617  	l = len(m.RegistryRoot)
   618  	if l > 0 {
   619  		n += 1 + l + sovRunhcs(uint64(l))
   620  	}
   621  	l = len(m.SandboxImage)
   622  	if l > 0 {
   623  		n += 1 + l + sovRunhcs(uint64(l))
   624  	}
   625  	l = len(m.SandboxPlatform)
   626  	if l > 0 {
   627  		n += 1 + l + sovRunhcs(uint64(l))
   628  	}
   629  	if m.SandboxIsolation != 0 {
   630  		n += 1 + sovRunhcs(uint64(m.SandboxIsolation))
   631  	}
   632  	l = len(m.BootFilesRootPath)
   633  	if l > 0 {
   634  		n += 1 + l + sovRunhcs(uint64(l))
   635  	}
   636  	if m.VmProcessorCount != 0 {
   637  		n += 1 + sovRunhcs(uint64(m.VmProcessorCount))
   638  	}
   639  	if m.VmMemorySizeInMb != 0 {
   640  		n += 1 + sovRunhcs(uint64(m.VmMemorySizeInMb))
   641  	}
   642  	l = len(m.GPUVHDPath)
   643  	if l > 0 {
   644  		n += 1 + l + sovRunhcs(uint64(l))
   645  	}
   646  	if m.ScaleCpuLimitsToSandbox {
   647  		n += 2
   648  	}
   649  	if m.DefaultContainerScratchSizeInGb != 0 {
   650  		n += 1 + sovRunhcs(uint64(m.DefaultContainerScratchSizeInGb))
   651  	}
   652  	if m.DefaultVmScratchSizeInGb != 0 {
   653  		n += 1 + sovRunhcs(uint64(m.DefaultVmScratchSizeInGb))
   654  	}
   655  	if m.ShareScratch {
   656  		n += 2
   657  	}
   658  	l = len(m.NCProxyAddr)
   659  	if l > 0 {
   660  		n += 1 + l + sovRunhcs(uint64(l))
   661  	}
   662  	l = len(m.LogLevel)
   663  	if l > 0 {
   664  		n += 2 + l + sovRunhcs(uint64(l))
   665  	}
   666  	if m.IoRetryTimeoutInSec != 0 {
   667  		n += 2 + sovRunhcs(uint64(m.IoRetryTimeoutInSec))
   668  	}
   669  	if len(m.DefaultContainerAnnotations) > 0 {
   670  		for k, v := range m.DefaultContainerAnnotations {
   671  			_ = k
   672  			_ = v
   673  			mapEntrySize := 1 + len(k) + sovRunhcs(uint64(len(k))) + 1 + len(v) + sovRunhcs(uint64(len(v)))
   674  			n += mapEntrySize + 2 + sovRunhcs(uint64(mapEntrySize))
   675  		}
   676  	}
   677  	if m.NoInheritHostTimezone {
   678  		n += 3
   679  	}
   680  	if m.ScrubLogs {
   681  		n += 3
   682  	}
   683  	if m.XXX_unrecognized != nil {
   684  		n += len(m.XXX_unrecognized)
   685  	}
   686  	return n
   687  }
   688  
   689  func (m *ProcessDetails) Size() (n int) {
   690  	if m == nil {
   691  		return 0
   692  	}
   693  	var l int
   694  	_ = l
   695  	l = len(m.ImageName)
   696  	if l > 0 {
   697  		n += 1 + l + sovRunhcs(uint64(l))
   698  	}
   699  	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt)
   700  	n += 1 + l + sovRunhcs(uint64(l))
   701  	if m.KernelTime_100Ns != 0 {
   702  		n += 1 + sovRunhcs(uint64(m.KernelTime_100Ns))
   703  	}
   704  	if m.MemoryCommitBytes != 0 {
   705  		n += 1 + sovRunhcs(uint64(m.MemoryCommitBytes))
   706  	}
   707  	if m.MemoryWorkingSetPrivateBytes != 0 {
   708  		n += 1 + sovRunhcs(uint64(m.MemoryWorkingSetPrivateBytes))
   709  	}
   710  	if m.MemoryWorkingSetSharedBytes != 0 {
   711  		n += 1 + sovRunhcs(uint64(m.MemoryWorkingSetSharedBytes))
   712  	}
   713  	if m.ProcessID != 0 {
   714  		n += 1 + sovRunhcs(uint64(m.ProcessID))
   715  	}
   716  	if m.UserTime_100Ns != 0 {
   717  		n += 1 + sovRunhcs(uint64(m.UserTime_100Ns))
   718  	}
   719  	l = len(m.ExecID)
   720  	if l > 0 {
   721  		n += 1 + l + sovRunhcs(uint64(l))
   722  	}
   723  	if m.XXX_unrecognized != nil {
   724  		n += len(m.XXX_unrecognized)
   725  	}
   726  	return n
   727  }
   728  
   729  func sovRunhcs(x uint64) (n int) {
   730  	return (math_bits.Len64(x|1) + 6) / 7
   731  }
   732  func sozRunhcs(x uint64) (n int) {
   733  	return sovRunhcs(uint64((x << 1) ^ uint64((int64(x) >> 63))))
   734  }
   735  func (this *Options) String() string {
   736  	if this == nil {
   737  		return "nil"
   738  	}
   739  	keysForDefaultContainerAnnotations := make([]string, 0, len(this.DefaultContainerAnnotations))
   740  	for k, _ := range this.DefaultContainerAnnotations {
   741  		keysForDefaultContainerAnnotations = append(keysForDefaultContainerAnnotations, k)
   742  	}
   743  	github_com_gogo_protobuf_sortkeys.Strings(keysForDefaultContainerAnnotations)
   744  	mapStringForDefaultContainerAnnotations := "map[string]string{"
   745  	for _, k := range keysForDefaultContainerAnnotations {
   746  		mapStringForDefaultContainerAnnotations += fmt.Sprintf("%v: %v,", k, this.DefaultContainerAnnotations[k])
   747  	}
   748  	mapStringForDefaultContainerAnnotations += "}"
   749  	s := strings.Join([]string{`&Options{`,
   750  		`Debug:` + fmt.Sprintf("%v", this.Debug) + `,`,
   751  		`DebugType:` + fmt.Sprintf("%v", this.DebugType) + `,`,
   752  		`RegistryRoot:` + fmt.Sprintf("%v", this.RegistryRoot) + `,`,
   753  		`SandboxImage:` + fmt.Sprintf("%v", this.SandboxImage) + `,`,
   754  		`SandboxPlatform:` + fmt.Sprintf("%v", this.SandboxPlatform) + `,`,
   755  		`SandboxIsolation:` + fmt.Sprintf("%v", this.SandboxIsolation) + `,`,
   756  		`BootFilesRootPath:` + fmt.Sprintf("%v", this.BootFilesRootPath) + `,`,
   757  		`VmProcessorCount:` + fmt.Sprintf("%v", this.VmProcessorCount) + `,`,
   758  		`VmMemorySizeInMb:` + fmt.Sprintf("%v", this.VmMemorySizeInMb) + `,`,
   759  		`GPUVHDPath:` + fmt.Sprintf("%v", this.GPUVHDPath) + `,`,
   760  		`ScaleCpuLimitsToSandbox:` + fmt.Sprintf("%v", this.ScaleCpuLimitsToSandbox) + `,`,
   761  		`DefaultContainerScratchSizeInGb:` + fmt.Sprintf("%v", this.DefaultContainerScratchSizeInGb) + `,`,
   762  		`DefaultVmScratchSizeInGb:` + fmt.Sprintf("%v", this.DefaultVmScratchSizeInGb) + `,`,
   763  		`ShareScratch:` + fmt.Sprintf("%v", this.ShareScratch) + `,`,
   764  		`NCProxyAddr:` + fmt.Sprintf("%v", this.NCProxyAddr) + `,`,
   765  		`LogLevel:` + fmt.Sprintf("%v", this.LogLevel) + `,`,
   766  		`IoRetryTimeoutInSec:` + fmt.Sprintf("%v", this.IoRetryTimeoutInSec) + `,`,
   767  		`DefaultContainerAnnotations:` + mapStringForDefaultContainerAnnotations + `,`,
   768  		`NoInheritHostTimezone:` + fmt.Sprintf("%v", this.NoInheritHostTimezone) + `,`,
   769  		`ScrubLogs:` + fmt.Sprintf("%v", this.ScrubLogs) + `,`,
   770  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
   771  		`}`,
   772  	}, "")
   773  	return s
   774  }
   775  func (this *ProcessDetails) String() string {
   776  	if this == nil {
   777  		return "nil"
   778  	}
   779  	s := strings.Join([]string{`&ProcessDetails{`,
   780  		`ImageName:` + fmt.Sprintf("%v", this.ImageName) + `,`,
   781  		`CreatedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.CreatedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
   782  		`KernelTime_100Ns:` + fmt.Sprintf("%v", this.KernelTime_100Ns) + `,`,
   783  		`MemoryCommitBytes:` + fmt.Sprintf("%v", this.MemoryCommitBytes) + `,`,
   784  		`MemoryWorkingSetPrivateBytes:` + fmt.Sprintf("%v", this.MemoryWorkingSetPrivateBytes) + `,`,
   785  		`MemoryWorkingSetSharedBytes:` + fmt.Sprintf("%v", this.MemoryWorkingSetSharedBytes) + `,`,
   786  		`ProcessID:` + fmt.Sprintf("%v", this.ProcessID) + `,`,
   787  		`UserTime_100Ns:` + fmt.Sprintf("%v", this.UserTime_100Ns) + `,`,
   788  		`ExecID:` + fmt.Sprintf("%v", this.ExecID) + `,`,
   789  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
   790  		`}`,
   791  	}, "")
   792  	return s
   793  }
   794  func valueToStringRunhcs(v interface{}) string {
   795  	rv := reflect.ValueOf(v)
   796  	if rv.IsNil() {
   797  		return "nil"
   798  	}
   799  	pv := reflect.Indirect(rv).Interface()
   800  	return fmt.Sprintf("*%v", pv)
   801  }
   802  func (m *Options) Unmarshal(dAtA []byte) error {
   803  	l := len(dAtA)
   804  	iNdEx := 0
   805  	for iNdEx < l {
   806  		preIndex := iNdEx
   807  		var wire uint64
   808  		for shift := uint(0); ; shift += 7 {
   809  			if shift >= 64 {
   810  				return ErrIntOverflowRunhcs
   811  			}
   812  			if iNdEx >= l {
   813  				return io.ErrUnexpectedEOF
   814  			}
   815  			b := dAtA[iNdEx]
   816  			iNdEx++
   817  			wire |= uint64(b&0x7F) << shift
   818  			if b < 0x80 {
   819  				break
   820  			}
   821  		}
   822  		fieldNum := int32(wire >> 3)
   823  		wireType := int(wire & 0x7)
   824  		if wireType == 4 {
   825  			return fmt.Errorf("proto: Options: wiretype end group for non-group")
   826  		}
   827  		if fieldNum <= 0 {
   828  			return fmt.Errorf("proto: Options: illegal tag %d (wire type %d)", fieldNum, wire)
   829  		}
   830  		switch fieldNum {
   831  		case 1:
   832  			if wireType != 0 {
   833  				return fmt.Errorf("proto: wrong wireType = %d for field Debug", wireType)
   834  			}
   835  			var v int
   836  			for shift := uint(0); ; shift += 7 {
   837  				if shift >= 64 {
   838  					return ErrIntOverflowRunhcs
   839  				}
   840  				if iNdEx >= l {
   841  					return io.ErrUnexpectedEOF
   842  				}
   843  				b := dAtA[iNdEx]
   844  				iNdEx++
   845  				v |= int(b&0x7F) << shift
   846  				if b < 0x80 {
   847  					break
   848  				}
   849  			}
   850  			m.Debug = bool(v != 0)
   851  		case 2:
   852  			if wireType != 0 {
   853  				return fmt.Errorf("proto: wrong wireType = %d for field DebugType", wireType)
   854  			}
   855  			m.DebugType = 0
   856  			for shift := uint(0); ; shift += 7 {
   857  				if shift >= 64 {
   858  					return ErrIntOverflowRunhcs
   859  				}
   860  				if iNdEx >= l {
   861  					return io.ErrUnexpectedEOF
   862  				}
   863  				b := dAtA[iNdEx]
   864  				iNdEx++
   865  				m.DebugType |= Options_DebugType(b&0x7F) << shift
   866  				if b < 0x80 {
   867  					break
   868  				}
   869  			}
   870  		case 3:
   871  			if wireType != 2 {
   872  				return fmt.Errorf("proto: wrong wireType = %d for field RegistryRoot", wireType)
   873  			}
   874  			var stringLen uint64
   875  			for shift := uint(0); ; shift += 7 {
   876  				if shift >= 64 {
   877  					return ErrIntOverflowRunhcs
   878  				}
   879  				if iNdEx >= l {
   880  					return io.ErrUnexpectedEOF
   881  				}
   882  				b := dAtA[iNdEx]
   883  				iNdEx++
   884  				stringLen |= uint64(b&0x7F) << shift
   885  				if b < 0x80 {
   886  					break
   887  				}
   888  			}
   889  			intStringLen := int(stringLen)
   890  			if intStringLen < 0 {
   891  				return ErrInvalidLengthRunhcs
   892  			}
   893  			postIndex := iNdEx + intStringLen
   894  			if postIndex < 0 {
   895  				return ErrInvalidLengthRunhcs
   896  			}
   897  			if postIndex > l {
   898  				return io.ErrUnexpectedEOF
   899  			}
   900  			m.RegistryRoot = string(dAtA[iNdEx:postIndex])
   901  			iNdEx = postIndex
   902  		case 4:
   903  			if wireType != 2 {
   904  				return fmt.Errorf("proto: wrong wireType = %d for field SandboxImage", wireType)
   905  			}
   906  			var stringLen uint64
   907  			for shift := uint(0); ; shift += 7 {
   908  				if shift >= 64 {
   909  					return ErrIntOverflowRunhcs
   910  				}
   911  				if iNdEx >= l {
   912  					return io.ErrUnexpectedEOF
   913  				}
   914  				b := dAtA[iNdEx]
   915  				iNdEx++
   916  				stringLen |= uint64(b&0x7F) << shift
   917  				if b < 0x80 {
   918  					break
   919  				}
   920  			}
   921  			intStringLen := int(stringLen)
   922  			if intStringLen < 0 {
   923  				return ErrInvalidLengthRunhcs
   924  			}
   925  			postIndex := iNdEx + intStringLen
   926  			if postIndex < 0 {
   927  				return ErrInvalidLengthRunhcs
   928  			}
   929  			if postIndex > l {
   930  				return io.ErrUnexpectedEOF
   931  			}
   932  			m.SandboxImage = string(dAtA[iNdEx:postIndex])
   933  			iNdEx = postIndex
   934  		case 5:
   935  			if wireType != 2 {
   936  				return fmt.Errorf("proto: wrong wireType = %d for field SandboxPlatform", wireType)
   937  			}
   938  			var stringLen uint64
   939  			for shift := uint(0); ; shift += 7 {
   940  				if shift >= 64 {
   941  					return ErrIntOverflowRunhcs
   942  				}
   943  				if iNdEx >= l {
   944  					return io.ErrUnexpectedEOF
   945  				}
   946  				b := dAtA[iNdEx]
   947  				iNdEx++
   948  				stringLen |= uint64(b&0x7F) << shift
   949  				if b < 0x80 {
   950  					break
   951  				}
   952  			}
   953  			intStringLen := int(stringLen)
   954  			if intStringLen < 0 {
   955  				return ErrInvalidLengthRunhcs
   956  			}
   957  			postIndex := iNdEx + intStringLen
   958  			if postIndex < 0 {
   959  				return ErrInvalidLengthRunhcs
   960  			}
   961  			if postIndex > l {
   962  				return io.ErrUnexpectedEOF
   963  			}
   964  			m.SandboxPlatform = string(dAtA[iNdEx:postIndex])
   965  			iNdEx = postIndex
   966  		case 6:
   967  			if wireType != 0 {
   968  				return fmt.Errorf("proto: wrong wireType = %d for field SandboxIsolation", wireType)
   969  			}
   970  			m.SandboxIsolation = 0
   971  			for shift := uint(0); ; shift += 7 {
   972  				if shift >= 64 {
   973  					return ErrIntOverflowRunhcs
   974  				}
   975  				if iNdEx >= l {
   976  					return io.ErrUnexpectedEOF
   977  				}
   978  				b := dAtA[iNdEx]
   979  				iNdEx++
   980  				m.SandboxIsolation |= Options_SandboxIsolation(b&0x7F) << shift
   981  				if b < 0x80 {
   982  					break
   983  				}
   984  			}
   985  		case 7:
   986  			if wireType != 2 {
   987  				return fmt.Errorf("proto: wrong wireType = %d for field BootFilesRootPath", wireType)
   988  			}
   989  			var stringLen uint64
   990  			for shift := uint(0); ; shift += 7 {
   991  				if shift >= 64 {
   992  					return ErrIntOverflowRunhcs
   993  				}
   994  				if iNdEx >= l {
   995  					return io.ErrUnexpectedEOF
   996  				}
   997  				b := dAtA[iNdEx]
   998  				iNdEx++
   999  				stringLen |= uint64(b&0x7F) << shift
  1000  				if b < 0x80 {
  1001  					break
  1002  				}
  1003  			}
  1004  			intStringLen := int(stringLen)
  1005  			if intStringLen < 0 {
  1006  				return ErrInvalidLengthRunhcs
  1007  			}
  1008  			postIndex := iNdEx + intStringLen
  1009  			if postIndex < 0 {
  1010  				return ErrInvalidLengthRunhcs
  1011  			}
  1012  			if postIndex > l {
  1013  				return io.ErrUnexpectedEOF
  1014  			}
  1015  			m.BootFilesRootPath = string(dAtA[iNdEx:postIndex])
  1016  			iNdEx = postIndex
  1017  		case 8:
  1018  			if wireType != 0 {
  1019  				return fmt.Errorf("proto: wrong wireType = %d for field VmProcessorCount", wireType)
  1020  			}
  1021  			m.VmProcessorCount = 0
  1022  			for shift := uint(0); ; shift += 7 {
  1023  				if shift >= 64 {
  1024  					return ErrIntOverflowRunhcs
  1025  				}
  1026  				if iNdEx >= l {
  1027  					return io.ErrUnexpectedEOF
  1028  				}
  1029  				b := dAtA[iNdEx]
  1030  				iNdEx++
  1031  				m.VmProcessorCount |= int32(b&0x7F) << shift
  1032  				if b < 0x80 {
  1033  					break
  1034  				}
  1035  			}
  1036  		case 9:
  1037  			if wireType != 0 {
  1038  				return fmt.Errorf("proto: wrong wireType = %d for field VmMemorySizeInMb", wireType)
  1039  			}
  1040  			m.VmMemorySizeInMb = 0
  1041  			for shift := uint(0); ; shift += 7 {
  1042  				if shift >= 64 {
  1043  					return ErrIntOverflowRunhcs
  1044  				}
  1045  				if iNdEx >= l {
  1046  					return io.ErrUnexpectedEOF
  1047  				}
  1048  				b := dAtA[iNdEx]
  1049  				iNdEx++
  1050  				m.VmMemorySizeInMb |= int32(b&0x7F) << shift
  1051  				if b < 0x80 {
  1052  					break
  1053  				}
  1054  			}
  1055  		case 10:
  1056  			if wireType != 2 {
  1057  				return fmt.Errorf("proto: wrong wireType = %d for field GPUVHDPath", wireType)
  1058  			}
  1059  			var stringLen uint64
  1060  			for shift := uint(0); ; shift += 7 {
  1061  				if shift >= 64 {
  1062  					return ErrIntOverflowRunhcs
  1063  				}
  1064  				if iNdEx >= l {
  1065  					return io.ErrUnexpectedEOF
  1066  				}
  1067  				b := dAtA[iNdEx]
  1068  				iNdEx++
  1069  				stringLen |= uint64(b&0x7F) << shift
  1070  				if b < 0x80 {
  1071  					break
  1072  				}
  1073  			}
  1074  			intStringLen := int(stringLen)
  1075  			if intStringLen < 0 {
  1076  				return ErrInvalidLengthRunhcs
  1077  			}
  1078  			postIndex := iNdEx + intStringLen
  1079  			if postIndex < 0 {
  1080  				return ErrInvalidLengthRunhcs
  1081  			}
  1082  			if postIndex > l {
  1083  				return io.ErrUnexpectedEOF
  1084  			}
  1085  			m.GPUVHDPath = string(dAtA[iNdEx:postIndex])
  1086  			iNdEx = postIndex
  1087  		case 11:
  1088  			if wireType != 0 {
  1089  				return fmt.Errorf("proto: wrong wireType = %d for field ScaleCpuLimitsToSandbox", wireType)
  1090  			}
  1091  			var v int
  1092  			for shift := uint(0); ; shift += 7 {
  1093  				if shift >= 64 {
  1094  					return ErrIntOverflowRunhcs
  1095  				}
  1096  				if iNdEx >= l {
  1097  					return io.ErrUnexpectedEOF
  1098  				}
  1099  				b := dAtA[iNdEx]
  1100  				iNdEx++
  1101  				v |= int(b&0x7F) << shift
  1102  				if b < 0x80 {
  1103  					break
  1104  				}
  1105  			}
  1106  			m.ScaleCpuLimitsToSandbox = bool(v != 0)
  1107  		case 12:
  1108  			if wireType != 0 {
  1109  				return fmt.Errorf("proto: wrong wireType = %d for field DefaultContainerScratchSizeInGb", wireType)
  1110  			}
  1111  			m.DefaultContainerScratchSizeInGb = 0
  1112  			for shift := uint(0); ; shift += 7 {
  1113  				if shift >= 64 {
  1114  					return ErrIntOverflowRunhcs
  1115  				}
  1116  				if iNdEx >= l {
  1117  					return io.ErrUnexpectedEOF
  1118  				}
  1119  				b := dAtA[iNdEx]
  1120  				iNdEx++
  1121  				m.DefaultContainerScratchSizeInGb |= int32(b&0x7F) << shift
  1122  				if b < 0x80 {
  1123  					break
  1124  				}
  1125  			}
  1126  		case 13:
  1127  			if wireType != 0 {
  1128  				return fmt.Errorf("proto: wrong wireType = %d for field DefaultVmScratchSizeInGb", wireType)
  1129  			}
  1130  			m.DefaultVmScratchSizeInGb = 0
  1131  			for shift := uint(0); ; shift += 7 {
  1132  				if shift >= 64 {
  1133  					return ErrIntOverflowRunhcs
  1134  				}
  1135  				if iNdEx >= l {
  1136  					return io.ErrUnexpectedEOF
  1137  				}
  1138  				b := dAtA[iNdEx]
  1139  				iNdEx++
  1140  				m.DefaultVmScratchSizeInGb |= int32(b&0x7F) << shift
  1141  				if b < 0x80 {
  1142  					break
  1143  				}
  1144  			}
  1145  		case 14:
  1146  			if wireType != 0 {
  1147  				return fmt.Errorf("proto: wrong wireType = %d for field ShareScratch", wireType)
  1148  			}
  1149  			var v int
  1150  			for shift := uint(0); ; shift += 7 {
  1151  				if shift >= 64 {
  1152  					return ErrIntOverflowRunhcs
  1153  				}
  1154  				if iNdEx >= l {
  1155  					return io.ErrUnexpectedEOF
  1156  				}
  1157  				b := dAtA[iNdEx]
  1158  				iNdEx++
  1159  				v |= int(b&0x7F) << shift
  1160  				if b < 0x80 {
  1161  					break
  1162  				}
  1163  			}
  1164  			m.ShareScratch = bool(v != 0)
  1165  		case 15:
  1166  			if wireType != 2 {
  1167  				return fmt.Errorf("proto: wrong wireType = %d for field NCProxyAddr", wireType)
  1168  			}
  1169  			var stringLen uint64
  1170  			for shift := uint(0); ; shift += 7 {
  1171  				if shift >= 64 {
  1172  					return ErrIntOverflowRunhcs
  1173  				}
  1174  				if iNdEx >= l {
  1175  					return io.ErrUnexpectedEOF
  1176  				}
  1177  				b := dAtA[iNdEx]
  1178  				iNdEx++
  1179  				stringLen |= uint64(b&0x7F) << shift
  1180  				if b < 0x80 {
  1181  					break
  1182  				}
  1183  			}
  1184  			intStringLen := int(stringLen)
  1185  			if intStringLen < 0 {
  1186  				return ErrInvalidLengthRunhcs
  1187  			}
  1188  			postIndex := iNdEx + intStringLen
  1189  			if postIndex < 0 {
  1190  				return ErrInvalidLengthRunhcs
  1191  			}
  1192  			if postIndex > l {
  1193  				return io.ErrUnexpectedEOF
  1194  			}
  1195  			m.NCProxyAddr = string(dAtA[iNdEx:postIndex])
  1196  			iNdEx = postIndex
  1197  		case 16:
  1198  			if wireType != 2 {
  1199  				return fmt.Errorf("proto: wrong wireType = %d for field LogLevel", wireType)
  1200  			}
  1201  			var stringLen uint64
  1202  			for shift := uint(0); ; shift += 7 {
  1203  				if shift >= 64 {
  1204  					return ErrIntOverflowRunhcs
  1205  				}
  1206  				if iNdEx >= l {
  1207  					return io.ErrUnexpectedEOF
  1208  				}
  1209  				b := dAtA[iNdEx]
  1210  				iNdEx++
  1211  				stringLen |= uint64(b&0x7F) << shift
  1212  				if b < 0x80 {
  1213  					break
  1214  				}
  1215  			}
  1216  			intStringLen := int(stringLen)
  1217  			if intStringLen < 0 {
  1218  				return ErrInvalidLengthRunhcs
  1219  			}
  1220  			postIndex := iNdEx + intStringLen
  1221  			if postIndex < 0 {
  1222  				return ErrInvalidLengthRunhcs
  1223  			}
  1224  			if postIndex > l {
  1225  				return io.ErrUnexpectedEOF
  1226  			}
  1227  			m.LogLevel = string(dAtA[iNdEx:postIndex])
  1228  			iNdEx = postIndex
  1229  		case 17:
  1230  			if wireType != 0 {
  1231  				return fmt.Errorf("proto: wrong wireType = %d for field IoRetryTimeoutInSec", wireType)
  1232  			}
  1233  			m.IoRetryTimeoutInSec = 0
  1234  			for shift := uint(0); ; shift += 7 {
  1235  				if shift >= 64 {
  1236  					return ErrIntOverflowRunhcs
  1237  				}
  1238  				if iNdEx >= l {
  1239  					return io.ErrUnexpectedEOF
  1240  				}
  1241  				b := dAtA[iNdEx]
  1242  				iNdEx++
  1243  				m.IoRetryTimeoutInSec |= int32(b&0x7F) << shift
  1244  				if b < 0x80 {
  1245  					break
  1246  				}
  1247  			}
  1248  		case 18:
  1249  			if wireType != 2 {
  1250  				return fmt.Errorf("proto: wrong wireType = %d for field DefaultContainerAnnotations", wireType)
  1251  			}
  1252  			var msglen int
  1253  			for shift := uint(0); ; shift += 7 {
  1254  				if shift >= 64 {
  1255  					return ErrIntOverflowRunhcs
  1256  				}
  1257  				if iNdEx >= l {
  1258  					return io.ErrUnexpectedEOF
  1259  				}
  1260  				b := dAtA[iNdEx]
  1261  				iNdEx++
  1262  				msglen |= int(b&0x7F) << shift
  1263  				if b < 0x80 {
  1264  					break
  1265  				}
  1266  			}
  1267  			if msglen < 0 {
  1268  				return ErrInvalidLengthRunhcs
  1269  			}
  1270  			postIndex := iNdEx + msglen
  1271  			if postIndex < 0 {
  1272  				return ErrInvalidLengthRunhcs
  1273  			}
  1274  			if postIndex > l {
  1275  				return io.ErrUnexpectedEOF
  1276  			}
  1277  			if m.DefaultContainerAnnotations == nil {
  1278  				m.DefaultContainerAnnotations = make(map[string]string)
  1279  			}
  1280  			var mapkey string
  1281  			var mapvalue string
  1282  			for iNdEx < postIndex {
  1283  				entryPreIndex := iNdEx
  1284  				var wire uint64
  1285  				for shift := uint(0); ; shift += 7 {
  1286  					if shift >= 64 {
  1287  						return ErrIntOverflowRunhcs
  1288  					}
  1289  					if iNdEx >= l {
  1290  						return io.ErrUnexpectedEOF
  1291  					}
  1292  					b := dAtA[iNdEx]
  1293  					iNdEx++
  1294  					wire |= uint64(b&0x7F) << shift
  1295  					if b < 0x80 {
  1296  						break
  1297  					}
  1298  				}
  1299  				fieldNum := int32(wire >> 3)
  1300  				if fieldNum == 1 {
  1301  					var stringLenmapkey uint64
  1302  					for shift := uint(0); ; shift += 7 {
  1303  						if shift >= 64 {
  1304  							return ErrIntOverflowRunhcs
  1305  						}
  1306  						if iNdEx >= l {
  1307  							return io.ErrUnexpectedEOF
  1308  						}
  1309  						b := dAtA[iNdEx]
  1310  						iNdEx++
  1311  						stringLenmapkey |= uint64(b&0x7F) << shift
  1312  						if b < 0x80 {
  1313  							break
  1314  						}
  1315  					}
  1316  					intStringLenmapkey := int(stringLenmapkey)
  1317  					if intStringLenmapkey < 0 {
  1318  						return ErrInvalidLengthRunhcs
  1319  					}
  1320  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  1321  					if postStringIndexmapkey < 0 {
  1322  						return ErrInvalidLengthRunhcs
  1323  					}
  1324  					if postStringIndexmapkey > l {
  1325  						return io.ErrUnexpectedEOF
  1326  					}
  1327  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  1328  					iNdEx = postStringIndexmapkey
  1329  				} else if fieldNum == 2 {
  1330  					var stringLenmapvalue uint64
  1331  					for shift := uint(0); ; shift += 7 {
  1332  						if shift >= 64 {
  1333  							return ErrIntOverflowRunhcs
  1334  						}
  1335  						if iNdEx >= l {
  1336  							return io.ErrUnexpectedEOF
  1337  						}
  1338  						b := dAtA[iNdEx]
  1339  						iNdEx++
  1340  						stringLenmapvalue |= uint64(b&0x7F) << shift
  1341  						if b < 0x80 {
  1342  							break
  1343  						}
  1344  					}
  1345  					intStringLenmapvalue := int(stringLenmapvalue)
  1346  					if intStringLenmapvalue < 0 {
  1347  						return ErrInvalidLengthRunhcs
  1348  					}
  1349  					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
  1350  					if postStringIndexmapvalue < 0 {
  1351  						return ErrInvalidLengthRunhcs
  1352  					}
  1353  					if postStringIndexmapvalue > l {
  1354  						return io.ErrUnexpectedEOF
  1355  					}
  1356  					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
  1357  					iNdEx = postStringIndexmapvalue
  1358  				} else {
  1359  					iNdEx = entryPreIndex
  1360  					skippy, err := skipRunhcs(dAtA[iNdEx:])
  1361  					if err != nil {
  1362  						return err
  1363  					}
  1364  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  1365  						return ErrInvalidLengthRunhcs
  1366  					}
  1367  					if (iNdEx + skippy) > postIndex {
  1368  						return io.ErrUnexpectedEOF
  1369  					}
  1370  					iNdEx += skippy
  1371  				}
  1372  			}
  1373  			m.DefaultContainerAnnotations[mapkey] = mapvalue
  1374  			iNdEx = postIndex
  1375  		case 19:
  1376  			if wireType != 0 {
  1377  				return fmt.Errorf("proto: wrong wireType = %d for field NoInheritHostTimezone", wireType)
  1378  			}
  1379  			var v int
  1380  			for shift := uint(0); ; shift += 7 {
  1381  				if shift >= 64 {
  1382  					return ErrIntOverflowRunhcs
  1383  				}
  1384  				if iNdEx >= l {
  1385  					return io.ErrUnexpectedEOF
  1386  				}
  1387  				b := dAtA[iNdEx]
  1388  				iNdEx++
  1389  				v |= int(b&0x7F) << shift
  1390  				if b < 0x80 {
  1391  					break
  1392  				}
  1393  			}
  1394  			m.NoInheritHostTimezone = bool(v != 0)
  1395  		case 20:
  1396  			if wireType != 0 {
  1397  				return fmt.Errorf("proto: wrong wireType = %d for field ScrubLogs", wireType)
  1398  			}
  1399  			var v int
  1400  			for shift := uint(0); ; shift += 7 {
  1401  				if shift >= 64 {
  1402  					return ErrIntOverflowRunhcs
  1403  				}
  1404  				if iNdEx >= l {
  1405  					return io.ErrUnexpectedEOF
  1406  				}
  1407  				b := dAtA[iNdEx]
  1408  				iNdEx++
  1409  				v |= int(b&0x7F) << shift
  1410  				if b < 0x80 {
  1411  					break
  1412  				}
  1413  			}
  1414  			m.ScrubLogs = bool(v != 0)
  1415  		default:
  1416  			iNdEx = preIndex
  1417  			skippy, err := skipRunhcs(dAtA[iNdEx:])
  1418  			if err != nil {
  1419  				return err
  1420  			}
  1421  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1422  				return ErrInvalidLengthRunhcs
  1423  			}
  1424  			if (iNdEx + skippy) > l {
  1425  				return io.ErrUnexpectedEOF
  1426  			}
  1427  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1428  			iNdEx += skippy
  1429  		}
  1430  	}
  1431  
  1432  	if iNdEx > l {
  1433  		return io.ErrUnexpectedEOF
  1434  	}
  1435  	return nil
  1436  }
  1437  func (m *ProcessDetails) Unmarshal(dAtA []byte) error {
  1438  	l := len(dAtA)
  1439  	iNdEx := 0
  1440  	for iNdEx < l {
  1441  		preIndex := iNdEx
  1442  		var wire uint64
  1443  		for shift := uint(0); ; shift += 7 {
  1444  			if shift >= 64 {
  1445  				return ErrIntOverflowRunhcs
  1446  			}
  1447  			if iNdEx >= l {
  1448  				return io.ErrUnexpectedEOF
  1449  			}
  1450  			b := dAtA[iNdEx]
  1451  			iNdEx++
  1452  			wire |= uint64(b&0x7F) << shift
  1453  			if b < 0x80 {
  1454  				break
  1455  			}
  1456  		}
  1457  		fieldNum := int32(wire >> 3)
  1458  		wireType := int(wire & 0x7)
  1459  		if wireType == 4 {
  1460  			return fmt.Errorf("proto: ProcessDetails: wiretype end group for non-group")
  1461  		}
  1462  		if fieldNum <= 0 {
  1463  			return fmt.Errorf("proto: ProcessDetails: illegal tag %d (wire type %d)", fieldNum, wire)
  1464  		}
  1465  		switch fieldNum {
  1466  		case 1:
  1467  			if wireType != 2 {
  1468  				return fmt.Errorf("proto: wrong wireType = %d for field ImageName", wireType)
  1469  			}
  1470  			var stringLen uint64
  1471  			for shift := uint(0); ; shift += 7 {
  1472  				if shift >= 64 {
  1473  					return ErrIntOverflowRunhcs
  1474  				}
  1475  				if iNdEx >= l {
  1476  					return io.ErrUnexpectedEOF
  1477  				}
  1478  				b := dAtA[iNdEx]
  1479  				iNdEx++
  1480  				stringLen |= uint64(b&0x7F) << shift
  1481  				if b < 0x80 {
  1482  					break
  1483  				}
  1484  			}
  1485  			intStringLen := int(stringLen)
  1486  			if intStringLen < 0 {
  1487  				return ErrInvalidLengthRunhcs
  1488  			}
  1489  			postIndex := iNdEx + intStringLen
  1490  			if postIndex < 0 {
  1491  				return ErrInvalidLengthRunhcs
  1492  			}
  1493  			if postIndex > l {
  1494  				return io.ErrUnexpectedEOF
  1495  			}
  1496  			m.ImageName = string(dAtA[iNdEx:postIndex])
  1497  			iNdEx = postIndex
  1498  		case 2:
  1499  			if wireType != 2 {
  1500  				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
  1501  			}
  1502  			var msglen int
  1503  			for shift := uint(0); ; shift += 7 {
  1504  				if shift >= 64 {
  1505  					return ErrIntOverflowRunhcs
  1506  				}
  1507  				if iNdEx >= l {
  1508  					return io.ErrUnexpectedEOF
  1509  				}
  1510  				b := dAtA[iNdEx]
  1511  				iNdEx++
  1512  				msglen |= int(b&0x7F) << shift
  1513  				if b < 0x80 {
  1514  					break
  1515  				}
  1516  			}
  1517  			if msglen < 0 {
  1518  				return ErrInvalidLengthRunhcs
  1519  			}
  1520  			postIndex := iNdEx + msglen
  1521  			if postIndex < 0 {
  1522  				return ErrInvalidLengthRunhcs
  1523  			}
  1524  			if postIndex > l {
  1525  				return io.ErrUnexpectedEOF
  1526  			}
  1527  			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreatedAt, dAtA[iNdEx:postIndex]); err != nil {
  1528  				return err
  1529  			}
  1530  			iNdEx = postIndex
  1531  		case 3:
  1532  			if wireType != 0 {
  1533  				return fmt.Errorf("proto: wrong wireType = %d for field KernelTime_100Ns", wireType)
  1534  			}
  1535  			m.KernelTime_100Ns = 0
  1536  			for shift := uint(0); ; shift += 7 {
  1537  				if shift >= 64 {
  1538  					return ErrIntOverflowRunhcs
  1539  				}
  1540  				if iNdEx >= l {
  1541  					return io.ErrUnexpectedEOF
  1542  				}
  1543  				b := dAtA[iNdEx]
  1544  				iNdEx++
  1545  				m.KernelTime_100Ns |= uint64(b&0x7F) << shift
  1546  				if b < 0x80 {
  1547  					break
  1548  				}
  1549  			}
  1550  		case 4:
  1551  			if wireType != 0 {
  1552  				return fmt.Errorf("proto: wrong wireType = %d for field MemoryCommitBytes", wireType)
  1553  			}
  1554  			m.MemoryCommitBytes = 0
  1555  			for shift := uint(0); ; shift += 7 {
  1556  				if shift >= 64 {
  1557  					return ErrIntOverflowRunhcs
  1558  				}
  1559  				if iNdEx >= l {
  1560  					return io.ErrUnexpectedEOF
  1561  				}
  1562  				b := dAtA[iNdEx]
  1563  				iNdEx++
  1564  				m.MemoryCommitBytes |= uint64(b&0x7F) << shift
  1565  				if b < 0x80 {
  1566  					break
  1567  				}
  1568  			}
  1569  		case 5:
  1570  			if wireType != 0 {
  1571  				return fmt.Errorf("proto: wrong wireType = %d for field MemoryWorkingSetPrivateBytes", wireType)
  1572  			}
  1573  			m.MemoryWorkingSetPrivateBytes = 0
  1574  			for shift := uint(0); ; shift += 7 {
  1575  				if shift >= 64 {
  1576  					return ErrIntOverflowRunhcs
  1577  				}
  1578  				if iNdEx >= l {
  1579  					return io.ErrUnexpectedEOF
  1580  				}
  1581  				b := dAtA[iNdEx]
  1582  				iNdEx++
  1583  				m.MemoryWorkingSetPrivateBytes |= uint64(b&0x7F) << shift
  1584  				if b < 0x80 {
  1585  					break
  1586  				}
  1587  			}
  1588  		case 6:
  1589  			if wireType != 0 {
  1590  				return fmt.Errorf("proto: wrong wireType = %d for field MemoryWorkingSetSharedBytes", wireType)
  1591  			}
  1592  			m.MemoryWorkingSetSharedBytes = 0
  1593  			for shift := uint(0); ; shift += 7 {
  1594  				if shift >= 64 {
  1595  					return ErrIntOverflowRunhcs
  1596  				}
  1597  				if iNdEx >= l {
  1598  					return io.ErrUnexpectedEOF
  1599  				}
  1600  				b := dAtA[iNdEx]
  1601  				iNdEx++
  1602  				m.MemoryWorkingSetSharedBytes |= uint64(b&0x7F) << shift
  1603  				if b < 0x80 {
  1604  					break
  1605  				}
  1606  			}
  1607  		case 7:
  1608  			if wireType != 0 {
  1609  				return fmt.Errorf("proto: wrong wireType = %d for field ProcessID", wireType)
  1610  			}
  1611  			m.ProcessID = 0
  1612  			for shift := uint(0); ; shift += 7 {
  1613  				if shift >= 64 {
  1614  					return ErrIntOverflowRunhcs
  1615  				}
  1616  				if iNdEx >= l {
  1617  					return io.ErrUnexpectedEOF
  1618  				}
  1619  				b := dAtA[iNdEx]
  1620  				iNdEx++
  1621  				m.ProcessID |= uint32(b&0x7F) << shift
  1622  				if b < 0x80 {
  1623  					break
  1624  				}
  1625  			}
  1626  		case 8:
  1627  			if wireType != 0 {
  1628  				return fmt.Errorf("proto: wrong wireType = %d for field UserTime_100Ns", wireType)
  1629  			}
  1630  			m.UserTime_100Ns = 0
  1631  			for shift := uint(0); ; shift += 7 {
  1632  				if shift >= 64 {
  1633  					return ErrIntOverflowRunhcs
  1634  				}
  1635  				if iNdEx >= l {
  1636  					return io.ErrUnexpectedEOF
  1637  				}
  1638  				b := dAtA[iNdEx]
  1639  				iNdEx++
  1640  				m.UserTime_100Ns |= uint64(b&0x7F) << shift
  1641  				if b < 0x80 {
  1642  					break
  1643  				}
  1644  			}
  1645  		case 9:
  1646  			if wireType != 2 {
  1647  				return fmt.Errorf("proto: wrong wireType = %d for field ExecID", wireType)
  1648  			}
  1649  			var stringLen uint64
  1650  			for shift := uint(0); ; shift += 7 {
  1651  				if shift >= 64 {
  1652  					return ErrIntOverflowRunhcs
  1653  				}
  1654  				if iNdEx >= l {
  1655  					return io.ErrUnexpectedEOF
  1656  				}
  1657  				b := dAtA[iNdEx]
  1658  				iNdEx++
  1659  				stringLen |= uint64(b&0x7F) << shift
  1660  				if b < 0x80 {
  1661  					break
  1662  				}
  1663  			}
  1664  			intStringLen := int(stringLen)
  1665  			if intStringLen < 0 {
  1666  				return ErrInvalidLengthRunhcs
  1667  			}
  1668  			postIndex := iNdEx + intStringLen
  1669  			if postIndex < 0 {
  1670  				return ErrInvalidLengthRunhcs
  1671  			}
  1672  			if postIndex > l {
  1673  				return io.ErrUnexpectedEOF
  1674  			}
  1675  			m.ExecID = string(dAtA[iNdEx:postIndex])
  1676  			iNdEx = postIndex
  1677  		default:
  1678  			iNdEx = preIndex
  1679  			skippy, err := skipRunhcs(dAtA[iNdEx:])
  1680  			if err != nil {
  1681  				return err
  1682  			}
  1683  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1684  				return ErrInvalidLengthRunhcs
  1685  			}
  1686  			if (iNdEx + skippy) > l {
  1687  				return io.ErrUnexpectedEOF
  1688  			}
  1689  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1690  			iNdEx += skippy
  1691  		}
  1692  	}
  1693  
  1694  	if iNdEx > l {
  1695  		return io.ErrUnexpectedEOF
  1696  	}
  1697  	return nil
  1698  }
  1699  func skipRunhcs(dAtA []byte) (n int, err error) {
  1700  	l := len(dAtA)
  1701  	iNdEx := 0
  1702  	depth := 0
  1703  	for iNdEx < l {
  1704  		var wire uint64
  1705  		for shift := uint(0); ; shift += 7 {
  1706  			if shift >= 64 {
  1707  				return 0, ErrIntOverflowRunhcs
  1708  			}
  1709  			if iNdEx >= l {
  1710  				return 0, io.ErrUnexpectedEOF
  1711  			}
  1712  			b := dAtA[iNdEx]
  1713  			iNdEx++
  1714  			wire |= (uint64(b) & 0x7F) << shift
  1715  			if b < 0x80 {
  1716  				break
  1717  			}
  1718  		}
  1719  		wireType := int(wire & 0x7)
  1720  		switch wireType {
  1721  		case 0:
  1722  			for shift := uint(0); ; shift += 7 {
  1723  				if shift >= 64 {
  1724  					return 0, ErrIntOverflowRunhcs
  1725  				}
  1726  				if iNdEx >= l {
  1727  					return 0, io.ErrUnexpectedEOF
  1728  				}
  1729  				iNdEx++
  1730  				if dAtA[iNdEx-1] < 0x80 {
  1731  					break
  1732  				}
  1733  			}
  1734  		case 1:
  1735  			iNdEx += 8
  1736  		case 2:
  1737  			var length int
  1738  			for shift := uint(0); ; shift += 7 {
  1739  				if shift >= 64 {
  1740  					return 0, ErrIntOverflowRunhcs
  1741  				}
  1742  				if iNdEx >= l {
  1743  					return 0, io.ErrUnexpectedEOF
  1744  				}
  1745  				b := dAtA[iNdEx]
  1746  				iNdEx++
  1747  				length |= (int(b) & 0x7F) << shift
  1748  				if b < 0x80 {
  1749  					break
  1750  				}
  1751  			}
  1752  			if length < 0 {
  1753  				return 0, ErrInvalidLengthRunhcs
  1754  			}
  1755  			iNdEx += length
  1756  		case 3:
  1757  			depth++
  1758  		case 4:
  1759  			if depth == 0 {
  1760  				return 0, ErrUnexpectedEndOfGroupRunhcs
  1761  			}
  1762  			depth--
  1763  		case 5:
  1764  			iNdEx += 4
  1765  		default:
  1766  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  1767  		}
  1768  		if iNdEx < 0 {
  1769  			return 0, ErrInvalidLengthRunhcs
  1770  		}
  1771  		if depth == 0 {
  1772  			return iNdEx, nil
  1773  		}
  1774  	}
  1775  	return 0, io.ErrUnexpectedEOF
  1776  }
  1777  
  1778  var (
  1779  	ErrInvalidLengthRunhcs        = fmt.Errorf("proto: negative length found during unmarshaling")
  1780  	ErrIntOverflowRunhcs          = fmt.Errorf("proto: integer overflow")
  1781  	ErrUnexpectedEndOfGroupRunhcs = fmt.Errorf("proto: unexpected end of group")
  1782  )
  1783  

View as plain text