func serversRetrieve(client *cm15.Api, serversLocator string) []Server {
serverLocator := client.ServerLocator(serversLocator)
servers, err := serverLocator.Index(rsapi.ApiParams{"view": "instance_detail"})
if err != nil {
fmt.Println("failed to find servers: %s", err)
}
var serverList = make([]Server, len(servers))
for i := 0; i < len(servers); i++ {
nextInstanceLocator := extractHref(servers[i].Links, "next_instance")
currentInstanceLocator := extractHref(servers[i].Links, "current_instance")
s := Server{Name: servers[i].Name, Locked: false}
nextInstance := instanceRetrieve(client, nextInstanceLocator)
templateLocator := extractHref(nextInstance.Links, "server_template")
template := templateRetrieve(client, templateLocator)
s.Template = template.Name
templates[templateLocator] = template.Name
alertSpecs := alertsRetrieve(client, extractHref(servers[i].Links, "alert_specs"))
alerts = append(alerts, alertSpecs...)
s.NextInstance = inputsRetrieve(client, extractHref(nextInstance.Links, "inputs"))
if currentInstanceLocator != "" {
templateLocator := instanceRetrieve(client, currentInstanceLocator)
s.CurrentInstance = inputsRetrieve(client, extractHref(templateLocator.Links, "inputs"))
s.Locked = templateLocator.Locked
s.Volumes = extractVolumesInfo(client, currentInstanceLocator+"/volume_attachments")
if len(s.Volumes) == 0 {
s.Volumes = nil
}
}
serverList[i] = s
}
return serverList
}
// Makes a GET call on the given server array and returns all its current instances.
func serverArray(client *cm15.Api, name string) []*cm15.Instance {
serverArrayLocator := client.ServerArrayLocator("/api/server_arrays")
serverArrays, err := serverArrayLocator.Index(rsapi.ApiParams{"view": "default", "filter": []string{"name==" + name}})
if err != nil {
fail("Failed to retrieve server array: %v\n", err.Error())
}
if len(serverArrays) == 0 {
fail("Could not find server array with name: %v\n", name)
} else if len(serverArrays) != 1 {
fail("More than one server array found with name: %v\n", name)
}
array := serverArrays[0]
var instancesHref string
for _, l := range array.Links {
if l["rel"] == "current_instances" {
instancesHref = l["href"]
break
}
}
instanceLocator := client.InstanceLocator(instancesHref)
instances, err := instanceLocator.Index(rsapi.ApiParams{})
if err != nil {
fail("Failed to retrieve current instances of the server array: %v\n", err.Error())
}
if len(instances) == 0 {
fail("No instances found in server array: %v\n", name)
}
return instances
}
func instanceRetrieve(client *cm15.Api, instanceLocator string) *cm15.Instance {
locator := client.InstanceLocator(instanceLocator)
instance, err := locator.Show(rsapi.ApiParams{})
if err != nil {
fmt.Println("failed to find instance: %s", err)
}
return instance
}
func runnableBindingsRetrieve(client *cm15.Api, runnableBindingLocator string) []*cm15.RunnableBinding {
locator := client.RunnableBindingLocator(runnableBindingLocator)
runnableBindings, err := locator.Index(rsapi.ApiParams{})
if err != nil {
fmt.Printf("failed to find runnable bindings: %s", err)
}
return runnableBindings
}
func cookbookAttachmentsRetrieve(client *cm15.Api, cookbookAttachmentsLocator string) []*cm15.CookbookAttachment {
locator := client.CookbookAttachmentLocator(cookbookAttachmentsLocator)
cookbookAttachments, err := locator.Index(rsapi.ApiParams{})
if err != nil {
fmt.Println("failed to find cookbook attachments: %s", err)
}
return cookbookAttachments
}
func alertsRetrieve(client *cm15.Api, alertsLocator string) []*cm15.AlertSpec {
locator := client.AlertSpecLocator(alertsLocator)
alertSpec, err := locator.Index(rsapi.ApiParams{"with_inherited": "false"})
if err != nil {
fmt.Println("failed to find alertspec: %s", err)
}
return alertSpec
}
func volumeRetrieve(client *cm15.Api, volumeLocator string) *cm15.Volume {
locator := client.VolumeLocator(volumeLocator)
volume, err := locator.Show(rsapi.ApiParams{})
if err != nil {
fmt.Println("failed to find volume: %s", err)
}
return volume
}
func volumeAttachmentsRetrive(client *cm15.Api, volumeAttachmentsLocator string) []*cm15.VolumeAttachment {
locator := client.VolumeAttachmentLocator(volumeAttachmentsLocator)
volumeAttachments, err := locator.Index(rsapi.ApiParams{})
if err != nil {
fmt.Println("failed to find volume attachments: %s", err)
}
return volumeAttachments
}
func cookbooksRetrieve(client *cm15.Api, cookbookLocator string) *cm15.Cookbook {
locator := client.CookbookLocator(cookbookLocator)
cookbook, err := locator.Show(rsapi.ApiParams{})
if err != nil {
fmt.Println("failed to find cookbook: %s", err)
}
return cookbook
}
func templateRetrieve(client *cm15.Api, templateLocator string) *cm15.ServerTemplate {
locator := client.ServerTemplateLocator(templateLocator)
template, err := locator.Show(rsapi.ApiParams{})
if err != nil {
fmt.Println("failed to find server template: %s", err)
}
return template
}
func inputsRetrieve(client *cm15.Api, inputsLocator string) []Input {
locator := client.InputLocator(inputsLocator)
inputs, err := locator.Index(rsapi.ApiParams{})
if err != nil {
fmt.Println("failed to find inputs: %s", err)
}
var inputsRetrieved = make([]Input, len(inputs))
for index, input := range inputs {
inputsRetrieved[index] = Input{Name: input.Name, Value: input.Value}
}
return inputsRetrieved
}
// Makes a GET call on the given server and returns the current instance of the server.
func server(client *cm15.Api, name string) *cm15.Instance {
serverLocator := client.ServerLocator("/api/servers")
servers, err := serverLocator.Index(rsapi.ApiParams{"view": "instance_detail", "filter": []string{"name==" + name}})
if err != nil {
fail("Failed to retrieve server: %v\n", err.Error())
}
if len(servers) == 0 {
fail("Could not find server with name: %v\n", name)
} else if len(servers) != 1 {
fail("More than one server found with name: %v\n", name)
}
return servers[0].CurrentInstance
}
// Make an API call and fetch the audit entries matching specified criteria
func fetchAuditEntries(client *cm15.Api, filterEmail string) ([]*cm15.AuditEntry, error) {
auditLocator := client.AuditEntryLocator("/api/audit_entries")
var apiParams = rsapi.ApiParams{"filter": []string{"user_email==" + filterEmail}}
auditEntries, err := auditLocator.Index(
tomorrow(), // End date
"100", // Limit
yesterday(), // Start date
apiParams,
)
if err != nil {
return auditEntries, err
}
return auditEntries, nil
}
func extractRightScript(client *cm15.Api, rightscriptLocator string) RightScript {
var rs RightScript
locator := client.RightScriptLocator(rightscriptLocator)
rightScript, err := locator.Show()
if err != nil {
fmt.Println("failed to find right script: %s", err)
} else {
rs = RightScript{
Name: rightScript.Name,
Revision: rightScript.Revision,
UpdatedAt: rightScript.UpdatedAt,
}
}
return rs
}
func serverArraysRetrieve(client *cm15.Api, serverArraysLocator string) []ServerArray {
arrayLocator := client.ServerArrayLocator(serverArraysLocator)
serverArrays, err := arrayLocator.Index(rsapi.ApiParams{"view": "instance_detail"})
if err != nil {
fmt.Println("failed to find servers: %s", err)
}
var serverArrayList = make([]ServerArray, len(serverArrays))
for i := 0; i < len(serverArrays); i++ {
nextInstanceLocator := extractHref(serverArrays[i].Links, "next_instance")
currentInstancesLocator := extractHref(serverArrays[i].Links, "current_instances")
var volumes []Volume
sa := ServerArray{Name: serverArrays[i].Name, Locked: false}
nextInstance := instanceRetrieve(client, nextInstanceLocator)
templateLocator := extractHref(nextInstance.Links, "server_template")
template := templateRetrieve(client, templateLocator)
sa.Template = template.Name
templates[templateLocator] = template.Name
alertSpecs := alertsRetrieve(client, extractHref(serverArrays[i].Links, "alert_specs"))
alerts = append(alerts, alertSpecs...)
sa.NextInstance = inputsRetrieve(client, extractHref(nextInstance.Links, "inputs"))
instanceLocator := client.InstanceLocator(currentInstancesLocator)
instances, err := instanceLocator.Index(rsapi.ApiParams{})
if err != nil {
fmt.Println("failed to find instances: %s", err)
}
if len(instances) != 0 {
currentInstanceLocator := extractHref(instances[0].Links, "self")
currentInstance := instanceRetrieve(client, currentInstanceLocator)
sa.CurrentInstance = inputsRetrieve(client, extractHref(currentInstance.Links, "inputs"))
sa.Locked = currentInstance.Locked
}
for _, instance := range instances {
v := extractVolumesInfo(client, extractHref(instance.Links, "self")+"/volume_attachments")
volumes = append(volumes, v...)
}
if len(volumes) != 0 {
sa.Volumes = volumes
}
serverArrayList[i] = sa
}
return serverArrayList
}