Chainable API: polish error handling

hovsep · Nov 4, 2024 · 96d41ef · 96d41ef
1 parent abb0e00
commit 96d41ef
Show file tree

Hide file tree

Showing 7 changed files with 48 additions and 22 deletions.
diff --git a/common/chainable.go b/common/chainable.go
@@ -16,6 +16,7 @@ func (c *Chainable) HasChainError() bool {
 	return c.err != nil
 }
 
+// @TODO: rename to Err()
 func (c *Chainable) ChainError() error {
 	return c.err
 }
diff --git a/component/component.go b/component/component.go
@@ -48,6 +48,9 @@ func (c *Component) WithDescription(description string) *Component {
 
 // withInputPorts sets input ports collection
 func (c *Component) withInputPorts(collection *port.Collection) *Component {
+	if c.HasChainError() {
+		return c
+	}
 	if collection.HasChainError() {
 		return c.WithChainError(collection.ChainError())
 	}
@@ -57,6 +60,9 @@ func (c *Component) withInputPorts(collection *port.Collection) *Component {
 
 // withOutputPorts sets input ports collection
 func (c *Component) withOutputPorts(collection *port.Collection) *Component {
+	if c.HasChainError() {
+		return c
+	}
 	if collection.HasChainError() {
 		return c.WithChainError(collection.ChainError())
 	}
@@ -73,8 +79,10 @@ func (c *Component) WithInputs(portNames ...string) *Component {
 
 	ports, err := port.NewGroup(portNames...).Ports()
 	if err != nil {
-		return c.WithChainError(err)
+		c.SetChainError(err)
+		return New("").WithChainError(c.ChainError())
 	}
+
 	return c.withInputPorts(c.Inputs().With(ports...))
 }
 
@@ -86,7 +94,8 @@ func (c *Component) WithOutputs(portNames ...string) *Component {
 
 	ports, err := port.NewGroup(portNames...).Ports()
 	if err != nil {
-		return c.WithChainError(err)
+		c.SetChainError(err)
+		return New("").WithChainError(c.ChainError())
 	}
 	return c.withOutputPorts(c.Outputs().With(ports...))
 }
@@ -262,10 +271,11 @@ func (c *Component) FlushOutputs() *Component {
 
 	ports, err := c.Outputs().Ports()
 	if err != nil {
-		return c.WithChainError(err)
+		c.SetChainError(err)
+		return New("").WithChainError(c.ChainError())
 	}
 	for _, out := range ports {
-		out.Flush()
+		out = out.Flush()
 		if out.HasChainError() {
 			return c.WithChainError(out.ChainError())
 		}

diff --git a/fmesh.go b/fmesh.go
@@ -95,14 +95,16 @@ func (fm *FMesh) runCycle() *cycle.Cycle {
 	}
 
 	if fm.Components().Len() == 0 {
-		return newCycle.WithChainError(errors.New("failed to run cycle: no components found"))
+		fm.SetChainError(errors.New("failed to run cycle: no components found"))
+		return newCycle.WithChainError(fm.ChainError())
 	}
 
 	var wg sync.WaitGroup
 
 	components, err := fm.Components().Components()
 	if err != nil {
-		return newCycle.WithChainError(fmt.Errorf("failed to run cycle: %w", err))
+		fm.SetChainError(fmt.Errorf("failed to run cycle: %w", err))
+		return newCycle.WithChainError(fm.ChainError())
 	}
 
 	for _, c := range components {

diff --git a/port/collection.go b/port/collection.go
@@ -46,6 +46,7 @@ func (collection *Collection) ByNames(names ...string) *Collection {
 		return NewCollection().WithChainError(collection.ChainError())
 	}
 
+	//Preserve collection config
 	selectedPorts := NewCollection().WithDefaultLabels(collection.defaultLabels)
 
 	for _, name := range names {
@@ -122,7 +123,7 @@ func (collection *Collection) Flush() *Collection {
 	}
 
 	for _, p := range collection.ports {
-		p.Flush()
+		p = p.Flush()
 
 		if p.HasChainError() {
 			return collection.WithChainError(p.ChainError())
@@ -147,7 +148,7 @@ func (collection *Collection) PipeTo(destPorts ...*Port) *Collection {
 // With adds ports to collection and returns it
 func (collection *Collection) With(ports ...*Port) *Collection {
 	if collection.HasChainError() {
-		return NewCollection().WithChainError(collection.ChainError())
+		return collection
 	}
 
 	for _, port := range ports {
@@ -164,12 +165,13 @@ func (collection *Collection) With(ports ...*Port) *Collection {
 // WithIndexed creates ports with names like "o1","o2","o3" and so on
 func (collection *Collection) WithIndexed(prefix string, startIndex int, endIndex int) *Collection {
 	if collection.HasChainError() {
-		return NewCollection().WithChainError(collection.ChainError())
+		return collection
 	}
 
 	indexedPorts, err := NewIndexedGroup(prefix, startIndex, endIndex).Ports()
 	if err != nil {
-		return collection.WithChainError(err)
+		collection.SetChainError(err)
+		return NewCollection().WithChainError(collection.ChainError())
 	}
 	return collection.With(indexedPorts...)
 }
@@ -184,7 +186,8 @@ func (collection *Collection) Signals() *signal.Group {
 	for _, p := range collection.ports {
 		signals, err := p.Buffer().Signals()
 		if err != nil {
-			return group.WithChainError(err)
+			collection.SetChainError(err)
+			return signal.NewGroup().WithChainError(collection.ChainError())
 		}
 		group = group.With(signals...)
 	}

diff --git a/port/port.go b/port/port.go
@@ -37,7 +37,7 @@ func New(name string) *Port {
 // @TODO: maybe we can hide this and return signals to user code
 func (p *Port) Buffer() *signal.Group {
 	if p.HasChainError() {
-		return p.buffer.WithChainError(p.ChainError())
+		return signal.NewGroup().WithChainError(p.ChainError())
 	}
 	return p.buffer
 }
@@ -46,15 +46,20 @@ func (p *Port) Buffer() *signal.Group {
 // @TODO maybe better to return []*Port directly
 func (p *Port) Pipes() *Group {
 	if p.HasChainError() {
-		return p.pipes.WithChainError(p.ChainError())
+		return NewGroup().WithChainError(p.ChainError())
 	}
 	return p.pipes
 }
 
 // withBuffer sets buffer field
 func (p *Port) withBuffer(buffer *signal.Group) *Port {
+	if p.HasChainError() {
+		return p
+	}
+
 	if buffer.HasChainError() {
-		return p.WithChainError(buffer.ChainError())
+		p.SetChainError(buffer.ChainError())
+		return New("").WithChainError(p.ChainError())
 	}
 	p.buffer = buffer
 	return p
@@ -86,11 +91,12 @@ func (p *Port) WithSignalGroups(signalGroups ...*signal.Group) *Port {
 	for _, group := range signalGroups {
 		signals, err := group.Signals()
 		if err != nil {
-			return p.WithChainError(err)
+			p.SetChainError(err)
+			return New("").WithChainError(p.ChainError())
 		}
 		p.PutSignals(signals...)
 		if p.HasChainError() {
-			return p
+			return New("").WithChainError(p.ChainError())
 		}
 	}
 
@@ -120,14 +126,16 @@ func (p *Port) Flush() *Port {
 
 	pipes, err := p.pipes.Ports()
 	if err != nil {
-		return p.WithChainError(err)
+		p.SetChainError(err)
+		return New("").WithChainError(p.ChainError())
 	}
 
 	for _, outboundPort := range pipes {
 		//Fan-Out
 		err = ForwardSignals(p, outboundPort)
 		if err != nil {
-			return p.WithChainError(err)
+			p.SetChainError(err)
+			return New("").WithChainError(p.ChainError())
 		}
 	}
 	return p.Clear()

diff --git a/signal/group.go b/signal/group.go
@@ -33,7 +33,7 @@ func (g *Group) First() *Signal {
 
 	if len(g.signals) == 0 {
 		g.SetChainError(ErrNoSignalsInGroup)
-		return New(nil).WithChainError(ErrNoSignalsInGroup)
+		return New(nil).WithChainError(g.ChainError())
 	}
 
 	return g.signals[0]
@@ -76,11 +76,13 @@ func (g *Group) With(signals ...*Signal) *Group {
 	copy(newSignals, g.signals)
 	for i, sig := range signals {
 		if sig == nil {
-			return g.WithChainError(ErrInvalidSignal)
+			g.SetChainError(ErrInvalidSignal)
+			return NewGroup().WithChainError(g.ChainError())
 		}
 
 		if sig.HasChainError() {
-			return g.WithChainError(sig.ChainError())
+			g.SetChainError(sig.ChainError())
+			return NewGroup().WithChainError(g.ChainError())
 		}
 
 		newSignals[len(g.signals)+i] = sig

diff --git a/signal/group_test.go b/signal/group_test.go
@@ -189,7 +189,7 @@ func TestGroup_With(t *testing.T) {
 			args: args{
 				signals: NewGroup(7, nil, 9).SignalsOrNil(),
 			},
-			want: NewGroup(1, 2, 3, "valid before invalid").WithChainError(errors.New("signal is invalid")),
+			want: NewGroup().WithChainError(errors.New("signal is invalid")),
 		},
 		{
 			name:  "with error in signal",