Example #1
0
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
}
Example #2
0
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
}
Example #3
0
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
}