Debug mode

config.go

@@ -0,0 +1,36 @@
+package fmesh
+
+import "log"
+
+const UnlimitedCycles = 0
+
+type Config struct {
+	// ErrorHandlingStrategy defines how f-mesh will handle errors and panics
+	ErrorHandlingStrategy ErrorHandlingStrategy
+	// CyclesLimit defines max number of activation cycles, 0 means no limit
+	CyclesLimit int
+	// Debug flag enabled debug mode, when additional information will be logged
+	Debug  bool
+	Logger *log.Logger
+}
+
+var defaultConfig = &Config{
+	ErrorHandlingStrategy: StopOnFirstErrorOrPanic,
+	CyclesLimit:           1000,
+	Debug:                 false,
+	Logger:                getDefaultLogger(),
+}
+
+// withConfig sets the configuration and returns the f-mesh
+func (fm *FMesh) withConfig(config *Config) *FMesh {
+	if fm.HasErr() {
+		return fm
+	}
+
+	fm.config = config
+
+	if fm.Logger() == nil {
+		fm.config.Logger = getDefaultLogger()
+	}
+	return fm
+}

examples/async_input/main.go

@@ -149,7 +149,7 @@ func getMesh() *fmesh.FMesh {
 	//Define pipes
 	crawler.OutputByName("errors").PipeTo(logger.InputByName("error"))
 
-	return fmesh.New("web scraper").WithConfig(fmesh.Config{
+	return fmesh.NewWithConfig("web scraper", &fmesh.Config{
 		ErrorHandlingStrategy: fmesh.StopOnFirstErrorOrPanic,
 	}).WithComponents(crawler, logger)
 

examples/stateful_electric_circuit/main.go

@@ -142,12 +142,12 @@ func main() {
 	battery.OutputByName("power_supply").PipeTo(lightbulb.InputByName("power_supply"))
 	lightbulb.OutputByName("power_demand").PipeTo(battery.InputByName("power_demand"))
 
-	fm := fmesh.New("battery_and_lightbulb").
+	fm := fmesh.NewWithConfig("battery_and_lightbulb", &fmesh.Config{
+		ErrorHandlingStrategy: fmesh.StopOnFirstErrorOrPanic,
+		Debug:                 false,
+	}).
 		WithDescription("simple electric simulation").
-		WithComponents(battery, lightbulb).
-		WithConfig(fmesh.Config{
-			ErrorHandlingStrategy: fmesh.StopOnFirstErrorOrPanic,
-		})
+		WithComponents(battery, lightbulb)
 
 	// Turn on the lightbulb (yes you can init an output port)
 	lightbulb.InputByName("start_power_demand").PutSignals(signal.New("start"))

examples/strings_processing/main.go

@@ -11,7 +11,10 @@ import (
 
 // This example is used in readme.md
 func main() {
-	fm := fmesh.New("hello world").
+	fm := fmesh.NewWithConfig("hello world", &fmesh.Config{
+		ErrorHandlingStrategy: fmesh.StopOnFirstErrorOrPanic,
+		CyclesLimit:           10,
+	}).
 		WithComponents(
 			component.New("concat").
 				WithInputs("i1", "i2").
@@ -31,11 +34,7 @@ func main() {
 
 					this.OutputByName("res").PutSignals(signal.New(strings.ToTitle(inputString)))
 					return nil
-				})).
-		WithConfig(fmesh.Config{
-			ErrorHandlingStrategy: fmesh.StopOnFirstErrorOrPanic,
-			CyclesLimit:           10,
-		})
+				}))
 
 	fm.Components().ByName("concat").Outputs().ByName("res").PipeTo(
 		fm.Components().ByName("case").Inputs().ByName("i1"),

fmesh.go

@@ -6,37 +6,20 @@ import (
 	"github.com/hovsep/fmesh/common"
 	"github.com/hovsep/fmesh/component"
 	"github.com/hovsep/fmesh/cycle"
-	"log"
-	"os"
 	"sync"
 )
 
-const UnlimitedCycles = 0
-
-type Config struct {
-	// ErrorHandlingStrategy defines how f-mesh will handle errors and panics
-	ErrorHandlingStrategy ErrorHandlingStrategy
-	// CyclesLimit defines max number of activation cycles, 0 means no limit
-	CyclesLimit int
-}
-
-var defaultConfig = Config{
-	ErrorHandlingStrategy: StopOnFirstErrorOrPanic,
-	CyclesLimit:           1000,
-}
-
 // FMesh is the functional mesh
 type FMesh struct {
 	common.NamedEntity
 	common.DescribedEntity
 	*common.Chainable
 	components *component.Collection
 	cycles     *cycle.Group
-	config     Config
-	logger     *log.Logger
+	config     *Config
 }
 
-// New creates a new f-mesh
+// New creates a new f-mesh with default config
 func New(name string) *FMesh {
 	return &FMesh{
 		NamedEntity:     common.NewNamedEntity(name),
@@ -45,10 +28,14 @@ func New(name string) *FMesh {
 		components:      component.NewCollection(),
 		cycles:          cycle.NewGroup(),
 		config:          defaultConfig,
-		logger:          getDefaultLogger(),
 	}
 }
 
+// NewWithConfig creates a new f-mesh with custom config
+func NewWithConfig(name string, config *Config) *FMesh {
+	return New(name).withConfig(config)
+}
+
 // Components getter
 func (fm *FMesh) Components() *component.Collection {
 	if fm.HasErr() {
@@ -57,7 +44,10 @@ func (fm *FMesh) Components() *component.Collection {
 	return fm.components
 }
 
-//@TODO: add shortcut method: ComponentByName()
+// ComponentByName shortcut method
+func (fm *FMesh) ComponentByName(name string) *component.Component {
+	return fm.Components().ByName(name)
+}
 
 // WithDescription sets a description
 func (fm *FMesh) WithDescription(description string) *FMesh {
@@ -81,23 +71,17 @@ func (fm *FMesh) WithComponents(components ...*component.Component) *FMesh {
 			return fm.WithErr(c.Err())
 		}
 	}
-	return fm
-}
 
-// WithConfig sets the configuration and returns the f-mesh
-func (fm *FMesh) WithConfig(config Config) *FMesh {
-	if fm.HasErr() {
-		return fm
-	}
-
-	fm.config = config
+	fm.LogDebug(fmt.Sprintf("%d components added to mesh", fm.Components().Len()))
 	return fm
 }
 
 // runCycle runs one activation cycle (tries to activate ready components)
 func (fm *FMesh) runCycle() {
 	newCycle := cycle.New().WithNumber(fm.cycles.Len() + 1)
 
+	fm.LogDebug(fmt.Sprintf("starting activation cycle #%d", newCycle.Number()))
+
 	if fm.HasErr() {
 		newCycle.SetErr(fm.Err())
 	}
@@ -142,6 +126,12 @@ func (fm *FMesh) runCycle() {
 		fm.SetErr(newCycle.Err())
 	}
 
+	if fm.IsDebug() {
+		for _, ar := range newCycle.ActivationResults() {
+			fm.LogDebug(fmt.Sprintf("activation result for component %s : activated: %t, , code: %s, is error: %t, is panic: %t, error: %v", ar.ComponentName(), ar.Activated(), ar.Code(), ar.IsError(), ar.IsPanic(), ar.ActivationError()))
+		}
+	}
+
 	fm.cycles = fm.cycles.With(newCycle)
 }
 
@@ -186,7 +176,6 @@ func (fm *FMesh) drainComponents() {
 		}
 
 		c.FlushOutputs()
-
 	}
 }
 
@@ -289,23 +278,3 @@ func (fm *FMesh) WithErr(err error) *FMesh {
 	fm.SetErr(err)
 	return fm
 }
-
-func (fm *FMesh) WithLogger(logger *log.Logger) *FMesh {
-	if fm.HasErr() {
-		return fm
-	}
-
-	fm.logger = logger
-	return fm
-}
-
-func (fm *FMesh) Logger() *log.Logger {
-	return fm.logger
-}
-
-func getDefaultLogger() *log.Logger {
-	logger := log.Default()
-	logger.SetOutput(os.Stdout)
-	logger.SetFlags(log.LstdFlags | log.Lmsgprefix)
-	return logger
-}

fmesh_test.go

@@ -33,7 +33,6 @@ func TestNew(t *testing.T) {
 				components:      component.NewCollection(),
 				cycles:          cycle.NewGroup(),
 				config:          defaultConfig,
-				logger:          getDefaultLogger(),
 			},
 		},
 		{
@@ -48,7 +47,6 @@ func TestNew(t *testing.T) {
 				components:      component.NewCollection(),
 				cycles:          cycle.NewGroup(),
 				config:          defaultConfig,
-				logger:          getDefaultLogger(),
 			},
 		},
 	}
@@ -82,7 +80,6 @@ func TestFMesh_WithDescription(t *testing.T) {
 				components:      component.NewCollection(),
 				cycles:          cycle.NewGroup(),
 				config:          defaultConfig,
-				logger:          getDefaultLogger(),
 			},
 		},
 		{
@@ -98,7 +95,6 @@ func TestFMesh_WithDescription(t *testing.T) {
 				components:      component.NewCollection(),
 				cycles:          cycle.NewGroup(),
 				config:          defaultConfig,
-				logger:          getDefaultLogger(),
 			},
 		},
 	}
