// getAppName returns the app name to enter
// If one was supplied in the flags then it's simply returned
// If the PM contains a single app, that app's name is returned
// If the PM has multiple apps, the names are printed and an error is returned
func getAppName(p *pod) (*types.ACName, error) {
if flagAppName != "" {
return types.NewACName(flagAppName)
}
// figure out the app name, or show a list if multiple are present
b, err := ioutil.ReadFile(common.PodManifestPath(p.path()))
if err != nil {
return nil, errwrap.Wrap(errors.New("error reading pod manifest"), err)
}
m := schema.PodManifest{}
if err = m.UnmarshalJSON(b); err != nil {
return nil, errwrap.Wrap(errors.New("invalid pod manifest"), err)
}
switch len(m.Apps) {
case 0:
return nil, fmt.Errorf("pod contains zero apps")
case 1:
return &m.Apps[0].Name, nil
default:
}
stderr.Print("pod contains multiple apps:")
for _, ra := range m.Apps {
stderr.Printf("\t%v", ra.Name)
}
return nil, fmt.Errorf("specify app using \"rkt enter --app= ...\"")
}
func runList(cmd *cobra.Command, args []string) int {
var errors []error
tabBuffer := new(bytes.Buffer)
tabOut := getTabOutWithWriter(tabBuffer)
if !flagNoLegend {
if flagFullOutput {
fmt.Fprintf(tabOut, "UUID\tAPP\tIMAGE NAME\tIMAGE ID\tSTATE\tCREATED\tSTARTED\tNETWORKS\n")
} else {
fmt.Fprintf(tabOut, "UUID\tAPP\tIMAGE NAME\tSTATE\tCREATED\tSTARTED\tNETWORKS\n")
}
}
if err := walkPods(includeMostDirs, func(p *pod) {
pm := schema.PodManifest{}
if !p.isPreparing && !p.isAbortedPrepare && !p.isExitedDeleting {
// TODO(vc): we should really hold a shared lock here to prevent gc of the pod
pmf, err := p.readFile(common.PodManifestPath(""))
if err != nil {
errors = append(errors, newPodListReadError(p, err))
return
}
if err := pm.UnmarshalJSON(pmf); err != nil {
errors = append(errors, newPodListLoadError(p, err, pmf))
return
}
if len(pm.Apps) == 0 {
errors = append(errors, newPodListZeroAppsError(p))
return
}
}
type printedApp struct {
uuid string
appName string
imgName string
imgID string
state string
nets string
created string
started string
}
var appsToPrint []printedApp
uuid := p.uuid.String()
state := p.getState()
nets := fmtNets(p.nets)
created, err := p.getCreationTime()
if err != nil {
errors = append(errors, errwrap.Wrap(fmt.Errorf("unable to get creation time for pod %q", uuid), err))
}
var createdStr string
if flagFullOutput {
createdStr = created.Format(defaultTimeLayout)
} else {
createdStr = humanize.Time(created)
}
started, err := p.getStartTime()
if err != nil {
errors = append(errors, errwrap.Wrap(fmt.Errorf("unable to get start time for pod %q", uuid), err))
}
var startedStr string
if !started.IsZero() {
if flagFullOutput {
startedStr = started.Format(defaultTimeLayout)
} else {
startedStr = humanize.Time(started)
}
}
if !flagFullOutput {
uuid = uuid[:8]
}
for _, app := range pm.Apps {
imageName, err := getImageName(p, app.Name)
if err != nil {
errors = append(errors, newPodListLoadImageManifestError(p, err))
imageName = "--"
}
var imageID string
if flagFullOutput {
imageID = app.Image.ID.String()[:19]
}
appsToPrint = append(appsToPrint, printedApp{
uuid: uuid,
appName: app.Name.String(),
imgName: imageName,
imgID: imageID,
state: state,
nets: nets,
created: createdStr,
started: startedStr,
})
// clear those variables so they won't be
// printed for another apps in the pod as they
// are actually describing a pod, not an app
uuid = ""
state = ""
nets = ""
createdStr = ""
startedStr = ""
}
// if we reached that point, then it means that the
// pod and all its apps are valid, so they can be
// printed
for _, app := range appsToPrint {
if flagFullOutput {
fmt.Fprintf(tabOut, "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", app.uuid, app.appName, app.imgName, app.imgID, app.state, app.created, app.started, app.nets)
} else {
fmt.Fprintf(tabOut, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n", app.uuid, app.appName, app.imgName, app.state, app.created, app.started, app.nets)
}
}
}); err != nil {
stderr.PrintE("failed to get pod handles", err)
return 1
}
if len(errors) > 0 {
sep := "----------------------------------------"
stderr.Printf("%d error(s) encountered when listing pods:", len(errors))
stderr.Print(sep)
for _, err := range errors {
stderr.Error(err)
stderr.Print(sep)
}
stderr.Print("misc:")
stderr.Printf(" rkt's appc version: %s", schema.AppContainerVersion)
stderr.Print(sep)
// make a visible break between errors and the listing
stderr.Print("")
}
tabOut.Flush()
stdout.Print(tabBuffer)
return 0
}
func BasicPodManifest() *schema.PodManifest {
im := new(schema.PodManifest)
im.UnmarshalJSON([]byte(POD_MANIFEST))
return im
}
