refactored Processor initialization and shutdown: now using initializer and shutdowner

backends/abstract.go

@@ -4,19 +4,15 @@ import (
 	"errors"
 	"fmt"
 	"github.com/flashmob/go-guerrilla/envelope"
-	"github.com/flashmob/go-guerrilla/ev"
 	"reflect"
 	"runtime/debug"
 	"strings"
 )
 
 type AbstractBackend struct {
-	config        abstractConfig
-	Extend        Worker
-	p             Processor
-	configLoaders []ConfigLoaderFunc
-	configTesters []ConfigTesterFunc
-	initializers  []DecoratorinitializeFunc
+	config abstractConfig
+	Extend Worker
+	p      Processor
 }
 
 type abstractConfig struct {
@@ -25,24 +21,6 @@ type abstractConfig struct {
 
 var ab AbstractBackend
 
-type ConfigLoaderFunc func(backendConfig BackendConfig) error
-
-func (b *AbstractBackend) AddConfigLoader(f ConfigLoaderFunc) {
-	b.configLoaders = append(b.configLoaders, f)
-}
-
-type ConfigTesterFunc func(backendConfig BackendConfig) error
-
-func (b *AbstractBackend) AddConfigTester(f ConfigTesterFunc) {
-	b.configTesters = append(b.configTesters, f)
-}
-
-type DecoratorinitializeFunc func() error
-
-func (b *AbstractBackend) AddInitializer(f DecoratorinitializeFunc) {
-	b.initializers = append(b.initializers, f)
-}
-
 // Your backend should implement this method and set b.config field with a custom config struct
 // Therefore, your implementation would have your own custom config type instead of dummyConfig
 func (b *AbstractBackend) loadConfig(backendConfig BackendConfig) (err error) {
@@ -69,14 +47,9 @@ func (b *AbstractBackend) SetProcessors(p ...Decorator) {
 }
 
 func (b *AbstractBackend) Initialize(config BackendConfig) error {
-	for _, loader := range b.configLoaders {
-		loader(config)
-	}
-	for i := range b.initializers {
-		b.initializers[i]()
-	}
-	//Service.Publish(ev.BackendProcConfigLoad, config)
-	Service.Publish(ev.BackendProcInitialize, config)
+
+	Service.Initialize(config)
+
 	return nil
 
 	// TODO delete

backends/backend.go

@@ -3,7 +3,6 @@ package backends
 import (
 	"fmt"
 	"github.com/flashmob/go-guerrilla/envelope"
-	"github.com/flashmob/go-guerrilla/ev"
 	"github.com/flashmob/go-guerrilla/log"
 	"strconv"
 	"strings"
@@ -11,10 +10,10 @@ import (
 
 var mainlog log.Logger
 
-var Service BackendService
+var Service *BackendService
 
 func init() {
-	Service = BackendService{}
+	Service = &BackendService{}
 }
 
 // Backends process received mail. Depending on the implementation, they can store mail in the database,
@@ -38,10 +37,6 @@ type Worker interface {
 	// parse the configuration files
 	loadConfig(BackendConfig) error
 
-	AddConfigLoader(f ConfigLoaderFunc)
-	AddConfigTester(f ConfigTesterFunc)
-	AddInitializer(f DecoratorinitializeFunc)
-
 	Shutdown() error
 	Process(*envelope.Envelope) BackendResult
 	Initialize(BackendConfig) error
@@ -49,12 +44,6 @@ type Worker interface {
 	SetProcessors(p ...Decorator)
 }
 
-type DecoratorCallbacks struct {
-	loader     ConfigLoaderFunc
-	tester     ConfigTesterFunc
-	initialize DecoratorinitializeFunc
-}
-
 type BackendConfig map[string]interface{}
 
 var backends = map[string]Worker{}
@@ -107,6 +96,55 @@ func NewBackendResult(message string) BackendResult {
 	return backendResult(message)
 }
 
+type ProcessorInitializer interface {
+	Initialize(backendConfig BackendConfig) error
+}
+
+type ProcessorShutdowner interface {
+	Shutdown() error
+}
+
+type Initialize func(backendConfig BackendConfig) error
+type Shutdown func() error
+
+// Satisfy ProcessorInitializer interface
+// So we can now pass an anonymous function that implements ProcessorInitializer
+func (i Initialize) Initialize(backendConfig BackendConfig) error {
+	// delegate to the anonymous function
+	return i(backendConfig)
+}
+
+// satisfy ProcessorShutdowner interface, same concept as Initialize type
+func (s Shutdown) Shutdown() error {
+	// delegate
+	return s()
+}
+
 type BackendService struct {
-	ev.EventHandler
+	ProcessorHandlers
+}
+
+type ProcessorHandlers struct {
+	Initializers []ProcessorInitializer
+	Shutdowners  []ProcessorShutdowner
+}
+
+func (b *BackendService) AddInitializer(i ProcessorInitializer) {
+	b.Initializers = append(b.Initializers, i)
+}
+
+func (b *BackendService) AddShutdowner(i ProcessorShutdowner) {
+	b.Shutdowners = append(b.Shutdowners, i)
+}
+
+func (b *BackendService) Initialize(backend BackendConfig) {
+	for i := range b.Initializers {
+		b.Initializers[i].Initialize(backend)
+	}
+}
+
+func (b *BackendService) Shutdown() {
+	for i := range b.Shutdowners {
+		b.Shutdowners[i].Shutdown()
+	}
 }

backends/dummy.go

@@ -2,14 +2,8 @@ package backends
 
 func init() {
 	backends["dummy"] = &AbstractBackend{}
-	debuggercb := &DecoratorCallbacks{}
-	headerCB := &DecoratorCallbacks{}
-	redisCB := &DecoratorCallbacks{}
 	backends["dummy"].SetProcessors(
-		MySql(), Redis(redisCB), Compressor(), Header(headerCB), Hasher(), Debugger(debuggercb), HeadersParser())
-	backends["dummy"].AddConfigLoader(debuggercb.loader)
-	backends["dummy"].AddConfigLoader(headerCB.loader)
-	backends["dummy"].AddConfigLoader(redisCB.loader)
+		MySql(), Redis(), Compressor(), Header(), Hasher(), Debugger(), HeadersParser())
 }
 
 // custom configuration we will parse from the json

backends/p_debugger.go

@@ -8,10 +8,9 @@ type debuggerConfig struct {
 	LogReceivedMails bool `json:"log_received_mails"`
 }
 
-func Debugger(dc *DecoratorCallbacks) Decorator {
-
+func Debugger() Decorator {
 	var config *debuggerConfig
-	dc.loader = func(backendConfig BackendConfig) error {
+	initFunc := Initialize(func(backendConfig BackendConfig) error {
 		configType := baseConfig(&debuggerConfig{})
 		bcfg, err := ab.extractConfig(backendConfig, configType)
 		if err != nil {
@@ -19,8 +18,8 @@ func Debugger(dc *DecoratorCallbacks) Decorator {
 		}
 		config = bcfg.(*debuggerConfig)
 		return nil
-	}
-
+	})
+	Service.AddInitializer(initFunc)
 	return func(c Processor) Processor {
 		return ProcessorFunc(func(e *envelope.Envelope) (BackendResult, error) {
 			if config.LogReceivedMails {

backends/p_header.go

@@ -11,20 +11,20 @@ type HeaderConfig struct {
 }
 
 // Generate the MTA delivery header
-// Sets e.DeliveryHeader with the result
-func Header(dc *DecoratorCallbacks) Decorator {
+// Sets e.DeliveryHeader part of the envelope with the generated header
+func Header() Decorator {
 
 	var config *HeaderConfig
-	dc.loader = func(backendConfig BackendConfig) error {
+
+	Service.AddInitializer(Initialize(func(backendConfig BackendConfig) error {
 		configType := baseConfig(&HeaderConfig{})
 		bcfg, err := ab.extractConfig(backendConfig, configType)
 		if err != nil {
 			return err
 		}
 		config = bcfg.(*HeaderConfig)
-
 		return nil
-	}
+	}))
 
 	return func(c Processor) Processor {
 		return ProcessorFunc(func(e *envelope.Envelope) (BackendResult, error) {

backends/p_mysql.go

@@ -8,7 +8,6 @@ import (
 	"github.com/flashmob/go-guerrilla/envelope"
 	"github.com/go-sql-driver/mysql"
 
-	"github.com/flashmob/go-guerrilla/ev"
 	"runtime/debug"
 )
 
@@ -24,13 +23,35 @@ type MysqlProcessorConfig struct {
 	PrimaryHost        string `json:"primary_mail_host"`
 }
 
-type MysqlProcessorDecorator struct {
+type MysqlProcessor struct {
 	cache  stmtCache
 	config *MysqlProcessorConfig
 }
 
+func (m *MysqlProcessor) connect(config *MysqlProcessorConfig) (*sql.DB, error) {
+	var db *sql.DB
+	var err error
+	conf := mysql.Config{
+		User:         config.MysqlUser,
+		Passwd:       config.MysqlPass,
+		DBName:       config.MysqlDB,
+		Net:          "tcp",
+		Addr:         config.MysqlHost,
+		ReadTimeout:  GuerrillaDBAndRedisBatchTimeout + (time.Second * 10),
+		WriteTimeout: GuerrillaDBAndRedisBatchTimeout + (time.Second * 10),
+		Params:       map[string]string{"collation": "utf8_general_ci"},
+	}
+	if db, err = sql.Open("mysql", conf.FormatDSN()); err != nil {
+		mainlog.Error("cannot open mysql", err)
+		return nil, err
+	}
+	mainlog.Info("connected to mysql on tcp ", config.MysqlHost)
+	return db, err
+
+}
+
 // prepares the sql query with the number of rows that can be batched with it
-func (g *MysqlProcessorDecorator) prepareInsertQuery(rows int, db *sql.DB) *sql.Stmt {
+func (g *MysqlProcessor) prepareInsertQuery(rows int, db *sql.DB) *sql.Stmt {
 	if rows == 0 {
 		panic("rows argument cannot be 0")
 	}
@@ -58,7 +79,7 @@ func (g *MysqlProcessorDecorator) prepareInsertQuery(rows int, db *sql.DB) *sql.
 	return stmt
 }
 
-func (g *MysqlProcessorDecorator) doQuery(c int, db *sql.DB, insertStmt *sql.Stmt, vals *[]interface{}) {
+func (g *MysqlProcessor) doQuery(c int, db *sql.DB, insertStmt *sql.Stmt, vals *[]interface{}) {
 	var execErr error
 	defer func() {
 		if r := recover(); r != nil {
@@ -84,48 +105,34 @@ func (g *MysqlProcessorDecorator) doQuery(c int, db *sql.DB, insertStmt *sql.Stm
 
 func MySql() Decorator {
 
-	decorator := MysqlProcessorDecorator{}
-
 	var config *MysqlProcessorConfig
-
 	var vals []interface{}
 	var db *sql.DB
+	mp := &MysqlProcessor{}
 
-	mysqlConnect := func() (*sql.DB, error) {
-		conf := mysql.Config{
-			User:         config.MysqlUser,
-			Passwd:       config.MysqlPass,
-			DBName:       config.MysqlDB,
-			Net:          "tcp",
-			Addr:         config.MysqlHost,
-			ReadTimeout:  GuerrillaDBAndRedisBatchTimeout + (time.Second * 10),
-			WriteTimeout: GuerrillaDBAndRedisBatchTimeout + (time.Second * 10),
-			Params:       map[string]string{"collation": "utf8_general_ci"},
-		}
-		if db, err := sql.Open("mysql", conf.FormatDSN()); err != nil {
-			mainlog.Error("cannot open mysql", err)
-			return nil, err
-		} else {
-			mainlog.Info("connected to mysql on tcp ", config.MysqlHost)
-			return db, nil
-		}
-
-	}
-	Service.Subscribe(ev.BackendProcInitialize, func(backendConfig BackendConfig) {
-
+	Service.AddInitializer(Initialize(func(backendConfig BackendConfig) error {
 		configType := baseConfig(&MysqlProcessorConfig{})
-		// TODO deal with error (supressed) push them on a channel? eg, Service.Errors <- service.ErrConfigLoad
-		bcfg, _ := ab.extractConfig(backendConfig, configType)
+		bcfg, err := ab.extractConfig(backendConfig, configType)
+		if err != nil {
+			return err
+		}
 		config = bcfg.(*MysqlProcessorConfig)
-		decorator.config = config
-
-		// todo backendErrors chan error
-		var err error
-		db, err = mysqlConnect()
+		mp.config = config
+		db, err = mp.connect(config)
 		if err != nil {
 			mainlog.Fatalf("cannot open mysql: %s", err)
+			return err
+		}
+		return nil
+	}))
+
+	// shutdown
+	Service.AddShutdowner(Shutdown(func() error {
+		if db != nil {
+			db.Close()
 		}
-	})
+		return nil
+	}))
 
 	return func(c Processor) Processor {
 		return ProcessorFunc(func(e *envelope.Envelope) (BackendResult, error) {
@@ -174,8 +181,8 @@ func MySql() Decorator {
 				trimToLimit(e.MailFrom.String(), 255),
 				e.TLS)
 
-			stmt := decorator.prepareInsertQuery(1, db)
-			decorator.doQuery(1, db, stmt, &vals)
+			stmt := mp.prepareInsertQuery(1, db)
+			mp.doQuery(1, db, stmt, &vals)
 			// continue to the next Processor in the decorator chain
 			return c.Process(e)
 		})

backends/p_redis.go

@@ -1,9 +1,12 @@
 package backends
 
 import (
+	"fmt"
+
 	"github.com/flashmob/go-guerrilla/envelope"
 
 	"github.com/flashmob/go-guerrilla/response"
+	"github.com/garyburd/redigo/redis"
 )
 
 type RedisProcessorConfig struct {
@@ -11,22 +14,51 @@ type RedisProcessorConfig struct {
 	RedisInterface     string `json:"redis_interface"`
 }
 
+type RedisProcessor struct {
+	isConnected bool
+	conn        redis.Conn
+}
+
+func (r *RedisProcessor) redisConnection(redisInterface string) (err error) {
+	if r.isConnected == false {
+		r.conn, err = redis.Dial("tcp", redisInterface)
+		if err != nil {
+			// handle error
+			return err
+		}
+		r.isConnected = true
+	}
+	return nil
+}
+
 // The redis decorator stores the email data in redis
 
-func Redis(dc *DecoratorCallbacks) Decorator {
+func Redis() Decorator {
 
 	var config *RedisProcessorConfig
-	redisClient := &redisClient{}
-	dc.loader = func(backendConfig BackendConfig) error {
+	redisClient := &RedisProcessor{}
+	// read the config into RedisProcessorConfig
+	Service.AddInitializer(Initialize(func(backendConfig BackendConfig) error {
 		configType := baseConfig(&RedisProcessorConfig{})
 		bcfg, err := ab.extractConfig(backendConfig, configType)
 		if err != nil {
 			return err
 		}
 		config = bcfg.(*RedisProcessorConfig)
-
+		if redisErr := redisClient.redisConnection(config.RedisInterface); redisErr != nil {
+			err := fmt.Errorf("Redis cannot connect, check your settings: %s", redisErr)
+			return err
+		}
 		return nil
-	}
+	}))
+	// When shutting down
+	Service.AddShutdowner(Shutdown(func() error {
+		if redisClient.isConnected {
+			redisClient.conn.Close()
+		}
+		return nil
+	}))
+
 	var redisErr error
 
 	return func(c Processor) Processor {

backends/processor.go

@@ -12,7 +12,7 @@ type Processor interface {
 // Signature of DoFunc
 type ProcessorFunc func(*envelope.Envelope) (BackendResult, error)
 
-// Add method to DoFunc type to satisfy Client interface
+// Make ProcessorFunc will satisfy the Processor interface
 func (f ProcessorFunc) Process(e *envelope.Envelope) (BackendResult, error) {
 	return f(e)
 }

cmd/guerrillad/serve.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"github.com/flashmob/go-guerrilla"
 	"github.com/flashmob/go-guerrilla/backends"
-	"github.com/flashmob/go-guerrilla/ev"
 	"github.com/flashmob/go-guerrilla/log"
 	"github.com/spf13/cobra"
 	"io/ioutil"
@@ -86,7 +85,7 @@ func sigHandler(app guerrilla.Guerrilla) {
 	}
 }
 
-func subscribeBackendEvent(event ev.Event, backend backends.Backend, app guerrilla.Guerrilla) {
+func subscribeBackendEvent(event guerrilla.Event, backend backends.Backend, app guerrilla.Guerrilla) {
 
 	app.Subscribe(event, func(cmdConfig *CmdConfig) {
 		logger, _ := log.GetLogger(cmdConfig.LogFile)
@@ -145,12 +144,12 @@ func serve(cmd *cobra.Command, args []string) {
 	if err != nil {
 		mainlog.WithError(err).Error("Error(s) when starting server(s)")
 	}
-	subscribeBackendEvent(ev.ConfigBackendConfig, backend, app)
-	subscribeBackendEvent(ev.ConfigBackendName, backend, app)
+	subscribeBackendEvent(guerrilla.EventConfigBackendConfig, backend, app)
+	subscribeBackendEvent(guerrilla.EventConfigBackendName, backend, app)
 	// Write out our PID
 	writePid(cmdConfig.PidFile)
 	// ...and write out our pid whenever the file name changes in the config
-	app.Subscribe(ev.ConfigPidFile, func(ac *guerrilla.AppConfig) {
+	app.Subscribe(guerrilla.EventConfigPidFile, func(ac *guerrilla.AppConfig) {
 		writePid(ac.PidFile)
 	})
 	// change the logger from stdrerr to one from config
@@ -185,10 +184,10 @@ func (c *CmdConfig) load(jsonBytes []byte) error {
 func (c *CmdConfig) emitChangeEvents(oldConfig *CmdConfig, app guerrilla.Guerrilla) {
 	// has backend changed?
 	if !reflect.DeepEqual((*c).BackendConfig, (*oldConfig).BackendConfig) {
-		app.Publish(ev.ConfigBackendConfig, c)
+		app.Publish(guerrilla.EventConfigBackendConfig, c)
 	}
 	if c.BackendName != oldConfig.BackendName {
-		app.Publish(ev.ConfigBackendName, c)
+		app.Publish(guerrilla.EventConfigBackendName, c)
 	}
 	// call other emitChangeEvents
 	c.AppConfig.EmitChangeEvents(&oldConfig.AppConfig, app)

config.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/flashmob/go-guerrilla/ev"
 	"os"
 	"reflect"
 	"strings"
@@ -67,26 +66,26 @@ func (c *AppConfig) Load(jsonBytes []byte) error {
 func (c *AppConfig) EmitChangeEvents(oldConfig *AppConfig, app Guerrilla) {
 	// has config changed, general check
 	if !reflect.DeepEqual(oldConfig, c) {
-		app.Publish(ev.ConfigNewConfig, c)
+		app.Publish(EventConfigNewConfig, c)
 	}
 	// has 'allowed hosts' changed?
 	if !reflect.DeepEqual(oldConfig.AllowedHosts, c.AllowedHosts) {
-		app.Publish(ev.ConfigAllowedHosts, c)
+		app.Publish(EventConfigAllowedHosts, c)
 	}
 	// has pid file changed?
 	if strings.Compare(oldConfig.PidFile, c.PidFile) != 0 {
-		app.Publish(ev.ConfigPidFile, c)
+		app.Publish(EventConfigPidFile, c)
 	}
 	// has mainlog log changed?
 	if strings.Compare(oldConfig.LogFile, c.LogFile) != 0 {
-		app.Publish(ev.ConfigLogFile, c)
+		app.Publish(EventConfigLogFile, c)
 	} else {
 		// since config file has not changed, we reload it
-		app.Publish(ev.ConfigLogReopen, c)
+		app.Publish(EventConfigLogReopen, c)
 	}
 	// has log level changed?
 	if strings.Compare(oldConfig.LogLevel, c.LogLevel) != 0 {
-		app.Publish(ev.ConfigLogLevel, c)
+		app.Publish(EventConfigLogLevel, c)
 	}
 	// server config changes
 	oldServers := oldConfig.getServers()
@@ -99,21 +98,21 @@ func (c *AppConfig) EmitChangeEvents(oldConfig *AppConfig, app Guerrilla) {
 			newServer.emitChangeEvents(oldServer, app)
 		} else {
 			// start new server
-			app.Publish(ev.ConfigEvServerNew, newServer)
+			app.Publish(EventConfigEvServerNew, newServer)
 		}
 
 	}
 	// remove any servers that don't exist anymore
 	for _, oldserver := range oldServers {
-		app.Publish(ev.ConfigServerRemove, oldserver)
+		app.Publish(EventConfigServerRemove, oldserver)
 	}
 }
 
 // EmitLogReopen emits log reopen events using existing config
 func (c *AppConfig) EmitLogReopenEvents(app Guerrilla) {
-	app.Publish(ev.ConfigLogReopen, c)
+	app.Publish(EventConfigLogReopen, c)
 	for _, sc := range c.getServers() {
-		app.Publish(ev.ConfigServerLogReopen, sc)
+		app.Publish(EventConfigServerLogReopen, sc)
 	}
 }
 
@@ -136,33 +135,33 @@ func (sc *ServerConfig) emitChangeEvents(oldServer *ServerConfig, app Guerrilla)
 	)
 	if len(changes) > 0 {
 		// something changed in the server config
-		app.Publish(ev.ConfigServerConfig, sc)
+		app.Publish(EventConfigServerConfig, sc)
 	}
 
 	// enable or disable?
 	if _, ok := changes["IsEnabled"]; ok {
 		if sc.IsEnabled {
-			app.Publish(ev.ConfigServerStart, sc)
+			app.Publish(EventConfigServerStart, sc)
 		} else {
-			app.Publish(ev.ConfigServerStop, sc)
+			app.Publish(EventConfigServerStop, sc)
 		}
 		// do not emit any more events when IsEnabled changed
 		return
 	}
 	// log file change?
 	if _, ok := changes["LogFile"]; ok {
-		app.Publish(ev.ConfigServerLogFile, sc)
+		app.Publish(EventConfigServerLogFile, sc)
 	} else {
 		// since config file has not changed, we reload it
-		app.Publish(ev.ConfigServerLogReopen, sc)
+		app.Publish(EventConfigServerLogReopen, sc)
 	}
 	// timeout changed
 	if _, ok := changes["Timeout"]; ok {
-		app.Publish(ev.ConfigServerTimeout, sc)
+		app.Publish(EventConfigServerTimeout, sc)
 	}
 	// max_clients changed
 	if _, ok := changes["MaxClients"]; ok {
-		app.Publish(ev.ConfigServerMaxClients, sc)
+		app.Publish(EventConfigServerMaxClients, sc)
 	}
 
 	// tls changed
@@ -181,7 +180,7 @@ func (sc *ServerConfig) emitChangeEvents(oldServer *ServerConfig, app Guerrilla)
 		}
 		return false
 	}(); ok {
-		app.Publish(ev.ConfigServerTLSConfig, sc)
+		app.Publish(EventConfigServerTLSConfig, sc)
 	}
 }
 

ev/event.go → event.go

@@ -1,4 +1,4 @@
-package ev
+package guerrilla
 
 import (
 	evbus "github.com/asaskevich/EventBus"
@@ -8,48 +8,41 @@ type Event int
 
 const (
 	// when a new config was loaded
-	ConfigNewConfig Event = iota
+	EventConfigNewConfig Event = iota
 	// when allowed_hosts changed
-	ConfigAllowedHosts
+	EventConfigAllowedHosts
 	// when pid_file changed
-	ConfigPidFile
+	EventConfigPidFile
 	// when log_file changed
-	ConfigLogFile
+	EventConfigLogFile
 	// when it's time to reload the main log file
-	ConfigLogReopen
+	EventConfigLogReopen
 	// when log level changed
-	ConfigLogLevel
+	EventConfigLogLevel
 	// when the backend changed
-	ConfigBackendName
+	EventConfigBackendName
 	// when the backend's config changed
-	ConfigBackendConfig
+	EventConfigBackendConfig
 	// when a new server was added
-	ConfigEvServerNew
+	EventConfigEvServerNew
 	// when an existing server was removed
-	ConfigServerRemove
+	EventConfigServerRemove
 	// when a new server config was detected (general event)
-	ConfigServerConfig
+	EventConfigServerConfig
 	// when a server was enabled
-	ConfigServerStart
+	EventConfigServerStart
 	// when a server was disabled
-	ConfigServerStop
+	EventConfigServerStop
 	// when a server's log file changed
-	ConfigServerLogFile
+	EventConfigServerLogFile
 	// when it's time to reload the server's log
-	ConfigServerLogReopen
+	EventConfigServerLogReopen
 	// when a server's timeout changed
-	ConfigServerTimeout
+	EventConfigServerTimeout
 	// when a server's max clients changed
-	ConfigServerMaxClients
+	EventConfigServerMaxClients
 	// when a server's TLS config changed
-	ConfigServerTLSConfig
-
-	// Load a backend processor's config todo: dont need it?
-	BackendProcConfigLoad
-	// initialize a backend processor
-	BackendProcInitialize
-	// shutdown a backend processor
-	BackendProcShutdown
+	EventConfigServerTLSConfig
 )
 
 var eventList = [...]string{

guerrilla.go

@@ -3,7 +3,6 @@ package guerrilla
 import (
 	"errors"
 	"github.com/flashmob/go-guerrilla/backends"
-	"github.com/flashmob/go-guerrilla/ev"
 	"github.com/flashmob/go-guerrilla/log"
 	"sync"
 	"sync/atomic"
@@ -36,9 +35,9 @@ func (e Errors) Error() string {
 type Guerrilla interface {
 	Start() error
 	Shutdown()
-	Subscribe(topic ev.Event, fn interface{}) error
-	Publish(topic ev.Event, args ...interface{})
-	Unsubscribe(topic ev.Event, handler interface{}) error
+	Subscribe(topic Event, fn interface{}) error
+	Publish(topic Event, args ...interface{})
+	Unsubscribe(topic Event, handler interface{}) error
 	SetLogger(log.Logger)
 }
 
@@ -49,7 +48,7 @@ type guerrilla struct {
 	// guard controls access to g.servers
 	guard sync.Mutex
 	state int8
-	ev.EventHandler
+	EventHandler
 	logStore
 }
 
@@ -173,12 +172,12 @@ func (g *guerrilla) mapServers(callback func(*server)) map[string]*server {
 func (g *guerrilla) subscribeEvents() {
 
 	// main config changed
-	g.Subscribe(ev.ConfigNewConfig, func(c *AppConfig) {
+	g.Subscribe(EventConfigNewConfig, func(c *AppConfig) {
 		g.setConfig(c)
 	})
 
 	// allowed_hosts changed, set for all servers
-	g.Subscribe(ev.ConfigAllowedHosts, func(c *AppConfig) {
+	g.Subscribe(EventConfigAllowedHosts, func(c *AppConfig) {
 		g.mapServers(func(server *server) {
 			server.setAllowedHosts(c.AllowedHosts)
 		})
@@ -186,7 +185,7 @@ func (g *guerrilla) subscribeEvents() {
 	})
 
 	// the main log file changed
-	g.Subscribe(ev.ConfigLogFile, func(c *AppConfig) {
+	g.Subscribe(EventConfigLogFile, func(c *AppConfig) {
 		var err error
 		var l log.Logger
 		if l, err = log.GetLogger(c.LogFile); err == nil {
@@ -203,13 +202,13 @@ func (g *guerrilla) subscribeEvents() {
 	})
 
 	// re-open the main log file (file not changed)
-	g.Subscribe(ev.ConfigLogReopen, func(c *AppConfig) {
+	g.Subscribe(EventConfigLogReopen, func(c *AppConfig) {
 		g.mainlog().Reopen()
 		g.mainlog().Infof("re-opened main log file [%s]", c.LogFile)
 	})
 
 	// when log level changes, apply to mainlog and server logs
-	g.Subscribe(ev.ConfigLogLevel, func(c *AppConfig) {
+	g.Subscribe(EventConfigLogLevel, func(c *AppConfig) {
 		g.mainlog().SetLevel(c.LogLevel)
 		g.mapServers(func(server *server) {
 			server.log.SetLevel(c.LogLevel)
@@ -218,12 +217,12 @@ func (g *guerrilla) subscribeEvents() {
 	})
 
 	// server config was updated
-	g.Subscribe(ev.ConfigServerConfig, func(sc *ServerConfig) {
+	g.Subscribe(EventConfigServerConfig, func(sc *ServerConfig) {
 		g.setServerConfig(sc)
 	})
 
 	// add a new server to the config & start
-	g.Subscribe(ev.ConfigEvServerNew, func(sc *ServerConfig) {
+	g.Subscribe(EventConfigEvServerNew, func(sc *ServerConfig) {
 		if _, err := g.findServer(sc.ListenInterface); err != nil {
 			// not found, lets add it
 			if err := g.makeServers(); err != nil {
@@ -240,7 +239,7 @@ func (g *guerrilla) subscribeEvents() {
 		}
 	})
 	// start a server that already exists in the config and has been enabled
-	g.Subscribe(ev.ConfigServerStart, func(sc *ServerConfig) {
+	g.Subscribe(EventConfigServerStart, func(sc *ServerConfig) {
 		if server, err := g.findServer(sc.ListenInterface); err == nil {
 			if server.state == ServerStateStopped || server.state == ServerStateNew {
 				g.mainlog().Infof("Starting server [%s]", server.listenInterface)
@@ -252,7 +251,7 @@ func (g *guerrilla) subscribeEvents() {
 		}
 	})
 	// stop running a server
-	g.Subscribe(ev.ConfigServerStop, func(sc *ServerConfig) {
+	g.Subscribe(EventConfigServerStop, func(sc *ServerConfig) {
 		if server, err := g.findServer(sc.ListenInterface); err == nil {
 			if server.state == ServerStateRunning {
 				server.Shutdown()
@@ -261,7 +260,7 @@ func (g *guerrilla) subscribeEvents() {
 		}
 	})
 	// server was removed from config
-	g.Subscribe(ev.ConfigServerRemove, func(sc *ServerConfig) {
+	g.Subscribe(EventConfigServerRemove, func(sc *ServerConfig) {
 		if server, err := g.findServer(sc.ListenInterface); err == nil {
 			server.Shutdown()
 			g.removeServer(sc.ListenInterface)
@@ -270,7 +269,7 @@ func (g *guerrilla) subscribeEvents() {
 	})
 
 	// TLS changes
-	g.Subscribe(ev.ConfigServerTLSConfig, func(sc *ServerConfig) {
+	g.Subscribe(EventConfigServerTLSConfig, func(sc *ServerConfig) {
 		if server, err := g.findServer(sc.ListenInterface); err == nil {
 			if err := server.configureSSL(); err == nil {
 				g.mainlog().Infof("Server [%s] new TLS configuration loaded", sc.ListenInterface)
@@ -280,19 +279,19 @@ func (g *guerrilla) subscribeEvents() {
 		}
 	})
 	// when server's timeout change.
-	g.Subscribe(ev.ConfigServerTimeout, func(sc *ServerConfig) {
+	g.Subscribe(EventConfigServerTimeout, func(sc *ServerConfig) {
 		g.mapServers(func(server *server) {
 			server.setTimeout(sc.Timeout)
 		})
 	})
 	// when server's max clients change.
-	g.Subscribe(ev.ConfigServerMaxClients, func(sc *ServerConfig) {
+	g.Subscribe(EventConfigServerMaxClients, func(sc *ServerConfig) {
 		g.mapServers(func(server *server) {
 			// TODO resize the pool somehow
 		})
 	})
 	// when a server's log file changes
-	g.Subscribe(ev.ConfigServerLogFile, func(sc *ServerConfig) {
+	g.Subscribe(EventConfigServerLogFile, func(sc *ServerConfig) {
 		if server, err := g.findServer(sc.ListenInterface); err == nil {
 			var err error
 			var l log.Logger
@@ -314,7 +313,7 @@ func (g *guerrilla) subscribeEvents() {
 		}
 	})
 	// when the daemon caught a sighup, event for individual server
-	g.Subscribe(ev.ConfigServerLogReopen, func(sc *ServerConfig) {
+	g.Subscribe(EventConfigServerLogReopen, func(sc *ServerConfig) {
 		if server, err := g.findServer(sc.ListenInterface); err == nil {
 			server.log.Reopen()
 			g.mainlog().Infof("Server [%s] re-opened log file [%s]", sc.ListenInterface, sc.LogFile)