@@ -111,7 +107,7 @@ func TestFMesh_WithDescription(t *testing.T) {
 
 func TestFMesh_WithConfig(t *testing.T) {
 	type args struct {
-		config Config
+		config *Config
 	}
 	tests := []struct {
 		name string
@@ -123,7 +119,7 @@ func TestFMesh_WithConfig(t *testing.T) {
 			name: "custom config",
 			fm:   New("fm1"),
 			args: args{
-				config: Config{
+				config: &Config{
 					ErrorHandlingStrategy: IgnoreAll,
 					CyclesLimit:           9999,
 				},
@@ -134,17 +130,17 @@ func TestFMesh_WithConfig(t *testing.T) {
 				Chainable:       common.NewChainable(),
 				components:      component.NewCollection(),
 				cycles:          cycle.NewGroup(),
-				config: Config{
+				config: &Config{
 					ErrorHandlingStrategy: IgnoreAll,
 					CyclesLimit:           9999,
+					Logger:                getDefaultLogger(),
 				},
-				logger: getDefaultLogger(),
 			},
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			assert.Equal(t, tt.want, tt.fm.WithConfig(tt.args.config))
+			assert.Equal(t, tt.want, tt.fm.withConfig(tt.args.config))
 		})
 	}
 }
@@ -243,7 +239,7 @@ func TestFMesh_Run(t *testing.T) {
 		},
 		{
 			name: "unsupported error handling strategy",
-			fm: New("fm").WithConfig(Config{
+			fm: NewWithConfig("fm", &Config{
 				ErrorHandlingStrategy: 100,
 				CyclesLimit:           0,
 			}).
@@ -271,10 +267,9 @@ func TestFMesh_Run(t *testing.T) {
 		},
 		{
 			name: "stop on first error on first cycle",
-			fm: New("fm").
-				WithConfig(Config{
-					ErrorHandlingStrategy: StopOnFirstErrorOrPanic,
-				}).
+			fm: NewWithConfig("fm", &Config{
+				ErrorHandlingStrategy: StopOnFirstErrorOrPanic,
+			}).
 				WithComponents(
 					component.New("c1").
 						WithDescription("This component just returns an unexpected error").
@@ -298,10 +293,9 @@ func TestFMesh_Run(t *testing.T) {
 		},
 		{
 			name: "stop on first panic on cycle 3",
-			fm: New("fm").
-				WithConfig(Config{
-					ErrorHandlingStrategy: StopOnFirstPanic,
-				}).
+			fm: NewWithConfig("fm", &Config{
+				ErrorHandlingStrategy: StopOnFirstPanic,
+			}).
 				WithComponents(
 					component.New("c1").
 						WithDescription("This component just sends a number to c2").
@@ -396,10 +390,9 @@ func TestFMesh_Run(t *testing.T) {
 		},
 		{
 			name: "all errors and panics are ignored",
-			fm: New("fm").
-				WithConfig(Config{
-					ErrorHandlingStrategy: IgnoreAll,
-				}).
+			fm: NewWithConfig("fm", &Config{
+				ErrorHandlingStrategy: IgnoreAll,
+			}).
 				WithComponents(
 					component.New("c1").
 						WithDescription("This component just sends a number to c2").
@@ -727,7 +720,7 @@ func TestFMesh_mustStop(t *testing.T) {
 		{
 			name: "mesh hit an error",
 			getFMesh: func() *FMesh {
-				fm := New("fm").WithConfig(Config{
+				fm := NewWithConfig("fm", &Config{
 					ErrorHandlingStrategy: StopOnFirstErrorOrPanic,
 					CyclesLimit:           UnlimitedCycles,
 				})
@@ -746,7 +739,7 @@ func TestFMesh_mustStop(t *testing.T) {
 		{
 			name: "mesh hit a panic",
 			getFMesh: func() *FMesh {
-				fm := New("fm").WithConfig(Config{
+				fm := NewWithConfig("fm", &Config{
 					ErrorHandlingStrategy: StopOnFirstPanic,
 				})
 				c := cycle.New().WithActivationResults(