tweak: variable naming for queue keys

cmd/vela-server/queue.go

@@ -18,12 +18,12 @@ func setupQueue(c *cli.Context) (queue.Service, error) {
 
 	// queue configuration
 	_setup := &queue.Setup{
-		Driver:                   c.String("queue.driver"),
-		Address:                  c.String("queue.addr"),
-		Cluster:                  c.Bool("queue.cluster"),
-		Routes:                   c.StringSlice("queue.routes"),
-		Timeout:                  c.Duration("queue.pop.timeout"),
-		EncodedSigningPrivateKey: c.String("queue.signing.private-key"),
+		Driver:     c.String("queue.driver"),
+		Address:    c.String("queue.addr"),
+		Cluster:    c.Bool("queue.cluster"),
+		Routes:     c.StringSlice("queue.routes"),
+		Timeout:    c.Duration("queue.pop.timeout"),
+		PrivateKey: c.String("queue.signing.private-key"),
 	}
 
 	// setup the queue

queue/redis/opts.go

@@ -75,32 +75,32 @@ func WithTimeout(timeout time.Duration) ClientOpt {
 // WithPrivateKey sets the private key in the queue client for Redis.
 //
 //nolint:dupl // ignore similar code
-func WithPrivateKey(privateKeyEncoded string) ClientOpt {
+func WithPrivateKey(key string) ClientOpt {
 	return func(c *client) error {
 		c.Logger.Trace("configuring private key in redis queue client")
 
-		if len(privateKeyEncoded) == 0 {
+		if len(key) == 0 {
 			c.Logger.Warn("unable to base64 decode private key, provided key is empty. queue service will be unable to sign items")
 			return nil
 		}
 
-		privateKeyDecoded, err := base64.StdEncoding.DecodeString(privateKeyEncoded)
+		decoded, err := base64.StdEncoding.DecodeString(key)
 		if err != nil {
 			return err
 		}
 
-		if len(privateKeyDecoded) == 0 {
+		if len(decoded) == 0 {
 			return errors.New("unable to base64 decode private key, decoded key is empty")
 		}
 
-		c.config.SigningPrivateKey = new([64]byte)
-		copy(c.config.SigningPrivateKey[:], privateKeyDecoded)
+		c.config.PrivateKey = new([64]byte)
+		copy(c.config.PrivateKey[:], decoded)
 
-		if c.config.SigningPrivateKey == nil {
+		if c.config.PrivateKey == nil {
 			return errors.New("unable to copy decoded queue signing private key, copied key is nil")
 		}
 
-		if len(c.config.SigningPrivateKey) == 0 {
+		if len(c.config.PrivateKey) == 0 {
 			return errors.New("unable to copy decoded queue signing private key, copied key is empty")
 		}
 
@@ -111,32 +111,32 @@ func WithPrivateKey(privateKeyEncoded string) ClientOpt {
 // WithPublicKey sets the public key in the queue client for Redis.
 //
 //nolint:dupl // ignore similar code
-func WithPublicKey(publicKeyEncoded string) ClientOpt {
+func WithPublicKey(key string) ClientOpt {
 	return func(c *client) error {
 		c.Logger.Tracef("configuring public key in redis queue client")
 
-		if len(publicKeyEncoded) == 0 {
+		if len(key) == 0 {
 			c.Logger.Warn("unable to base64 decode public key, provided key is empty. queue service will be unable to open items")
 			return nil
 		}
 
-		publicKeyDecoded, err := base64.StdEncoding.DecodeString(publicKeyEncoded)
+		decoded, err := base64.StdEncoding.DecodeString(key)
 		if err != nil {
 			return err
 		}
 
-		if len(publicKeyDecoded) == 0 {
+		if len(decoded) == 0 {
 			return errors.New("unable to base64 decode public key, decoded key is empty")
 		}
 
-		c.config.SigningPublicKey = new([32]byte)
-		copy(c.config.SigningPublicKey[:], publicKeyDecoded)
+		c.config.PublicKey = new([32]byte)
+		copy(c.config.PublicKey[:], decoded)
 
-		if c.config.SigningPublicKey == nil {
+		if c.config.PublicKey == nil {
 			return errors.New("unable to copy decoded queue signing public key, copied key is nil")
 		}
 
-		if len(c.config.SigningPublicKey) == 0 {
+		if len(c.config.PublicKey) == 0 {
 			return errors.New("unable to copy decoded queue signing public key, copied key is empty")
 		}
 

queue/redis/opts_test.go

@@ -235,8 +235,8 @@ func TestRedis_ClientOpt_WithSigningPrivateKey(t *testing.T) {
 		}
 
 		got := ""
-		if _service.config.SigningPrivateKey != nil {
-			got = fmt.Sprintf("%s", *_service.config.SigningPrivateKey)
+		if _service.config.PrivateKey != nil {
+			got = fmt.Sprintf("%s", *_service.config.PrivateKey)
 		} else {
 			got = ""
 		}
@@ -303,8 +303,8 @@ func TestRedis_ClientOpt_WithSigningPublicKey(t *testing.T) {
 		}
 
 		got := ""
-		if _service.config.SigningPublicKey != nil {
-			got = fmt.Sprintf("%s", *_service.config.SigningPublicKey)
+		if _service.config.PublicKey != nil {
+			got = fmt.Sprintf("%s", *_service.config.PublicKey)
 		} else {
 			got = ""
 		}

queue/redis/pop.go

@@ -37,7 +37,7 @@ func (c *client) Pop(ctx context.Context) (*types.Item, error) {
 	}
 
 	// this should already be validated on startup
-	if c.config.SigningPublicKey == nil || len(*c.config.SigningPublicKey) != 32 {
+	if c.config.PublicKey == nil || len(*c.config.PublicKey) != 32 {
 		return nil, errors.New("no valid signing public key provided")
 	}
 
@@ -49,7 +49,7 @@ func (c *client) Pop(ctx context.Context) (*types.Item, error) {
 	// open the item using the public key generated using sign
 	//
 	// https://pkg.go.dev/golang.org/x/[email protected]/nacl/sign
-	opened, ok := sign.Open(out, signed, c.config.SigningPublicKey)
+	opened, ok := sign.Open(out, signed, c.config.PublicKey)
 	if !ok {
 		return nil, errors.New("unable to open signed item")
 	}

queue/redis/pop_test.go

@@ -39,7 +39,7 @@ func TestRedis_Pop(t *testing.T) {
 		t.Errorf("unable to create queue service: %v", err)
 	}
 
-	signed = sign.Sign(out, bytes, _redis.config.SigningPrivateKey)
+	signed = sign.Sign(out, bytes, _redis.config.PrivateKey)
 
 	// push item to queue
 	err = _redis.Redis.RPush(context.Background(), "vela", signed).Err()
@@ -63,7 +63,7 @@ func TestRedis_Pop(t *testing.T) {
 	// overwrite channel to be invalid
 	badChannel.config.Channels = nil
 
-	signed = sign.Sign(out, bytes, badChannel.config.SigningPrivateKey)
+	signed = sign.Sign(out, bytes, badChannel.config.PrivateKey)
 
 	// push something to badChannel queue
 	err = badChannel.Redis.RPush(context.Background(), "vela", signed).Err()

queue/redis/push.go

@@ -28,7 +28,7 @@ func (c *client) Push(ctx context.Context, channel string, item []byte) error {
 	var out []byte
 
 	// this should already be validated on startup
-	if c.config.SigningPrivateKey == nil || len(*c.config.SigningPrivateKey) != 64 {
+	if c.config.PrivateKey == nil || len(*c.config.PrivateKey) != 64 {
 		return errors.New("no valid signing private key provided")
 	}
 
@@ -37,7 +37,7 @@ func (c *client) Push(ctx context.Context, channel string, item []byte) error {
 	// sign the item using the private key generated using sign
 	//
 	// https://pkg.go.dev/golang.org/x/[email protected]/nacl/sign
-	signed = sign.Sign(out, item, c.config.SigningPrivateKey)
+	signed = sign.Sign(out, item, c.config.PrivateKey)
 
 	// build a redis queue command to push an item to queue
 	//

queue/redis/redis.go

@@ -26,9 +26,9 @@ type config struct {
 	// specifies the timeout to use for the Redis client
 	Timeout time.Duration
 	// key for signing items pushed to the Redis client
-	SigningPrivateKey *[64]byte
+	PrivateKey *[64]byte
 	// key for opening items popped from the Redis client
-	SigningPublicKey *[32]byte
+	PublicKey *[32]byte
 }
 
 type client struct {

queue/setup.go

@@ -30,10 +30,10 @@ type Setup struct {
 	Routes []string
 	// specifies the timeout for pop requests for the queue client
 	Timeout time.Duration
-	// encoded key used for signing items pushed to the queue
-	EncodedSigningPrivateKey string
-	// encoded key used for opening items popped from the queue
-	EncodedSigningPublicKey string
+	// private key in base64 used for signing items pushed to the queue
+	PrivateKey string
+	// public key in base64 used for opening items popped from the queue
+	PublicKey string
 }
 
 // Redis creates and returns a Vela service capable
@@ -49,8 +49,8 @@ func (s *Setup) Redis() (Service, error) {
 		redis.WithChannels(s.Routes...),
 		redis.WithCluster(s.Cluster),
 		redis.WithTimeout(s.Timeout),
-		redis.WithPrivateKey(s.EncodedSigningPrivateKey),
-		redis.WithPublicKey(s.EncodedSigningPublicKey),
+		redis.WithPrivateKey(s.PrivateKey),
+		redis.WithPublicKey(s.PublicKey),
 	)
 }