Пример #1
0
func fetch(cmd *cobra.Command, specs []string) {
	c := cli.NewClient(getServerURL())
	if len(specs) == 0 {
		specs = cli.Read(os.Stdin)
	}
	for _, spec := range specs {
		cli.AssertSpec(spec)
		image, _ := c.Post("image", "images", spec)
		cli.JMap(image).Print(jsonout)
	}
}
Пример #2
0
func job(cmd *cobra.Command, ids []string) {
	c := cli.NewClient(server)
	if len(ids) == 0 {
		ids = cli.Read(os.Stdin)
	}

	for _, id := range ids {
		cli.AssertID(id)
		job := getJob(c, id)
		job.Print(jsonout)
	}
}
Пример #3
0
func del(cmd *cobra.Command, ids []string) {
	c := cli.NewClient(server)
	if len(ids) == 0 {
		ids = cli.Read(os.Stdin)
	}

	for _, id := range ids {
		cli.AssertID(id)
		j := deleteGuest(c, id)
		j.Print(jsonout)
	}
}
Пример #4
0
func create(cmd *cobra.Command, specs []string) {
	c := cli.NewClient(server)
	if len(specs) == 0 {
		specs = cli.Read(os.Stdin)
	}

	for _, spec := range specs {
		cli.AssertSpec(spec)
		j := createGuest(c, spec)
		j.Print(jsonout)
	}
}
Пример #5
0
func del(cmd *cobra.Command, ids []string) {
	c := cli.NewClient(getServerURL())
	if len(ids) == 0 {
		ids = cli.Read(os.Stdin)
	}

	for _, id := range ids {
		cli.AssertID(id)
		image, _ := c.Delete("image", "images/"+id)
		cli.JMap(image).Print(jsonout)
	}
}
Пример #6
0
func generateActionHandler(action string) func(*cobra.Command, []string) {
	return func(cmd *cobra.Command, ids []string) {
		c := cli.NewClient(server)
		if len(ids) == 0 {
			ids = cli.Read(os.Stdin)
		}

		for _, id := range ids {
			cli.AssertID(id)
			j := guestAction(c, id, action)
			j.Print(jsonout)
		}
	}
}
Пример #7
0
func modify(cmd *cobra.Command, args []string) {
	c := cli.NewClient(server)
	if len(args) == 0 {
		args = cli.Read(os.Stdin)
	}
	if len(args)%2 != 0 {
		log.WithField("num", len(args)).Fatal("expected an even number of args")
	}

	for i := 0; i < len(args); i += 2 {
		id := args[i]
		cli.AssertID(id)
		spec := args[i+1]
		cli.AssertSpec(spec)

		guest := modifyGuest(c, id, spec)
		guest.Print(jsonout)
	}
}
Пример #8
0
func subnetsDel(cmd *cobra.Command, args []string) {
	c := cli.NewClient(server)
	if len(args) == 0 {
		args = cli.Read(os.Stdin)
	}
	if len(args)%2 != 0 {
		log.WithField("num", len(args)).Fatal("expected an even amount of args")
	}

	for i := 0; i < len(args); i += 2 {
		hv := args[i]
		cli.AssertID(hv)
		subnet := args[i+1]
		cli.AssertID(subnet)

		deleted := deleteSubnet(c, hv, subnet)
		deleted.Print(jsonout)
	}
}
Пример #9
0
func subnetsModify(cmd *cobra.Command, args []string) {
	c := cli.NewClient(server)
	if len(args) == 0 {
		args = cli.Read(os.Stdin)
	}
	if len(args)%2 != 0 {
		log.WithField("num", len(args)).Fatal("expected an even amount of args")
	}

	for i := 0; i < len(args); i += 2 {
		id := args[i]
		cli.AssertID(id)
		spec := args[i+1]
		cli.AssertSpec(spec)

		subnet := modifySubnets(c, id, spec)
		printTreeMap(id, "subnet", subnet)
	}
}
Пример #10
0
func list(cmd *cobra.Command, args []string) {
	c := cli.NewClient(server)
	guests := []cli.JMap{}
	if len(args) == 0 {
		if termutil.Isatty(os.Stdin.Fd()) {
			guests = getGuests(c)
			sort.Sort(cli.JMapSlice(guests))
		} else {
			args = cli.Read(os.Stdin)
		}
	}
	if len(guests) == 0 {
		for _, id := range args {
			cli.AssertID(id)
			guests = append(guests, getGuest(c, id))
		}
	}

	for _, guest := range guests {
		guest.Print(jsonout)
	}
}
Пример #11
0
func subnets(cmd *cobra.Command, ids []string) {
	c := cli.NewClient(server)
	if len(ids) == 0 {
		if termutil.Isatty(os.Stdin.Fd()) {
			for _, hv := range getHVs(c) {
				ids = append(ids, hv["id"].(string))
			}
		} else {
			ids = cli.Read(os.Stdin)
			sort.Strings(ids)
		}
	} else {
		for _, id := range ids {
			cli.AssertID(id)
		}
	}

	for _, id := range ids {
		subnet, _ := c.Get("subnet", "hypervisors/"+id+"/subnets")
		printTreeMap(id, "subnet", subnet)
	}
}
Пример #12
0
func guests(cmd *cobra.Command, ids []string) {
	c := cli.NewClient(server)
	if len(ids) == 0 {
		if termutil.Isatty(os.Stdin.Fd()) {
			for _, hv := range getHVs(c) {
				ids = append(ids, hv["id"].(string))
			}
		} else {
			ids = cli.Read(os.Stdin)
			sort.Strings(ids)
		}
	} else {
		for _, id := range ids {
			cli.AssertID(id)
		}
	}

	for _, id := range ids {
		guests := getGuests(c, id)
		printTreeSlice(id, "guests", guests)
	}
}
Пример #13
0
func list(cmd *cobra.Command, args []string) {
	c := cli.NewClient(server)
	hvs := []cli.JMap{}
	if len(args) == 0 {
		if termutil.Isatty(os.Stdin.Fd()) {
			hvs = getHVs(c)
			sort.Sort(cli.JMapSlice(hvs))
		} else {
			args = cli.Read(os.Stdin)
		}
	}
	if len(hvs) == 0 {
		for _, id := range args {
			cli.AssertID(id)
			hvs = append(hvs, getHV(c, id))
		}
	}

	for _, hv := range hvs {
		hv.Print(jsonout)
	}
}
Пример #14
0
func list(cmd *cobra.Command, args []string) {
	c := cli.NewClient(getServerURL())
	images := []cli.JMap{}
	if len(args) == 0 {
		if termutil.Isatty(os.Stdin.Fd()) {
			images = getImages(c)
			sort.Sort(cli.JMapSlice(images))
		} else {
			args = cli.Read(os.Stdin)
		}
	}
	if len(images) == 0 {
		for _, id := range args {
			cli.AssertID(id)
			image, _ := c.Get("image", "images/"+id)
			images = append(images, image)
		}
	}

	for _, image := range images {
		image.Print(jsonout)
	}
}
Пример #15
0
func upload(cmd *cobra.Command, specs []string) {
	if len(specs) == 0 {
		specs = cli.Read(os.Stdin)
	}

	uploadURL := getServerURL() + "/images"
	for _, spec := range specs {
		uploadImage := &metadata.Image{}
		if err := json.Unmarshal([]byte(spec), uploadImage); err != nil {
			log.WithFields(log.Fields{
				"error": err,
				"json":  spec,
				"func":  "json.Unmarshal",
			}).Fatal("invalid spec")
		}

		sourcePath, err := filepath.Abs(uploadImage.Source)
		if err != nil {
			log.WithFields(log.Fields{
				"error": err,
				"image": uploadImage,
				"func":  "filepath.Abs",
			}).Fatal("failed determine absolute source path")
		}
		file, err := os.Open(sourcePath)
		if err != nil {
			log.WithFields(log.Fields{
				"error": err,
				"path":  sourcePath,
				"func":  "os.Open",
			}).Fatal("failed to open file")
		}
		// File remains open until function exit
		defer logx.LogReturnedErr(file.Close, log.Fields{
			"filename": sourcePath,
		}, "failed to close image source file")

		info, err := file.Stat()
		if err != nil {
			log.WithFields(log.Fields{
				"error": err,
				"file":  file.Name(),
				"func":  "file.Stat",
			}).Fatal("failed to stat file")
		}

		req, err := http.NewRequest("PUT", uploadURL, file)
		if err != nil {
			log.WithFields(log.Fields{
				"error": err,
				"url":   uploadURL,
				"file":  file.Name(),
				"func":  "http.NewRequest",
			}).Fatal("failed to create request")
		}
		req.Header.Add("Content-Length", fmt.Sprintf("%d", info.Size()))
		req.Header.Add("X-Image-Type", uploadImage.Type)
		req.Header.Add("X-Image-Comment", uploadImage.Comment)
		req.Header.Add("Content-Type", "application/octet-stream")
		res, err := http.DefaultClient.Do(req)
		if err != nil {
			log.WithFields(log.Fields{
				"error": err,
				"url":   uploadURL,
				"file":  file.Name(),
				"func":  "http.DefaultClient.Do",
			}).Fatal("request error")
		}
		image := &cli.JMap{}
		cli.ProcessResponse(res, "image", "upload", []int{http.StatusOK}, image)
		image.Print(jsonout)
	}
}
Пример #16
0
func download(cmd *cobra.Command, ids []string) {
	if len(ids) == 0 {
		ids = cli.Read(os.Stdin)
	}

	for _, id := range ids {
		success := false
		tempDest, err := ioutil.TempFile(downloadDir, "incompleteImage-")
		if err != nil {
			log.WithFields(log.Fields{
				"error": err,
				"dir":   downloadDir,
				"func":  "ioutil.TempFile",
			}).Fatal("could not create temporary file")
		}
		defer func() {
			if !success {
				if err := os.Remove(tempDest.Name()); err != nil {
					log.WithFields(log.Fields{
						"error":    err,
						"tempfile": tempDest.Name(),
						"func":     "os.Remove",
					}).Error("failed to remove temporary file")
				}
			}
		}()
		defer logx.LogReturnedErr(tempDest.Close, log.Fields{
			"filename": tempDest.Name(),
		}, "failed to close temp dest")

		sourceURL := fmt.Sprintf("%s/images/%s/download", getServerURL(), id)
		resp, err := http.Get(sourceURL)
		if err != nil {
			log.WithFields(log.Fields{
				"error":     err,
				"sourceURL": sourceURL,
				"func":      "http.Get",
			}).Error("request error")
			return
		}
		defer logx.LogReturnedErr(resp.Body.Close, nil, "failed to close response body")

		if resp.StatusCode != http.StatusOK {
			log.WithFields(log.Fields{
				"sourceURL":  sourceURL,
				"statusCode": resp.StatusCode,
				"func":       "http.Get",
			}).Error("bad response code")
			return
		}

		if _, err := io.Copy(tempDest, resp.Body); err != nil {
			log.WithFields(log.Fields{
				"error":     err,
				"sourceURL": sourceURL,
				"tempFile":  tempDest.Name(),
				"func":      "io.Copy",
			}).Error("failed to download image")
			return
		}

		if _, err := tempDest.Seek(0, 0); err != nil {
			log.WithFields(log.Fields{
				"error":    err,
				"tempFile": tempDest.Name(),
				"func":     "tempDest.Seek",
			}).Error("failed to seek to beginning of file")
		}
		fileBuffer := bufio.NewReader(tempDest)
		filetypeBytes, err := fileBuffer.Peek(512)
		if err != nil {
			log.WithFields(log.Fields{
				"error":    err,
				"tempFile": tempDest.Name(),
				"func":     "tempDest.Peek",
			}).Error("failed to read image filetype bytes")
			return
		}
		extension := ".tar"
		if http.DetectContentType(filetypeBytes) == "application/x-gzip" {
			extension = extension + ".gz"
		}

		imagePath := filepath.Join(downloadDir, id+extension)
		if err := os.Rename(tempDest.Name(), imagePath); err != nil {
			log.WithFields(log.Fields{
				"tempFile":  tempDest.Name(),
				"imagePath": imagePath,
				"func":      "os.Rename",
			}).Error("failed to rename image file")
			return
		}
		fmt.Println(imagePath)
		success = true
	}
}