Merge pull request #2 from berndverst/pr2215

Update PR 2215 with Upstream

Author: kubemq

.github/workflows/certification.yml

@@ -245,7 +245,7 @@ jobs:
       working-directory: ${{ env.TEST_PATH }}
       run: |
         echo "Running certification tests for ${{ matrix.component }} ... "
-        export GOLANG_PROTOBUF_REGISTRATION_CONFLICT=warn
+        export GOLANG_PROTOBUF_REGISTRATION_CONFLICT=ignore
         set +e
         gotestsum --jsonfile ${{ env.TEST_OUTPUT_FILE_PREFIX }}_certification.json \
           --junitfile ${{ env.TEST_OUTPUT_FILE_PREFIX }}_certification.xml --format standard-quiet -- \

.golangci.yml

@@ -116,13 +116,14 @@ linters-settings:
     # minimal occurrences count to trigger, 3 by default
     min-occurrences: 5
   depguard:
-    list-type: blacklist
+    list-type: denylist
     include-go-root: false
-    packages:
-      - github.com/Sirupsen/logrus
-    packages-with-error-messages:
-      # specify an error message to output when a blacklisted package is used
-      github.com/Sirupsen/logrus: "must use github.com/dapr/kit/logger"
+    packages-with-error-message:
+      - "github.com/Sirupsen/logrus": "must use github.com/dapr/kit/logger"
+      - "github.com/agrea/ptr": "must use github.com/dapr/kit/ptr"
+      - "github.com/cenkalti/backoff": "must use github.com/cenkalti/backoff/v4"
+      - "github.com/cenkalti/backoff/v2": "must use github.com/cenkalti/backoff/v4"
+      - "github.com/cenkalti/backoff/v3": "must use github.com/cenkalti/backoff/v4"
   misspell:
     # Correct spellings using locale preferences for US or UK.
     # Default is to use a neutral variety of English.

bindings/mysql/mysql.go

