github.com/Jeffail/benthos/v3@v3.65.0/lib/processor/switch_deprecated.go (about)

     1  package processor
     2  
     3  import (
     4  	"fmt"
     5  	"strconv"
     6  	"time"
     7  
     8  	"github.com/Jeffail/benthos/v3/internal/interop"
     9  	"github.com/Jeffail/benthos/v3/internal/tracing"
    10  	"github.com/Jeffail/benthos/v3/lib/condition"
    11  	"github.com/Jeffail/benthos/v3/lib/log"
    12  	"github.com/Jeffail/benthos/v3/lib/metrics"
    13  	"github.com/Jeffail/benthos/v3/lib/types"
    14  )
    15  
    16  type switchCaseDeprecated struct {
    17  	condition   types.Condition
    18  	processors  []types.Processor
    19  	fallThrough bool
    20  }
    21  
    22  type switchDeprecated struct {
    23  	cases []switchCaseDeprecated
    24  	log   log.Modular
    25  
    26  	mCount     metrics.StatCounter
    27  	mSent      metrics.StatCounter
    28  	mBatchSent metrics.StatCounter
    29  }
    30  
    31  func newSwitchDeprecated(
    32  	conf Config, mgr types.Manager, log log.Modular, stats metrics.Type,
    33  ) (Type, error) {
    34  	var cases []switchCaseDeprecated
    35  	for i, caseConf := range conf.Switch {
    36  		prefix := strconv.Itoa(i)
    37  
    38  		var err error
    39  		var cond types.Condition
    40  		var procs []types.Processor
    41  
    42  		cMgr, cLog, cStats := interop.LabelChild(prefix+".condition", mgr, log, stats)
    43  		if cond, err = condition.New(caseConf.Condition, cMgr, cLog, cStats); err != nil {
    44  			return nil, fmt.Errorf("case [%v] condition: %w", i, err)
    45  		}
    46  
    47  		for j, procConf := range caseConf.Processors {
    48  			pMgr, pLog, pStats := interop.LabelChild(prefix+"."+strconv.Itoa(j), mgr, log, stats)
    49  			var proc types.Processor
    50  			if proc, err = New(procConf, pMgr, pLog, pStats); err != nil {
    51  				return nil, fmt.Errorf("case [%v] processor [%v]: %w", i, j, err)
    52  			}
    53  			procs = append(procs, proc)
    54  		}
    55  
    56  		cases = append(cases, switchCaseDeprecated{
    57  			condition:   cond,
    58  			processors:  procs,
    59  			fallThrough: caseConf.Fallthrough,
    60  		})
    61  	}
    62  	return &switchDeprecated{
    63  		cases: cases,
    64  		log:   log,
    65  
    66  		mCount:     stats.GetCounter("count"),
    67  		mSent:      stats.GetCounter("sent"),
    68  		mBatchSent: stats.GetCounter("batch.sent"),
    69  	}, nil
    70  }
    71  
    72  //------------------------------------------------------------------------------
    73  
    74  func (s *switchDeprecated) ProcessMessage(msg types.Message) (msgs []types.Message, res types.Response) {
    75  	s.mCount.Incr(1)
    76  
    77  	var procs []types.Processor
    78  	fellthrough := false
    79  
    80  	spans := tracing.CreateChildSpans(TypeSwitch, msg)
    81  
    82  	for i, switchCase := range s.cases {
    83  		if !fellthrough && !switchCase.condition.Check(msg) {
    84  			continue
    85  		}
    86  		procs = append(procs, switchCase.processors...)
    87  		for _, s := range spans {
    88  			s.LogKV(
    89  				"event", "case_match",
    90  				"value", strconv.Itoa(i),
    91  			)
    92  		}
    93  		if fellthrough = switchCase.fallThrough; !fellthrough {
    94  			break
    95  		}
    96  	}
    97  
    98  	for _, s := range spans {
    99  		s.Finish()
   100  	}
   101  
   102  	msgs, res = ExecuteAll(procs, msg)
   103  
   104  	s.mBatchSent.Incr(int64(len(msgs)))
   105  	totalParts := 0
   106  	for _, msg := range msgs {
   107  		totalParts += msg.Len()
   108  	}
   109  	s.mSent.Incr(int64(totalParts))
   110  	return
   111  }
   112  
   113  func (s *switchDeprecated) CloseAsync() {
   114  	for _, s := range s.cases {
   115  		for _, proc := range s.processors {
   116  			proc.CloseAsync()
   117  		}
   118  	}
   119  }
   120  
   121  func (s *switchDeprecated) WaitForClose(timeout time.Duration) error {
   122  	stopBy := time.Now().Add(timeout)
   123  	for _, s := range s.cases {
   124  		for _, proc := range s.processors {
   125  			if err := proc.WaitForClose(time.Until(stopBy)); err != nil {
   126  				return err
   127  			}
   128  		}
   129  	}
   130  	return nil
   131  }
   132  
   133  //------------------------------------------------------------------------------