Merge branch 'master' into master

Author: berndverst

bindings/azure/blobstorage/blobstorage.go

@@ -8,19 +8,91 @@ package blobstorage
 import (
 	"testing"
 
+	"github.com/Azure/azure-storage-blob-go/azblob"
 	"github.com/dapr/components-contrib/bindings"
 	"github.com/dapr/kit/logger"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestParseMetadata(t *testing.T) {
 	m := bindings.Metadata{}
-	m.Properties = map[string]string{"storageAccount": "account", "storageAccessKey": "key", "container": "test", "decodeBase64": "true"}
-	blonStorage := NewAzureBlobStorage(logger.NewLogger("test"))
-	meta, err := blonStorage.parseMetadata(m)
-	assert.Nil(t, err)
-	assert.Equal(t, "test", meta.Container)
-	assert.Equal(t, "account", meta.StorageAccount)
-	assert.Equal(t, "key", meta.StorageAccessKey)
-	assert.Equal(t, "true", meta.DecodeBase64)
+	blobStorage := NewAzureBlobStorage(logger.NewLogger("test"))
+
+	t.Run("parse all metadata", func(t *testing.T) {
+		m.Properties = map[string]string{
+			"storageAccount":    "account",
+			"storageAccessKey":  "key",
+			"container":         "test",
+			"getBlobRetryCount": "5",
+			"decodeBase64":      "true",
+		}
+		meta, err := blobStorage.parseMetadata(m)
+		assert.Nil(t, err)
+		assert.Equal(t, "test", meta.Container)
+		assert.Equal(t, "account", meta.StorageAccount)
+		assert.Equal(t, "key", meta.StorageAccessKey)
+		assert.Equal(t, true, meta.DecodeBase64)
+		assert.Equal(t, 5, meta.GetBlobRetryCount)
+		assert.Equal(t, azblob.PublicAccessNone, meta.PublicAccessLevel)
+	})
+
+	t.Run("parse metadata with publicAccessLevel = blob", func(t *testing.T) {
+		m.Properties = map[string]string{
+			"publicAccessLevel": "blob",
+		}
+		meta, err := blobStorage.parseMetadata(m)
+		assert.Nil(t, err)
+		assert.Equal(t, azblob.PublicAccessBlob, meta.PublicAccessLevel)
+	})
+
+	t.Run("parse metadata with publicAccessLevel = container", func(t *testing.T) {
+		m.Properties = map[string]string{
+			"publicAccessLevel": "container",
+		}
+		meta, err := blobStorage.parseMetadata(m)
+		assert.Nil(t, err)
+		assert.Equal(t, azblob.PublicAccessContainer, meta.PublicAccessLevel)
+	})
+
+	t.Run("parse metadata with invalid publicAccessLevel", func(t *testing.T) {
+		m.Properties = map[string]string{
+			"publicAccessLevel": "invalid",
+		}
+		_, err := blobStorage.parseMetadata(m)
+		assert.Error(t, err)
+	})
+}
+
+func TestGetOption(t *testing.T) {
+	blobStorage := NewAzureBlobStorage(logger.NewLogger("test"))
+
+	t.Run("return error if blobName is missing", func(t *testing.T) {
+		r := bindings.InvokeRequest{}
+		_, err := blobStorage.get(&r)
+		if assert.Error(t, err) {
+			assert.Equal(t, ErrMissingBlobName, err)
+		}
+	})
+}
+
+func TestDeleteOption(t *testing.T) {
+	blobStorage := NewAzureBlobStorage(logger.NewLogger("test"))
+
+	t.Run("return error if blobName is missing", func(t *testing.T) {
+		r := bindings.InvokeRequest{}
+		_, err := blobStorage.delete(&r)
+		if assert.Error(t, err) {
+			assert.Equal(t, ErrMissingBlobName, err)
+		}
+	})
+
+	t.Run("return error for invalid deleteSnapshots", func(t *testing.T) {
+		r := bindings.InvokeRequest{}
+		r.Metadata = map[string]string{
+			"blobName":        "foo",
+			"deleteSnapshots": "invalid",
+		}
+		_, err := blobStorage.delete(&r)
+		assert.Error(t, err)
+	})
 }

bindings/azure/blobstorage/blobstorage_test.go

@@ -0,0 +1,123 @@
+// ------------------------------------------------------------
+// Copyright (c) Microsoft Corporation and Dapr Contributors.
+// Licensed under the MIT License.
+// ------------------------------------------------------------
+
+package cosmosgraphdb
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/dapr/components-contrib/bindings"
+	"github.com/dapr/kit/logger"
+	gremcos "github.com/supplyon/gremcos"
+)
+
+const (
+	queryOperation bindings.OperationKind = "query"
+
+	// keys from request's Data
+	commandGremlinKey = "gremlin"
+
+	// keys from response's Data
+	respGremlinKey   = "gremlin"
+	respOpKey        = "operation"
+	respStartTimeKey = "start-time"
+	respEndTimeKey   = "end-time"
+	respDurationKey  = "duration"
+)
+
+// CosmosGraphDB allows performing state operations on collections
+type CosmosGraphDB struct {
+	metadata *cosmosGraphDBCredentials
+	client   *gremcos.Cosmos
+	logger   logger.Logger
+}
+
+type cosmosGraphDBCredentials struct {
+	URL       string `json:"url"`
+	MasterKey string `json:"masterKey"`
+	Username  string `json:"username"`
+}
+
+// NewCosmosGraphDB returns a new CosmosGraphDB instance
+func NewCosmosGraphDB(logger logger.Logger) *CosmosGraphDB {
+	return &CosmosGraphDB{logger: logger}
+}
+
+// Init performs CosmosDB connection parsing and connecting
+func (c *CosmosGraphDB) Init(metadata bindings.Metadata) error {
+	c.logger.Debug("Initializing Cosmos Graph DB binding")
+
+	m, err := c.parseMetadata(metadata)
+	if err != nil {
+		return err
+	}
+	c.metadata = m
+	client, err := gremcos.New(c.metadata.URL,
+		gremcos.WithAuth(c.metadata.Username, c.metadata.MasterKey),
+	)
+	if err != nil {
+		return errors.New("CosmosGraphDB Error: failed to create the Cosmos Graph DB connector")
+	}
+
+	c.client = client
+
+	return nil
+}
+
+func (c *CosmosGraphDB) parseMetadata(metadata bindings.Metadata) (*cosmosGraphDBCredentials, error) {
+	b, err := json.Marshal(metadata.Properties)
+	if err != nil {
+		return nil, err
+	}
+
+	var creds cosmosGraphDBCredentials
+	err = json.Unmarshal(b, &creds)
+	if err != nil {
+		return nil, err
+	}
+
+	return &creds, nil
+}
+
+func (c *CosmosGraphDB) Operations() []bindings.OperationKind {
+	return []bindings.OperationKind{queryOperation}
+}
+
+func (c *CosmosGraphDB) Invoke(req *bindings.InvokeRequest) (*bindings.InvokeResponse, error) {
+	var jsonPoint map[string]interface{}
+	err := json.Unmarshal(req.Data, &jsonPoint)
+	if err != nil {
+		return nil, errors.New("CosmosGraphDB Error: Cannot convert request data")
+	}
+
+	gq := fmt.Sprintf("%s", jsonPoint[commandGremlinKey])
+
+	if gq == "" {
+		return nil, errors.New("CosmosGraphDB Error: missing data - gremlin query not set")
+	}
+	startTime := time.Now().UTC()
+	resp := &bindings.InvokeResponse{
+		Metadata: map[string]string{
+			respOpKey:        string(req.Operation),
+			respGremlinKey:   gq,
+			respStartTimeKey: startTime.Format(time.RFC3339Nano),
+		},
+	}
+	d, err := c.client.Execute(gq)
+	if err != nil {
+		return nil, errors.New("CosmosGraphDB Error:error excuting gremlin")
+	}
+	if len(d) > 0 {
+		resp.Data = d[0].Result.Data
+	}
+	endTime := time.Now().UTC()
+	resp.Metadata[respEndTimeKey] = endTime.Format(time.RFC3339Nano)
+	resp.Metadata[respDurationKey] = endTime.Sub(startTime).String()
+
+	return resp, nil
+}