@@ -20,14 +20,14 @@ import (
 	"database/sql"
 	"database/sql/driver"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"os"
 	"reflect"
 	"strconv"
 	"time"
 
 	"github.com/go-sql-driver/mysql"
-	"github.com/pkg/errors"
 
 	"github.com/dapr/components-contrib/bindings"
 	"github.com/dapr/kit/logger"
@@ -117,7 +117,7 @@ func (m *Mysql) Init(metadata bindings.Metadata) error {
 
 	err = db.Ping()
 	if err != nil {
-		return errors.Wrap(err, "unable to ping the DB")
+		return fmt.Errorf("unable to ping the DB: %w", err)
 	}
 
 	m.db = db
@@ -128,21 +128,21 @@ func (m *Mysql) Init(metadata bindings.Metadata) error {
 // Invoke handles all invoke operations.
 func (m *Mysql) Invoke(ctx context.Context, req *bindings.InvokeRequest) (*bindings.InvokeResponse, error) {
 	if req == nil {
-		return nil, errors.Errorf("invoke request required")
+		return nil, errors.New("invoke request required")
 	}
 
 	if req.Operation == closeOperation {
 		return nil, m.db.Close()
 	}
 
 	if req.Metadata == nil {
-		return nil, errors.Errorf("metadata required")
+		return nil, errors.New("metadata required")
 	}
 	m.logger.Debugf("operation: %v", req.Operation)
 
 	s, ok := req.Metadata[commandSQLKey]
 	if !ok || s == "" {
-		return nil, errors.Errorf("required metadata not set: %s", commandSQLKey)
+		return nil, fmt.Errorf("required metadata not set: %s", commandSQLKey)
 	}
 
 	startTime := time.Now()
@@ -171,7 +171,7 @@ func (m *Mysql) Invoke(ctx context.Context, req *bindings.InvokeRequest) (*bindi
 		resp.Data = d
 
 	default:
-		return nil, errors.Errorf("invalid operation type: %s. Expected %s, %s, or %s",
+		return nil, fmt.Errorf("invalid operation type: %s. Expected %s, %s, or %s",
 			req.Operation, execOperation, queryOperation, closeOperation)
 	}
 
@@ -201,11 +201,9 @@ func (m *Mysql) Close() error {
 }
 
 func (m *Mysql) query(ctx context.Context, sql string) ([]byte, error) {
-	m.logger.Debugf("query: %s", sql)
-
 	rows, err := m.db.QueryContext(ctx, sql)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error executing %s", sql)
+		return nil, fmt.Errorf("error executing query: %w", err)
 	}
 
 	defer func() {
@@ -215,7 +213,7 @@ func (m *Mysql) query(ctx context.Context, sql string) ([]byte, error) {
 
 	result, err := m.jsonify(rows)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error marshalling query result for %s", sql)
+		return nil, fmt.Errorf("error marshalling query result for query: %w", err)
 	}
 
 	return result, nil
@@ -226,7 +224,7 @@ func (m *Mysql) exec(ctx context.Context, sql string) (int64, error) {
 
 	res, err := m.db.ExecContext(ctx, sql)
 	if err != nil {
-		return 0, errors.Wrapf(err, "error executing %s", sql)
+		return 0, fmt.Errorf("error executing query: %w", err)
 	}
 
 	return res.RowsAffected()
@@ -237,7 +235,7 @@ func propertyToInt(props map[string]string, key string, setter func(int)) error
 		if i, err := strconv.Atoi(v); err == nil {
 			setter(i)
 		} else {
-			return errors.Wrapf(err, "error converitng %s:%s to int", key, v)
+			return fmt.Errorf("error converting %s:%s to int: %w", key, v, err)
 		}
 	}
 
@@ -249,7 +247,7 @@ func propertyToDuration(props map[string]string, key string, setter func(time.Du
 		if d, err := time.ParseDuration(v); err == nil {
 			setter(d)
 		} else {
-			return errors.Wrapf(err, "error converitng %s:%s to time duration", key, v)
+			return fmt.Errorf("error converting %s:%s to duration: %w", key, v, err)
 		}
 	}
 
@@ -258,14 +256,14 @@ func propertyToDuration(props map[string]string, key string, setter func(time.Du
 
 func initDB(url, pemPath string) (*sql.DB, error) {
 	if _, err := mysql.ParseDSN(url); err != nil {
-		return nil, errors.Wrapf(err, "illegal Data Source Name (DNS) specified by %s", connectionURLKey)
+		return nil, fmt.Errorf("illegal Data Source Name (DSN) specified by %s", connectionURLKey)
 	}
 
 	if pemPath != "" {
 		rootCertPool := x509.NewCertPool()
 		pem, err := os.ReadFile(pemPath)
 		if err != nil {
-			return nil, errors.Wrapf(err, "Error reading PEM file from %s", pemPath)
+			return nil, fmt.Errorf("error reading PEM file from %s: %w", pemPath, err)
 		}
 
 		ok := rootCertPool.AppendCertsFromPEM(pem)
@@ -275,13 +273,13 @@ func initDB(url, pemPath string) (*sql.DB, error) {
 
 		err = mysql.RegisterTLSConfig("custom", &tls.Config{RootCAs: rootCertPool, MinVersion: tls.VersionTLS12})
 		if err != nil {
-			return nil, errors.Wrap(err, "Error register TLS config")
+			return nil, fmt.Errorf("error register TLS config: %w", err)
 		}
 	}
 
 	db, err := sql.Open("mysql", url)
 	if err != nil {
-		return nil, errors.Wrap(err, "error opening DB connection")
+		return nil, fmt.Errorf("error opening DB connection: %w", err)
 	}
 
 	return db, nil

configuration/redis/metadata.go

@@ -16,11 +16,11 @@ package redis
 import "time"
 
 type metadata struct {
-	host               string
-	password           string
-	sentinelMasterName string
-	maxRetries         int
-	maxRetryBackoff    time.Duration
-	enableTLS          bool
-	failover           bool
+	Host               string
+	Password           string
+	SentinelMasterName string
+	MaxRetries         int
+	MaxRetryBackoff    time.Duration
+	EnableTLS          bool
+	Failover           bool
 }

configuration/redis/redis.go

@@ -78,54 +78,54 @@ func parseRedisMetadata(meta configuration.Metadata) (metadata, error) {
 	m := metadata{}
 
 	if val, ok := meta.Properties[host]; ok && val != "" {
-		m.host = val
+		m.Host = val
 	} else {
 		return m, errors.New("redis store error: missing host address")
 	}
 
 	if val, ok := meta.Properties[password]; ok && val != "" {
-		m.password = val
+		m.Password = val
 	}
 
-	m.enableTLS = defaultEnableTLS
+	m.EnableTLS = defaultEnableTLS
 	if val, ok := meta.Properties[enableTLS]; ok && val != "" {
 		tls, err := strconv.ParseBool(val)
 		if err != nil {
 			return m, fmt.Errorf("redis store error: can't parse enableTLS field: %s", err)
 		}
-		m.enableTLS = tls
+		m.EnableTLS = tls
 	}
 
-	m.maxRetries = defaultMaxRetries
+	m.MaxRetries = defaultMaxRetries
 	if val, ok := meta.Properties[maxRetries]; ok && val != "" {
 		parsedVal, err := strconv.ParseInt(val, defaultBase, defaultBitSize)
 		if err != nil {
 			return m, fmt.Errorf("redis store error: can't parse maxRetries field: %s", err)
 		}
-		m.maxRetries = int(parsedVal)
+		m.MaxRetries = int(parsedVal)
 	}
 
-	m.maxRetryBackoff = defaultMaxRetryBackoff
+	m.MaxRetryBackoff = defaultMaxRetryBackoff
 	if val, ok := meta.Properties[maxRetryBackoff]; ok && val != "" {
 		parsedVal, err := strconv.ParseInt(val, defaultBase, defaultBitSize)
 		if err != nil {
 			return m, fmt.Errorf("redis store error: can't parse maxRetryBackoff field: %s", err)
 		}
-		m.maxRetryBackoff = time.Duration(parsedVal)
+		m.MaxRetryBackoff = time.Duration(parsedVal)
 	}
 
 	if val, ok := meta.Properties[failover]; ok && val != "" {
 		failover, err := strconv.ParseBool(val)
 		if err != nil {
 			return m, fmt.Errorf("redis store error: can't parse failover field: %s", err)
 		}
-		m.failover = failover
+		m.Failover = failover
 	}
 
 	// set the sentinelMasterName only with failover == true.
-	if m.failover {
+	if m.Failover {
 		if val, ok := meta.Properties[sentinelMasterName]; ok && val != "" {
-			m.sentinelMasterName = val
+			m.SentinelMasterName = val
 		} else {
 			return m, errors.New("redis store error: missing sentinelMasterName")
 		}
@@ -142,14 +142,14 @@ func (r *ConfigurationStore) Init(metadata configuration.Metadata) error {
 	}
 	r.metadata = m
 
-	if r.metadata.failover {
+	if r.metadata.Failover {
 		r.client = r.newFailoverClient(m)
 	} else {
 		r.client = r.newClient(m)
 	}
 
 	if _, err = r.client.Ping(context.TODO()).Result(); err != nil {
-		return fmt.Errorf("redis store: error connecting to redis at %s: %s", m.host, err)
+		return fmt.Errorf("redis store: error connecting to redis at %s: %s", m.Host, err)
 	}
 
 	r.replicas, err = r.getConnectedSlaves()
@@ -159,18 +159,18 @@ func (r *ConfigurationStore) Init(metadata configuration.Metadata) error {
 
 func (r *ConfigurationStore) newClient(m metadata) *redis.Client {
 	opts := &redis.Options{
-		Addr:            m.host,
-		Password:        m.password,
+		Addr:            m.Host,
+		Password:        m.Password,
 		DB:              defaultDB,
-		MaxRetries:      m.maxRetries,
-		MaxRetryBackoff: m.maxRetryBackoff,
+		MaxRetries:      m.MaxRetries,
+		MaxRetryBackoff: m.MaxRetryBackoff,
 	}
 
 	// tell the linter to skip a check here.
 	/* #nosec */
-	if m.enableTLS {
+	if m.EnableTLS {
 		opts.TLSConfig = &tls.Config{
-			InsecureSkipVerify: m.enableTLS,
+			InsecureSkipVerify: m.EnableTLS,
 		}
 	}
 
@@ -179,17 +179,17 @@ func (r *ConfigurationStore) newClient(m metadata) *redis.Client {
 
 func (r *ConfigurationStore) newFailoverClient(m metadata) *redis.Client {
 	opts := &redis.FailoverOptions{
-		MasterName:      r.metadata.sentinelMasterName,
-		SentinelAddrs:   []string{r.metadata.host},
+		MasterName:      r.metadata.SentinelMasterName,
+		SentinelAddrs:   []string{r.metadata.Host},
 		DB:              defaultDB,
-		MaxRetries:      m.maxRetries,
-		MaxRetryBackoff: m.maxRetryBackoff,
+		MaxRetries:      m.MaxRetries,
+		MaxRetryBackoff: m.MaxRetryBackoff,
 	}
 
 	/* #nosec */
-	if m.enableTLS {
+	if m.EnableTLS {
 		opts.TLSConfig = &tls.Config{
-			InsecureSkipVerify: m.enableTLS,
+			InsecureSkipVerify: m.EnableTLS,
 		}
 	}
 

configuration/redis/redis_test.go

@@ -264,13 +264,13 @@ func Test_parseRedisMetadata(t *testing.T) {
 				}},
 			},
 			want: metadata{
-				host:               "testHost",
-				password:           "testPassword",
-				enableTLS:          true,
-				maxRetries:         10,
-				maxRetryBackoff:    time.Second,
-				failover:           true,
-				sentinelMasterName: "tesSentinelMasterName",
+				Host:               "testHost",
+				Password:           "testPassword",
+				EnableTLS:          true,
+				MaxRetries:         10,
+				MaxRetryBackoff:    time.Second,
+				Failover:           true,
+				SentinelMasterName: "tesSentinelMasterName",
 			},
 		},
 	}