Implementing AutoCloser when program shutdown

Signed-off-by: Filip Petrov
Signed-off-by: Filip Petrov <lombert.p.v@gmail.com>

Author: FilipVPetrov

.golangci.yml

@@ -0,0 +1,48 @@
+linters:
+  disable-all: true
+  enable:
+    - bodyclose
+    - deadcode
+    - depguard
+    - dogsled
+    - dupl
+    - errcheck
+    - funlen
+    - goconst
+    - gocritic
+    - gocyclo
+    - gofmt
+    - goimports
+    - golint
+    - gomnd
+    - goprintffuncname
+    - gosec
+    - gosimple
+    - govet
+    - ineffassign
+    - interfacer
+    - lll
+    - misspell
+    - nakedret
+    - noctx
+    - nolintlint
+    - rowserrcheck
+    - scopelint
+    - staticcheck
+    - structcheck
+    - stylecheck
+    - typecheck
+    - unconvert
+    - unparam
+    - unused
+    - varcheck
+    - whitespace
+    - maligned
+    - prealloc
+
+linters-settings:
+  govet:
+    check-shadowing: true
+
+issues:
+  exclude-use-default: false

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 go-autowire
+Copyright (c) 2021 go-autowire (Filip Petrov)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

atesting/testing.go

@@ -1,11 +1,13 @@
+// atesting package provides Spy function for easy way to mock dependencies
 package atesting
 
 import (
 	"container/list"
-	"github.com/go-autowire/autowire"
 	"log"
 	"reflect"
 	"unicode"
+
+	"github.com/go-autowire/autowire"
 )
 
 // Spy Function is replacing object field with the one provided in the function as a second argument.
