func (os *OpenStack) LoadBalancer() (cloudprovider.LoadBalancer, bool) { glog.V(4).Info("openstack.LoadBalancer() called") // TODO: Search for and support Rackspace loadbalancer API, and others. network, err := openstack.NewNetworkV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find neutron endpoint: %v", err) return nil, false } compute, err := openstack.NewComputeV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find compute endpoint: %v", err) return nil, false } glog.V(1).Info("Claiming to support LoadBalancer") if os.lbOpts.LBVersion == "v2" { return &LbaasV2{LoadBalancer{network, compute, os.lbOpts}}, true } else { return &LbaasV1{LoadBalancer{network, compute, os.lbOpts}}, true } }
func (os *OpenStack) TCPLoadBalancer() (cloudprovider.TCPLoadBalancer, bool) { glog.V(4).Info("openstack.TCPLoadBalancer() called") if err := openstack.Authenticate(os.provider, os.authOpts); err != nil { glog.Warningf("Failed to reauthenticate: %v", err) return nil, false } // TODO: Search for and support Rackspace loadbalancer API, and others. network, err := openstack.NewNetworkV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find neutron endpoint: %v", err) return nil, false } compute, err := openstack.NewComputeV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find compute endpoint: %v", err) return nil, false } glog.V(1).Info("Claiming to support TCPLoadBalancer") return &LoadBalancer{network, compute, os.lbOpts}, true }
func (os *OpenStack) LoadBalancer() (cloudprovider.LoadBalancer, bool) { glog.V(4).Info("openstack.LoadBalancer() called") // TODO: Search for and support Rackspace loadbalancer API, and others. network, err := openstack.NewNetworkV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find network endpoint: %v", err) return nil, false } compute, err := openstack.NewComputeV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find compute endpoint: %v", err) return nil, false } lbversion := os.lbOpts.LBVersion if lbversion == "" { // No version specified, try newest supported by server netExts, err := networkExtensions(network) if err != nil { glog.Warningf("Failed to list neutron extensions: %v", err) return nil, false } if netExts["lbaasv2"] { lbversion = "v2" } else if netExts["lbaas"] { lbversion = "v1" } else { glog.Warningf("Failed to find neutron LBaaS extension (v1 or v2)") return nil, false } glog.V(3).Infof("Using LBaaS extension %v", lbversion) } glog.V(1).Info("Claiming to support LoadBalancer") if lbversion == "v2" { return &LbaasV2{LoadBalancer{network, compute, os.lbOpts}}, true } else if lbversion == "v1" { return &LbaasV1{LoadBalancer{network, compute, os.lbOpts}}, true } else { glog.Warningf("Config error: unrecognised lb-version \"%v\"", lbversion) return nil, false } }
func (c *GenericClient) InitNetworkClient(d *Driver) error { if c.Network != nil { return nil } network, err := openstack.NewNetworkV2(c.Provider, gophercloud.EndpointOpts{ Region: d.Region, Availability: c.getEndpointType(d), }) if err != nil { return err } c.Network = network return nil }
func networkingClient() (*gophercloud.ServiceClient, error) { opts, err := openstack.AuthOptionsFromEnv() if err != nil { return nil, err } provider, err := openstack.AuthenticatedClient(opts) if err != nil { return nil, err } return openstack.NewNetworkV2(provider, gophercloud.EndpointOpts{ Region: os.Getenv("OS_REGION_NAME"), }) }
func NewNeutronMapper() (*NeutronMapper, error) { mapper := &NeutronMapper{} authURL := config.GetConfig().Section("openstack").Key("auth_url").String() username := config.GetConfig().Section("openstack").Key("username").String() password := config.GetConfig().Section("openstack").Key("password").String() tenantName := config.GetConfig().Section("openstack").Key("tenant_name").String() regionName := config.GetConfig().Section("openstack").Key("region_name").String() opts := gophercloud.AuthOptions{ IdentityEndpoint: authURL, Username: username, Password: password, TenantName: tenantName, } provider, err := openstack.AuthenticatedClient(opts) if err != nil { return nil, err } /* TODO(safchain) add config param for the Availability */ client, err := openstack.NewNetworkV2(provider, gophercloud.EndpointOpts{ Name: "neutron", Region: regionName, Availability: gophercloud.AvailabilityPublic, }) if err != nil { return nil, err } mapper.client = client // Create a cache with a default expiration time of 5 minutes, and which // purges expired items every 30 seconds expire, err := config.GetConfig().Section("cache").Key("expire").Int() if err != nil { return nil, err } cleanup, err := config.GetConfig().Section("cache").Key("cleanup").Int() if err != nil { return nil, err } mapper.cache = cache.New(time.Duration(expire)*time.Second, time.Duration(cleanup)*time.Second) mapper.cacheUpdaterChan = make(chan string) go mapper.cacheUpdater() return mapper, nil }
// initNetworkClient initializes openstack api using // gophercloud which handles auth tokens keeping api calls // simpler. Currently it uses environment variables for // authenticating with openstack identity. func initNetworkClient() (*gophercloud.ServiceClient, error) { opts, err := openstack.AuthOptionsFromEnv() if err != nil { log.Println("Error fetching openstack env vars: ", err) return nil, err } provider, err := openstack.AuthenticatedClient(opts) if err != nil { log.Println("Error authenticating with openstack: ", err) return nil, err } return openstack.NewNetworkV2(provider, gophercloud.EndpointOpts{ Name: "neutron", Region: os.Getenv("OS_REGION_NAME"), }) }
func (os *OpenStack) Routes() (cloudprovider.Routes, bool) { glog.V(4).Info("openstack.Routes() called") network, err := openstack.NewNetworkV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find network endpoint: %v", err) return nil, false } netExts, err := networkExtensions(network) if err != nil { glog.Warningf("Failed to list neutron extensions: %v", err) return nil, false } if !netExts["extraroute"] { glog.V(3).Infof("Neutron extraroute extension not found, required for Routes support") return nil, false } compute, err := openstack.NewComputeV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find compute endpoint: %v", err) return nil, false } r, err := NewRoutes(compute, network, os.routeOpts) if err != nil { glog.Warningf("Error initialising Routes support: %v", err) return nil, false } glog.V(1).Info("Claiming to support Routes") return r, true }
func NewNeutronMapper(g *graph.Graph, authURL string, username string, password string, tenantName string, regionName string) (*NeutronMapper, error) { mapper := &NeutronMapper{graph: g} opts := gophercloud.AuthOptions{ IdentityEndpoint: authURL, Username: username, Password: password, TenantName: tenantName, AllowReauth: true, } provider, err := openstack.AuthenticatedClient(opts) if err != nil { return nil, err } /* TODO(safchain) add config param for the Availability */ client, err := openstack.NewNetworkV2(provider, gophercloud.EndpointOpts{ Name: "neutron", Region: regionName, Availability: gophercloud.AvailabilityPublic, }) if err != nil { return nil, err } mapper.client = client // Create a cache with a default expiration time of 5 minutes, and which // purges expired items every 30 seconds expire := config.GetConfig().GetInt("cache.expire") cleanup := config.GetConfig().GetInt("cache.cleanup") mapper.cache = cache.New(time.Duration(expire)*time.Second, time.Duration(cleanup)*time.Second) mapper.nodeUpdaterChan = make(chan graph.Identifier, 500) g.AddEventListener(mapper) return mapper, nil }
func (c *Config) networkingV2Client(region string) (*gophercloud.ServiceClient, error) { return openstack.NewNetworkV2(c.osClient, gophercloud.EndpointOpts{ Region: region, Availability: c.getEndpointType(), }) }
func TestNeutron(t *testing.T) { g := newGraph(t) authUrl := os.Getenv("OS_AUTH_URL") username := os.Getenv("OS_USERNAME") password := os.Getenv("OS_PASSWORD") tenantName := os.Getenv("OS_TENANT_NAME") regionName := os.Getenv("OS_REGION_NAME") ovsdbPort := os.Getenv("SKYDIVE_OVSDB_REMOTE_PORT") params := map[string]interface{}{ "OsAuthUrl": authUrl, "OsUsername": username, "OsPassword": password, "OsTenantName": tenantName, "OsRegionName": regionName, "OvsdbPort": ovsdbPort, } agent := helper.StartAgentWithConfig(t, confNeutron, params) defer agent.Stop() opts := gophercloud.AuthOptions{ IdentityEndpoint: authUrl, Username: username, Password: password, TenantName: tenantName, } provider, err := openstack.AuthenticatedClient(opts) if err != nil { t.Fatal(err.Error()) } client, err := openstack.NewNetworkV2(provider, gophercloud.EndpointOpts{ Name: "neutron", Region: regionName, Availability: gophercloud.AvailabilityPublic, }) if err != nil { t.Fatalf("Failed to create neutron client: %s", err.Error()) } result := networks.Create(client, networks.CreateOpts{Name: "skydive-test-network"}) if result.Err != nil { t.Fatalf("Failed to create neutron network: %s", result.Err.Error()) } network, err := result.Extract() if err != nil { t.Fatalf("Failed to create neutron network: %s", err.Error()) } defer networks.Delete(client, network.ID) setupCmds := []helper.Cmd{ {fmt.Sprintf("neutron subnet-create --name skydive-test-subnet-%s %s 10.0.0.0/24", network.ID, network.ID), false}, {fmt.Sprintf("neutron-debug probe-create %s", network.ID), false}, } tearDownCmds := []helper.Cmd{ {fmt.Sprintf("neutron subnet-delete skydive-test-subnet-%s", network.ID), false}, } var port *ports.Port testPassed := false onChange := func(ws *websocket.Conn) { g.Lock() defer g.Unlock() if port == nil { portListOpts := ports.ListOpts{} pager := ports.List(client, portListOpts) err = pager.EachPage(func(page pagination.Page) (bool, error) { portList, err := ports.ExtractPorts(page) if err != nil { return false, err } for _, p := range portList { if p.DeviceOwner == "network:probe" && p.NetworkID == network.ID { port = &p return false, nil } } return true, nil }) if port != nil { tearDownCmds = append(tearDownCmds, helper.Cmd{}) copy(tearDownCmds[1:], tearDownCmds[0:]) tearDownCmds[0] = helper.Cmd{fmt.Sprintf("neutron-debug probe-delete %s", port.ID), false} } } if !testPassed && len(g.GetNodes()) >= 1 && len(g.GetEdges()) >= 1 && port != nil { if g.LookupFirstNode(graph.Metadata{"Name": fmt.Sprintf("qdhcp-%s", network.ID), "Type": "netns"}) != nil { if g.LookupFirstNode(graph.Metadata{"Name": fmt.Sprintf("qprobe-%s", port.ID), "Type": "netns"}) != nil { if g.LookupFirstNode(graph.Metadata{"Type": "internal", "Driver": "openvswitch", "Manager": "neutron", "Neutron.NetworkID": network.ID}) != nil { testPassed = true ws.Close() } } } } } testTopology(t, g, setupCmds, onChange) if !testPassed { t.Error("test not executed or failed") } testCleanup(t, g, tearDownCmds, []string{fmt.Sprintf("qdhcp-%s", network.ID), fmt.Sprintf("qprobe-%s", port.ID)}) }
func main() { // step-1 var authUsername string = "your_auth_username" var authPassword string = "your_auth_password" var authUrl string = "http://controller:5000" var projectName string = "your_project_id" var regionName string = "your_region_name" authOpts := gophercloud.AuthOptions{ IdentityEndpoint: authUrl, Username: authUsername, Password: authPassword, TenantID: projectName, } provider, _ := openstack.AuthenticatedClient(authOpts) client, _ := openstack.NewComputeV2(provider, gophercloud.EndpointOpts{ Region: regionName, }) // step-2 pager := images.ListDetail(client, images.ListOpts{}) page, _ := pager.AllPages() imageList, _ := images.ExtractImages(page) fmt.Println(imageList) // step-3 pager = flavors.ListDetail(client, flavors.ListOpts{}) page, _ = pager.AllPages() flavorList, _ := flavors.ExtractFlavors(page) fmt.Println(flavorList) // step-4 imageID := "74e6d1ec-9a08-444c-8518-4f232446386d" image, _ := images.Get(client, imageID).Extract() fmt.Println(image) // step-5 flavorID := "1" flavor, _ := flavors.Get(client, flavorID).Extract() fmt.Println(flavor) // step-6 instanceName := "testing" testingInstance, _ := servers.Create(client, servers.CreateOpts{ Name: instanceName, ImageRef: imageID, FlavorRef: flavorID, }).Extract() fmt.Println(testingInstance) // step-7 pager = servers.List(client, servers.ListOpts{}) page, _ = pager.AllPages() serverList, _ := servers.ExtractServers(page) fmt.Println(serverList) // step-8 servers.Delete(client, testingInstance.ID) // step-9 fmt.Println("Checking for existing SSH key pair...") keyPairName := "demokey" pubKeyFile := "~/.ssh/id_rsa.pub" keyPairExists := false pager = keypairs.List(client) page, _ = pager.AllPages() keypairList, _ := keypairs.ExtractKeyPairs(page) for _, k := range keypairList { if k.Name == keyPairName { keyPairExists = true break } } if keyPairExists { fmt.Println("Keypair " + keyPairName + " already exists. Skipping import.") } else { fmt.Println("adding keypair...") bs, _ := ioutil.ReadFile(pubKeyFile) keypairs.Create(client, keypairs.CreateOpts{ Name: keyPairName, PublicKey: string(bs), }).Extract() } pager = keypairs.List(client) page, _ = pager.AllPages() keypairList, _ = keypairs.ExtractKeyPairs(page) fmt.Println(keypairList) // step-10 fmt.Println("Checking for existing security group...") var allInOneSecurityGroup secgroups.SecurityGroup securityGroupName := "all-in-one" securityGroupExists := false pager = secgroups.List(client) page, _ = pager.AllPages() secgroupList, _ := secgroups.ExtractSecurityGroups(page) for _, secGroup := range secgroupList { if secGroup.Name == securityGroupName { allInOneSecurityGroup = secGroup securityGroupExists = true break } } if securityGroupExists { fmt.Println("Security Group " + allInOneSecurityGroup.Name + " already exists. Skipping creation.") } else { allInOneSecurityGroup, _ := secgroups.Create(client, secgroups.CreateOpts{ Name: securityGroupName, Description: "network access for all-in-one application.", }).Extract() secgroups.CreateRule(client, secgroups.CreateRuleOpts{ ParentGroupID: allInOneSecurityGroup.ID, FromPort: 80, ToPort: 80, IPProtocol: "TCP", CIDR: "0.0.0.0/0", }).Extract() secgroups.CreateRule(client, secgroups.CreateRuleOpts{ ParentGroupID: allInOneSecurityGroup.ID, FromPort: 22, ToPort: 22, IPProtocol: "TCP", CIDR: "0.0.0.0/0", }).Extract() } pager = secgroups.List(client) page, _ = pager.AllPages() secgroupList, _ = secgroups.ExtractSecurityGroups(page) fmt.Println(secgroupList) // step-11 userData := `#!/usr/bin/env bash curl -L -s https://git.openstack.org/cgit/openstack/faafo/plain/contrib/install.sh | bash -s -- \ -i faafo -i messaging -r api -r worker -r demo ` // step-12 fmt.Println("Checking for existing instance...") instanceName = "all-in-one" instanceExists := false pager = servers.List(client, servers.ListOpts{}) page, _ = pager.AllPages() serverList, _ = servers.ExtractServers(page) for _, s := range serverList { if s.Name == instanceName { testingInstance = &s instanceExists = true break } } if instanceExists { fmt.Println("Instance " + testingInstance.Name + " already exists. Skipping creation.") } else { opts := servers.CreateOpts{ Name: instanceName, ImageRef: image.ID, FlavorRef: flavor.ID, SecurityGroups: []string{securityGroupName}, UserData: []byte(userData), } testingInstance, _ = servers.Create(client, keypairs.CreateOptsExt{ CreateOptsBuilder: opts, KeyName: keyPairName, }).Extract() } servers.WaitForStatus(client, testingInstance.ID, "ACTIVE", 300) pager = servers.List(client, servers.ListOpts{}) page, _ = pager.AllPages() serverList, _ = servers.ExtractServers(page) fmt.Println(serverList) // step-13 var privateIP string for t, addrs := range testingInstance.Addresses { if t != "private" || len(privateIP) != 0 { continue } addrs, ok := addrs.([]interface{}) if !ok { continue } for _, addr := range addrs { a, ok := addr.(map[string]interface{}) if !ok || a["version"].(float64) != 4 { continue } ip, ok := a["addr"].(string) if ok && len(ip) != 0 { privateIP = ip fmt.Println("Private IP found: " + privateIP) break } } } // step-14 var publicIP string for t, addrs := range testingInstance.Addresses { if t != "public" || len(publicIP) != 0 { continue } addrs, ok := addrs.([]interface{}) if !ok { continue } for _, addr := range addrs { a, ok := addr.(map[string]interface{}) if !ok || a["version"].(float64) != 4 { continue } ip, ok := a["addr"].(string) if ok && len(ip) != 0 { publicIP = ip fmt.Println("Public IP found: " + publicIP) break } } } // step-15 fmt.Println("Checking for unused Floating IP...") var unusedFloatingIP string pager = floatingip.List(client) page, _ = pager.AllPages() floatingIPList, _ := floatingip.ExtractFloatingIPs(page) for _, ip := range floatingIPList { if ip.InstanceID == "" { unusedFloatingIP = ip.IP break } } networkClient, _ := openstack.NewNetworkV2(provider, gophercloud.EndpointOpts{ Region: regionName, }) pager = networks.List(networkClient, networks.ListOpts{}) page, _ = pager.AllPages() poolList, _ := external.ExtractList(page) for _, pool := range poolList { if len(unusedFloatingIP) != 0 || !pool.External { continue } fmt.Println("Allocating new Floating IP from pool: " + pool.Name) f, _ := floatingip.Create(client, floatingip.CreateOpts{Pool: pool.Name}).Extract() unusedFloatingIP = f.IP } // step-16 if len(publicIP) != 0 { fmt.Println("Instance " + testingInstance.Name + " already has a public ip. Skipping attachment.") } else { floatingip.Associate(client, testingInstance.ID, unusedFloatingIP) } // step-17 var actualIPAddress string if len(publicIP) != 0 { actualIPAddress = publicIP } else if len(unusedFloatingIP) != 0 { actualIPAddress = unusedFloatingIP } else { actualIPAddress = privateIP } fmt.Println("The Fractals app will be deployed to http://" + actualIPAddress) }