.github/workflows/linux.yml

@@ -45,7 +45,7 @@ jobs:
       - name: Run golang tests on ${{ matrix.os }}
         run: |
           mkdir ./coverage-ci
-          go test -v -race -cover -tags=debug -coverpkg=./... -coverprofile=./coverage-ci/backoff.txt -covermode=atomic ./tests/backoff
+          go test -v -race -cover -tags=debug -coverpkg=./... -coverprofile=./coverage-ci/backoff.txt -covermode=atomic ./tests/init
           go test -v -race -cover -tags=debug -coverpkg=./... -coverprofile=./coverage-ci/happy_scenarios.txt -covermode=atomic ./tests/happy_scenarios
           go test -v -race -cover -tags=debug -coverpkg=./... -coverprofile=./coverage-ci/interfaces.txt -covermode=atomic ./tests/interfaces
           go test -v -race -cover -tags=debug -coverpkg=./... -coverprofile=./coverage-ci/issues.txt -covermode=atomic ./tests/issues

.github/workflows/macOS.yml

@@ -44,7 +44,7 @@ jobs:
 
       - name: Run golang tests on ${{ matrix.os }}
         run: |
-          go test -v -race -cover -tags=debug ./tests/backoff
+          go test -v -race -cover -tags=debug ./tests/init
           go test -v -race -cover -tags=debug ./tests/happy_scenarios
           go test -v -race -cover -tags=debug ./tests/interfaces
           go test -v -race -cover -tags=debug ./tests/issues

.github/workflows/windows.yml

@@ -44,7 +44,7 @@ jobs:
 
       - name: Run golang tests on ${{ matrix.os }}
         run: |
-          go test -v -race -tags=debug ./tests/backoff
+          go test -v -race -tags=debug ./tests/init
           go test -v -race -tags=debug ./tests/happy_scenarios
           go test -v -race -tags=debug ./tests/interfaces
           go test -v -race -tags=debug ./tests/issues

Makefile

@@ -1,5 +1,10 @@
 test:
-	go test -v -race -tags=debug ./tests/backoff
+	go test -v -race -tags=debug ./tests/general/test1
+	go test -v -race -tags=debug ./tests/general/test2
+	go test -v -race -tags=debug ./tests/general/test3
+	go test -v -race -tags=debug ./tests/general/test4
+	go test -v -race -tags=debug ./tests/general/test5
+	go test -v -race -tags=debug ./tests/init
 	go test -v -race -tags=debug ./tests/happy_scenarios
 	go test -v -race -tags=debug ./tests/interfaces
 	go test -v -race -tags=debug ./tests/issues

README.md

@@ -1,71 +1,69 @@
 # Endure
 
 <p align="center">
- <a href="https://pkg.go.dev/github.com/roadrunner-server/endure?tab=doc"><img src="https://godoc.org/github.com/roadrunner-server/endure?status.svg"></a>
+ <a href="https://pkg.go.dev/github.com/roadrunner-server/endure/v2?tab=doc"><img src="https://godoc.org/github.com/roadrunner-server/endure/v2?status.svg"></a>
  <a href="https://github.com/roadrunner-server/endure/actions"><img src="https://github.com/roadrunner-server/endure/workflows/Linux/badge.svg" alt=""></a>
  <a href="https://github.com/roadrunner-server/endure/actions"><img src="https://github.com/roadrunner-server/endure/workflows/macOS/badge.svg" alt=""></a>
  <a href="https://github.com/roadrunner-server/endure/actions"><img src="https://github.com/roadrunner-server/endure/workflows/Windows/badge.svg" alt=""></a>
  <a href="https://github.com/roadrunner-server/endure/actions"><img src="https://github.com/roadrunner-server/endure/workflows/Linters/badge.svg" alt=""></a>
  <a href="https://codecov.io/gh/roadrunner-server/endure"><img src="https://codecov.io/gh/roadrunner-server/endure/branch/master/graph/badge.svg?token=itNaiZ6ALN"/></a>
  <a href="https://discord.gg/TFeEmCs"><img src="https://img.shields.io/badge/discord-chat-magenta.svg"></a>
- <a href="https://lgtm.com/projects/g/roadrunner-server/endure/alerts/"><img src="https://img.shields.io/lgtm/alerts/g/roadrunner-server/endure.svg?logo=lgtm&logoWidth=18"></a>
 </p>
 
-Endure is an open-source (MIT licensed) plugin container with IoC and self-healing.
+Endure is an open-source (MIT licensed) plugin container with IoC (Inversion of Control) and self-healing capabilities.
 
