all: Introduce database backend interface and update plugin system an…

…d boostrap accordingly (ory#949)

Signed-off-by: Prateek Malhotra <someone1@gmail.com>

.circleci/config.yml

@@ -40,6 +40,7 @@ jobs:
       - run: go test -race -short $(go list ./... | grep -v cmd)
       - run: ./scripts/test-e2e-jwt.sh
       - run: ./scripts/test-e2e-opaque.sh
+      - run: ./scripts/test-plugin.sh
       - run: test -z "$CIRCLE_PR_NUMBER" && goveralls -service=circle-ci -coverprofile=coverage.txt -repotoken=$COVERALLS_REPO_TOKEN || echo "forks are not allowed to push to coveralls"
 
   swagger:

cmd/server/handler_client_factory.go

@@ -27,33 +27,13 @@ import (
 	"github.com/ory/herodot"
 	"github.com/ory/hydra/client"
 	"github.com/ory/hydra/config"
-	"github.com/ory/sqlcon"
 )
 
 func newClientManager(c *config.Config) client.Manager {
 	ctx := c.Context()
 
-	switch con := ctx.Connection.(type) {
-	case *config.MemoryConnection:
-		expectDependency(c.GetLogger(), ctx.Hasher)
-		return client.NewMemoryManager(ctx.Hasher)
-	case *sqlcon.SQLConnection:
-		expectDependency(c.GetLogger(), ctx.Hasher, con.GetDatabase())
-		return &client.SQLManager{
-			DB:     con.GetDatabase(),
-			Hasher: ctx.Hasher,
-		}
-	case *config.PluginConnection:
-		if m, err := con.NewClientManager(); err != nil {
-			c.GetLogger().Fatalf("Could not load client manager plugin %s", err)
-		} else {
-			return m
-		}
-		break
-	default:
-		panic("Unknown connection type.")
-	}
-	return nil
+	expectDependency(c.GetLogger(), ctx.Hasher, ctx.Connection)
+	return ctx.Connection.NewClientManager(ctx.Hasher)
 }
 
 func newClientHandler(c *config.Config, router *httprouter.Router, manager client.Manager) *client.Handler {

cmd/server/handler_consent_factory.go

@@ -26,37 +26,13 @@ import (
 	"github.com/ory/hydra/client"
 	"github.com/ory/hydra/config"
 	"github.com/ory/hydra/consent"
-	"github.com/ory/sqlcon"
 )
 
 func injectConsentManager(c *config.Config, cm client.Manager) {
 	var ctx = c.Context()
-	var manager consent.Manager
 
-	switch con := ctx.Connection.(type) {
-	case *config.MemoryConnection:
-		expectDependency(c.GetLogger(), ctx.FositeStore)
-		manager = consent.NewMemoryManager(ctx.FositeStore)
-		break
-	case *sqlcon.SQLConnection:
-		expectDependency(c.GetLogger(), ctx.FositeStore, con.GetDatabase())
-		manager = consent.NewSQLManager(
-			con.GetDatabase(),
-			cm,
-			ctx.FositeStore,
-		)
-		break
-	case *config.PluginConnection:
-		var err error
-		if manager, err = con.NewConsentManager(); err != nil {
-			c.GetLogger().Fatalf("Could not load client manager plugin %s", err)
-		}
-		break
-	default:
-		panic("Unknown connection type.")
-	}
-
-	ctx.ConsentManager = manager
+	expectDependency(c.GetLogger(), ctx.FositeStore, ctx.Connection)
+	ctx.ConsentManager = ctx.Connection.NewConsentManager(cm, ctx.FositeStore)
 }
 
 func newConsentHandler(c *config.Config, router *httprouter.Router) *consent.Handler {

cmd/server/handler_health_factory.go

@@ -25,33 +25,13 @@ import (
 	"github.com/ory/herodot"
 	"github.com/ory/hydra/config"
 	"github.com/ory/hydra/health"
-	"github.com/ory/sqlcon"
 )
 
 func newHealthHandler(c *config.Config, router *httprouter.Router) *health.Handler {
 	ctx := c.Context()
-	var rc health.ReadyChecker
 
-	switch con := ctx.Connection.(type) {
-	case *config.MemoryConnection:
-		rc = func() error {
-			return nil
-		}
-		break
-	case *sqlcon.SQLConnection:
-		expectDependency(c.GetLogger(), con.GetDatabase())
-		rc = func() error {
-			return con.GetDatabase().Ping()
-		}
-		break
-	case *config.PluginConnection:
-		rc = func() error {
-			return con.Ping()
-		}
-		break
-	default:
-		panic("Unknown connection type.")
-	}
+	expectDependency(c.GetLogger(), ctx.Connection)
+	var rc health.ReadyChecker = ctx.Connection.Ping
 
 	w := herodot.NewJSONWriter(c.GetLogger())
 	w.ErrorEnhancer = writerErrorEnhancer

cmd/server/handler_jwk_factory.go

@@ -26,35 +26,15 @@ import (
 	"github.com/ory/hydra/config"
 	"github.com/ory/hydra/jwk"
 	"github.com/ory/hydra/oauth2"
-	"github.com/ory/sqlcon"
 )
 
 func injectJWKManager(c *config.Config) {
 	ctx := c.Context()
 
-	switch con := ctx.Connection.(type) {
-	case *config.MemoryConnection:
-		ctx.KeyManager = &jwk.MemoryManager{}
-		break
-	case *sqlcon.SQLConnection:
-		expectDependency(c.GetLogger(), con.GetDatabase())
-		ctx.KeyManager = &jwk.SQLManager{
-			DB: con.GetDatabase(),
-			Cipher: &jwk.AEAD{
-				Key: c.GetSystemSecret(),
-			},
-		}
-		break
-	case *config.PluginConnection:
-		var err error
-		ctx.KeyManager, err = con.NewJWKManager()
-		if err != nil {
-			c.GetLogger().Fatalf("Could not load client manager plugin %s", err)
-		}
-		break
-	default:
-		c.GetLogger().Fatalf("Unknown connection type.")
-	}
+	expectDependency(c.GetLogger(), ctx.Connection)
+	ctx.KeyManager = ctx.Connection.NewJWKManager(&jwk.AEAD{
+		Key: c.GetSystemSecret(),
+	})
 }
 
 func newJWKHandler(c *config.Config, router *httprouter.Router) *jwk.Handler {

cmd/server/handler_oauth2_factory.go

@@ -39,33 +39,14 @@ import (
 	"github.com/ory/hydra/jwk"
 	"github.com/ory/hydra/oauth2"
 	"github.com/ory/hydra/pkg"
-	"github.com/ory/sqlcon"
 	"github.com/pborman/uuid"
 )
 
 func injectFositeStore(c *config.Config, clients client.Manager) {
 	var ctx = c.Context()
-	var store pkg.FositeStorer
-
-	switch con := ctx.Connection.(type) {
-	case *config.MemoryConnection:
-		store = oauth2.NewFositeMemoryStore(clients, c.GetAccessTokenLifespan())
-		break
-	case *sqlcon.SQLConnection:
-		expectDependency(c.GetLogger(), con.GetDatabase())
-		store = oauth2.NewFositeSQLStore(clients, con.GetDatabase(), c.GetLogger(), c.GetAccessTokenLifespan(), c.OAuth2AccessTokenStrategy == "jwt")
-		break
-	case *config.PluginConnection:
-		var err error
-		if store, err = con.NewOAuth2Manager(clients); err != nil {
-			c.GetLogger().Fatalf("Could not load client manager plugin %s", err)
-		}
-		break
-	default:
-		panic("Unknown connection type.")
-	}
 
-	ctx.FositeStore = store
+	expectDependency(c.GetLogger(), ctx.Connection)
+	ctx.FositeStore = ctx.Connection.NewOAuth2Manager(clients, c.GetAccessTokenLifespan(), c.OAuth2AccessTokenStrategy)
 }
 
 func newOAuth2Provider(c *config.Config) fosite.OAuth2Provider {

config/backend_manager.go

@@ -0,0 +1,37 @@
+package config
+
+import (
+	"sync"
+	"time"
+
+	"github.com/sirupsen/logrus"
+
+	"github.com/ory/fosite"
+	"github.com/ory/hydra/client"
+	"github.com/ory/hydra/consent"
+	"github.com/ory/hydra/jwk"
+	"github.com/ory/hydra/pkg"
+)
+
+var (
+	backends = make(map[string]BackendManager)
+	bmutex   sync.Mutex
+)
+
+type BackendManager interface {
+	Init(url string, l logrus.FieldLogger) error
+	NewConsentManager(clientManager client.Manager, fs pkg.FositeStorer) consent.Manager
+	NewOAuth2Manager(clientManager client.Manager, accessTokenLifespan time.Duration, tokenStrategy string) pkg.FositeStorer
+	NewClientManager(hasher fosite.Hasher) client.Manager
+	NewJWKManager(cipher *jwk.AEAD) jwk.Manager
+	Ping() error
+	Prefixes() []string
+}
+
+func RegisterBackend(b BackendManager) {
+	bmutex.Lock()
+	for _, prefix := range b.Prefixes() {
+		backends[prefix] = b
+	}
+	bmutex.Unlock()
+}

config/backend_memory.go

@@ -20,4 +20,52 @@
 
 package config
 
-type MemoryConnection struct{}
+import (
+	"time"
+
+	"github.com/sirupsen/logrus"
+
+	"github.com/ory/fosite"
+	"github.com/ory/hydra/client"
+	"github.com/ory/hydra/consent"
+	"github.com/ory/hydra/jwk"
+	"github.com/ory/hydra/oauth2"
+	"github.com/ory/hydra/pkg"
+)
+
+type MemoryBackend struct {
+	l logrus.FieldLogger
+}
+
+func init() {
+	RegisterBackend(&MemoryBackend{})
+}
+
+func (m *MemoryBackend) Init(url string, l logrus.FieldLogger) error {
+	m.l = l
+	return nil
+}
+
+func (m *MemoryBackend) NewConsentManager(clientManager client.Manager, fs pkg.FositeStorer) consent.Manager {
+	return consent.NewMemoryManager(fs)
+}
+
+func (m *MemoryBackend) NewOAuth2Manager(clientManager client.Manager, accessTokenLifespan time.Duration, tokenStrategy string) pkg.FositeStorer {
+	return oauth2.NewFositeMemoryStore(clientManager, accessTokenLifespan)
+}
+
+func (m *MemoryBackend) NewClientManager(hasher fosite.Hasher) client.Manager {
+	return client.NewMemoryManager(hasher)
+}
+
+func (m *MemoryBackend) NewJWKManager(cipher *jwk.AEAD) jwk.Manager {
+	return &jwk.MemoryManager{}
+}
+
+func (m *MemoryBackend) Prefixes() []string {
+	return []string{"memory"}
+}
+
+func (m *MemoryBackend) Ping() error {
+	return nil
+}