Feature/note feature transfer

.gitignore

@@ -10,3 +10,6 @@
 
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
+
+# Editor folders
+.vscode

connectionmanager/connectionmanager.go

@@ -0,0 +1,118 @@
+package connectionmanager
+
+import (
+	"log"
+	"sync"
+)
+
+// Initializer is the interface that initializes a connection of some kind.
+type Initializer interface {
+	Initialize()
+}
+
+// Closer is the interface that gracefully closes a connection of some kind.
+type Closer interface {
+	Close()
+}
+
+// InitializerCloser is the interface the both initializes and gracefully closes a
+// connection of some kind.
+type InitializerCloser interface {
+	Initializer
+	Closer
+}
+
+// CloseFunc is a function that gracefully shuts down a connection as a side effect.
+type CloseFunc func()
+
+// ConnectionManager allows multiple items needing initialization or shutdown to be
+// managed as a group.
+//
+// Initialization and Close of connections are managed independently of each other. Once
+// created the connection manager can accept any number of items supporting initialization,
+// close, or both. The ManageInitialization, ManageClose, and ManageConnection methods can
+// be called as many times as needed in any order to add managed items. They are variadic
+// functions, so multiple items can be added in a single call.
+//
+// Initialization items will immediately start initialization in a separate go routine
+// once the item is added to the ConnectionManager. An internally managed sync.WaitGroup
+// is made available. Calling WG.Wait() on the ConnectionManager will block the current
+// go routine until all initialization functions are complete.
+//
+// Closers are queued up internally running only when the ConnectionManager's Close method
+// is called. The ConnectionManager runs each Close method in a separate go routine and blocks
+// blocks until all are complete.
+type ConnectionManager struct {
+	closerChan chan CloseFunc
+	Close      CloseFunc
+	WG         sync.WaitGroup
+}
+
+// New initializes a new ConnectionManager object that can be used
+// to manage the life of long lived remote connections such as to a database.
+func New(logger *log.Logger) ConnectionManager {
+	closerChan := make(chan CloseFunc)
+	shutdown := make(chan struct{})
+	var stopwg sync.WaitGroup
+	go func() {
+		closers := []CloseFunc{}
+	loop:
+		for {
+			select {
+			case <-shutdown:
+				logger.Println("Shutting Down")
+				break loop
+			case c := <-closerChan:
+				stopwg.Add(1)
+				closers = append(closers, c)
+			}
+		}
+
+		for _, c := range closers {
+			go func(c func()) {
+				c()
+				stopwg.Done()
+			}(c)
+		}
+	}()
+	return ConnectionManager{
+		closerChan: closerChan,
+		Close: func() {
+			shutdown <- struct{}{}
+			stopwg.Wait()
+		},
+	}
+}
+
+// ManageInitialization allows the connection manager to accept any number of items
+// matching the Initializer interface and initializes each in parallel. The wait
+// group is managed to allow callers to block until all managed initialization
+// methods are complete.
+func (cm *ConnectionManager) ManageInitialization(initializers ...Initializer) {
+	for _, initializer := range initializers {
+		cm.WG.Add(1)
+		go func(i Initializer) {
+			i.Initialize()
+			cm.WG.Done()
+		}(initializer)
+	}
+}
+
+// ManageClose allow the connection manager to accept any number of items matching
+// the Closer interface. It queues them up internally. When Close is called on
+// the connection manager, all queued Close methods are executed in parallel.
+// The close method blocks until managed Closers are complete.
+func (cm *ConnectionManager) ManageClose(closers ...Closer) {
+	for _, closer := range closers {
+		cm.closerChan <- closer.Close
+	}
+}
+
+// ManageConnection accepts any number of items matching the InitializerCloser
+// interface and manages both an item's initialization and close.
+func (cm *ConnectionManager) ManageConnection(initializerClosers ...InitializerCloser) {
+	for _, ic := range initializerClosers {
+		cm.ManageClose(ic)
+		cm.ManageInitialization(ic)
+	}
+}

database/db.go

@@ -1,11 +1,11 @@
 package database
 
 import (
-	"fmt"
-	"github.com/go-pg/pg"
-	"github.com/robinjoseph08/go-pg-migrations"
 	"log"
-	"os"
+	"time"
+
+	"github.com/go-pg/pg"
+	migrations "github.com/robinjoseph08/go-pg-migrations"
 )
 
 var (
@@ -15,19 +15,24 @@ var (
 
 // DBConfig wraps config for connecting to a database.
 type DBConfig struct {
-	Address  string
-	User     string
-	Database string
-	Password string
+	Address       string
+	User          string
+	Database      string
+	Password      string
+	Logger        *log.Logger
+	EnableLogging bool
 }
 
 // DB wraps a client for a database.
 type DB struct {
-	Client *pg.DB
+	Client      *pg.DB
+	Logger      *log.Logger
+	initializer func(*DB)
 }
 
 // Close closes a connection to a database. Once close has been called calling other methods on db will error.
 func (db *DB) Close() {
+	db.Logger.Println("Closing database connection")
 	db.Client.Close()
 }
 
@@ -57,18 +62,45 @@ func (d dbLogger) AfterQuery(q *pg.QueryEvent) {
 	d.logger.Printf("executed query\n%+v ", query)
 }
 
-// New returns a new DB object which wraps
-// a connection to the database specified in config
+// New returns a new DB object which wraps a connection to the database specified in config
 func New(config DBConfig) DB {
 	db := pg.Connect(&pg.Options{
 		Addr:     config.Address,
 		User:     config.User,
 		Database: config.Database,
 		Password: config.Password,
 	})
-	if os.Getenv("QUERY_DEBUG") == "ON" {
-		db.AddQueryHook(dbLogger{logger: log.New(os.Stdout, fmt.Sprintf("%s: %s: ", config.Address, config.Database), log.LstdFlags)})
+	if config.EnableLogging {
+		db.AddQueryHook(dbLogger{logger: config.Logger})
+	}
+	return DB{
+		Client:      db,
+		Logger:      config.Logger,
+		initializer: RunMigrations,
+	}
+}
+
+// Initialize runs any needed set up operations for the database. This defaults
+// to RunMigrations, but can be set using the Initializer method.
+func (db *DB) Initialize() {
+	db.initializer(db)
+}
+
+// Initializer changes the initialization function run when the Initialize method is called.
+func (db *DB) Initializer(initializer func(*DB)) {
+	db.initializer = initializer
+}
+
+// RunMigrations is an initialization function for a DB which attempts to run migrations
+// once a second in a loop until they run successfully.
+func RunMigrations(db *DB) {
+	for {
+		err := db.Migrate()
+		if err != nil {
+			db.Logger.Println(err)
+			time.Sleep(1 * time.Second)
+			continue
+		}
+		break
 	}
-	dbWrap := DB{Client: db}
-	return dbWrap
 }