-<h2>Features</h2>
+## Features
 
-- Supports structs and interfaces (see examples)
-- Use graph to topologically sort, run, stop and restart dependent plugins
-- Algorithms used: graph and double-linked list
-- Support easy to add Middleware plugins
+- Supports interfaces (see examples)
+- Uses a graph to topologically sort, run, stop, and restart dependent plugins
+- Supports easy addition of Middleware plugins
 - Error reporting
 
-<h2>Installation</h2>
+## Installation
 
 ```go
-go get -u github.com/roadrunner-server/endure
+go get -u github.com/roadrunner-server/endure/v2
 ```
 
+
 ### Why?
 
-Imagine you have an application in which you want to implement plugin system. These plugins can depend on each other (
-via interfaces or directly). For example, we have 3 plugins: HTTP (to communicate with world), DB (to save the world)
-and logger (to see the progress).  
-In this particular case, we can't start HTTP before we start all other parts. Also, we have to initialize logger first,
-because all parts of our system need logger. All you need to do in `Endure` is to pass `HTTP`, `DB` and `Logger` structs
-to the `Endure` and implement `Endure` interface. So, the dependency graph will be the following:
+Imagine you have an application in which you want to implement a plugin system. These plugins can depend on each other (via interfaces or directly). For example, we have 3 plugins: HTTP (to communicate with the world), DB (to save the world), and logger (to see the progress). In this particular case, we can't start HTTP before we start all other parts. Also, we have to initialize the logger first, because all parts of our system need the logger. All you need to do in Endure is to pass the `HTTP`, `DB`, and `Logger` structs to Endure and implement the `Endure` interface. So, the dependency graph will be the following:
 
