Merge remote-tracking branch 'origin/pr/114'

Author: samuelkarp

firecracker.go

@@ -15,9 +15,10 @@ package firecracker
 
 import (
 	"context"
-	"github.com/go-openapi/strfmt"
 	"time"
 
+	"github.com/go-openapi/strfmt"
+
 	"github.com/sirupsen/logrus"
 
 	"github.com/firecracker-microvm/firecracker-go-sdk/client"
@@ -234,6 +235,39 @@ func (f *Client) PutMmds(ctx context.Context, metadata interface{}, opts ...PutM
 	return f.client.Operations.PutMmds(params)
 }
 
+// GetMmdsOpt is a functional option to be used for the GetMmds API in setting
+// any additional optional fields.
+type GetMmdsOpt func(*ops.GetMmdsParams)
+
+// GetMmds is a wrapper for the swagger generated client to make calling of the
+// API easier.
+func (f *Client) GetMmds(ctx context.Context, opts ...GetMmdsOpt) (*ops.GetMmdsOK, error) {
+	params := ops.NewGetMmdsParams()
+	params.SetContext(ctx)
+	for _, opt := range opts {
+		opt(params)
+	}
+
+	return f.client.Operations.GetMmds(params)
+}
+
+// PatchMmdsOpt is a functional option to be used for the GetMmds API in setting
+// any additional optional fields.
+type PatchMmdsOpt func(*ops.PatchMmdsParams)
+
+// PatchMmds is a wrapper for the swagger generated client to make calling of the
+// API easier.
+func (f *Client) PatchMmds(ctx context.Context, metadata interface{}, opts ...PatchMmdsOpt) (*ops.PatchMmdsNoContent, error) {
+	params := ops.NewPatchMmdsParams()
+	params.SetContext(ctx)
+	params.SetBody(metadata)
+	for _, opt := range opts {
+		opt(params)
+	}
+
+	return f.client.Operations.PatchMmds(params)
+}
+
 // GetMachineConfigurationOpt  is a functional option to be used for the
 // GetMachineConfiguration API in setting any additional optional fields.
 type GetMachineConfigurationOpt func(*ops.GetMachineConfigurationParams)

machine.go

@@ -15,6 +15,7 @@ package firecracker
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
@@ -660,6 +661,40 @@ func (m *Machine) SetMetadata(ctx context.Context, metadata interface{}) error {
 	return nil
 }
 
+// UpdateMetadata patches the machine's metadata for MDDS
+func (m *Machine) UpdateMetadata(ctx context.Context, metadata interface{}) error {
+	if _, err := m.client.PatchMmds(ctx, metadata); err != nil {
+		m.logger.Errorf("Updating metadata: %s", err)
+		return err
+	}
+
+	m.logger.Printf("UpdateMetadata successful")
+	return nil
+}
+
+// GetMetadata gets the machine's metadata from MDDS and unmarshals it into v
+func (m *Machine) GetMetadata(ctx context.Context, v interface{}) error {
+	resp, err := m.client.GetMmds(ctx)
+	if err != nil {
+		m.logger.Errorf("Getting metadata: %s", err)
+		return err
+	}
+
+	payloadData, err := json.Marshal(resp.Payload)
+	if err != nil {
+		m.logger.Errorf("Getting metadata failed parsing payload: %s", err)
+		return err
+	}
+
+	if err := json.Unmarshal(payloadData, v); err != nil {
+		m.logger.Errorf("Getting metadata failed parsing payload: %s", err)
+		return err
+	}
+
+	m.logger.Printf("GetMetadata successful")
+	return nil
+}
+
 // UpdateGuestDrive will modify the current guest drive of ID index with the new
 // parameters of the partialDrive.
 func (m *Machine) UpdateGuestDrive(ctx context.Context, driveID, pathOnHost string, opts ...PatchGuestDriveByIDOpt) error {

machine_test.go

@@ -330,6 +330,8 @@ func TestMicroVMExecution(t *testing.T) {
 	t.Run("TestAttachSecondaryDrive", func(t *testing.T) { testAttachSecondaryDrive(ctx, t, m) })
 	t.Run("TestAttachVsock", func(t *testing.T) { testAttachVsock(ctx, t, m) })
 	t.Run("SetMetadata", func(t *testing.T) { testSetMetadata(ctx, t, m) })
+	t.Run("UpdateMetadata", func(t *testing.T) { testUpdateMetadata(ctx, t, m) })
+	t.Run("GetMetadata", func(t *testing.T) { testGetMetadata(ctx, t, m) }) // Should be after testSetMetadata and testUpdateMetadata
 	t.Run("TestUpdateGuestDrive", func(t *testing.T) { testUpdateGuestDrive(ctx, t, m) })
 	t.Run("TestUpdateGuestNetworkInterface", func(t *testing.T) { testUpdateGuestNetworkInterface(ctx, t, m) })
 	t.Run("TestStartInstance", func(t *testing.T) { testStartInstance(ctx, t, m) })
@@ -667,6 +669,28 @@ func testSetMetadata(ctx context.Context, t *testing.T, m *Machine) {
 	}
 }
 
+func testUpdateMetadata(ctx context.Context, t *testing.T, m *Machine) {
+	metadata := map[string]string{"patch_key": "patch_value"}
+	err := m.UpdateMetadata(ctx, metadata)
+	if err != nil {
+		t.Errorf("failed to set metadata: %s", err)
+	}
+}
+
+func testGetMetadata(ctx context.Context, t *testing.T, m *Machine) {
+	metadata := struct {
+		Key      string `json:"key"`
+		PatchKey string `json:"patch_key"`
+	}{}
+	if err := m.GetMetadata(ctx, &metadata); err != nil {
+		t.Errorf("failed to get metadata: %s", err)
+	}
+
+	if metadata.Key != "value" || metadata.PatchKey != "patch_value" {
+		t.Error("failed to get expected metadata values")
+	}
+}
+
 func TestLogFiles(t *testing.T) {
 	cfg := Config{
 		Debug:           true,