[Refactor] Compute

acceptance/openstack/cce/helpers.go

@@ -126,7 +126,7 @@ func CreateKeypair(t *testing.T) string {
 	opts := keypairs.CreateOpts{
 		Name: tools.RandomString("cce-nodes-", 4),
 	}
-	_, err = keypairs.Create(client, opts).Extract()
+	_, err = keypairs.Create(client, opts)
 	th.AssertNoErr(t, err)
 	return opts.Name
 }
@@ -135,5 +135,5 @@ func DeleteKeypair(t *testing.T, kp string) {
 	client, err := clients.NewComputeV2Client()
 	th.AssertNoErr(t, err)
 
-	th.AssertNoErr(t, keypairs.Delete(client, kp).ExtractErr())
+	th.AssertNoErr(t, keypairs.Delete(client, kp))
 }

acceptance/openstack/common.go

@@ -33,9 +33,7 @@ func DefaultSecurityGroup(t *testing.T) string {
 	client, err := clients.NewComputeV2Client()
 	th.AssertNoErr(t, err)
 
-	securityGroupPages, err := secgroups.List(client).AllPages()
-	th.AssertNoErr(t, err)
-	securityGroups, err := secgroups.ExtractSecurityGroups(securityGroupPages)
+	securityGroups, err := secgroups.List(client)
 	th.AssertNoErr(t, err)
 	var sgId string
 	for _, val := range securityGroups {
@@ -54,11 +52,11 @@ func CreateSecurityGroup(t *testing.T) string {
 	client, err := clients.NewComputeV2Client()
 	th.AssertNoErr(t, err)
 
-	createSGOpts := secgroups.CreateOpts{
+	createSGOpts := secgroups.GroupOpts{
 		Name:        tools.RandomString("acc-sg-", 3),
 		Description: "security group for acceptance testing",
 	}
-	secGroup, err := secgroups.Create(client, createSGOpts).Extract()
+	secGroup, err := secgroups.Create(client, createSGOpts)
 	th.AssertNoErr(t, err)
 
 	t.Logf("Security group %s was created", secGroup.ID)

acceptance/openstack/compute/v2/servers_test.go

@@ -68,29 +68,29 @@ func TestServerLifecycle(t *testing.T) {
 		},
 	}
 
-	ecs, err := servers.Create(client, createOpts).Extract()
+	ecs, err := servers.Create(client, createOpts)
 	th.AssertNoErr(t, err)
 
 	err = servers.WaitForStatus(client, ecs.ID, "ACTIVE", 1200)
 	th.AssertNoErr(t, err)
 	t.Logf("Created ECSv2: %s", ecs.ID)
 
-	ecs, err = servers.Get(client, ecs.ID).Extract()
+	ecs, err = servers.Get(client, ecs.ID)
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, ecsName, ecs.Name)
 
-	nicInfo, err := servers.GetNICs(client, ecs.ID).Extract()
+	nicInfo, err := servers.GetNICs(client, ecs.ID)
 	th.AssertNoErr(t, err)
 	tools.PrintResource(t, nicInfo)
 
 	defer func() {
 		t.Logf("Attempting to delete ECSv2: %s", ecs.ID)
 
-		_, err := servers.Delete(client, ecs.ID).ExtractJobResponse()
+		err := servers.Delete(client, ecs.ID)
 		th.AssertNoErr(t, err)
 
 		err = golangsdk.WaitFor(1200, func() (bool, error) {
-			_, err := servers.Get(client, ecs.ID).Extract()
+			_, err := servers.Get(client, ecs.ID)
 			if err != nil {
 				if _, ok := err.(golangsdk.ErrDefault400); ok {
 					time.Sleep(10 * time.Second)
@@ -112,13 +112,13 @@ func TestServerLifecycle(t *testing.T) {
 		Name: ecsName,
 	}
 
-	_, err = servers.Update(client, ecs.ID, updateOpts).Extract()
+	_, err = servers.Update(client, ecs.ID, updateOpts)
 	th.AssertNoErr(t, err)
 
 	t.Logf("ECSv2 successfully updated: %s", ecs.ID)
 	th.AssertNoErr(t, err)
 
-	newECS, err := servers.Get(client, ecs.ID).Extract()
+	newECS, err := servers.Get(client, ecs.ID)
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, ecsName, newECS.Name)
 }

acceptance/openstack/csbs/v1/policies_test.go

@@ -206,7 +206,7 @@ func createComputeInstance(t *testing.T, subnetID string) *servers.Server {
 		},
 	}
 
-	server, err := servers.Create(client, opts).Extract()
+	server, err := servers.Create(client, opts)
 	th.AssertNoErr(t, err)
 	err = waitForComputeInstanceAvailable(client, 600, server.ID)
 	th.AssertNoErr(t, err)
@@ -221,15 +221,15 @@ func deleteComputeInstance(t *testing.T, instanceId string) {
 	client, err := clients.NewComputeV2Client()
 	th.AssertNoErr(t, err)
 
-	err = servers.Delete(client, instanceId).ExtractErr()
+	err = servers.Delete(client, instanceId)
 	th.AssertNoErr(t, err)
 	err = waitForComputeInstanceDelete(client, 600, instanceId)
 	th.AssertNoErr(t, err)
 }
 
 func waitForComputeInstanceAvailable(client *golangsdk.ServiceClient, secs int, instanceId string) error {
 	return golangsdk.WaitFor(secs, func() (bool, error) {
-		server, err := servers.Get(client, instanceId).Extract()
+		server, err := servers.Get(client, instanceId)
 		if err != nil {
 			return false, err
 		}
@@ -242,7 +242,7 @@ func waitForComputeInstanceAvailable(client *golangsdk.ServiceClient, secs int,
 
 func waitForComputeInstanceDelete(client *golangsdk.ServiceClient, secs int, instanceId string) error {
 	return golangsdk.WaitFor(secs, func() (bool, error) {
-		server, err := servers.Get(client, instanceId).Extract()
+		server, err := servers.Get(client, instanceId)
 		if err != nil {
 			if _, ok := err.(golangsdk.ErrDefault404); ok {
 				return true, nil

internal/build/backward_test.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/opentelekomcloud/gophertelekomcloud/internal/extract"
 	"github.com/opentelekomcloud/gophertelekomcloud/openstack/common/tags"
-	"github.com/opentelekomcloud/gophertelekomcloud/openstack/compute/v2/servers"
 	"github.com/opentelekomcloud/gophertelekomcloud/openstack/dns/v2/zones"
 	"github.com/opentelekomcloud/gophertelekomcloud/openstack/objectstorage/v1/accounts"
 	"github.com/stretchr/testify/require"
@@ -18,24 +17,6 @@ import (
 //
 // Those tests can be used as an example of replacing deprecated methods.
 
-func TestCompareQueryOpts(t *testing.T) {
-	listOpts := &servers.ListOpts{
-		ChangesSince: "2012-06-12",
-		Image:        "some-random-image",
-		Flavor:       "top-flavor",
-		Limit:        64,
-		AllTenants:   true,
-	}
-
-	expected, err := listOpts.ToServerListQuery()
-	require.NoError(t, err)
-
-	actual, err := QueryString(listOpts)
-	require.NoError(t, err)
-
-	require.EqualValues(t, expected, actual.String()) // inside ToServerListQuery `.String()` for URL is called
-}
-
 func TestCompareHeaderOpts(t *testing.T) {
 	headerOpts := &accounts.UpdateOpts{
 		ContentType:       "application/lolson",

openstack/compute/v2/extensions/aggregates/add_host.go

@@ -0,0 +1,26 @@
+package aggregates
+
+import (
+	"strconv"
+
+	"github.com/opentelekomcloud/gophertelekomcloud"
+	"github.com/opentelekomcloud/gophertelekomcloud/internal/build"
+)
+
+type AddHostOpts struct {
+	// The name of the host.
+	Host string `json:"host" required:"true"`
+}
+
+// AddHost makes a request against the API to add host to a specific aggregate.
+func AddHost(client *golangsdk.ServiceClient, aggregateID int, opts AddHostOpts) (*Aggregate, error) {
+	b, err := build.RequestBody(opts, "add_host")
+	if err != nil {
+		return nil, err
+	}
+
+	raw, err := client.Post(client.ServiceURL("os-aggregates", strconv.Itoa(aggregateID), "action"), b, nil, &golangsdk.RequestOpts{
+		OkCodes: []int{200},
+	})
+	return extra(err, raw)
+}

openstack/compute/v2/extensions/aggregates/create.go

@@ -0,0 +1,29 @@
+package aggregates
+
+import (
+	"github.com/opentelekomcloud/gophertelekomcloud"
+	"github.com/opentelekomcloud/gophertelekomcloud/internal/build"
+)
+
+type CreateOpts struct {
+	// The name of the host aggregate.
+	Name string `json:"name" required:"true"`
+	// The availability zone of the host aggregate.
+	// You should use a custom availability zone rather than
+	// the default returned by the os-availability-zone API.
+	// The availability zone must not include ‘:’ in its name.
+	AvailabilityZone string `json:"availability_zone,omitempty"`
+}
+
+// Create makes a request against the API to create an aggregate.
+func Create(client *golangsdk.ServiceClient, opts CreateOpts) (*Aggregate, error) {
+	b, err := build.RequestBody(opts, "aggregate")
+	if err != nil {
+		return nil, err
+	}
+
+	raw, err := client.Post(client.ServiceURL("os-aggregates"), b, nil, &golangsdk.RequestOpts{
+		OkCodes: []int{200},
+	})
+	return extra(err, raw)
+}

openstack/compute/v2/extensions/aggregates/delete.go

@@ -0,0 +1,15 @@
+package aggregates
+
+import (
+	"strconv"
+
+	"github.com/opentelekomcloud/gophertelekomcloud"
+)
+
+// Delete makes a request against the API to delete an aggregate.
+func Delete(client *golangsdk.ServiceClient, aggregateID int) (err error) {
+	_, err = client.Delete(client.ServiceURL("os-aggregates", strconv.Itoa(aggregateID)), &golangsdk.RequestOpts{
+		OkCodes: []int{200},
+	})
+	return
+}

openstack/compute/v2/extensions/aggregates/get.go

@@ -0,0 +1,15 @@
+package aggregates
+
+import (
+	"strconv"
+
+	"github.com/opentelekomcloud/gophertelekomcloud"
+)
+
+// Get makes a request against the API to get details for a specific aggregate.
+func Get(client *golangsdk.ServiceClient, aggregateID int) (*Aggregate, error) {
+	raw, err := client.Get(client.ServiceURL("os-aggregates", strconv.Itoa(aggregateID)), nil, &golangsdk.RequestOpts{
+		OkCodes: []int{200},
+	})
+	return extra(err, raw)
+}

openstack/compute/v2/extensions/aggregates/list.go

@@ -0,0 +1,18 @@
+package aggregates
+
+import (
+	"github.com/opentelekomcloud/gophertelekomcloud"
+	"github.com/opentelekomcloud/gophertelekomcloud/internal/extract"
+)
+
+// List makes a request against the API to list aggregates.
+func List(client *golangsdk.ServiceClient) ([]Aggregate, error) {
+	raw, err := client.Get(client.ServiceURL("os-aggregates"), nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var res []Aggregate
+	err = extract.IntoSlicePtr(raw.Body, &res, "aggregates")
+	return res, err
+}

openstack/compute/v2/extensions/aggregates/remove_host.go

@@ -0,0 +1,26 @@
+package aggregates
+
+import (
+	"strconv"
+
+	"github.com/opentelekomcloud/gophertelekomcloud"
+	"github.com/opentelekomcloud/gophertelekomcloud/internal/build"
+)
+
+type RemoveHostOpts struct {
+	// The name of the host.
+	Host string `json:"host" required:"true"`
+}
+
+// RemoveHost makes a request against the API to remove host from a specific aggregate.
+func RemoveHost(client *golangsdk.ServiceClient, aggregateID int, opts RemoveHostOpts) (*Aggregate, error) {
+	b, err := build.RequestBody(opts, "remove_host")
+	if err != nil {
+		return nil, err
+	}
+
+	raw, err := client.Post(client.ServiceURL("os-aggregates", strconv.Itoa(aggregateID), "action"), b, nil, &golangsdk.RequestOpts{
+		OkCodes: []int{200},
+	})
+	return extra(err, raw)
+}