func subnetSingle(subnet *osSubnets.Subnet) map[string]interface{} {
m := structs.Map(subnet)
tmpMap := make([]map[string]interface{}, len(m["AllocationPools"].([]osSubnets.AllocationPool)))
for i, pool := range m["AllocationPools"].([]osSubnets.AllocationPool) {
tmpMap[i] = structs.Map(pool)
}
m["AllocationPools"] = tmpMap
/*
m["Host Routes"] = m["HostRoutes"]
delete(m, "HostRoutes")
if hostRoutes, ok := m["Host Routes"].([]osSubnets.HostRoute); ok && len(hostRoutes) > 0 {
fmt.Printf("hostRoutes: %+v\n", hostRoutes)
out := []string{"Destination CIDR\tNext Hop"}
for _, route := range hostRoutes {
out = append(out, fmt.Sprintf("%s\t%s", route.DestinationCIDR, route.NextHop))
}
m["Host Routes"] = strings.Join(out, "\n")
} else {
m["Host Routes"] = ""
}
*/
if nameServers, ok := m["DNSNameservers"].([]string); ok && len(nameServers) > 0 {
m["DNSNameservers"] = strings.Join(nameServers, ", ")
} else {
m["DNSNameservers"] = ""
}
return m
}
func portSingle(port *osPorts.Port) map[string]interface{} {
m := structs.Map(port)
tmpMap := make([]map[string]interface{}, len(m["FixedIPs"].([]osPorts.IP)))
for i, pool := range m["FixedIPs"].([]osPorts.IP) {
tmpMap[i] = structs.Map(pool)
}
m["FixedIPs"] = tmpMap
m["Up"] = m["AdminStateUp"]
/*
if fixedIPs, ok := m["FixedIPs"].([]osPorts.IP); ok && len(fixedIPs) > 0 {
out := []string{"Subnet ID\tIP Address"}
for _, ip := range fixedIPs {
out = append(out, fmt.Sprintf("%s\t%s", ip.SubnetID, ip.IPAddress))
}
m["FixedIPs"] = strings.Join(out, "\n")
} else {
m["FixedIPs"] = ""
}
*/
if nameServers, ok := m["SecurityGroups"].([]string); ok && len(nameServers) > 0 {
m["SecurityGroups"] = strings.Join(nameServers, "\n")
} else {
m["SecurityGroups"] = ""
}
return m
}
func securityGroupSingle(securityGroup *osSecurityGroups.SecGroup) map[string]interface{} {
m := structs.Map(securityGroup)
tmpMap := make([]map[string]interface{}, len(m["Rules"].([]osSecurityGroupRules.SecGroupRule)))
for i, pool := range m["Rules"].([]osSecurityGroupRules.SecGroupRule) {
tmpMap[i] = map[string]interface{}{
"ID": pool.ID,
"Direction": pool.Direction,
"EtherType": pool.EtherType,
"Protocol": pool.Protocol,
}
}
m["Rules"] = tmpMap
/*
if rules, ok := m["Rules"].([]osSecurityGroupRules.SecGroupRule); ok && len(rules) > 0 {
out := []string{"ID\tDirection\tEtherType\tProtocol"}
for _, rule := range rules {
out = append(out, fmt.Sprintf("%s\t%s\t%s\t%s", rule.ID, rule.Direction, rule.EtherType, rule.Protocol))
}
m["Rules"] = strings.Join(out, "\n")
} else {
m["Rules"] = ""
}
*/
return m
}
func (command *commandGetSchema) PreCSV(resource *handler.Resource) error {
resource.Result = structs.Map(resource.Result)
resource.FlattenMap("Attributes")
resource.FlattenMap("Properties")
resource.FlattenMap("SupportStatus")
return nil
}
func securityGroupRuleSingle(rule *osSecurityGroupRules.SecGroupRule) map[string]interface{} {
m := structs.Map(rule)
m["SecurityGroupID"] = m["SecGroupID"]
return m
}
func resourceSingle(rawResource interface{}) map[string]interface{} {
m := structs.Map(rawResource)
switch resource := rawResource.(type) {
case *osStackResources.Resource:
if resource.CreationTime.Unix() != -62135596800 {
m["CreationTime"] = resource.CreationTime
} else {
m["CreationTime"] = ""
}
if resource.UpdatedTime.Unix() != -62135596800 {
m["UpdatedTime"] = resource.UpdatedTime
} else {
m["UpdatedTime"] = ""
}
if resource.Links != nil {
links := make([]map[string]interface{}, len(resource.Links))
for i, link := range resource.Links {
links[i] = map[string]interface{}{
"Href": link.Href,
"Rel": link.Rel,
}
}
m["Links"] = links
}
return m
}
return nil
}
func (command *commandListEvents) Execute(resource *handler.Resource) {
params := resource.Params.(*paramsListEvents)
opts := params.opts
stackName := params.stackName
stackID := params.stackID
resourceName := params.resourceName
pager := stackevents.ListResourceEvents(command.Ctx.ServiceClient, stackName, stackID, resourceName, opts)
pages, err := pager.AllPages()
if err != nil {
resource.Err = err
return
}
info, err := osStackEvents.ExtractResourceEvents(pages)
if err != nil {
resource.Err = err
return
}
result := make([]map[string]interface{}, len(info))
for j, event := range info {
result[j] = structs.Map(&event)
result[j]["Time"] = event.Time
}
resource.Result = result
}
func (command *commandList) Execute(resource *handler.Resource) {
opts := resource.Params.(*paramsList).opts
opts.Full = true
containerName := resource.Params.(*paramsList).container
allPages := resource.Params.(*paramsList).allPages
pager := objects.List(command.Ctx.ServiceClient, containerName, opts)
if allPages {
pages, err := pager.AllPages()
if err != nil {
resource.Err = err
return
}
info, err := objects.ExtractInfo(pages)
if err != nil {
resource.Err = err
return
}
result := make([]map[string]interface{}, len(info))
for j, obj := range info {
result[j] = structs.Map(&obj)
}
resource.Result = result
} else {
limit := opts.Limit
err := pager.EachPage(func(page pagination.Page) (bool, error) {
info, err := objects.ExtractInfo(page)
if err != nil {
return false, err
}
result := make([]map[string]interface{}, len(info))
for j, obj := range info {
result[j] = structs.Map(&obj)
}
resource.Result = result
if len(info) >= limit {
return false, nil
}
limit -= len(info)
command.Ctx.Results <- resource
return true, nil
})
if err != nil {
resource.Err = err
return
}
}
}
func (command *commandGet) Execute(resource *handler.Resource) {
buildids, err := buildinfo.Get(command.Ctx.ServiceClient).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = structs.Map(buildids)
}
func (command *commandAbandon) PreCSV(resource *handler.Resource) error {
resource.Result = structs.Map(resource.Result)
resource.FlattenMap("Template")
resource.FlattenMap("Files")
resource.FlattenMap("Environment")
resource.FlattenMap("Resources")
return nil
}
func networkSingle(network *osNetworks.Network) map[string]interface{} {
m := structs.Map(network)
m["Up"] = m["AdminStateUp"]
if subnets, ok := m["Subnets"].([]string); ok {
m["Subnets"] = strings.Join(subnets, ",")
}
return m
}
func volumeSingle(volume *volumes.Volume) map[string]interface{} {
m := structs.Map(volume)
for k, v := range m {
if v == nil {
m[k] = ""
}
}
return m
}
func (command *commandCreate) Execute(resource *handler.Resource) {
params := resource.Params.(*paramsCreate)
volumeAttachment, err := osVolumeAttach.Create(command.Ctx.ServiceClient, params.serverID, params.opts).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = structs.Map(volumeAttachment)
}
func (command *commandGet) Execute(resource *handler.Resource) {
flavorID := resource.Params.(*paramsGet).flavor
flavor, err := flavors.Get(command.Ctx.ServiceClient, flavorID).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = structs.Map(flavor)
}
func (command *commandUpload) Execute(resource *handler.Resource) {
opts := resource.Params.(*paramsUpload).opts
keypair, err := keypairs.Create(command.Ctx.ServiceClient, opts).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = structs.Map(keypair)
}
func (command *commandGet) Execute(resource *handler.Resource) {
imageID := resource.Params.(*paramsGet).image
image, err := images.Get(command.Ctx.ServiceClient, imageID).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = structs.Map(image)
}
func (command *commandGet) Execute(resource *handler.Resource) {
keypairName := resource.Params.(*paramsGet).keypair
keypair, err := keypairs.Get(command.Ctx.ServiceClient, keypairName).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = structs.Map(keypair)
}
func snapshotSingle(snapshot *osSnapshots.Snapshot) map[string]interface{} {
m := structs.Map(snapshot)
if attachments := m["Attachments"].([]string); len(attachments) > 0 {
m["Attachments"] = strings.Join(attachments, ",")
} else {
m["Attachments"] = ""
}
return m
}
func (command *commandValidate) Execute(resource *handler.Resource) {
params := resource.Params.(*paramsValidate).opts
result, err := stacktemplates.Validate(command.Ctx.ServiceClient, params).Extract()
if err != nil {
resource.Err = err
return
}
resource.Result = structs.Map(result)
}
func (command *commandGet) Execute(resource *handler.Resource) {
info, err := buildinfo.Get(command.Ctx.ServiceClient).Extract()
if err != nil {
resource.Err = err
}
result := structs.Map(info)
for k, v := range result {
result[k] = v.(map[string]interface{})["Revision"]
}
resource.Result = result
}
func securityGroupSingle(securityGroup *osSecurityGroups.SecGroup) map[string]interface{} {
m := structs.Map(securityGroup)
if rules, ok := m["Rules"].([]osSecurityGroupRules.SecGroupRule); ok && len(rules) > 0 {
out := []string{"ID\tDirection\tEtherType\tProtocol"}
for _, rule := range rules {
out = append(out, fmt.Sprintf("%s\t%s\t%s\t%s", rule.ID, rule.Direction, rule.EtherType, rule.Protocol))
}
m["Rules"] = strings.Join(out, "\n")
} else {
m["Rules"] = ""
}
return m
}
func (command *commandGet) Execute(resource *handler.Resource) {
containerName := resource.Params.(*paramsGet).container
containerRaw := containers.Get(command.Ctx.ServiceClient, containerName)
containerInfo, err := containerRaw.Extract()
if err != nil {
resource.Err = err
return
}
containerMetadata, err := containerRaw.ExtractMetadata()
if err != nil {
resource.Err = err
return
}
resource.Result = structs.Map(containerInfo)
resource.Result.(map[string]interface{})["Name"] = containerName
resource.Result.(map[string]interface{})["Metadata"] = containerMetadata
}
func (command *commandList) Execute(resource *handler.Resource) {
err := keypairs.List(command.Ctx.ServiceClient).EachPage(func(page pagination.Page) (bool, error) {
info, err := osKeypairs.ExtractKeyPairs(page)
if err != nil {
return false, err
}
result := make([]map[string]interface{}, len(info))
for j, key := range info {
result[j] = structs.Map(key)
}
resource.Result = result
return false, nil
})
if err != nil {
resource.Err = err
return
}
}
func stackList(client *gophercloud.ServiceClient) ([]map[string]interface{}, error) {
pager := osStacks.List(client, nil)
pages, err := pager.AllPages()
if err != nil {
return nil, err
}
info, err := osStacks.ExtractStacks(pages)
if err != nil {
return nil, err
}
result := make([]map[string]interface{}, len(info))
for j, stack := range info {
result[j] = structs.Map(&stack)
result[j]["CreationTime"] = stack.CreationTime
result[j]["UpdatedTime"] = stack.UpdatedTime
}
return result, nil
}
func (command *commandList) Execute(resource *handler.Resource) {
params := resource.Params.(*paramsList)
err := osVolumeAttach.List(command.Ctx.ServiceClient, params.serverID).EachPage(func(page pagination.Page) (bool, error) {
volumeAttachments, err := osVolumeAttach.ExtractVolumeAttachments(page)
if err != nil {
return false, err
}
result := make([]map[string]interface{}, len(volumeAttachments))
for j, volumeAttachment := range volumeAttachments {
result[j] = structs.Map(volumeAttachment)
}
resource.Result = result
return false, nil
})
if err != nil {
resource.Err = err
return
}
}
func serverSingle(rawServer interface{}) map[string]interface{} {
server, ok := rawServer.(*osServers.Server)
if !ok {
return nil
}
m := structs.Map(rawServer)
m["PublicIPv4"] = server.AccessIPv4
m["PublicIPv6"] = server.AccessIPv6
m["PrivateIPv4"] = ""
ips, ok := server.Addresses["private"].([]interface{})
if ok || len(ips) > 0 {
priv, ok := ips[0].(map[string]interface{})
if ok {
m["PrivateIPv4"] = priv["addr"]
}
}
m["Flavor"] = server.Flavor["id"]
m["Image"] = server.Image["id"]
return m
}
func subnetSingle(subnet *osSubnets.Subnet) map[string]interface{} {
m := structs.Map(subnet)
if allocationPools, ok := m["AllocationPools"].([]osSubnets.AllocationPool); ok && len(allocationPools) > 0 {
out := []string{"Start\tEnd"}
for _, pool := range allocationPools {
out = append(out, fmt.Sprintf("%s\t%s", pool.Start, pool.End))
}
m["Allocation Pools"] = strings.Join(out, "\n")
}
/*
m["Host Routes"] = m["HostRoutes"]
delete(m, "HostRoutes")
if hostRoutes, ok := m["Host Routes"].([]osSubnets.HostRoute); ok && len(hostRoutes) > 0 {
fmt.Printf("hostRoutes: %+v\n", hostRoutes)
out := []string{"Destination CIDR\tNext Hop"}
for _, route := range hostRoutes {
out = append(out, fmt.Sprintf("%s\t%s", route.DestinationCIDR, route.NextHop))
}
m["Host Routes"] = strings.Join(out, "\n")
} else {
m["Host Routes"] = ""
}
*/
if nameServers, ok := m["DNSNameservers"].([]string); ok && len(nameServers) > 0 {
m["DNS Nameservers"] = strings.Join(nameServers, "\n")
} else {
m["DNS Nameservers"] = ""
}
m["Tenant ID"] = m["TenantID"]
m["Network ID"] = m["NetworkID"]
m["Gateway IP"] = m["GatewayIP"]
return m
}
func eventSingle(rawEvent interface{}) map[string]interface{} {
m := structs.Map(rawEvent)
switch event := rawEvent.(type) {
case *osStackEvents.Event:
if event.Time.Unix() != -62135596800 {
m["Time"] = event.Time
} else {
m["Time"] = ""
}
if event.Links != nil {
links := make([]map[string]interface{}, len(event.Links))
for i, link := range event.Links {
links[i] = map[string]interface{}{
"Href": link.Href,
"Rel": link.Rel,
}
}
m["Links"] = links
}
return m
}
return nil
}
func (command *commandList) Execute(resource *handler.Resource) {
params := resource.Params.(*paramsList)
opts := params.opts
stackName := params.stackName
stackID := params.stackID
pager := stackresources.List(command.Ctx.ServiceClient, stackName, stackID, opts)
pages, err := pager.AllPages()
if err != nil {
resource.Err = err
return
}
info, err := osStackResources.ExtractResources(pages)
if err != nil {
resource.Err = err
return
}
result := make([]map[string]interface{}, len(info))
for j, resource := range info {
result[j] = structs.Map(&resource)
result[j]["UpdatedTime"] = resource.UpdatedTime
}
resource.Result = result
}
func (command *commandGet) Execute(resource *handler.Resource) {
pager := stacks.List(command.Ctx.ServiceClient, nil)
//fmt.Println(pager)
pages, err := pager.AllPages()
if err != nil {
resource.Err = err
return
}
//fmt.Println(pages)
info, err := osStacks.ExtractStacks(pages)
//fmt.Println("Yeah!")
if err != nil {
resource.Err = err
return
}
result := make([]map[string]interface{}, len(info))
for j, stack := range info {
result[j] = structs.Map(stack)
}
fmt.Println(result)
resource.Result = result
}