feat(sdk): add qos limits capability to cloudian sdk

internal/sdk/cloudian/datasize.go

@@ -0,0 +1,44 @@
+package cloudian
+
+import (
+	"fmt"
+)
+
+// Construct by e.g. 3 * TB
+type ByteSize uint64
+
+const (
+	KB ByteSize = 1
+	MB          = KB << 10
+	GB          = MB << 10
+	TB          = GB << 10
+)
+
+func (b ByteSize) KB() uint64 {
+	return uint64(b)
+}
+
+func (b ByteSize) MB() float64 {
+	v := b / MB
+	r := b % MB
+	return float64(v) + float64(r)/float64(MB)
+}
+
+func (b ByteSize) GB() float64 {
+	v := b / GB
+	r := b % GB
+	return float64(v) + float64(r)/float64(GB)
+}
+
+func (b ByteSize) TB() float64 {
+	v := b / TB
+	r := b % TB
+	return float64(v) + float64(r)/float64(TB)
+}
+
+func (b ByteSize) KBString() string {
+	if b == 0 {
+		return "0"
+	}
+	return fmt.Sprintf("%d", b/KB)
+}

internal/sdk/cloudian/datasize_test.go

@@ -0,0 +1,14 @@
+package cloudian
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestRenderTerraBytesAsKiloBytes(t *testing.T) {
+	expected := fmt.Sprintf("%d", 3*1024*1024*1024)
+
+	if actual := (3 * TB).KBString(); actual != expected {
+		t.Errorf("Expected 3 TB expressed in KB to be %s, got %s", expected, actual)
+	}
+}

internal/sdk/cloudian/sdk.go

@@ -112,6 +112,30 @@ type SecurityInfo struct {
 	SecretKey string `json:"secretKey"`
 }
 
+// QoS is the Cloudian API's term for limits on quotas, counts and rates enforced on a `User`
+type QoS struct {
+	// Max storage quota
+	StorageQuota ByteSize
+	// Warning limit storage quota
+	StorageQuotaWarning ByteSize
+	// Max storage quota in number of objects
+	StorageQuotaCount uint64
+	// Warning limit storage quota in number of objects
+	StorageQuotaCountWarning uint64
+	// Max nr of HTTP requests per minute
+	RequestRatePrMin uint64
+	// Warning limit nr of HTTP requests per minute
+	RequestRatePrMinWarning uint64
+	// Max inbound datarate in ByteSize per minute
+	DataRatePrMinInbound ByteSize
+	// Warning limit inbound datarate in ByteSize per minute
+	DataRatePrMinInboundWarning ByteSize
+	// Max outbound datarate in ByteSize per minute
+	DataRatePrMinOutbound ByteSize
+	// Warning limit outbound datarate in ByteSize per minute
+	DataRatePrMinOutboundWarning ByteSize
+}
+
 var ErrNotFound = errors.New("not found")
 
 // WithInsecureTLSVerify skips the TLS validation of the server certificate when `insecure` is true.
@@ -405,6 +429,40 @@ func (client Client) GetGroup(ctx context.Context, groupID string) (*Group, erro
 	}
 }
 
+func qosQueryMap(user User, qos QoS) map[string]string {
+	return map[string]string{
+		"userId":               user.UserID,
+		"groupId":              user.GroupID,
+		"hlStorageQuotaKBytes": qos.StorageQuota.KBString(),
+		"wlStorageQuotaKBytes": qos.StorageQuotaWarning.KBString(),
+		"hlStorageQuotaCount":  fmt.Sprintf("%d", qos.StorageQuotaCount),
+		"wlStorageQuotaCount":  fmt.Sprintf("%d", qos.StorageQuotaCountWarning),
+		"hlRequestRate":        fmt.Sprintf("%d", qos.RequestRatePrMin),
+		"wlRequestRate":        fmt.Sprintf("%d", qos.RequestRatePrMinWarning),
+		"hlDataKBytesIn":       qos.DataRatePrMinInbound.KBString(),
+		"wlDataKBytesIn":       qos.DataRatePrMinInboundWarning.KBString(),
+		"hlDataKBytesOut":      qos.DataRatePrMinOutbound.KBString(),
+		"wlDataKBytesOut":      qos.DataRatePrMinOutboundWarning.KBString(),
+	}
+}
+
+// CreateQuota sets the QoS limits for a `User`. To change QoS limits, a delete and recreate is necessary.
+func (client Client) CreateQuota(ctx context.Context, user User, qos QoS) error {
+	resp, err := client.newRequest(ctx).
+		SetQueryParams(qosQueryMap(user, qos)).
+		Post("/qos/limits")
+	if err != nil {
+		return err
+	}
+
+	switch resp.StatusCode() {
+	case 200:
+		return nil
+	default:
+		return fmt.Errorf("SET quota unexpected status: %d", resp.StatusCode())
+	}
+}
+
 func (client Client) newRequest(ctx context.Context) *resty.Request {
 	return client.client.R().
 		SetContext(ctx).

internal/sdk/cloudian/sdk_test.go

@@ -150,6 +150,43 @@ func TestListUsers(t *testing.T) {
 
 }
 
+func TestQosQueryMap(t *testing.T) {
+	expected := map[string]string{
+		"userId":               "1",
+		"groupId":              "1",
+		"hlStorageQuotaKBytes": fmt.Sprintf("%d", 1*1024*1024),
+		"wlStorageQuotaKBytes": fmt.Sprintf("%d", 750*1024),
+		"hlStorageQuotaCount":  "1000",
+		"wlStorageQuotaCount":  "750",
+		"hlRequestRate":        "200",
+		"wlRequestRate":        "150",
+		"hlDataKBytesIn":       fmt.Sprintf("%d", 1*1024*1024),
+		"wlDataKBytesIn":       fmt.Sprintf("%d", 750*1024),
+		"hlDataKBytesOut":      fmt.Sprintf("%d", 1*1024*1024),
+		"wlDataKBytesOut":      fmt.Sprintf("%d", 750*1024),
+	}
+	actual := qosQueryMap(
+		User{
+			UserID:  "1",
+			GroupID: "1",
+		},
+		QoS{
+			StorageQuota:                 1 * GB,
+			StorageQuotaWarning:          750 * MB,
+			StorageQuotaCount:            1000,
+			StorageQuotaCountWarning:     750,
+			RequestRatePrMin:             200,
+			RequestRatePrMinWarning:      150,
+			DataRatePrMinInbound:         1 * GB,
+			DataRatePrMinInboundWarning:  750 * MB,
+			DataRatePrMinOutbound:        1 * GB,
+			DataRatePrMinOutboundWarning: 750 * MB,
+		})
+	if diff := cmp.Diff(expected, actual); diff != "" {
+		t.Errorf("qosQueryMap() mismatch (-want +got):\n%s", diff)
+	}
+}
+
 func mockBy(handler http.HandlerFunc) (*Client, *httptest.Server) {
 	mockServer := httptest.NewServer(handler)
 	return NewClient(mockServer.URL, ""), mockServer