Move StreamError to pkg/errors

Allows library implementations of StreamClient and StreamClientFactory
to return fatal StreamErrors

Signed-off-by: Michael Stergianis <[email protected]>

internal/api/websocket_client.go

@@ -12,6 +12,7 @@ import (
  "time"
 
  "github.com/vmware-tanzu/octant/internal/util/json"
+ "github.com/vmware-tanzu/octant/pkg/errors"
 
  "github.com/vmware-tanzu/octant/pkg/event"
 
@@ -168,7 +169,7 @@ func (c *WebsocketClient) readPump() {
  for {
  request, err := c.Receive()
  if err != nil {
- if IsFatalStreamError(err) {
+ if errors.IsFatalStreamError(err) {
  c.cancel()
  break
  }
@@ -293,7 +294,7 @@ func (c *WebsocketClient) Receive() (StreamRequest, error) {
  ) {
  c.logger.WithErr(err).Errorf("Unhandled websocket error")
  }
- return StreamRequest{}, FatalStreamError(err)
+ return StreamRequest{}, errors.FatalStreamError(err)
  }
 
  var request StreamRequest

pkg/errors/streaming_connection_error.go

@@ -0,0 +1,39 @@
+package errors
+
+import "github.com/vmware-tanzu/octant/internal/errors"
+
+type StreamError struct {
+ *errors.GenericError
+ Fatal bool
+}
+
+func NewStreamError(err error) *StreamError {
+ return &StreamError{
+ errors.NewGenericError(err),
+ false,
+ }
+}
+
+func FatalStreamError(err error) *StreamError {
+ return &StreamError{
+ errors.NewGenericError(err),
+ true,
+ }
+}
+
+func IsFatalStreamError(err error) bool {
+ switch sErr := err.(type) {
+ case StreamError:
+ return sErr.Fatal
+ case *StreamError:
+ return sErr.Fatal
+ default:
+ return false
+ }
+}
+
+const StreamingConnectionError = "StreamingConnectionError"
+
+func (s *StreamError) Name() string {
+ return StreamingConnectionError
+}

pkg/errors/streaming_connection_error_test.go

@@ -0,0 +1,65 @@
+package errors
+
+import (
+ "fmt"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+)
+
+func TestConstructors(t *testing.T) {
+ err := fmt.Errorf("encountered an error while streaming")
+ table := []struct {
+ name string
+ sErr *StreamError
+ fatal bool
+ }{
+ {"NewStreamError", NewStreamError(err), false},
+ {"FatalStreamError", FatalStreamError(err), true},
+ }
+
+ for _, test := range table {
+ t.Run(test.name, func(t *testing.T) {
+ assert.NotEmpty(t, test.sErr.Timestamp())
+ assert.Equal(t, test.sErr.Name(), StreamingConnectionError)
+ assert.NotZero(t, test.sErr.ID())
+ assert.Equal(t, test.fatal, test.sErr.Fatal)
+ assert.Equal(t, err.Error(), test.sErr.Error())
+ })
+ }
+}
+
+func TestIsFatalStreamError(t *testing.T) {
+ table := []struct {
+ name string
+ sErr error
+ expected bool
+ }{
+ {
+ "Expect IsFatalStreamError to be false for a standard stream error",
+ NewStreamError(fmt.Errorf("")),
+ false,
+ },
+ {
+ "Expect IsFatalStreamError to be true for fatal stream error",
+ FatalStreamError(fmt.Errorf("")),
+ true,
+ },
+ {
+ "A non pointer fatal stream error is provided",
+ *FatalStreamError(fmt.Errorf("")),
+ true,
+ },
+ {
+ "A generic error is provided",
+ fmt.Errorf(""),
+ false,
+ },
+ }
+
+ for _, test := range table {
+ t.Run(test.name, func(t *testing.T) {
+ assert.Equal(t, test.expected, IsFatalStreamError(test.sErr))
+ })
+ }
+}