kata-agent: add network gRPC support

Introduce initial support for setting up interface and routes when
working with Kata agent.

Fixes: #596

Signed-off-by: Eric Ernst <[email protected]>

Author: Eric Ernst

kata_agent.go

@@ -300,6 +300,83 @@ func (k *kataAgent) exec(pod *Pod, c Container, cmd Cmd) (*Process, error) {
 	return prepareAndStartShim(pod, k.shim, c.id, req.ExecId, k.state.URL, cmd)
 }
 
+func (k *kataAgent) generateInterfacesAndRoutes(networkNS NetworkNamespace) ([]*grpc.Interface, []*grpc.Route, error) {
+
+	if networkNS.NetNsPath == "" {
+		return nil, nil, nil
+	}
+
+	var routes []*grpc.Route
+	var ifaces []*grpc.Interface
+
+	for _, endpoint := range networkNS.Endpoints {
+
+		var ipAddresses []*grpc.IPAddress
+		for _, addr := range endpoint.Properties().Addrs {
+			// Skip IPv6 because not supported
+			if addr.IP.To4() == nil {
+				// Skip IPv6 because not supported
+				k.Logger().WithFields(logrus.Fields{
+					"unsupported-address-type": "ipv6",
+					"address":                  addr,
+				}).Warn("unsupported address")
+				continue
+			}
+			// Skip localhost interface
+			if addr.IP.IsLoopback() {
+				continue
+			}
+			netMask, _ := addr.Mask.Size()
+			ipAddress := grpc.IPAddress{
+				Family:  grpc.IPFamily_v4,
+				Address: addr.IP.String(),
+				Mask:    fmt.Sprintf("%d", netMask),
+			}
+			ipAddresses = append(ipAddresses, &ipAddress)
+		}
+		ifc := grpc.Interface{
+			IPAddresses: ipAddresses,
+			Device:      endpoint.Name(),
+			Name:        endpoint.Name(),
+			Mtu:         uint64(endpoint.Properties().Iface.MTU),
+			HwAddr:      endpoint.HardwareAddr(),
+		}
+
+		ifaces = append(ifaces, &ifc)
+
+		for _, route := range endpoint.Properties().Routes {
+			var r grpc.Route
+
+			if route.Dst != nil {
+				r.Dest = route.Dst.String()
+
+				if route.Dst.IP.To4() == nil {
+					// Skip IPv6 because not supported
+					k.Logger().WithFields(logrus.Fields{
+						"unsupported-route-type": "ipv6",
+						"destination":            r.Dest,
+					}).Warn("unsupported route")
+					continue
+				}
+			}
+
+			if route.Gw != nil {
+				r.Gateway = route.Gw.String()
+			}
+
+			if route.Src != nil {
+				r.Source = route.Src.String()
+			}
+
+			r.Device = endpoint.Name()
+			r.Scope = uint32(route.Scope)
+			routes = append(routes, &r)
+
+		}
+	}
+	return ifaces, routes, nil
+}
+
 func (k *kataAgent) startPod(pod Pod) error {
 	if k.proxy == nil {
 		return errorMissingProxy
@@ -335,6 +412,45 @@ func (k *kataAgent) startPod(pod Pod) error {
 		hostname = hostname[:maxHostnameLen]
 	}
 
+	//
+	// Setup network interfaces and routes
+	//
+	interfaces, routes, err := k.generateInterfacesAndRoutes(pod.networkNS)
+	if err != nil {
+		return err
+	}
+	for _, ifc := range interfaces {
+		// send update interface request
+		ifcReq := &grpc.UpdateInterfaceRequest{
+			Interface: ifc,
+		}
+		resultingInterface, err := k.sendReq(ifcReq)
+		if err != nil {
+			k.Logger().WithFields(logrus.Fields{
+				"interface-requested": fmt.Sprintf("%+v", ifc),
+				"resulting-interface": fmt.Sprintf("%+v", resultingInterface),
+			}).WithError(err).Error("update interface request failed")
+			return err
+		}
+	}
+
+	if routes != nil {
+		routesReq := &grpc.UpdateRoutesRequest{
+			Routes: &grpc.Routes{
+				Routes: routes,
+			},
+		}
+
+		resultingRoutes, err := k.sendReq(routesReq)
+		if err != nil {
+			k.Logger().WithFields(logrus.Fields{
+				"routes-requested": fmt.Sprintf("%+v", routes),
+				"resulting-routes": fmt.Sprintf("%+v", resultingRoutes),
+			}).WithError(err).Error("update routes request failed")
+			return err
+		}
+	}
+
 	// We mount the shared directory in a predefined location
 	// in the guest.
 	// This is where at least some of the host config files
@@ -659,6 +775,12 @@ func (k *kataAgent) sendReq(request interface{}) (interface{}, error) {
 	case *grpc.SignalProcessRequest:
 		_, err := k.client.SignalProcess(context.Background(), req)
 		return nil, err
+	case *grpc.UpdateRoutesRequest:
+		_, err := k.client.UpdateRoutes(context.Background(), req)
+		return nil, err
+	case *grpc.UpdateInterfaceRequest:
+		ifc, err := k.client.UpdateInterface(context.Background(), req)
+		return ifc, err
 	default:
 		return nil, fmt.Errorf("Unknown gRPC type %T", req)
 	}