Updated plugin

Author: djthorpe

pkg/sqlite3/pool.go

@@ -80,6 +80,12 @@ func (cfg PoolConfig) WithTrace(fn TraceFunc) PoolConfig {
 	return cfg
 }
 
+// Enable or disable creation of database files
+func (cfg PoolConfig) WithCreate(create bool) PoolConfig {
+	cfg.Create = create
+	return cfg
+}
+
 // Set maxmimum concurrent connections
 func (cfg PoolConfig) WithMaxConnections(n int) PoolConfig {
 	if n >= 0 {
@@ -184,7 +190,7 @@ func (p *Pool) String() string {
 	str += fmt.Sprintf(" ver=%q", Version())
 	str += fmt.Sprint(" flags=", p.cfg.Flags)
 	str += fmt.Sprint(" cur=", p.Cur())
-	str += fmt.Sprint(" max=", p.cfg.Max)
+	str += fmt.Sprint(" max=", p.Max())
 	for schema := range p.cfg.Schemas {
 		str += fmt.Sprintf(" <schema %s=%q>", strings.TrimSpace(schema), p.pathForSchema(schema))
 	}
@@ -217,6 +223,11 @@ func (p *Pool) Cur() int {
 	return int(atomic.LoadInt32(&p.n))
 }
 
+// Return maximum allowed connections
+func (p *Pool) Max() int {
+	return int(p.cfg.Max)
+}
+
 // Set maximum number of "checked out" connections
 func (p *Pool) SetMax(n int) {
 	if n == 0 {

plugin/sqlite3/handlers.go

@@ -20,9 +20,6 @@ import (
 	. "github.com/mutablelogic/go-server"
 	. "github.com/mutablelogic/go-sqlite"
 	. "github.com/mutablelogic/go-sqlite/pkg/lang"
-
-	// Some sort of hack
-	_ "gopkg.in/yaml.v3"
 )
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -36,8 +33,8 @@ type PingResponse struct {
 }
 
 type PoolResponse struct {
-	Cur int32 `json:"cur"`
-	Max int32 `json:"max"`
+	Cur int `json:"cur"`
+	Max int `json:"max"`
 }
 
 type SchemaResponse struct {
@@ -146,7 +143,7 @@ func (p *plugin) AddHandlers(ctx context.Context, provider Provider) error {
 
 func (p *plugin) ServePing(w http.ResponseWriter, req *http.Request) {
 	// Get a connection
-	conn := p.Get(req.Context())
+	conn := p.Get()
 	if conn == nil {
 		router.ServeError(w, http.StatusBadGateway, "No connection")
 		return
@@ -161,7 +158,7 @@ func (p *plugin) ServePing(w http.ResponseWriter, req *http.Request) {
 	response.Version = sqlite3.Version()
 	response.Schemas = append(response.Schemas, conn.Schemas()...)
 	response.Modules = append(response.Modules, conn.Modules()...)
-	response.Pool = PoolResponse{Cur: p.Cur(), Max: p.Max()}
+	response.Pool = PoolResponse{Cur: p.pool.Cur(), Max: p.pool.Max()}
 
 	// Serve response
 	router.ServeJSON(w, response, http.StatusOK, 2)
@@ -172,7 +169,7 @@ func (p *plugin) ServeSchema(w http.ResponseWriter, req *http.Request) {
 	params := router.RequestParams(req)
 
 	// Get a connection
-	conn := p.Get(req.Context())
+	conn := p.Get()
 	if conn == nil {
 		router.ServeError(w, http.StatusBadGateway, "No connection")
 		return
@@ -240,7 +237,7 @@ func (p *plugin) ServeTable(w http.ResponseWriter, req *http.Request) {
 	}
 
 	// Get a connection
-	conn := p.Get(req.Context())
+	conn := p.Get()
 	if conn == nil {
 		router.ServeError(w, http.StatusBadGateway, "No connection")
 		return
@@ -293,7 +290,7 @@ func (p *plugin) ServeTokenizer(w http.ResponseWriter, req *http.Request) {
 	}
 
 	// Get a connection
-	conn := p.Get(req.Context())
+	conn := p.Get()
 	if conn == nil {
 		router.ServeError(w, http.StatusBadGateway, "No connection")
 		return
@@ -326,7 +323,7 @@ func (p *plugin) ServeQuery(w http.ResponseWriter, req *http.Request) {
 	}
 
 	// Get a connection
-	conn := p.Get(req.Context())
+	conn := p.Get()
 	if conn == nil {
 		router.ServeError(w, http.StatusBadGateway, "No connection")
 		return

plugin/sqlite3/main.go

@@ -3,20 +3,31 @@ package main
 import (
 	"context"
 	"fmt"
+	"time"
 
 	// Packages
 	sqlite3 "github.com/mutablelogic/go-sqlite/pkg/sqlite3"
 
 	// Namespace imports
 	. "github.com/mutablelogic/go-server"
 	. "github.com/mutablelogic/go-sqlite"
+
+	// Some sort of hack
+	_ "gopkg.in/yaml.v3"
 )
 
 ///////////////////////////////////////////////////////////////////////////////
 // TYPES
 
+type Config struct {
+	Databases map[string]string `yaml:"databases"`
+	Max       int               `yaml:"max"`
+	Create    bool              `yaml:"create"`
+	Trace     bool              `yaml:"trace"`
+}
+
 type plugin struct {
-	SQPool
+	pool SQPool
 	errs chan error
 }
 
@@ -28,21 +39,42 @@ func New(ctx context.Context, provider Provider) Plugin {
 	p := new(plugin)
 
 	// Get configuration
-	cfg := sqlite3.PoolConfig{}
+	var cfg Config
 	if err := provider.GetConfig(ctx, &cfg); err != nil {
 		provider.Print(ctx, err)
 		return nil
 	}
+	// Check for databases
+	if len(cfg.Databases) == 0 {
+		provider.Print(ctx, fmt.Errorf("no databases defined"))
+		return nil
+	}
+	// Create the pool
+	poolcfg := sqlite3.NewConfig().
+		WithMaxConnections(cfg.Max).
+		WithCreate(cfg.Create)
+	for name, path := range cfg.Databases {
+		poolcfg = poolcfg.WithSchema(name, path)
+	}
+	if cfg.Trace {
+		poolcfg = poolcfg.WithTrace(func(q string, d time.Duration) {
+			if d >= 0 {
+				provider.Printf(ctx, "TRACE %q => %v", q, d)
+			}
+		})
+	}
 
 	// Create a channel for errors
 	p.errs = make(chan error)
 
 	// Create a pool
-	if pool, err := sqlite3.OpenPool(cfg, p.errs); err != nil {
+	if pool, err := sqlite3.OpenPool(poolcfg, p.errs); err != nil {
 		provider.Print(ctx, err)
+		close(p.errs)
+		p.errs = nil
 		return nil
 	} else {
-		p.SQPool = pool
+		p.pool = pool
 	}
 
 	// Return success
@@ -53,7 +85,11 @@ func New(ctx context.Context, provider Provider) Plugin {
 // STRINGIFY
 
 func (p *plugin) String() string {
-	return fmt.Sprint(p.SQPool)
+	str := "<sqlite3"
+	if p.pool != nil {
+		str += fmt.Sprint(" ", p.pool)
+	}
+	return str + ">"
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -83,7 +119,7 @@ FOR_LOOP:
 	}
 
 	// Close the pool
-	if err := p.SQPool.Close(); err != nil {
+	if err := p.pool.Close(); err != nil {
 		provider.Print(ctx, err)
 	}
 
@@ -93,3 +129,14 @@ FOR_LOOP:
 	// Return success
 	return nil
 }
+
+///////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS - PUT AND GET
+
+func (p *plugin) Get() SQConnection {
+	return p.pool.Get()
+}
+
+func (p *plugin) Put(conn SQConnection) {
+	p.pool.Put(conn)
+}

sqlite.go

@@ -39,6 +39,9 @@ type SQPool interface {
 	// Cur returns the current number of used connections
 	Cur() int
 
+	// Max returns the maximum allowed number of used connections
+	Max() int
+
 	// SetMax allowed connections released from pool. Note this does not change
 	// the maximum instantly, it will settle to this value over time.
 	SetMax(int)