src

Go monorepo.
git clone git://code.dwrz.net/src
Log | Files | Refs

step_serialize.go (7044B)

      1 package middleware
      2 
      3 import "context"
      4 
      5 // SerializeInput provides the input parameters for the SerializeMiddleware to
      6 // consume. SerializeMiddleware may modify the Request value before forwarding
      7 // SerializeInput along to the next SerializeHandler. The Parameters member
      8 // should not be modified by SerializeMiddleware, InitializeMiddleware should
      9 // be responsible for modifying the provided Parameter value.
     10 type SerializeInput struct {
     11 	Parameters interface{}
     12 	Request    interface{}
     13 }
     14 
     15 // SerializeOutput provides the result returned by the next SerializeHandler.
     16 type SerializeOutput struct {
     17 	Result interface{}
     18 }
     19 
     20 // SerializeHandler provides the interface for the next handler the
     21 // SerializeMiddleware will call in the middleware chain.
     22 type SerializeHandler interface {
     23 	HandleSerialize(ctx context.Context, in SerializeInput) (
     24 		out SerializeOutput, metadata Metadata, err error,
     25 	)
     26 }
     27 
     28 // SerializeMiddleware provides the interface for middleware specific to the
     29 // serialize step. Delegates to the next SerializeHandler for further
     30 // processing.
     31 type SerializeMiddleware interface {
     32 	// ID returns a unique ID for the middleware in the SerializeStep. The step does not
     33 	// allow duplicate IDs.
     34 	ID() string
     35 
     36 	// HandleSerialize invokes the middleware behavior which must delegate to the next handler
     37 	// for the middleware chain to continue. The method must return a result or
     38 	// error to its caller.
     39 	HandleSerialize(ctx context.Context, in SerializeInput, next SerializeHandler) (
     40 		out SerializeOutput, metadata Metadata, err error,
     41 	)
     42 }
     43 
     44 // SerializeMiddlewareFunc returns a SerializeMiddleware with the unique ID
     45 // provided, and the func to be invoked.
     46 func SerializeMiddlewareFunc(id string, fn func(context.Context, SerializeInput, SerializeHandler) (SerializeOutput, Metadata, error)) SerializeMiddleware {
     47 	return serializeMiddlewareFunc{
     48 		id: id,
     49 		fn: fn,
     50 	}
     51 }
     52 
     53 type serializeMiddlewareFunc struct {
     54 	// Unique ID for the middleware.
     55 	id string
     56 
     57 	// Middleware function to be called.
     58 	fn func(context.Context, SerializeInput, SerializeHandler) (
     59 		SerializeOutput, Metadata, error,
     60 	)
     61 }
     62 
     63 // ID returns the unique ID for the middleware.
     64 func (s serializeMiddlewareFunc) ID() string { return s.id }
     65 
     66 // HandleSerialize invokes the middleware Fn.
     67 func (s serializeMiddlewareFunc) HandleSerialize(ctx context.Context, in SerializeInput, next SerializeHandler) (
     68 	out SerializeOutput, metadata Metadata, err error,
     69 ) {
     70 	return s.fn(ctx, in, next)
     71 }
     72 
     73 var _ SerializeMiddleware = (serializeMiddlewareFunc{})
     74 
     75 // SerializeStep provides the ordered grouping of SerializeMiddleware to be
     76 // invoked on a handler.
     77 type SerializeStep struct {
     78 	newRequest func() interface{}
     79 	ids        *orderedIDs
     80 }
     81 
     82 // NewSerializeStep returns a SerializeStep ready to have middleware for
     83 // initialization added to it. The newRequest func parameter is used to
     84 // initialize the transport specific request for the stack SerializeStep to
     85 // serialize the input parameters into.
     86 func NewSerializeStep(newRequest func() interface{}) *SerializeStep {
     87 	return &SerializeStep{
     88 		ids:        newOrderedIDs(),
     89 		newRequest: newRequest,
     90 	}
     91 }
     92 
     93 var _ Middleware = (*SerializeStep)(nil)
     94 
     95 // ID returns the unique ID of the step as a middleware.
     96 func (s *SerializeStep) ID() string {
     97 	return "Serialize stack step"
     98 }
     99 
    100 // HandleMiddleware invokes the middleware by decorating the next handler
    101 // provided. Returns the result of the middleware and handler being invoked.
    102 //
    103 // Implements Middleware interface.
    104 func (s *SerializeStep) HandleMiddleware(ctx context.Context, in interface{}, next Handler) (
    105 	out interface{}, metadata Metadata, err error,
    106 ) {
    107 	order := s.ids.GetOrder()
    108 
    109 	var h SerializeHandler = serializeWrapHandler{Next: next}
    110 	for i := len(order) - 1; i >= 0; i-- {
    111 		h = decoratedSerializeHandler{
    112 			Next: h,
    113 			With: order[i].(SerializeMiddleware),
    114 		}
    115 	}
    116 
    117 	sIn := SerializeInput{
    118 		Parameters: in,
    119 		Request:    s.newRequest(),
    120 	}
    121 
    122 	res, metadata, err := h.HandleSerialize(ctx, sIn)
    123 	return res.Result, metadata, err
    124 }
    125 
    126 // Get retrieves the middleware identified by id. If the middleware is not present, returns false.
    127 func (s *SerializeStep) Get(id string) (SerializeMiddleware, bool) {
    128 	get, ok := s.ids.Get(id)
    129 	if !ok {
    130 		return nil, false
    131 	}
    132 	return get.(SerializeMiddleware), ok
    133 }
    134 
    135 // Add injects the middleware to the relative position of the middleware group.
    136 // Returns an error if the middleware already exists.
    137 func (s *SerializeStep) Add(m SerializeMiddleware, pos RelativePosition) error {
    138 	return s.ids.Add(m, pos)
    139 }
    140 
    141 // Insert injects the middleware relative to an existing middleware ID.
    142 // Returns error if the original middleware does not exist, or the middleware
    143 // being added already exists.
    144 func (s *SerializeStep) Insert(m SerializeMiddleware, relativeTo string, pos RelativePosition) error {
    145 	return s.ids.Insert(m, relativeTo, pos)
    146 }
    147 
    148 // Swap removes the middleware by id, replacing it with the new middleware.
    149 // Returns the middleware removed, or error if the middleware to be removed
    150 // doesn't exist.
    151 func (s *SerializeStep) Swap(id string, m SerializeMiddleware) (SerializeMiddleware, error) {
    152 	removed, err := s.ids.Swap(id, m)
    153 	if err != nil {
    154 		return nil, err
    155 	}
    156 
    157 	return removed.(SerializeMiddleware), nil
    158 }
    159 
    160 // Remove removes the middleware by id. Returns error if the middleware
    161 // doesn't exist.
    162 func (s *SerializeStep) Remove(id string) (SerializeMiddleware, error) {
    163 	removed, err := s.ids.Remove(id)
    164 	if err != nil {
    165 		return nil, err
    166 	}
    167 
    168 	return removed.(SerializeMiddleware), nil
    169 }
    170 
    171 // List returns a list of the middleware in the step.
    172 func (s *SerializeStep) List() []string {
    173 	return s.ids.List()
    174 }
    175 
    176 // Clear removes all middleware in the step.
    177 func (s *SerializeStep) Clear() {
    178 	s.ids.Clear()
    179 }
    180 
    181 type serializeWrapHandler struct {
    182 	Next Handler
    183 }
    184 
    185 var _ SerializeHandler = (*serializeWrapHandler)(nil)
    186 
    187 // Implements SerializeHandler, converts types and delegates to underlying
    188 // generic handler.
    189 func (w serializeWrapHandler) HandleSerialize(ctx context.Context, in SerializeInput) (
    190 	out SerializeOutput, metadata Metadata, err error,
    191 ) {
    192 	res, metadata, err := w.Next.Handle(ctx, in.Request)
    193 	return SerializeOutput{
    194 		Result: res,
    195 	}, metadata, err
    196 }
    197 
    198 type decoratedSerializeHandler struct {
    199 	Next SerializeHandler
    200 	With SerializeMiddleware
    201 }
    202 
    203 var _ SerializeHandler = (*decoratedSerializeHandler)(nil)
    204 
    205 func (h decoratedSerializeHandler) HandleSerialize(ctx context.Context, in SerializeInput) (
    206 	out SerializeOutput, metadata Metadata, err error,
    207 ) {
    208 	return h.With.HandleSerialize(ctx, in, h.Next)
    209 }
    210 
    211 // SerializeHandlerFunc provides a wrapper around a function to be used as a serialize middleware handler.
    212 type SerializeHandlerFunc func(context.Context, SerializeInput) (SerializeOutput, Metadata, error)
    213 
    214 // HandleSerialize calls the wrapped function with the provided arguments.
    215 func (s SerializeHandlerFunc) HandleSerialize(ctx context.Context, in SerializeInput) (SerializeOutput, Metadata, error) {
    216 	return s(ctx, in)
    217 }
    218 
    219 var _ SerializeHandler = SerializeHandlerFunc(nil)