Exemplo n.º 1
0
func main() {
	var simple = flag.Bool("simple", false, "Use simple (debugging) output format")
	flag.Parse()

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	locations, err := client.GetLocations()
	if err != nil {
		exit.Fatalf("Failed to list queue requests: %s", err)
	}

	if len(locations) == 0 {
		println("Empty result.")
	} else if *simple {
		for _, l := range locations {
			utils.PrintStruct(l)
		}
	} else {
		table := tablewriter.NewWriter(os.Stdout)
		table.SetAutoFormatHeaders(false)
		table.SetAlignment(tablewriter.ALIGN_LEFT)
		table.SetAutoWrapText(false)

		table.SetHeader([]string{"Alias", "Region"})
		for _, l := range locations {
			table.Append([]string{l.Alias, l.Region})
		}
		table.Render()
	}
}
Exemplo n.º 2
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias to use")
	var busId = flag.String("bus", "", "The SCSI bus ID of the disk")
	var devId = flag.String("dev", "", "The SCSI device ID of the disk")
	var force = flag.Bool("force", false, "Override safety checks required for primary/OS disks")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <server-name>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()
	if flag.NArg() != 1 || *busId == "" || *devId == "" {
		flag.Usage()
		os.Exit(1)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	reqId, err := client.DeleteDisk(flag.Arg(0), *acctAlias, *busId, *devId, *force)
	if err != nil {
		exit.Fatalf("Failed to delete disk on %s: %s", flag.Arg(0), err)
	}

	fmt.Println("Request ID for server disk deletion:", reqId)
}
Exemplo n.º 3
0
Arquivo: list.go Projeto: grrtrr/clcv1
func main() {
	flag.Parse()

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	accts, err := client.GetAccounts()
	if err != nil {
		exit.Fatalf("Failed to obtain account list: %s", err)
	}

	table := tablewriter.NewWriter(os.Stdout)
	table.SetAutoFormatHeaders(false)
	table.SetAlignment(tablewriter.ALIGN_LEFT)
	table.SetAutoWrapText(true)

	table.SetHeader([]string{"Account", "Parent", "Location", "Business Name"})
	for _, a := range accts {
		var acct = a.AccountAlias

		if !a.IsActive {
			acct += " (INACTIVE)"
		}
		table.Append([]string{acct, a.ParentAlias, a.Location, a.BusinessName})
	}
	table.Render()
}
Exemplo n.º 4
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias to use")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <HW Group UUID>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()
	if flag.NArg() != 1 {
		flag.Usage()
		os.Exit(1)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	reqId, err := client.ArchiveHardwareGroup(flag.Arg(0), *acctAlias)
	if err != nil {
		exit.Fatalf("Failed to archive Hardware Group %s: %s", flag.Arg(0), err)
	}

	fmt.Println("Request ID for group archival:", reqId)
}
Exemplo n.º 5
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias to use")
	var password = flag.String("pass", "", "Administrator/root password for the server to convert")
	var templAlias = flag.String("alias", "TEMPL", "The alias for the Template to create")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <server-name>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()
	if flag.NArg() != 1 || *password == "" || *templAlias == "" {
		flag.Usage()
		os.Exit(1)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	reqId, err := client.ConvertServerToTemplate(flag.Arg(0), *password, *templAlias, *acctAlias)
	if err != nil {
		exit.Fatalf("Failed to convert %s into a template: %s", flag.Arg(0), err)
	}

	fmt.Println("Request ID for converting server:", reqId)
}
Exemplo n.º 6
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias of the account that owns the servers")
	var location = flag.String("l", "", "The data center location")
	var hwGrpUUID = flag.String("u", "", "UUID of the Hardware Group")
	var simple = flag.Bool("simple", false, "Use simple (debugging) output format")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  [<location>]\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()
	if flag.NArg() != 0 && *location != "" {
		flag.Usage()
		os.Exit(1)
	} else if flag.NArg() == 1 {
		*location = flag.Arg(0)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	servers, err := client.GetAllServers(*acctAlias, *hwGrpUUID, *location)
	if err != nil {
		exit.Fatalf("Failed to list all servers: %s", err)
	}

	if len(servers) == 0 {
		println("Empty result.")
	} else if *simple {
		for _, s := range servers {
			utils.PrintStruct(s)
		}
	} else {
		table := tablewriter.NewWriter(os.Stdout)
		table.SetAutoFormatHeaders(false)
		table.SetAlignment(tablewriter.ALIGN_LEFT)
		table.SetAutoWrapText(true)

		table.SetHeader([]string{
			"Name", "Description",
			"#CPU", "#Disk", "Disk",
			"OS", "IP", "Power", "Who modified", "Modified date",
		})
		for _, s := range servers {
			table.Append([]string{
				s.Name, s.Description,
				fmt.Sprint(s.Cpu), fmt.Sprint(s.DiskCount), fmt.Sprint(s.TotalDiskSpaceGB),
				fmt.Sprintf("%25.25s", s.OperatingSystem), s.IPAddress,
				s.PowerState, fmt.Sprintf("%12.12s", s.ModifiedBy),
				s.DateModified.Format("Jan _2/06 15:04"),
			})
		}
		table.Render()
	}
}
Exemplo n.º 7
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias to use")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <server-name>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()
	if flag.NArg() != 1 {
		flag.Usage()
		os.Exit(1)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	reqId, err := client.SnapshotServer(flag.Arg(0), *acctAlias)
	if err != nil {
		exit.Fatalf("Failed to take snapshot of server %s: %s", flag.Arg(0), err)
	}

	fmt.Println("Request ID for taking server snapshot:", reqId)
}
Exemplo n.º 8
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias to use")

	flag.Parse()

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	bh, err := client.GetBillingHistory(*acctAlias)
	if err != nil {
		exit.Fatalf("Failed to obtain billing history: %s", err)
	}

	fmt.Printf("Billing history for %s:\n", bh.AccountAlias)
	table := tablewriter.NewWriter(os.Stdout)
	table.SetAutoFormatHeaders(false)
	table.SetAlignment(tablewriter.ALIGN_RIGHT)
	table.SetAutoWrapText(true)

	table.SetHeader([]string{"Date", "Debit", "Credit", "ID", "Description"})

	for _, le := range bh.BillingHistory {
		table.Append([]string{
			le.Date.Time.Format("Jan 2006"),
			fmt.Sprintf("%.2f", le.Debit),
			fmt.Sprintf("%.2f", le.Credit),
			le.InvoiceID, le.Description,
		})
	}
	table.Render()
}
Exemplo n.º 9
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias to use")
	var busId = flag.String("bus", "", "The SCSI bus ID of the disk")
	var devId = flag.String("dev", "", "The SCSI device ID of the disk")
	var newSize = flag.Int("s", 0, "The expanded size of the disk")
	var expand = flag.Bool("e", false, "Expand the filesystem on the disk after the resize")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <server-name>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()
	if flag.NArg() != 1 || *busId == "" || *devId == "" {
		flag.Usage()
		os.Exit(1)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	reqId, err := client.ResizeDisk(flag.Arg(0), *acctAlias, *busId, *devId, *newSize, *expand)
	if err != nil {
		exit.Fatalf("Failed to resize disk on %s: %s", flag.Arg(0), err)
	}

	fmt.Println("Request ID for resizing server disk:", reqId)
}
Exemplo n.º 10
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias to use")
	var maintenance = flag.Bool("m", false, "Turn maintenance mode on (-m) or off (-m=false)")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <HW Group UUID>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()
	if flag.NArg() != 1 {
		flag.Usage()
		os.Exit(1)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	reqId, err := client.HardwareGroupMaintenance(*maintenance, flag.Arg(0), *acctAlias)
	if err != nil {
		exit.Fatalf("Failed to modify maintenance mode: %s", err)
	}

	fmt.Println("Request ID for group maintenance status change:", reqId)
}
Exemplo n.º 11
0
func main() {
	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <Location>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}
	flag.Parse()

	if flag.NArg() != 1 {
		flag.Usage()
		os.Exit(1)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	rootGroup, err := client.GetRootGroup(flag.Arg(0))
	if err != nil {
		exit.Fatalf("Failed to list root group: %s", err)
	}

	fmt.Println("Location:   ", flag.Arg(0))
	fmt.Println("Root Group: ", rootGroup.Name)
	fmt.Println("UUID:       ", rootGroup.UUID)
}
Exemplo n.º 12
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias to use")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <server-name>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()

	if flag.NArg() != 1 {
		flag.Usage()
		os.Exit(1)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	credentials, err := client.GetServerCredentials(flag.Arg(0), *acctAlias)
	if err != nil {
		exit.Fatalf("Failed to obtain the credentials of server %q: %s", flag.Arg(0), err)
	}

	fmt.Printf("Credentials for %s:\n", flag.Arg(0))
	fmt.Printf("User:     %s\n", credentials.Username)
	fmt.Printf("Password: '******'\n", credentials.Password)
}
Exemplo n.º 13
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias to use")
	var hwGrpUUID = flag.String("u", "", "UUID of the Hardware Group to restore the server to")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <server-name>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()
	if flag.NArg() != 1 {
		flag.Usage()
		os.Exit(1)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	reqId, err := client.RestoreServer(flag.Arg(0), *acctAlias, *hwGrpUUID)
	if err != nil {
		exit.Fatalf("Failed to restore server %s: %s", flag.Arg(0), err)
	}

	fmt.Println("Request ID for restoring server:", reqId)
}
Exemplo n.º 14
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias to use")
	var snapName = flag.String("s", "", "The name of the Snapshot to delete")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <server-name>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()
	if flag.NArg() != 1 || *snapName == "" {
		flag.Usage()
		os.Exit(1)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	err = client.DeleteSnapshot(*snapName, flag.Arg(0), *acctAlias)
	if err != nil {
		exit.Fatalf("Failed to delete snapshot on %s: %s", flag.Arg(0), err)
	}

	fmt.Printf("Successfully deleted snapshot %q from %s.\n", *snapName, flag.Arg(0))
}
Exemplo n.º 15
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias to use")
	var simple = flag.Bool("simple", false, "Use simple (debugging) output format")

	flag.Parse()

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	acctSummary, err := client.GetAccountSummary(*acctAlias)
	if err != nil {
		exit.Fatalf("Failed to obtain account billing summary of %s: %s", *acctAlias, err)
	}

	if *simple {
		utils.PrintStruct(acctSummary)
	} else {
		fmt.Printf("Total charges during this hour:     $%.2f\n", acctSummary.CurrentHour)
		fmt.Printf("Total charges during previous hour: $%.2f\n", acctSummary.PreviousHour)
		fmt.Printf("Total hourly charges this month:    $%.2f\n", acctSummary.MonthToDate)
		fmt.Printf("Total one-time charges this month:  $%.2f\n", acctSummary.OneTimeCharges)
		fmt.Printf("Total overall charges this month:   $%.2f\n", acctSummary.MonthToDateTotal)
		fmt.Printf("Corresponding monthly estimate:     $%.2f\n", acctSummary.MonthlyEstimate)

	}
}
func main() {
	var acctAlias = flag.String("a", "", "Account alias of the account that owns the servers")
	var location = flag.String("l", "", "The data center location")
	var simple = flag.Bool("simple", false, "Use simple (debugging) output format")

	flag.Parse()

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	servers, err := client.GetAllServersForAccountHierarchy(*acctAlias, *location)
	if err != nil {
		exit.Fatalf("Failed to list all servers: %s", err)
	}

	// FIXME: simple representation only, since currently not able to test
	//       (StatusCode 2, null result)
	*simple = true
	if len(servers) == 0 {
		println("Empty result.")
	} else if *simple {
		for _, s := range servers {
			utils.PrintStruct(s)
		}
	}
}
Exemplo n.º 17
0
func main() {
	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s <Account-Alias>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()
	if flag.NArg() != 1 {
		flag.Usage()
		os.Exit(0)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	acctDetails, err := client.GetAccountDetails(flag.Arg(0))
	if err != nil {
		exit.Fatalf("Failed to obtain account details of %s: %s", flag.Arg(0), err)
	}

	utils.PrintStruct(acctDetails)
}
Exemplo n.º 18
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias to use")

	flag.Parse()

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	customFields, err := client.GetCustomFields(*acctAlias)
	if err != nil {
		exit.Fatalf("Failed to obtain Custom Fields of %s: %s", *acctAlias, err)
	}

	if len(customFields) == 0 {
		println("Empty result.")
	} else {
		for _, cf := range customFields {
			utils.PrintStruct(cf)
		}
	}
}
Exemplo n.º 19
0
func main() {
	var location = flag.String("l", "", "The location of the deployment to retrieve status for (required)")
	var pollIntvl = flag.Int("i", 1, "Poll interval in seconds (to monitor progress")
	var acctAlias = flag.String("a", "", "Account alias to use")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <Request-ID>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()
	if flag.NArg() != 1 || *location == "" {
		flag.Usage()
		os.Exit(1)
	}

	reqId, err := strconv.ParseUint(flag.Arg(0), 10, 32)
	if err != nil {
		exit.Errorf("Invalid Request ID %q: %s", flag.Arg(0), err)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	err = client.PollDeploymentStatus(int(reqId), *location, *acctAlias, *pollIntvl)
	if err != nil {
		exit.Fatalf("Failed to poll status of request ID %d: %s", reqId, err)
	}
}
Exemplo n.º 20
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias to use")
	var hwGrpUUID = flag.String("u", "", "UUID of the Hardware Group to place the converted server in")
	var password = flag.String("pass", "", "New administrator/root password for the converted server")
	var network = flag.String("net", "", "Name of the network to use for the converted server")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <server-name>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()
	if flag.NArg() != 1 || *password == "" || *hwGrpUUID == "" || *network == "" {
		flag.Usage()
		os.Exit(1)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	reqId, err := client.ConvertTemplateToServer(flag.Arg(0), *password, *hwGrpUUID, *network, *acctAlias)
	if err != nil {
		exit.Fatalf("Failed to generate a server from %s: %s", flag.Arg(0), err)
	}

	fmt.Println("Request ID for converting template:", reqId)
}
Exemplo n.º 21
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias of the account in question")
	var location = flag.String("l", "", "Data centre alias of the network (uses Home Data Centre by default)")
	var ips = flag.Bool("ips", false, "Also list IP addresses")
	var unclaimed = flag.Bool("free", false, "Also list unclaimed IP addresses (implies -ips)")
	var simple = flag.Bool("simple", false, "Use simple (debugging) output format")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <Network-Name>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()
	if flag.NArg() != 1 {
		flag.Usage()
		os.Exit(1)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	details, err := client.GetNetworkDetails(flag.Arg(0), *acctAlias, *location)
	if err != nil {
		exit.Fatalf("Failed to query network details of %s: %s", flag.Arg(0), err)
	}

	if *simple {
		utils.PrintStruct(details)
	} else {
		fmt.Printf("Details for %s (%s) at %s:\n", details.Name, details.Description, details.Location)
		fmt.Printf("Gateway: %s\n", details.Gateway)
		fmt.Printf("Netmask: %s\n", details.NetworkMask)

		if !*ips && !*unclaimed {
			return
		}
		fmt.Printf("IP addresses:\n")

		table := tablewriter.NewWriter(os.Stdout)
		table.SetAutoFormatHeaders(false)
		table.SetAlignment(tablewriter.ALIGN_LEFT)
		table.SetAutoWrapText(false)

		table.SetHeader([]string{"Address", "Type", "Claimed", "Used by"})
		for _, ip := range details.IPAddresses {
			if ip.IsClaimed || *unclaimed {
				table.Append([]string{ip.Address, ip.AddressType, fmt.Sprint(ip.IsClaimed), ip.ServerName})
			}
		}
		table.Render()
	}
}
Exemplo n.º 22
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias to use")
	var startDate = flag.String("start", "", "Start date of the query range")
	var endDate = flag.String("end", "", "End date of the query range")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <Servername>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()
	if flag.NArg() != 1 {
		flag.Usage()
		os.Exit(1)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	hr, err := client.GetServerHourlyCharges(flag.Arg(0), *startDate, *endDate, *acctAlias)
	if err != nil {
		exit.Fatalf("Failed to obtain server hourly charges for %s: %s", flag.Arg(0), err)
	}

	fmt.Printf("Hourly charges for %s (%s) from %s until %s:\n", hr.ServerName, hr.AccountAlias,
		hr.StartDate.Time.Format("2 Jan 2006 3:04PM"), hr.EndDate.Time.Format("2 Jan 2006 3:04PM"))

	fmt.Printf("\tCharges for the current hour:      $%.2f\n", hr.Summary.CurrentHour)
	fmt.Printf("\tCharges for the previous hour:     $%.2f\n", hr.Summary.PreviousHour)
	fmt.Printf("\tCurrent charges so far this month: $%.2f\n", hr.Summary.MonthToDate)
	fmt.Printf("\tEstimated monthly costs:           $%.2f\n", hr.Summary.MonthlyEstimate)

	if len(hr.HourlyCharges) > 0 {
		fmt.Println("\nHourly charges:")
		table := tablewriter.NewWriter(os.Stdout)
		table.SetAutoFormatHeaders(false)
		table.SetAlignment(tablewriter.ALIGN_RIGHT)
		table.SetAutoWrapText(true)

		table.SetHeader([]string{"Hour", "CPU", "Memory", "Storage", "OS"})

		for _, ch := range hr.HourlyCharges {
			table.Append([]string{ch.Hour, ch.ProcessorCost,
				ch.MemoryCost, ch.StorageCost, ch.OSCost,
			})
		}
		table.Render()
	}
}
Exemplo n.º 23
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias of the account that owns the servers")
	var hwGrpUUID = flag.String("u", "", "UUID of the Hardware Group")
	var location = flag.String("l", "", "The data center location")
	var beginDate = flag.String("b", "", "Only list servers modified later than this date (defaults to yesterday)")
	var endDate = flag.String("e", "", "Only list servers modified earlier than this date (defaults to now)")
	var simple = flag.Bool("simple", false, "Use simple (debugging) output format")

	flag.Parse()

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	servers, err := client.GetAllServersByModifiedDates(*acctAlias, *hwGrpUUID, *location, *beginDate, *endDate)
	if err != nil {
		exit.Fatalf("Failed to list all servers: %s", err)
	}

	if len(servers) == 0 {
		println("Empty result.")
	} else if *simple {
		for _, s := range servers {
			utils.PrintStruct(s)
		}
	} else {
		table := tablewriter.NewWriter(os.Stdout)
		table.SetAutoFormatHeaders(false)
		table.SetAlignment(tablewriter.ALIGN_LEFT)
		table.SetAutoWrapText(true)

		table.SetHeader([]string{
			"Name", "Description",
			"#CPU", "#Disk", "Disk",
			"OS", "IP", "Power", "Who modified", "Modified date",
		})
		for _, s := range servers {
			table.Append([]string{
				s.Name, s.Description,
				fmt.Sprint(s.Cpu), fmt.Sprint(s.DiskCount), fmt.Sprint(s.TotalDiskSpaceGB),
				fmt.Sprintf("%25.25s", s.OperatingSystem), s.IPAddress,
				s.PowerState, fmt.Sprintf("%12.12s", s.ModifiedBy),
				s.DateModified.Format("Jan _2/06 15:04"),
			})
		}
		table.Render()
	}
}
Exemplo n.º 24
0
Arquivo: list.go Projeto: grrtrr/clcv1
func main() {
	var acctAlias = flag.String("a", "", "Account alias to use")
	var simple = flag.Bool("simple", false, "Use simple (debugging) output format")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <location>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()
	if flag.NArg() != 1 {
		flag.Usage()
		os.Exit(1)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	templates, err := client.ListAvailableServerTemplates(*acctAlias, flag.Arg(0))
	if err != nil {
		exit.Fatalf("Failed to list available templates: %s", err)
	}

	if len(templates) == 0 {
		println("Empty result.")
	} else if *simple {
		for _, t := range templates {
			utils.PrintStruct(t)
		}
	} else {
		fmt.Printf("Server templates available at %s:\n", templates[0].Location)
		table := tablewriter.NewWriter(os.Stdout)
		table.SetAutoFormatHeaders(false)
		table.SetAlignment(tablewriter.ALIGN_LEFT)
		table.SetAutoWrapText(true)

		table.SetHeader([]string{"Name", "Description", "OS", "#Disk", "Disk/GB"})

		for _, t := range templates {
			table.Append([]string{
				t.Name, t.Description, fmt.Sprint(t.OperatingSystem),
				fmt.Sprint(t.DiskCount), fmt.Sprint(t.TotalDiskSpaceGB),
			})
		}
		table.Render()
	}
}
Exemplo n.º 25
0
Arquivo: show.go Projeto: grrtrr/clcv1
func main() {
	var acctAlias = flag.String("a", "", "Account alias to use")
	var simple = flag.Bool("simple", false, "Use simple (debugging) output format")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <Template Name>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()
	if flag.NArg() != 1 {
		flag.Usage()
		os.Exit(1)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	template, err := client.GetServer(flag.Arg(0), *acctAlias)
	if err != nil {
		exit.Fatalf("Failed to list details of server %q: %s", flag.Arg(0), err)
	}

	if *simple {
		utils.PrintStruct(template)
	} else {
		table := tablewriter.NewWriter(os.Stdout)
		table.SetAutoFormatHeaders(false)
		table.SetAlignment(tablewriter.ALIGN_LEFT)
		table.SetAutoWrapText(false)

		table.SetHeader([]string{
			"Name", "Description", "OS",
			"CPU", "Disk",
			"Last Change",
		})
		table.Append([]string{
			template.Name, template.Description, fmt.Sprint(template.OperatingSystem),
			fmt.Sprint(template.Cpu),
			fmt.Sprintf("%d GB", template.TotalDiskSpaceGB),
			fmt.Sprintf("%s by %s", humanize.Time(template.DateModified.Time), template.ModifiedBy),
		})
		table.Render()
	}
}
Exemplo n.º 26
0
func main() {
	var parentUUID string
	var parentGroup = flag.String("g", "", "UUID or Name (if unique and -l present) of the parent Hardware Group")
	var location = flag.String("l", "", "Data centre location to use for resolving -g <Group-Name>")
	var desc = flag.String("t", "", "Textual description of the new group")
	var acctAlias = flag.String("a", "", "Account alias to use")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <New Group Name>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}
	flag.Parse()
	if flag.NArg() != 1 || *parentGroup == "" {
		flag.Usage()
		os.Exit(1)
	}

	/* parentGroup may be hex uuid or group name */
	if _, err := hex.DecodeString(*parentGroup); err == nil {
		parentUUID = *parentGroup
	} else if *location == "" {
		exit.Errorf("Using -g <Group-Name> requires -l <Location> to be set")
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	if parentUUID == "" {
		if group, err := client.GetGroupByName(*parentGroup, *location, *acctAlias); err != nil {
			exit.Errorf("Failed to resolve group name %q: %s", *parentGroup, err)
		} else if group == nil {
			exit.Errorf("No group named %q was found on %s", *parentGroup, *location)
		} else {
			parentUUID = group.UUID
		}
	}

	g, err := client.CreateHardwareGroup(*acctAlias, parentUUID, flag.Arg(0), *desc)
	if err != nil {
		exit.Fatalf("Failed to create hardware group %q: %s", flag.Arg(0), err)
	}

	fmt.Println("New Group: ", g.Name)
	fmt.Println("UUID:      ", g.UUID)
}
Exemplo n.º 27
0
func main() {
	var acctAlias = flag.String("a", "", "Account alias to use")
	var diskNames = flag.Bool("q", false, "Enable to list disk mount points / drive letters.")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <server-name>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()

	if flag.NArg() != 1 {
		flag.Usage()
		os.Exit(1)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	hasSnapshot, disks, err := client.ListDisks(flag.Arg(0), *acctAlias, *diskNames)
	if err != nil {
		exit.Fatalf("Failed to list disks of server %q: %s", flag.Arg(0), err)
	}

	fmt.Printf("Server %s (", flag.Arg(0))
	if hasSnapshot {
		fmt.Printf("has")
	} else {
		fmt.Printf("no")
	}
	fmt.Printf(" snapshot) disks:\n")

	table := tablewriter.NewWriter(os.Stdout)
	table.SetAutoFormatHeaders(false)
	table.SetAlignment(tablewriter.ALIGN_LEFT)
	table.SetAutoWrapText(true)

	table.SetHeader([]string{"Name", "Size/GB", "SCSI Bus ID", "SCSI Dev ID"})
	for _, d := range disks {
		table.Append([]string{d.Name, fmt.Sprint(d.SizeGB), d.ScsiBusID, d.ScsiDeviceID})
	}
	table.Render()
}
Exemplo n.º 28
0
Arquivo: list.go Projeto: grrtrr/clcv1
func main() {
	var simple = flag.Bool("simple", false, "Use simple (debugging) output format")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s <Account-Alias>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}

	flag.Parse()

	if flag.NArg() != 1 {
		flag.Usage()
		os.Exit(0)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	users, err := client.GetUsers(flag.Arg(0))
	if err != nil {
		exit.Fatalf("Failed to list users of %s: %s", flag.Arg(0), err)
	}

	if len(users) == 0 {
		println("Empty result.")
	} else if *simple {
		for _, l := range users {
			utils.PrintStruct(l)
		}
	} else {
		table := tablewriter.NewWriter(os.Stdout)
		table.SetAutoFormatHeaders(false)
		table.SetAlignment(tablewriter.ALIGN_LEFT)
		table.SetAutoWrapText(true)

		table.SetHeader([]string{"Username", "First", "Last", "Email", "Roles"})
		for _, u := range users {
			table.Append([]string{u.UserName, u.FirstName, u.LastName,
				u.EmailAddress, fmt.Sprint(u.Roles)})
		}
		table.Render()
	}
}
Exemplo n.º 29
0
Arquivo: list.go Projeto: grrtrr/clcv1
func main() {
	var acctAlias = flag.String("a", "", "Account alias of the account in question")
	var simple = flag.Bool("simple", false, "Use simple (debugging) output format")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: %s [options]  <Location>\n", path.Base(os.Args[0]))
		flag.PrintDefaults()
	}
	flag.Parse()

	/* The Location argument is always required */
	if flag.NArg() != 1 {
		flag.Usage()
		os.Exit(1)
	}

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	groups, err := client.GetGroups(flag.Arg(0), *acctAlias)
	if err != nil {
		exit.Fatalf("Failed to obtain hardware groups: %s", err)
	}

	if len(groups) == 0 {
		println("Empty result.")
	} else if *simple {
		for _, g := range groups {
			utils.PrintStruct(g)
		}
	} else {
		table := tablewriter.NewWriter(os.Stdout)
		table.SetAutoFormatHeaders(false)
		table.SetAlignment(tablewriter.ALIGN_LEFT)
		table.SetAutoWrapText(true)

		table.SetHeader([]string{"Name", "UUID", "Parent UUID", "System Group?"})
		for _, g := range groups {
			table.Append([]string{g.Name, g.UUID, g.ParentUUID, fmt.Sprint(g.IsSystemGroup)})
		}
		table.Render()
	}
}
Exemplo n.º 30
0
func main() {
	flag.Parse()

	client, err := clcv1.NewClient(log.New(os.Stdout, "", log.LstdFlags|log.Ltime))
	if err != nil {
		exit.Fatal(err.Error())
	} else if err := client.Logon("", ""); err != nil {
		exit.Fatalf("Login failed: %s", err)
	}

	alias, password, err := client.CreateAlias()
	if err != nil {
		exit.Fatalf("Failed to create new SMTP relay alias: %s", err)
	}

	fmt.Printf("New Relay Alias:    %s\n", alias)
	fmt.Printf("Password for Alias: %s\n", password)
}