Merge pull request firecracker-microvm#182 from sipsma/fccontrol

Integrate fccontrol plugin with shim.

Author: sipsma

agent/service.go

@@ -103,25 +103,25 @@ func (ts *TaskService) Create(requestCtx context.Context, req *taskAPI.CreateTas
 
 	extraData, err := unmarshalExtraData(req.Options)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "failed to unmarshal extra data")
 	}
 
 	bundleDir := bundle.Dir(filepath.Join(containerRootDir, req.ID))
 	err = bundleDir.Create()
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "failed to create bundle dir")
 	}
 
 	err = bundleDir.OCIConfig().Write(extraData.JsonSpec)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "failed to write oci config file")
 	}
 
 	// TODO replace with proper drive mounting once that PR is merged. Right now, all containers in
 	// this VM start up with the same rootfs image no matter their configuration
 	err = bundleDir.MountRootfs("/dev/vdb", "ext4", nil)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "failed to mount rootfs device")
 	}
 
 	// Create a runc shim to manage this task
@@ -130,7 +130,7 @@ func (ts *TaskService) Create(requestCtx context.Context, req *taskAPI.CreateTas
 	taskCtx, taskCancel := context.WithCancel(ts.shimCtx)
 	runcService, err := runc.New(taskCtx, req.ID, ts.publisher, taskCancel)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "failed to create runc shim for task")
 	}
 
 	defer func() {
@@ -143,7 +143,7 @@ func (ts *TaskService) Create(requestCtx context.Context, req *taskAPI.CreateTas
 	fifoSet, err := cio.NewFIFOSetInDir(bundleDir.RootPath(), req.ID, req.Terminal)
 	if err != nil {
 		logger.WithError(err).Error("failed opening stdio FIFOs")
-		return nil, err
+		return nil, errors.Wrap(err, "failed to open stdio FIFOs")
 	}
 
 	// Don't try to connect any io streams that weren't requested by the client
@@ -161,7 +161,7 @@ func (ts *TaskService) Create(requestCtx context.Context, req *taskAPI.CreateTas
 
 	task, err := ts.taskManager.AddTask(req.ID, runcService, bundleDir, extraData, fifoSet, taskCtx.Done(), taskCancel)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "failed to add task")
 	}
 
 	logger.Debug("calling runc create")
@@ -180,13 +180,13 @@ func (ts *TaskService) Create(requestCtx context.Context, req *taskAPI.CreateTas
 	// the task to ensure we capture all task output
 	err = <-task.StartStdioProxy(taskCtx, vm.VSockToFIFO, acceptVSock)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "failed to initialize stdio proxy")
 	}
 
 	resp, err := task.Create(requestCtx, req)
 	if err != nil {
 		logger.WithError(err).Error("error creating container")
-		return nil, err
+		return nil, errors.Wrap(err, "failed create container")
 	}
 
 	logger.WithField("pid", resp.Pid).Debugf("create succeeded")

examples/Makefile

@@ -11,8 +11,13 @@
 # express or implied. See the License for the specific language governing
 # permissions and limitations under the License.
 
+# Set this to pass additional commandline flags to the go compiler, e.g. "make test EXTRAGOARGS=-v"
+EXTRAGOARGS?=
+
+SOURCES:=$(shell find . -name '*.go')
 GOMOD := $(shell go env GOMOD)
 GOSUM := $(GOMOD:.mod=.sum)
+DOCKER_IMAGE_TAG?=latest
 
 all: examples
 
@@ -21,6 +26,19 @@ examples: taskworkflow
 taskworkflow: taskworkflow.go $(GOMOD) $(GOSUM)
 	go build -o taskworkflow taskworkflow.go
 
+test-docker: $(SOURCES) $(GOMOD) $(GOSUM)
+	docker run --rm \
+		--privileged \
+		--ipc=host \
+		--volume /dev:/dev \
+		--volume /sys:/sys \
+		--volume /run/udev/control:/run/udev/control \
+		--volume $(shell pwd)/logs:/var/log/firecracker-containerd-test \
+		--workdir="/firecracker-containerd/examples" \
+		--env EXTRAGOARGS="${EXTRAGOARGS}" \
+		localhost/firecracker-containerd-e2etest-naive:${DOCKER_IMAGE_TAG} \
+		"make examples && ./taskworkflow"
+
 clean:
 	- rm -f taskworkflow
 

examples/taskworkflow.go

