// initialize uses our required environment variables to authenticate with // OpenStack and create some clients we will use in the other methods func (p *openstackp) initialize() (err error) { // authenticate opts, err := openstack.AuthOptionsFromEnv() if err != nil { return } provider, err := openstack.AuthenticatedClient(opts) if err != nil { return } // make a compute client p.computeClient, err = openstack.NewComputeV2(provider, gophercloud.EndpointOpts{ Region: os.Getenv("OS_REGION_NAME"), }) if err != nil { return } // make a network client p.networkClient, err = openstack.NewNetworkV2(provider, gophercloud.EndpointOpts{ //Name: "neutron", //*** "services can have the same Type but a different Name, which is why [...] Name [is] sometimes needed... but how do I see the available names? Region: os.Getenv("OS_REGION_NAME"), }) if err != nil { return } // we need to know the network pool name *** does this have to be a user // input/config option? Or can it be discovered? p.poolName = os.Getenv("OS_POOL_NAME") // I made this one up, so we'll default to nova if p.poolName == "" { p.poolName = "nova" } p.externalNetworkID, err = networks.IDFromName(p.networkClient, p.poolName) if err != nil { return } // get the details of all the possible server flavors p.fmap = make(map[string]Flavor) pager := flavors.ListDetail(p.computeClient, flavors.ListOpts{}) err = pager.EachPage(func(page pagination.Page) (bool, error) { flavorList, err := flavors.ExtractFlavors(page) if err != nil { return false, err } for _, f := range flavorList { p.fmap[f.ID] = Flavor{ ID: f.ID, Name: f.Name, Cores: f.VCPUs, RAM: f.RAM, Disk: f.Disk, } } return true, nil }) return }
// deploy achieves the aims of Deploy(). func (p *openstackp) deploy(resources *Resources, requiredPorts []int) (err error) { // the resource name can only contain letters, numbers, underscores, // spaces and hyphens if !openstackValidResourceNameRegexp.MatchString(resources.ResourceName) { err = Error{"openstack", "deploy", ErrBadResourceName} return } // get/create key pair kp, err := keypairs.Get(p.computeClient, resources.ResourceName).Extract() if err != nil { if _, notfound := err.(gophercloud.ErrDefault404); notfound { // create a new keypair; we can't just let Openstack create one for // us because in latest versions it does not return a DER encoded // key, which is what GO built-in library supports. privateKey, errk := rsa.GenerateKey(rand.Reader, 1024) if errk != nil { err = errk return } privateKeyPEM := &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(privateKey)} privateKeyPEMBytes := pem.EncodeToMemory(privateKeyPEM) pub, errk := ssh.NewPublicKey(&privateKey.PublicKey) if errk != nil { err = errk return err } publicKeyStr := ssh.MarshalAuthorizedKey(pub) kp, err = keypairs.Create(p.computeClient, keypairs.CreateOpts{Name: resources.ResourceName, PublicKey: string(publicKeyStr)}).Extract() if err != nil { return } resources.PrivateKey = string(privateKeyPEMBytes) } else { return } } resources.Details["keypair"] = kp.Name // based on hostname, see if we're currently running on an openstack server, // in which case we'll use this server's security group and network. hostname, err := os.Hostname() inCloud := false if err == nil { pager := servers.List(p.computeClient, servers.ListOpts{}) err = pager.EachPage(func(page pagination.Page) (bool, error) { serverList, err := servers.ExtractServers(page) if err != nil { return false, err } for _, server := range serverList { if server.Name == hostname { p.ownName = hostname // get the first networkUUID we come across *** not sure // what the other possibilities are and what else we can do // instead for networkName := range server.Addresses { networkUUID, _ := networks.IDFromName(p.networkClient, networkName) if networkUUID != "" { p.networkName = networkName p.networkUUID = networkUUID break } } // get the first security group *** again, not sure how to // pick the "best" if more than one for _, smap := range server.SecurityGroups { if value, found := smap["name"]; found && value.(string) != "" { p.securityGroup = value.(string) break } } if p.networkUUID != "" && p.securityGroup != "" { inCloud = true return false, nil } } } return true, nil }) } //*** actually, if in cloud, we should create a security group that allows // the given ports, only accessible by things in the current security group // don't create any more resources if we're already running in OpenStack if inCloud { return } // get/create security group pager := secgroups.List(p.computeClient) var group *secgroups.SecurityGroup foundGroup := false err = pager.EachPage(func(page pagination.Page) (bool, error) { groupList, err := secgroups.ExtractSecurityGroups(page) if err != nil { return false, err } for _, g := range groupList { if g.Name == resources.ResourceName { group = &g foundGroup = true return false, nil } } return true, nil }) if err != nil { return } if !foundGroup { // create a new security group with rules allowing the desired ports group, err = secgroups.Create(p.computeClient, secgroups.CreateOpts{Name: resources.ResourceName, Description: "access amongst wr-spawned nodes"}).Extract() if err != nil { return } //*** check if the rules are already there, in case we previously died // between previous line and this one for _, port := range requiredPorts { _, err = secgroups.CreateRule(p.computeClient, secgroups.CreateRuleOpts{ ParentGroupID: group.ID, FromPort: port, ToPort: port, IPProtocol: "TCP", CIDR: "0.0.0.0/0", // FromGroupID: group.ID if we were creating a head node and then wanted a rule for all worker nodes... }).Extract() if err != nil { return } } // ICMP may help networking work as expected _, err = secgroups.CreateRule(p.computeClient, secgroups.CreateRuleOpts{ ParentGroupID: group.ID, FromPort: 0, ToPort: 0, // *** results in a port of '0', which is not the same as "ALL ICMP" which then says "Any" in the web interface IPProtocol: "ICMP", CIDR: "0.0.0.0/0", }).Extract() if err != nil { return } } resources.Details["secgroup"] = group.ID p.securityGroup = resources.ResourceName // get/create network var network *networks.Network networkID, err := networks.IDFromName(p.networkClient, resources.ResourceName) if err != nil { if _, notfound := err.(gophercloud.ErrResourceNotFound); notfound { // create a network for ourselves network, err = networks.Create(p.networkClient, networks.CreateOpts{Name: resources.ResourceName, AdminStateUp: gophercloud.Enabled}).Extract() if err != nil { return } networkID = network.ID } else { return } } else { network, err = networks.Get(p.networkClient, networkID).Extract() if err != nil { return } } resources.Details["network"] = networkID p.networkName = resources.ResourceName p.networkUUID = networkID // get/create subnet var subnetID string if len(network.Subnets) == 1 { subnetID = network.Subnets[0] // *** check it's valid? could we end up with more than 1 subnet? } else { // add a big enough subnet var gip = new(string) *gip = "192.168.0.1" var subnet *subnets.Subnet subnet, err = subnets.Create(p.networkClient, subnets.CreateOpts{ NetworkID: networkID, CIDR: "192.168.0.0/16", GatewayIP: gip, DNSNameservers: dnsNameServers[:], // this is critical, or servers on new networks can't be ssh'd to for many minutes IPVersion: 4, Name: resources.ResourceName, }).Extract() if err != nil { return } subnetID = subnet.ID } resources.Details["subnet"] = subnetID // get/create router var routerID string pager = routers.List(p.networkClient, routers.ListOpts{Name: resources.ResourceName}) err = pager.EachPage(func(page pagination.Page) (bool, error) { routerList, err := routers.ExtractRouters(page) if err != nil { return false, err } routerID = routerList[0].ID // *** check it's valid? could we end up with more than 1 router? return false, nil }) if err != nil { return } if routerID == "" { var router *routers.Router router, err = routers.Create(p.networkClient, routers.CreateOpts{ Name: resources.ResourceName, GatewayInfo: &routers.GatewayInfo{NetworkID: p.externalNetworkID}, AdminStateUp: gophercloud.Enabled, }).Extract() if err != nil { return } routerID = router.ID // add our subnet _, err = routers.AddInterface(p.networkClient, routerID, routers.AddInterfaceOpts{SubnetID: subnetID}).Extract() if err != nil { // if this fails, we'd be stuck with a useless router, so we try and // delete it routers.Delete(p.networkClient, router.ID) return } } resources.Details["router"] = routerID return }