bindings/azure/cosmosgraphdb/cosmosgraphdb.go

@@ -0,0 +1,25 @@
+// ------------------------------------------------------------
+// Copyright (c) Microsoft Corporation and Dapr Contributors.
+// Licensed under the MIT License.
+// ------------------------------------------------------------
+
+package cosmosgraphdb
+
+import (
+	"testing"
+
+	"github.com/dapr/components-contrib/bindings"
+	"github.com/dapr/kit/logger"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseMetadata(t *testing.T) {
+	m := bindings.Metadata{}
+	m.Properties = map[string]string{"Url": "a", "masterKey": "a", "username": "a"}
+	cosmosgraphdb := CosmosGraphDB{logger: logger.NewLogger("test")}
+	im, err := cosmosgraphdb.parseMetadata(m)
+	assert.Nil(t, err)
+	assert.Equal(t, "a", im.URL)
+	assert.Equal(t, "a", im.MasterKey)
+	assert.Equal(t, "a", im.Username)
+}

bindings/azure/cosmosgraphdb/cosmosgraphdb_test.go

@@ -5,6 +5,11 @@
 
 package bindings
 
+import (
+	"fmt"
+	"strconv"
+)
+
 // InvokeRequest is the object given to a dapr output binding
 type InvokeRequest struct {
 	Data      []byte            `json:"data"`
@@ -22,3 +27,31 @@ const (
 	DeleteOperation OperationKind = "delete"
 	ListOperation   OperationKind = "list"
 )
+
+// GetMetadataAsBool parses metadata as bool
+func (r *InvokeRequest) GetMetadataAsBool(key string) (bool, error) {
+	if val, ok := r.Metadata[key]; ok {
+		boolVal, err := strconv.ParseBool(val)
+		if err != nil {
+			return false, fmt.Errorf("error parsing metadata `%s` with value `%s` as bool: %w", key, val, err)
+		}
+
+		return boolVal, nil
+	}
+
+	return false, nil
+}
+
+// GetMetadataAsBool parses metadata as int64
+func (r *InvokeRequest) GetMetadataAsInt64(key string, bitSize int) (int64, error) {
+	if val, ok := r.Metadata[key]; ok {
+		intVal, err := strconv.ParseInt(val, 10, bitSize)
+		if err != nil {
+			return 0, fmt.Errorf("error parsing metadata `%s` with value `%s` as int%d: %w", key, val, bitSize, err)
+		}
+
+		return intVal, nil
+	}
+
+	return 0, nil
+}

bindings/requests.go

@@ -11,7 +11,7 @@ require (
 	github.com/Azure/azure-event-hubs-go/v3 v3.3.10
 	github.com/Azure/azure-sdk-for-go v48.2.0+incompatible
 	github.com/Azure/azure-service-bus-go v0.10.10
-	github.com/Azure/azure-storage-blob-go v0.8.0
+	github.com/Azure/azure-storage-blob-go v0.10.0
 	github.com/Azure/azure-storage-queue-go v0.0.0-20191125232315-636801874cdd
 	github.com/Azure/go-amqp v0.13.1
 	github.com/Azure/go-autorest/autorest v0.11.12
@@ -113,6 +113,7 @@ require (
 	github.com/sergi/go-diff v1.2.0 // indirect
 	github.com/streadway/amqp v0.0.0-20190827072141-edfb9018d271
 	github.com/stretchr/testify v1.7.0
+	github.com/supplyon/gremcos v0.1.0
 	github.com/tidwall/gjson v1.8.0 // indirect
 	github.com/tidwall/pretty v1.2.0 // indirect
 	github.com/valyala/fasthttp v1.21.0