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

/*
Package v1alpha1 is a generated protocol buffer package.

It is generated from these files:

	api.proto

It has these top-level messages:

	NodeContext
	ExecuteNodeHookRequest
	ExecuteNodeHookResponse
	SidecarContext
	MutateDomainRequest
	MutateDomainResponse
*/
package v1alpha1

import (
	fmt "fmt"
	math "math"

	proto "github.com/golang/protobuf/proto"

	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

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

type NodeContext struct {
	NodeName string `protobuf:"bytes,1,opt,name=node_name,json=nodeName" json:"node_name,omitempty"`
}

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

func (m *NodeContext) GetNodeName() string {
	if m != nil {
		return m.NodeName
	}
	return ""
}

type ExecuteNodeHookRequest struct {
	// hookPoint identifies which lifecycle hook point is being invoked (e.g. "PreVMStart", "PreVMStop")
	HookPoint string `protobuf:"bytes,1,opt,name=hookPoint" json:"hookPoint,omitempty"`
	// vmi is the VirtualMachineInstance object encoded as JSON
	Vmi []byte `protobuf:"bytes,2,opt,name=vmi,proto3" json:"vmi,omitempty"`
	// node_context provides node-level context for the hook
	NodeContext *NodeContext `protobuf:"bytes,3,opt,name=node_context,json=nodeContext" json:"node_context,omitempty"`
}

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

func (m *ExecuteNodeHookRequest) GetHookPoint() string {
	if m != nil {
		return m.HookPoint
	}
	return ""
}

func (m *ExecuteNodeHookRequest) GetVmi() []byte {
	if m != nil {
		return m.Vmi
	}
	return nil
}

func (m *ExecuteNodeHookRequest) GetNodeContext() *NodeContext {
	if m != nil {
		return m.NodeContext
	}
	return nil
}

type ExecuteNodeHookResponse struct {
}

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

type SidecarContext struct {
	InvocationContext string `protobuf:"bytes,1,opt,name=invocation_context,json=invocationContext" json:"invocation_context,omitempty"`
}

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

func (m *SidecarContext) GetInvocationContext() string {
	if m != nil {
		return m.InvocationContext
	}
	return ""
}

type MutateDomainRequest struct {
	DomainType     string          `protobuf:"bytes,1,opt,name=domain_type,json=domainType" json:"domain_type,omitempty"`
	Domain         []byte          `protobuf:"bytes,2,opt,name=domain,proto3" json:"domain,omitempty"`
	Vmi            []byte          `protobuf:"bytes,3,opt,name=vmi,proto3" json:"vmi,omitempty"`
	SidecarContext *SidecarContext `protobuf:"bytes,4,opt,name=sidecar_context,json=sidecarContext" json:"sidecar_context,omitempty"`
}

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

func (m *MutateDomainRequest) GetDomainType() string {
	if m != nil {
		return m.DomainType
	}
	return ""
}

func (m *MutateDomainRequest) GetDomain() []byte {
	if m != nil {
		return m.Domain
	}
	return nil
}

func (m *MutateDomainRequest) GetVmi() []byte {
	if m != nil {
		return m.Vmi
	}
	return nil
}

func (m *MutateDomainRequest) GetSidecarContext() *SidecarContext {
	if m != nil {
		return m.SidecarContext
	}
	return nil
}

type MutateDomainResponse struct {
	Domain []byte `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty"`
}

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

func (m *MutateDomainResponse) GetDomain() []byte {
	if m != nil {
		return m.Domain
	}
	return nil
}

func init() {
	proto.RegisterType((*NodeContext)(nil), "kubevirt.hooks.plugins.v1alpha1.NodeContext")
	proto.RegisterType((*ExecuteNodeHookRequest)(nil), "kubevirt.hooks.plugins.v1alpha1.ExecuteNodeHookRequest")
	proto.RegisterType((*ExecuteNodeHookResponse)(nil), "kubevirt.hooks.plugins.v1alpha1.ExecuteNodeHookResponse")
	proto.RegisterType((*SidecarContext)(nil), "kubevirt.hooks.plugins.v1alpha1.SidecarContext")
	proto.RegisterType((*MutateDomainRequest)(nil), "kubevirt.hooks.plugins.v1alpha1.MutateDomainRequest")
	proto.RegisterType((*MutateDomainResponse)(nil), "kubevirt.hooks.plugins.v1alpha1.MutateDomainResponse")
}

// 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

// Client API for NodeHookService service

type NodeHookServiceClient interface {
	ExecuteNodeHook(ctx context.Context, in *ExecuteNodeHookRequest, opts ...grpc.CallOption) (*ExecuteNodeHookResponse, error)
}

type nodeHookServiceClient struct {
	cc *grpc.ClientConn
}

func NewNodeHookServiceClient(cc *grpc.ClientConn) NodeHookServiceClient {
	return &nodeHookServiceClient{cc}
}

func (c *nodeHookServiceClient) ExecuteNodeHook(ctx context.Context, in *ExecuteNodeHookRequest, opts ...grpc.CallOption) (*ExecuteNodeHookResponse, error) {
	out := new(ExecuteNodeHookResponse)
	err := grpc.Invoke(ctx, "/kubevirt.hooks.plugins.v1alpha1.NodeHookService/ExecuteNodeHook", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for NodeHookService service

type NodeHookServiceServer interface {
	ExecuteNodeHook(context.Context, *ExecuteNodeHookRequest) (*ExecuteNodeHookResponse, error)
}

func RegisterNodeHookServiceServer(s *grpc.Server, srv NodeHookServiceServer) {
	s.RegisterService(&_NodeHookService_serviceDesc, srv)
}

func _NodeHookService_ExecuteNodeHook_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExecuteNodeHookRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeHookServiceServer).ExecuteNodeHook(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/kubevirt.hooks.plugins.v1alpha1.NodeHookService/ExecuteNodeHook",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeHookServiceServer).ExecuteNodeHook(ctx, req.(*ExecuteNodeHookRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _NodeHookService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "kubevirt.hooks.plugins.v1alpha1.NodeHookService",
	HandlerType: (*NodeHookServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ExecuteNodeHook",
			Handler:    _NodeHookService_ExecuteNodeHook_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api.proto",
}

// Client API for DomainHookService service

type DomainHookServiceClient interface {
	MutateDomain(ctx context.Context, in *MutateDomainRequest, opts ...grpc.CallOption) (*MutateDomainResponse, error)
}

type domainHookServiceClient struct {
	cc *grpc.ClientConn
}

func NewDomainHookServiceClient(cc *grpc.ClientConn) DomainHookServiceClient {
	return &domainHookServiceClient{cc}
}

func (c *domainHookServiceClient) MutateDomain(ctx context.Context, in *MutateDomainRequest, opts ...grpc.CallOption) (*MutateDomainResponse, error) {
	out := new(MutateDomainResponse)
	err := grpc.Invoke(ctx, "/kubevirt.hooks.plugins.v1alpha1.DomainHookService/MutateDomain", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for DomainHookService service

type DomainHookServiceServer interface {
	MutateDomain(context.Context, *MutateDomainRequest) (*MutateDomainResponse, error)
}

func RegisterDomainHookServiceServer(s *grpc.Server, srv DomainHookServiceServer) {
	s.RegisterService(&_DomainHookService_serviceDesc, srv)
}

func _DomainHookService_MutateDomain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MutateDomainRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DomainHookServiceServer).MutateDomain(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/kubevirt.hooks.plugins.v1alpha1.DomainHookService/MutateDomain",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DomainHookServiceServer).MutateDomain(ctx, req.(*MutateDomainRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _DomainHookService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "kubevirt.hooks.plugins.v1alpha1.DomainHookService",
	HandlerType: (*DomainHookServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "MutateDomain",
			Handler:    _DomainHookService_MutateDomain_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api.proto",
}

func init() { proto.RegisterFile("api.proto", fileDescriptor0) }

var fileDescriptor0 = []byte{
	// 395 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x93, 0xcf, 0xae, 0x93, 0x40,
	0x14, 0x87, 0x33, 0x97, 0x9b, 0x9b, 0xcb, 0xa1, 0xe9, 0x9f, 0xd1, 0xd4, 0x5a, 0x4d, 0xda, 0xb0,
	0x6a, 0x8c, 0x62, 0x5a, 0x35, 0xba, 0xd7, 0x26, 0xc6, 0xc4, 0x6a, 0xa8, 0x0b, 0x77, 0xcd, 0x14,
	0x4e, 0xec, 0xa4, 0x65, 0x06, 0x61, 0x20, 0x6d, 0xdc, 0xfa, 0x00, 0x2e, 0xf5, 0x55, 0x7c, 0x3a,
	0x03, 0x03, 0x85, 0x7a, 0x9b, 0x90, 0xee, 0x38, 0x07, 0x0e, 0xe7, 0xfb, 0x7d, 0x30, 0x60, 0xb2,
	0x90, 0x3b, 0x61, 0x24, 0x95, 0xa4, 0xa3, 0x6d, 0xb2, 0xc6, 0x94, 0x47, 0xca, 0xd9, 0x48, 0xb9,
	0x8d, 0x9d, 0x70, 0x97, 0x7c, 0xe3, 0x22, 0x76, 0xd2, 0x29, 0xdb, 0x85, 0x1b, 0x36, 0xb5, 0x9f,
	0x80, 0xb5, 0x90, 0x3e, 0xbe, 0x95, 0x42, 0xe1, 0x5e, 0xd1, 0x47, 0x60, 0x0a, 0xe9, 0xe3, 0x4a,
	0xb0, 0x00, 0x07, 0x64, 0x4c, 0x26, 0xa6, 0x7b, 0x9b, 0x35, 0x16, 0x2c, 0x40, 0xfb, 0x0f, 0x81,
	0xfe, 0x7c, 0x8f, 0x5e, 0xa2, 0x30, 0x9b, 0x79, 0x2f, 0xe5, 0xd6, 0xc5, 0xef, 0x09, 0xc6, 0x8a,
	0x3e, 0x06, 0x33, 0x5b, 0xf0, 0x59, 0x72, 0xa1, 0x8a, 0xb9, 0xaa, 0x41, 0xbb, 0x60, 0xa4, 0x01,
	0x1f, 0x5c, 0x8d, 0xc9, 0xa4, 0xe5, 0x66, 0x97, 0xf4, 0x13, 0xb4, 0xf2, 0x3d, 0x9e, 0xde, 0x3b,
	0x30, 0xc6, 0x64, 0x62, 0xcd, 0x9e, 0x3a, 0x0d, 0xb8, 0x4e, 0x8d, 0xd5, 0xb5, 0x44, 0x55, 0xd8,
	0x0f, 0xe1, 0xc1, 0x1d, 0xb4, 0x38, 0x94, 0x22, 0x46, 0x7b, 0x0e, 0xed, 0x25, 0xf7, 0xd1, 0x63,
	0x51, 0x99, 0xf2, 0x19, 0x50, 0x2e, 0x52, 0xe9, 0x31, 0xc5, 0xa5, 0x38, 0x32, 0x68, 0xec, 0x5e,
	0x75, 0xa7, 0x78, 0xfc, 0xc3, 0xf5, 0xed, 0x55, 0xd7, 0xb0, 0xff, 0x12, 0xb8, 0xf7, 0x31, 0x51,
	0x4c, 0xe1, 0x3b, 0x19, 0x30, 0x2e, 0xca, 0xe8, 0x23, 0xb0, 0xfc, 0xbc, 0xb1, 0x52, 0x87, 0xb0,
	0x94, 0x06, 0xba, 0xf5, 0xe5, 0x10, 0x22, 0xed, 0xc3, 0x8d, 0xae, 0x0a, 0x01, 0x45, 0x55, 0x5a,
	0x31, 0x2a, 0x2b, 0x5f, 0xa1, 0x13, 0x6b, 0xd2, 0x23, 0xd4, 0x75, 0x2e, 0xe6, 0x79, 0xa3, 0x98,
	0xd3, 0x84, 0x6e, 0x3b, 0x3e, 0xa9, 0x6d, 0x07, 0xee, 0x9f, 0xb2, 0x6b, 0x37, 0x35, 0x36, 0x52,
	0x67, 0x9b, 0xfd, 0x26, 0xd0, 0x29, 0x45, 0x2e, 0x31, 0x4a, 0xb9, 0x87, 0xf4, 0x27, 0x81, 0xce,
	0x7f, 0x8e, 0xe9, 0xeb, 0x46, 0xb0, 0xf3, 0x3f, 0xcc, 0xf0, 0xcd, 0xe5, 0x83, 0x1a, 0x79, 0xf6,
	0x8b, 0x40, 0x4f, 0xa7, 0xa8, 0xc3, 0xfd, 0x80, 0x56, 0x3d, 0x20, 0x7d, 0xd9, 0xf8, 0xfe, 0x33,
	0xdf, 0x72, 0xf8, 0xea, 0xc2, 0x29, 0x8d, 0xb4, 0xbe, 0xc9, 0x0f, 0xdb, 0x8b, 0x7f, 0x01, 0x00,
	0x00, 0xff, 0xff, 0xe1, 0x4e, 0x31, 0x81, 0x79, 0x03, 0x00, 0x00,
}
