add env and config file support

Author: walterwanderley

cmd/sqlite-http-proxy/main.go

@@ -4,51 +4,53 @@ import (
 	"crypto/tls"
 	"crypto/x509"
 	"database/sql"
-	"flag"
 	"fmt"
 	"log"
 	"net"
 	"net/http"
 	"os"
+	"path/filepath"
 	"strings"
 
 	"github.com/elazarl/goproxy"
 	_ "github.com/mattn/go-sqlite3"
+	"github.com/peterbourgon/ff/v4"
+	"github.com/peterbourgon/ff/v4/ffhelp"
 
 	"github.com/walterwanderley/sqlite-http-cache/db"
 )
 
-var (
-	port       uint
-	dbParams   string
-	allowHTTP2 bool
-	verbose    bool
-
-	ttl uint
-
-	caCert    string
-	caCertKey string
+func main() {
+	fs := ff.NewFlagSet("sqlite-http-proxy")
+	port := fs.Uint('p', "port", 8080, "Server port")
+	dbParams := fs.StringLong("db-params", "_journal=WAL&_sync=NORMAL&_timeout=5000&_txlock=immediate", "Database connection params")
+	verbose := fs.Bool('v', "verbose", "Enable verbose mode")
+	allowHTTP2 := fs.BoolLong("h2", "Allow HTTP2")
+	ttl := fs.UintLong("ttl", 0, "Time to Live in seconds (0 is infinite time)")
+	responseTables := fs.StringListLong("response-table", "List of database tables used to store response data")
+	forceCreateTables := fs.BoolLong("force-create-tables", "Force create response tables if not exists")
+	caCert := fs.StringLong("ca-cert", "", "Path to CA Certificate file (required to HTTPS proxy)")
+	caCertKey := fs.StringLong("ca-cert-key", "", "Path to CA Certificate Key file (required to HTTPS proxy)")
+	readOnly := fs.BoolLong("ro", "Read Only mode. Do not store new HTTP responses")
+	_ = fs.String('c', "config", "", "config file (optional)")
+
+	if err := ff.Parse(fs, os.Args[1:],
+		ff.WithEnvVarPrefix("SQLITE_HTTP_PROXY"),
+		ff.WithConfigFileFlag("config"),
+		ff.WithConfigFileParser(ff.PlainParser),
+	); err != nil {
+		fmt.Printf("%s\n", ffhelp.Flags(fs))
+		fmt.Printf("err=%v\n", err)
+		return
+	}
 
-	responseTables    string
-	forceCreateTables bool
-	readOnly          bool
-)
+	if len(fs.GetArgs()) == 0 {
+		log.Fatalf("Usage: %s <FLAGS> [DatabasePath1] [DatabasePathN\n\nExample:\n\t%s example.db example2.db example3.db\n", os.Args[0], os.Args[0])
+	}
 
-func main() {
-	flag.UintVar(&port, "p", 8080, "Server port")
-	flag.StringVar(&dbParams, "db-params", "_journal=WAL&_sync=NORMAL&_timeout=5000&_txlock=immediate", "Database connection params")
-	flag.BoolVar(&verbose, "v", false, "Enable verbose mode")
-	flag.BoolVar(&allowHTTP2, "h2", false, "Allow HTTP2")
-	flag.UintVar(&ttl, "ttl", 0, "Time to Live in seconds (0 is infinite time)")
-	flag.StringVar(&responseTables, "response-tables", "", "Comma separated list of database tables used to store response data")
-	flag.BoolVar(&forceCreateTables, "force-create-tables", false, "Force create response tables if not exists")
-	flag.StringVar(&caCert, "ca-cert", "", "Path to CA Certificate file (required to HTTPS proxy)")
-	flag.StringVar(&caCertKey, "ca-cert-key", "", "Path to CA Certificate Key file (required to HTTPS proxy)")
-	flag.BoolVar(&readOnly, "ro", false, "Read Only mode. Do not store new HTTP responses")
-	flag.Parse()
-
-	if len(flag.Args()) == 0 {
-		log.Fatalf("Usage: %s <flags> [DatabasePath1] [DatabasePathN\n\nExample:\n\t%s example.db example2.db example3.db\n", os.Args[0], os.Args[0])
+	if *verbose {
+		fmt.Printf("Using options: port=%d db-params=%s, h2=%v, ttl=%d, response-tables=%v, force-create-tables=%v, ca-cert=%s, ca-cert-key=%s, read-only=%v\n",
+			*port, *dbParams, *allowHTTP2, *ttl, *responseTables, *forceCreateTables, *caCert, *caCertKey, *readOnly)
 	}
 
 	dbs := make([]*sql.DB, 0)
@@ -57,14 +59,31 @@ func main() {
 		tableList  []string
 		err        error
 	)
-	for _, file := range flag.Args() {
-		var dsn string
-		if file == ":memory:" {
-			dsn = file + "?cache=shared"
-		} else {
-			dsn = fmt.Sprintf("file:%s?%s", file, dbParams)
+
+	dsnList := make([]string, 0)
+	for _, pattern := range fs.GetArgs() {
+		if pattern == ":memory:" {
+			dsn := pattern + "?cache=shared"
+			dsnList = append(dsnList, dsn)
+			continue
 		}
+		matches, err := filepath.Glob(pattern)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		for _, file := range matches {
+			dsn := fmt.Sprintf("file:%s?%s", file, *dbParams)
+			dsnList = append(dsnList, dsn)
+		}
+		if len(matches) == 0 && !strings.Contains(pattern, "*") {
+			dsn := fmt.Sprintf("file:%s?%s", pattern, *dbParams)
+			dsnList = append(dsnList, dsn)
+		}
+
+	}
 
+	for _, dsn := range dsnList {
 		sqlDB, err := sql.Open("sqlite3", dsn)
 		if err != nil {
 			log.Fatalf("open db error: %v", err)
@@ -73,17 +92,17 @@ func main() {
 
 		dbs = append(dbs, sqlDB)
 
-		if responseTables == "" {
+		if responseTables == nil || len(*responseTables) == 0 {
 			tableList, err = db.ResponseTables(sqlDB)
 			if err != nil {
 				log.Fatalf("discovery response tables: %v", err)
 			}
 		} else {
-			tableList = strings.Split(responseTables, ",")
-			if forceCreateTables {
+			tableList = *responseTables
+			if *forceCreateTables {
 				err := db.CreateResponseTables(sqlDB, tableList...)
 				if err != nil {
-					log.Fatalf("force create tables: %v", err)
+					log.Fatalf("force create tables on DB %q: %v", dsn, err)
 				}
 			}
 		}
@@ -102,12 +121,12 @@ func main() {
 	defer repository.Close()
 
 	proxy := goproxy.NewProxyHttpServer()
-	proxy.Verbose = verbose
-	proxy.AllowHTTP2 = allowHTTP2
+	proxy.Verbose = *verbose
+	proxy.AllowHTTP2 = *allowHTTP2
 
-	if caCert != "" && caCertKey != "" {
+	if *caCert != "" && *caCertKey != "" {
 		proxy.Logger.Printf("INFO: Starting HTTP/HTTPS Proxy...")
-		cert, err := parseCA([]byte(caCert), []byte(caCertKey))
+		cert, err := parseCA([]byte(*caCert), []byte(*caCertKey))
 		if err != nil {
 			log.Fatal(err)
 		}
@@ -122,20 +141,24 @@ func main() {
 	}
 
 	proxy.OnRequest().Do(&requestHandler{
-		querier: repository,
+		querier:  repository,
+		verbose:  *verbose,
+		ttl:      *ttl,
+		readOnly: *readOnly,
 	})
-	if !readOnly {
+	if !*readOnly {
 		proxy.OnResponse().Do(&responseHandler{
-			writer: repository,
+			writer:  repository,
+			verbose: *verbose,
 		})
 	}
 
-	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
+	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))
 	if err != nil {
 		log.Fatalf("cannot open port %d: %v", port, err)
 	}
 
-	proxy.Logger.Printf("SQLite-HTTP-Proxy listening port=%d", port)
+	proxy.Logger.Printf("SQLite-HTTP-Proxy listening port=%d", *port)
 	log.Fatal(http.Serve(lis, proxy))
 }
 

cmd/sqlite-http-proxy/request.go

@@ -19,7 +19,10 @@ type requestQuerier interface {
 }
 
 type requestHandler struct {
-	querier requestQuerier
+	verbose  bool
+	ttl      uint
+	readOnly bool
+	querier  requestQuerier
 }
 
 func (h *requestHandler) Handle(r *http.Request, ctx *goproxy.ProxyCtx) (*http.Request, *http.Response) {
@@ -38,12 +41,12 @@ func (h *requestHandler) Handle(r *http.Request, ctx *goproxy.ProxyCtx) (*http.R
 		return r, nil
 	}
 
-	if !readOnly && ttl > 0 && uint(time.Since(resp.Timestamp).Seconds()) > ttl {
+	if !h.readOnly && h.ttl > 0 && uint(time.Since(resp.Timestamp).Seconds()) > h.ttl {
 		// data is too old, tell the responseHandler to save the new data
 		ctx.UserData = fmt.Sprintf("%s:%d", resp.TableName, resp.DatabaseID)
 		return r, nil
 	}
-	if verbose {
+	if h.verbose {
 		slog.Info("serving from database", "url", url, "status", resp.Status, "timestamp", resp.Timestamp.Format(time.RFC3339))
 	}
 

cmd/sqlite-http-proxy/response.go

@@ -16,12 +16,13 @@ type responseWriter interface {
 }
 
 type responseHandler struct {
-	writer responseWriter
+	writer  responseWriter
+	verbose bool
 }
 
 func (h *responseHandler) Handle(resp *http.Response, ctx *goproxy.ProxyCtx) *http.Response {
 	if ctx.UserData != nil {
-		if verbose {
+		if h.verbose {
 			slog.Info("recording response", "url", ctx.Req.URL.String(), "status", resp.StatusCode)
 		}
 		responseDB, err := db.HttpToResponse(resp)