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

package os

import (
	context "context"
	fmt "fmt"
	math "math"

	proto "github.com/golang/protobuf/proto"
	empty "github.com/golang/protobuf/ptypes/empty"
	grpc "google.golang.org/grpc"

	common "github.com/talos-systems/talos/api/common"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

// The request message containing the containerd namespace.
type ContainerDriver int32

const (
	ContainerDriver_CONTAINERD ContainerDriver = 0
	ContainerDriver_CRI        ContainerDriver = 1
)

var ContainerDriver_name = map[int32]string{
	0: "CONTAINERD",
	1: "CRI",
}

var ContainerDriver_value = map[string]int32{
	"CONTAINERD": 0,
	"CRI":        1,
}

func (x ContainerDriver) String() string {
	return proto.EnumName(ContainerDriver_name, int32(x))
}

func (ContainerDriver) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b20a722d09fd3254, []int{0}
}

type ContainersRequest struct {
	Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// driver might be default "containerd" or "cri"
	Driver               ContainerDriver `protobuf:"varint,2,opt,name=driver,proto3,enum=os.ContainerDriver" json:"driver,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

func (m *ContainersRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ContainersRequest.Unmarshal(m, b)
}

func (m *ContainersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ContainersRequest.Marshal(b, m, deterministic)
}

func (m *ContainersRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContainersRequest.Merge(m, src)
}

func (m *ContainersRequest) XXX_Size() int {
	return xxx_messageInfo_ContainersRequest.Size(m)
}

func (m *ContainersRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ContainersRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ContainersRequest proto.InternalMessageInfo

func (m *ContainersRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *ContainersRequest) GetDriver() ContainerDriver {
	if m != nil {
		return m.Driver
	}
	return ContainerDriver_CONTAINERD
}

// The response message containing the requested containers.
type Container struct {
	Namespace            string   `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Id                   string   `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	Image                string   `protobuf:"bytes,3,opt,name=image,proto3" json:"image,omitempty"`
	Pid                  uint32   `protobuf:"varint,4,opt,name=pid,proto3" json:"pid,omitempty"`
	Status               string   `protobuf:"bytes,5,opt,name=status,proto3" json:"status,omitempty"`
	PodId                string   `protobuf:"bytes,6,opt,name=pod_id,json=podId,proto3" json:"pod_id,omitempty"`
	Name                 string   `protobuf:"bytes,7,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *Container) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Container.Unmarshal(m, b)
}

func (m *Container) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Container.Marshal(b, m, deterministic)
}

func (m *Container) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Container.Merge(m, src)
}

func (m *Container) XXX_Size() int {
	return xxx_messageInfo_Container.Size(m)
}

func (m *Container) XXX_DiscardUnknown() {
	xxx_messageInfo_Container.DiscardUnknown(m)
}

var xxx_messageInfo_Container proto.InternalMessageInfo

func (m *Container) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

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

func (m *Container) GetImage() string {
	if m != nil {
		return m.Image
	}
	return ""
}

func (m *Container) GetPid() uint32 {
	if m != nil {
		return m.Pid
	}
	return 0
}

func (m *Container) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

func (m *Container) GetPodId() string {
	if m != nil {
		return m.PodId
	}
	return ""
}

func (m *Container) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