-<p align="left">
-  <img src="https://github.com/roadrunner-server/endure/blob/master/images/graph.png" width="300" height="250" />
-</p>
+![Dependency Graph](https://github.com/roadrunner-server/endure/blob/master/images/graph.png)
 
--------
-First step is to initialize the `endure` container:
+First, we initialize the `endure` container:
 
 ```go
-container, err := endure.NewContainer(nil, endure.SetLogLevel(endure.ErrorLevel), endure.Visualize(endure.StdOut, ""))
+import (
+    "golang.org/x/exp/slog"
+)
+
+func main() {
+    container := endure.New(slog.LevelDebug, endure.Visualize())
+}
 ```
 
-Let's take a look at the `endure.NewContainer()`:
+Let's take a look at the `endure.New()` function:
+
+1. The first argument is the standard golang logger log level.
+2. The next arguments are optional and can be set using `Options`. For example, `endure.Visualize()` will show you a dot-compatible graph in the console. Then we need to pass our structures as references to the `RegisterAll` or `Register` function.
 
-1. First arg here is the external logger. If you want to use your own logger, you can pass it as the first argument.
-2. Next arguments are optional and can be set using `Options`. For example `endure.Visualize(endure.StdOut, "")` will
-   show you dot-compatible graph in the console.
-   Then we need to pass our structures as references to the `RegisterAll` or `Register` function.
 
 ```go
 err = container.RegisterAll(
     &httpPlugin{},
     &DBPlugin{},
-    &LoggerPlugin{})
+    &LoggerPlugin{},
+	)
     if err != nil {
         panic(err)
-}
+    }
 ```
 
-The order of plugins in the `RegisterAll` plugin does no matter.  
-Next we need to initialize and run our container:
+The order of plugins in the `RegisterAll` function does not matter.
+Next, we need to initialize and run our container:
+
 
 ```go
 err := container.Init()
@@ -78,8 +76,8 @@ errCh, err := container.Serve()
 }
 ```
 
-`errCh` is the channel with errors from the all `Vertices`. You can identify vertex by `vertexID` which is presented
-in `errCh` struct. Then just process the events from the `errCh`:
+
+`errCh` is the channel with errors from all `Vertices`. You can identify the vertex by `vertexID`, which is presented in the `errCh` struct. Then just process the events from the `errCh`:
 
 ```go
 for {
@@ -95,70 +93,57 @@ for {
 }
 ```
 
-Also `Endure` will take care of the restart failing vertices (HTTP, DB, Logger in example) with exponential backoff
-mechanism.  
-The start will proceed in topological order (`Logger` -> `DB` -> `HTTP`), and the stop in reverse-topological order
-automatically.
+The start will proceed in topological order (Logger -> DB -> HTTP), and the stop in reverse-topological order automatically.
 
-<h2>Endure main interface</h2>
+### Endure main interface
 
 ```go
 package sample
 
+import (
+   "github.com/roadrunner-server/endure/v2/dep"
+)
+
 type (
-	// This is the main Endure service interface which may be implemented to Start (Serve) and Stop plugin (OPTIONAL)
-	Service interface {
-		// Serve
-		Serve() chan error
-		// Stop
-		Stop() error
-	}
-
-	// Name of the service (OPTIONAL)
-	Named interface {
-		Name() string
-	}
-
-	// Provider declares the ability to provide dependencies to other plugins (OPTIONAL)
-	Provider interface {
-		Provides() []any
-	}
-
-	// Collector declares the ability to accept the plugins which match the provided method signature (OPTIONAL)
-	Collector interface {
-		Collects() []any
-	}
+   // This is the main Endure service interface which may be implemented to Start (Serve) and Stop plugin (OPTIONAL)
+   Service interface {
+      // Serve
+      Serve() chan error
+      // Stop with context, if you reach the timeout, endure will force the exit via context deadline
+      Stop(context.Context) error
+      // Named return plugin's name
+      Named() string
+   }
+
+   // Provider declares the ability to provide dependencies to other plugins (OPTIONAL)
+   Provider interface {
+      Provides() []*dep.In
+   }
+
+   // Collector declares the ability to accept the plugins which match the provided method signature (OPTIONAL)
+   Collector interface {
+      Collects() []*dep.Out
+   }
 )
 
 // Init is mandatory to implement
 type Plugin struct{}
 
 func (p *Plugin) Init( /* deps here */) error {
-	return nil
+   return nil
 }
 ```
 
 Order is the following:
 
-1. `Init() error` - is mandatory to implement. For your structure (which you pass to `Endure`), you should have this method as the method of the struct(```go func (p *Plugin) Init() error {}```). It can accept as a parameter any passed to the `Endure` structure (see samples) or interface (with
-   limitations).
-2. `Service` - is optional to implement. It has 2 methods - `Serve` which should run the plugin and return
-   initialized golang channel with errors, and `Stop` to shut down the plugin. The `Stop` and `Serve` should not block the execution.
+1. `Init() error` - is mandatory to implement. For your structure (which you pass to `Endure`), you should have this method as the method of the struct (```go func (p *Plugin) Init() error {}```). It can accept as a parameter any passed to the `Endure` structure (see samples) or interface (with limitations).
+2. `Service` - is optional to implement. It has 2 methods: `Serve` which should run the plugin and return an initialized golang channel with errors, and `Stop` to shut down the plugin. The `Stop` and `Serve` should not block the execution.
 3. `Provider` - is optional to implement. It is used to provide some dependency if you need to extend your struct without deep modification.
-4. `Collector` - is optional to implement. It is used to mark a structure (vertex) as some struct dependency. It can
-   accept interfaces which implement a caller.
-5. `Named` - is mandatory to implement. This is a special kind of interface which provides the name of the struct (
-   plugin, vertex) to the caller. Is useful in logger (for example) to know user-friendly plugin name.
+4. `Collector` - is optional to implement. It is used to mark a structure (vertex) as some struct dependency. It can accept interfaces that implement a caller.
+5. `Named` - is mandatory to implement. This is a special kind of interface that provides the name of the struct (plugin, vertex) to the caller. It is useful in the logger (for example) to know the user-friendly plugin name.
 
 Available options:
-1. `SetLogLevel` - used to set internal log level. Available options: `endure.DebugLevel`, `endure.InfoLevel`,`endure.WarnLevel`,`endure.ErrorLevel`,`endure.DPanicLevel`,`endure.PanicLevel`,`endure.FatalLevel` ordered from the most to the least verbosity level.  
-2. `RetryOnFail`: bool, used to reinitialize graph w/o stopping application when error received from the `Serve`.
-3. `SetBackoff`: initialInterval, maxInterval, `time.Duration`. When `RetryOnFail` is set, backoff configures how much time spend to reinitialize vertex.
-4. `Visualize`: Output (`endure.StdOut`, `endure.File`), path. Graph visualization option via the graphviz. The Graphviz diagram can be shown via stdout or file (path should not be empty).
-5. `GracefulShutdownTimeout`: time.Duration. How long to wait for a vertex (plugin) to stop.  
-
-The fully operational example located in the `examples` folder.
+1. `Visualize`: Graph visualization option via graphviz. The Graphviz diagram can be shown via stdout.
+2. `GracefulShutdownTimeout`: `time.Duration`. How long to wait for a vertex (plugin) to stop.
 
-## Known issues:
-- [ ] Vertex can provide only 1 implementaion per interface. For example, at the moment, you can't provide two implementations of the `Logger` interface within the same vertex.
-- [ ] No support for the type aliases.
+The fully operational example is located in the `examples` folder.

collects.go

@@ -0,0 +1,42 @@
+package endure
+
+import (
+	"github.com/roadrunner-server/errors"
+)
+
+func (e *Endure) collects() error {
+	vertices := e.graph.TopologicalOrder()
+
+	for i := 0; i < len(vertices); i++ {
+		if !vertices[i].IsActive() {
+			continue
+		}
+
+		if _, ok := vertices[i].Plugin().(Collector); !ok {
+			continue
+		}
+
+		// in deps
+		collects := vertices[i].Plugin().(Collector).Collects()
+
+		// get vals
+		for j := 0; j < len(collects); j++ {
+			impl := e.registar.ImplementsExcept(collects[j].Type, vertices[i].Plugin())
+			if len(impl) == 0 {
+				continue
+			}
+
+			for k := 0; k < len(impl); k++ {
+				value, ok := e.registar.TypeValue(impl[k].Plugin(), collects[j].Type)
+				if !ok {
+					return errors.E("this is likely a bug, nil value from the implements. Value should be initialized due to the topological order")
+				}
+
+				// call user's callback
+				collects[j].Callback(value.Interface())
+			}
+		}
+	}
+
+	return nil
+}

pkg/container/container.go → container.go

@@ -1,13 +1,19 @@
 package endure
 
-// InitMethodName is the function fn for the reflection
-const InitMethodName = "Init"
+import (
+	"context"
 
-// ServeMethodName is the function fn for the Serve
-const ServeMethodName = "Serve"
+	"github.com/roadrunner-server/endure/v2/dep"
+)
 
-// StopMethodName is the function fn for the reflection to Stop the service
-const StopMethodName = "Stop"
+const (
+	// InitMethodName is the function fn for the reflection
+	InitMethodName = "Init"
+	// ServeMethodName is the function fn for the Serve
+	ServeMethodName = "Serve"
+	// StopMethodName is the function fn for the reflection to Stop the service
+	StopMethodName = "Stop"
+)
 
 // Result is the information which endure sends to the user
 type Result struct {
@@ -34,7 +40,7 @@ type (
 		// Serve starts the plugin
 		Serve() chan error
 		// Stop stops the plugin
-		Stop() error
+		Stop(context.Context) error
 	}
 
 	// Named -> Name of the service
@@ -51,6 +57,8 @@ type (
 		Stop() error
 		// Register registers one plugin in container
 		Register(service any) error
+		// Plugins method is responsible for returning an all registered plugins
+		Plugins() string
 		// RegisterAll register set of comma separated plugins in container
 		RegisterAll(service ...any) error
 		// Init initializes all plugins (calling Init function), calculate vertices, invoke Collects and Provided functions if exist
@@ -60,12 +68,17 @@ type (
 	// Provider declares the ability to provide service edges of declared types.
 	Provider interface {
 		// Provides function return set of functions which provided dependencies to other plugins
-		Provides() []any
+		Provides() []*dep.Out
+	}
+
+	// Weighted is optional to implement, but when implemented the return value added during the topological sort
+	Weighted interface {
+		Weight() uint
 	}
 
 	// Collector declares the ability to accept the plugins which match the provided method signature.
 	Collector interface {
-		// Collects search for the structures or (and) interfaces in the arguments and provides it for the plugin
-		Collects() []any
+		// Collects search for the plugins which implements given interfaces in the args
+		Collects() []*dep.In
 	}
 )

dep/in.go

@@ -0,0 +1,25 @@
+package dep
+
+import (
+	"reflect"
+)
+
+type In struct {
+	Type     reflect.Type
+	Callback func(any)
+}
+
+func Fits(callback func(p any), tp any) *In {
+	if reflect.TypeOf(tp) == nil {
+		panic("nil type provided, should be of the form of: (*FooBar)(nil), not (FooBar)(nil)")
+	}
+
+	if reflect.TypeOf(tp).Elem().Kind() != reflect.Interface {
+		panic("type should be of the Interface type")
+	}
+
+	return &In{
+		Type:     reflect.TypeOf(tp).Elem(),
+		Callback: callback,
+	}
+}