templates/fallback

import (
	"errors"
	"fmt"
	"strings"
	"time"
)

{{ $decorator := (or .Vars.DecoratorName (printf "%sWithFallback" .Interface.Name)) }}

// {{$decorator}} implements {{.Interface.Type}} interface wrapped with Prometheus metrics
type {{$decorator}} struct {
  implementations []{{.Interface.Type}}
  interval time.Duration
}

// New{{$decorator}} takes several implementations of the {{.Interface.Type}} and returns an instance of {{.Interface.Type}}
// which calls all implementations concurrently with given interval and returns first non-error response.
func New{{$decorator}}(interval time.Duration, impls ...{{.Interface.Type}}) {{$decorator}} {
  return {{$decorator}}{implementations: impls, interval: interval}
}

{{range $method := .Interface.Methods}}
  // {{$method.Name}} implements {{$.Interface.Type}}
  func (_d {{$decorator}}) {{$method.Declaration}} {
      type _resultStruct {{$method.ResultsStruct}}
      var _ch = make(chan _resultStruct, 0)
      var _next = make(chan struct{}, len(_d.implementations))
      {{if $method.ReturnsError}}var _errorsList []string{{end}}
      var _ticker = time.NewTicker(_d.interval)
      defer _ticker.Stop()

      {{- if $method.AcceptsContext}}
        ctx, _cancelFunc := context.WithCancel(ctx)
        defer _cancelFunc()
      {{end}}

      go func() {
        for _i :=0; _i < len(_d.implementations); _i++ {
          go func(_impl {{$.Interface.Type}}) {
            {{if $method.HasResults}}{{$method.ResultsNames}} := {{end}}_impl.{{$method.Call}}
            {{- if $method.ReturnsError}}
              if err != nil {
                err = fmt.Errorf("%T: %v", _impl, err)
              }
            {{end}}

            {{if $method.AcceptsContext}}
              select {
                case _ch <- _resultStruct{ {{$method.ResultsNames}} }:
                case <-ctx.Done():
              }
            {{else}}
              select {
                case _ch <- _resultStruct{ {{$method.ResultsNames}} }:
                default:
              }
            {{end}}
          }(_d.implementations[_i])

          if _i < len(_d.implementations) - 1 {
            select {
              case <-_next:
              case <-_ticker.C:
            }
          }
        }
      }()

        {{if $method.AcceptsContext}}
          for {
              select {
              case {{if $method.HasResults}}_res := {{end}} <- _ch:
                {{- if $method.ReturnsError}}
                  if _res.err == nil {
                    {{ $method.ReturnStruct "_res" }}
                  }
                  _next <- struct{}{}
                  _errorsList = append(_errorsList, _res.err.Error())
                  if len(_errorsList) == len(_d.implementations) {
                    err =  errors.New(strings.Join(_errorsList, ";"))
                    return
                  }
                {{else}}
                  {{ $method.ReturnStruct "_res" }}
                {{end -}}
              {{if $method.AcceptsContext}}case <-ctx.Done():
                {{if $method.ReturnsError}}
                  err = fmt.Errorf("%w: %s", ctx.Err(), strings.Join(_errorsList, ";"))
                {{end}}
                return
              {{end -}}
              }
          }
        {{else}}
          {{if $method.HasResults}}_res := {{end}} <- _ch
          {{- if $method.ReturnsError}}
            if _res.err == nil {
              {{ $method.ReturnStruct "_res" }}
            }
            _errorsList = append(_errorsList, _res.err.Error())
          {{else}}
            {{ $method.ReturnStruct "_res" }}
          {{end -}}
        {{end}}
  }
{{end}}