refactor(push): completly change the package structure

Author: ndyakov

options.go

@@ -15,6 +15,7 @@ import (
 
 	"github.com/redis/go-redis/v9/auth"
 	"github.com/redis/go-redis/v9/internal/pool"
+	"github.com/redis/go-redis/v9/push"
 )
 
 // Limiter is the interface of a rate limiter or a circuit breaker.
@@ -222,7 +223,7 @@ type Options struct {
 
 	// PushNotificationProcessor is the processor for handling push notifications.
 	// If nil, a default processor will be created for RESP3 connections.
-	PushNotificationProcessor PushNotificationProcessorInterface
+	PushNotificationProcessor push.NotificationProcessor
 }
 
 func (opt *Options) init() {

pubsub.go

@@ -10,6 +10,7 @@ import (
 	"github.com/redis/go-redis/v9/internal"
 	"github.com/redis/go-redis/v9/internal/pool"
 	"github.com/redis/go-redis/v9/internal/proto"
+	"github.com/redis/go-redis/v9/push"
 )
 
 // PubSub implements Pub/Sub commands as described in
@@ -40,7 +41,7 @@ type PubSub struct {
 	allCh  *channel
 
 	// Push notification processor for handling generic push notifications
-	pushProcessor PushNotificationProcessorInterface
+	pushProcessor push.NotificationProcessor
 }
 
 func (c *PubSub) init() {
@@ -551,14 +552,13 @@ func (c *PubSub) processPendingPushNotificationWithReader(ctx context.Context, c
 	return c.pushProcessor.ProcessPendingNotifications(ctx, handlerCtx, rd)
 }
 
-func (c *PubSub) pushNotificationHandlerContext(cn *pool.Conn) PushNotificationHandlerContext {
+func (c *PubSub) pushNotificationHandlerContext(cn *pool.Conn) push.NotificationHandlerContext {
 	// PubSub doesn't have a client or connection pool, so we pass nil for those
 	// PubSub connections are blocking
-	return NewPushNotificationHandlerContext(nil, nil, c, cn, true)
+	return push.HandlerContext{}
+	return push.NewNotificationHandlerContext(nil, nil, c, cn, true)
 }
 
-
-
 type ChannelOption func(c *channel)
 
 // WithChannelSize specifies the Go chan size that is used to buffer incoming messages.

push/errors.go

@@ -0,0 +1,150 @@
+package push
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+// Push notification error definitions
+// This file contains all error types and messages used by the push notification system
+
+// Common error variables for reuse
+var (
+	// ErrHandlerNil is returned when attempting to register a nil handler
+	ErrHandlerNil = errors.New("handler cannot be nil")
+)
+
+// Registry errors
+
+// ErrHandlerExists creates an error for when attempting to overwrite an existing handler
+func ErrHandlerExists(pushNotificationName string) error {
+	return fmt.Errorf("cannot overwrite existing handler for push notification: %s", pushNotificationName)
+}
+
+// ErrProtectedHandler creates an error for when attempting to unregister a protected handler
+func ErrProtectedHandler(pushNotificationName string) error {
+	return fmt.Errorf("cannot unregister protected handler for push notification: %s", pushNotificationName)
+}
+
+// VoidProcessor errors
+
+// ErrVoidProcessorRegister creates an error for when attempting to register a handler on void processor
+func ErrVoidProcessorRegister(pushNotificationName string) error {
+	return fmt.Errorf("cannot register push notification handler '%s': push notifications are disabled (using void processor)", pushNotificationName)
+}
+
+// ErrVoidProcessorUnregister creates an error for when attempting to unregister a handler on void processor
+func ErrVoidProcessorUnregister(pushNotificationName string) error {
+	return fmt.Errorf("cannot unregister push notification handler '%s': push notifications are disabled (using void processor)", pushNotificationName)
+}
+
+// Error message constants for consistency
+const (
+	// Error message templates
+	MsgHandlerNil              = "handler cannot be nil"
+	MsgHandlerExists           = "cannot overwrite existing handler for push notification: %s"
+	MsgProtectedHandler        = "cannot unregister protected handler for push notification: %s"
+	MsgVoidProcessorRegister   = "cannot register push notification handler '%s': push notifications are disabled (using void processor)"
+	MsgVoidProcessorUnregister = "cannot unregister push notification handler '%s': push notifications are disabled (using void processor)"
+)
+
+// Error type definitions for advanced error handling
+
+// HandlerError represents errors related to handler operations
+type HandlerError struct {
+	Operation            string // "register", "unregister", "get"
+	PushNotificationName string
+	Reason               string
+	Err                  error
+}
+
+func (e *HandlerError) Error() string {
+	if e.Err != nil {
+		return fmt.Sprintf("handler %s failed for '%s': %s (%v)", e.Operation, e.PushNotificationName, e.Reason, e.Err)
+	}
+	return fmt.Sprintf("handler %s failed for '%s': %s", e.Operation, e.PushNotificationName, e.Reason)
+}
+
+func (e *HandlerError) Unwrap() error {
+	return e.Err
+}
+
+// NewHandlerError creates a new HandlerError
+func NewHandlerError(operation, pushNotificationName, reason string, err error) *HandlerError {
+	return &HandlerError{
+		Operation:            operation,
+		PushNotificationName: pushNotificationName,
+		Reason:               reason,
+		Err:                  err,
+	}
+}
+
+// ProcessorError represents errors related to processor operations
+type ProcessorError struct {
+	ProcessorType string // "processor", "void_processor"
+	Operation     string // "process", "register", "unregister"
+	Reason        string
+	Err           error
+}
+
+func (e *ProcessorError) Error() string {
+	if e.Err != nil {
+		return fmt.Sprintf("%s %s failed: %s (%v)", e.ProcessorType, e.Operation, e.Reason, e.Err)
+	}
+	return fmt.Sprintf("%s %s failed: %s", e.ProcessorType, e.Operation, e.Reason)
+}
+
+func (e *ProcessorError) Unwrap() error {
+	return e.Err
+}
+
+// NewProcessorError creates a new ProcessorError
+func NewProcessorError(processorType, operation, reason string, err error) *ProcessorError {
+	return &ProcessorError{
+		ProcessorType: processorType,
+		Operation:     operation,
+		Reason:        reason,
+		Err:           err,
+	}
+}
+
+// Helper functions for common error scenarios
+
+// IsHandlerNilError checks if an error is due to a nil handler
+func IsHandlerNilError(err error) bool {
+	return errors.Is(err, ErrHandlerNil)
+}
+
+// IsHandlerExistsError checks if an error is due to attempting to overwrite an existing handler
+func IsHandlerExistsError(err error) bool {
+	if err == nil {
+		return false
+	}
+	return fmt.Sprintf("%v", err) == fmt.Sprintf(MsgHandlerExists, extractNotificationName(err))
+}
+
+// IsProtectedHandlerError checks if an error is due to attempting to unregister a protected handler
+func IsProtectedHandlerError(err error) bool {
+	if err == nil {
+		return false
+	}
+	return fmt.Sprintf("%v", err) == fmt.Sprintf(MsgProtectedHandler, extractNotificationName(err))
+}
+
+// IsVoidProcessorError checks if an error is due to void processor operations
+func IsVoidProcessorError(err error) bool {
+	if err == nil {
+		return false
+	}
+	errStr := err.Error()
+	return strings.Contains(errStr, "push notifications are disabled (using void processor)")
+}
+
+// extractNotificationName attempts to extract the notification name from error messages
+// This is a helper function for error type checking
+func extractNotificationName(err error) string {
+	// This is a simplified implementation - in practice, you might want more sophisticated parsing
+	// For now, we return a placeholder since the exact extraction logic depends on the error format
+	return "unknown"
+}

push/handler.go

@@ -0,0 +1,14 @@
+package push
+
+import (
+	"context"
+)
+
+// NotificationHandler defines the interface for push notification handlers.
+type NotificationHandler interface {
+	// HandlePushNotification processes a push notification with context information.
+	// The handlerCtx provides information about the client, connection pool, and connection
+	// on which the notification was received, allowing handlers to make informed decisions.
+	// Returns an error if the notification could not be handled.
+	HandlePushNotification(ctx context.Context, handlerCtx NotificationHandlerContext, notification []interface{}) error
+}

push/handler_context.go

@@ -0,0 +1,89 @@
+package push
+
+import (
+	"github.com/redis/go-redis/v9/internal/pool"
+)
+
+// NotificationHandlerContext provides context information about where a push notification was received.
+// This interface allows handlers to make informed decisions based on the source of the notification
+// with strongly typed access to different client types using concrete types.
+type NotificationHandlerContext interface {
+	// GetClient returns the Redis client instance that received the notification.
+	// Returns nil if no client context is available.
+	// It is interface to both allow for future expansion and to avoid
+	// circular dependencies. The developer is responsible for type assertion.
+	// It can be one of the following types:
+	// - *redis.Client
+	// - *redis.ClusterClient
+	// - *redis.Conn
+	GetClient() interface{}
+
+	// GetConnPool returns the connection pool from which the connection was obtained.
+	// Returns nil if no connection pool context is available.
+	// It is interface to both allow for future expansion and to avoid
+	// circular dependencies. The developer is responsible for type assertion.
+	// It can be one of the following types:
+	// - *pool.ConnPool
+	// - *pool.SingleConnPool
+	// - *pool.StickyConnPool
+	GetConnPool() interface{}
+
+	// GetPubSub returns the PubSub instance that received the notification.
+	// Returns nil if this is not a PubSub connection.
+	// It is interface to both allow for future expansion and to avoid
+	// circular dependencies. The developer is responsible for type assertion.
+	// It can be one of the following types:
+	// - *redis.PubSub
+	GetPubSub() interface{}
+
+	// GetConn returns the specific connection on which the notification was received.
+	// Returns nil if no connection context is available.
+	GetConn() *pool.Conn
+
+	// IsBlocking returns true if the notification was received on a blocking connection.
+	IsBlocking() bool
+}
+
+// pushNotificationHandlerContext is the concrete implementation of PushNotificationHandlerContext interface
+type pushNotificationHandlerContext struct {
+	client     interface{}
+	connPool   interface{}
+	pubSub     interface{}
+	conn       *pool.Conn
+	isBlocking bool
+}
+
+// NewNotificationHandlerContext creates a new push.NotificationHandlerContext instance
+func NewNotificationHandlerContext(client, connPool, pubSub interface{}, conn *pool.Conn, isBlocking bool) NotificationHandlerContext {
+	return &pushNotificationHandlerContext{
+		client:     client,
+		connPool:   connPool,
+		pubSub:     pubSub,
+		conn:       conn,
+		isBlocking: isBlocking,
+	}
+}
+
+// GetClient returns the Redis client instance that received the notification
+func (h *pushNotificationHandlerContext) GetClient() interface{} {
+	return h.client
+}
+
+// GetConnPool returns the connection pool from which the connection was obtained
+func (h *pushNotificationHandlerContext) GetConnPool() interface{} {
+	return h.connPool
+}
+
+func (h *pushNotificationHandlerContext) GetPubSub() interface{} {
+	return h.pubSub
+}
+
+// GetConn returns the specific connection on which the notification was received
+func (h *pushNotificationHandlerContext) GetConn() *pool.Conn {
+	return h.conn
+}
+
+// IsBlocking returns true if the notification was received on a blocking connection
+func (h *pushNotificationHandlerContext) IsBlocking() bool {
+	return h.isBlocking
+}