diff options
| -rw-r--r-- | libpod/boltdb_state.go | 1117 | ||||
| -rw-r--r-- | libpod/boltdb_state_internal.go | 382 | ||||
| -rw-r--r-- | libpod/pod.go | 12 |
3 files changed, 1074 insertions, 437 deletions
diff --git a/libpod/boltdb_state.go b/libpod/boltdb_state.go index 3584c9a9d..96d987c82 100644 --- a/libpod/boltdb_state.go +++ b/libpod/boltdb_state.go @@ -41,42 +41,21 @@ func NewBoltState(path, lockDir string, runtime *Runtime) (State, error) { // Perform initial database setup err = db.Update(func(tx *bolt.Tx) error { - _, err = tx.CreateBucketIfNotExists(idRegistryBkt) - if err != nil { + if _, err := tx.CreateBucketIfNotExists(idRegistryBkt); err != nil { return errors.Wrapf(err, "error creating id-registry bucket") } - _, err = tx.CreateBucketIfNotExists(nameRegistryBkt) - if err != nil { + if _, err := tx.CreateBucketIfNotExists(nameRegistryBkt); err != nil { return errors.Wrapf(err, "error creating name-registry bucket") } - _, err = tx.CreateBucketIfNotExists(ctrConfigBkt) - if err != nil { - return errors.Wrapf(err, "error creating container-config bucket") - } - _, err = tx.CreateBucketIfNotExists(ctrStateBkt) - if err != nil { - return errors.Wrapf(err, "error creating container-state bucket") + if _, err := tx.CreateBucketIfNotExists(ctrBkt); err != nil { + return errors.Wrapf(err, "error creating containers bucket") } - _, err = tx.CreateBucketIfNotExists(netNSBkt) - if err != nil { - return errors.Wrapf(err, "error creating net-ns bucket") + if _, err := tx.CreateBucketIfNotExists(podBkt); err != nil { + return errors.Wrapf(err, "error creating pods bucket") } - _, err = tx.CreateBucketIfNotExists(runtimeConfigBkt) - if err != nil { + if _, err := tx.CreateBucketIfNotExists(runtimeConfigBkt); err != nil { return errors.Wrapf(err, "error creating runtime-config bucket") } - _, err = tx.CreateBucketIfNotExists(ctrDependsBkt) - if err != nil { - return errors.Wrapf(err, "error creating container-depends bucket") - } - _, err = tx.CreateBucketIfNotExists(podBkt) - if err != nil { - return errors.Wrapf(err, "error creating pod bucket") - } - _, err = tx.CreateBucketIfNotExists(podContainersBkt) - if err != nil { - return errors.Wrapf(err, "error creating pod-containers bucket") - } return nil }) if err != nil { @@ -117,12 +96,7 @@ func (s *BoltState) Refresh() error { return err } - ctrStateBucket, err := getCtrStateBucket(tx) - if err != nil { - return err - } - - netNSBucket, err := getNetNSBucket(tx) + ctrsBucket, err := getCtrBucket(tx) if err != nil { return err } @@ -133,15 +107,21 @@ func (s *BoltState) Refresh() error { // Then save the modified state // Also clear all network namespaces err = idBucket.ForEach(func(id, name []byte) error { - if err := netNSBucket.Delete(id); err != nil { - return errors.Wrapf(err, "error removing network namespace ID %s", string(id)) + ctrBkt := ctrsBucket.Bucket(id) + if ctrBkt == nil { + // It's not a container, nothing to do + return nil } - stateBytes := ctrStateBucket.Get(id) + // First, delete the network namespace + if err := ctrBkt.Delete(netNSKey); err != nil { + return errors.Wrapf(err, "error removing network namespace for container %s", string(id)) + } + + stateBytes := ctrBkt.Get(stateKey) if stateBytes == nil { - // This is a pod, not a container - // Nothing to do - return nil + // Badly formatted container bucket + return errors.Wrapf(ErrInternal, "container %s missing state in DB", string(id)) } state := new(containerState) @@ -160,7 +140,7 @@ func (s *BoltState) Refresh() error { return errors.Wrapf(err, "error marshalling modified state for container %s", string(id)) } - if err := ctrStateBucket.Put(id, newStateBytes); err != nil { + if err := ctrBkt.Put(stateKey, newStateBytes); err != nil { return errors.Wrapf(err, "error updating state for container %s in DB", string(id)) } @@ -194,28 +174,12 @@ func (s *BoltState) Container(id string) (*Container, error) { defer db.Close() err = db.View(func(tx *bolt.Tx) error { - ctrConfigBucket, err := getCtrConfigBucket(tx) + ctrBucket, err := getCtrBucket(tx) if err != nil { return err } - ctrStateBucket, err := getCtrStateBucket(tx) - if err != nil { - return err - } - - netNSBucket, err := getNetNSBucket(tx) - if err != nil { - return err - } - - err = s.getContainerFromDB(ctrID, ctr, ctrConfigBucket, - ctrStateBucket, netNSBucket) - if err != nil { - return err - } - - return nil + return s.getContainerFromDB(ctrID, ctr, ctrBucket) }) if err != nil { return nil, err @@ -251,26 +215,15 @@ func (s *BoltState) LookupContainer(idOrName string) (*Container, error) { return err } - ctrConfigBucket, err := getCtrConfigBucket(tx) - if err != nil { - return err - } - - ctrStateBucket, err := getCtrStateBucket(tx) - if err != nil { - return err - } - - netNSBucket, err := getNetNSBucket(tx) + ctrBucket, err := getCtrBucket(tx) if err != nil { return err } // First, check if the ID given was the actual container ID - // Query against state because it's a lot smaller than config var id []byte - stateExists := ctrStateBucket.Get([]byte(idOrName)) - if stateExists != nil { + ctrExists := ctrBucket.Bucket([]byte(idOrName)) + if ctrExists != nil { // A full container ID was given id = []byte(idOrName) } else { @@ -302,13 +255,7 @@ func (s *BoltState) LookupContainer(idOrName string) (*Container, error) { } } - err = s.getContainerFromDB(id, ctr, ctrConfigBucket, - ctrStateBucket, netNSBucket) - if err != nil { - return err - } - - return nil + return s.getContainerFromDB(id, ctr, ctrBucket) }) if err != nil { return nil, err @@ -338,12 +285,12 @@ func (s *BoltState) HasContainer(id string) (bool, error) { exists := false err = db.View(func(tx *bolt.Tx) error { - idsBucket, err := getIDBucket(tx) + ctrBucket, err := getCtrBucket(tx) if err != nil { return err } - ctrExists := idsBucket.Get(ctrID) + ctrExists := ctrBucket.Bucket(ctrID) if ctrExists != nil { exists = true } @@ -372,131 +319,20 @@ func (s *BoltState) AddContainer(ctr *Container) error { return errors.Wrapf(ErrInvalidArg, "cannot add a container that belongs to a pod with AddContainer - use AddContainerToPod") } - // JSON container structs to insert into DB - // TODO use a higher-performance struct encoding than JSON - configJSON, err := json.Marshal(ctr.config) - if err != nil { - return errors.Wrapf(err, "error marshalling container %s config to JSON", ctr.ID()) - } - stateJSON, err := json.Marshal(ctr.state) - if err != nil { - return errors.Wrapf(err, "error marshalling container %s state to JSON", ctr.ID()) - } - netNSPath := "" - if ctr.state.NetNS != nil { - netNSPath = ctr.state.NetNS.Path() - } - - // Collect dependencies for the container. Use a map to ensure no dupes. - dependsCtrs := ctr.Dependencies() - - ctrID := []byte(ctr.ID()) - ctrName := []byte(ctr.Name()) - - db, err := s.getDBCon() - if err != nil { - return err - } - defer db.Close() - - err = db.Update(func(tx *bolt.Tx) error { - idsBucket, err := getIDBucket(tx) - if err != nil { - return err - } - - namesBucket, err := getNamesBucket(tx) - if err != nil { - return err - } - - ctrConfigBucket, err := getCtrConfigBucket(tx) - if err != nil { - return err - } - - ctrStateBucket, err := getCtrStateBucket(tx) - if err != nil { - return err - } - - netNSBucket, err := getNetNSBucket(tx) - if err != nil { - return err - } - - ctrDependsBucket, err := getCtrDependsBucket(tx) - if err != nil { - return err - } - - // Check if we already have a container with the given ID and name - idExist := idsBucket.Get(ctrID) - if idExist != nil { - return errors.Wrapf(ErrCtrExists, "container with ID %s already exists", ctr.ID()) - } - nameExist := namesBucket.Get(ctrName) - if nameExist != nil { - return errors.Wrapf(ErrCtrExists, "container with name %s already exists", ctr.Name()) - } - - // No overlapping containers - // Add the new container to the DB - if err := idsBucket.Put(ctrID, ctrName); err != nil { - return errors.Wrapf(err, "error adding container %s ID to DB", ctr.ID()) - } - if err := namesBucket.Put(ctrName, ctrID); err != nil { - return errors.Wrapf(err, "error adding container %s name (%s) to DB", ctr.ID(), ctr.Name()) - } - if err := ctrConfigBucket.Put(ctrID, configJSON); err != nil { - return errors.Wrapf(err, "error adding container %s config to DB", ctr.ID()) - } - if err := ctrStateBucket.Put(ctrID, stateJSON); err != nil { - return errors.Wrapf(err, "error adding container %s state to DB", ctr.ID()) - } - if netNSPath != "" { - if err := netNSBucket.Put(ctrID, []byte(netNSPath)); err != nil { - return errors.Wrapf(err, "error adding container %s netns path to DB", ctr.ID()) - } - } - - // Add dependencies for the container - for _, dependsCtr := range dependsCtrs { - depCtrID := []byte(dependsCtr) - deps := ctrDependsBucket.Get(depCtrID) - depsArray := []string{} - if deps != nil { - if err := json.Unmarshal(deps, &depsArray); err != nil { - return errors.Wrapf(err, "error unmarshalling container %s deps JSON", dependsCtr) - } - } - depsArray = append(depsArray, ctr.ID()) - depsJSON, err := json.Marshal(&depsArray) - if err != nil { - return errors.Wrapf(err, "error marshalling container %s deps JSON", dependsCtr) - } - if err := ctrDependsBucket.Put(depCtrID, depsJSON); err != nil { - return errors.Wrapf(err, "error adding container %s dependencies JSON to DB", dependsCtr) - } - } - - return nil - }) - return err + return s.addContainer(ctr, nil) } // RemoveContainer removes a container from the state -// The container will only be removed from the state and not any pods it belongs -// to +// Only removes containers not in pods - for containers that are a member of a +// pod, use RemoveContainerFromPod func (s *BoltState) RemoveContainer(ctr *Container) error { if !s.valid { return ErrDBClosed } - ctrID := []byte(ctr.ID()) - ctrName := []byte(ctr.Name()) - - depCtrs := ctr.Dependencies() + if ctr.config.Pod != "" { + return errors.Wrapf(ErrPodExists, "container %s is part of a pod, use RemoveContainerFromPod instead", ctr.ID()) + } db, err := s.getDBCon() if err != nil { @@ -505,120 +341,7 @@ func (s *BoltState) RemoveContainer(ctr *Container) error { defer db.Close() err = db.Update(func(tx *bolt.Tx) error { - idsBucket, err := getIDBucket(tx) - if err != nil { - return err - } - - namesBucket, err := getNamesBucket(tx) - if err != nil { - return err - } - - ctrConfigBucket, err := getCtrConfigBucket(tx) - if err != nil { - return err - } - - ctrStateBucket, err := getCtrStateBucket(tx) - if err != nil { - return err - } - - netNSBucket, err := getNetNSBucket(tx) - if err != nil { - return err - } - - ctrDependsBucket, err := getCtrDependsBucket(tx) - if err != nil { - return err - } - - // Does the container exist? - ctrExists := idsBucket.Get(ctrID) - if ctrExists == nil { - return errors.Wrapf(ErrNoSuchCtr, "no container with ID %s found in DB", ctr.ID()) - } - - // Does the container have dependencies? - ctrDeps := ctrDependsBucket.Get(ctrID) - if ctrDeps != nil { - dependsCtrs := []string{} - if err := json.Unmarshal(ctrDeps, &dependsCtrs); err != nil { - return errors.Wrapf(err, "cannot unmarshal container %s dependencies JSON", ctr.ID()) - } - if len(dependsCtrs) > 0 { - depsStr := strings.Join(dependsCtrs, ", ") - - return errors.Wrapf(ErrCtrExists, "container %s is a dependency on the following containers: %s", ctr.ID(), depsStr) - } - } - - if err := idsBucket.Delete(ctrID); err != nil { - return errors.Wrapf(err, "error deleting container %s ID in DB", ctr.ID()) - } - - if err := namesBucket.Delete(ctrName); err != nil { - return errors.Wrapf(err, "error deleting container %s name in DB", ctr.ID()) - } - - if err := ctrConfigBucket.Delete(ctrID); err != nil { - return errors.Wrapf(err, "error deleting container %s config in DB", ctr.ID()) - } - - if err := ctrStateBucket.Delete(ctrID); err != nil { - return errors.Wrapf(err, "error deleting container %s state in DB", ctr.ID()) - } - - // Can safely delete netNS even if it doesn't exist - // Delete on a non-existent key doesn't error - if err := netNSBucket.Delete(ctrID); err != nil { - return errors.Wrapf(err, "error deleting container %s network ns in DB", ctr.ID()) - } - - // As above, can safely delete even if it doesn't exist - if err := ctrDependsBucket.Delete(ctrID); err != nil { - return errors.Wrapf(err, "error deleting container %s dependencies in DB", ctr.ID()) - } - - // Remove us from other container's dependencies - for _, depCtr := range depCtrs { - depCtrID := []byte(depCtr) - dep := ctrDependsBucket.Get(depCtrID) - if dep == nil { - // Inconsistent state, but the dependency we were trying to remove doesn't exist... - // Just continue - continue - } - depStr := []string{} - if err := json.Unmarshal(dep, &depStr); err != nil { - return errors.Wrapf(err, "error unmarshaling ctr %s dependencies", ctr.ID(), depCtr) - } - newDeps := make([]string, 0, len(depStr)) - for _, checkID := range depStr { - if checkID != ctr.ID() { - newDeps = append(newDeps, checkID) - } - } - if len(newDeps) == 0 { - // Just delete the container's deps - if err := ctrDependsBucket.Delete(depCtrID); err != nil { - return errors.Wrapf(err, "error deleting container %s dependencies in DB", depCtr) - } - } else { - // Store the new deps - depsJSON, err := json.Marshal(&newDeps) - if err != nil { - return errors.Wrapf(err, "error marshalling container %s dependencies", depCtr) - } - if err := ctrDependsBucket.Put(depCtrID, depsJSON); err != nil { - return errors.Wrapf(err, "error adding container %s dependencies to DB", depCtr) - } - } - } - - return nil + return removeContainer(ctr, nil, tx) }) return err } @@ -645,27 +368,27 @@ func (s *BoltState) UpdateContainer(ctr *Container) error { defer db.Close() err = db.View(func(tx *bolt.Tx) error { - ctrStateBucket, err := getCtrStateBucket(tx) + ctrBucket, err := getCtrBucket(tx) if err != nil { return err } - netNSBucket, err := getNetNSBucket(tx) - if err != nil { - return err + ctrToUpdate := ctrBucket.Bucket(ctrID) + if ctrToUpdate == nil { + ctr.valid = false + return errors.Wrapf(ErrNoSuchCtr, "container %s does not exist in database", ctr.ID()) } - newStateBytes := ctrStateBucket.Get(ctrID) + newStateBytes := ctrToUpdate.Get(stateKey) if newStateBytes == nil { - ctr.valid = false - return errors.Wrapf(ErrCtrRemoved, "container %s removed from database", ctr.ID()) + return errors.Wrapf(ErrInternal, "container %s does not have a state key in DB", ctr.ID()) } if err := json.Unmarshal(newStateBytes, newState); err != nil { return errors.Wrapf(err, "error unmarshalling container %s state", ctr.ID()) } - netNSBytes := netNSBucket.Get(ctrID) + netNSBytes := ctrToUpdate.Get(netNSKey) if netNSBytes != nil { netNSPath = string(netNSBytes) } @@ -736,31 +459,30 @@ func (s *BoltState) SaveContainer(ctr *Container) error { defer db.Close() err = db.Update(func(tx *bolt.Tx) error { - ctrStateBucket, err := getCtrStateBucket(tx) - if err != nil { - return err - } - - netNSBucket, err := getNetNSBucket(tx) + ctrBucket, err := getCtrBucket(tx) if err != nil { return err } - oldJSON := ctrStateBucket.Get(ctrID) - if oldJSON == nil { - ctr.valid = false - return errors.Wrapf(ErrCtrRemoved, "container %s no longer present in DB", ctr.ID()) + ctrToSave := ctrBucket.Bucket(ctrID) + if ctrToSave == nil { + return errors.Wrapf(ErrNoSuchCtr, "container %s does not exist in DB", ctr.ID()) } // Update the state - if err := ctrStateBucket.Put(ctrID, stateJSON); err != nil { + if err := ctrToSave.Put(stateKey, stateJSON); err != nil { return errors.Wrapf(err, "error updating container %s state in DB", ctr.ID()) } if netNSPath != "" { - if err := netNSBucket.Put(ctrID, []byte(netNSPath)); err != nil { + if err := ctrToSave.Put(netNSKey, []byte(netNSPath)); err != nil { return errors.Wrapf(err, "error updating network namespace path for container %s in DB", ctr.ID()) } + } else { + // Delete the existing network namespace + if err := ctrToSave.Delete(netNSKey); err != nil { + return errors.Wrapf(err, "error removing network namespace path for container %s in DB", ctr.ID()) + } } return nil @@ -789,20 +511,30 @@ func (s *BoltState) ContainerInUse(ctr *Container) ([]string, error) { defer db.Close() err = db.View(func(tx *bolt.Tx) error { - ctrDependsBucket, err := getCtrDependsBucket(tx) + ctrBucket, err := getCtrBucket(tx) if err != nil { return err } - depsJSON := ctrDependsBucket.Get([]byte(ctr.ID())) - if depsJSON == nil { - // No deps, just return - return nil + ctrDB := ctrBucket.Bucket([]byte(ctr.ID())) + if ctrDB == nil { + ctr.valid = false + return errors.Wrapf(ErrNoSuchCtr, "no container with ID %s found in DB", ctr.ID()) } - // We have deps, un-JSON them - if err := json.Unmarshal(depsJSON, &depCtrs); err != nil { - return errors.Wrapf(err, "error unmarshalling container %s dependencies", ctr.ID()) + dependsBkt := ctrDB.Bucket(dependenciesBkt) + if dependsBkt == nil { + return errors.Wrapf(ErrInternal, "container %s has no dependencies bucket", ctr.ID()) + } + + // Iterate through and add dependencies + err = dependsBkt.ForEach(func(id, value []byte) error { + depCtrs = append(depCtrs, string(id)) + + return nil + }) + if err != nil { + return err } return nil @@ -830,44 +562,35 @@ func (s *BoltState) AllContainers() ([]*Container, error) { defer db.Close() err = db.View(func(tx *bolt.Tx) error { - ctrConfigBucket, err := getCtrConfigBucket(tx) - if err != nil { - return err - } - - ctrStateBucket, err := getCtrStateBucket(tx) + idBucket, err := getIDBucket(tx) if err != nil { return err } - netNSBucket, err := getNetNSBucket(tx) + ctrBucket, err := getCtrBucket(tx) if err != nil { return err } - // Iterate through all containers we know of in the state - // Build a full container struct for all of them and append + // Iterate through all IDs + // If they're containers, make a container from them and append // it into the containers listing - err = ctrStateBucket.ForEach(func(id, data []byte) error { + err = idBucket.ForEach(func(id, name []byte) error { + ctrExists := ctrBucket.Bucket(id) + if ctrExists == nil { + // It's a pod not a container + return nil + } + ctr := new(Container) ctr.config = new(ContainerConfig) ctr.state = new(containerState) - err = s.getContainerFromDB(id, ctr, ctrConfigBucket, - ctrStateBucket, netNSBucket) - if err != nil { - return err - } - ctrs = append(ctrs, ctr) - return nil + return s.getContainerFromDB(id, ctr, ctrBucket) }) - if err != nil { - return err - } - - return nil + return err }) if err != nil { return nil, err @@ -878,63 +601,705 @@ func (s *BoltState) AllContainers() ([]*Container, error) { // Pod retrieves a pod given its full ID func (s *BoltState) Pod(id string) (*Pod, error) { - return nil, ErrNotImplemented + if id == "" { + return nil, ErrEmptyID + } + + if !s.valid { + return nil, ErrDBClosed + } + + podID := []byte(id) + + pod := new(Pod) + + db, err := s.getDBCon() + if err != nil { + return nil, err + } + defer db.Close() + + err = db.View(func(tx *bolt.Tx) error { + podBkt, err := getPodBucket(tx) + if err != nil { + return err + } + + return s.getPodFromDB(podID, pod, podBkt) + }) + if err != nil { + return nil, err + } + + return pod, nil } // LookupPod retrieves a pod from full or unique partial ID or name func (s *BoltState) LookupPod(idOrName string) (*Pod, error) { - return nil, ErrNotImplemented + if idOrName == "" { + return nil, ErrEmptyID + } + + if !s.valid { + return nil, ErrDBClosed + } + + pod := new(Pod) + + db, err := s.getDBCon() + if err != nil { + return nil, err + } + defer db.Close() + + err = db.View(func(tx *bolt.Tx) error { + idBucket, err := getIDBucket(tx) + if err != nil { + return err + } + + podBkt, err := getPodBucket(tx) + if err != nil { + return err + } + + // First, check if the ID given was the actual pod ID + var id []byte + podExists := podBkt.Bucket([]byte(idOrName)) + if podExists != nil { + // A full pod ID was given + id = []byte(idOrName) + } else { + // They did not give us a full pod ID. + // Search for partial ID or full name matches + // Use else-if in case the name is set to a partial ID + exists := false + err = idBucket.ForEach(func(checkID, checkName []byte) error { + if string(checkName) == idOrName { + if exists { + return errors.Wrapf(ErrPodExists, "more than one result for ID or name %s", idOrName) + } + id = checkID + exists = true + } else if strings.HasPrefix(string(checkID), idOrName) { + if exists { + return errors.Wrapf(ErrPodExists, "more than one result for ID or name %s", idOrName) + } + id = checkID + exists = true + } + + return nil + }) + if err != nil { + return err + } else if !exists { + return errors.Wrapf(ErrNoSuchCtr, "no pod with name or ID %s found", idOrName) + } + } + + // We might have found a container ID, but it's OK + // We'll just fail in getPodFromDB with ErrNoSuchPod + + return s.getPodFromDB(id, pod, podBkt) + }) + if err != nil { + return nil, err + } + + return pod, nil } // HasPod checks if a pod with the given ID exists in the state func (s *BoltState) HasPod(id string) (bool, error) { - return false, ErrNotImplemented + if id == "" { + return false, ErrEmptyID + } + + if !s.valid { + return false, ErrDBClosed + } + + podID := []byte(id) + + exists := false + + db, err := s.getDBCon() + if err != nil { + return false, err + } + defer db.Close() + + err = db.View(func(tx *bolt.Tx) error { + podBkt, err := getPodBucket(tx) + if err != nil { + return err + } + + podBytes := podBkt.Get(podID) + if podBytes != nil { + exists = true + } + + return nil + }) + if err != nil { + return false, err + } + + return exists, nil } // PodHasContainer checks if the given pod has a container with the given ID func (s *BoltState) PodHasContainer(pod *Pod, id string) (bool, error) { - return false, ErrNotImplemented + if id == "" { + return false, ErrEmptyID + } + + if !s.valid { + return false, ErrDBClosed + } + + if !pod.valid { + return false, ErrPodRemoved + } + + ctrID := []byte(id) + podID := []byte(pod.ID()) + + exists := false + + db, err := s.getDBCon() + if err != nil { + return false, err + } + defer db.Close() + + err = db.View(func(tx *bolt.Tx) error { + podBkt, err := getPodBucket(tx) + if err != nil { + return err + } + + // Get pod itself + podDB := podBkt.Bucket(podID) + if podDB == nil { + pod.valid = false + return errors.Wrapf(ErrNoSuchPod, "pod %s not found in database", pod.ID()) + } + + // Get pod containers bucket + podCtrs := podDB.Bucket(containersBkt) + if podCtrs == nil { + return errors.Wrapf(ErrInternal, "pod %s missing containers bucket in DB", pod.ID()) + } + + ctr := podCtrs.Get(ctrID) + if ctr != nil { + exists = true + } + + return nil + }) + if err != nil { + return false, err + } + + return exists, nil } // PodContainersByID returns the IDs of all containers present in the given pod func (s *BoltState) PodContainersByID(pod *Pod) ([]string, error) { - return nil, ErrNotImplemented + if !s.valid { + return nil, ErrDBClosed + } + + if !pod.valid { + return nil, ErrPodRemoved + } + + podID := []byte(pod.ID()) + + ctrs := []string{} + + db, err := s.getDBCon() + if err != nil { + return nil, err + } + defer db.Close() + + err = db.View(func(tx *bolt.Tx) error { + podBkt, err := getPodBucket(tx) + if err != nil { + return err + } + + // Get pod itself + podDB := podBkt.Bucket(podID) + if podDB == nil { + pod.valid = false + return errors.Wrapf(ErrNoSuchPod, "pod %s not found in database", pod.ID()) + } + + // Get pod containers bucket + podCtrs := podDB.Bucket(containersBkt) + if podCtrs == nil { + return errors.Wrapf(ErrInternal, "pod %s missing containers bucket in DB", pod.ID()) + } + + // Iterate through all containers in the pod + err = podCtrs.ForEach(func(id, val []byte) error { + ctrs = append(ctrs, string(id)) + + return nil + }) + if err != nil { + return err + } + + return nil + }) + if err != nil { + return nil, err + } + + return ctrs, nil } // PodContainers returns all the containers present in the given pod func (s *BoltState) PodContainers(pod *Pod) ([]*Container, error) { - return nil, ErrNotImplemented + if !s.valid { + return nil, ErrDBClosed + } + + if !pod.valid { + return nil, ErrPodRemoved + } + + podID := []byte(pod.ID()) + + ctrs := []*Container{} + + db, err := s.getDBCon() + if err != nil { + return nil, err + } + defer db.Close() + + err = db.View(func(tx *bolt.Tx) error { + podBkt, err := getPodBucket(tx) + if err != nil { + return err + } + + ctrBkt, err := getCtrBucket(tx) + if err != nil { + return err + } + + // Get pod itself + podDB := podBkt.Bucket(podID) + if podDB == nil { + pod.valid = false + return errors.Wrapf(ErrNoSuchPod, "pod %s not found in database", pod.ID()) + } + + // Get pod containers bucket + podCtrs := podDB.Bucket(containersBkt) + if podCtrs == nil { + return errors.Wrapf(ErrInternal, "pod %s missing containers bucket in DB", pod.ID()) + } + + // Iterate through all containers in the pod + err = podCtrs.ForEach(func(id, val []byte) error { + newCtr := new(Container) + ctrs = append(ctrs, newCtr) + + return s.getContainerFromDB(id, newCtr, ctrBkt) + }) + if err != nil { + return err + } + + return nil + }) + if err != nil { + return nil, err + } + + return ctrs, nil } -// AddPod adds the given pod to the state. Only empty pods can be added. +// AddPod adds the given pod to the state. func (s *BoltState) AddPod(pod *Pod) error { - return ErrNotImplemented + if !s.valid { + return ErrDBClosed + } + + if !pod.valid { + return ErrPodRemoved + } + + podID := []byte(pod.ID()) + podName := []byte(pod.Name()) + + podJSON, err := json.Marshal(pod) + if err != nil { + return errors.Wrapf(err, "error marshalling pod %s JSON", pod.ID()) + } + + db, err := s.getDBCon() + if err != nil { + return err + } + defer db.Close() + + err = db.Update(func(tx *bolt.Tx) error { + podBkt, err := getPodBucket(tx) + if err != nil { + return err + } + + idsBkt, err := getIDBucket(tx) + if err != nil { + return err + } + + namesBkt, err := getNamesBucket(tx) + if err != nil { + return err + } + + // Check if we already have something with the given ID and name + idExist := idsBkt.Get(podID) + if idExist != nil { + return errors.Wrapf(ErrPodExists, "ID %s is in use", pod.ID()) + } + nameExist := namesBkt.Get(podName) + if nameExist != nil { + return errors.Wrapf(ErrPodExists, "name %s is in use", pod.Name()) + } + + // We are good to add the pod + // Make a bucket for it + newPod, err := podBkt.CreateBucket(podID) + if err != nil { + return errors.Wrapf(err, "error creating bucket for pod %s", pod.ID()) + } + + // Make a subbucket for pod containers + if _, err := newPod.CreateBucket(containersBkt); err != nil { + return errors.Wrapf(err, "error creating bucket for pod %s containers", pod.ID()) + } + + if err := newPod.Put(configKey, podJSON); err != nil { + return errors.Wrapf(err, "error storing pod %s configuration in DB", pod.ID()) + } + + // Add us to the ID and names buckets + if err := idsBkt.Put(podID, podName); err != nil { + return errors.Wrapf(err, "error storing pod %s ID in DB", pod.ID()) + } + if err := namesBkt.Put(podName, podID); err != nil { + return errors.Wrapf(err, "error storing pod %s name in DB", pod.Name()) + } + + return nil + }) + if err != nil { + return err + } + + return nil } // RemovePod removes the given pod from the state // Only empty pods can be removed func (s *BoltState) RemovePod(pod *Pod) error { - return ErrNotImplemented + if !s.valid { + return ErrDBClosed + } + + if !pod.valid { + return ErrPodRemoved + } + + podID := []byte(pod.ID()) + podName := []byte(pod.Name()) + + db, err := s.getDBCon() + if err != nil { + return err + } + defer db.Close() + + err = db.Update(func(tx *bolt.Tx) error { + podBkt, err := getPodBucket(tx) + if err != nil { + return err + } + + idsBkt, err := getIDBucket(tx) + if err != nil { + return err + } + + namesBkt, err := getNamesBucket(tx) + if err != nil { + return err + } + + // Check if the pod exists + podDB := podBkt.Bucket(podID) + if podDB == nil { + pod.valid = false + return errors.Wrapf(ErrNoSuchPod, "pod %s does not exist in DB", pod.ID()) + } + + // Check if pod is empty + // This should never be nil + // But if it is, we can assume there are no containers in the + // pod. + // So let's eject the malformed pod without error. + podCtrsBkt := podDB.Bucket(containersBkt) + if podCtrsBkt != nil { + cursor := podCtrsBkt.Cursor() + if id, _ := cursor.First(); id != nil { + return errors.Wrapf(ErrCtrExists, "pod %s is not empty", pod.ID()) + } + } + + // Pod is empty, and ready for removal + // Let's kick it out + if err := idsBkt.Delete(podID); err != nil { + return errors.Wrapf(err, "error removing pod %s ID from DB", pod.ID()) + } + if err := namesBkt.Delete(podName); err != nil { + return errors.Wrapf(err, "error removing pod %s name (%s) from DB", pod.ID(), pod.Name()) + } + if err := podBkt.DeleteBucket(podID); err != nil { + return errors.Wrapf(err, "error removing pod %s from DB", pod.ID()) + } + + return nil + }) + if err != nil { + return err + } + + return nil } // RemovePodContainers removes all containers in a pod func (s *BoltState) RemovePodContainers(pod *Pod) error { - return ErrNotImplemented + if !s.valid { + return ErrDBClosed + } + + if !pod.valid { + return ErrPodRemoved + } + + podID := []byte(pod.ID()) + + db, err := s.getDBCon() + if err != nil { + return err + } + defer db.Close() + + err = db.Update(func(tx *bolt.Tx) error { + podBkt, err := getPodBucket(tx) + if err != nil { + return err + } + + ctrBkt, err := getCtrBucket(tx) + if err != nil { + return err + } + + idsBkt, err := getIDBucket(tx) + if err != nil { + return err + } + + namesBkt, err := getNamesBucket(tx) + if err != nil { + return err + } + + // Check if the pod exists + podDB := podBkt.Bucket(podID) + if podDB == nil { + pod.valid = false + return errors.Wrapf(ErrNoSuchPod, "pod %s does not exist in DB", pod.ID()) + } + + podCtrsBkt := podDB.Bucket(containersBkt) + if podCtrsBkt == nil { + return errors.Wrapf(ErrInternal, "pod %s does not have a containers bucket", pod.ID()) + } + + // Traverse all containers in the pod with a cursor + // for-each has issues with data mutation + cursor := podCtrsBkt.Cursor() + id, name := cursor.Last() + for id != nil { + // Remove the container from the bucker + if err := podCtrsBkt.Delete(id); err != nil { + return errors.Wrapf(err, "error removing container %s from pod %s", string(id), pod.ID()) + } + + // Get the container so we can check dependencies + ctr := ctrBkt.Bucket(id) + if ctr == nil { + // This should never happen + // State is inconsistent + return errors.Wrapf(ErrNoSuchCtr, "pod %s referenced nonexistant container %s", pod.ID(), string(id)) + } + ctrDeps := ctr.Bucket(dependenciesBkt) + // This should never be nil, but if it is, we're + // removing it anyways, so continue if it is + if ctrDeps != nil { + err = ctrDeps.ForEach(func(depID, name []byte) error { + exists := podCtrsBkt.Get(depID) + if exists == nil { + // The dependency isn't in the + // pod + return errors.Wrapf(ErrCtrExists, "container %s has a dependency outside of pod %s", string(depID), pod.ID()) + } + return nil + }) + if err != nil { + return err + } + } + + // Dependencies are set, we're clear to remove + + if err := ctrBkt.DeleteBucket(id); err != nil { + return errors.Wrapf(ErrInternal, "error deleting container %s from DB", string(id)) + } + + if err := idsBkt.Delete(id); err != nil { + return errors.Wrapf(err, "error deleting container %s ID in DB", string(id)) + } + + if err := namesBkt.Delete(name); err != nil { + return errors.Wrapf(err, "error deleting container %s name in DB", string(id)) + } + + id, name = cursor.Last() + } + + return nil + }) + if err != nil { + return err + } + + return nil } // AddContainerToPod adds the given container to an existing pod // The container will be added to the state and the pod func (s *BoltState) AddContainerToPod(pod *Pod, ctr *Container) error { - return ErrNotImplemented + if !s.valid { + return ErrDBClosed + } + + if !pod.valid { + return ErrPodRemoved + } + + if !ctr.valid { + return ErrCtrRemoved + } + + if ctr.config.Pod != pod.ID() { + return errors.Wrapf(ErrNoSuchCtr, "container %s is not part of pod %s", ctr.ID(), pod.ID()) + } + + return s.addContainer(ctr, pod) } // RemoveContainerFromPod removes a container from an existing pod // The container will also be removed from the state func (s *BoltState) RemoveContainerFromPod(pod *Pod, ctr *Container) error { - return ErrNotImplemented + if !s.valid { + return ErrDBClosed + } + + if !pod.valid { + return ErrPodRemoved + } + + if ctr.config.Pod == "" { + return errors.Wrapf(ErrNoSuchPod, "container %s is not part of a pod, use RemoveContainer instead", ctr.ID()) + } + + if ctr.config.Pod != pod.ID() { + return errors.Wrapf(ErrInvalidArg, "container %s is not part of pod %s", ctr.ID(), pod.ID()) + } + + db, err := s.getDBCon() + if err != nil { + return err + } + defer db.Close() + + err = db.Update(func(tx *bolt.Tx) error { + return removeContainer(ctr, pod, tx) + }) + return err } // AllPods returns all pods present in the state func (s *BoltState) AllPods() ([]*Pod, error) { - return nil, ErrNotImplemented + if !s.valid { + return nil, ErrDBClosed + } + + pods := []*Pod{} + + db, err := s.getDBCon() + if err != nil { + return nil, err + } + defer db.Close() + + err = db.View(func(tx *bolt.Tx) error { + idBucket, err := getIDBucket(tx) + if err != nil { + return err + } + + podBucket, err := getPodBucket(tx) + if err != nil { + return err + } + + // Iterate through all IDs + // If they're pod, make a container from them and append it + err = idBucket.ForEach(func(id, name []byte) error { + podExists := podBucket.Bucket(id) + if podExists == nil { + // Container not pod + return nil + } + + pod := new(Pod) + + pods = append(pods, pod) + + return s.getPodFromDB(id, pod, podBucket) + }) + return err + }) + if err != nil { + return nil, err + } + + return pods, nil } diff --git a/libpod/boltdb_state_internal.go b/libpod/boltdb_state_internal.go index c8aa4adbf..89adac79d 100644 --- a/libpod/boltdb_state_internal.go +++ b/libpod/boltdb_state_internal.go @@ -3,34 +3,42 @@ package libpod import ( "encoding/json" "path/filepath" + "strings" "github.com/boltdb/bolt" "github.com/containers/storage" "github.com/pkg/errors" + "github.com/sirupsen/logrus" ) const ( idRegistryName = "id-registry" nameRegistryName = "name-registry" - ctrConfigName = "container-config" - ctrStateName = "container-state" - netNSName = "net-ns" - runtimeConfigName = "runtime-config" - ctrDependsName = "container-depends" + ctrName = "ctr" podName = "pod" - podContainersName = "pod-containers" + runtimeConfigName = "runtime-config" + + configName = "config" + stateName = "state" + dependenciesName = "dependencies" + netNSName = "netns" + containersName = "containers" + + dbExistName = "ok" ) var ( idRegistryBkt = []byte(idRegistryName) nameRegistryBkt = []byte(nameRegistryName) - ctrConfigBkt = []byte(ctrConfigName) - ctrStateBkt = []byte(ctrStateName) - netNSBkt = []byte(netNSName) - runtimeConfigBkt = []byte(runtimeConfigName) - ctrDependsBkt = []byte(ctrDependsName) + ctrBkt = []byte(ctrName) podBkt = []byte(podName) - podContainersBkt = []byte(podContainersName) + runtimeConfigBkt = []byte(runtimeConfigName) + + configKey = []byte(configName) + stateKey = []byte(stateName) + dependenciesBkt = []byte(dependenciesName) + netNSKey = []byte(netNSName) + containersBkt = []byte(containersName) ) // Check if the configuration of the database is compatible with the @@ -122,26 +130,18 @@ func getNamesBucket(tx *bolt.Tx) (*bolt.Bucket, error) { return bkt, nil } -func getCtrConfigBucket(tx *bolt.Tx) (*bolt.Bucket, error) { - bkt := tx.Bucket(ctrConfigBkt) +func getCtrBucket(tx *bolt.Tx) (*bolt.Bucket, error) { + bkt := tx.Bucket(ctrBkt) if bkt == nil { - return nil, errors.Wrapf(ErrDBBadConfig, "container config bucket not found in DB") + return nil, errors.Wrapf(ErrDBBadConfig, "containers bucket not found in DB") } return bkt, nil } -func getCtrStateBucket(tx *bolt.Tx) (*bolt.Bucket, error) { - bkt := tx.Bucket(ctrStateBkt) - if bkt == nil { - return nil, errors.Wrapf(ErrDBBadConfig, "container state bucket not found in DB") - } - return bkt, nil -} - -func getNetNSBucket(tx *bolt.Tx) (*bolt.Bucket, error) { - bkt := tx.Bucket(netNSBkt) +func getPodBucket(tx *bolt.Tx) (*bolt.Bucket, error) { + bkt := tx.Bucket(podBkt) if bkt == nil { - return nil, errors.Wrapf(ErrDBBadConfig, "network namespace bucket not found in DB") + return nil, errors.Wrapf(ErrDBBadConfig, "pods bucket not found in DB") } return bkt, nil } @@ -154,52 +154,34 @@ func getRuntimeConfigBucket(tx *bolt.Tx) (*bolt.Bucket, error) { return bkt, nil } -func getCtrDependsBucket(tx *bolt.Tx) (*bolt.Bucket, error) { - bkt := tx.Bucket(ctrDependsBkt) - if bkt == nil { - return nil, errors.Wrapf(ErrDBBadConfig, "container dependencies bucket not found in DB") +func (s *BoltState) getContainerFromDB(id []byte, ctr *Container, ctrsBkt *bolt.Bucket) error { + ctrBkt := ctrsBkt.Bucket(id) + if ctrBkt == nil { + return errors.Wrapf(ErrNoSuchCtr, "container %s not found in DB", string(id)) } - return bkt, nil -} -func getPodBucket(tx *bolt.Tx) (*bolt.Bucket, error) { - bkt := tx.Bucket(podBkt) - if bkt == nil { - return nil, errors.Wrapf(ErrDBBadConfig, "pods bucket not found in DB") + configBytes := ctrBkt.Get(configKey) + if configBytes == nil { + return errors.Wrapf(ErrInternal, "container %s missing config key in DB", string(id)) } - return bkt, nil -} -func getPodContainersBucket(tx *bolt.Tx) (*bolt.Bucket, error) { - bkt := tx.Bucket(podContainersBkt) - if bkt == nil { - return nil, errors.Wrapf(ErrDBBadConfig, "pod containers bucket not found in DB") + stateBytes := ctrBkt.Get(stateKey) + if stateBytes == nil { + return errors.Wrapf(ErrInternal, "container %s missing state key in DB", string(id)) } - return bkt, nil -} -func (s *BoltState) getContainerFromDB(id []byte, ctr *Container, config, state, netNS *bolt.Bucket) error { - configBytes := config.Get(id) - if configBytes == nil { - return errors.Wrapf(ErrNoSuchCtr, "error unmarshalling container %s config", string(id)) - } + netNSBytes := ctrBkt.Get(netNSKey) if err := json.Unmarshal(configBytes, ctr.config); err != nil { return errors.Wrapf(err, "error unmarshalling container %s config", string(id)) } - stateBytes := state.Get(id) - if stateBytes == nil { - return errors.Wrapf(ErrInternal, "container %s has config but no state", string(id)) - } - if err := json.Unmarshal(stateBytes, ctr.state); err != nil { return errors.Wrapf(err, "error unmarshalling container %s state", string(id)) } // The container may not have a network namespace, so it's OK if this is // nil - netNSBytes := netNS.Get(id) if netNSBytes != nil { nsPath := string(netNSBytes) netNS, err := joinNetNS(nsPath) @@ -222,3 +204,293 @@ func (s *BoltState) getContainerFromDB(id []byte, ctr *Container, config, state, return nil } + +func (s *BoltState) getPodFromDB(id []byte, pod *Pod, podBkt *bolt.Bucket) error { + podDB := podBkt.Bucket(id) + if podDB == nil { + return errors.Wrapf(ErrNoSuchPod, "pod with ID %s not found", string(id)) + } + + podBytes := podDB.Get(configKey) + if podBytes == nil { + return errors.Wrapf(ErrInternal, "pod %s is missing configuration key in DB", string(id)) + } + + if err := json.Unmarshal(podBytes, pod); err != nil { + return errors.Wrapf(err, "error unmarshalling pod %s from DB", string(id)) + } + + // Get the lock + lockPath := filepath.Join(s.lockDir, string(id)) + lock, err := storage.GetLockfile(lockPath) + if err != nil { + return errors.Wrapf(err, "error retrieving lockfile for pod %s", string(id)) + } + pod.lock = lock + + pod.runtime = s.runtime + pod.valid = true + + return nil +} + +// Add a container to the DB +// If pod is not nil, the container is added to the pod as well +func (s *BoltState) addContainer(ctr *Container, pod *Pod) error { + // JSON container structs to insert into DB + // TODO use a higher-performance struct encoding than JSON + configJSON, err := json.Marshal(ctr.config) + if err != nil { + return errors.Wrapf(err, "error marshalling container %s config to JSON", ctr.ID()) + } + stateJSON, err := json.Marshal(ctr.state) + if err != nil { + return errors.Wrapf(err, "error marshalling container %s state to JSON", ctr.ID()) + } + netNSPath := "" + if ctr.state.NetNS != nil { + netNSPath = ctr.state.NetNS.Path() + } + + dependsCtrs := ctr.Dependencies() + + ctrID := []byte(ctr.ID()) + ctrName := []byte(ctr.Name()) + + db, err := s.getDBCon() + if err != nil { + return err + } + defer db.Close() + + err = db.Update(func(tx *bolt.Tx) error { + idsBucket, err := getIDBucket(tx) + if err != nil { + return err + } + + namesBucket, err := getNamesBucket(tx) + if err != nil { + return err + } + + ctrBucket, err := getCtrBucket(tx) + if err != nil { + return err + } + + // If a pod was given, check if it exists + var podDB *bolt.Bucket + var podCtrs *bolt.Bucket + if pod != nil { + podBucket, err := getPodBucket(tx) + if err != nil { + return err + } + + podID := []byte(pod.ID()) + + podDB = podBucket.Bucket(podID) + if podDB == nil { + pod.valid = false + return errors.Wrapf(ErrNoSuchPod, "pod %s does not exist in database", pod.ID()) + } + podCtrs = podDB.Bucket(containersBkt) + if podCtrs == nil { + return errors.Wrapf(ErrInternal, "pod %s does not have a containers bucket", pod.ID()) + } + } + + // Check if we already have a container with the given ID and name + idExist := idsBucket.Get(ctrID) + if idExist != nil { + return errors.Wrapf(ErrCtrExists, "ID %s is in use", ctr.ID()) + } + nameExist := namesBucket.Get(ctrName) + if nameExist != nil { + return errors.Wrapf(ErrCtrExists, "name %s is in use", ctr.Name()) + } + + // No overlapping containers + // Add the new container to the DB + if err := idsBucket.Put(ctrID, ctrName); err != nil { + return errors.Wrapf(err, "error adding container %s ID to DB", ctr.ID()) + } + if err := namesBucket.Put(ctrName, ctrID); err != nil { + return errors.Wrapf(err, "error adding container %s name (%s) to DB", ctr.ID(), ctr.Name()) + } + + newCtrBkt, err := ctrBucket.CreateBucket(ctrID) + if err != nil { + return errors.Wrapf(err, "error adding container %s bucket to DB", ctr.ID()) + } + + if err := newCtrBkt.Put(configKey, configJSON); err != nil { + return errors.Wrapf(err, "error adding container %s config to DB", ctr.ID()) + } + if err := newCtrBkt.Put(stateKey, stateJSON); err != nil { + return errors.Wrapf(err, "error adding container %s state to DB", ctr.ID()) + } + if netNSPath != "" { + if err := newCtrBkt.Put(netNSKey, []byte(netNSPath)); err != nil { + return errors.Wrapf(err, "error adding container %s netns path to DB", ctr.ID()) + } + } + if _, err := newCtrBkt.CreateBucket(dependenciesBkt); err != nil { + return errors.Wrapf(err, "error creating dependencies bucket for container %s", ctr.ID()) + } + + // Add dependencies for the container + for _, dependsCtr := range dependsCtrs { + depCtrID := []byte(dependsCtr) + + depCtrBkt := ctrBucket.Bucket(depCtrID) + if depCtrBkt == nil { + return errors.Wrapf(ErrNoSuchCtr, "container %s depends on container %s, but it does not exist in the DB", ctr.ID(), dependsCtr) + } + depCtrDependsBkt := depCtrBkt.Bucket(dependenciesBkt) + if depCtrDependsBkt == nil { + return errors.Wrapf(ErrInternal, "container %s does not have a dependencies bucket", dependsCtr) + } + if err := depCtrDependsBkt.Put(ctrID, ctrName); err != nil { + return errors.Wrapf(err, "error adding ctr %s as dependency of container %s", ctr.ID(), dependsCtr) + } + } + + // Add ctr to pod + if pod != nil { + if err := podCtrs.Put(ctrID, ctrName); err != nil { + return errors.Wrapf(err, "error adding container %s to pod %s", ctr.ID(), pod.ID()) + } + } + + return nil + }) + return err +} + +// Remove a container from the DB +// If pod is not nil, the container is treated as belonging to a pod, and +// will be removed from the pod as well +func removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error { + ctrID := []byte(ctr.ID()) + ctrName := []byte(ctr.Name()) + + idsBucket, err := getIDBucket(tx) + if err != nil { + return err + } + + namesBucket, err := getNamesBucket(tx) + if err != nil { + return err + } + + ctrBucket, err := getCtrBucket(tx) + if err != nil { + return err + } + + // Does the pod exist? + var podDB *bolt.Bucket + if pod != nil { + podBucket, err := getPodBucket(tx) + if err != nil { + return err + } + + podID := []byte(pod.ID()) + + podDB = podBucket.Bucket(podID) + if podDB == nil { + pod.valid = false + return errors.Wrapf(ErrNoSuchPod, "no pod with ID %s found in DB", pod.ID()) + } + } + + // Does the container exist? + ctrExists := ctrBucket.Bucket(ctrID) + if ctrExists == nil { + ctr.valid = false + return errors.Wrapf(ErrNoSuchCtr, "no container with ID %s found in DB", ctr.ID()) + } + + if podDB != nil { + // Check if the container is in the pod, remove it if it is + podCtrs := podDB.Bucket(containersBkt) + if podCtrs == nil { + // Malformed pod + logrus.Errorf("pod %s malformed in database, missing containers bucket!", pod.ID()) + } else { + ctrInPod := podCtrs.Get(ctrID) + if ctrInPod == nil { + return errors.Wrapf(ErrNoSuchCtr, "container %s is not in pod %s", ctr.ID(), pod.ID()) + } + if err := podCtrs.Delete(ctrID); err != nil { + return errors.Wrapf(err, "error removing container %s from pod %s", ctr.ID(), pod.ID()) + } + } + } + + // Does the container have dependencies? + ctrDepsBkt := ctrExists.Bucket(dependenciesBkt) + if ctrDepsBkt == nil { + return errors.Wrapf(ErrInternal, "container %s does not have a dependencies bucket", ctr.ID()) + } + deps := []string{} + err = ctrDepsBkt.ForEach(func(id, value []byte) error { + deps = append(deps, string(id)) + + return nil + }) + if err != nil { + return err + } + if len(deps) != 0 { + return errors.Wrapf(ErrCtrExists, "container %s is a dependency of the following containers: %s", ctr.ID(), strings.Join(deps, ", ")) + } + + if err := ctrBucket.DeleteBucket(ctrID); err != nil { + return errors.Wrapf(ErrInternal, "error deleting container %s from DB", ctr.ID()) + } + + if err := idsBucket.Delete(ctrID); err != nil { + return errors.Wrapf(err, "error deleting container %s ID in DB", ctr.ID()) + } + + if err := namesBucket.Delete(ctrName); err != nil { + return errors.Wrapf(err, "error deleting container %s name in DB", ctr.ID()) + } + + depCtrs := ctr.Dependencies() + + // Remove us from other container's dependencies + for _, depCtr := range depCtrs { + depCtrID := []byte(depCtr) + + depCtrBkt := ctrBucket.Bucket(depCtrID) + if depCtrBkt == nil { + // The dependent container has been removed + // This should not be possible, and means the + // state is inconsistent, but don't error + // The container with inconsistent state is the + // one being removed + continue + } + + depCtrDependsBkt := depCtrBkt.Bucket(dependenciesBkt) + if depCtrDependsBkt == nil { + // This is more serious - another container in + // the state is inconsistent + // Log it, continue removing + logrus.Errorf("Container %s is missing dependencies bucket in DB", ctr.ID()) + continue + } + + if err := depCtrDependsBkt.Delete(ctrID); err != nil { + return errors.Wrapf(err, "error removing container %s as a dependency of container %s", ctr.ID(), depCtr) + } + } + + return nil +} diff --git a/libpod/pod.go b/libpod/pod.go index ecef8554e..09e003608 100644 --- a/libpod/pod.go +++ b/libpod/pod.go @@ -11,13 +11,13 @@ import ( // Pod represents a group of containers that may share namespaces type Pod struct { - id string - name string - labels map[string]string + id string `json:"id"` + name string `json:"name"` + labels map[string]string `json:"labels"` - valid bool - runtime *Runtime - lock storage.Locker + valid bool `json:"-"` + runtime *Runtime `json:"-"` + lock storage.Locker `json:"-"` } // ID retrieves the pod's ID |