github.com/aavshr/aws-sdk-go@v1.41.3/private/model/api/eventstream_tmpl_reader.go (about)

     1  //go:build codegen
     2  // +build codegen
     3  
     4  package api
     5  
     6  import "text/template"
     7  
     8  var eventStreamShapeReaderTmpl = template.Must(template.New("eventStreamShapeReaderTmpl").
     9  	Funcs(template.FuncMap{}).
    10  	Parse(`
    11  {{- $es := $.EventStream }}
    12  
    13  // {{ $es.StreamReaderAPIName }} provides the interface for reading to the stream. The
    14  // default implementation for this interface will be {{ $.ShapeName }}.
    15  //
    16  // The reader's Close method must allow multiple concurrent calls.
    17  //
    18  // These events are:
    19  // {{ range $_, $event := $es.Events }}
    20  //     * {{ $event.Shape.ShapeName }}
    21  {{- end }}
    22  //     * {{ $es.StreamUnknownEventName }}
    23  type {{ $es.StreamReaderAPIName }} interface {
    24  	// Returns a channel of events as they are read from the event stream.
    25  	Events() <-chan {{ $es.EventGroupName }}
    26  
    27  	// Close will stop the reader reading events from the stream.
    28  	Close() error
    29  
    30  	// Returns any error that has occurred while reading from the event stream.
    31  	Err() error
    32  }
    33  
    34  type {{ $es.StreamReaderImplName }} struct {
    35  	eventReader *eventstreamapi.EventReader
    36  	stream      chan {{ $es.EventGroupName }}
    37  	err         *eventstreamapi.OnceError
    38  
    39  	done      chan struct{}
    40  	closeOnce sync.Once
    41  }
    42  
    43  func {{ $es.StreamReaderImplConstructorName }}(eventReader *eventstreamapi.EventReader) *{{ $es.StreamReaderImplName }} {
    44  	r := &{{ $es.StreamReaderImplName }}{
    45  		eventReader: eventReader,
    46  		stream: make(chan {{ $es.EventGroupName }}),
    47  		done:   make(chan struct{}),
    48  		err:    eventstreamapi.NewOnceError(),
    49  	}
    50  	go r.readEventStream()
    51  
    52  	return r
    53  }
    54  
    55  // Close will close the underlying event stream reader.
    56  func (r *{{ $es.StreamReaderImplName }}) Close() error {
    57  	r.closeOnce.Do(r.safeClose)
    58  	return r.Err()
    59  }
    60  
    61  func (r *{{ $es.StreamReaderImplName }}) ErrorSet() <-chan struct{} {
    62  	return r.err.ErrorSet()
    63  }
    64  
    65  func (r *{{ $es.StreamReaderImplName }}) Closed() <-chan struct{} {
    66  	return r.done
    67  }
    68  
    69  func (r *{{ $es.StreamReaderImplName }}) safeClose() {
    70  	close(r.done)
    71  }
    72  
    73  func (r *{{ $es.StreamReaderImplName }}) Err() error {
    74  	return r.err.Err()
    75  }
    76  
    77  func (r *{{ $es.StreamReaderImplName }}) Events() <-chan {{ $es.EventGroupName }} {
    78  	return r.stream
    79  }
    80  
    81  func (r *{{ $es.StreamReaderImplName }}) readEventStream() {
    82  	defer r.Close()
    83  	defer close(r.stream)
    84  
    85  	for {
    86  		event, err := r.eventReader.ReadEvent()
    87  		if err != nil {
    88  			if err == io.EOF {
    89  				return
    90  			}
    91  			select {
    92  			case <-r.done:
    93  				// If closed already ignore the error
    94  				return
    95  			default:
    96  			}
    97  			if _, ok := err.(*eventstreamapi.UnknownMessageTypeError); ok {
    98  				continue
    99  			}
   100  			r.err.SetError(err)
   101  			return
   102  		}
   103  
   104  		select {
   105  		case r.stream <- event.({{ $es.EventGroupName }}):
   106  		case <-r.done:
   107  			return
   108  		}
   109  	}
   110  }
   111  
   112  type {{ $es.StreamUnmarshalerForEventName }} struct {
   113  	metadata protocol.ResponseMetadata
   114  }
   115  
   116  func (u {{ $es.StreamUnmarshalerForEventName }}) UnmarshalerForEventName(eventType string) (eventstreamapi.Unmarshaler, error) {
   117  	switch eventType {
   118  		{{- range $_, $event := $es.Events }}
   119  			case {{ printf "%q" $event.Name }}:
   120  				return &{{ $event.Shape.ShapeName }}{}, nil
   121  		{{- end }}
   122  		{{- range $_, $event := $es.Exceptions }}
   123  			case {{ printf "%q" $event.Name }}:
   124  				return newError{{ $event.Shape.ShapeName }}(u.metadata).(eventstreamapi.Unmarshaler), nil
   125  		{{- end }}
   126  	default:
   127  		return &{{ $es.StreamUnknownEventName }}{Type: eventType}, nil
   128  	}
   129  }
   130  
   131  // {{ $es.StreamUnknownEventName }} provides a failsafe event for the 
   132  // {{ $es.Name }} group of events when an unknown event is received.
   133  type {{ $es.StreamUnknownEventName }} struct {
   134  	Type string
   135  	Message eventstream.Message
   136  }
   137  
   138  // The {{ $es.StreamUnknownEventName }} is and event in the {{ $es.Name }}
   139  // group of events.
   140  func (s *{{ $es.StreamUnknownEventName }}) event{{ $es.Name }}() {}
   141  
   142  // MarshalEvent marshals the type into an stream event value. This method
   143  // should only used internally within the SDK's EventStream handling.
   144  func (e *{{ $es.StreamUnknownEventName }}) MarshalEvent(pm protocol.PayloadMarshaler) (
   145  	msg eventstream.Message, err error,
   146  ) {
   147  	return e.Message.Clone(), nil
   148  }
   149  
   150  // UnmarshalEvent unmarshals the EventStream Message into the {{ $.ShapeName }} value.
   151  // This method is only used internally within the SDK's EventStream handling.
   152  func (e *{{ $es.StreamUnknownEventName }}) UnmarshalEvent(
   153  	payloadUnmarshaler protocol.PayloadUnmarshaler,
   154  	msg eventstream.Message,
   155  ) error {
   156  	e.Message = msg.Clone()
   157  	return nil
   158  }
   159  `))