Expose config to allow for advanced handlers

Exposing the config allows for modification of the machine configuration
during the 'Start' method. An example usage of this is using a custom
jailer

Author: xibz

handlers.go

@@ -46,7 +46,7 @@ var ConfigValidationHandler = Handler{
 	Name: ValidateCfgHandlerName,
 	Fn: func(ctx context.Context, m *Machine) error {
 		// ensure that the configuration is valid for the FcInit handlers.
-		return m.cfg.Validate()
+		return m.Cfg.Validate()
 	},
 }
 
@@ -55,12 +55,12 @@ var ConfigValidationHandler = Handler{
 var JailerConfigValidationHandler = Handler{
 	Name: ValidateJailerCfgHandlerName,
 	Fn: func(ctx context.Context, m *Machine) error {
-		if m.cfg.JailerCfg == nil {
+		if m.Cfg.JailerCfg == nil {
 			return nil
 		}
 
 		hasRoot := false
-		for _, drive := range m.cfg.Drives {
+		for _, drive := range m.Cfg.Drives {
 			if BoolValue(drive.IsRootDevice) {
 				hasRoot = true
 				break
@@ -71,27 +71,27 @@ var JailerConfigValidationHandler = Handler{
 			return fmt.Errorf("A root drive must be present in the drive list")
 		}
 
-		if m.cfg.JailerCfg.ChrootStrategy == nil {
+		if m.Cfg.JailerCfg.ChrootStrategy == nil {
 			return fmt.Errorf("ChrootStrategy cannot be nil")
 		}
 
-		if len(m.cfg.JailerCfg.ExecFile) == 0 {
+		if len(m.Cfg.JailerCfg.ExecFile) == 0 {
 			return fmt.Errorf("exec file must be specified when using jailer mode")
 		}
 
-		if len(m.cfg.JailerCfg.ID) == 0 {
+		if len(m.Cfg.JailerCfg.ID) == 0 {
 			return fmt.Errorf("id must be specified when using jailer mode")
 		}
 
-		if m.cfg.JailerCfg.GID == nil {
+		if m.Cfg.JailerCfg.GID == nil {
 			return fmt.Errorf("GID must be specified when using jailer mode")
 		}
 
-		if m.cfg.JailerCfg.UID == nil {
+		if m.Cfg.JailerCfg.UID == nil {
 			return fmt.Errorf("UID must be specified when using jailer mode")
 		}
 
-		if m.cfg.JailerCfg.NumaNode == nil {
+		if m.Cfg.JailerCfg.NumaNode == nil {
 			return fmt.Errorf("ID must be specified when using jailer mode")
 		}
 
@@ -112,8 +112,8 @@ var StartVMMHandler = Handler{
 var CreateLogFilesHandler = Handler{
 	Name: CreateLogFilesHandlerName,
 	Fn: func(ctx context.Context, m *Machine) error {
-		logFifoPath := m.cfg.LogFifo
-		metricsFifoPath := m.cfg.MetricsFifo
+		logFifoPath := m.Cfg.LogFifo
+		metricsFifoPath := m.Cfg.MetricsFifo
 
 		if len(logFifoPath) == 0 || len(metricsFifoPath) == 0 {
 			// logging is disabled
@@ -160,7 +160,7 @@ var CreateMachineHandler = Handler{
 var CreateBootSourceHandler = Handler{
 	Name: CreateBootSourceHandlerName,
 	Fn: func(ctx context.Context, m *Machine) error {
-		return m.createBootSource(ctx, m.cfg.KernelImagePath, m.cfg.KernelArgs)
+		return m.createBootSource(ctx, m.Cfg.KernelImagePath, m.Cfg.KernelArgs)
 	},
 }
 
@@ -169,7 +169,7 @@ var CreateBootSourceHandler = Handler{
 var AttachDrivesHandler = Handler{
 	Name: AttachDrivesHandlerName,
 	Fn: func(ctx context.Context, m *Machine) error {
-		return m.attachDrives(ctx, m.cfg.Drives...)
+		return m.attachDrives(ctx, m.Cfg.Drives...)
 	},
 }
 
@@ -178,7 +178,7 @@ var AttachDrivesHandler = Handler{
 var CreateNetworkInterfacesHandler = Handler{
 	Name: CreateNetworkInterfacesHandlerName,
 	Fn: func(ctx context.Context, m *Machine) error {
-		return m.createNetworkInterfaces(ctx, m.cfg.NetworkInterfaces...)
+		return m.createNetworkInterfaces(ctx, m.Cfg.NetworkInterfaces...)
 	},
 }
 
@@ -187,7 +187,7 @@ var CreateNetworkInterfacesHandler = Handler{
 var AddVsocksHandler = Handler{
 	Name: AddVsocksHandlerName,
 	Fn: func(ctx context.Context, m *Machine) error {
-		return m.addVsocks(ctx, m.cfg.VsockDevices...)
+		return m.addVsocks(ctx, m.Cfg.VsockDevices...)
 	},
 }
 
@@ -234,7 +234,7 @@ type Handlers struct {
 // into a single list and running.
 func (h Handlers) Run(ctx context.Context, m *Machine) error {
 	l := HandlerList{}
-	if !m.cfg.DisableValidation {
+	if !m.Cfg.DisableValidation {
 		l = l.Append(h.Validation.list...)
 	}
 

jailer.go

@@ -35,7 +35,7 @@ const (
 var (
 	// ErrMissingJailerConfig will occur when entering jailer logic but the
 	// jailer config had not been specified.
-	ErrMissingJailerConfig = fmt.Errorf("JailerConfig was not set for use.")
+	ErrMissingJailerConfig = fmt.Errorf("jailer config was not set for use")
 )
 
 // SeccompLevelValue represents a secure computing level type.
@@ -372,52 +372,52 @@ func LinkFilesHandler(rootfs, kernelImageFileName string) Handler {
 	return Handler{
 		Name: LinkFilesToRootFSHandlerName,
 		Fn: func(ctx context.Context, m *Machine) error {
-			if m.cfg.JailerCfg == nil {
+			if m.Cfg.JailerCfg == nil {
 				return ErrMissingJailerConfig
 			}
 
 			// copy kernel image to root fs
 			if err := linkFileToRootFS(
-				m.cfg.JailerCfg,
+				m.Cfg.JailerCfg,
 				filepath.Join(rootfs, kernelImageFileName),
-				m.cfg.KernelImagePath,
+				m.Cfg.KernelImagePath,
 			); err != nil {
 				return err
 			}
 
 			// copy all drives to the root fs
-			for i, drive := range m.cfg.Drives {
+			for i, drive := range m.Cfg.Drives {
 				hostPath := StringValue(drive.PathOnHost)
 				driveFileName := filepath.Base(hostPath)
 
 				if err := linkFileToRootFS(
-					m.cfg.JailerCfg,
+					m.Cfg.JailerCfg,
 					filepath.Join(rootfs, driveFileName),
 					hostPath,
 				); err != nil {
 					return err
 				}
 
-				m.cfg.Drives[i].PathOnHost = String(driveFileName)
+				m.Cfg.Drives[i].PathOnHost = String(driveFileName)
 			}
 
-			m.cfg.KernelImagePath = kernelImageFileName
+			m.Cfg.KernelImagePath = kernelImageFileName
 
-			for _, fifoPath := range []*string{&m.cfg.LogFifo, &m.cfg.MetricsFifo} {
+			for _, fifoPath := range []*string{&m.Cfg.LogFifo, &m.Cfg.MetricsFifo} {
 				if fifoPath == nil || *fifoPath == "" {
 					continue
 				}
 
 				fileName := filepath.Base(*fifoPath)
 				if err := linkFileToRootFS(
-					m.cfg.JailerCfg,
+					m.Cfg.JailerCfg,
 					filepath.Join(rootfs, fileName),
 					*fifoPath,
 				); err != nil {
 					return err
 				}
 
-				if err := os.Chown(filepath.Join(rootfs, fileName), *m.cfg.JailerCfg.UID, *m.cfg.JailerCfg.GID); err != nil {
+				if err := os.Chown(filepath.Join(rootfs, fileName), *m.Cfg.JailerCfg.UID, *m.Cfg.JailerCfg.GID); err != nil {
 					return err
 				}
 

machine.go

@@ -141,7 +141,7 @@ type Machine struct {
 	// Handlers holds the set of handlers that are run for validation and start
 	Handlers Handlers
 
-	cfg           Config
+	Cfg           Config
 	client        *Client
 	cmd           *exec.Cmd
 	logger        *log.Entry
@@ -209,17 +209,17 @@ type VsockDevice struct {
 // SocketPath returns the filesystem path to the socket used for VMM
 // communication
 func (m *Machine) socketPath() string {
-	return m.cfg.SocketPath
+	return m.Cfg.SocketPath
 }
 
 // LogFile returns the filesystem path of the VMM log
 func (m *Machine) LogFile() string {
-	return m.cfg.LogFifo
+	return m.Cfg.LogFifo
 }
 
 // LogLevel returns the VMM log level.
 func (m *Machine) LogLevel() string {
-	return m.cfg.LogLevel
+	return m.Cfg.LogLevel
 }
 
 // NewMachine initializes a new Machine instance and performs validation of the
@@ -261,7 +261,7 @@ func NewMachine(ctx context.Context, cfg Config, opts ...Opt) (*Machine, error)
 	}
 
 	m.machineConfig = cfg.MachineCfg
-	m.cfg = cfg
+	m.Cfg = cfg
 
 	m.logger.Debug("Called NewMachine()")
 	return m, nil
@@ -309,7 +309,7 @@ func (m *Machine) Wait(ctx context.Context) error {
 }
 
 func (m *Machine) addVsocks(ctx context.Context, vsocks ...VsockDevice) error {
-	for _, dev := range m.cfg.VsockDevices {
+	for _, dev := range m.Cfg.VsockDevices {
 		if err := m.addVsock(ctx, dev); err != nil {
 			return err
 		}
@@ -342,7 +342,7 @@ func (m *Machine) attachDrives(ctx context.Context, drives ...models.Drive) erro
 
 // startVMM starts the firecracker vmm process and configures logging.
 func (m *Machine) startVMM(ctx context.Context) error {
-	m.logger.Printf("Called startVMM(), setting up a VMM on %s", m.cfg.SocketPath)
+	m.logger.Printf("Called startVMM(), setting up a VMM on %s", m.Cfg.SocketPath)
 
 	errCh := make(chan error)
 
@@ -352,7 +352,7 @@ func (m *Machine) startVMM(ctx context.Context) error {
 		close(m.exitCh)
 		return err
 	}
-	m.logger.Debugf("VMM started socket path is %s", m.cfg.SocketPath)
+	m.logger.Debugf("VMM started socket path is %s", m.Cfg.SocketPath)
 
 	go func() {
 		if err := m.cmd.Wait(); err != nil {
@@ -361,9 +361,9 @@ func (m *Machine) startVMM(ctx context.Context) error {
 			m.logger.Printf("firecracker exited: status=0")
 		}
 
-		os.Remove(m.cfg.SocketPath)
-		os.Remove(m.cfg.LogFifo)
-		os.Remove(m.cfg.MetricsFifo)
+		os.Remove(m.Cfg.SocketPath)
+		os.Remove(m.Cfg.LogFifo)
+		os.Remove(m.Cfg.MetricsFifo)
 		errCh <- err
 
 		// Notify subscribers that there will be no more values.
@@ -390,7 +390,7 @@ func (m *Machine) startVMM(ctx context.Context) error {
 	// Wait for firecracker to initialize:
 	err = m.waitForSocket(3*time.Second, errCh)
 	if err != nil {
-		msg := fmt.Sprintf("Firecracker did not create API socket %s: %s", m.cfg.SocketPath, err)
+		msg := fmt.Sprintf("Firecracker did not create API socket %s: %s", m.Cfg.SocketPath, err)
 		err = errors.New(msg)
 		close(m.exitCh)
 		return err
@@ -443,16 +443,16 @@ func createFifos(logFifo, metricsFifo string) error {
 }
 
 func (m *Machine) setupLogging(ctx context.Context) error {
-	if len(m.cfg.LogFifo) == 0 || len(m.cfg.MetricsFifo) == 0 {
+	if len(m.Cfg.LogFifo) == 0 || len(m.Cfg.MetricsFifo) == 0 {
 		// No logging configured
 		m.logger.Printf("VMM logging and metrics disabled.")
 		return nil
 	}
 
 	l := models.Logger{
-		LogFifo:       String(m.cfg.LogFifo),
-		Level:         String(m.cfg.LogLevel),
-		MetricsFifo:   String(m.cfg.MetricsFifo),
+		LogFifo:       String(m.Cfg.LogFifo),
+		Level:         String(m.Cfg.LogLevel),
+		MetricsFifo:   String(m.Cfg.MetricsFifo),
 		ShowLevel:     Bool(true),
 		ShowLogOrigin: Bool(false),
 		Options:       []string{},
@@ -464,12 +464,12 @@ func (m *Machine) setupLogging(ctx context.Context) error {
 	}
 
 	m.logger.Debugf("Configured VMM logging to %s, metrics to %s",
-		m.cfg.LogFifo,
-		m.cfg.MetricsFifo,
+		m.Cfg.LogFifo,
+		m.Cfg.MetricsFifo,
 	)
 
-	if m.cfg.FifoLogWriter != nil {
-		if err := captureFifoToFile(m.logger, m.cfg.LogFifo, m.cfg.FifoLogWriter); err != nil {
+	if m.Cfg.FifoLogWriter != nil {
+		if err := captureFifoToFile(m.logger, m.Cfg.LogFifo, m.Cfg.FifoLogWriter); err != nil {
 			return err
 		}
 	}
@@ -507,7 +507,7 @@ func captureFifoToFile(logger *log.Entry, fifoPath string, fifo io.Writer) error
 }
 
 func (m *Machine) createMachine(ctx context.Context) error {
-	resp, err := m.client.PutMachineConfiguration(ctx, &m.cfg.MachineCfg)
+	resp, err := m.client.PutMachineConfiguration(ctx, &m.Cfg.MachineCfg)
 	if err != nil {
 		m.logger.Errorf("PutMachineConfiguration returned %s", resp.Error())
 		return err
@@ -699,7 +699,7 @@ func (m *Machine) waitForSocket(timeout time.Duration, exitchan chan error) erro
 		case err := <-exitchan:
 			return err
 		case <-ticker.C:
-			if _, err := os.Stat(m.cfg.SocketPath); err != nil {
+			if _, err := os.Stat(m.Cfg.SocketPath); err != nil {
 				continue
 			}
 

machine_test.go

@@ -616,7 +616,7 @@ func TestWaitForSocket(t *testing.T) {
 	errchan := make(chan error)
 
 	m := Machine{
-		cfg:    Config{SocketPath: filename},
+		Cfg:    Config{SocketPath: filename},
 		logger: fctesting.NewLogEntry(t),
 	}