func main() { // 1. Retrieve login and endpoint information email := flag.String("e", "", "Login email") pwd := flag.String("p", "", "Login password") host := flag.String("h", "us-3.rightscale.com", "RightScale API host") conf := flag.String("c", "", "Configuration file") insecure := flag.Bool("insecure", false, "Use HTTP instead of HTTPS - used for testing") flag.Parse() if *email == "" { fail("Login email required") } if *pwd == "" { fail("Login password required") } if *host == "" { fail("Host required") } if *conf == "" { usr, _ := user.Current() *conf = usr.HomeDir + "/.rsssh" } // Read the configuration content, err := ioutil.ReadFile(*conf) if err != nil { fail("Failed to read configuration file: %v\n", err.Error()) } var config Config err = json.Unmarshal(content, &config) if err != nil { fail("Failed to Unmarshal configuration file: %v\n", err.Error()) } if config.OutputFile == "" { config.OutputFile = "rightscale_aliases" } if config.SSHUser == "" { config.SSHUser = "******" } var sshConfig = make([]SSHConfig, 0) for envName, envDetail := range config.Environments { if envDetail.Account == 0 { fail("No account specified for environment: %v\n", envName) } // Create a new client for every environment because they can be in different accounts. auth := rsapi.NewBasicAuthenticator(*email, *pwd, envDetail.Account) client := cm15.New(*host, auth) if *insecure { httpclient.Insecure = true } if err := client.CanAuthenticate(); err != nil { fail("invalid credentials: %s", err) } fetchDetails(client, envName, envDetail, &sshConfig) } aliases := buildAliases(sshConfig, config.SSHOptions, config.SSHUser) writeFile(config.OutputFile, []byte(aliases), 0644) }
func main() { // 1. Retrieve login and endpoint information email := flag.String("e", "", "Login email") pwd := flag.String("p", "", "Login password") account := flag.Int("a", 0, "Account id") host := flag.String("h", "us-3.rightscale.com", "RightScale API host") insecure := flag.Bool("insecure", false, "Bypass certificate check, used for testing") cat := flag.String("cat", "", "Path to CAT file") flag.Parse() if *email == "" { fail("Login email required") } if *pwd == "" { fail("Login password required") } if *account == 0 { fail("Account id required") } if *host == "" { fail("Host required") } if *insecure { httpclient.NoCertCheck = true } if *cat == "" { fail("Path to CAT required") } if _, err := os.Stat(*cat); err != nil { fail("Can't find file %s", *cat) } // 2. Setup client using basic auth auth := rsapi.NewBasicAuthenticator(*email, *pwd, *account) ssAuth := rsapi.NewSSAuthenticator(auth, *account) client := ssd.New(*host, ssAuth) if err := client.CanAuthenticate(); err != nil { fail("invalid credentials: %s", err) } // 3. Make execution index call using expanded view file, err := os.Open(*cat) if err != nil { fail("Could not open %s", *cat) } name := filepath.Base(*cat) l := client.TemplateLocator(fmt.Sprintf("/designer/collections/%d/templates", *account)) upload := rsapi.FileUpload{Name: name, Filename: name, Reader: file} t, err := l.Create(&upload) if err != nil { fail("failed to create template: %s", err) } created, err := t.Show(rsapi.ApiParams{}) if err != nil { fail("failed to retrieve created template: %s", err) } fmt.Fprintf(osStdout, "%s created at %s by %s\n", created.Name, created.Timestamps.CreatedAt, created.CreatedBy.Name) }
func main() { // 1. Retrieve login and endpoint information email := flag.String("e", "", "Login email") pwd := flag.String("p", "", "Login password") account := flag.Int("a", 0, "Account id") host := flag.String("h", "us-3.rightscale.com", "RightScale API host") filterEmail := flag.String("f", "", "Audit user email for filtering audit entries") flag.Parse() if *email == "" { fail("Login email required") } if *pwd == "" { fail("Login password required") } if *account == 0 { fail("Account id required") } if *host == "" { fail("Host required") } if *filterEmail == "" { *filterEmail = *email } // 2. Setup client using basic auth auth := rsapi.NewBasicAuthenticator(*email, *pwd, *account) client := cm15.New(*host, auth) if err := client.CanAuthenticate(); err != nil { fail("invalid credentials: %s", err) } ticker := time.NewTicker(time.Second) // 3. Make an initial API call and retrieve the audit entries entries, err := fetchAuditEntries(client, *filterEmail) oldEntries := entries if err != nil { fail("Failed to retrieve audit entries: %v\n", err.Error()) } printAudits(entries) // 4. Periodically retrieve audit entries and print the new ones for { select { case <-ticker.C: entries, err := fetchAuditEntries(client, *filterEmail) if err != nil { fail("Failed to retrieve audit entries: %v\n", err.Error()) } printAudits(extractUnique(oldEntries, entries)) oldEntries = entries } } }
func main() { // 1. Retrieve login and endpoint information email := flag.String("e", "", "Login email") pwd := flag.String("p", "", "Login password") account := flag.Int("a", 0, "Account id") host := flag.String("h", "us-3.rightscale.com", "RightScale API host") insecure := flag.Bool("insecure", false, "Use HTTP instead of HTTPS - used for testing") flag.Parse() if *email == "" { fail("Login email required") } if *pwd == "" { fail("Login password required") } if *account == 0 { fail("Account id required") } if *host == "" { fail("Host required") } // 2. Setup client using basic auth auth := rsapi.NewBasicAuthenticator(*email, *pwd, *account) ssAuth := rsapi.NewSSAuthenticator(auth, *account) client := ssm.New(*host, ssAuth) if *insecure { httpclient.Insecure = true } if err := client.CanAuthenticate(); err != nil { fail("invalid credentials: %s", err) } // 3. Make execution index call using expanded view l := client.ExecutionLocator(fmt.Sprintf("/projects/%d/executions", *account)) execs, err := l.Index(rsapi.APIParams{}) if err != nil { fail("failed to list executions: %s", err) } sort.Sort(ByName(execs)) // 4. Print executions launch from w := new(tabwriter.Writer) w.Init(osStdout, 5, 0, 1, ' ', 0) fmt.Fprintln(w, "Name\tState\tBy\tLink") fmt.Fprintln(w, "-----\t-----\t-----\t-----") for _, e := range execs { link := fmt.Sprintf("https://%s/manager/#/exe/%s", ss.HostFromLogin(client.Host), e.Id) fmt.Fprintln(w, fmt.Sprintf("%s\t%s\t%s\t%s", e.Name, e.Status, e.CreatedBy.Email, link)) } w.Flush() }
func main() { // 1. Retrieve login and endpoint information email := flag.String("e", "", "Login email") pwd := flag.String("p", "", "Login password") account := flag.Int("a", 0, "Account id") host := flag.String("h", "us-3.rightscale.com", "RightScale API host") insecure := flag.Bool("insecure", false, "Use HTTP instead of HTTPS - used for testing") flag.Parse() if *email == "" { fail("Login email required") } if *pwd == "" { fail("Login password required") } if *account == 0 { fail("Account id required") } if *host == "" { fail("Host required") } // 2. Setup client using basic auth auth := rsapi.NewBasicAuthenticator(*email, *pwd, *account) client := cm15.New(*host, auth) if *insecure { httpclient.Insecure = true } if err := client.CanAuthenticate(); err != nil { fail("invalid credentials: %s", err) } // 3. Make cloud index call using extended view l := client.CloudLocator("/api/clouds") clouds, err := l.Index(rsapi.APIParams{"view": "extended"}) if err != nil { fail("failed to list clouds: %s", err) } // 4. Print cloud capabilities for i, c := range clouds { fmt.Fprintln(osStdout, "") fmt.Fprintf(osStdout, "%d. %s\n", i+1, c.Name) for _, ca := range c.Capabilities { fmt.Fprintf(osStdout, "%s: %v\n", ca["name"], ca["value"]) } } }
func main() { // Retrieve login and endpoint information email := flag.String("e", "", "Login email") pwd := flag.String("p", "", "Login password") account := flag.Int("a", 0, "Account id") host := flag.String("h", "us-3.rightscale.com", "RightScale API host") deploymentId := flag.String("d", "", "Deployment id") flag.Parse() if *email == "" { fmt.Println("Login email required") } if *pwd == "" { fmt.Println("Login password required") } if *account == 0 { fmt.Println("Account id required") } if *host == "" { fmt.Println("Host required") } if *deploymentId == "" { fmt.Println("Deployment required") } // Setup client using basic auth auth := rsapi.NewBasicAuthenticator(*email, *pwd, *account) client := cm15.New(*host, auth) if err := client.CanAuthenticate(); err != nil { fmt.Println("invalid credentials: %s", err) } // Deployment show deploymentLocator := client.DeploymentLocator("/api/deployments/" + *deploymentId) deployment, err := deploymentLocator.Show(rsapi.ApiParams{}) if err != nil { fmt.Println("failed to find deployment: %s", err) } // Initialize the template maps to store only unique server templates templates = make(map[string]string) serversLocator := extractHref(deployment.Links, "servers") servers := serversRetrieve(client, serversLocator) serverArraysLocator := extractHref(deployment.Links, "server_arrays") serverArrays := serverArraysRetrieve(client, serverArraysLocator) var serverTemplates = make([]ServerTemplate, len(templates)) i := 0 for key, _ := range templates { template := templateRetrieve(client, key) st := ServerTemplate{ Name: template.Name, Revision: template.Revision, } runnableBindings := runnableBindingsRetrieve(client, extractHref(template.Links, "runnable_bindings")) cookbookAttachments := cookbookAttachmentsRetrieve(client, extractHref(template.Links, "cookbook_attachments")) cookbooks := extractCookbooks(client, cookbookAttachments) st.RightScripts, st.Recipes = extractAttachmentsInfo(client, runnableBindings, cookbooks) alertSpecs := alertsRetrieve(client, extractHref(template.Links, "alert_specs")) alerts = append(alerts, alertSpecs...) serverTemplates[i] = st i++ } var alertSpecs = make([]Alert, len(alerts)) for i = 0; i < len(alerts); i++ { alert := Alert{ Name: alerts[i].Name, Escaltion: alerts[i].EscalationName, AlertCondition: fmt.Sprintf("%s.%s %s %s for %d", alerts[i].File, alerts[i].Variable, alerts[i].Condition, alerts[i].Threshold, alerts[i].Duration), Subject: extractHref(alerts[i].Links, "subject"), CreatedAt: alerts[i].CreatedAt, UpdatedAt: alerts[i].UpdatedAt, } alertSpecs[i] = alert } deploymentStruct := Deployment{ Name: deployment.Name, Inputs: inputsRetrieve(client, extractHref(deployment.Links, "inputs")), Servers: servers, ServersNumber: len(servers), ServerArrays: serverArrays, ServerArraysNumber: len(serverArrays), ServerTemplates: serverTemplates, Alerts: alertSpecs, } jsonBody, err := json.MarshalIndent(deploymentStruct, "", " ") if err == nil { fmt.Println(htmlReplace(string(jsonBody))) } }