persist: save and restore state from persist.json

Save and restore state from persist.json instead of state.json

Signed-off-by: Wei Zhang <[email protected]>

virtcontainers/api.go

@@ -105,6 +105,7 @@ func createSandboxFromConfig(ctx context.Context, sandboxConfig SandboxConfig, f
 		}
 	}()
 
+	s.Logger().Error("=====")
 	if err := s.getAndStoreGuestDetails(); err != nil {
 		return nil, err
 	}

virtcontainers/container.go

@@ -419,6 +419,9 @@ func (c *Container) setContainerState(state stateString) error {
 	}
 
 	c.sandbox.PersistState()
+	if err := c.sandbox.store.Dump(); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -625,9 +628,14 @@ func newContainer(sandbox *Sandbox, contConfig ContainerConfig) (*Container, err
 		ctx:           sandbox.ctx,
 	}
 
-	state, err := c.sandbox.storage.fetchContainerState(c.sandboxID, c.id)
+	/*state, err := c.sandbox.storage.fetchContainerState(c.sandboxID, c.id)
 	if err == nil {
 		c.state = state
+	}*/
+
+	if err := c.Restore(); err != nil &&
+		!os.IsNotExist(err) && err != ContainerPersistNotExist {
+		return nil, err
 	}
 
 	process, err := c.sandbox.storage.fetchContainerProcess(c.sandboxID, c.id)

virtcontainers/persist.go

@@ -6,14 +6,17 @@
 package virtcontainers
 
 import (
-	//"fmt"
-
-	//"github.com/sirupsen/logrus"
+	"errors"
 
 	"github.com/kata-containers/runtime/virtcontainers/device/api"
 	persistapi "github.com/kata-containers/runtime/virtcontainers/persist/api"
 )
 
+var (
+	SandboxPersistNotExist   = errors.New("sandbox doesn't exist in persist data")
+	ContainerPersistNotExist = errors.New("container doesn't exist in persist data")
+)
+
 // PersistVersion set persist data version to current version in runtime
 func (s *Sandbox) PersistVersion() {
 	s.store.RegisterHook("version", func(ss *persistapi.SandboxState, cs map[string]persistapi.ContainerState) error {
@@ -88,44 +91,61 @@ func (s *Sandbox) PersistDevices() {
 	})
 }
 
-// Restore will restore data from persist disk on disk
-func (s *Sandbox) Restore() error {
-	if err := s.store.Restore(s.id); err != nil {
-		return err
-	}
-
+func (s *Sandbox) getSbxAndCntStates() (*persistapi.SandboxState, map[string]persistapi.ContainerState, error) {
 	ss, cs, err := s.store.GetStates()
 	if err != nil {
-		return err
+		return nil, nil, err
 	}
 
-	/*
-		// TODO: need more modifications, restoring containers
-		// will make sandbox.addContainer failing
-		if s.containers == nil {
-			s.containers = make(map[string]*Container)
+	if len(cs) == 0 {
+		if err := s.store.Restore(s.id); err != nil {
+			return nil, nil, err
 		}
 
-		for id, cont := range cs {
-			s.containers[id] = &Container{
-				state: State{
-					State:         stateString(cont.State),
-					BlockDeviceID: cont.Rootfs.BlockDeviceID,
-					Fstype:        cont.Rootfs.FsType,
-					Pid:           cont.ShimPid,
-				},
-			}
+		ss, cs, err = s.store.GetStates()
+		if err != nil {
+			return nil, nil, err
 		}
 
-		sbxCont, ok := s.containers[ss.SandboxContainer]
-		if !ok {
-			return fmt.Errorf("failed to get sandbox container state")
+		if len(cs) == 0 {
+			return nil, nil, SandboxPersistNotExist
 		}
-	*/
+	}
+	return ss, cs, nil
+}
+
+// Restore will restore sandbox ata from persist file on disk
+func (s *Sandbox) Restore() error {
+	ss, cs, err := s.getSbxAndCntStates()
+	if err != nil {
+		return err
+	}
+
 	s.state.GuestMemoryBlockSizeMB = ss.GuestMemoryBlockSizeMB
 	s.state.BlockIndex = ss.HypervisorState.BlockIndex
 	s.state.State = stateString(cs[ss.SandboxContainer].State)
 	s.state.Pid = cs[ss.SandboxContainer].ShimPid
 
 	return nil
 }
+
+// RestoreContainer will restore container data from persist file on disk
+func (c *Container) Restore() error {
+	_, cs, err := c.sandbox.getSbxAndCntStates()
+	if err != nil {
+		return err
+	}
+
+	if _, ok := cs[c.id]; !ok {
+		return ContainerPersistNotExist
+	}
+
+	c.state = State{
+		State:         stateString(cs[c.id].State),
+		BlockDeviceID: cs[c.id].Rootfs.BlockDeviceID,
+		Fstype:        cs[c.id].Rootfs.FsType,
+		Pid:           cs[c.id].ShimPid,
+	}
+
+	return nil
+}

virtcontainers/persist/fs/fs.go

@@ -9,6 +9,7 @@ package fs
 import (
 	"encoding/json"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"syscall"
@@ -139,15 +140,12 @@ func (fs *FS) Restore(sid string) error {
 	}
 
 	fs.sandboxState.SandboxContainer = sid
+
 	sandboxDir, err := fs.sandboxDir()
 	if err != nil {
 		return err
 	}
 
-	if err := os.MkdirAll(sandboxDir, dirMode); err != nil {
-		return err
-	}
-
 	if err := fs.lock(); err != nil {
 		return err
 	}
@@ -166,13 +164,7 @@ func (fs *FS) Restore(sid string) error {
 	}
 
 	// walk sandbox dir and find container
-	d, err := os.OpenFile(sandboxDir, os.O_RDONLY, fileMode)
-	if err != nil {
-		return err
-	}
-	defer d.Close()
-
-	files, err := d.Readdir(-1)
+	files, err := ioutil.ReadDir(sandboxDir)
 	if err != nil {
 		return err
 	}

virtcontainers/sandbox.go

@@ -1680,11 +1680,15 @@ func (s *Sandbox) Stop() error {
 	}
 
 	for _, c := range s.containers {
+		c.Logger().Errorf("============container %q stop", c.id)
 		if err := c.stop(); err != nil {
+			c.Logger().Errorf("============container %q stop error: %v", c.id, err)
 			return err
 		}
+		c.Logger().Errorf("============container %q stop success", c.id)
 	}
 
+	s.Logger().Errorf("============sandbox stop VM")
 	if err := s.stopVM(); err != nil {
 		return err
 	}