github.com/gophercloud/gophercloud@v1.11.0/internal/acceptance/openstack/networking/v2/extensions/lbaas_v2/loadbalancers_test.go (about)

     1  //go:build acceptance || networking || lbaas_v2 || loadbalancers
     2  // +build acceptance networking lbaas_v2 loadbalancers
     3  
     4  package lbaas_v2
     5  
     6  import (
     7  	"testing"
     8  
     9  	"github.com/gophercloud/gophercloud/internal/acceptance/clients"
    10  	networking "github.com/gophercloud/gophercloud/internal/acceptance/openstack/networking/v2"
    11  	"github.com/gophercloud/gophercloud/internal/acceptance/tools"
    12  	"github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/lbaas_v2/l7policies"
    13  	"github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/lbaas_v2/listeners"
    14  	"github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/lbaas_v2/loadbalancers"
    15  	"github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/lbaas_v2/monitors"
    16  	"github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/lbaas_v2/pools"
    17  	th "github.com/gophercloud/gophercloud/testhelper"
    18  )
    19  
    20  func TestLoadbalancersList(t *testing.T) {
    21  	t.Skip("Neutron LBaaS v2 was replaced by Octavia and the API will be removed in a future release")
    22  	client, err := clients.NewNetworkV2Client()
    23  	th.AssertNoErr(t, err)
    24  
    25  	allPages, err := loadbalancers.List(client, nil).AllPages()
    26  	th.AssertNoErr(t, err)
    27  
    28  	allLoadbalancers, err := loadbalancers.ExtractLoadBalancers(allPages)
    29  	th.AssertNoErr(t, err)
    30  
    31  	for _, lb := range allLoadbalancers {
    32  		tools.PrintResource(t, lb)
    33  	}
    34  }
    35  
    36  func TestLoadbalancersCRUD(t *testing.T) {
    37  	t.Skip("Neutron LBaaS v2 was replaced by Octavia and the API will be removed in a future release")
    38  	client, err := clients.NewNetworkV2Client()
    39  	th.AssertNoErr(t, err)
    40  
    41  	network, err := networking.CreateNetwork(t, client)
    42  	th.AssertNoErr(t, err)
    43  	defer networking.DeleteNetwork(t, client, network.ID)
    44  
    45  	subnet, err := networking.CreateSubnet(t, client, network.ID)
    46  	th.AssertNoErr(t, err)
    47  	defer networking.DeleteSubnet(t, client, subnet.ID)
    48  
    49  	lb, err := CreateLoadBalancer(t, client, subnet.ID)
    50  	th.AssertNoErr(t, err)
    51  	defer DeleteLoadBalancer(t, client, lb.ID)
    52  
    53  	lbDescription := ""
    54  	updateLoadBalancerOpts := loadbalancers.UpdateOpts{
    55  		Description: &lbDescription,
    56  	}
    57  	_, err = loadbalancers.Update(client, lb.ID, updateLoadBalancerOpts).Extract()
    58  	th.AssertNoErr(t, err)
    59  
    60  	if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE"); err != nil {
    61  		t.Fatalf("Timed out waiting for loadbalancer to become active")
    62  	}
    63  
    64  	newLB, err := loadbalancers.Get(client, lb.ID).Extract()
    65  	th.AssertNoErr(t, err)
    66  
    67  	tools.PrintResource(t, newLB)
    68  
    69  	th.AssertEquals(t, newLB.Description, lbDescription)
    70  
    71  	lbStats, err := loadbalancers.GetStats(client, lb.ID).Extract()
    72  	th.AssertNoErr(t, err)
    73  
    74  	tools.PrintResource(t, lbStats)
    75  
    76  	// Because of the time it takes to create a loadbalancer,
    77  	// this test will include some other resources.
    78  
    79  	// Listener
    80  	listener, err := CreateListener(t, client, lb)
    81  	th.AssertNoErr(t, err)
    82  	defer DeleteListener(t, client, lb.ID, listener.ID)
    83  
    84  	listenerName := ""
    85  	listenerDescription := ""
    86  	updateListenerOpts := listeners.UpdateOpts{
    87  		Name:        &listenerName,
    88  		Description: &listenerDescription,
    89  	}
    90  	_, err = listeners.Update(client, listener.ID, updateListenerOpts).Extract()
    91  	th.AssertNoErr(t, err)
    92  
    93  	if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE"); err != nil {
    94  		t.Fatalf("Timed out waiting for loadbalancer to become active")
    95  	}
    96  
    97  	newListener, err := listeners.Get(client, listener.ID).Extract()
    98  	th.AssertNoErr(t, err)
    99  
   100  	tools.PrintResource(t, newListener)
   101  
   102  	th.AssertEquals(t, newListener.Name, listenerName)
   103  	th.AssertEquals(t, newListener.Description, listenerDescription)
   104  
   105  	// L7 policy
   106  	policy, err := CreateL7Policy(t, client, listener, lb)
   107  	th.AssertNoErr(t, err)
   108  	defer DeleteL7Policy(t, client, lb.ID, policy.ID)
   109  
   110  	newDescription := ""
   111  	updateL7policyOpts := l7policies.UpdateOpts{
   112  		Description: &newDescription,
   113  	}
   114  	_, err = l7policies.Update(client, policy.ID, updateL7policyOpts).Extract()
   115  	th.AssertNoErr(t, err)
   116  
   117  	if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE"); err != nil {
   118  		t.Fatalf("Timed out waiting for loadbalancer to become active")
   119  	}
   120  
   121  	newPolicy, err := l7policies.Get(client, policy.ID).Extract()
   122  	th.AssertNoErr(t, err)
   123  
   124  	tools.PrintResource(t, newPolicy)
   125  
   126  	th.AssertEquals(t, newPolicy.Description, newDescription)
   127  
   128  	// L7 rule
   129  	rule, err := CreateL7Rule(t, client, newPolicy.ID, lb)
   130  	th.AssertNoErr(t, err)
   131  	defer DeleteL7Rule(t, client, lb.ID, policy.ID, rule.ID)
   132  
   133  	allPages, err := l7policies.ListRules(client, policy.ID, l7policies.ListRulesOpts{}).AllPages()
   134  	th.AssertNoErr(t, err)
   135  	allRules, err := l7policies.ExtractRules(allPages)
   136  	th.AssertNoErr(t, err)
   137  	for _, rule := range allRules {
   138  		tools.PrintResource(t, rule)
   139  	}
   140  
   141  	/* NOT supported on F5 driver */
   142  	updateL7ruleOpts := l7policies.UpdateRuleOpts{
   143  		RuleType:    l7policies.TypePath,
   144  		CompareType: l7policies.CompareTypeRegex,
   145  		Value:       "/images/special*",
   146  	}
   147  	_, err = l7policies.UpdateRule(client, policy.ID, rule.ID, updateL7ruleOpts).Extract()
   148  	th.AssertNoErr(t, err)
   149  
   150  	if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE"); err != nil {
   151  		t.Fatalf("Timed out waiting for loadbalancer to become active")
   152  	}
   153  
   154  	newRule, err := l7policies.GetRule(client, newPolicy.ID, rule.ID).Extract()
   155  	th.AssertNoErr(t, err)
   156  
   157  	tools.PrintResource(t, newRule)
   158  
   159  	// Pool
   160  	pool, err := CreatePool(t, client, lb)
   161  	th.AssertNoErr(t, err)
   162  	defer DeletePool(t, client, lb.ID, pool.ID)
   163  
   164  	poolName := ""
   165  	poolDescription := ""
   166  	updatePoolOpts := pools.UpdateOpts{
   167  		Name:        &poolName,
   168  		Description: &poolDescription,
   169  	}
   170  	_, err = pools.Update(client, pool.ID, updatePoolOpts).Extract()
   171  	th.AssertNoErr(t, err)
   172  
   173  	if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE"); err != nil {
   174  		t.Fatalf("Timed out waiting for loadbalancer to become active")
   175  	}
   176  
   177  	newPool, err := pools.Get(client, pool.ID).Extract()
   178  	th.AssertNoErr(t, err)
   179  
   180  	tools.PrintResource(t, newPool)
   181  	th.AssertEquals(t, newPool.Name, poolName)
   182  	th.AssertEquals(t, newPool.Description, poolDescription)
   183  
   184  	// Update L7policy to redirect to pool
   185  	newRedirectURL := ""
   186  	updateL7policyOpts = l7policies.UpdateOpts{
   187  		Action:         l7policies.ActionRedirectToPool,
   188  		RedirectPoolID: &newPool.ID,
   189  		RedirectURL:    &newRedirectURL,
   190  	}
   191  	_, err = l7policies.Update(client, policy.ID, updateL7policyOpts).Extract()
   192  	th.AssertNoErr(t, err)
   193  
   194  	if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE"); err != nil {
   195  		t.Fatalf("Timed out waiting for loadbalancer to become active")
   196  	}
   197  
   198  	newPolicy, err = l7policies.Get(client, policy.ID).Extract()
   199  	th.AssertNoErr(t, err)
   200  
   201  	tools.PrintResource(t, newPolicy)
   202  
   203  	th.AssertEquals(t, newPolicy.Description, newDescription)
   204  	th.AssertEquals(t, newPolicy.Action, string(l7policies.ActionRedirectToPool))
   205  	th.AssertEquals(t, newPolicy.RedirectPoolID, newPool.ID)
   206  	th.AssertEquals(t, newPolicy.RedirectURL, newRedirectURL)
   207  
   208  	// Workaround for proper delete order
   209  	defer DeleteL7Policy(t, client, lb.ID, policy.ID)
   210  	defer DeleteL7Rule(t, client, lb.ID, policy.ID, rule.ID)
   211  
   212  	// Update listener's default pool ID
   213  	updateListenerOpts = listeners.UpdateOpts{
   214  		DefaultPoolID: &pool.ID,
   215  	}
   216  	_, err = listeners.Update(client, listener.ID, updateListenerOpts).Extract()
   217  	th.AssertNoErr(t, err)
   218  
   219  	if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE"); err != nil {
   220  		t.Fatalf("Timed out waiting for loadbalancer to become active")
   221  	}
   222  
   223  	newListener, err = listeners.Get(client, listener.ID).Extract()
   224  	th.AssertNoErr(t, err)
   225  
   226  	tools.PrintResource(t, newListener)
   227  
   228  	th.AssertEquals(t, newListener.DefaultPoolID, pool.ID)
   229  
   230  	// Remove listener's default pool ID
   231  	emptyPoolID := ""
   232  	updateListenerOpts = listeners.UpdateOpts{
   233  		DefaultPoolID: &emptyPoolID,
   234  	}
   235  	_, err = listeners.Update(client, listener.ID, updateListenerOpts).Extract()
   236  	th.AssertNoErr(t, err)
   237  
   238  	if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE"); err != nil {
   239  		t.Fatalf("Timed out waiting for loadbalancer to become active")
   240  	}
   241  
   242  	newListener, err = listeners.Get(client, listener.ID).Extract()
   243  	th.AssertNoErr(t, err)
   244  
   245  	tools.PrintResource(t, newListener)
   246  
   247  	th.AssertEquals(t, newListener.DefaultPoolID, "")
   248  
   249  	// Member
   250  	member, err := CreateMember(t, client, lb, newPool, subnet.ID, subnet.CIDR)
   251  	th.AssertNoErr(t, err)
   252  	defer DeleteMember(t, client, lb.ID, pool.ID, member.ID)
   253  
   254  	memberName := ""
   255  	newWeight := tools.RandomInt(11, 100)
   256  	updateMemberOpts := pools.UpdateMemberOpts{
   257  		Name:   &memberName,
   258  		Weight: &newWeight,
   259  	}
   260  	_, err = pools.UpdateMember(client, pool.ID, member.ID, updateMemberOpts).Extract()
   261  	th.AssertNoErr(t, err)
   262  
   263  	if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE"); err != nil {
   264  		t.Fatalf("Timed out waiting for loadbalancer to become active")
   265  	}
   266  
   267  	newMember, err := pools.GetMember(client, pool.ID, member.ID).Extract()
   268  	th.AssertNoErr(t, err)
   269  
   270  	tools.PrintResource(t, newMember)
   271  	th.AssertEquals(t, newMember.Name, memberName)
   272  	th.AssertEquals(t, newMember.Weight, newWeight)
   273  
   274  	// Monitor
   275  	monitor, err := CreateMonitor(t, client, lb, newPool)
   276  	th.AssertNoErr(t, err)
   277  	defer DeleteMonitor(t, client, lb.ID, monitor.ID)
   278  
   279  	monName := ""
   280  	newDelay := tools.RandomInt(20, 30)
   281  	updateMonitorOpts := monitors.UpdateOpts{
   282  		Name:  &monName,
   283  		Delay: newDelay,
   284  	}
   285  	_, err = monitors.Update(client, monitor.ID, updateMonitorOpts).Extract()
   286  	th.AssertNoErr(t, err)
   287  
   288  	if err := WaitForLoadBalancerState(client, lb.ID, "ACTIVE"); err != nil {
   289  		t.Fatalf("Timed out waiting for loadbalancer to become active")
   290  	}
   291  
   292  	newMonitor, err := monitors.Get(client, monitor.ID).Extract()
   293  	th.AssertNoErr(t, err)
   294  
   295  	tools.PrintResource(t, newMonitor)
   296  
   297  	th.AssertEquals(t, newMonitor.Name, monName)
   298  	th.AssertEquals(t, newMonitor.Delay, newDelay)
   299  }