@@ -28,6 +28,8 @@ import (
 	"github.com/containerd/containerd/namespaces"
 	"github.com/containerd/containerd/oci"
 	"github.com/firecracker-microvm/firecracker-containerd/proto"
+	fccontrol "github.com/firecracker-microvm/firecracker-containerd/proto/service/fccontrol/grpc"
+	"github.com/firecracker-microvm/firecracker-containerd/runtime/firecrackeroci"
 	specs "github.com/opencontainers/runtime-spec/specs-go"
 	"github.com/pkg/errors"
 )
@@ -52,7 +54,7 @@ func main() {
 	}
 }
 
-func taskWorkflow(containerIP string, gateway string, netMask string) error {
+func taskWorkflow(containerIP string, gateway string, netMask string) (err error) {
 	log.Println("Creating containerd client")
 	client, err := containerd.New("/run/containerd/containerd.sock")
 	if err != nil {
@@ -71,6 +73,39 @@ func taskWorkflow(containerIP string, gateway string, netMask string) error {
 		return errors.Wrapf(err, "creating container")
 
 	}
+
+	fcClient := fccontrol.NewFirecrackerClient(client.Conn())
+
+	vmID := "fc-example"
+	createVMRequest := &proto.CreateVMRequest{
+		VMID: vmID,
+	}
+
+	if containerIP != "" {
+		createVMRequest.NetworkInterfaces = []*proto.FirecrackerNetworkInterface{
+			{
+				MacAddress:  macAddress,
+				HostDevName: hostDevName,
+			},
+		}
+		createVMRequest.KernelArgs = fmt.Sprintf(kernelArgsFormat, containerIP, gateway, netMask)
+	}
+
+	_, err = fcClient.CreateVM(ctx, createVMRequest)
+	if err != nil {
+		return errors.Wrap(err, "failed to create VM")
+	}
+
+	defer func() {
+		_, stopErr := fcClient.StopVM(ctx, &proto.StopVMRequest{VMID: vmID})
+		if stopErr != nil {
+			log.Printf("failed to stop VM, err: %v\n", stopErr)
+		}
+		if err == nil {
+			err = stopErr
+		}
+	}()
+
 	log.Printf("Successfully pulled %s image\n", image.Name())
 	container, err := client.NewContainer(
 		ctx,
@@ -82,6 +117,7 @@ func taskWorkflow(containerIP string, gateway string, netMask string) error {
 			oci.WithHostNamespace(specs.NetworkNamespace),
 			oci.WithHostHostsFile,
 			oci.WithHostResolvconf,
+			firecrackeroci.WithVMID(vmID),
 		),
 		containerd.WithRuntime("aws.firecracker", nil),
 	)
@@ -90,26 +126,7 @@ func taskWorkflow(containerIP string, gateway string, netMask string) error {
 	}
 	defer container.Delete(ctx, containerd.WithSnapshotCleanup)
 
-	task, err := container.NewTask(ctx,
-		cio.NewCreator(cio.WithStdio),
-		func(ctx context.Context, _ *containerd.Client, ti *containerd.TaskInfo) error {
-			if containerIP == "" {
-				return nil
-			}
-			// An IP address for the container has been provided. Configure
-			// the VM opts accordingly.
-			firecrackerConfig := &proto.FirecrackerConfig{
-				NetworkInterfaces: []*proto.FirecrackerNetworkInterface{
-					{
-						MacAddress:  macAddress,
-						HostDevName: hostDevName,
-					},
-				},
-				KernelArgs: fmt.Sprintf(kernelArgsFormat, containerIP, gateway, netMask),
-			}
-			ti.Options = firecrackerConfig
-			return nil
-		})
+	task, err := container.NewTask(ctx, cio.NewCreator(cio.WithStdio))
 	if err != nil {
 		return errors.Wrapf(err, "creating task")
 

firecracker-control/common.go

@@ -13,30 +13,7 @@
 
 package service
 
-import (
-	"time"
-
-	models "github.com/firecracker-microvm/firecracker-go-sdk/client/models"
-	"github.com/pkg/errors"
-)
-
 const (
 	localPluginID = "fc-control"
 	grpcPluginID  = "fc-control-service"
 )
-
-var (
-	// ErrVMNotFound means that a VM with the given ID not found
-	ErrVMNotFound = errors.New("vm not found")
-)
-
-const (
-	firecrackerStartTimeout = 5 * time.Second
-	defaultCPUTemplate      = models.CPUTemplateT2
-	defaultCPUCount         = 1
-	defaultMemSizeMb        = 128
-	defaultKernelArgs       = "console=ttyS0 noapic reboot=k panic=1 pci=off nomodules rw"
-	defaultFilesPath        = "/var/lib/firecracker-containerd/runtime/"
-	defaultKernelPath       = defaultFilesPath + "default-vmlinux.bin"
-	defaultRootfsPath       = defaultFilesPath + "default-rootfs.img"
-)