func Get(args ...string) (string, error) {
// 1 argument: <entity>
// 2 arguments: <entity> <ID>
// 3 arguments: <entity> <ID> <children>
if len(args) < 1 || len(args) > 3 {
return "GET <entity> [ <ID> [ <children> ] ] ", nil
}
entity := args[0]
switch entity {
case "enterprises":
switch len(args) {
case 1: // GET enterprises
var orglist nuage_v3_2.EnterpriseSlice
err := orglist.List(myconn)
if err != nil {
return "", err
}
// Yuck -- We need to to this hacky type cast since we can iterate through "[]nuage_v3_2.Enterprise" but not "nuage_v3_2.EnterpriseSlice"
var orgs []nuage_v3_2.Enterprise
orgs = orglist
// Iterate through the list of org's and JSON pretty-print them
for i, v := range orgs {
org, _ := json.MarshalIndent(v, "", "\t")
fmt.Printf("\n\n ===> Org nr [%d]: Name [%s] <=== \n%#s\n", i, orgs[i].Name, string(org))
}
return "Enterprise list -- done", err
case 2: // GET enterprises <ID>
org := new(nuage_v3_2.Enterprise)
org.ID = args[1]
err := org.Get(myconn)
if err != nil {
return "", err
}
// JSON pretty-print the org
jsonorg, _ := json.MarshalIndent(org, "", "\t")
fmt.Printf("\n\n ===> Org: Name [%s] <=== \n%#s\n", org.Name, string(jsonorg))
return "Enterprise Get ID -- done", err
case 3:
entityid := args[1]
child := args[2]
switch child {
case "domaintemplates": // GET enterprises <ID> domaintemplates
// Get list of domain templates for that org
var dts nuage_v3_2.Domaintemplateslice
err := dts.List(myconn, entityid)
if err != nil {
return "", err
}
// Yucky -- type cast from nuage_v3_2.Domaintemplateslice to []nuage_v3_2.Domaintemplate
var dtl []nuage_v3_2.Domaintemplate
dtl = dts
// Iterate through the list of domain templates and JSON pretty-print them
fmt.Printf("\n ######## Domain templates for Enterprise ID: [%s] ########\n", entityid)
for i, v := range dtl {
dt, _ := json.MarshalIndent(v, "", "\t")
fmt.Printf("\n ===> Domain template nr [%d]: Name [%s] <=== \n%#s\n", i, dtl[i].Name, string(dt))
}
return "Domain template list -- done", err
case "domains": // GET enterprises <ID> domains
// Get list of domains for the Enterprise ID
var ds nuage_v3_2.Domainslice
err := ds.List(myconn, entityid)
if err != nil {
return "", err
}
// Yucky -- type cast from nuage_v3_2.Domainslice to []nuage_v3_2.Domain
var dl []nuage_v3_2.Domain
dl = ds
// Iterate through the list of domains and JSON pretty-print them
fmt.Printf("\n ######## Domains for Enterprise ID: [%s] ########\n", entityid)
for i, v := range dl {
domain, _ := json.MarshalIndent(v, "", "\t")
fmt.Printf("\n ===> Domain nr [%d]: Name [%s] <=== \n%#s\n", i, dl[i].Name, string(domain))
}
return "Domain list -- done", err
}
}
case "domaintemplates":
switch len(args) {
case 2: // GET domaintemplates <ID>
dt := new(nuage_v3_2.Domaintemplate)
dt.ID = args[1]
err := dt.Get(myconn)
if err != nil {
return "", err
}
// JSON pretty-print the domain template
jsondt, _ := json.MarshalIndent(dt, "", "\t")
fmt.Printf("\n ===> Domain Template: Name [%s] <=== \n%#s\n", dt.Name, string(jsondt))
return "Domain Template Get -- done", err
case 3:
dtid := args[1]
child := args[2]
switch child {
case "zonetemplates": // GET domaintemplates <ID> zonetemplates
var zts nuage_v3_2.Zonetemplateslice
err := zts.List(myconn, dtid)
if err != nil {
return "", err
}
// Yucky -- type cast from nuage_v3_2.Zonetemplateslice to []nuage_v3_2.Zonetemplate
var zta []nuage_v3_2.Zonetemplate
zta = zts
// Iterate through the list of zone templates and JSON pretty-print them
fmt.Printf("\n ######## Zone templates for Domain template ID: [%s] ########\n", dtid)
for i, v := range zta {
zt, _ := json.MarshalIndent(v, "", "\t")
fmt.Printf("\n ===> Zone template nr [%d]: Name [%s] <=== \n%#s\n", i, zta[i].Name, string(zt))
}
return "Zone template list -- done", err
}
}
case "domains":
switch len(args) {
case 1: // GET domains
// Get list of domains with "nil" as parent enterprise -- i.e. global list of all domains
var ds nuage_v3_2.Domainslice
err := ds.List(myconn, "")
if err != nil {
return "", err
}
// Yucky -- type cast from nuage_v3_2.Domainslice to []nuage_v3_2.Domain
var dl []nuage_v3_2.Domain
dl = ds
for i, v := range dl {
jsondomain, _ := json.MarshalIndent(v, "", "\t")
fmt.Printf("\n ===> Domain nr [%d]: Name [%s] <=== \n%#s\n", i, dl[i].Name, string(jsondomain))
}
return "Domain list -- done", err
case 2: // GET domains <ID>
// Get a specific Domain ID
domain := new(nuage_v3_2.Domain)
domain.ID = args[1]
err := domain.Get(myconn)
if err != nil {
return "", err
}
jsondomain, _ := json.MarshalIndent(domain, "", "\t")
fmt.Printf("\n ===> Domain Name [%s] <=== \n%#s\n", domain.Name, string(jsondomain))
return "Domain Get -- done", err
case 3:
switch args[2] {
case "vports": // GET domains <ID> vports
var vports []nuage_v3_2.VPort
var err error
domain := new(nuage_v3_2.Domain)
domain.ID = args[1]
vports, err = domain.VPortsList(myconn)
if err != nil {
return "", err
}
for i, v := range vports {
jsonvport, _ := json.MarshalIndent(v, "", "\t")
fmt.Printf("\n ===> VPort nr [%d]: Name [%s] <=== \n%#s\n", i, vports[i].Name, string(jsonvport))
}
return "Domain VPorts list -- done", err
case "vminterfaces": // GET domains <ID> vminterfaces
// var vmis []nuage_v3_2.VMInterface
// var err error
var domain nuage_v3_2.Domain
domain.ID = args[1]
vmis, err := (&domain).VMInterfacesList(myconn)
if err != nil {
return "", err
}
for i, v := range vmis {
jsonvmi, _ := json.MarshalIndent(v, "", "\t")
fmt.Printf("\n ===> VMInterface nr [%d]: Name [%s] <=== \n%#s\n", i, vmis[i].Name, string(jsonvmi))
}
return "Subnet VMInterfaces list -- done", err
}
}
case "zonetemplates":
if len(args) < 2 {
return "Format:\n GET zonetemplates <ID>", nil
}
switch len(args) {
case 2: // GET zonetemplates <ID>
zt := new(nuage_v3_2.Zonetemplate)
zt.ID = args[1]
err := zt.Get(myconn)
if err != nil {
return "", err
}
// JSON pretty-print the zone template
jsonzt, _ := json.MarshalIndent(zt, "", "\t")
fmt.Printf("\n ===> Zone Template: Name [%s] <=== \n%#s\n", zt.Name, string(jsonzt))
return "Zone Template Get -- done", err
}
case "zones":
switch len(args) {
case 1: // GET zones
// Get list of zones with "nil" as parent domain -- i.e. global list of all zones
var zs nuage_v3_2.Zoneslice
err := zs.List(myconn, "")
if err != nil {
return "", err
}
// Yucky -- type cast from nuage_v3_2.Zoneslice to []nuage_v3_2.Zone
var zl []nuage_v3_2.Zone
zl = zs
for i, v := range zl {
jsonzone, _ := json.MarshalIndent(v, "", "\t")
fmt.Printf("\n ===> Zone nr [%d]: Name [%s] <=== \n%#s\n", i, zl[i].Name, string(jsonzone))
}
return "Zone list -- done", err
case 2: // GET zones <ID>
// Get a specific Zone ID
zone := new(nuage_v3_2.Zone)
zone.ID = args[1]
err := zone.Get(myconn)
if err != nil {
return "", err
}
jsonzone, _ := json.MarshalIndent(zone, "", "\t")
fmt.Printf("\n ===> Zone Name [%s] <=== \n%#s\n", zone.Name, string(jsonzone))
return "Zone Get -- done", err
}
case "subnets":
switch len(args) {
case 1: // GET subnets
// Get list of subnets with "nil" as parent domain -- i.e. global list of all subnets
var ss nuage_v3_2.Subnetslice
err := ss.List(myconn, "")
if err != nil {
return "", err
}
// Yucky -- type cast from nuage_v3_2.Subnetslice to []nuage_v3_2.Subnet
var za []nuage_v3_2.Subnet
za = ss
for i, v := range za {
jsonsubnet, _ := json.MarshalIndent(v, "", "\t")
fmt.Printf("\n ===> Subnet nr [%d]: Name [%s] <=== \n%#s\n", i, za[i].Name, string(jsonsubnet))
}
return "Subnet list -- done", err
case 2: // GET subnets <ID>
// Get a specific Subnet ID
subnet := new(nuage_v3_2.Subnet)
subnet.ID = args[1]
err := subnet.Get(myconn)
if err != nil {
return "", err
}
jsonsubnet, _ := json.MarshalIndent(subnet, "", "\t")
fmt.Printf("\n ===> Subnet Name [%s] <=== \n%#s\n", subnet.Name, string(jsonsubnet))
return "Subnet Get -- done", err
case 3:
switch args[2] {
case "vports": // GET subnets <ID> vports
var vports []nuage_v3_2.VPort
var err error
subnet := new(nuage_v3_2.Subnet)
subnet.ID = args[1]
vports, err = subnet.VPortsList(myconn)
if err != nil {
return "", err
}
for i, v := range vports {
jsonvport, _ := json.MarshalIndent(v, "", "\t")
fmt.Printf("\n ===> VPort nr [%d]: Name [%s] <=== \n%#s\n", i, vports[i].Name, string(jsonvport))
}
return "Subnet VPorts list -- done", err
case "vminterfaces": // GET subnets <ID> vminterfaces
var vmis []nuage_v3_2.VMInterface
var err error
var subnet nuage_v3_2.Subnet
subnet.ID = args[1]
vmis, err = (&subnet).VMInterfacesList(myconn)
if err != nil {
return "", err
}
for i, v := range vmis {
jsonvmi, _ := json.MarshalIndent(v, "", "\t")
fmt.Printf("\n ===> VMInterface nr [%d]: Name [%s] <=== \n%#s\n", i, vmis[i].Name, string(jsonvmi))
}
return "Subnet VMInterfaces list -- done", err
}
}
case "vports": // GET vports <ID>
if len(args) != 2 {
return "Format:\n GET vports <ID>", nil
}
vport := new(nuage_v3_2.VPort)
vport.ID = args[1]
err := vport.Get(myconn)
if err != nil {
return "", err
}
jsonvport, _ := json.MarshalIndent(vport, "", "\t")
fmt.Printf("\n ===> VPort Name [%s] <=== \n%#s\n", vport.Name, string(jsonvport))
return "VPort Get -- done", err
case "vminterfaces":
switch len(args) {
case 1: // GET vminterfaces
var vmis nuage_v3_2.VMInterfaceslice
err := vmis.List(myconn)
if err != nil {
return "", err
}
// Yucky -- type cast from nuage_v3_2.VMInterfaceslice to []nuage_v3_2.VMInterface
var vmia []nuage_v3_2.VMInterface
vmia = vmis
for i, v := range vmia {
jsonvminterface, _ := json.MarshalIndent(v, "", "\t")
fmt.Printf("\n ===> VMInterface nr [%d]: Name [%s] <=== \n%#s\n", i, vmia[i].Name, string(jsonvminterface))
}
return "VMinterfaces list -- done", err
case 2: // GET vminterfaces <ID>
var vminterface nuage_v3_2.VMInterface
vminterface.ID = args[1]
err := (&vminterface).Get(myconn)
if err != nil {
return "", err
}
jsonvminterface, _ := json.MarshalIndent(vminterface, "", "\t")
fmt.Printf("\n ===> VMinterface Name [%s] <=== \n%#s\n", vminterface.Name, string(jsonvminterface))
return "VMinterface Get -- done", err
}
case "vms":
switch len(args) {
case 1: // GET vms
var vms nuage_v3_2.VirtualMachineslice
err := vms.List(myconn)
if err != nil {
return "", err
}
// Yucky -- type cast from nuage_v3_2.VirtualMachineslice to []nuage_v3_2.VirtualMachine
var vma []nuage_v3_2.VirtualMachine
vma = vms
for i, v := range vma {
jsonvm, _ := json.MarshalIndent(v, "", "\t")
fmt.Printf("\n ===> VirtualMachine nr [%d]: Name [%s] <=== \n%#s\n", i, vma[i].Name, string(jsonvm))
}
return "VirtualMachine list -- done", err
case 2: // GET vms <ID>
var vm nuage_v3_2.VirtualMachine
vm.ID = args[1]
err := (&vm).Get(myconn)
if err != nil {
return "", err
}
jsonvm, _ := json.MarshalIndent(vm, "", "\t")
fmt.Printf("\n ===> VirtualMachine Name [%s] <=== \n%#s\n", vm.Name, string(jsonvm))
return "Virtual Machine Get -- done", err
}
default:
// Unknown entity request
break
}
return "Don't know how to process Nuage API entity: " + strings.Join(args, " "), nil
}
func Delete(args ...string) (string, error) {
// Format: <entity> <ID>
if len(args) != 2 {
return "Format:\n DELETE <entity> <ID>", nil
}
entity := args[0]
id := args[1]
switch entity {
case "enterprise": // DELETE enterprise <ID>
org := new(nuage_v3_2.Enterprise)
org.ID = id
err := org.Delete(myconn)
if err != nil {
return "", err
}
return "", err
case "domaintemplate": // DELETE domaintemplate <ID>
dt := new(nuage_v3_2.Domaintemplate)
dt.ID = id
err := dt.Delete(myconn)
if err != nil {
return "", err
}
return "", err
case "domain": // DELETE domain <ID>
domain := new(nuage_v3_2.Domain)
domain.ID = id
err := domain.Delete(myconn)
if err != nil {
return "", err
}
return "", err
case "zonetemplate": // DELETE zonetemplate <ID>
zt := new(nuage_v3_2.Zonetemplate)
zt.ID = id
err := zt.Delete(myconn)
if err != nil {
return "", err
}
return "", err
case "zone": // DELETE zone <ID>
zone := new(nuage_v3_2.Zone)
zone.ID = id
err := zone.Delete(myconn)
if err != nil {
return "", err
}
return "", err
case "subnet": // DELETE subnet <ID>
subnet := new(nuage_v3_2.Subnet)
subnet.ID = id
err := subnet.Delete(myconn)
if err != nil {
return "", err
}
return "", err
case "vport": // DELETE vport <ID>
var vp nuage_v3_2.VPort
vp.ID = id
err := (&vp).Delete(myconn)
if err != nil {
return "", err
}
return "", err
case "vminterface": // DELETE vminterface <ID>
var vmi nuage_v3_2.VMInterface
vmi.ID = id
err := (&vmi).Delete(myconn)
if err != nil {
return "", err
}
return "", err
case "vm": // DELETE vm <ID>
var vm nuage_v3_2.VirtualMachine
vm.ID = id
err := (&vm).Delete(myconn)
if err != nil {
return "", err
}
return "", err
default:
return "Don't know how to DELETE entity: " + entity, nil
}
return "", nil
}
func Create(args ...string) (string, error) {
// At least 2 arguments: entity <Name>
if len(args) < 2 {
return "Format:\n CREATE <entity> <Name> [options]", nil
}
entity := args[0]
switch entity {
case "enterprise":
if len(args) != 2 {
return "Format:\n CREATE enterprise <Name>", nil
}
// CREATE enterprise <Name>
org := new(nuage_v3_2.Enterprise)
org.Name = args[1]
err := org.Create(myconn)
if err != nil {
return "", err
}
// JSON pretty-print the org
jsonorg, _ := json.MarshalIndent(org, "", "\t")
fmt.Printf("\n ===> Org: [%s] <=== \n%#s\n", org.Name, string(jsonorg))
return "", err
case "domaintemplate":
if len(args) != 3 {
return "Format:\n CREATE domaintemplate <Name> <Parent Enterprise ID> ", nil
}
// CREATE domaintemplate <Name> <Parent Enterprise ID>
dt := new(nuage_v3_2.Domaintemplate)
dt.Name = args[1]
dt.ParentID = args[2]
err := dt.Create(myconn)
if err != nil {
return "", err
}
// JSON pretty-print the domain template
jsondt, _ := json.MarshalIndent(dt, "", "\t")
fmt.Printf("\n ===> Domain Template: Name [%s] <=== \n%#s\n", dt.Name, string(jsondt))
return "Domain Template Create -- done", err
case "domain":
if len(args) != 4 {
return "Format:\n CREATE domain <Name> <Parent Enterprise ID> <Domain template ID>", nil
}
// CREATE domain <Name> <Parent Enterprise ID> <Domain template ID>
domain := new(nuage_v3_2.Domain)
domain.Name = args[1]
domain.ParentID = args[2]
domain.TemplateID = args[3]
err := domain.Create(myconn)
if err != nil {
return "", err
}
jsondomain, _ := json.MarshalIndent(domain, "", "\t")
fmt.Printf("\n ===> Domain Name [%s] <=== \n%#s\n", domain.Name, string(jsondomain))
return "Domain Create -- done", err
case "zonetemplate":
if len(args) != 3 {
return "Format:\n CREATE zonetemplate <Name> <Parent domain template ID>", nil
}
// CREATE zonetemplate <Name> <Parent domain template ID>
zt := new(nuage_v3_2.Zonetemplate)
zt.Name = args[1]
zt.ParentID = args[2]
err := zt.Create(myconn)
if err != nil {
return "", err
}
jsonzt, _ := json.MarshalIndent(zt, "", "\t")
fmt.Printf("\n ===> Zone template: Name [%s] <=== \n%#s\n", zt.Name, string(jsonzt))
return "Zone Template Create -- done", err
case "zone":
if len(args) < 3 {
return "Format:\n CREATE zone <Name> <Parent Domain ID> [ <Zone template ID> ]", nil
}
// CREATE zone <Name> <Parent Domain ID> [ <Zone template ID> ]
zone := new(nuage_v3_2.Zone)
zone.Name = args[1]
zone.ParentID = args[2]
if len(args) >= 4 {
zone.TemplateID = args[3]
}
err := zone.Create(myconn)
if err != nil {
return "", err
}
jsonzone, _ := json.MarshalIndent(zone, "", "\t")
fmt.Printf("\n ===> Zone Name [%s] <=== \n%#s\n", zone.Name, string(jsonzone))
return "Zone Create -- done", err
case "subnet":
if len(args) < 4 {
return "Format:\n CREATE subnet <Name> <Parent Zone ID> <Subnet template ID> \n or:\n CREATE subnet <Name> <Parent Zone ID> <Subnet address> <Subnet mask>\n", nil
}
switch len(args) {
case 4:
// CREATE subnet <Name> <Parent Subnet ID> <Subnet template ID>
subnet := new(nuage_v3_2.Subnet)
subnet.Name = args[1]
subnet.ParentID = args[2]
subnet.TemplateID = args[3]
err := subnet.Create(myconn)
if err != nil {
return "", err
}
jsonsubnet, _ := json.MarshalIndent(subnet, "", "\t")
fmt.Printf("\n ===> Subnet Name [%s] <=== \n%#s\n", subnet.Name, string(jsonsubnet))
return "Subnet Create -- done", err
case 5:
// CREATE subnet <Name> <Parent Subnet ID> <Subnet address> <Subnet mask>
subnet := new(nuage_v3_2.Subnet)
subnet.Name = args[1]
subnet.ParentID = args[2]
// TBD -- make sure these are proper dot notation...
subnet.Address = args[3]
subnet.Netmask = args[4]
err := subnet.Create(myconn)
if err != nil {
return "", err
}
jsonsubnet, _ := json.MarshalIndent(subnet, "", "\t")
fmt.Printf("\n ===> Subnet Name [%s] <=== \n%#s\n", subnet.Name, string(jsonsubnet))
return "Subnet Create -- done", err
}
case "vport":
if len(args) < 3 {
return "Format:\n CREATE vport <Name> <Parent Subnet ID> [ options ...]", nil
}
// CREATE vport <Name> <Parent Subnet ID> [ options ...]
subnet := new(nuage_v3_2.Subnet)
subnet.ID = args[2]
var vport nuage_v3_2.VPort
vport.Name = args[1]
// ???
vport.ID = vport.Name
vport.Type = "VM"
vport.AddressSpoofing = "INHERITED"
vport.Active = true
// ???? Not needed but still....
vport.ParentID = subnet.ID
vport.ParentType = "subnet"
jsonvport, err := json.MarshalIndent(vport, "", "\t")
fmt.Printf("\n ===> Created VPort: Name [%s] <=== \n%#s\n", vport.Name, string(jsonvport))
vp, err := subnet.AddVPort(myconn, vport)
if err != nil {
return "", err
}
jsonvp, err := json.MarshalIndent(vp, "", "\t")
fmt.Printf("\n ===> Created VPort: Name [%s] <=== \n%#s\n", vp.Name, string(jsonvp))
return "VPort Create -- done", err
case "vm":
if len(args) != 5 {
return "Format:\n CREATE vm <Name> <UUID> <Interface0-MAC> <Interface0-VPortID>", nil
}
// CREATE vm <Name> <UUID> <Interface0-MAC> <Interface0-VPortID>
var vm nuage_v3_2.VirtualMachine
vm.Name = args[1]
vm.UUID = args[2]
var vmi nuage_v3_2.VMInterface
vmi.MAC = args[3]
vmi.VPortID = args[4]
vm.Interfaces = append(vm.Interfaces, vmi)
err := (&vm).Create(myconn)
if err != nil {
return "", err
}
jsonvm, _ := json.MarshalIndent(vm, "", "\t")
fmt.Printf("\n ===> Virtual Machine: Name [%s] <=== \n%#s\n", vm.Name, string(jsonvm))
return "Virtual Machine Create -- done", err
default:
return "Don't know how to create Nuage API entity: [" + entity + "]" + " with Name [" + args[1] + "]" + " and options: " + strings.Join(args[2:], " "), nil
}
return "", nil
}