// 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 *pkgPod.Pod) (*types.ACName, error) {
if flagAppName != "" {
return types.NewACName(flagAppName)
}
// figure out the app name, or show a list if multiple are present
_, m, err := p.PodManifest()
if err != nil {
return nil, errwrap.Wrap(errors.New("error reading 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 (s *v1AlphaAPIServer) getBasicPodFromDisk(p *pkgPod.Pod) (*v1alpha.Pod, error) {
pod := &v1alpha.Pod{Id: p.UUID.String()}
data, manifest, err := p.PodManifest()
if err != nil {
stderr.PrintE(fmt.Sprintf("failed to get the pod manifest for pod %q", p.UUID), err)
} else {
pod.Annotations = convertAnnotationsToKeyValue(manifest.Annotations)
pod.Apps = getApplist(manifest)
pod.Manifest = data
err = fillStaticAppInfo(s.store, p, pod)
}
return pod, err
}
// getExitStatuses returns a map of the statuses of the pod.
func getExitStatuses(p *pkgPod.Pod) (map[string]int, error) {
_, manifest, err := p.PodManifest()
if err != nil {
return nil, err
}
stats := make(map[string]int)
for _, app := range manifest.Apps {
exitCode, err := p.AppExitCode(app.Name.String())
if err != nil {
continue
}
stats[app.Name.String()] = exitCode
}
return stats, nil
}
// NewPodFromInternalPod converts *pkgPod.Pod to *Pod
func NewPodFromInternalPod(p *pkgPod.Pod) (*Pod, error) {
pod := &Pod{
UUID: p.UUID.String(),
State: p.State(),
Networks: p.Nets,
}
startTime, err := p.StartTime()
if err != nil {
return nil, err
}
if !startTime.IsZero() {
startedAt := startTime.Unix()
pod.StartedAt = &startedAt
}
if !p.PodManifestAvailable() {
return pod, nil
}
// TODO(vc): we should really hold a shared lock here to prevent gc of the pod
_, manifest, err := p.PodManifest()
if err != nil {
return nil, err
}
for _, app := range manifest.Apps {
pod.AppNames = append(pod.AppNames, app.Name.String())
}
if len(manifest.UserAnnotations) > 0 {
pod.UserAnnotations = make(map[string]string)
for name, value := range manifest.UserAnnotations {
pod.UserAnnotations[name] = value
}
}
if len(manifest.UserLabels) > 0 {
pod.UserLabels = make(map[string]string)
for name, value := range manifest.UserLabels {
pod.UserLabels[name] = value
}
}
return pod, nil
}
// getApp returns the app to export
// If one was supplied in the flags then it's returned if present
// If the PM contains a single app, that app is returned
// If the PM has multiple apps, the names are printed and an error is returned
func getApp(p *pkgPod.Pod) (*schema.RuntimeApp, error) {
_, manifest, err := p.PodManifest()
if err != nil {
return nil, errwrap.Wrap(errors.New("problem getting the pod's manifest"), err)
}
apps := manifest.Apps
if flagExportAppName != "" {
exportAppName, err := types.NewACName(flagExportAppName)
if err != nil {
return nil, err
}
for _, ra := range apps {
if *exportAppName == ra.Name {
return &ra, nil
}
}
return nil, fmt.Errorf("app %s is not present in pod", flagExportAppName)
}
switch len(apps) {
case 0:
return nil, fmt.Errorf("pod contains zero apps")
case 1:
return &apps[0], nil
default:
}
stderr.Print("pod contains multiple apps:")
for _, ra := range apps {
stderr.Printf("\t%v", ra.Name)
}
return nil, fmt.Errorf("specify app using \"rkt export --app= ...\"")
}