func TestRequiredFieldsForCreate(t *testing.T) {
res1 := floatingips.Create(fake.ServiceClient(), floatingips.CreateOpts{FloatingNetworkID: ""})
if res1.Err == nil {
t.Fatalf("Expected error, got none")
}
res2 := floatingips.Create(fake.ServiceClient(), floatingips.CreateOpts{FloatingNetworkID: "foo", PortID: ""})
if res2.Err == nil {
t.Fatalf("Expected error, got none")
}
}
// Bind an port to external network, return floatingip binded
func (os *OpenStack) BindPortToExternal(portName, tenantID string) (string, error) {
port, err := os.GetPort(portName)
if err != nil {
glog.Errorf("Get openstack port failed: %v", err)
return "", err
}
opts := floatingips.CreateOpts{
FloatingNetworkID: os.ExtNetID,
TenantID: tenantID,
}
ip, err := floatingips.Create(os.network, opts).Extract()
if err != nil {
glog.Errorf("Create openstack flaotingip failed: %v", err)
return "", err
}
floatOpts := floatingips.UpdateOpts{PortID: port.ID}
_, err = floatingips.Update(os.network, ip.ID, floatOpts).Extract()
if err != nil {
glog.Errorf("Associate floatingip failed: %v", err)
e := floatingips.Delete(os.network, ip.ID).ExtractErr()
if e != nil {
glog.Errorf("Delete floatingip error: %v", e)
}
return "", err
}
return ip.FloatingIP, nil
}
// Bind an port to external network, return error
func (os *OpenStack) BindPortToFloatingip(portID, floatingIPAddress, tenantID string) error {
var fip *floatingips.FloatingIP
opts := floatingips.ListOpts{
FloatingIP: floatingIPAddress,
}
pager := floatingips.List(os.network, opts)
err := pager.EachPage(func(page pagination.Page) (bool, error) {
floatingipList, err := floatingips.ExtractFloatingIPs(page)
if err != nil {
glog.Errorf("Get openstack floatingips error: %v", err)
return false, err
}
if len(floatingipList) > 0 {
fip = &floatingipList[0]
}
return true, nil
})
if err != nil {
return err
}
if fip != nil {
// fip has already been used
if fip.PortID != "" {
return fmt.Errorf("FloatingIP %v is already been binded to %v", floatingIPAddress, fip.PortID)
}
// Update floatingip
floatOpts := floatingips.UpdateOpts{PortID: portID}
_, err = floatingips.Update(os.network, fip.ID, floatOpts).Extract()
if err != nil {
glog.Errorf("Bind floatingip %v to %v failed: %v", floatingIPAddress, portID, err)
return err
}
} else {
// Create floatingip
opts := floatingips.CreateOpts{
FloatingNetworkID: os.ExtNetID,
TenantID: tenantID,
FloatingIP: floatingIPAddress,
PortID: portID,
}
_, err := floatingips.Create(os.network, opts).Extract()
if err != nil {
glog.Errorf("Create openstack flaotingip failed: %v", err)
return err
}
}
return nil
}
func TestCreate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/v2.0/floatingips", func(w http.ResponseWriter, r *http.Request) {
th.TestMethod(t, r, "POST")
th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
th.TestHeader(t, r, "Content-Type", "application/json")
th.TestHeader(t, r, "Accept", "application/json")
th.TestJSONRequest(t, r, `
{
"floatingip": {
"floating_network_id": "376da547-b977-4cfe-9cba-275c80debf57",
"port_id": "ce705c24-c1ef-408a-bda3-7bbd946164ab"
}
}
`)
w.Header().Add("Content-Type", "application/json")
w.WriteHeader(http.StatusCreated)
fmt.Fprintf(w, `
{
"floatingip": {
"router_id": "d23abc8d-2991-4a55-ba98-2aaea84cc72f",
"tenant_id": "4969c491a3c74ee4af974e6d800c62de",
"floating_network_id": "376da547-b977-4cfe-9cba-275c80debf57",
"fixed_ip_address": "10.0.0.3",
"floating_ip_address": "",
"port_id": "ce705c24-c1ef-408a-bda3-7bbd946164ab",
"id": "2f245a7b-796b-4f26-9cf9-9e82d248fda7"
}
}
`)
})
options := floatingips.CreateOpts{
FloatingNetworkID: "376da547-b977-4cfe-9cba-275c80debf57",
PortID: "ce705c24-c1ef-408a-bda3-7bbd946164ab",
}
ip, err := floatingips.Create(fake.ServiceClient(), options).Extract()
th.AssertNoErr(t, err)
th.AssertEquals(t, "2f245a7b-796b-4f26-9cf9-9e82d248fda7", ip.ID)
th.AssertEquals(t, "4969c491a3c74ee4af974e6d800c62de", ip.TenantID)
th.AssertEquals(t, "376da547-b977-4cfe-9cba-275c80debf57", ip.FloatingNetworkID)
th.AssertEquals(t, "", ip.FloatingIP)
th.AssertEquals(t, "ce705c24-c1ef-408a-bda3-7bbd946164ab", ip.PortID)
th.AssertEquals(t, "10.0.0.3", ip.FixedIP)
}
func resourceNetworkFloatingIPV2Create(d *schema.ResourceData, meta interface{}) error {
config := meta.(*Config)
networkingClient, err := config.networkingV2Client(GetRegion(d))
if err != nil {
return fmt.Errorf("Error creating OpenStack network client: %s", err)
}
poolID, err := getNetworkID(d, meta, d.Get("pool").(string))
if err != nil {
return fmt.Errorf("Error retrieving floating IP pool name: %s", err)
}
if len(poolID) == 0 {
return fmt.Errorf("No network found with name: %s", d.Get("pool").(string))
}
createOpts := FloatingIPCreateOpts{
floatingips.CreateOpts{
FloatingNetworkID: poolID,
PortID: d.Get("port_id").(string),
TenantID: d.Get("tenant_id").(string),
FixedIP: d.Get("fixed_ip").(string),
},
MapValueSpecs(d),
}
log.Printf("[DEBUG] Create Options: %#v", createOpts)
floatingIP, err := floatingips.Create(networkingClient, createOpts).Extract()
if err != nil {
return fmt.Errorf("Error allocating floating IP: %s", err)
}
log.Printf("[DEBUG] Waiting for OpenStack Neutron Floating IP (%s) to become available.", floatingIP.ID)
stateConf := &resource.StateChangeConf{
Target: []string{"ACTIVE"},
Refresh: waitForFloatingIPActive(networkingClient, floatingIP.ID),
Timeout: 2 * time.Minute,
Delay: 5 * time.Second,
MinTimeout: 3 * time.Second,
}
_, err = stateConf.WaitForState()
d.SetId(floatingIP.ID)
return resourceNetworkFloatingIPV2Read(d, meta)
}
// CreateFloatingIP creates a floating IP on a given network and port. An error
// will be returned if the creation failed.
func CreateFloatingIP(t *testing.T, client *gophercloud.ServiceClient, networkID, portID string) (*floatingips.FloatingIP, error) {
t.Logf("Attempting to create floating IP on port: %s", portID)
createOpts := &floatingips.CreateOpts{
FloatingNetworkID: networkID,
PortID: portID,
}
floatingIP, err := floatingips.Create(client, createOpts).Extract()
if err != nil {
return floatingIP, err
}
t.Logf("Created floating IP.")
return floatingIP, err
}