예제 #1
0
파일: nuke.go 프로젝트: vektra/container
func (no *nukeOptions) Execute(args []string) error {
	if err := app.CheckArity(1, 1, args); err != nil {
		return err
	}

	id := utils.ExpandID(env.DIR, args[0])

	root := path.Join(env.DIR, "containers", id)

	_, err := os.Stat(root)

	if err != nil {
		// Look for an image instead
		return nukeImage(no, id)
	}

	_, err = ioutil.ReadFile(path.Join(root, "running"))

	if err == nil {
		fmt.Printf("Cowardly refusing to nuke running container\n")
		os.Exit(1)
	}

	err = os.RemoveAll(root)

	if err != nil {
		return err
	}

	fmt.Printf("Removed %s\n", id)

	return nil
}
예제 #2
0
파일: commit.go 프로젝트: vektra/container
func (co *commitOptions) Execute(args []string) error {
	if err := app.CheckArity(1, 1, args); err != nil {
		return err
	}

	id := utils.ExpandID(env.DIR, args[0])

	cont, err := env.LoadContainer(env.DIR, id)

	if err != nil {
		return fmt.Errorf("Unable to load %s: %s\n", id, err)
	}

	ts, err := env.DefaultTagStore()

	if err != nil {
		return err
	}

	img, err := cont.Commit(co.Comment, co.Author, nil, co.Squash, false)

	if err != nil {
		return fmt.Errorf("Unable to create image: %s\n", err)
	}

	repo, tag := env.ParseRepositoryTag(args[1])

	ts.Add(repo, tag, img.ID)
	ts.Flush()

	return nil
}
예제 #3
0
파일: ls.go 프로젝트: vektra/container
func (lo *lsOptions) Execute(args []string) error {
	if err := app.CheckArity(1, 2, args); err != nil {
		return err
	}

	repo := args[0]

	dir := "."

	if len(args) > 1 {
		dir = args[1]
	}

	tags, err := env.DefaultTagStore()

	if err != nil {
		return err
	}

	img, err := tags.LookupImage(repo)

	if err != nil {
		return err
	}

	e := exec.Command("ls", path.Join(env.DIR, "graph", img.ID, "layer", dir))
	e.Stdout = os.Stdout

	return e.Run()
}
예제 #4
0
파일: ps.go 프로젝트: vektra/container
func (po *psOptions) Execute(args []string) error {
	if err := app.CheckArity(0, 0, args); err != nil {
		return err
	}

	dir, err := ioutil.ReadDir(path.Join(env.DIR, "containers"))

	if err != nil {
		return err
	}

	ts, err := env.DefaultTagStore()

	w := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
	fmt.Fprintf(w, "  ID\tREPO\tCREATED\n")

	var cs Containers

	for _, f := range dir {
		id := f.Name()

		cont, err := env.LoadContainer(env.DIR, id)
		if err != nil {
			continue
		}

		cs = append(cs, cont)
	}

	sort.Sort(cs)

	for _, cont := range cs {
		repo, tag := ts.Find(cont.Image)

		state := "  "

		_, err := os.Stat(cont.PathTo("running"))

		if err == nil {
			state = "* "
		}

		if repo == "" {
			fmt.Fprintf(w, "%s%s\t \t%s\n", state, cont.ID[0:12], cont.Created.String())
		} else {
			fmt.Fprintf(w, "%s%s\t%s:%s\t%s\n", state, cont.ID[0:12], repo, tag, cont.Created.String())
		}

	}

	w.Flush()

	return nil
}
예제 #5
0
파일: s3.go 프로젝트: vektra/container
func (so *s3Options) Execute(args []string) error {
	if err := app.CheckArity(1, 1, args); err != nil {
		return err
	}

	repo := args[0]

	s3 := s3.New(awsAuth, awsRegion)
	buk := s3.Bucket(defBucket)

	data, err := buk.Get("/binary/repos/repositories")

	if err != nil {
		return err
	}

	ts := &env.TagStore{}

	err = json.Unmarshal(data, &ts)

	id, err := ts.Lookup(repo)

	if err != nil {
		return err
	}

	dts, err := env.DefaultTagStore()

	if err != nil {
		return err
	}

	i := &Importer{tags: ts, sysTags: dts}

	if !so.Force {
		if i.alreadyExists(id) {
			return fmt.Errorf("Already have %s, skipping download\n", utils.TruncateID(id))
		}
	}

	fmt.Printf("Downloading %s (%s)\n", repo, utils.TruncateID(id))

	err = i.download(buk, id)

	dts.Flush()

	return err
}
예제 #6
0
파일: rmi.go 프로젝트: vektra/container
func (ro *rmiOptions) Execute(args []string) error {
	if err := app.CheckArity(1, 1, args); err != nil {
		return err
	}

	ts, err := env.DefaultTagStore()
	if err != nil {
		return err
	}

	if !ts.RemoveByPrefix(args[0]) {
		fmt.Println("Unable to remove image.")
	}

	return ts.Flush()
}
예제 #7
0
파일: port.go 프로젝트: vektra/container
func (po *portOptions) Execute(args []string) error {
	if err := app.CheckArity(1, 1, args); err != nil {
		return err
	}

	id := utils.ExpandID(env.DIR, args[0])

	cont, err := env.LoadContainer(env.DIR, id)

	if err != nil {
		return fmt.Errorf("Error loading conatiner %s: %s\n", id, err)
	}

	if po.TCP != "" {
		h, ok := cont.NetworkSettings.PortMapping["Tcp"][po.TCP]

		if ok {
			fmt.Printf("%s\n", h)
		} else {
			return fmt.Errorf("Unknown tcp port %s\n", po.TCP)
		}

		return nil
	}

	if po.UDP != "" {
		h, ok := cont.NetworkSettings.PortMapping["Udp"][po.UDP]

		if ok {
			fmt.Printf("%s\n", h)
		} else {
			return fmt.Errorf("Unknown udp port %s\n", po.UDP)
		}

		return nil
	}

	for c, h := range cont.NetworkSettings.PortMapping["Tcp"] {
		fmt.Printf("tcp %s -> tcp %s\n", c, h)
	}

	for c, h := range cont.NetworkSettings.PortMapping["Udp"] {
		fmt.Printf("udp %s -> udp %s\n", c, h)
	}

	return nil
}
예제 #8
0
파일: volumes.go 프로젝트: vektra/container
func (vo *volumeOptions) Execute(args []string) error {
	if err := app.CheckArity(0, 0, args); err != nil {
		return err
	}

	if vo.Remove != "" {
		pth := path.Join(env.DIR, "volumes", vo.Remove)

		_, err := os.Stat(pth)

		if err != nil {
			return fmt.Errorf("No volume to remove: %s\n", vo.Remove)
		}

		os.RemoveAll(pth)
		return nil
	}

	if vo.Dir != "" {
		pth := path.Join(env.DIR, "volumes", vo.Dir)

		_, err := os.Stat(pth)

		if err != nil {
			return fmt.Errorf("No volume: %s\n", vo.Dir)
		}

		fmt.Printf("%s\n", pth)
		return nil
	}

	dirs, err := ioutil.ReadDir(path.Join(env.DIR, "volumes"))

	if err != nil {
		return fmt.Errorf("Error reading volumes: %s\n", err)
	}

	for _, d := range dirs {
		fmt.Printf("%s\n", d.Name())
	}

	return nil
}
예제 #9
0
파일: build.go 프로젝트: vektra/container
func (bo *buildOptions) Execute(args []string) error {
	ts, err := env.DefaultTagStore()

	if err != nil {
		return err
	}

	if err := app.CheckArity(1, 1, args); err != nil {
		return err
	}

	abort := make(chan os.Signal, 1)

	signal.Notify(abort, syscall.SIGINT)

	b := &buildFile{
		tags:       ts,
		config:     &env.Config{},
		out:        os.Stdout,
		verbose:    true,
		outImage:   bo.Image,
		abort:      abort,
		squash:     bo.Squash,
		experiment: bo.Experiment,
	}

	if bo.Tar {
		err = b.BuildTar(args[0])
	} else {
		err = b.Build(args[0])
	}

	if err != nil && err != ErrAbort {
		return err
	}

	return nil
}
예제 #10
0
파일: inspect.go 프로젝트: vektra/container
func (io *inspectOptions) Execute(args []string) error {
	if err := app.CheckArity(1, 1, args); err != nil {
		return err
	}

	id := utils.ExpandID(env.DIR, args[0])

	cont, err := env.LoadContainer(env.DIR, id)

	if err != nil {
		return err
	}

	data, err := json.Marshal(cont)

	var out bytes.Buffer

	json.Indent(&out, data, "", "  ")

	out.WriteTo(os.Stdout)
	os.Stdout.Write([]byte("\n"))

	return nil
}
예제 #11
0
파일: import.go 프로젝트: vektra/container
func (io *importOptions) Execute(args []string) error {
	if err := app.CheckArity(2, 2, args); err != nil {
		return err
	}

	dir := args[0]

	i := &Importer{dir, nil, nil}

	name, tag := env.ParseRepositoryTag(args[1])

	fmt.Printf("Importing %s:%s...\n", name, tag)

	repoPath := path.Join(i.dir, "repositories")

	data, err := ioutil.ReadFile(repoPath)

	if err != nil {
		return err
	}

	i.tags = &env.TagStore{}

	err = json.Unmarshal(data, &i.tags)

	if err != nil {
		return err
	}

	sub := i.tags.Repositories[name]

	if sub == nil {
		return fmt.Errorf("No repo named %s found\n", name)
	}

	hash, ok := sub[tag]

	if !ok {
		return fmt.Errorf("No tag named %s found\n", tag)
	}

	i.sysTags = &env.TagStore{}
	sysPath := path.Join(env.DIR, "repositories")

	sysData, err := ioutil.ReadFile(sysPath)

	if err != nil {
		i.sysTags.Repositories = make(map[string]env.Repository)
	} else {
		err = json.Unmarshal(sysData, &i.sysTags)

		if err != nil {
			return err
		}
	}

	i.importLayer(hash)

	sysData, err = json.Marshal(i.sysTags)

	if err != nil {
		return err
	}

	ioutil.WriteFile(sysPath, sysData, 0644)

	return nil
}
예제 #12
0
파일: images.go 프로젝트: vektra/container
func (io *imagesOptions) Execute(args []string) error {
	if err := app.CheckArity(0, 1, args); err != nil {
		return err
	}

	var repoDir string
	if len(args) > 0 {
		repoDir = args[0]
		fmt.Printf("Loading tag store from: %s\n", repoDir)
	} else {
		repoDir = env.DIR
	}

	// TODO(kev): Don't hardcode file name
	ts, err := env.LoadTagStore(repoDir)

	if err != nil {
		return fmt.Errorf("No images: %s\n", err)
	}

	w := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
	if io.Verbose {
		fmt.Fprintf(w, "REPO\tTAG\tID\tPARENT\tCREATED\n")
	} else {
		fmt.Fprintf(w, "REPO\tTAG\tID\n")
	}

	var repos []string

	for repo, _ := range ts.Repositories {
		repos = append(repos, repo)
	}

	sort.Strings(repos)

	for _, repo := range repos {
		tags := ts.Repositories[repo]

		var stags []string

		for tag, _ := range tags {
			stags = append(stags, tag)
		}

		sort.Strings(stags)

		for _, tag := range stags {
			id := tags[tag]

			if io.Verbose {
				img := ts.Entries[id]
				if img == nil {
					fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n", repo, tag, utils.TruncateID(id), "?", "?")
				} else {
					fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n", repo, tag, utils.TruncateID(id),
						utils.TruncateID(img.Parent), img.Created)
				}
			} else {
				fmt.Fprintf(w, "%s\t%s\t%s\n", repo, tag, utils.TruncateID(id))
			}
		}
	}

	w.Flush()

	return nil
}