feat(client): add WithZones and WithRegions options (#1416)

Co-authored-by: Rémy Léone <[email protected]>
Co-authored-by: jaime Bernabe <[email protected]>

Author: 3 people

example_test.go

@@ -80,6 +80,30 @@ func Example_listServers() {
 	fmt.Println(response)
 }
 
+func Example_listServersWithZones() {
+	// Create a Scaleway client
+	client, err := scw.NewClient(
+		scw.WithAuth("ACCESS_KEY", "SECRET_KEY"), // Get your credentials at https://console.scaleway.com/project/credentials
+	)
+	if err != nil {
+		// handle error
+	}
+
+	// Create SDK objects for Scaleway Instance product
+	instanceAPI := instance.NewAPI(client)
+
+	// Call the ListServers method on the Instance SDK
+	response, err := instanceAPI.ListServers(&instance.ListServersRequest{},
+		// Add WithZones option to list servers from multiple zones
+		scw.WithZones(scw.ZoneFrPar1, scw.ZoneNlAms1, scw.ZonePlWaw1))
+	if err != nil {
+		// handle error
+	}
+
+	// Do something with the response...
+	fmt.Println(response)
+}
+
 func Example_createServer() {
 	// Create a Scaleway client
 	client, err := scw.NewClient(

internal/generic/sort.go

@@ -0,0 +1,17 @@
+package generic
+
+import (
+	"reflect"
+	"sort"
+)
+
+// SortSliceByField sorts given slice of struct by passing the specified field to given compare function
+// given slice must be a slice of Ptr
+func SortSliceByField(list interface{}, field string, compare func(interface{}, interface{}) bool) {
+	listValue := reflect.ValueOf(list)
+	sort.SliceStable(list, func(i, j int) bool {
+		field1 := listValue.Index(i).Elem().FieldByName(field).Interface()
+		field2 := listValue.Index(j).Elem().FieldByName(field).Interface()
+		return compare(field1, field2)
+	})
+}

internal/generic/sort_test.go

@@ -0,0 +1,24 @@
+package generic
+
+import (
+	"testing"
+
+	"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
+)
+
+func Test_SortSliceByField(t *testing.T) {
+	type Elem struct {
+		Field string
+	}
+	elems := []*Elem{
+		{"2"},
+		{"1"},
+		{"3"},
+	}
+	SortSliceByField(elems, "Field", func(i interface{}, i2 interface{}) bool {
+		return i.(string) < i2.(string)
+	})
+	testhelpers.Assert(t, elems[0].Field == "1", "slice is not sorted")
+	testhelpers.Assert(t, elems[1].Field == "2", "slice is not sorted")
+	testhelpers.Assert(t, elems[2].Field == "3", "slice is not sorted")
+}

scw/client.go

@@ -3,18 +3,22 @@ package scw
 import (
 	"crypto/tls"
 	"encoding/json"
+	"fmt"
 	"io"
 	"math"
 	"net"
 	"net/http"
 	"net/http/httputil"
 	"reflect"
 	"strconv"
+	"strings"
+	"sync"
 	"sync/atomic"
 	"time"
 
 	"github.com/scaleway/scaleway-sdk-go/internal/auth"
 	"github.com/scaleway/scaleway-sdk-go/internal/errors"
+	"github.com/scaleway/scaleway-sdk-go/internal/generic"
 	"github.com/scaleway/scaleway-sdk-go/logger"
 )
 
@@ -164,6 +168,13 @@ func (c *Client) Do(req *ScalewayRequest, res interface{}, opts ...RequestOption
 		req.auth = c.auth
 	}
 
+	if req.zones != nil {
+		return c.doListZones(req, res, req.zones)
+	}
+	if req.regions != nil {
+		return c.doListRegions(req, res, req.regions)
+	}
+
 	if req.allPages {
 		return c.doListAll(req, res)
 	}
@@ -340,6 +351,182 @@ func (c *Client) doListAll(req *ScalewayRequest, res interface{}) (err error) {
 	return errors.New("%T does not support pagination", res)
 }
 
+// doListLocalities collects all localities using mutliple list requests and aggregate all results on a lister response
+// results is sorted by locality
+func (c *Client) doListLocalities(req *ScalewayRequest, res lister, localities []string) (err error) {
+	path := req.Path
+	if !strings.Contains(path, "%locality%") {
+		return fmt.Errorf("request is not a valid locality request")
+	}
+	// Requests are parallelized
+	responseMutex := sync.Mutex{}
+	requestGroup := sync.WaitGroup{}
+	errChan := make(chan error, len(localities))
+
+	requestGroup.Add(len(localities))
+	for _, locality := range localities {
+		go func(locality string) {
+			defer requestGroup.Done()
+			// Request is cloned as doListAll will change header
+			// We remove zones as it would recurse in the same function
+			req := req.clone()
+			req.zones = []Zone(nil)
+			req.Path = strings.ReplaceAll(path, "%locality%", locality)
+
+			// We create a new response that we append to main response
+			zoneResponse := newVariableFromType(res)
+			err := c.Do(req, zoneResponse)
+			if err != nil {
+				errChan <- err
+			}
+			responseMutex.Lock()
+			_, err = res.UnsafeAppend(zoneResponse)
+			responseMutex.Unlock()
+			if err != nil {
+				errChan <- err
+			}
+		}(locality)
+	}
+	requestGroup.Wait()
+
+L: // We gather potential errors and return them all together
+	for {
+		select {
+		case newErr := <-errChan:
+			err = errors.Wrap(err, newErr.Error())
+		default:
+			break L
+		}
+	}
+	close(errChan)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// doListZones collects all zones using multiple list requests and aggregate all results on a single response.
+// result is sorted by zone
+func (c *Client) doListZones(req *ScalewayRequest, res interface{}, zones []Zone) (err error) {
+	if response, isLister := res.(lister); isLister {
+		// Prepare request with %zone% that can be replaced with actual zone
+		for _, zone := range AllZones {
+			if strings.Contains(req.Path, string(zone)) {
+				req.Path = strings.ReplaceAll(req.Path, string(zone), "%locality%")
+				break
+			}
+		}
+		if !strings.Contains(req.Path, "%locality%") {
+			return fmt.Errorf("request is not a valid zoned request")
+		}
+		localities := make([]string, 0, len(zones))
+		for _, zone := range zones {
+			localities = append(localities, string(zone))
+		}
+
+		err := c.doListLocalities(req, response, localities)
+		if err != nil {
+			return fmt.Errorf("failed to list localities: %w", err)
+		}
+
+		sortResponseByZones(res, zones)
+		return nil
+	}
+
+	return errors.New("%T does not support pagination", res)
+}
+
+// doListRegions collects all regions using multiple list requests and aggregate all results on a single response.
+// result is sorted by region
+func (c *Client) doListRegions(req *ScalewayRequest, res interface{}, regions []Region) (err error) {
+	if response, isLister := res.(lister); isLister {
+		// Prepare request with %locality% that can be replaced with actual region
+		for _, region := range AllRegions {
+			if strings.Contains(req.Path, string(region)) {
+				req.Path = strings.ReplaceAll(req.Path, string(region), "%locality%")
+				break
+			}
+		}
+		if !strings.Contains(req.Path, "%locality%") {
+			return fmt.Errorf("request is not a valid zoned request")
+		}
+		localities := make([]string, 0, len(regions))
+		for _, region := range regions {
+			localities = append(localities, string(region))
+		}
+
+		err := c.doListLocalities(req, response, localities)
+		if err != nil {
+			return fmt.Errorf("failed to list localities: %w", err)
+		}
+
+		sortResponseByRegions(res, regions)
+		return nil
+	}
+
+	return errors.New("%T does not support pagination", res)
+}
+
+// sortSliceByZones sorts a slice of struct using a Zone field that should exist
+func sortSliceByZones(list interface{}, zones []Zone) {
+	zoneMap := map[Zone]int{}
+	for i, zone := range zones {
+		zoneMap[zone] = i
+	}
+	generic.SortSliceByField(list, "Zone", func(i interface{}, i2 interface{}) bool {
+		return zoneMap[i.(Zone)] < zoneMap[i2.(Zone)]
+	})
+}
+
+// sortSliceByRegions sorts a slice of struct using a Region field that should exist
+func sortSliceByRegions(list interface{}, regions []Region) {
+	regionMap := map[Region]int{}
+	for i, region := range regions {
+		regionMap[region] = i
+	}
+	generic.SortSliceByField(list, "Region", func(i interface{}, i2 interface{}) bool {
+		return regionMap[i.(Region)] < regionMap[i2.(Region)]
+	})
+}
+
+// sortResponseByZones find first field that is a slice in a struct and sort it by zone
+func sortResponseByZones(res interface{}, zones []Zone) {
+	// res may be ListServersResponse
+	//
+	// type ListServersResponse struct {
+	//	TotalCount uint32 `json:"total_count"`
+	//	Servers []*Server `json:"servers"`
+	// }
+	// We iterate over fields searching for the slice one to sort it
+	resType := reflect.TypeOf(res).Elem()
+	fields := reflect.VisibleFields(resType)
+	for _, field := range fields {
+		if field.Type.Kind() == reflect.Slice {
+			sortSliceByZones(reflect.ValueOf(res).Elem().FieldByName(field.Name).Interface(), zones)
+			return
+		}
+	}
+}
+
+// sortResponseByRegions find first field that is a slice in a struct and sort it by region
+func sortResponseByRegions(res interface{}, regions []Region) {
+	// res may be ListServersResponse
+	//
+	// type ListServersResponse struct {
+	//	TotalCount uint32 `json:"total_count"`
+	//	Servers []*Server `json:"servers"`
+	// }
+	// We iterate over fields searching for the slice one to sort it
+	resType := reflect.TypeOf(res).Elem()
+	fields := reflect.VisibleFields(resType)
+	for _, field := range fields {
+		if field.Type.Kind() == reflect.Slice {
+			sortSliceByRegions(reflect.ValueOf(res).Elem().FieldByName(field.Name).Interface(), regions)
+			return
+		}
+	}
+}
+
 // newVariableFromType returns a variable set to the zero value of the given type
 func newVariableFromType(t interface{}) interface{} {
 	// reflect.New always create a pointer, that's why we use reflect.Indirect before

scw/request.go

@@ -24,6 +24,8 @@ type ScalewayRequest struct {
 	ctx      context.Context
 	auth     auth.Auth
 	allPages bool
+	zones    []Zone
+	regions  []Region
 }
 
 // getAllHeaders constructs a http.Header object and aggregates all headers into the object.
@@ -102,3 +104,19 @@ func (req *ScalewayRequest) validate() error {
 	// nothing so far
 	return nil
 }
+
+func (req *ScalewayRequest) clone() *ScalewayRequest {
+	clonedReq := &ScalewayRequest{
+		Method:   req.Method,
+		Path:     req.Path,
+		Headers:  req.Headers.Clone(),
+		ctx:      req.ctx,
+		auth:     req.auth,
+		allPages: req.allPages,
+		zones:    req.zones,
+	}
+	if req.Query != nil {
+		clonedReq.Query = url.Values(http.Header(req.Query).Clone())
+	}
+	return clonedReq
+}

scw/request_option.go

@@ -30,3 +30,21 @@ func WithAuthRequest(accessKey, secretKey string) RequestOption {
 		s.auth = auth.NewToken(accessKey, secretKey)
 	}
 }
+
+// WithZones aggregate results from requested zones in the response of a List request.
+// response rows are sorted by zone using order of given zones
+// Will error when pagination is not supported on the request.
+func WithZones(zones ...Zone) RequestOption {
+	return func(s *ScalewayRequest) {
+		s.zones = append(s.zones, zones...)
+	}
+}
+
+// WithRegions aggregate results from requested regions in the response of a List request.
+// response rows are sorted by region using order of given regions
+// Will error when pagination is not supported on the request.
+func WithRegions(regions ...Region) RequestOption {
+	return func(s *ScalewayRequest) {
+		s.regions = append(s.regions, regions...)
+	}
+}