func runHistory(cmd *types.Command, args []string) {
if historyHelp {
cmd.PrintUsage()
}
if len(args) != 1 {
cmd.PrintShortUsage()
}
imageID := cmd.API.GetImageID(args[0], true)
image, err := cmd.API.GetImage(imageID)
if err != nil {
log.Fatalf("Cannot get image %s: %v", imageID, err)
}
if imagesQ {
fmt.Println(imageID)
return
}
w := tabwriter.NewWriter(os.Stdout, 10, 1, 3, ' ', 0)
defer w.Flush()
fmt.Fprintf(w, "IMAGE\tCREATED\tCREATED BY\tSIZE\n")
identifier := utils.TruncIf(image.Identifier, 8, !historyNoTrunc)
creationDate, err := time.Parse("2006-01-02T15:04:05.000000+00:00", image.CreationDate)
if err != nil {
log.Fatalf("Unable to parse creation date from the Scaleway API: %v", err)
}
creationDateStr := units.HumanDuration(time.Now().UTC().Sub(creationDate))
volumeName := utils.TruncIf(image.RootVolume.Name, 25, !historyNoTrunc)
size := units.HumanSize(float64(image.RootVolume.Size))
fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", identifier, creationDateStr, volumeName, size)
}
func runSearch(cmd *types.Command, args []string) {
if searchHelp {
cmd.PrintUsage()
}
if len(args) != 1 {
cmd.PrintShortUsage()
}
w := tabwriter.NewWriter(os.Stdout, 10, 1, 3, ' ', 0)
defer w.Flush()
fmt.Fprintf(w, "NAME\tDESCRIPTION\tSTARS\tOFFICIAL\tAUTOMATED\n")
var entries = []api.ScalewayImageInterface{}
images, err := cmd.API.GetImages()
if err != nil {
log.Fatalf("unable to fetch images from the Scaleway API: %v", err)
}
for _, val := range *images {
entries = append(entries, api.ScalewayImageInterface{
Type: "image",
Name: val.Name,
Public: val.Public,
})
}
snapshots, err := cmd.API.GetSnapshots()
if err != nil {
log.Fatalf("unable to fetch snapshots from the Scaleway API: %v", err)
}
for _, val := range *snapshots {
entries = append(entries, api.ScalewayImageInterface{
Type: "snapshot",
Name: val.Name,
Public: false,
})
}
for _, image := range entries {
// name field
name := utils.TruncIf(utils.Wordify(image.Name), 45, !searchNoTrunc)
// description field
var description string
switch image.Type {
case "image":
if image.Public {
description = "public image"
} else {
description = "user image"
}
case "snapshot":
description = "user snapshot"
}
description = utils.TruncIf(utils.Wordify(description), 45, !searchNoTrunc)
// official field
var official string
if image.Public {
official = "[OK]"
} else {
official = ""
}
fmt.Fprintf(w, "%s\t%s\t%d\t%s\t%s\n", name, description, 0, official, "")
}
}
func runImages(cmd *types.Command, args []string) {
if imagesHelp {
cmd.PrintUsage()
}
if len(args) != 0 {
cmd.PrintShortUsage()
}
wg := sync.WaitGroup{}
chEntries := make(chan api.ScalewayImageInterface)
var entries = []api.ScalewayImageInterface{}
wg.Add(1)
go func() {
defer wg.Done()
images, err := cmd.API.GetImages()
if err != nil {
log.Fatalf("unable to fetch images from the Scaleway API: %v", err)
}
for _, val := range *images {
creationDate, err := time.Parse("2006-01-02T15:04:05.000000+00:00", val.CreationDate)
if err != nil {
log.Fatalf("unable to parse creation date from the Scaleway API: %v", err)
}
chEntries <- api.ScalewayImageInterface{
Type: "image",
CreationDate: creationDate,
Identifier: val.Identifier,
Name: val.Name,
Public: val.Public,
Tag: "latest",
VirtualSize: float64(val.RootVolume.Size),
}
}
}()
if imagesA {
wg.Add(1)
go func() {
defer wg.Done()
snapshots, err := cmd.API.GetSnapshots()
if err != nil {
log.Fatalf("unable to fetch snapshots from the Scaleway API: %v", err)
}
for _, val := range *snapshots {
creationDate, err := time.Parse("2006-01-02T15:04:05.000000+00:00", val.CreationDate)
if err != nil {
log.Fatalf("unable to parse creation date from the Scaleway API: %v", err)
}
chEntries <- api.ScalewayImageInterface{
Type: "snapshot",
CreationDate: creationDate,
Identifier: val.Identifier,
Name: val.Name,
Tag: "<snapshot>",
VirtualSize: float64(val.Size),
Public: false,
}
}
}()
wg.Add(1)
go func() {
defer wg.Done()
bootscripts, err := cmd.API.GetBootscripts()
if err != nil {
log.Fatalf("unable to fetch bootscripts from the Scaleway API: %v", err)
}
for _, val := range *bootscripts {
chEntries <- api.ScalewayImageInterface{
Type: "bootscript",
Identifier: val.Identifier,
Name: val.Title,
Tag: "<bootscript>",
Public: false,
}
}
}()
wg.Add(1)
go func() {
defer wg.Done()
volumes, err := cmd.API.GetVolumes()
if err != nil {
log.Fatalf("unable to fetch volumes from the Scaleway API: %v", err)
}
for _, val := range *volumes {
creationDate, err := time.Parse("2006-01-02T15:04:05.000000+00:00", val.CreationDate)
if err != nil {
log.Fatalf("unable to parse creation date from the Scaleway API: %v", err)
}
chEntries <- api.ScalewayImageInterface{
Type: "volume",
CreationDate: creationDate,
Identifier: val.Identifier,
Name: val.Name,
Tag: "<volume>",
VirtualSize: float64(val.Size),
Public: false,
}
}
}()
}
go func() {
wg.Wait()
close(chEntries)
}()
done := false
for {
select {
case entry, ok := <-chEntries:
if !ok {
done = true
break
}
entries = append(entries, entry)
}
if done {
break
}
}
w := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
defer w.Flush()
if !imagesQ {
fmt.Fprintf(w, "REPOSITORY\tTAG\tIMAGE ID\tCREATED\tVIRTUAL SIZE\n")
}
sort.Sort(api.ByCreationDate(entries))
for _, image := range entries {
if imagesQ {
fmt.Fprintf(w, "%s\n", image.Identifier)
} else {
tag := image.Tag
shortID := utils.TruncIf(image.Identifier, 8, !imagesNoTrunc)
name := utils.Wordify(image.Name)
if !image.Public && image.Type == "image" {
name = "user/" + name
}
shortName := utils.TruncIf(name, 25, !imagesNoTrunc)
var creationDate, virtualSize string
if image.CreationDate.IsZero() {
creationDate = "n/a"
} else {
creationDate = units.HumanDuration(time.Now().UTC().Sub(image.CreationDate))
}
if image.VirtualSize == 0 {
virtualSize = "n/a"
} else {
virtualSize = units.HumanSize(image.VirtualSize)
}
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n", shortName, tag, shortID, creationDate, virtualSize)
}
}
}