1 package main
2
3 import (
4 "context"
5 "errors"
6 "strconv"
7
8 ncproxygrpcv0 "github.com/Microsoft/hcsshim/pkg/ncproxy/ncproxygrpc/v0"
9 ncproxygrpc "github.com/Microsoft/hcsshim/pkg/ncproxy/ncproxygrpc/v1"
10 "google.golang.org/grpc/codes"
11 "google.golang.org/grpc/status"
12 )
13
14 var (
15 errUnsupportedNetworkType = errors.New("unsupported network type")
16 errUnsupportedEndpointType = errors.New("unsupported endpoint type")
17 )
18
19 type v0ServiceWrapper struct {
20 s *grpcService
21 }
22
23 func newV0ServiceWrapper(s *grpcService) *v0ServiceWrapper {
24 return &v0ServiceWrapper{s}
25 }
26
27 var _ ncproxygrpcv0.NetworkConfigProxyServer = &v0ServiceWrapper{}
28
29 func (w *v0ServiceWrapper) AddNIC(ctx context.Context, req *ncproxygrpcv0.AddNICRequest) (_ *ncproxygrpcv0.AddNICResponse, err error) {
30 v1Req := &ncproxygrpc.AddNICRequest{
31 ContainerID: req.ContainerID,
32 NicID: req.NicID,
33 EndpointName: req.EndpointName,
34 }
35 _, err = w.s.AddNIC(ctx, v1Req)
36 if err != nil {
37 return nil, err
38 }
39 return &ncproxygrpcv0.AddNICResponse{}, nil
40 }
41
42 func (w *v0ServiceWrapper) ModifyNIC(ctx context.Context, req *ncproxygrpcv0.ModifyNICRequest) (_ *ncproxygrpcv0.ModifyNICResponse, err error) {
43 v1Req := &ncproxygrpc.ModifyNICRequest{
44 ContainerID: req.ContainerID,
45 NicID: req.NicID,
46 EndpointName: req.EndpointName,
47 }
48 if req.IovPolicySettings != nil {
49 v1Req.EndpointSettings = &ncproxygrpc.EndpointSettings{
50 Settings: &ncproxygrpc.EndpointSettings_HcnEndpoint{
51 HcnEndpoint: &ncproxygrpc.HcnEndpointSettings{
52 Policies: &ncproxygrpc.HcnEndpointPolicies{
53 IovPolicySettings: &ncproxygrpc.IovEndpointPolicySetting{
54 IovOffloadWeight: req.IovPolicySettings.IovOffloadWeight,
55 QueuePairsRequested: req.IovPolicySettings.QueuePairsRequested,
56 InterruptModeration: req.IovPolicySettings.InterruptModeration,
57 },
58 },
59 },
60 },
61 }
62 }
63 _, err = w.s.ModifyNIC(ctx, v1Req)
64 if err != nil {
65 return nil, err
66 }
67 return &ncproxygrpcv0.ModifyNICResponse{}, nil
68 }
69
70 func (w *v0ServiceWrapper) DeleteNIC(ctx context.Context, req *ncproxygrpcv0.DeleteNICRequest) (_ *ncproxygrpcv0.DeleteNICResponse, err error) {
71 v1Req := &ncproxygrpc.DeleteNICRequest{
72 ContainerID: req.ContainerID,
73 NicID: req.NicID,
74 EndpointName: req.EndpointName,
75 }
76 _, err = w.s.DeleteNIC(ctx, v1Req)
77 if err != nil {
78 return nil, err
79 }
80 return &ncproxygrpcv0.DeleteNICResponse{}, nil
81 }
82
83 func (w *v0ServiceWrapper) CreateNetwork(ctx context.Context, req *ncproxygrpcv0.CreateNetworkRequest) (_ *ncproxygrpcv0.CreateNetworkResponse, err error) {
84 v1Req := &ncproxygrpc.CreateNetworkRequest{
85 Network: &ncproxygrpc.Network{
86 Settings: &ncproxygrpc.Network_HcnNetwork{
87 HcnNetwork: &ncproxygrpc.HostComputeNetworkSettings{
88 Name: req.Name,
89 Mode: ncproxygrpc.HostComputeNetworkSettings_NetworkMode(req.Mode),
90 SwitchName: req.SwitchName,
91 IpamType: ncproxygrpc.HostComputeNetworkSettings_IpamType(req.IpamType),
92 SubnetIpaddressPrefix: req.SubnetIpaddressPrefix,
93 DefaultGateway: req.DefaultGateway,
94 },
95 },
96 },
97 }
98 resp, err := w.s.CreateNetwork(ctx, v1Req)
99 if err != nil {
100 return nil, err
101 }
102 return &ncproxygrpcv0.CreateNetworkResponse{
103 ID: resp.ID,
104 }, nil
105 }
106
107 func (w *v0ServiceWrapper) CreateEndpoint(ctx context.Context, req *ncproxygrpcv0.CreateEndpointRequest) (_ *ncproxygrpcv0.CreateEndpointResponse, err error) {
108 var v1DnsSettings *ncproxygrpc.DnsSetting
109 if req.DnsSetting != nil {
110 v1DnsSettings = &ncproxygrpc.DnsSetting{
111 ServerIpAddrs: req.DnsSetting.ServerIpAddrs,
112 Domain: req.DnsSetting.Domain,
113 Search: req.DnsSetting.Search,
114 }
115 }
116 var v1PortnamePolicySetting *ncproxygrpc.PortNameEndpointPolicySetting
117 if req.PortnamePolicySetting != nil {
118 v1PortnamePolicySetting = &ncproxygrpc.PortNameEndpointPolicySetting{
119 PortName: req.PortnamePolicySetting.PortName,
120 }
121 }
122
123 var v1IovPolicySettings *ncproxygrpc.IovEndpointPolicySetting
124 if req.IovPolicySettings != nil {
125 v1IovPolicySettings = &ncproxygrpc.IovEndpointPolicySetting{
126 IovOffloadWeight: req.IovPolicySettings.IovOffloadWeight,
127 QueuePairsRequested: req.IovPolicySettings.QueuePairsRequested,
128 InterruptModeration: req.IovPolicySettings.InterruptModeration,
129 }
130 }
131 prefixLen, err := strconv.ParseUint(req.IpaddressPrefixlength, 10, 32)
132 if err != nil {
133 return nil, status.Errorf(codes.InvalidArgument, "received invalid ip address prefix length %+v: %v", req, err)
134 }
135 v1Req := &ncproxygrpc.CreateEndpointRequest{
136 EndpointSettings: &ncproxygrpc.EndpointSettings{
137 Settings: &ncproxygrpc.EndpointSettings_HcnEndpoint{
138 HcnEndpoint: &ncproxygrpc.HcnEndpointSettings{
139 Name: req.Name,
140 Macaddress: req.Macaddress,
141 Ipaddress: req.Ipaddress,
142 IpaddressPrefixlength: uint32(prefixLen),
143 NetworkName: req.NetworkName,
144 DnsSetting: v1DnsSettings,
145 Policies: &ncproxygrpc.HcnEndpointPolicies{
146 PortnamePolicySetting: v1PortnamePolicySetting,
147 IovPolicySettings: v1IovPolicySettings,
148 },
149 },
150 },
151 },
152 }
153 resp, err := w.s.CreateEndpoint(ctx, v1Req)
154 if err != nil {
155 return nil, err
156 }
157 return &ncproxygrpcv0.CreateEndpointResponse{
158 ID: resp.ID,
159 }, nil
160 }
161
162 func (w *v0ServiceWrapper) AddEndpoint(ctx context.Context, req *ncproxygrpcv0.AddEndpointRequest) (_ *ncproxygrpcv0.AddEndpointResponse, err error) {
163 v1Req := &ncproxygrpc.AddEndpointRequest{
164 Name: req.Name,
165 NamespaceID: req.NamespaceID,
166 }
167 _, err = w.s.AddEndpoint(ctx, v1Req)
168 if err != nil {
169 return nil, err
170 }
171 return &ncproxygrpcv0.AddEndpointResponse{}, nil
172 }
173
174 func (w *v0ServiceWrapper) DeleteEndpoint(ctx context.Context, req *ncproxygrpcv0.DeleteEndpointRequest) (_ *ncproxygrpcv0.DeleteEndpointResponse, err error) {
175 v1Req := &ncproxygrpc.DeleteEndpointRequest{
176 Name: req.Name,
177 }
178 _, err = w.s.DeleteEndpoint(ctx, v1Req)
179 if err != nil {
180 return nil, err
181 }
182 return &ncproxygrpcv0.DeleteEndpointResponse{}, nil
183 }
184
185 func (w *v0ServiceWrapper) DeleteNetwork(ctx context.Context, req *ncproxygrpcv0.DeleteNetworkRequest) (_ *ncproxygrpcv0.DeleteNetworkResponse, err error) {
186 v1Req := &ncproxygrpc.DeleteNetworkRequest{
187 Name: req.Name,
188 }
189 _, err = w.s.DeleteNetwork(ctx, v1Req)
190 if err != nil {
191 return nil, err
192 }
193 return &ncproxygrpcv0.DeleteNetworkResponse{}, nil
194 }
195
196 func (w *v0ServiceWrapper) GetEndpoint(ctx context.Context, req *ncproxygrpcv0.GetEndpointRequest) (_ *ncproxygrpcv0.GetEndpointResponse, err error) {
197 v1Req := &ncproxygrpc.GetEndpointRequest{
198 Name: req.Name,
199 }
200 resp, err := w.s.GetEndpoint(ctx, v1Req)
201 if err != nil {
202 return nil, err
203 }
204 v0Resp, err := v1EndpointToV0EndpointResp(resp)
205 if err != nil {
206 if err == errUnsupportedEndpointType {
207 return nil, status.Errorf(codes.NotFound, "no endpoint with name `%s` found", req.Name)
208 }
209 return nil, err
210 }
211
212 return v0Resp, nil
213 }
214
215 func v1EndpointToV0EndpointResp(v1EndpointResp *ncproxygrpc.GetEndpointResponse) (_ *ncproxygrpcv0.GetEndpointResponse, err error) {
216 if v1EndpointResp.Endpoint != nil {
217 if v1EndpointResp.Endpoint.GetHcnEndpoint() != nil {
218 v0Resp := &ncproxygrpcv0.GetEndpointResponse{
219 ID: v1EndpointResp.ID,
220 Namespace: v1EndpointResp.Namespace,
221 }
222 v1EndpointSettings := v1EndpointResp.Endpoint.GetHcnEndpoint()
223 v0Resp.Name = v1EndpointSettings.Name
224 v0Resp.Network = v1EndpointSettings.NetworkName
225
226 if v1EndpointSettings.DnsSetting != nil {
227 v0Resp.DnsSetting = &ncproxygrpcv0.DnsSetting{
228 ServerIpAddrs: v1EndpointSettings.DnsSetting.ServerIpAddrs,
229 Domain: v1EndpointSettings.DnsSetting.Domain,
230 Search: v1EndpointSettings.DnsSetting.Search,
231 }
232 }
233 return v0Resp, nil
234 }
235 }
236 return nil, errUnsupportedEndpointType
237 }
238
239 func (w *v0ServiceWrapper) GetEndpoints(ctx context.Context, req *ncproxygrpcv0.GetEndpointsRequest) (_ *ncproxygrpcv0.GetEndpointsResponse, err error) {
240 resp, err := w.s.GetEndpoints(ctx, &ncproxygrpc.GetEndpointsRequest{})
241 if err != nil {
242 return nil, err
243 }
244 v0Endpoints := make([]*ncproxygrpcv0.GetEndpointResponse, len(resp.Endpoints))
245 for i, e := range resp.Endpoints {
246 v0Endpoint, err := v1EndpointToV0EndpointResp(e)
247 if err != nil {
248 if err == errUnsupportedEndpointType {
249
250 continue
251 }
252 return nil, err
253 }
254 v0Endpoints[i] = v0Endpoint
255 }
256 return &ncproxygrpcv0.GetEndpointsResponse{
257 Endpoints: v0Endpoints,
258 }, nil
259 }
260
261 func (w *v0ServiceWrapper) GetNetwork(ctx context.Context, req *ncproxygrpcv0.GetNetworkRequest) (_ *ncproxygrpcv0.GetNetworkResponse, err error) {
262 v1Req := &ncproxygrpc.GetNetworkRequest{
263 Name: req.Name,
264 }
265 resp, err := w.s.GetNetwork(ctx, v1Req)
266 if err != nil {
267 return nil, err
268 }
269
270 v0Resp, err := v1NetworkToV0NetworkResp(resp)
271 if err != nil {
272 if err == errUnsupportedNetworkType {
273 return nil, status.Errorf(codes.NotFound, "no network with name `%s` found", req.Name)
274 }
275 return nil, err
276 }
277
278 return v0Resp, nil
279 }
280
281 func v1NetworkToV0NetworkResp(v1NetworkResp *ncproxygrpc.GetNetworkResponse) (_ *ncproxygrpcv0.GetNetworkResponse, err error) {
282 if v1NetworkResp.Network != nil {
283 if v1NetworkResp.Network.GetHcnNetwork() != nil {
284 v0Resp := &ncproxygrpcv0.GetNetworkResponse{
285 ID: v1NetworkResp.ID,
286 Name: v1NetworkResp.Network.GetHcnNetwork().Name,
287 }
288 return v0Resp, nil
289 }
290 }
291 return nil, errUnsupportedNetworkType
292 }
293
294 func (w *v0ServiceWrapper) GetNetworks(ctx context.Context, req *ncproxygrpcv0.GetNetworksRequest) (_ *ncproxygrpcv0.GetNetworksResponse, err error) {
295 resp, err := w.s.GetNetworks(ctx, &ncproxygrpc.GetNetworksRequest{})
296 if err != nil {
297 return nil, err
298 }
299 v0Networks := make([]*ncproxygrpcv0.GetNetworkResponse, len(resp.Networks))
300 for i, n := range resp.Networks {
301 v0Network, err := v1NetworkToV0NetworkResp(n)
302 if err != nil {
303 if err == errUnsupportedNetworkType {
304
305 continue
306 }
307 return nil, err
308 }
309 v0Networks[i] = v0Network
310 }
311 return &ncproxygrpcv0.GetNetworksResponse{
312 Networks: v0Networks,
313 }, nil
314 }
315
View as plain text