@@ -17,17 +19,19 @@ import (
 //   atesting.Spy(application, &TestAuditClient{})
 // Or this is equivalent of
 //   application.UserSvc().SetAuditClient(&TestAuditClient{})
-// Getter UserSvc() is used to access userSvc field, which is unexported. For more information take a look at example package.
-//Parameters of Spy function:
+// Getter UserSvc() is used to access userSvc field, which is unexported.
+// For more information take a look at example package.
+// Parameters of Spy function:
 //   - `v`          : pointer to structure inside which spy object will be applied
 //   - `dependency` : pointer to structure which will be injected
 func Spy(v interface{}, dependency interface{}) {
 	slice := []interface{}{dependency}
 	Spies(v, slice)
 }
 
-// Spies Function is replacing object fields with the list of provided dependencies in the function as a second argument.
-// Spy Function detects automatically which field could be replaced with the provided one in the list of dependencies.
+// Spies Function is replacing object fields with the list of provided dependencies
+// in the function as a second argument. Spy Function detects automatically which field
+// could be replaced with the provided one in the list of dependencies.
 // Important note: In order to traverse fields of the unexported fields we need to implement Getters.
 // As shown inside example package, we are replacing AuditClient with our mock implementation and in order to reach this
 // field we need Getter.
@@ -36,7 +40,8 @@ func Spy(v interface{}, dependency interface{}) {
 // Or this is equivalent of
 //   application.UserSvc().SetAuditClient(&TestAuditClient{})
 //   application.UserSvc().PaymentSvc = &TestPaymentServiceTest{}
-// Getter UserSvc() is used to access userSvc field, which is unexported. In case of PaymentSvc it is not required as field PaymentSvc is exported.
+// Getter UserSvc() is used to access userSvc field, which is unexported. In case of PaymentSvc it is not required
+// as field PaymentSvc is exported.
 // Parameters of Spies function:
 //   - `v`            : structure inside which spy objects will be applied
 //   - `dependencies` : list of dependencies which will be injected

autowire.go

@@ -3,8 +3,6 @@ package autowire
 import (
 	"io"
 	"log"
-	"os"
-	"os/signal"
 	"reflect"
 	"regexp"
 	"strings"
@@ -13,15 +11,13 @@ import (
 
 var dependencies map[string]interface{}
 var currentProfile = getProfile()
-var ch = make(chan os.Signal)
 
 // Tag name
 const Tag = "autowire"
 
 func init() {
 	log.SetFlags(log.LstdFlags | log.Lshortfile)
 	log.Println("Init Autowire Context")
-	signal.Notify(ch, os.Interrupt, os.Kill)
 	dependencies = make(map[string]interface{})
 }
 
@@ -34,49 +30,60 @@ func InitProd(initFunc func()) {
 }
 
 // Autowire function injects all dependencies for the given structure v.
-// In order dependencies to be injected the desired struct fields should be marked with
-// autowire tag.
+// Autowire function should be executed in the init() function of the
+// package. In order dependencies to be injected the desired struct fields
+// should be marked with autowire tag.
 //
 // Concrete type Injection
 //
 // Currently both type of fields exported and unexported are supported.
 //
 // Unexported field
 //
-// Following snippet shows injecting dependencies inside private structure fields using `autowire:""` tag:
+// Following snippet shows injecting dependencies inside private structure
+// fields using `autowire:""` tag:
 //  type Application struct {
 //      config  *configuration.ApplicationConfig `autowire:""`
 //  }
 //  func (a *Application) SetConfig(config  *configuration.ApplicationConfig)  {
 //      a.config = config
 //  }
-// If we need given dependency to be injected into unexported field Setter function(Set<FieldName>) is required, as show above.
-// If you have a field called config (lower case, unexported), the setter method should be called SetConfig (upper case, exported), not Setconfig.
+// If we need given dependency to be injected into unexported field Setter
+// function(Set<FieldName>) is required, as show above. If you have a field
+// called config (lower case, unexported), the setter method should be called
+// SetConfig, not Setconfig.
 //
 // Exported field
 //
-// The use of upper-case names of the struct fields indicated field is exported.
+// The use of upper-case names of the struct fields indicated that field is exported.
 //  type Application struct {
 //      Config  *configuration.ApplicationConfig `autowire:""`
 //  }
-// Dependency injection of exported field is supported with the difference that we don`t provide additional Setter function.
+// Dependency injection of exported field is supported with the difference that we don't
+// provide additional Setter function.
 //
 // Interface Injection
 //
-// Often it`s better to rely on interface instead of concrete type, in order to accomplish this decoupling we specify
-// interfaces as a type of struct fields. The following snippet demonstrate that
+// Often it's better to rely on interface instead of concrete type, in order to
+// accomplish this decoupling we should specify interfaces as a type of struct
+// fields. The following snippet demonstrate that:
 //  type UserService struct {
 //      userRoleRepository UserRoleRepository `autowire:"repository/InMemoryUserRoleRepository"`
 //  }
 //  func (u *UserService) SetUserRoleRepository(userRoleRepository UserRoleRepository) {
 //      u.userRoleRepository = userRoleRepository
 //  }
-// UserRoleRepository is simply an interface and InMemoryUserRoleRepository is a struct, which implements this interface.
-// As it`s done dependency injection on unexported field, providing Setter is required. Just to highlight unexported fields
-// needs Setter while exported not. For more information take a look at example#https://github.com/go-autowire/autowire/tree/main/example package.
-// Example:
-//
-//
+// UserRoleRepository is simply an interface and InMemoryUserRoleRepository is a
+// struct, which implements that interface. As dependency injection is executed
+// on unexported field, providing Setter is required. Just to highlight unexported
+// fields needs Setter while exported not. For more information take a look at
+// example https://github.com/go-autowire/autowire/tree/main/example package.
+// Very Simplified Example:
+//		type App struct {}
+//		func init()  {
+//			autowire.Autowire(&App{})
+//		}
+// As mentioned above Autowire function should be invoked in the package init function.
 func Autowire(v interface{}) {
 	value := reflect.ValueOf(v)
 	switch value.Kind() {
@@ -95,12 +102,12 @@ func Autowire(v interface{}) {
 	default: // reflect.Array, reflect.Struct, reflect.Interface
 		log.Println(value.Type().String() + " value")
 	}
-	//log.Println(dependencies)
+	// log.Println(dependencies)
 }
 
 // Autowired function returns fully initialized with all dependencies instance, which is ready to be used.
-//As the result is empty interface, type assertions is required before using the instance.
-//Take a look at https://golang.org/ref/spec#Type_assertions for more information.
+// As the result is empty interface, type assertions is required before using the instance.
+// Take a look at https://golang.org/ref/spec#Type_assertions for more information.
 // The following snippet demonstrate how could be done :
 // 	 app := autowire.Autowired(app.Application{}).(*app.Application)
 func Autowired(v interface{}) interface{} {
@@ -121,6 +128,24 @@ func Autowired(v interface{}) interface{} {
 	return nil
 }
 
+// Close function invoke Close method on each autowired struct
+// which implements io.Closer interface, so currently active
+// occupied resources (connections, channels, descriptor, etc.)
+// could be released.
+func Close() {
+	log.Println("Closing...")
+	for _, dependency := range dependencies {
+		valueDepend := reflect.ValueOf(dependency)
+		closerType := reflect.TypeOf((*io.Closer)(nil)).Elem()
+		if valueDepend.Type().Implements(closerType) {
+			err := dependency.(io.Closer).Close()
+			if err != nil {
+				log.Println(err.Error())
+			}
+		}
+	}
+}
+
 func getStructPtrFullPath(value reflect.Value) string {
 	return getFullPath(value.Elem().Type().PkgPath(), value.Type().String())
 }
@@ -191,25 +216,3 @@ func findDependency(tagDependencyType string) []interface{} {
 	}
 	return result
 }
-
-// Run executes function function after the function execution completes for each autowired struct
-// which implements io.Closer interface will be invoked Call() function, so currently active
-//occupied resources(connections, channels, etc.) could be released.
-func Run(function func()) {
-	defer closeAll()
-	function()
-}
-
-func closeAll() {
-	log.Println("Closing...")
-	for _, dependency := range dependencies {
-		valueDepend := reflect.ValueOf(dependency)
-		closerType := reflect.TypeOf((*io.Closer)(nil)).Elem()
-		if valueDepend.Type().Implements(closerType) {
-			err := dependency.(io.Closer).Close()
-			if err != nil {
-				log.Println(err.Error())
-			}
-		}
-	}
-}

doc.go

@@ -1,15 +1,18 @@
-// Package Autowire is a framework that makes dependency injection in Golang.
+// Package autowire is a framework that makes easy using the dependency
+// injection in Golang.
 //
-// Autowire applications use dependency injection framework to eliminate usage
-// of globals without the tedious approach to manually wiring all the
-// dependencies together. Current approach of Autowire framework to accomplish
-// dependency injection is via using struct tags.
+// The main purpose of using Autowire as dependency injection framework is
+// to eliminate usage of globals without the tedious approach to manually
+// wiring all the dependencies together. Current approach of Autowire
+// framework is relying on dependency injection via using struct tags and
+// reflection. All the dependencies are injected via golang reflection.
 //
 // Basic usage is explained in the package-level example below. If you're new
 // to Autowire, start there!
 //
 // Testing of Autowire Applications
 //
-// To write end-to-end tests of your application, you can use functions provided
-//by atesting package https://godoc.org/github.com/go-autowire/autowire/atesting
+// To write unit or end-to-end tests of your application, you can use functions
+// provided by atesting package. For more information take a look at
+// https://godoc.org/github.com/go-autowire/autowire/atesting.
 package autowire

example/app/application.go

@@ -1,17 +1,19 @@
+// app package
 package app
 
 import (
-	"fmt"
+	"log"
+
 	"github.com/go-autowire/autowire"
 	"github.com/go-autowire/autowire/example/configuration"
 	"github.com/go-autowire/autowire/example/service"
-	"log"
 )
 
 func init() {
 	autowire.Autowire(&Application{})
 }
 
+// Application represents named struct
 type Application struct {
 	config  *configuration.ApplicationConfig `autowire:""`
 	userSvc *service.UserService             `autowire:""`
@@ -25,7 +27,7 @@ func (a Application) Start() {
 	if err != nil {
 		log.Fatalln(err.Error())
 	}
-	fmt.Println("Current balance is " + balance.String())
+	log.Println("Current balance is " + balance.String())
 }
 
 // SetConfig method is a Setter of private field config

example/autowire_test.go

@@ -1,12 +1,13 @@
 package example
 
 import (
-	"github.com/go-autowire/autowire"
-	"github.com/go-autowire/autowire/atesting"
-	"github.com/go-autowire/autowire/example/app"
 	"log"
 	"math/big"
 	"testing"
+
+	"github.com/go-autowire/autowire"
+	"github.com/go-autowire/autowire/atesting"
+	"github.com/go-autowire/autowire/example/app"
 )
 
 type TestPaymentServiceTest struct {
@@ -26,6 +27,7 @@ func (TestAuditClient) Send(_ string) {
 }
 
 func TestAutowire(t *testing.T) {
+	defer autowire.Close()
 	application := autowire.Autowired(app.Application{}).(*app.Application)
 	atesting.Spies(application, []interface{}{&TestPaymentServiceTest{}, &TestAuditClient{}})
 	application.Start()

example/configuration/application_config.go

@@ -1,3 +1,4 @@
+// configuration package
 package configuration
 
 import (

example/repository/user_repo.go

@@ -1,3 +1,4 @@
+// repository package
 package repository
 
 import "github.com/go-autowire/autowire"
@@ -10,7 +11,7 @@ func init() {
 type UserRole string
 
 const (
-	// OwnerRole
+	// OwnerRole literal
 	OwnerRole UserRole = "owner"
 )
 

example/service/audit_service.go

@@ -15,7 +15,13 @@ type AuditService struct {
 	Type string
 }
 
-// A Send is dispatching the event
+// Send is dispatching the event
 func (AuditService) Send(event string) {
 	log.Printf("auditClient Event %s sent", event)
 }
+
+// Close method release all occupied resources
+func (a AuditService) Close() error {
+	log.Println("Closing AuditService")
+	return nil
+}