564 lines
19 KiB
Go
564 lines
19 KiB
Go
package main
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"path/filepath"
|
|
|
|
"github.com/UpCloudLtd/upcloud-go-api/upcloud"
|
|
"github.com/UpCloudLtd/upcloud-go-api/upcloud/request"
|
|
|
|
"encoding/json"
|
|
"log"
|
|
"math/rand"
|
|
"os"
|
|
"time"
|
|
|
|
"gopkg.in/yaml.v3"
|
|
// https://abhinavg.net/posts/flexible-yaml/
|
|
)
|
|
|
|
const VERSION = "0.1.1"
|
|
const SEPARATOR = "::"
|
|
const DATA_CFG = "datacfg.yaml"
|
|
const DFLT_COMMAND= "infoserver"
|
|
const SSH_KEY_PATH = ".sshkeys"
|
|
const DFLT_SSH_USER = "kloudsadm"
|
|
|
|
const MONTH_HOURS = 672
|
|
|
|
var username string
|
|
var password string
|
|
|
|
var TECODER = CoderConfig {
|
|
cmd: "tecoder",
|
|
abbrv: "tc",
|
|
decoder: "-d",
|
|
fdecoder: "--fdecrypt",
|
|
encoder: "-e",
|
|
fencoder: "--fencrypt",
|
|
}
|
|
|
|
type RunFlags struct {
|
|
command string
|
|
dataCfgPath string
|
|
id string
|
|
runCmd string
|
|
encdr string
|
|
out string
|
|
target string
|
|
sid string
|
|
version bool
|
|
}
|
|
type CoderConfig struct {
|
|
cmd string
|
|
abbrv string
|
|
decoder string
|
|
fdecoder string
|
|
encoder string
|
|
fencoder string
|
|
}
|
|
type StoreConfig struct {
|
|
Title string `yaml:"title"`
|
|
Uuid string `yaml:"uuid"`
|
|
Size int `yaml:"size"`
|
|
Servers []string `yaml:"servers"`
|
|
}
|
|
type DataStorageDevices struct {
|
|
Action string `yaml:"action"`
|
|
Title string `yaml:"title"`
|
|
Storage string `yaml:"storage"`
|
|
Size int `yaml:"size"`
|
|
FinalSize int `yaml:"finalSize"`
|
|
PartSizes string `yaml:"partSizes"`
|
|
MakeFs string `yaml:"makefs"`
|
|
Tier string `yaml:"tier"`
|
|
Source string `yaml:"source"`
|
|
// Type: string `yaml:"type"`
|
|
// Address string `json:"address,omitempty"`
|
|
}
|
|
|
|
type NetworksConfig struct {
|
|
Access string `yaml:"access"`
|
|
Family string `yaml:"family"`
|
|
Network string `yaml:"network"`
|
|
IPAddress string `yaml:"ipaddress"`
|
|
SourceIPFiltering string `yaml:"source_ip_filtering"`
|
|
// SourceIPFiltering upcloud.Boolean `yaml:"source_ip_filtering"`
|
|
}
|
|
|
|
type ClusterRole struct {
|
|
Role string `yaml:"role"`
|
|
}
|
|
|
|
type TskSrvc struct {
|
|
name string `yaml:"name"`
|
|
path string `yaml:"path"`
|
|
target string `yaml:"target"`
|
|
req string `yaml:"req"`
|
|
liveness string `yaml:"liveness"`
|
|
}
|
|
|
|
type App struct {
|
|
name string `yaml:"name"`
|
|
path string `yaml:"path"`
|
|
target string `yaml:"target"`
|
|
req string `yaml:"req"`
|
|
liveness string `yaml:"liveness"`
|
|
}
|
|
|
|
type SSHAccess struct {
|
|
Host string `yaml:"host"`
|
|
User string `yaml:"user"`
|
|
Password string `yaml:"password"`
|
|
UType string `yaml:"utype"`
|
|
KeyPath string `yaml:"keyPath"`
|
|
Port int `yaml:"port"`
|
|
}
|
|
type LoginUserConfig struct {
|
|
// CreatePassword string `yaml:"createPassword"`
|
|
// Username string `yaml:"username"`
|
|
SSHKeys []string `yaml:"sshKeys"`
|
|
}
|
|
|
|
type Cntrllrs struct {
|
|
host string `yaml:"host"`
|
|
sshaccess SSHAccess `yaml:"sshaccess"`
|
|
cldPath string `yaml:"cldPath"`
|
|
masterPath string `yaml:"masterPath"`
|
|
}
|
|
|
|
// https://abhinavg.net/posts/flexible-yaml/
|
|
|
|
type ServerConfig struct {
|
|
Hostname string `yaml:"hostname"`
|
|
Title string `yaml:"title"`
|
|
UserData string `yaml:"userData"`
|
|
Zone string `yaml:"zone"`
|
|
UUID string `yaml:"uuid"`
|
|
Host string `yaml:"host"`
|
|
Tags []string `yaml:"tags"`
|
|
Cluster ClusterRole `yaml:"cluster"`
|
|
SSHAccess SSHAccess `yaml:"sshAccess"`
|
|
LoginUser LoginUserConfig `yaml:"loginUser"`
|
|
Plan string `yaml:"plan"`
|
|
Metadata upcloud.Boolean `yaml:"metadata"`
|
|
TimeZone string `yaml:"timeZone"`
|
|
Networks []NetworksConfig `yaml:"networks"`
|
|
StorageDevices []DataStorageDevices `yaml:"storages"`
|
|
UseFloatIP bool `yaml:"useFloatIP"`
|
|
TskSrvcs []TskSrvc `yaml:"tsksrvcs"`
|
|
Apps []App `yaml:"apps"`
|
|
Clients []string `yaml:"clients"`
|
|
Rules []string `yaml:"rules"`
|
|
Backup []string `yaml:"backup"`
|
|
}
|
|
|
|
type DataConfig struct {
|
|
Servers []ServerConfig `yaml:"servers"`
|
|
FloatIP string `yaml:"floatIP"`
|
|
Group string `yaml:"group"`
|
|
GroupPath string `yaml:"group_path"`
|
|
HostPrefix string `yaml:"hostPrefix"`
|
|
MainName string `yaml:"main"`
|
|
domainName string `yaml:"domainName"`
|
|
cntrllrs []Cntrllrs `yaml:"cntrllrs"`
|
|
}
|
|
|
|
type InfoServer struct {
|
|
info upcloud.ServerDetails `json:"ServerDetails"`
|
|
price Price `json:"Price"`
|
|
// price upcloud.Price `json:"Price"`
|
|
}
|
|
/*
|
|
type CloudGroup struct {
|
|
name string `yaml:"name"`
|
|
path string `yaml:"path"`
|
|
info string `yaml:"info"`
|
|
resources ConfigResources `yaml:"resources"`
|
|
}
|
|
|
|
type KloudHome struct {
|
|
name string `yaml:"name"`
|
|
title string `yaml:"title"`
|
|
dflts string `yaml:"dflts"`
|
|
provider []ProviderName `yaml:"provider"`
|
|
netips []IpDef `yaml:"netips"`
|
|
cntrllrs []Cntrllrs `yaml:"cntrllrs"`
|
|
groups []CloudGroup `yaml:"groups"`
|
|
}
|
|
*/
|
|
// type DDataConfig struct {
|
|
// // Servers []ServerConfig `yaml:"servers"`
|
|
// floatIP string `yaml:"floatIP"`
|
|
// hostPrefix string `yaml:"hostPrefix"`
|
|
// mainName string `yaml:"main"`
|
|
// }
|
|
|
|
// Price represents a price
|
|
type Price struct {
|
|
Amount int `yam:"amount"`
|
|
Price float64 `yaml:"price"`
|
|
Hour float64 `yaml:"price_hour"`
|
|
Month float64 `yaml:"price_month"`
|
|
}
|
|
|
|
type DataPrices struct {
|
|
Prices PricesZones `yaml:"prices"`
|
|
}
|
|
type PricesZones struct {
|
|
Zone []PricesZone `yaml:"zone"`
|
|
}
|
|
|
|
type PricesZone struct {
|
|
Name string `yaml:"name"`
|
|
Firewall Price `yaml:"firewall"`
|
|
IORequestBackup Price `yaml:"io_request_backup"`
|
|
IORequestHDD Price `yaml:"io_request_hdd"`
|
|
IORequestMaxIOPS Price `yaml:"io_request_maxiops"`
|
|
IPv4Address Price `yaml:"ipv4_address"`
|
|
IPv6Address Price `yaml:"ipv6_address"`
|
|
ManagedDatabase1x1CPU2GB25GB Price `yaml:"managed_database_1x1xCPU-2GB-25GB"`
|
|
ManagedDatabase1x2CPU4GB100GB Price `yaml:"managed_database_1x2xCPU-4GB-100GB"`
|
|
ManagedDatabase1x2CPU4GB50GB Price `yaml:"managed_database_1x2xCPU-4GB-50GB"`
|
|
ManagedDatabase2x2CPU4GB100GB Price `yaml:"managed_database_2x2xCPU-4GB-100GB"`
|
|
ManagedDatabase2x2CPU4GB50GB Price `yaml:"managed_database_2x2xCPU-4GB-50GB"`
|
|
ManagedDatabase2x4CPU8GB100GB Price `yaml:"managed_database_2x4xCPU-8GB-100GB"`
|
|
ManagedDatabase2x4CPU8GB50GB Price `yaml:"managed_database_2x4xCPU-8GB-50GB"`
|
|
ManagedDatabase2x6CPU16GB100GB Price `yaml:"managed_database_2x6xCPU-16GB-100GB"`
|
|
ManagedDatabase2x6CPU16GB50GB Price `yaml:"managed_database_2x6xCPU-16GB-250GB"`
|
|
ManagedDatabase2x8CPU32GB100GB Price `yaml:"managed_database_2x8xCPU-32GB-100GB"`
|
|
ManagedDatabase2x8CPU22GB250GB Price `yaml:"managed_database_2x8xCPU-32GB-250GB"`
|
|
ManagedDatabase3x2CPU4GB100GB Price `yaml:"managed_database_3x2xCPU-4GB-100GB"`
|
|
ManagedDatabase3x2CPU4GB200GB Price `yaml:"managed_database_3x2xCPU-4GB-200GB"`
|
|
ManagedDatabase3x4CPU8GB100GB Price `yaml:"managed_database_3x4xCPU-8GB-100GB"`
|
|
ManagedDatabase3x4CPU8GB200GB Price `yaml:"managed_database_3x4xCPU-8GB-200GB"`
|
|
ManagedDatabase3x6CPU16GB200GB Price `yaml:"managed_database_3x6xCPU-16GB-200GB"`
|
|
ManagedDatabase3x6CPU16GB500GB Price `yaml:"managed_database_3x6xCPU-16GB-500GB"`
|
|
ManagedDatabase3x8CPU32GB200GB Price `yaml:"managed_database_3x8xCPU-32GB-200GB"`
|
|
ManagedDatabase3x8CPU32GB500GB Price `yaml:"managed_database_3x8xCPU-32GB-500GB"`
|
|
NetworkPrivateVLAN Price `yaml:"network_private_vlan"`
|
|
ObjectStorage1TB Price `yaml:"object_storage_1TB"`
|
|
ObjectStorage250GB Price `yaml:"object_storage_250GB"`
|
|
ObjectStorage500GB Price `yaml:"object_storage_500GB"`
|
|
PublicIPv4BandwidthIn Price `yaml:"public_ipv4_bandwidth_in"`
|
|
PublicIPv4BandwidthOut Price `yaml:"public_ipv4_bandwidth_out"`
|
|
PublicIPv6BandwidthIn Price `yaml:"public_ipv6_bandwidth_in"`
|
|
PublicIPv6BandwidthOut Price `yaml:"public_ipv6_bandwidth_out"`
|
|
ServerCore Price `yaml:"server_core"`
|
|
ServerMemory Price `yaml:"server_memory"`
|
|
ServerPlan6xCPU8GB Price `yaml:"server_plan_6xCPU-8GB"`
|
|
ServerPlan12xCPU48GB Price `yaml:"server_plan_12xCPU-48GB"`
|
|
ServerPlan16xCPU64GB Price `yaml:"server_plan_16xCPU-64GB"`
|
|
ServerPlan1xCPU1GB Price `yaml:"server_plan_1xCPU-1GB"`
|
|
ServerPlan1xCPU2GB Price `yaml:"server_plan_1xCPU-2GB"`
|
|
ServerPlan20xCPU128GB Price `yaml:"server_plan_20xCPU-128GB"`
|
|
ServerPlan20xCPU96GB Price `yaml:"server_plan_20xCPU-96GB"`
|
|
ServerPlan2xCPU4GB Price `yaml:"server_plan_2xCPU-4GB"`
|
|
ServerPlan4xCPU8GB Price `yaml:"server_plan_4xCPU-8GB"`
|
|
ServerPlan6xCPU16GB Price `yaml:"server_plan_6xCPU-16GB"`
|
|
ServerPlan8xCPU32GB Price `yaml:"server_plan_8xCPU-32GB"`
|
|
SimpleBackupDailies12xCPU48GB Price `yaml:"simple_backup_dailies_12xCPU-48GB"`
|
|
SimpleBackupDailies16xCPU64GB Price `yaml:"simple_backup_dailies_16xCPU-64GB"`
|
|
SimpleBackupDailiesx1CPU1GB Price `yaml:"simple_backup_dailies_1xCPU-1GB"`
|
|
SimpleBackupDailies1xCPU2GB Price `yaml:"simple_backup_dailies_1xCPU-2GB"`
|
|
SimpleBackupDailies20xCPU128GB Price `yaml:"simple_backup_dailies_20xCPU-128GB"`
|
|
SimpleBackupDailies20xCPU96GB Price `yaml:"simple_backup_dailies_20xCPU-96GB"`
|
|
SimpleBackupDailies2xCPU4GB Price `yaml:"simple_backup_dailies_2xCPU-4GB"`
|
|
SimpleBackupDailies4xCPU8GB Price `yaml:"simple_backup_dailies_4xCPU-8GB"`
|
|
SimpleBackupDailies6xCPU16GB Price `yaml:"simple_backup_dailies_6xCPU-16GB"`
|
|
SimpleBackupDailies8xCPU32GB Price `yaml:"simple_backup_dailies_8xCPU-32GB"`
|
|
SimpleBackupExtraDailies Price `yaml:"simple_backup_extra_dailies"`
|
|
SimpleBackupExtraMontlies Price `yaml:"simple_backup_extra_monthlies"`
|
|
SimpleBackupExtraWeeklies Price `yaml:"simple_backup_extra_weeklies"`
|
|
SimpleBackupMonthlies12xCPU48GB Price `yaml:"simple_backup_monthlies_12xCPU-48GB"`
|
|
SimpleBackupMonthlies16xCPU64GB Price `yaml:"simple_backup_monthlies_16xCPU-64GB"`
|
|
SimpleBackupMonthlies1xCPU1GB Price `yaml:"simple_backup_monthlies_1xCPU-1GB"`
|
|
SimpleBackupMonthlies1xCPU2GB Price `yaml:"simple_backup_monthlies_1xCPU-2GB"`
|
|
SimpleBackupMonthlies20xCPU128GB Price `yaml:"simple_backup_monthlies_20xCPU-128GB"`
|
|
SimpleBackupMonthlies20xCPU96GB Price `yaml:"simple_backup_monthlies_20xCPU-96GB"`
|
|
SimpleBackupMonthlies2xCPU4GB Price `yaml:"simple_backup_monthlies_2xCPU-4GB"`
|
|
SimpleBackupMonthlies4xCPU8GB Price `yaml:"simple_backup_monthlies_4xCPU-8GB"`
|
|
SimpleBackupMonthlies6xCPU16GB Price `yaml:"simple_backup_monthlies_6xCPU-16GB"`
|
|
SimpleBackupMonthlies8xCPU32GB Price `yaml:"simple_backup_monthlies_8xCPU-32GB"`
|
|
SimpleBackupWeeklies12xCPU48GB Price `yaml:"simple_backup_weeklies_12xCPU-48GB"`
|
|
SimpleBackupWeeklies16xCPU64GB Price `yaml:"simple_backup_weeklies_16xCPU-64GB"`
|
|
SimpleBackupWeeklies1xCPU1GB Price `yaml:"simple_backup_weeklies_1xCPU-1GB"`
|
|
SimpleBackupWeeklies1xCPU2GB Price `yaml:"simple_backup_weeklies_1xCPU-2GB"`
|
|
SimpleBackupWeeklies20xCPU128GB Price `yaml:"simple_backup_weeklies_20xCPU-128GB"`
|
|
SimpleBackupWeeklies20xCPU96GB Price `yaml:"simple_backup_weeklies_20xCPU-96GB"`
|
|
SimpleBackupWeeklies2xCPU4GB Price `yaml:"simple_backup_weeklies_2xCPU-4GB"`
|
|
SimpleBackupWeeklies4xCPU8GB Price `yaml:"simple_backup_weeklies_4xCPU-8GB"`
|
|
SimpleBackupWeeklies6xCPU16GB Price `yaml:"simple_backup_weeklies_6xCPU-16GB"`
|
|
SimpleBackupWeeklies8xCPU32GB Price `yaml:"simple_backup_weeklies_8xCPU-32GB"`
|
|
StorageHDD Price `yaml:"storage_hdd"`
|
|
StorageBackup Price `yaml:"storage_backup"`
|
|
StorageMaxIOPS Price `yaml:"storage_maxiops"`
|
|
StorageTemplate Price `yaml:"storage_template"`
|
|
}
|
|
|
|
func (m *InfoServer) MarshalJSON() ([]byte, error) {
|
|
// meta := `"Id":` + strconv.Itoa(m.Meta.Id)
|
|
info, err_info := json.Marshal(m.info)
|
|
if err_info != nil {
|
|
return nil, err_info
|
|
}
|
|
price, err_price := json.Marshal(m.price)
|
|
if err_price != nil {
|
|
return nil, err_price
|
|
}
|
|
// fmt.Printf("price %s \n", price)
|
|
// Stitching it all together
|
|
// return []byte(`{` + meta + `,"Contents":` + string(cont) + `}`), nil
|
|
return []byte(`{"info":` + string(info) + `,"price":` + string(price) + `}`), nil
|
|
}
|
|
//func (s *InfoServer) UnmarshalJSON(b []byte) error {
|
|
// type serverWrapper struct {
|
|
// PriceZones []PriceZone `json:"zone"`
|
|
// }
|
|
|
|
// v := struct {
|
|
// PriceZones serverWrapper `json:"prices"`
|
|
// }{}
|
|
// err := json.Unmarshal(b, &v)
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
|
|
// s.PriceZones = v.PriceZones.PriceZones
|
|
|
|
// return nil
|
|
// }
|
|
|
|
func getDataPrices() (*DataPrices, error) {
|
|
dataPrices := &DataPrices{}
|
|
if len(os.Getenv("UPCLOUD_PRICES")) == 0 {
|
|
return dataPrices,nil
|
|
}
|
|
file, err := os.Open(os.Getenv("UPCLOUD_PRICES"))
|
|
if err != nil {
|
|
return dataPrices,err
|
|
}
|
|
defer file.Close()
|
|
|
|
// Init new YAML decode
|
|
d := yaml.NewDecoder(file)
|
|
// Start YAML decoding from file
|
|
if err := d.Decode(&dataPrices); err != nil {
|
|
return dataPrices,err
|
|
}
|
|
// fmt.Printf("Loaded prices: %#v\n", dataPrices)
|
|
return dataPrices,nil
|
|
}
|
|
// NewDataConfig returns a new decoded DataConfig struct
|
|
func NewDataConfig(runFlags RunFlags) (*DataConfig, error) {
|
|
// Load config structure from YAML
|
|
dataConfig := &DataConfig{}
|
|
// fmt.Printf("Loaded config: %#v\n", runFlags.dataCfgPath)
|
|
/*
|
|
if runFlags.encdr == TECODER.cmd || runFlags.encdr == TECODER.abbrv {
|
|
// content, err := ioutil.ReadFile(runFlags.dataCfgPath)
|
|
// if err != nil {
|
|
// log.Fatal(err)
|
|
// return nil,err
|
|
// }
|
|
//out, err := exec.Command(CODER,ARGS_DECODER,string(content)).Output()
|
|
out, err := exec.Command(TECODER.cmd,TECODER.fdecoder,runFlags.dataCfgPath).Output()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Unable to decode %s error: %#v\n ",runFlags.dataCfgPath,err)
|
|
return nil, err
|
|
}
|
|
err = yaml.Unmarshal(out,&dataConfig)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
/*
|
|
ddataConfig := &DDataConfig{}
|
|
bytes, err := ioutil.ReadFile(runFlags.dataCfgPath)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
err = dhall.Unmarshal(bytes, &ddataConfig)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
fmt.Printf("Loaded config: %#v\n", ddataConfig)
|
|
*/
|
|
// Open config file
|
|
file, err := os.Open(runFlags.dataCfgPath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer file.Close()
|
|
|
|
// Init new YAML decode
|
|
d := yaml.NewDecoder(file)
|
|
// Start YAML decoding from file
|
|
if err := d.Decode(&dataConfig); err != nil {
|
|
return nil, err
|
|
}
|
|
// fmt.Printf("Loaded config: %#v\n", dataConfig)
|
|
// }
|
|
return dataConfig, nil
|
|
}
|
|
func getAuthKeysData(path string) string {
|
|
pathAuth := fmt.Sprintf("%s/%s", path,SSH_KEY_PATH)
|
|
// fmt.Fprintf(os.Stdout, "%#v\n",pathAuth)
|
|
if _, err := os.Stat(pathAuth); err == nil {
|
|
file, err := os.Open(pathAuth)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
defer file.Close()
|
|
}
|
|
return pathAuth
|
|
}
|
|
func loadLoginUserKeys(runFlags RunFlags) request.SSHKeySlice {
|
|
dirAuth := filepath.Dir(runFlags.dataCfgPath)
|
|
keysPath := getAuthKeysData(dirAuth)
|
|
for i := 0; i < 3; i++ {
|
|
if keysPath == "" {
|
|
break
|
|
}
|
|
dirAuth = filepath.Dir(dirAuth)
|
|
keysPath = getAuthKeysData(dirAuth)
|
|
}
|
|
if keysPath == "" {
|
|
return nil
|
|
}
|
|
file, err := os.Open(keysPath)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
defer file.Close()
|
|
// fmt.Fprintf(os.Stdout, "%#v\n",keysPath)
|
|
var sshKeys request.SSHKeySlice
|
|
d := yaml.NewDecoder(file)
|
|
if err := d.Decode(&sshKeys); err != nil {
|
|
fmt.Fprintf(os.Stdout, "%#v\n",err)
|
|
return nil
|
|
}
|
|
// fmt.Fprintf(os.Stdout, "%#v\n",sshKeys)
|
|
return sshKeys
|
|
}
|
|
|
|
func init() {
|
|
rand.Seed(time.Now().Unix())
|
|
}
|
|
|
|
func main() {
|
|
if len(os.Args) > 1 && (os.Args[1] == "-v" || os.Args[1] == "version") {
|
|
fmt.Fprintf(os.Stdout, "{...} UpClapi version:%s\n",VERSION)
|
|
os.Exit(0)
|
|
}
|
|
if len(os.Args) > 1 || len(os.Getenv("UPCLAPI_COMMAND")) > 0 {
|
|
os.Exit(run())
|
|
} else {
|
|
fmt.Fprintln(os.Stderr, "Use --help to see options")
|
|
}
|
|
}
|
|
|
|
func hasID(id string) bool {
|
|
if len(id) == 0 {
|
|
fmt.Fprintln(os.Stderr, "ID must be specified")
|
|
os.Exit(2)
|
|
}
|
|
return true
|
|
}
|
|
|
|
func loadDataConfig(runFlags RunFlags) (*DataConfig, error) {
|
|
// datacfg := &DataConfig{}
|
|
datacfg, err := NewDataConfig(runFlags)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
return datacfg, err
|
|
}
|
|
return datacfg, nil
|
|
}
|
|
|
|
// ValidateDataPath just makes sure, that the path provided is a file,
|
|
// that can be read
|
|
func ValidateDataPath(path string) error {
|
|
s, err := os.Stat(path); os.IsNotExist(err)
|
|
if err != nil {
|
|
return fmt.Errorf("'%s' config file not found", path)
|
|
}
|
|
if s.IsDir() {
|
|
return fmt.Errorf("'%s' is a directory, not a normal file", path)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ParseFlags will create and parse the CLI flags
|
|
// and return the path to be used elsewhere
|
|
func ParseFlags() (RunFlags,error) {
|
|
// target := flag.Arg(1)
|
|
// fmt.Printf("%+v ...\n",target) // Print with Variable Name
|
|
// String that contains the configured configuration path
|
|
runFlags := RunFlags {
|
|
command: os.Getenv("UPCLAPI_COMMAND"),
|
|
dataCfgPath: os.Getenv("UPCLAPI_DATACFG"),
|
|
id: os.Getenv("UPCLAPI_ID"),
|
|
runCmd: os.Getenv("UPCLAPI_RUNCMD"),
|
|
encdr: os.Getenv("UPCLAPI_ENCODER"),
|
|
out: os.Getenv("UPCLAPI_OUT"),
|
|
target: os.Getenv("UPCLAPI_TARGET"),
|
|
sid: os.Getenv("UPCLAPI_SID"),
|
|
}
|
|
if runFlags.command == "" {
|
|
runFlags.command = DFLT_COMMAND
|
|
}
|
|
if runFlags.dataCfgPath == "" {
|
|
runFlags.dataCfgPath = DATA_CFG
|
|
}
|
|
// var command string
|
|
// var dataCfgPath string
|
|
// var id string
|
|
// var cmd string
|
|
// var encdr string
|
|
|
|
// Set up a CLI flag called "-config" to allow users
|
|
// to supply the configuration file
|
|
commandInfo := fmt.Sprintf("command to run [\n%s\n%s\n%s\n%s\n%s\n%s\n]",
|
|
"createserver, infoserver, restartserver, startserver, stopserver, modifyserver, deleteserver,",
|
|
"infofloatip, movefloatip, modifyip,",
|
|
"infotags, addtags, deletetags (use -t keep to keep storages)",
|
|
"liststorages, fixstorage (-t size | part0 | part1 | final), deletestorage, modifystorage, createstorageimage (-t title),",
|
|
"inventory, pubhosts, prvhosts",
|
|
"runssh, runcmd")
|
|
flag.StringVar(&runFlags.command, "c", runFlags.command, commandInfo)
|
|
flag.StringVar(&runFlags.dataCfgPath, "f", runFlags.dataCfgPath, "path to data file")
|
|
flag.StringVar(&runFlags.id, "id", runFlags.id, "resource name or uuid")
|
|
flag.StringVar(&runFlags.runCmd, "cmd", runFlags.runCmd, "run [ssh] command")
|
|
flag.StringVar(&runFlags.encdr, "kdr", runFlags.encdr, "use coder ")
|
|
flag.StringVar(&runFlags.out, "o", runFlags.out, "output format (attached for infofloatip)")
|
|
flag.StringVar(&runFlags.target, "t", runFlags.target, "target item for command ")
|
|
flag.StringVar(&runFlags.sid, "sid", runFlags.sid, "ssh id for ssh commands (or defaul id_rsa)")
|
|
flag.BoolVar(&runFlags.version,"v",false,"version")
|
|
|
|
// Actually parse the flags
|
|
flag.Parse()
|
|
|
|
if len(runFlags.id) == 0 {
|
|
if _, err := os.Stat(runFlags.dataCfgPath); os.IsNotExist(err) {
|
|
msg := fmt.Errorf("'%s' config file not found", DATA_CFG)
|
|
if len(os.Getenv("UPCLAPI_DATACFG")) == 0 {
|
|
err = fmt.Errorf("%s\nUPCLAPI_DATACFG environment value not set\n",msg)
|
|
return runFlags,err
|
|
}
|
|
}
|
|
// fmt.Printf("dataCfgPath: %+v\n",dataCfgPath) // Print with Variable Name
|
|
// Validate the path first
|
|
// if err := ValidateDataPath(runFlags.dataCfgPath); err != nil {
|
|
// return runFlags,err
|
|
// }
|
|
} else {
|
|
if runFlags.command != os.Getenv("UPCLAPI_COMMAND") && runFlags.id == os.Getenv("UPCLAPI_ID") {
|
|
fmt.Fprintf(os.Stdout, "Warning: Resource ID is set in UPCLAPI_ID enviroment to: %s\n",runFlags.id)
|
|
}
|
|
}
|
|
// Return the configuration path
|
|
return runFlags,nil
|
|
}
|