func getReferencedImgs(s *store.Store) (map[string]struct{}, error) {
imgs := map[string]struct{}{}
walkErrors := []error{}
// Consider pods in preparing, prepared, run, exitedgarbage state
if err := walkPods(includeMostDirs, func(p *pod) {
appImgs, err := p.getAppsHashes()
if err != nil {
// Ignore errors reading/parsing pod file
return
}
for _, appImg := range appImgs {
key, err := s.ResolveKey(appImg.String())
if err != nil && err != store.ErrKeyNotFound {
walkErrors = append(walkErrors, fmt.Errorf("bad imageID %q in pod definition: %v", appImg.String(), err))
return
}
imgs[key] = struct{}{}
}
}); err != nil {
return nil, fmt.Errorf("failed to get pod handles: %v", err)
}
if len(walkErrors) > 0 {
return nil, fmt.Errorf("errors occured walking pods. errors: %v", walkErrors)
}
return imgs, nil
}
func rmImages(s *store.Store, images []string) error {
done := 0
errors := 0
staleErrors := 0
for _, pkey := range images {
errors++
h, err := types.NewHash(pkey)
if err != nil {
stderr("rkt: wrong image ID %q: %v", pkey, err)
continue
}
key, err := s.ResolveKey(h.String())
if err != nil {
stderr("rkt: image ID %q not valid: %v", pkey, err)
continue
}
if key == "" {
stderr("rkt: image ID %q doesn't exist", pkey)
continue
}
if err = s.RemoveACI(key); err != nil {
if serr, ok := err.(*store.StoreRemovalError); ok {
staleErrors++
stderr("rkt: some files cannot be removed for image ID %q: %v", pkey, serr)
} else {
stderr("rkt: error removing aci for image ID %q: %v", pkey, err)
continue
}
}
stdout("rkt: successfully removed aci for image ID: %q", pkey)
errors--
done++
}
if done > 0 {
stderr("rkt: %d image(s) successfully removed", done)
}
// If anything didn't complete, return exit status of 1
if (errors + staleErrors) > 0 {
if staleErrors > 0 {
stderr("rkt: %d image(s) removed but left some stale files", staleErrors)
}
if errors > 0 {
stderr("rkt: %d image(s) cannot be removed", errors)
}
return fmt.Errorf("error(s) found while removing images")
}
return nil
}
func getStoreKeyFromAppOrHash(s *store.Store, input string) (string, error) {
var key string
if _, err := types.NewHash(input); err == nil {
key, err = s.ResolveKey(input)
if err != nil {
return "", fmt.Errorf("cannot resolve key: %v", err)
}
} else {
key, err = getStoreKeyFromApp(s, input)
if err != nil {
return "", fmt.Errorf("cannot find image: %v", err)
}
}
return key, nil
}
func getStoreKeyFromAppOrHash(s *store.Store, input string) (string, error) {
var key string
if _, err := types.NewHash(input); err == nil {
key, err = s.ResolveKey(input)
if err != nil {
return "", errwrap.Wrap(errors.New("cannot resolve image ID"), err)
}
} else {
key, err = getStoreKeyFromApp(s, input)
if err != nil {
return "", errwrap.Wrap(errors.New("cannot find image"), err)
}
}
return key, nil
}
func getKeyFromAppOrHash(s *store.Store, input string) (string, error) {
var key string
if _, err := types.NewHash(input); err == nil {
key, err = s.ResolveKey(input)
if err != nil {
return "", fmt.Errorf("cannot resolve key: %v", err)
}
} else {
app, err := discovery.NewAppFromString(input)
if err != nil {
return "", fmt.Errorf("cannot parse the image name: %v", err)
}
labels, err := types.LabelsFromMap(app.Labels)
if err != nil {
return "", fmt.Errorf("invalid labels in the name: %v", err)
}
key, err = s.GetACI(app.Name, labels)
if err != nil {
return "", fmt.Errorf("cannot find image: %v", err)
}
}
return key, nil
}
// getImageInfo for a given image ID, returns the *v1alpha.Image object.
func getImageInfo(store *store.Store, imageID string) (*v1alpha.Image, error) {
key, err := store.ResolveKey(imageID)
if err != nil {
stderr.PrintE(fmt.Sprintf("failed to resolve the image ID %q", imageID), err)
return nil, err
}
aciInfo, err := store.GetACIInfoWithBlobKey(key)
if err != nil {
stderr.PrintE(fmt.Sprintf("failed to get ACI info for image %q", key), err)
return nil, err
}
image, _, err := aciInfoToV1AlphaAPIImage(store, aciInfo)
if err != nil {
stderr.PrintE(fmt.Sprintf("failed to convert ACI to v1alphaAPIImage for image %q", key), err)
return nil, err
}
return image, nil
}
// fillAppInfo fills the apps' state and image info of the pod.
func fillAppInfo(store *store.Store, p *pod, v1pod *v1alpha.Pod) error {
statusDir, err := p.getStatusDir()
if err != nil {
stderr.PrintE("failed to get pod exit status directory", err)
return err
}
for _, app := range v1pod.Apps {
// Fill app's image info (id, name, version).
fullImageID, err := store.ResolveKey(app.Image.Id)
if err != nil {
stderr.PrintE(fmt.Sprintf("failed to resolve the image ID %q", app.Image.Id), err)
return err
}
im, err := p.getAppImageManifest(*types.MustACName(app.Name))
if err != nil {
stderr.PrintE(fmt.Sprintf("failed to get image manifests for app %q", app.Name), err)
return err
}
version, ok := im.Labels.Get("version")
if !ok {
version = "latest"
}
app.Image = &v1alpha.Image{
BaseFormat: &v1alpha.ImageFormat{
// Only support appc image now. If it's a docker image, then it
// will be transformed to appc before storing in the disk store.
Type: v1alpha.ImageType_IMAGE_TYPE_APPC,
Version: schema.AppContainerVersion.String(),
},
Id: fullImageID,
Name: im.Name.String(),
Version: version,
// Other information are not available because they require the image
// info from store.
}
// Fill app's state and exit code.
value, err := p.readIntFromFile(filepath.Join(statusDir, app.Name))
if err == nil {
app.State = v1alpha.AppState_APP_STATE_EXITED
app.ExitCode = int32(value)
continue
}
if !os.IsNotExist(err) {
stderr.PrintE(fmt.Sprintf("failed to read status for app %q", app.Name), err)
return err
}
// If status file does not exit, that means the
// app is either running or aborted.
//
// FIXME(yifan): This is not acttually true, the app can be aborted while
// the pod is still running if the spec changes.
switch p.getState() {
case Running:
app.State = v1alpha.AppState_APP_STATE_RUNNING
default:
app.State = v1alpha.AppState_APP_STATE_UNDEFINED
}
}
return nil
}
func rmImages(s *store.Store, images []string) error {
done := 0
errors := 0
staleErrors := 0
imageMap := make(map[string]string)
imageCounter := make(map[string]int)
for _, pkey := range images {
errors++
h, err := types.NewHash(pkey)
if err != nil {
var found bool
keys, found, err := s.ResolveName(pkey)
if len(keys) > 0 {
errors += len(keys) - 1
}
if err != nil {
stderr("rkt: %v", err)
continue
}
if !found {
stderr("rkt: image name %q not found", pkey)
continue
}
for _, key := range keys {
imageMap[key] = pkey
imageCounter[key]++
}
} else {
key, err := s.ResolveKey(h.String())
if err != nil {
stderr("rkt: image ID %q not valid: %v", pkey, err)
continue
}
if key == "" {
stderr("rkt: image ID %q doesn't exist", pkey)
continue
}
aciinfo, err := s.GetACIInfoWithBlobKey(key)
if err != nil {
stderr("rkt: error retrieving aci infos for image %q: %v", key, err)
continue
}
imageMap[key] = aciinfo.Name
imageCounter[key]++
}
}
// Adjust the error count by subtracting duplicate IDs from it,
// therefore allowing only one error per ID.
for _, c := range imageCounter {
if c > 1 {
errors -= c - 1
}
}
for key, name := range imageMap {
if err := s.RemoveACI(key); err != nil {
if serr, ok := err.(*store.StoreRemovalError); ok {
staleErrors++
stderr("rkt: some files cannot be removed for image %q (%q): %v", key, name, serr)
} else {
stderr("rkt: error removing aci for image %q (%q): %v", key, name, err)
continue
}
}
stdout("rkt: successfully removed aci for image: %q (%q)", key, name)
errors--
done++
}
if done > 0 {
stderr("rkt: %d image(s) successfully removed", done)
}
// If anything didn't complete, return exit status of 1
if (errors + staleErrors) > 0 {
if staleErrors > 0 {
stderr("rkt: %d image(s) removed but left some stale files", staleErrors)
}
if errors > 0 {
stderr("rkt: %d image(s) cannot be removed", errors)
}
return fmt.Errorf("error(s) found while removing images")
}
return nil
}
func rmImages(s *store.Store, images []string) error {
done := 0
errors := 0
staleErrors := 0
for _, pkey := range images {
var (
keys []string
name string
)
errors++
h, err := types.NewHash(pkey)
if err != nil {
var found bool
keys, found, err = s.ResolveName(pkey)
if len(keys) > 0 {
errors += len(keys) - 1
}
if err != nil {
stderr("rkt: %v", err)
continue
}
if !found {
stderr("rkt: image name %q not found", pkey)
continue
}
name = pkey
} else {
key, err := s.ResolveKey(h.String())
if err != nil {
stderr("rkt: image ID %q not valid: %v", pkey, err)
continue
}
if key == "" {
stderr("rkt: image ID %q doesn't exist", pkey)
continue
}
aciinfo, err := s.GetACIInfoWithBlobKey(key)
if err != nil {
stderr("rkt: error retrieving aci infos for image %q: %v", key, err)
continue
}
name = aciinfo.Name
keys = append(keys, key)
}
for _, key := range keys {
if err = s.RemoveACI(key); err != nil {
if serr, ok := err.(*store.StoreRemovalError); ok {
staleErrors++
stderr("rkt: some files cannot be removed for image %q (%q): %v", key, name, serr)
} else {
stderr("rkt: error removing aci for image %q (%q): %v", key, name, err)
continue
}
}
stdout("rkt: successfully removed aci for image: %q (%q)", key, name)
errors--
done++
}
}
if done > 0 {
stderr("rkt: %d image(s) successfully removed", done)
}
// If anything didn't complete, return exit status of 1
if (errors + staleErrors) > 0 {
if staleErrors > 0 {
stderr("rkt: %d image(s) removed but left some stale files", staleErrors)
}
if errors > 0 {
stderr("rkt: %d image(s) cannot be removed", errors)
}
return fmt.Errorf("error(s) found while removing images")
}
return nil
}