From 10c29fc7b15f2e93343add9683fdaaea58ebf855 Mon Sep 17 00:00:00 2001 From: Kathryn Baldauf Date: Tue, 6 Jun 2023 10:22:58 -0700 Subject: [PATCH] Create a v0 nodenetsvc api and plumb through ncproxy code Signed-off-by: Kathryn Baldauf --- cmd/ncproxy/ncproxy.go | 2 +- cmd/ncproxy/run.go | 32 + cmd/ncproxy/server_test.go | 98 +- pkg/ncproxy/nodenetsvc/v0/doc.go | 3 + .../nodenetsvc/v0/mock/nodenetsvc_mock.pb.go | 200 ++ pkg/ncproxy/nodenetsvc/v0/nodenetsvc.pb.go | 2610 +++++++++++++++++ pkg/ncproxy/nodenetsvc/v0/nodenetsvc.proto | 63 + 7 files changed, 3004 insertions(+), 4 deletions(-) create mode 100644 pkg/ncproxy/nodenetsvc/v0/doc.go create mode 100644 pkg/ncproxy/nodenetsvc/v0/mock/nodenetsvc_mock.pb.go create mode 100644 pkg/ncproxy/nodenetsvc/v0/nodenetsvc.pb.go create mode 100644 pkg/ncproxy/nodenetsvc/v0/nodenetsvc.proto diff --git a/cmd/ncproxy/ncproxy.go b/cmd/ncproxy/ncproxy.go index ac402dc4ac..3e016c24bc 100644 --- a/cmd/ncproxy/ncproxy.go +++ b/cmd/ncproxy/ncproxy.go @@ -855,7 +855,7 @@ func (s *ttrpcService) ConfigureNetworking(ctx context.Context, req *ncproxyttrp ctx, cancel := context.WithTimeout(ctx, 5*time.Minute) defer cancel() - if _, err := nodeNetSvcClient.client.ConfigureNetworking(ctx, netsvcReq); err != nil { + if _, err := nodeNetSvcClient.ConfigureNetworking(ctx, netsvcReq); err != nil { return nil, err } return &ncproxyttrpc.ConfigureNetworkingInternalResponse{}, nil diff --git a/cmd/ncproxy/run.go b/cmd/ncproxy/run.go index 4bccef192d..222c3a5e00 100644 --- a/cmd/ncproxy/run.go +++ b/cmd/ncproxy/run.go @@ -19,6 +19,7 @@ import ( "github.com/Microsoft/hcsshim/internal/debug" "github.com/Microsoft/hcsshim/internal/log" "github.com/Microsoft/hcsshim/internal/oc" + nodenetsvcV0 "github.com/Microsoft/hcsshim/pkg/ncproxy/nodenetsvc/v0" nodenetsvc "github.com/Microsoft/hcsshim/pkg/ncproxy/nodenetsvc/v1" "github.com/containerd/ttrpc" "github.com/pkg/errors" @@ -27,14 +28,42 @@ import ( "go.opencensus.io/plugin/ocgrpc" "go.opencensus.io/trace" "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" ) type nodeNetSvcConn struct { client nodenetsvc.NodeNetworkServiceClient + v0Client nodenetsvcV0.NodeNetworkServiceClient addr string grpcConn *grpc.ClientConn } +func (n *nodeNetSvcConn) ConfigureNetworking(ctx context.Context, req *nodenetsvc.ConfigureNetworkingRequest) (*nodenetsvc.ConfigureNetworkingResponse, error) { + // try to use v1 client + _, err := n.client.ConfigureNetworking(ctx, req) + if err != nil { + errCode := status.Code(err) + if errCode == codes.Unimplemented { + // v1 api call for ConfigureNetworking returned "unimplemented", + // try the v0 client instead + log.G(ctx).Info("falling back to v0 nodenetsvc api") + v0Req := &nodenetsvcV0.ConfigureNetworkingRequest{ + ContainerID: req.ContainerID, + RequestType: nodenetsvcV0.RequestType(req.RequestType), + } + _, err = n.v0Client.ConfigureNetworking(ctx, v0Req) + if err != nil { + return nil, err + } + + return &nodenetsvc.ConfigureNetworkingResponse{}, nil + } + return nil, err + } + return &nodenetsvc.ConfigureNetworkingResponse{}, nil +} + type computeAgentClient struct { raw *ttrpc.Client computeagent.ComputeAgentService @@ -207,10 +236,13 @@ func run(clicontext *cli.Context) error { log.G(ctx).Infof("Successfully connected to NodeNetworkService at address %s", conf.NodeNetSvcAddr) + // create a client for both api versions netSvcClient := nodenetsvc.NewNodeNetworkServiceClient(client) + v0NetSvcClient := nodenetsvcV0.NewNodeNetworkServiceClient(client) nodeNetSvcClient = &nodeNetSvcConn{ addr: conf.NodeNetSvcAddr, client: netSvcClient, + v0Client: v0NetSvcClient, grpcConn: client, } } diff --git a/cmd/ncproxy/server_test.go b/cmd/ncproxy/server_test.go index 15921e2fa9..ddfdea3aba 100644 --- a/cmd/ncproxy/server_test.go +++ b/cmd/ncproxy/server_test.go @@ -12,12 +12,16 @@ import ( computeagentMock "github.com/Microsoft/hcsshim/internal/computeagent/mock" ncproxystore "github.com/Microsoft/hcsshim/internal/ncproxy/store" "github.com/Microsoft/hcsshim/internal/ncproxyttrpc" + nodenetsvcV0 "github.com/Microsoft/hcsshim/pkg/ncproxy/nodenetsvc/v0" + nodenetsvcMockV0 "github.com/Microsoft/hcsshim/pkg/ncproxy/nodenetsvc/v0/mock" nodenetsvc "github.com/Microsoft/hcsshim/pkg/ncproxy/nodenetsvc/v1" nodenetsvcMock "github.com/Microsoft/hcsshim/pkg/ncproxy/nodenetsvc/v1/mock" "github.com/containerd/ttrpc" "github.com/golang/mock/gomock" "github.com/pkg/errors" bolt "go.etcd.io/bbolt" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" ) func TestRegisterComputeAgent(t *testing.T) { @@ -65,7 +69,7 @@ func TestRegisterComputeAgent(t *testing.T) { } } -func TestConfigureNetworking(t *testing.T) { +func TestConfigureNetworking_V1(t *testing.T) { ctx := context.Background() // setup test database @@ -86,10 +90,14 @@ func TestConfigureNetworking(t *testing.T) { nodeNetCtrl := gomock.NewController(t) defer nodeNetCtrl.Finish() mockedClient := nodenetsvcMock.NewMockNodeNetworkServiceClient(nodeNetCtrl) + mockedClientV0 := nodenetsvcMockV0.NewMockNodeNetworkServiceClient(nodeNetCtrl) nodeNetSvcClient = &nodeNetSvcConn{ - addr: "", - client: mockedClient, + addr: "", + client: mockedClient, + v0Client: mockedClientV0, } + + // allow calls to v1 mock api mockedClient.EXPECT().ConfigureNetworking(gomock.Any(), gomock.Any()).Return(&nodenetsvc.ConfigureNetworkingResponse{}, nil).AnyTimes() type config struct { @@ -143,6 +151,90 @@ func TestConfigureNetworking(t *testing.T) { } } +func TestConfigureNetworking_V0(t *testing.T) { + ctx := context.Background() + + // setup test database + tempDir := t.TempDir() + + db, err := bolt.Open(filepath.Join(tempDir, "networkproxy.db.test"), 0600, nil) + if err != nil { + t.Fatal(err) + } + defer db.Close() + + // create test TTRPC service + store := ncproxystore.NewComputeAgentStore(db) + agentCache := newComputeAgentCache() + tService := newTTRPCService(ctx, agentCache, store) + + // setup mocked client and mocked calls for nodenetsvc + nodeNetCtrl := gomock.NewController(t) + defer nodeNetCtrl.Finish() + mockedClient := nodenetsvcMock.NewMockNodeNetworkServiceClient(nodeNetCtrl) + mockedClientV0 := nodenetsvcMockV0.NewMockNodeNetworkServiceClient(nodeNetCtrl) + nodeNetSvcClient = &nodeNetSvcConn{ + addr: "", + client: mockedClient, + v0Client: mockedClientV0, + } + + // v1 api calls should return "Unimplemented" so that we will try the v0 code path + // allow succcessful calls to v0 api + mockedClientV0.EXPECT().ConfigureNetworking(gomock.Any(), gomock.Any()).Return(&nodenetsvcV0.ConfigureNetworkingResponse{}, nil).AnyTimes() + mockedClient.EXPECT().ConfigureNetworking(gomock.Any(), gomock.Any()).Return(nil, status.Error(codes.Unimplemented, "mock the v1 api not implemented")).AnyTimes() + + type config struct { + name string + containerID string + requestType ncproxyttrpc.RequestTypeInternal + errorExpected bool + } + containerID := t.Name() + "-containerID" + tests := []config{ + { + name: "Configure Networking setup returns no error", + containerID: containerID, + requestType: ncproxyttrpc.RequestTypeInternal_Setup, + errorExpected: false, + }, + { + name: "Configure Networking teardown returns no error", + containerID: containerID, + requestType: ncproxyttrpc.RequestTypeInternal_Teardown, + errorExpected: false, + }, + { + name: "Configure Networking setup returns error when container ID is empty", + containerID: "", + requestType: ncproxyttrpc.RequestTypeInternal_Setup, + errorExpected: true, + }, + { + name: "Configure Networking setup returns error when request type is not supported", + containerID: containerID, + requestType: 3, // unsupported request type + errorExpected: true, + }, + } + + for _, test := range tests { + t.Run(test.name, func(_ *testing.T) { + req := &ncproxyttrpc.ConfigureNetworkingInternalRequest{ + ContainerID: test.containerID, + RequestType: test.requestType, + } + _, err := tService.ConfigureNetworking(ctx, req) + if test.errorExpected && err == nil { + t.Fatalf("expected ConfigureNetworking to return an error") + } + if !test.errorExpected && err != nil { + t.Fatalf("expected ConfigureNetworking to return no error, instead got %v", err) + } + }) + } +} + func TestReconnectComputeAgents_Success(t *testing.T) { ctx := context.Background() diff --git a/pkg/ncproxy/nodenetsvc/v0/doc.go b/pkg/ncproxy/nodenetsvc/v0/doc.go new file mode 100644 index 0000000000..1a65eb8e17 --- /dev/null +++ b/pkg/ncproxy/nodenetsvc/v0/doc.go @@ -0,0 +1,3 @@ +package v0 + +//go:generate go run github.com/golang/mock/mockgen -source=nodenetsvc.pb.go -package=nodenetsvc_v0_mock -destination=mock\nodenetsvc_mock.pb.go diff --git a/pkg/ncproxy/nodenetsvc/v0/mock/nodenetsvc_mock.pb.go b/pkg/ncproxy/nodenetsvc/v0/mock/nodenetsvc_mock.pb.go new file mode 100644 index 0000000000..ec32b60e96 --- /dev/null +++ b/pkg/ncproxy/nodenetsvc/v0/mock/nodenetsvc_mock.pb.go @@ -0,0 +1,200 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: nodenetsvc.pb.go + +// Package nodenetsvc_v0_mock is a generated GoMock package. +package nodenetsvc_v0_mock + +import ( + context "context" + reflect "reflect" + + v0 "github.com/Microsoft/hcsshim/pkg/ncproxy/nodenetsvc/v0" + gomock "github.com/golang/mock/gomock" + grpc "google.golang.org/grpc" +) + +// MockNodeNetworkServiceClient is a mock of NodeNetworkServiceClient interface. +type MockNodeNetworkServiceClient struct { + ctrl *gomock.Controller + recorder *MockNodeNetworkServiceClientMockRecorder +} + +// MockNodeNetworkServiceClientMockRecorder is the mock recorder for MockNodeNetworkServiceClient. +type MockNodeNetworkServiceClientMockRecorder struct { + mock *MockNodeNetworkServiceClient +} + +// NewMockNodeNetworkServiceClient creates a new mock instance. +func NewMockNodeNetworkServiceClient(ctrl *gomock.Controller) *MockNodeNetworkServiceClient { + mock := &MockNodeNetworkServiceClient{ctrl: ctrl} + mock.recorder = &MockNodeNetworkServiceClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockNodeNetworkServiceClient) EXPECT() *MockNodeNetworkServiceClientMockRecorder { + return m.recorder +} + +// ConfigureContainerNetworking mocks base method. +func (m *MockNodeNetworkServiceClient) ConfigureContainerNetworking(ctx context.Context, in *v0.ConfigureContainerNetworkingRequest, opts ...grpc.CallOption) (*v0.ConfigureContainerNetworkingResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ConfigureContainerNetworking", varargs...) + ret0, _ := ret[0].(*v0.ConfigureContainerNetworkingResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ConfigureContainerNetworking indicates an expected call of ConfigureContainerNetworking. +func (mr *MockNodeNetworkServiceClientMockRecorder) ConfigureContainerNetworking(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigureContainerNetworking", reflect.TypeOf((*MockNodeNetworkServiceClient)(nil).ConfigureContainerNetworking), varargs...) +} + +// ConfigureNetworking mocks base method. +func (m *MockNodeNetworkServiceClient) ConfigureNetworking(ctx context.Context, in *v0.ConfigureNetworkingRequest, opts ...grpc.CallOption) (*v0.ConfigureNetworkingResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ConfigureNetworking", varargs...) + ret0, _ := ret[0].(*v0.ConfigureNetworkingResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ConfigureNetworking indicates an expected call of ConfigureNetworking. +func (mr *MockNodeNetworkServiceClientMockRecorder) ConfigureNetworking(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigureNetworking", reflect.TypeOf((*MockNodeNetworkServiceClient)(nil).ConfigureNetworking), varargs...) +} + +// GetHostLocalIpAddress mocks base method. +func (m *MockNodeNetworkServiceClient) GetHostLocalIpAddress(ctx context.Context, in *v0.GetHostLocalIpAddressRequest, opts ...grpc.CallOption) (*v0.GetHostLocalIpAddressResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetHostLocalIpAddress", varargs...) + ret0, _ := ret[0].(*v0.GetHostLocalIpAddressResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHostLocalIpAddress indicates an expected call of GetHostLocalIpAddress. +func (mr *MockNodeNetworkServiceClientMockRecorder) GetHostLocalIpAddress(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostLocalIpAddress", reflect.TypeOf((*MockNodeNetworkServiceClient)(nil).GetHostLocalIpAddress), varargs...) +} + +// PingNodeNetworkService mocks base method. +func (m *MockNodeNetworkServiceClient) PingNodeNetworkService(ctx context.Context, in *v0.PingNodeNetworkServiceRequest, opts ...grpc.CallOption) (*v0.PingNodeNetworkServiceResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PingNodeNetworkService", varargs...) + ret0, _ := ret[0].(*v0.PingNodeNetworkServiceResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PingNodeNetworkService indicates an expected call of PingNodeNetworkService. +func (mr *MockNodeNetworkServiceClientMockRecorder) PingNodeNetworkService(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PingNodeNetworkService", reflect.TypeOf((*MockNodeNetworkServiceClient)(nil).PingNodeNetworkService), varargs...) +} + +// MockNodeNetworkServiceServer is a mock of NodeNetworkServiceServer interface. +type MockNodeNetworkServiceServer struct { + ctrl *gomock.Controller + recorder *MockNodeNetworkServiceServerMockRecorder +} + +// MockNodeNetworkServiceServerMockRecorder is the mock recorder for MockNodeNetworkServiceServer. +type MockNodeNetworkServiceServerMockRecorder struct { + mock *MockNodeNetworkServiceServer +} + +// NewMockNodeNetworkServiceServer creates a new mock instance. +func NewMockNodeNetworkServiceServer(ctrl *gomock.Controller) *MockNodeNetworkServiceServer { + mock := &MockNodeNetworkServiceServer{ctrl: ctrl} + mock.recorder = &MockNodeNetworkServiceServerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockNodeNetworkServiceServer) EXPECT() *MockNodeNetworkServiceServerMockRecorder { + return m.recorder +} + +// ConfigureContainerNetworking mocks base method. +func (m *MockNodeNetworkServiceServer) ConfigureContainerNetworking(arg0 context.Context, arg1 *v0.ConfigureContainerNetworkingRequest) (*v0.ConfigureContainerNetworkingResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigureContainerNetworking", arg0, arg1) + ret0, _ := ret[0].(*v0.ConfigureContainerNetworkingResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ConfigureContainerNetworking indicates an expected call of ConfigureContainerNetworking. +func (mr *MockNodeNetworkServiceServerMockRecorder) ConfigureContainerNetworking(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigureContainerNetworking", reflect.TypeOf((*MockNodeNetworkServiceServer)(nil).ConfigureContainerNetworking), arg0, arg1) +} + +// ConfigureNetworking mocks base method. +func (m *MockNodeNetworkServiceServer) ConfigureNetworking(arg0 context.Context, arg1 *v0.ConfigureNetworkingRequest) (*v0.ConfigureNetworkingResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigureNetworking", arg0, arg1) + ret0, _ := ret[0].(*v0.ConfigureNetworkingResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ConfigureNetworking indicates an expected call of ConfigureNetworking. +func (mr *MockNodeNetworkServiceServerMockRecorder) ConfigureNetworking(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigureNetworking", reflect.TypeOf((*MockNodeNetworkServiceServer)(nil).ConfigureNetworking), arg0, arg1) +} + +// GetHostLocalIpAddress mocks base method. +func (m *MockNodeNetworkServiceServer) GetHostLocalIpAddress(arg0 context.Context, arg1 *v0.GetHostLocalIpAddressRequest) (*v0.GetHostLocalIpAddressResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHostLocalIpAddress", arg0, arg1) + ret0, _ := ret[0].(*v0.GetHostLocalIpAddressResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHostLocalIpAddress indicates an expected call of GetHostLocalIpAddress. +func (mr *MockNodeNetworkServiceServerMockRecorder) GetHostLocalIpAddress(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostLocalIpAddress", reflect.TypeOf((*MockNodeNetworkServiceServer)(nil).GetHostLocalIpAddress), arg0, arg1) +} + +// PingNodeNetworkService mocks base method. +func (m *MockNodeNetworkServiceServer) PingNodeNetworkService(arg0 context.Context, arg1 *v0.PingNodeNetworkServiceRequest) (*v0.PingNodeNetworkServiceResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PingNodeNetworkService", arg0, arg1) + ret0, _ := ret[0].(*v0.PingNodeNetworkServiceResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PingNodeNetworkService indicates an expected call of PingNodeNetworkService. +func (mr *MockNodeNetworkServiceServerMockRecorder) PingNodeNetworkService(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PingNodeNetworkService", reflect.TypeOf((*MockNodeNetworkServiceServer)(nil).PingNodeNetworkService), arg0, arg1) +} diff --git a/pkg/ncproxy/nodenetsvc/v0/nodenetsvc.pb.go b/pkg/ncproxy/nodenetsvc/v0/nodenetsvc.pb.go new file mode 100644 index 0000000000..e6864d08e5 --- /dev/null +++ b/pkg/ncproxy/nodenetsvc/v0/nodenetsvc.pb.go @@ -0,0 +1,2610 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// github.com/Microsoft/hcsshim/pkg/ncproxy/nodenetsvc/v0/nodenetsvc.proto is a deprecated file. + +package v0 + +import ( + context "context" + fmt "fmt" + proto "github.com/gogo/protobuf/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" + reflect "reflect" + strings "strings" +) + +// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type RequestType int32 + +const ( + RequestType_Setup RequestType = 0 + RequestType_Teardown RequestType = 1 +) + +var RequestType_name = map[int32]string{ + 0: "Setup", + 1: "Teardown", +} + +var RequestType_value = map[string]int32{ + "Setup": 0, + "Teardown": 1, +} + +func (x RequestType) String() string { + return proto.EnumName(RequestType_name, int32(x)) +} + +func (RequestType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_8f1cc039953ac339, []int{0} +} + +type ConfigureNetworkingRequest struct { + ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` + RequestType RequestType `protobuf:"varint,2,opt,name=request_type,json=requestType,proto3,enum=azure.nodenetworkservice.RequestType" json:"request_type,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ConfigureNetworkingRequest) Reset() { *m = ConfigureNetworkingRequest{} } +func (*ConfigureNetworkingRequest) ProtoMessage() {} +func (*ConfigureNetworkingRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_8f1cc039953ac339, []int{0} +} +func (m *ConfigureNetworkingRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ConfigureNetworkingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ConfigureNetworkingRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ConfigureNetworkingRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConfigureNetworkingRequest.Merge(m, src) +} +func (m *ConfigureNetworkingRequest) XXX_Size() int { + return m.Size() +} +func (m *ConfigureNetworkingRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ConfigureNetworkingRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ConfigureNetworkingRequest proto.InternalMessageInfo + +type ConfigureNetworkingResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ConfigureNetworkingResponse) Reset() { *m = ConfigureNetworkingResponse{} } +func (*ConfigureNetworkingResponse) ProtoMessage() {} +func (*ConfigureNetworkingResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_8f1cc039953ac339, []int{1} +} +func (m *ConfigureNetworkingResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ConfigureNetworkingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ConfigureNetworkingResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ConfigureNetworkingResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConfigureNetworkingResponse.Merge(m, src) +} +func (m *ConfigureNetworkingResponse) XXX_Size() int { + return m.Size() +} +func (m *ConfigureNetworkingResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ConfigureNetworkingResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ConfigureNetworkingResponse proto.InternalMessageInfo + +type PingNodeNetworkServiceRequest struct { + PingRequestMessage string `protobuf:"bytes,1,opt,name=ping_request_message,json=pingRequestMessage,proto3" json:"ping_request_message,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PingNodeNetworkServiceRequest) Reset() { *m = PingNodeNetworkServiceRequest{} } +func (*PingNodeNetworkServiceRequest) ProtoMessage() {} +func (*PingNodeNetworkServiceRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_8f1cc039953ac339, []int{2} +} +func (m *PingNodeNetworkServiceRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PingNodeNetworkServiceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PingNodeNetworkServiceRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *PingNodeNetworkServiceRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_PingNodeNetworkServiceRequest.Merge(m, src) +} +func (m *PingNodeNetworkServiceRequest) XXX_Size() int { + return m.Size() +} +func (m *PingNodeNetworkServiceRequest) XXX_DiscardUnknown() { + xxx_messageInfo_PingNodeNetworkServiceRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_PingNodeNetworkServiceRequest proto.InternalMessageInfo + +type PingNodeNetworkServiceResponse struct { + PingResponseMessage string `protobuf:"bytes,1,opt,name=ping_response_message,json=pingResponseMessage,proto3" json:"ping_response_message,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PingNodeNetworkServiceResponse) Reset() { *m = PingNodeNetworkServiceResponse{} } +func (*PingNodeNetworkServiceResponse) ProtoMessage() {} +func (*PingNodeNetworkServiceResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_8f1cc039953ac339, []int{3} +} +func (m *PingNodeNetworkServiceResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PingNodeNetworkServiceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PingNodeNetworkServiceResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *PingNodeNetworkServiceResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_PingNodeNetworkServiceResponse.Merge(m, src) +} +func (m *PingNodeNetworkServiceResponse) XXX_Size() int { + return m.Size() +} +func (m *PingNodeNetworkServiceResponse) XXX_DiscardUnknown() { + xxx_messageInfo_PingNodeNetworkServiceResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_PingNodeNetworkServiceResponse proto.InternalMessageInfo + +type ConfigureContainerNetworkingRequest struct { + RequestType RequestType `protobuf:"varint,1,opt,name=request_type,json=requestType,proto3,enum=azure.nodenetworkservice.RequestType" json:"request_type,omitempty"` + ContainerID string `protobuf:"bytes,2,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` + NetworkNamespaceID string `protobuf:"bytes,3,opt,name=network_namespace_id,json=networkNamespaceId,proto3" json:"network_namespace_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ConfigureContainerNetworkingRequest) Reset() { *m = ConfigureContainerNetworkingRequest{} } +func (*ConfigureContainerNetworkingRequest) ProtoMessage() {} +func (*ConfigureContainerNetworkingRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_8f1cc039953ac339, []int{4} +} +func (m *ConfigureContainerNetworkingRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ConfigureContainerNetworkingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ConfigureContainerNetworkingRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ConfigureContainerNetworkingRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConfigureContainerNetworkingRequest.Merge(m, src) +} +func (m *ConfigureContainerNetworkingRequest) XXX_Size() int { + return m.Size() +} +func (m *ConfigureContainerNetworkingRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ConfigureContainerNetworkingRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ConfigureContainerNetworkingRequest proto.InternalMessageInfo + +type ConfigureContainerNetworkingResponse struct { + Interfaces []*ContainerNetworkInterface `protobuf:"bytes,1,rep,name=interfaces,proto3" json:"interfaces,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ConfigureContainerNetworkingResponse) Reset() { *m = ConfigureContainerNetworkingResponse{} } +func (*ConfigureContainerNetworkingResponse) ProtoMessage() {} +func (*ConfigureContainerNetworkingResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_8f1cc039953ac339, []int{5} +} +func (m *ConfigureContainerNetworkingResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ConfigureContainerNetworkingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ConfigureContainerNetworkingResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ConfigureContainerNetworkingResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConfigureContainerNetworkingResponse.Merge(m, src) +} +func (m *ConfigureContainerNetworkingResponse) XXX_Size() int { + return m.Size() +} +func (m *ConfigureContainerNetworkingResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ConfigureContainerNetworkingResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ConfigureContainerNetworkingResponse proto.InternalMessageInfo + +type ContainerIPAddress struct { + Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"` + Ip string `protobuf:"bytes,3,opt,name=ip,proto3" json:"ip,omitempty"` + PrefixLength string `protobuf:"bytes,4,opt,name=prefix_length,json=prefixLength,proto3" json:"prefix_length,omitempty"` + DefaultGateway string `protobuf:"bytes,5,opt,name=default_gateway,json=defaultGateway,proto3" json:"default_gateway,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ContainerIPAddress) Reset() { *m = ContainerIPAddress{} } +func (*ContainerIPAddress) ProtoMessage() {} +func (*ContainerIPAddress) Descriptor() ([]byte, []int) { + return fileDescriptor_8f1cc039953ac339, []int{6} +} +func (m *ContainerIPAddress) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ContainerIPAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ContainerIPAddress.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ContainerIPAddress) XXX_Merge(src proto.Message) { + xxx_messageInfo_ContainerIPAddress.Merge(m, src) +} +func (m *ContainerIPAddress) XXX_Size() int { + return m.Size() +} +func (m *ContainerIPAddress) XXX_DiscardUnknown() { + xxx_messageInfo_ContainerIPAddress.DiscardUnknown(m) +} + +var xxx_messageInfo_ContainerIPAddress proto.InternalMessageInfo + +type ContainerNetworkInterface struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + MacAddress string `protobuf:"bytes,2,opt,name=mac_address,json=macAddress,proto3" json:"mac_address,omitempty"` + NetworkNamespaceID string `protobuf:"bytes,3,opt,name=network_namespace_id,json=networkNamespaceId,proto3" json:"network_namespace_id,omitempty"` + Ipaddresses []*ContainerIPAddress `protobuf:"bytes,4,rep,name=ipaddresses,proto3" json:"ipaddresses,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ContainerNetworkInterface) Reset() { *m = ContainerNetworkInterface{} } +func (*ContainerNetworkInterface) ProtoMessage() {} +func (*ContainerNetworkInterface) Descriptor() ([]byte, []int) { + return fileDescriptor_8f1cc039953ac339, []int{7} +} +func (m *ContainerNetworkInterface) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ContainerNetworkInterface) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ContainerNetworkInterface.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ContainerNetworkInterface) XXX_Merge(src proto.Message) { + xxx_messageInfo_ContainerNetworkInterface.Merge(m, src) +} +func (m *ContainerNetworkInterface) XXX_Size() int { + return m.Size() +} +func (m *ContainerNetworkInterface) XXX_DiscardUnknown() { + xxx_messageInfo_ContainerNetworkInterface.DiscardUnknown(m) +} + +var xxx_messageInfo_ContainerNetworkInterface proto.InternalMessageInfo + +type GetHostLocalIpAddressRequest struct { + ContainerID string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetHostLocalIpAddressRequest) Reset() { *m = GetHostLocalIpAddressRequest{} } +func (*GetHostLocalIpAddressRequest) ProtoMessage() {} +func (*GetHostLocalIpAddressRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_8f1cc039953ac339, []int{8} +} +func (m *GetHostLocalIpAddressRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetHostLocalIpAddressRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetHostLocalIpAddressRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GetHostLocalIpAddressRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetHostLocalIpAddressRequest.Merge(m, src) +} +func (m *GetHostLocalIpAddressRequest) XXX_Size() int { + return m.Size() +} +func (m *GetHostLocalIpAddressRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetHostLocalIpAddressRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GetHostLocalIpAddressRequest proto.InternalMessageInfo + +type GetHostLocalIpAddressResponse struct { + IpAddr string `protobuf:"bytes,1,opt,name=ip_addr,json=ipAddr,proto3" json:"ip_addr,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetHostLocalIpAddressResponse) Reset() { *m = GetHostLocalIpAddressResponse{} } +func (*GetHostLocalIpAddressResponse) ProtoMessage() {} +func (*GetHostLocalIpAddressResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_8f1cc039953ac339, []int{9} +} +func (m *GetHostLocalIpAddressResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetHostLocalIpAddressResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetHostLocalIpAddressResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GetHostLocalIpAddressResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetHostLocalIpAddressResponse.Merge(m, src) +} +func (m *GetHostLocalIpAddressResponse) XXX_Size() int { + return m.Size() +} +func (m *GetHostLocalIpAddressResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetHostLocalIpAddressResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GetHostLocalIpAddressResponse proto.InternalMessageInfo + +func init() { + proto.RegisterEnum("azure.nodenetworkservice.RequestType", RequestType_name, RequestType_value) + proto.RegisterType((*ConfigureNetworkingRequest)(nil), "azure.nodenetworkservice.ConfigureNetworkingRequest") + proto.RegisterType((*ConfigureNetworkingResponse)(nil), "azure.nodenetworkservice.ConfigureNetworkingResponse") + proto.RegisterType((*PingNodeNetworkServiceRequest)(nil), "azure.nodenetworkservice.PingNodeNetworkServiceRequest") + proto.RegisterType((*PingNodeNetworkServiceResponse)(nil), "azure.nodenetworkservice.PingNodeNetworkServiceResponse") + proto.RegisterType((*ConfigureContainerNetworkingRequest)(nil), "azure.nodenetworkservice.ConfigureContainerNetworkingRequest") + proto.RegisterType((*ConfigureContainerNetworkingResponse)(nil), "azure.nodenetworkservice.ConfigureContainerNetworkingResponse") + proto.RegisterType((*ContainerIPAddress)(nil), "azure.nodenetworkservice.ContainerIPAddress") + proto.RegisterType((*ContainerNetworkInterface)(nil), "azure.nodenetworkservice.ContainerNetworkInterface") + proto.RegisterType((*GetHostLocalIpAddressRequest)(nil), "azure.nodenetworkservice.GetHostLocalIpAddressRequest") + proto.RegisterType((*GetHostLocalIpAddressResponse)(nil), "azure.nodenetworkservice.GetHostLocalIpAddressResponse") +} + +func init() { + proto.RegisterFile("github.com/Microsoft/hcsshim/pkg/ncproxy/nodenetsvc/v0/nodenetsvc.proto", fileDescriptor_8f1cc039953ac339) +} + +var fileDescriptor_8f1cc039953ac339 = []byte{ + // 723 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcd, 0x4e, 0xdb, 0x4c, + 0x14, 0x65, 0x42, 0x80, 0x8f, 0x9b, 0x7c, 0x80, 0x86, 0x9f, 0xba, 0x29, 0x04, 0x64, 0xfa, 0x83, + 0xaa, 0x2a, 0x41, 0xa1, 0x05, 0x36, 0xad, 0x54, 0x40, 0x82, 0x48, 0x10, 0x51, 0x87, 0x55, 0x37, + 0x91, 0xb1, 0x27, 0xce, 0x08, 0x32, 0x33, 0xf5, 0x38, 0x81, 0xb4, 0x9b, 0xaa, 0xab, 0x4a, 0xed, + 0x13, 0x54, 0xea, 0x7b, 0xf4, 0x11, 0x58, 0x56, 0x5d, 0x75, 0x85, 0x4a, 0x96, 0x95, 0xfa, 0x0e, + 0x15, 0xf6, 0x38, 0x44, 0x21, 0x8e, 0x20, 0xea, 0xce, 0x73, 0xef, 0xdc, 0x33, 0xe7, 0x9c, 0x3b, + 0x73, 0x0d, 0xdb, 0x0e, 0xf5, 0x2a, 0xb5, 0xc3, 0x8c, 0xc5, 0xab, 0xd9, 0x3d, 0x6a, 0xb9, 0x5c, + 0xf2, 0xb2, 0x97, 0xad, 0x58, 0x52, 0x56, 0x68, 0x35, 0x2b, 0x8e, 0x9c, 0x2c, 0xb3, 0x84, 0xcb, + 0x4f, 0x1b, 0x59, 0xc6, 0x6d, 0xc2, 0x88, 0x27, 0xeb, 0x56, 0xb6, 0xbe, 0xdc, 0xb6, 0xca, 0x08, + 0x97, 0x7b, 0x1c, 0x6b, 0xe6, 0xdb, 0x9a, 0x4b, 0x32, 0x2a, 0x7e, 0xc2, 0xdd, 0x23, 0x49, 0xdc, + 0x3a, 0xb5, 0x88, 0xfe, 0x05, 0x41, 0x6a, 0x93, 0xb3, 0x32, 0x75, 0x6a, 0x2e, 0x29, 0x04, 0x39, + 0xca, 0x1c, 0x83, 0xbc, 0xa9, 0x11, 0xe9, 0xe1, 0x1c, 0x24, 0x2d, 0xce, 0x3c, 0x93, 0x32, 0xe2, + 0x96, 0xa8, 0xad, 0xa1, 0x05, 0xb4, 0x34, 0xba, 0x31, 0xde, 0x3c, 0x9f, 0x4f, 0x6c, 0x86, 0xf1, + 0xfc, 0x96, 0x91, 0x68, 0x6d, 0xca, 0xdb, 0x78, 0x07, 0x92, 0x6e, 0x50, 0x5e, 0xf2, 0x1a, 0x82, + 0x68, 0xb1, 0x05, 0xb4, 0x34, 0x96, 0x7b, 0x90, 0x89, 0xe2, 0x90, 0x51, 0x87, 0x1d, 0x34, 0x04, + 0x31, 0x12, 0xee, 0xd5, 0x42, 0x9f, 0x83, 0x7b, 0x5d, 0xb9, 0x49, 0xc1, 0x99, 0x24, 0xfa, 0x2b, + 0x98, 0xdb, 0xa7, 0xcc, 0x29, 0x70, 0x3b, 0xcc, 0x16, 0x03, 0xc4, 0x90, 0xfd, 0x32, 0x4c, 0x09, + 0xca, 0x9c, 0x52, 0x48, 0xa7, 0x4a, 0xa4, 0x34, 0x1d, 0x12, 0xa8, 0x30, 0xb0, 0xb8, 0x12, 0xba, + 0x17, 0x64, 0xf4, 0x03, 0x48, 0x47, 0x41, 0x06, 0x87, 0xe2, 0x1c, 0x4c, 0x2b, 0xcc, 0x20, 0xd0, + 0x01, 0x3a, 0x29, 0xda, 0x18, 0x86, 0xa8, 0x7f, 0x10, 0x2c, 0xb6, 0x84, 0xb4, 0x7c, 0xbb, 0xee, + 0x76, 0xa7, 0x73, 0xa8, 0x5f, 0xe7, 0xae, 0xf5, 0x2d, 0x76, 0xa3, 0xbe, 0x4d, 0x29, 0xf8, 0x12, + 0x33, 0xab, 0x44, 0x0a, 0xd3, 0x22, 0x97, 0xb5, 0x83, 0x7e, 0xed, 0x4c, 0xf3, 0x7c, 0x1e, 0x2b, + 0xca, 0x85, 0x30, 0x9d, 0xdf, 0x32, 0x30, 0xeb, 0x8c, 0xd9, 0xfa, 0x3b, 0xb8, 0xdf, 0x5b, 0xae, + 0xf2, 0xb2, 0x08, 0x40, 0x99, 0x47, 0xdc, 0xb2, 0x69, 0x11, 0xa9, 0xa1, 0x85, 0xc1, 0xa5, 0x44, + 0x6e, 0x25, 0x5a, 0x6d, 0x27, 0x54, 0x3e, 0xac, 0x35, 0xda, 0x60, 0xf4, 0xcf, 0x08, 0xf0, 0x95, + 0xc6, 0xfd, 0x97, 0xb6, 0xed, 0x12, 0x29, 0xb1, 0x06, 0x23, 0x75, 0xe2, 0x4a, 0xca, 0x99, 0xea, + 0x54, 0xb8, 0xc4, 0x63, 0x10, 0xa3, 0x22, 0x50, 0x69, 0xc4, 0xa8, 0xc0, 0x8b, 0xf0, 0xbf, 0x70, + 0x49, 0x99, 0x9e, 0x96, 0x8e, 0x09, 0x73, 0xbc, 0x8a, 0x16, 0xf7, 0x53, 0xc9, 0x20, 0xb8, 0xeb, + 0xc7, 0xf0, 0x23, 0x18, 0xb7, 0x49, 0xd9, 0xac, 0x1d, 0x7b, 0x25, 0xc7, 0xf4, 0xc8, 0x89, 0xd9, + 0xd0, 0x86, 0xfc, 0x6d, 0x63, 0x2a, 0xbc, 0x1d, 0x44, 0xf5, 0xdf, 0x08, 0xee, 0x46, 0x12, 0xc7, + 0x18, 0xe2, 0x97, 0x5e, 0x2b, 0x4a, 0xfe, 0x37, 0x9e, 0x87, 0x44, 0xd5, 0xb4, 0x4a, 0x66, 0x40, + 0x3c, 0x68, 0x9d, 0x01, 0x55, 0xd3, 0x0a, 0xa5, 0xfc, 0xb3, 0x46, 0xe1, 0x02, 0x24, 0xa8, 0x50, + 0x07, 0x11, 0xa9, 0xc5, 0xfd, 0x0e, 0x3c, 0xb9, 0x41, 0x07, 0x5a, 0xbe, 0x1a, 0xed, 0x00, 0xba, + 0x01, 0xb3, 0xdb, 0xc4, 0xdb, 0xe1, 0xd2, 0xdb, 0xe5, 0x96, 0x79, 0x9c, 0x17, 0xe1, 0xae, 0xfe, + 0xc7, 0x89, 0xbe, 0x0e, 0x73, 0x11, 0x98, 0xea, 0x16, 0xdd, 0x81, 0x11, 0x2a, 0x7c, 0xbb, 0x94, + 0x8d, 0xc3, 0xd4, 0xdf, 0xf3, 0xf8, 0x21, 0x24, 0xda, 0x1e, 0x08, 0x1e, 0x85, 0xa1, 0x22, 0xf1, + 0x6a, 0x62, 0x62, 0x00, 0x27, 0xe1, 0xbf, 0x03, 0x62, 0xba, 0x36, 0x3f, 0x61, 0x13, 0x28, 0xf7, + 0x23, 0x0e, 0xf8, 0xfa, 0x8b, 0xc7, 0x1f, 0x10, 0x4c, 0x76, 0x19, 0x3f, 0xf8, 0x69, 0x4f, 0x7f, + 0x22, 0x26, 0x69, 0xea, 0xd9, 0x2d, 0xab, 0x94, 0xb8, 0xaf, 0x08, 0x66, 0x7b, 0xbd, 0x25, 0xfc, + 0xfc, 0x06, 0xb8, 0xd1, 0x23, 0x27, 0xf5, 0xa2, 0xdf, 0x72, 0xc5, 0xef, 0x13, 0x82, 0x99, 0xee, + 0x13, 0x13, 0xaf, 0x45, 0x43, 0xf7, 0x1c, 0xdb, 0xa9, 0xf5, 0xdb, 0x17, 0x2a, 0x36, 0x1f, 0x11, + 0x4c, 0x77, 0xbd, 0x2c, 0x78, 0x35, 0x1a, 0xb3, 0xd7, 0x8d, 0x4d, 0xad, 0xdd, 0xba, 0x2e, 0xa0, + 0xb2, 0x51, 0x3c, 0xbb, 0x48, 0x0f, 0xfc, 0xbc, 0x48, 0x0f, 0xbc, 0x6f, 0xa6, 0xd1, 0x59, 0x33, + 0x8d, 0xbe, 0x37, 0xd3, 0xe8, 0x57, 0x33, 0x8d, 0x5e, 0xaf, 0xf6, 0xf7, 0x57, 0xff, 0x86, 0xd0, + 0xe1, 0xb0, 0xff, 0x3b, 0x5f, 0xf9, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x97, 0x9e, 0x71, 0x12, 0x19, + 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 + +// NodeNetworkServiceClient is the client API for NodeNetworkService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type NodeNetworkServiceClient interface { + ConfigureNetworking(ctx context.Context, in *ConfigureNetworkingRequest, opts ...grpc.CallOption) (*ConfigureNetworkingResponse, error) + ConfigureContainerNetworking(ctx context.Context, in *ConfigureContainerNetworkingRequest, opts ...grpc.CallOption) (*ConfigureContainerNetworkingResponse, error) + PingNodeNetworkService(ctx context.Context, in *PingNodeNetworkServiceRequest, opts ...grpc.CallOption) (*PingNodeNetworkServiceResponse, error) + GetHostLocalIpAddress(ctx context.Context, in *GetHostLocalIpAddressRequest, opts ...grpc.CallOption) (*GetHostLocalIpAddressResponse, error) +} + +type nodeNetworkServiceClient struct { + cc *grpc.ClientConn +} + +func NewNodeNetworkServiceClient(cc *grpc.ClientConn) NodeNetworkServiceClient { + return &nodeNetworkServiceClient{cc} +} + +func (c *nodeNetworkServiceClient) ConfigureNetworking(ctx context.Context, in *ConfigureNetworkingRequest, opts ...grpc.CallOption) (*ConfigureNetworkingResponse, error) { + out := new(ConfigureNetworkingResponse) + err := c.cc.Invoke(ctx, "/azure.nodenetworkservice.NodeNetworkService/ConfigureNetworking", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *nodeNetworkServiceClient) ConfigureContainerNetworking(ctx context.Context, in *ConfigureContainerNetworkingRequest, opts ...grpc.CallOption) (*ConfigureContainerNetworkingResponse, error) { + out := new(ConfigureContainerNetworkingResponse) + err := c.cc.Invoke(ctx, "/azure.nodenetworkservice.NodeNetworkService/ConfigureContainerNetworking", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *nodeNetworkServiceClient) PingNodeNetworkService(ctx context.Context, in *PingNodeNetworkServiceRequest, opts ...grpc.CallOption) (*PingNodeNetworkServiceResponse, error) { + out := new(PingNodeNetworkServiceResponse) + err := c.cc.Invoke(ctx, "/azure.nodenetworkservice.NodeNetworkService/PingNodeNetworkService", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *nodeNetworkServiceClient) GetHostLocalIpAddress(ctx context.Context, in *GetHostLocalIpAddressRequest, opts ...grpc.CallOption) (*GetHostLocalIpAddressResponse, error) { + out := new(GetHostLocalIpAddressResponse) + err := c.cc.Invoke(ctx, "/azure.nodenetworkservice.NodeNetworkService/GetHostLocalIpAddress", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// NodeNetworkServiceServer is the server API for NodeNetworkService service. +type NodeNetworkServiceServer interface { + ConfigureNetworking(context.Context, *ConfigureNetworkingRequest) (*ConfigureNetworkingResponse, error) + ConfigureContainerNetworking(context.Context, *ConfigureContainerNetworkingRequest) (*ConfigureContainerNetworkingResponse, error) + PingNodeNetworkService(context.Context, *PingNodeNetworkServiceRequest) (*PingNodeNetworkServiceResponse, error) + GetHostLocalIpAddress(context.Context, *GetHostLocalIpAddressRequest) (*GetHostLocalIpAddressResponse, error) +} + +// UnimplementedNodeNetworkServiceServer can be embedded to have forward compatible implementations. +type UnimplementedNodeNetworkServiceServer struct { +} + +func (*UnimplementedNodeNetworkServiceServer) ConfigureNetworking(ctx context.Context, req *ConfigureNetworkingRequest) (*ConfigureNetworkingResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ConfigureNetworking not implemented") +} +func (*UnimplementedNodeNetworkServiceServer) ConfigureContainerNetworking(ctx context.Context, req *ConfigureContainerNetworkingRequest) (*ConfigureContainerNetworkingResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ConfigureContainerNetworking not implemented") +} +func (*UnimplementedNodeNetworkServiceServer) PingNodeNetworkService(ctx context.Context, req *PingNodeNetworkServiceRequest) (*PingNodeNetworkServiceResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method PingNodeNetworkService not implemented") +} +func (*UnimplementedNodeNetworkServiceServer) GetHostLocalIpAddress(ctx context.Context, req *GetHostLocalIpAddressRequest) (*GetHostLocalIpAddressResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetHostLocalIpAddress not implemented") +} + +func RegisterNodeNetworkServiceServer(s *grpc.Server, srv NodeNetworkServiceServer) { + s.RegisterService(&_NodeNetworkService_serviceDesc, srv) +} + +func _NodeNetworkService_ConfigureNetworking_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ConfigureNetworkingRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(NodeNetworkServiceServer).ConfigureNetworking(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/azure.nodenetworkservice.NodeNetworkService/ConfigureNetworking", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(NodeNetworkServiceServer).ConfigureNetworking(ctx, req.(*ConfigureNetworkingRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _NodeNetworkService_ConfigureContainerNetworking_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ConfigureContainerNetworkingRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(NodeNetworkServiceServer).ConfigureContainerNetworking(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/azure.nodenetworkservice.NodeNetworkService/ConfigureContainerNetworking", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(NodeNetworkServiceServer).ConfigureContainerNetworking(ctx, req.(*ConfigureContainerNetworkingRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _NodeNetworkService_PingNodeNetworkService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PingNodeNetworkServiceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(NodeNetworkServiceServer).PingNodeNetworkService(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/azure.nodenetworkservice.NodeNetworkService/PingNodeNetworkService", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(NodeNetworkServiceServer).PingNodeNetworkService(ctx, req.(*PingNodeNetworkServiceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _NodeNetworkService_GetHostLocalIpAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetHostLocalIpAddressRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(NodeNetworkServiceServer).GetHostLocalIpAddress(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/azure.nodenetworkservice.NodeNetworkService/GetHostLocalIpAddress", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(NodeNetworkServiceServer).GetHostLocalIpAddress(ctx, req.(*GetHostLocalIpAddressRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _NodeNetworkService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "azure.nodenetworkservice.NodeNetworkService", + HandlerType: (*NodeNetworkServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "ConfigureNetworking", + Handler: _NodeNetworkService_ConfigureNetworking_Handler, + }, + { + MethodName: "ConfigureContainerNetworking", + Handler: _NodeNetworkService_ConfigureContainerNetworking_Handler, + }, + { + MethodName: "PingNodeNetworkService", + Handler: _NodeNetworkService_PingNodeNetworkService_Handler, + }, + { + MethodName: "GetHostLocalIpAddress", + Handler: _NodeNetworkService_GetHostLocalIpAddress_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "github.com/Microsoft/hcsshim/pkg/ncproxy/nodenetsvc/v0/nodenetsvc.proto", +} + +func (m *ConfigureNetworkingRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConfigureNetworkingRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ConfigureNetworkingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.RequestType != 0 { + i = encodeVarintNodenetsvc(dAtA, i, uint64(m.RequestType)) + i-- + dAtA[i] = 0x10 + } + if len(m.ContainerID) > 0 { + i -= len(m.ContainerID) + copy(dAtA[i:], m.ContainerID) + i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.ContainerID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ConfigureNetworkingResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConfigureNetworkingResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ConfigureNetworkingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + return len(dAtA) - i, nil +} + +func (m *PingNodeNetworkServiceRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PingNodeNetworkServiceRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PingNodeNetworkServiceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.PingRequestMessage) > 0 { + i -= len(m.PingRequestMessage) + copy(dAtA[i:], m.PingRequestMessage) + i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.PingRequestMessage))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PingNodeNetworkServiceResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PingNodeNetworkServiceResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PingNodeNetworkServiceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.PingResponseMessage) > 0 { + i -= len(m.PingResponseMessage) + copy(dAtA[i:], m.PingResponseMessage) + i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.PingResponseMessage))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ConfigureContainerNetworkingRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConfigureContainerNetworkingRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ConfigureContainerNetworkingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.NetworkNamespaceID) > 0 { + i -= len(m.NetworkNamespaceID) + copy(dAtA[i:], m.NetworkNamespaceID) + i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.NetworkNamespaceID))) + i-- + dAtA[i] = 0x1a + } + if len(m.ContainerID) > 0 { + i -= len(m.ContainerID) + copy(dAtA[i:], m.ContainerID) + i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.ContainerID))) + i-- + dAtA[i] = 0x12 + } + if m.RequestType != 0 { + i = encodeVarintNodenetsvc(dAtA, i, uint64(m.RequestType)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ConfigureContainerNetworkingResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConfigureContainerNetworkingResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ConfigureContainerNetworkingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Interfaces) > 0 { + for iNdEx := len(m.Interfaces) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Interfaces[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintNodenetsvc(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ContainerIPAddress) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ContainerIPAddress) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ContainerIPAddress) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.DefaultGateway) > 0 { + i -= len(m.DefaultGateway) + copy(dAtA[i:], m.DefaultGateway) + i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.DefaultGateway))) + i-- + dAtA[i] = 0x2a + } + if len(m.PrefixLength) > 0 { + i -= len(m.PrefixLength) + copy(dAtA[i:], m.PrefixLength) + i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.PrefixLength))) + i-- + dAtA[i] = 0x22 + } + if len(m.Ip) > 0 { + i -= len(m.Ip) + copy(dAtA[i:], m.Ip) + i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.Ip))) + i-- + dAtA[i] = 0x1a + } + if len(m.Version) > 0 { + i -= len(m.Version) + copy(dAtA[i:], m.Version) + i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.Version))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ContainerNetworkInterface) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ContainerNetworkInterface) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ContainerNetworkInterface) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Ipaddresses) > 0 { + for iNdEx := len(m.Ipaddresses) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Ipaddresses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintNodenetsvc(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if len(m.NetworkNamespaceID) > 0 { + i -= len(m.NetworkNamespaceID) + copy(dAtA[i:], m.NetworkNamespaceID) + i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.NetworkNamespaceID))) + i-- + dAtA[i] = 0x1a + } + if len(m.MacAddress) > 0 { + i -= len(m.MacAddress) + copy(dAtA[i:], m.MacAddress) + i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.MacAddress))) + i-- + dAtA[i] = 0x12 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GetHostLocalIpAddressRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetHostLocalIpAddressRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetHostLocalIpAddressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.ContainerID) > 0 { + i -= len(m.ContainerID) + copy(dAtA[i:], m.ContainerID) + i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.ContainerID))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GetHostLocalIpAddressResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetHostLocalIpAddressResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetHostLocalIpAddressResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.IpAddr) > 0 { + i -= len(m.IpAddr) + copy(dAtA[i:], m.IpAddr) + i = encodeVarintNodenetsvc(dAtA, i, uint64(len(m.IpAddr))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintNodenetsvc(dAtA []byte, offset int, v uint64) int { + offset -= sovNodenetsvc(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *ConfigureNetworkingRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ContainerID) + if l > 0 { + n += 1 + l + sovNodenetsvc(uint64(l)) + } + if m.RequestType != 0 { + n += 1 + sovNodenetsvc(uint64(m.RequestType)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ConfigureNetworkingResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *PingNodeNetworkServiceRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.PingRequestMessage) + if l > 0 { + n += 1 + l + sovNodenetsvc(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *PingNodeNetworkServiceResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.PingResponseMessage) + if l > 0 { + n += 1 + l + sovNodenetsvc(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ConfigureContainerNetworkingRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RequestType != 0 { + n += 1 + sovNodenetsvc(uint64(m.RequestType)) + } + l = len(m.ContainerID) + if l > 0 { + n += 1 + l + sovNodenetsvc(uint64(l)) + } + l = len(m.NetworkNamespaceID) + if l > 0 { + n += 1 + l + sovNodenetsvc(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ConfigureContainerNetworkingResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Interfaces) > 0 { + for _, e := range m.Interfaces { + l = e.Size() + n += 1 + l + sovNodenetsvc(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ContainerIPAddress) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Version) + if l > 0 { + n += 1 + l + sovNodenetsvc(uint64(l)) + } + l = len(m.Ip) + if l > 0 { + n += 1 + l + sovNodenetsvc(uint64(l)) + } + l = len(m.PrefixLength) + if l > 0 { + n += 1 + l + sovNodenetsvc(uint64(l)) + } + l = len(m.DefaultGateway) + if l > 0 { + n += 1 + l + sovNodenetsvc(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ContainerNetworkInterface) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovNodenetsvc(uint64(l)) + } + l = len(m.MacAddress) + if l > 0 { + n += 1 + l + sovNodenetsvc(uint64(l)) + } + l = len(m.NetworkNamespaceID) + if l > 0 { + n += 1 + l + sovNodenetsvc(uint64(l)) + } + if len(m.Ipaddresses) > 0 { + for _, e := range m.Ipaddresses { + l = e.Size() + n += 1 + l + sovNodenetsvc(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetHostLocalIpAddressRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ContainerID) + if l > 0 { + n += 1 + l + sovNodenetsvc(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetHostLocalIpAddressResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.IpAddr) + if l > 0 { + n += 1 + l + sovNodenetsvc(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovNodenetsvc(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozNodenetsvc(x uint64) (n int) { + return sovNodenetsvc(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *ConfigureNetworkingRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ConfigureNetworkingRequest{`, + `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, + `RequestType:` + fmt.Sprintf("%v", this.RequestType) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ConfigureNetworkingResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ConfigureNetworkingResponse{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *PingNodeNetworkServiceRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PingNodeNetworkServiceRequest{`, + `PingRequestMessage:` + fmt.Sprintf("%v", this.PingRequestMessage) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *PingNodeNetworkServiceResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PingNodeNetworkServiceResponse{`, + `PingResponseMessage:` + fmt.Sprintf("%v", this.PingResponseMessage) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ConfigureContainerNetworkingRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ConfigureContainerNetworkingRequest{`, + `RequestType:` + fmt.Sprintf("%v", this.RequestType) + `,`, + `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, + `NetworkNamespaceID:` + fmt.Sprintf("%v", this.NetworkNamespaceID) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ConfigureContainerNetworkingResponse) String() string { + if this == nil { + return "nil" + } + repeatedStringForInterfaces := "[]*ContainerNetworkInterface{" + for _, f := range this.Interfaces { + repeatedStringForInterfaces += strings.Replace(f.String(), "ContainerNetworkInterface", "ContainerNetworkInterface", 1) + "," + } + repeatedStringForInterfaces += "}" + s := strings.Join([]string{`&ConfigureContainerNetworkingResponse{`, + `Interfaces:` + repeatedStringForInterfaces + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ContainerIPAddress) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ContainerIPAddress{`, + `Version:` + fmt.Sprintf("%v", this.Version) + `,`, + `Ip:` + fmt.Sprintf("%v", this.Ip) + `,`, + `PrefixLength:` + fmt.Sprintf("%v", this.PrefixLength) + `,`, + `DefaultGateway:` + fmt.Sprintf("%v", this.DefaultGateway) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ContainerNetworkInterface) String() string { + if this == nil { + return "nil" + } + repeatedStringForIpaddresses := "[]*ContainerIPAddress{" + for _, f := range this.Ipaddresses { + repeatedStringForIpaddresses += strings.Replace(f.String(), "ContainerIPAddress", "ContainerIPAddress", 1) + "," + } + repeatedStringForIpaddresses += "}" + s := strings.Join([]string{`&ContainerNetworkInterface{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `MacAddress:` + fmt.Sprintf("%v", this.MacAddress) + `,`, + `NetworkNamespaceID:` + fmt.Sprintf("%v", this.NetworkNamespaceID) + `,`, + `Ipaddresses:` + repeatedStringForIpaddresses + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *GetHostLocalIpAddressRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&GetHostLocalIpAddressRequest{`, + `ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *GetHostLocalIpAddressResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&GetHostLocalIpAddressResponse{`, + `IpAddr:` + fmt.Sprintf("%v", this.IpAddr) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringNodenetsvc(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *ConfigureNetworkingRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ConfigureNetworkingRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConfigureNetworkingRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthNodenetsvc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthNodenetsvc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContainerID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestType", wireType) + } + m.RequestType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RequestType |= RequestType(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipNodenetsvc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthNodenetsvc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConfigureNetworkingResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ConfigureNetworkingResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConfigureNetworkingResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipNodenetsvc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthNodenetsvc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PingNodeNetworkServiceRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PingNodeNetworkServiceRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PingNodeNetworkServiceRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PingRequestMessage", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthNodenetsvc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthNodenetsvc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PingRequestMessage = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipNodenetsvc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthNodenetsvc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PingNodeNetworkServiceResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PingNodeNetworkServiceResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PingNodeNetworkServiceResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PingResponseMessage", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthNodenetsvc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthNodenetsvc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PingResponseMessage = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipNodenetsvc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthNodenetsvc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConfigureContainerNetworkingRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ConfigureContainerNetworkingRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConfigureContainerNetworkingRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestType", wireType) + } + m.RequestType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RequestType |= RequestType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthNodenetsvc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthNodenetsvc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContainerID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NetworkNamespaceID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthNodenetsvc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthNodenetsvc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NetworkNamespaceID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipNodenetsvc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthNodenetsvc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConfigureContainerNetworkingResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ConfigureContainerNetworkingResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConfigureContainerNetworkingResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Interfaces", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthNodenetsvc + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthNodenetsvc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Interfaces = append(m.Interfaces, &ContainerNetworkInterface{}) + if err := m.Interfaces[len(m.Interfaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipNodenetsvc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthNodenetsvc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ContainerIPAddress) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ContainerIPAddress: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ContainerIPAddress: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthNodenetsvc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthNodenetsvc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Version = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ip", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthNodenetsvc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthNodenetsvc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ip = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrefixLength", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthNodenetsvc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthNodenetsvc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PrefixLength = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DefaultGateway", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthNodenetsvc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthNodenetsvc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DefaultGateway = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipNodenetsvc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthNodenetsvc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ContainerNetworkInterface) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ContainerNetworkInterface: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ContainerNetworkInterface: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthNodenetsvc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthNodenetsvc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MacAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthNodenetsvc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthNodenetsvc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MacAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NetworkNamespaceID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthNodenetsvc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthNodenetsvc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NetworkNamespaceID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ipaddresses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthNodenetsvc + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthNodenetsvc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ipaddresses = append(m.Ipaddresses, &ContainerIPAddress{}) + if err := m.Ipaddresses[len(m.Ipaddresses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipNodenetsvc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthNodenetsvc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetHostLocalIpAddressRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetHostLocalIpAddressRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetHostLocalIpAddressRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthNodenetsvc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthNodenetsvc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContainerID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipNodenetsvc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthNodenetsvc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetHostLocalIpAddressResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetHostLocalIpAddressResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetHostLocalIpAddressResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IpAddr", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthNodenetsvc + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthNodenetsvc + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.IpAddr = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipNodenetsvc(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthNodenetsvc + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipNodenetsvc(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowNodenetsvc + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthNodenetsvc + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupNodenetsvc + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthNodenetsvc + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthNodenetsvc = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowNodenetsvc = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupNodenetsvc = fmt.Errorf("proto: unexpected end of group") +) diff --git a/pkg/ncproxy/nodenetsvc/v0/nodenetsvc.proto b/pkg/ncproxy/nodenetsvc/v0/nodenetsvc.proto new file mode 100644 index 0000000000..2709957fec --- /dev/null +++ b/pkg/ncproxy/nodenetsvc/v0/nodenetsvc.proto @@ -0,0 +1,63 @@ +syntax = "proto3"; +package azure.nodenetworkservice; +option go_package = "github.com/Microsoft/hcsshim/pkg/ncproxy/nodenetsvc/v0"; +option deprecated = true; + +service NodeNetworkService { + rpc ConfigureNetworking(ConfigureNetworkingRequest) returns (ConfigureNetworkingResponse); + rpc ConfigureContainerNetworking(ConfigureContainerNetworkingRequest) returns (ConfigureContainerNetworkingResponse); + rpc PingNodeNetworkService(PingNodeNetworkServiceRequest) returns (PingNodeNetworkServiceResponse); + rpc GetHostLocalIpAddress(GetHostLocalIpAddressRequest) returns (GetHostLocalIpAddressResponse); +} + +message ConfigureNetworkingRequest { + string container_id = 1; + RequestType request_type = 2; +} + +message ConfigureNetworkingResponse {} + +message PingNodeNetworkServiceRequest { + string ping_request_message = 1; +} + +message PingNodeNetworkServiceResponse { + string ping_response_message = 1; +} + +enum RequestType { + Setup = 0; + Teardown = 1; +} + +message ConfigureContainerNetworkingRequest { + RequestType request_type = 1; + string container_id = 2; + string network_namespace_id = 3; +} + +message ConfigureContainerNetworkingResponse { + repeated ContainerNetworkInterface interfaces = 1; +} + +message ContainerIPAddress { + string version = 1; + string ip = 3; + string prefix_length = 4; + string default_gateway = 5; +} + +message ContainerNetworkInterface { + string name = 1; + string mac_address = 2; + string network_namespace_id = 3; + repeated ContainerIPAddress ipaddresses = 4; +} + +message GetHostLocalIpAddressRequest { + string container_id = 1; +} + +message GetHostLocalIpAddressResponse { + string ip_addr = 1; +}