// getAvailableFloatingIP gets or creates an unused floating ip func (p *openstackp) getAvailableFloatingIP() (floatingIP string, err error) { // find any existing floating ips allFloatingIPPages, err := floatingips.List(p.computeClient).AllPages() if err != nil { return } allFloatingIPs, err := floatingips.ExtractFloatingIPs(allFloatingIPPages) if err != nil { return } for _, fIP := range allFloatingIPs { if fIP.InstanceID == "" { floatingIP = fIP.IP break } } if floatingIP == "" { // create a new one fIP, ferr := floatingips.Create(p.computeClient, floatingips.CreateOpts{ Pool: p.poolName, }).Extract() if ferr != nil { err = ferr return } floatingIP = fIP.IP // *** should we delete these during TearDown? fIP.Delete(p.computeClient, fIP.ID) ... } return }
func (s *StepAllocateIp) Run(state multistep.StateBag) multistep.StepAction { ui := state.Get("ui").(packer.Ui) config := state.Get("config").(Config) server := state.Get("server").(*servers.Server) // We need the v2 compute client client, err := config.computeV2Client() if err != nil { err = fmt.Errorf("Error initializing compute client: %s", err) state.Put("error", err) return multistep.ActionHalt } var instanceIp floatingips.FloatingIP // This is here in case we error out before putting instanceIp into the // statebag below, because it is requested by Cleanup() state.Put("access_ip", &instanceIp) if s.FloatingIp != "" { instanceIp.IP = s.FloatingIp } else if s.FloatingIpPool != "" { ui.Say(fmt.Sprintf("Creating floating IP...")) ui.Message(fmt.Sprintf("Pool: %s", s.FloatingIpPool)) newIp, err := floatingips.Create(client, floatingips.CreateOpts{ Pool: s.FloatingIpPool, }).Extract() if err != nil { err := fmt.Errorf("Error creating floating ip from pool '%s'", s.FloatingIpPool) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } instanceIp = *newIp ui.Message(fmt.Sprintf("Created floating IP: %s", instanceIp.IP)) } if instanceIp.IP != "" { ui.Say(fmt.Sprintf("Associating floating IP with server...")) ui.Message(fmt.Sprintf("IP: %s", instanceIp.IP)) err := floatingips.AssociateInstance(client, server.ID, floatingips.AssociateOpts{ FloatingIP: instanceIp.IP, }).ExtractErr() if err != nil { err := fmt.Errorf( "Error associating floating IP %s with instance: %s", instanceIp.IP, err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } ui.Message(fmt.Sprintf( "Added floating IP %s to instance!", instanceIp.IP)) } state.Put("access_ip", &instanceIp) return multistep.ActionContinue }
func TestCreate(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleCreateSuccessfully(t) actual, err := floatingips.Create(client.ServiceClient(), floatingips.CreateOpts{ Pool: "nova", }).Extract() th.AssertNoErr(t, err) th.CheckDeepEquals(t, &CreatedFloatingIP, actual) }
// CreateFloatingIP will allocate a floating IP. // An error will be returend if one was unable to be allocated. func CreateFloatingIP(t *testing.T, client *gophercloud.ServiceClient, choices *clients.AcceptanceTestChoices) (*floatingips.FloatingIP, error) { createOpts := floatingips.CreateOpts{ Pool: choices.FloatingIPPoolName, } floatingIP, err := floatingips.Create(client, createOpts).Extract() if err != nil { return floatingIP, err } t.Logf("Created floating IP: %s", floatingIP.ID) return floatingIP, nil }
func resourceComputeFloatingIPV2Create(d *schema.ResourceData, meta interface{}) error { config := meta.(*Config) computeClient, err := config.computeV2Client(d.Get("region").(string)) if err != nil { return fmt.Errorf("Error creating OpenStack compute client: %s", err) } createOpts := &floatingips.CreateOpts{ Pool: d.Get("pool").(string), } log.Printf("[DEBUG] Create Options: %#v", createOpts) newFip, err := floatingips.Create(computeClient, createOpts).Extract() if err != nil { return fmt.Errorf("Error creating Floating IP: %s", err) } d.SetId(newFip.ID) return resourceComputeFloatingIPV2Read(d, meta) }