// The response message containing the requested containers.
type ContainerResponse struct {
	Metadata             *common.NodeMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Containers           []*Container         `protobuf:"bytes,2,rep,name=containers,proto3" json:"containers,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

func (m *ContainerResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ContainerResponse.Unmarshal(m, b)
}

func (m *ContainerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ContainerResponse.Marshal(b, m, deterministic)
}

func (m *ContainerResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContainerResponse.Merge(m, src)
}

func (m *ContainerResponse) XXX_Size() int {
	return xxx_messageInfo_ContainerResponse.Size(m)
}

func (m *ContainerResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ContainerResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ContainerResponse proto.InternalMessageInfo

func (m *ContainerResponse) GetMetadata() *common.NodeMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *ContainerResponse) GetContainers() []*Container {
	if m != nil {
		return m.Containers
	}
	return nil
}

type ContainersReply struct {
	Response             []*ContainerResponse `protobuf:"bytes,1,rep,name=response,proto3" json:"response,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

func (m *ContainersReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ContainersReply.Unmarshal(m, b)
}

func (m *ContainersReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ContainersReply.Marshal(b, m, deterministic)
}

func (m *ContainersReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContainersReply.Merge(m, src)
}

func (m *ContainersReply) XXX_Size() int {
	return xxx_messageInfo_ContainersReply.Size(m)
}

func (m *ContainersReply) XXX_DiscardUnknown() {
	xxx_messageInfo_ContainersReply.DiscardUnknown(m)
}

var xxx_messageInfo_ContainersReply proto.InternalMessageInfo

func (m *ContainersReply) GetResponse() []*ContainerResponse {
	if m != nil {
		return m.Response
	}
	return nil
}

// The request message containing the process name.
type LogsRequest struct {
	Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Id        string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	// driver might be default "containerd" or "cri"
	Driver               ContainerDriver `protobuf:"varint,3,opt,name=driver,proto3,enum=os.ContainerDriver" json:"driver,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

func (m *LogsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LogsRequest.Unmarshal(m, b)
}

func (m *LogsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LogsRequest.Marshal(b, m, deterministic)
}

func (m *LogsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogsRequest.Merge(m, src)
}

func (m *LogsRequest) XXX_Size() int {
	return xxx_messageInfo_LogsRequest.Size(m)
}

func (m *LogsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LogsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LogsRequest proto.InternalMessageInfo

func (m *LogsRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

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

func (m *LogsRequest) GetDriver() ContainerDriver {
	if m != nil {
		return m.Driver
	}
	return ContainerDriver_CONTAINERD
}

// rpc processes
type ProcessesRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *ProcessesRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ProcessesRequest.Unmarshal(m, b)
}

func (m *ProcessesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ProcessesRequest.Marshal(b, m, deterministic)
}

func (m *ProcessesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProcessesRequest.Merge(m, src)
}

func (m *ProcessesRequest) XXX_Size() int {
	return xxx_messageInfo_ProcessesRequest.Size(m)
}

func (m *ProcessesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ProcessesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ProcessesRequest proto.InternalMessageInfo

type ProcessesReply struct {
	Response             []*ProcessResponse `protobuf:"bytes,1,rep,name=response,proto3" json:"response,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

func (m *ProcessesReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ProcessesReply.Unmarshal(m, b)
}

func (m *ProcessesReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ProcessesReply.Marshal(b, m, deterministic)
}

func (m *ProcessesReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProcessesReply.Merge(m, src)
}

func (m *ProcessesReply) XXX_Size() int {
	return xxx_messageInfo_ProcessesReply.Size(m)
}

func (m *ProcessesReply) XXX_DiscardUnknown() {
	xxx_messageInfo_ProcessesReply.DiscardUnknown(m)
}

var xxx_messageInfo_ProcessesReply proto.InternalMessageInfo

func (m *ProcessesReply) GetResponse() []*ProcessResponse {
	if m != nil {
		return m.Response
	}
	return nil
}

type ProcessResponse struct {
	Metadata             *common.NodeMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Processes            []*Process           `protobuf:"bytes,2,rep,name=processes,proto3" json:"processes,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

func (m *ProcessResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ProcessResponse.Unmarshal(m, b)
}

func (m *ProcessResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ProcessResponse.Marshal(b, m, deterministic)
}

func (m *ProcessResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProcessResponse.Merge(m, src)
}

func (m *ProcessResponse) XXX_Size() int {
	return xxx_messageInfo_ProcessResponse.Size(m)
}

func (m *ProcessResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ProcessResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ProcessResponse proto.InternalMessageInfo

func (m *ProcessResponse) GetMetadata() *common.NodeMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *ProcessResponse) GetProcesses() []*Process {
	if m != nil {
		return m.Processes
	}
	return nil
}

type Process struct {
	Pid                  int32    `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"`
	Ppid                 int32    `protobuf:"varint,2,opt,name=ppid,proto3" json:"ppid,omitempty"`
	State                string   `protobuf:"bytes,3,opt,name=state,proto3" json:"state,omitempty"`
	Threads              int32    `protobuf:"varint,4,opt,name=threads,proto3" json:"threads,omitempty"`
	CpuTime              float64  `protobuf:"fixed64,5,opt,name=cpu_time,json=cpuTime,proto3" json:"cpu_time,omitempty"`
	VirtualMemory        uint64   `protobuf:"varint,6,opt,name=virtual_memory,json=virtualMemory,proto3" json:"virtual_memory,omitempty"`
	ResidentMemory       uint64   `protobuf:"varint,7,opt,name=resident_memory,json=residentMemory,proto3" json:"resident_memory,omitempty"`
	Command              string   `protobuf:"bytes,8,opt,name=command,proto3" json:"command,omitempty"`
	Executable           string   `protobuf:"bytes,9,opt,name=executable,proto3" json:"executable,omitempty"`
	Args                 string   `protobuf:"bytes,10,opt,name=args,proto3" json:"args,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *Process) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Process.Unmarshal(m, b)
}

func (m *Process) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Process.Marshal(b, m, deterministic)
}

func (m *Process) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Process.Merge(m, src)
}

func (m *Process) XXX_Size() int {
	return xxx_messageInfo_Process.Size(m)
}

func (m *Process) XXX_DiscardUnknown() {
	xxx_messageInfo_Process.DiscardUnknown(m)
}

var xxx_messageInfo_Process proto.InternalMessageInfo

func (m *Process) GetPid() int32 {
	if m != nil {
		return m.Pid
	}
	return 0
}

func (m *Process) GetPpid() int32 {
	if m != nil {
		return m.Ppid
	}
	return 0
}

func (m *Process) GetState() string {
	if m != nil {
		return m.State
	}
	return ""
}

func (m *Process) GetThreads() int32 {
	if m != nil {
		return m.Threads
	}
	return 0
}

func (m *Process) GetCpuTime() float64 {
	if m != nil {
		return m.CpuTime
	}
	return 0
}

func (m *Process) GetVirtualMemory() uint64 {
	if m != nil {
		return m.VirtualMemory
	}
	return 0
}

func (m *Process) GetResidentMemory() uint64 {
	if m != nil {
		return m.ResidentMemory
	}
	return 0
}

func (m *Process) GetCommand() string {
	if m != nil {
		return m.Command
	}
	return ""
}

func (m *Process) GetExecutable() string {
	if m != nil {
		return m.Executable
	}
	return ""
}

func (m *Process) GetArgs() string {
	if m != nil {
		return m.Args
	}
	return ""
}

// rpc restart
// The request message containing the process to restart.
type RestartRequest struct {
	Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Id        string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	// driver might be default "containerd" or "cri"
	Driver               ContainerDriver `protobuf:"varint,3,opt,name=driver,proto3,enum=os.ContainerDriver" json:"driver,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

func (m *RestartRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RestartRequest.Unmarshal(m, b)
}

func (m *RestartRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RestartRequest.Marshal(b, m, deterministic)
}

func (m *RestartRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RestartRequest.Merge(m, src)
}

func (m *RestartRequest) XXX_Size() int {
	return xxx_messageInfo_RestartRequest.Size(m)
}

func (m *RestartRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RestartRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RestartRequest proto.InternalMessageInfo

func (m *RestartRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

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

func (m *RestartRequest) GetDriver() ContainerDriver {
	if m != nil {
		return m.Driver
	}
	return ContainerDriver_CONTAINERD
}

type RestartResponse struct {
	Metadata             *common.NodeMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

func (m *RestartResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RestartResponse.Unmarshal(m, b)
}

func (m *RestartResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RestartResponse.Marshal(b, m, deterministic)
}

func (m *RestartResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RestartResponse.Merge(m, src)
}

func (m *RestartResponse) XXX_Size() int {
	return xxx_messageInfo_RestartResponse.Size(m)
}

func (m *RestartResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RestartResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RestartResponse proto.InternalMessageInfo

func (m *RestartResponse) GetMetadata() *common.NodeMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

// The response message containing the restart status.
type RestartReply struct {
	Response             []*RestartResponse `protobuf:"bytes,1,rep,name=response,proto3" json:"response,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

func (m *RestartReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RestartReply.Unmarshal(m, b)
}

func (m *RestartReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RestartReply.Marshal(b, m, deterministic)
}

func (m *RestartReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RestartReply.Merge(m, src)
}

func (m *RestartReply) XXX_Size() int {
	return xxx_messageInfo_RestartReply.Size(m)
}

func (m *RestartReply) XXX_DiscardUnknown() {
	xxx_messageInfo_RestartReply.DiscardUnknown(m)
}

var xxx_messageInfo_RestartReply proto.InternalMessageInfo

func (m *RestartReply) GetResponse() []*RestartResponse {
	if m != nil {
		return m.Response
	}
	return nil
}

// The request message containing the containerd namespace.
type StatsRequest struct {
	Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// driver might be default "containerd" or "cri"
	Driver               ContainerDriver `protobuf:"varint,2,opt,name=driver,proto3,enum=os.ContainerDriver" json:"driver,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

func (m *StatsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StatsRequest.Unmarshal(m, b)
}

func (m *StatsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StatsRequest.Marshal(b, m, deterministic)
}

func (m *StatsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StatsRequest.Merge(m, src)
}

func (m *StatsRequest) XXX_Size() int {
	return xxx_messageInfo_StatsRequest.Size(m)
}

func (m *StatsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_StatsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_StatsRequest proto.InternalMessageInfo

func (m *StatsRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *StatsRequest) GetDriver() ContainerDriver {
	if m != nil {
		return m.Driver
	}
	return ContainerDriver_CONTAINERD
}

// The response message containing the requested stats.
type StatsResponse struct {
	Metadata             *common.NodeMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Stats                []*Stat              `protobuf:"bytes,2,rep,name=stats,proto3" json:"stats,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

func (m *StatsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StatsResponse.Unmarshal(m, b)
}

func (m *StatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StatsResponse.Marshal(b, m, deterministic)
}

func (m *StatsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StatsResponse.Merge(m, src)
}

func (m *StatsResponse) XXX_Size() int {
	return xxx_messageInfo_StatsResponse.Size(m)
}

func (m *StatsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_StatsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_StatsResponse proto.InternalMessageInfo

func (m *StatsResponse) GetMetadata() *common.NodeMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *StatsResponse) GetStats() []*Stat {
	if m != nil {
		return m.Stats
	}
	return nil
}

type StatsReply struct {
	Response             []*StatsResponse `protobuf:"bytes,1,rep,name=response,proto3" json:"response,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

func (m *StatsReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StatsReply.Unmarshal(m, b)
}

func (m *StatsReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StatsReply.Marshal(b, m, deterministic)
}

func (m *StatsReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StatsReply.Merge(m, src)
}

func (m *StatsReply) XXX_Size() int {
	return xxx_messageInfo_StatsReply.Size(m)
}

func (m *StatsReply) XXX_DiscardUnknown() {
	xxx_messageInfo_StatsReply.DiscardUnknown(m)
}

var xxx_messageInfo_StatsReply proto.InternalMessageInfo

func (m *StatsReply) GetResponse() []*StatsResponse {
	if m != nil {
		return m.Response
	}
	return nil
}

// The response message containing the requested stat.
type Stat struct {
	Namespace            string   `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Id                   string   `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	MemoryUsage          uint64   `protobuf:"varint,4,opt,name=memory_usage,json=memoryUsage,proto3" json:"memory_usage,omitempty"`
	CpuUsage             uint64   `protobuf:"varint,5,opt,name=cpu_usage,json=cpuUsage,proto3" json:"cpu_usage,omitempty"`
	PodId                string   `protobuf:"bytes,6,opt,name=pod_id,json=podId,proto3" json:"pod_id,omitempty"`
	Name                 string   `protobuf:"bytes,7,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *Stat) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Stat.Unmarshal(m, b)
}

func (m *Stat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Stat.Marshal(b, m, deterministic)
}

func (m *Stat) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Stat.Merge(m, src)
}

func (m *Stat) XXX_Size() int {
	return xxx_messageInfo_Stat.Size(m)
}

func (m *Stat) XXX_DiscardUnknown() {
	xxx_messageInfo_Stat.DiscardUnknown(m)
}

var xxx_messageInfo_Stat proto.InternalMessageInfo

func (m *Stat) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

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

func (m *Stat) GetMemoryUsage() uint64 {
	if m != nil {
		return m.MemoryUsage
	}
	return 0
}

func (m *Stat) GetCpuUsage() uint64 {
	if m != nil {
		return m.CpuUsage
	}
	return 0
}

func (m *Stat) GetPodId() string {
	if m != nil {
		return m.PodId
	}
	return ""
}

func (m *Stat) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func init() {
	proto.RegisterEnum("os.ContainerDriver", ContainerDriver_name, ContainerDriver_value)
	proto.RegisterType((*ContainersRequest)(nil), "os.ContainersRequest")
	proto.RegisterType((*Container)(nil), "os.Container")
	proto.RegisterType((*ContainerResponse)(nil), "os.ContainerResponse")
	proto.RegisterType((*ContainersReply)(nil), "os.ContainersReply")
	proto.RegisterType((*LogsRequest)(nil), "os.LogsRequest")
	proto.RegisterType((*ProcessesRequest)(nil), "os.ProcessesRequest")
	proto.RegisterType((*ProcessesReply)(nil), "os.ProcessesReply")
	proto.RegisterType((*ProcessResponse)(nil), "os.ProcessResponse")
	proto.RegisterType((*Process)(nil), "os.Process")
	proto.RegisterType((*RestartRequest)(nil), "os.RestartRequest")
	proto.RegisterType((*RestartResponse)(nil), "os.RestartResponse")
	proto.RegisterType((*RestartReply)(nil), "os.RestartReply")
	proto.RegisterType((*StatsRequest)(nil), "os.StatsRequest")
	proto.RegisterType((*StatsResponse)(nil), "os.StatsResponse")
	proto.RegisterType((*StatsReply)(nil), "os.StatsReply")
	proto.RegisterType((*Stat)(nil), "os.Stat")
}

func init() { proto.RegisterFile("os/os.proto", fileDescriptor_b20a722d09fd3254) }

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// OSClient is the client API for OS service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type OSClient interface {
	Containers(ctx context.Context, in *ContainersRequest, opts ...grpc.CallOption) (*ContainersReply, error)
	Dmesg(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*common.DataReply, error)
	Logs(ctx context.Context, in *LogsRequest, opts ...grpc.CallOption) (OS_LogsClient, error)
	Processes(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*ProcessesReply, error)
	Restart(ctx context.Context, in *RestartRequest, opts ...grpc.CallOption) (*RestartReply, error)
	Stats(ctx context.Context, in *StatsRequest, opts ...grpc.CallOption) (*StatsReply, error)
}

type oSClient struct {
	cc *grpc.ClientConn
}

func NewOSClient(cc *grpc.ClientConn) OSClient {
	return &oSClient{cc}
}

func (c *oSClient) Containers(ctx context.Context, in *ContainersRequest, opts ...grpc.CallOption) (*ContainersReply, error) {
	out := new(ContainersReply)
	err := c.cc.Invoke(ctx, "/os.OS/Containers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *oSClient) Dmesg(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*common.DataReply, error) {
	out := new(common.DataReply)
	err := c.cc.Invoke(ctx, "/os.OS/Dmesg", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *oSClient) Logs(ctx context.Context, in *LogsRequest, opts ...grpc.CallOption) (OS_LogsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_OS_serviceDesc.Streams[0], "/os.OS/Logs", opts...)
	if err != nil {
		return nil, err
	}
	x := &oSLogsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type OS_LogsClient interface {
	Recv() (*common.Data, error)
	grpc.ClientStream
}

type oSLogsClient struct {
	grpc.ClientStream
}

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

func (c *oSClient) Processes(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*ProcessesReply, error) {
	out := new(ProcessesReply)
	err := c.cc.Invoke(ctx, "/os.OS/Processes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *oSClient) Restart(ctx context.Context, in *RestartRequest, opts ...grpc.CallOption) (*RestartReply, error) {
	out := new(RestartReply)
	err := c.cc.Invoke(ctx, "/os.OS/Restart", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *oSClient) Stats(ctx context.Context, in *StatsRequest, opts ...grpc.CallOption) (*StatsReply, error) {
	out := new(StatsReply)
	err := c.cc.Invoke(ctx, "/os.OS/Stats", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// OSServer is the server API for OS service.
type OSServer interface {
	Containers(context.Context, *ContainersRequest) (*ContainersReply, error)
	Dmesg(context.Context, *empty.Empty) (*common.DataReply, error)
	Logs(*LogsRequest, OS_LogsServer) error
	Processes(context.Context, *empty.Empty) (*ProcessesReply, error)
	Restart(context.Context, *RestartRequest) (*RestartReply, error)
	Stats(context.Context, *StatsRequest) (*StatsReply, error)
}

func RegisterOSServer(s *grpc.Server, srv OSServer) {
	s.RegisterService(&_OS_serviceDesc, srv)
}

func _OS_Containers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(OSServer).Containers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/os.OS/Containers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(OSServer).Containers(ctx, req.(*ContainersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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

func _OS_Logs_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LogsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(OSServer).Logs(m, &oSLogsServer{stream})
}

type OS_LogsServer interface {
	Send(*common.Data) error
	grpc.ServerStream
}

type oSLogsServer struct {
	grpc.ServerStream
}

func (x *oSLogsServer) Send(m *common.Data) error {
	return x.ServerStream.SendMsg(m)
}

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

func _OS_Restart_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RestartRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(OSServer).Restart(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/os.OS/Restart",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(OSServer).Restart(ctx, req.(*RestartRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _OS_Stats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StatsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(OSServer).Stats(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/os.OS/Stats",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(OSServer).Stats(ctx, req.(*StatsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _OS_serviceDesc = grpc.ServiceDesc{
	ServiceName: "os.OS",
	HandlerType: (*OSServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Containers",
			Handler:    _OS_Containers_Handler,
		},
		{
			MethodName: "Dmesg",
			Handler:    _OS_Dmesg_Handler,
		},
		{
			MethodName: "Processes",
			Handler:    _OS_Processes_Handler,
		},
		{
			MethodName: "Restart",
			Handler:    _OS_Restart_Handler,
		},
		{
			MethodName: "Stats",
			Handler:    _OS_Stats_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Logs",
			Handler:       _OS_Logs_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "os/os.proto",
}