add sqlite pragma support

cmd/temporalite/main.go

@@ -9,6 +9,7 @@ import (
 	goLog "log"
 	"net"
 	"os"
+	"strings"
 
 	"github.com/urfave/cli/v2"
 	"go.temporal.io/server/common/headers"
@@ -35,6 +36,7 @@ const (
 	ipFlag        = "ip"
 	logFormatFlag = "log-format"
 	namespaceFlag = "namespace"
+	pragmaFLag    = "sqlite-pragma"
 )
 
 func init() {
@@ -52,7 +54,6 @@ func buildCLI() *cli.App {
 	app.Name = "temporal"
 	app.Usage = "Temporal server"
 	app.Version = headers.ServerVersion
-
 	app.Commands = []*cli.Command{
 		{
 			Name:      "start",
@@ -64,6 +65,13 @@ func buildCLI() *cli.App {
 					Value: defaultCfg.Ephemeral,
 					Usage: "enable the in-memory storage driver **data will be lost on restart**",
 				},
+				&cli.StringSliceFlag{
+					Name:    pragmaFLag,
+					Aliases: []string{"sp"},
+					Usage:   fmt.Sprintf("specify sqlite pragma statements in pragma=value format. allowed pragmas: %v", liteconfig.GetAllowedPragmas()),
+					EnvVars: nil,
+					Value:   nil,
+				},
 				&cli.StringFlag{
 					Name:    dbPathFlag,
 					Aliases: []string{"f"},
@@ -103,6 +111,7 @@ func buildCLI() *cli.App {
 				if c.IsSet(ephemeralFlag) && c.IsSet(dbPathFlag) {
 					return cli.Exit(fmt.Sprintf("ERROR: only one of %q or %q flags may be passed at a time", ephemeralFlag, dbPathFlag), 1)
 				}
+
 				switch c.String(logFormatFlag) {
 				case "json", "pretty":
 				default:
@@ -117,10 +126,16 @@ func buildCLI() *cli.App {
 				return nil
 			},
 			Action: func(c *cli.Context) error {
+				pragmas, err := getPragmaMap(c.StringSlice(pragmaFLag))
+				if err != nil {
+					return err
+				}
+
 				opts := []temporalite.ServerOption{
 					temporalite.WithFrontendPort(c.Int(portFlag)),
 					temporalite.WithDatabaseFilePath(c.String(dbPathFlag)),
 					temporalite.WithNamespaces(c.StringSlice(namespaceFlag)...),
+					temporalite.WithSQLitePragmas(pragmas),
 					temporalite.WithUpstreamOptions(
 						temporal.InterruptOn(temporal.InterruptCh()),
 					),
@@ -161,3 +176,15 @@ func buildCLI() *cli.App {
 
 	return app
 }
+
+func getPragmaMap(input []string) (map[string]string, error) {
+	result := make(map[string]string)
+	for _, pragma := range input {
+		vals := strings.Split(pragma, "=")
+		if len(vals) != 2 {
+			return nil, fmt.Errorf("ERROR: pragma statements must be in KEY=VALUE format, got %q", pragma)
+		}
+		result[vals[0]] = vals[1]
+	}
+	return result, nil
+}

internal/liteconfig/config.go

@@ -9,6 +9,7 @@ import (
 	"math/rand"
 	"os"
 	"path/filepath"
+	"sort"
 	"time"
 
 	"go.temporal.io/server/common/cluster"
@@ -31,12 +32,27 @@ type Config struct {
 	FrontendPort     int
 	DynamicPorts     bool
 	Namespaces       []string
+	SQLitePragmas    map[string]string
 	Logger           log.Logger
 	UpstreamOptions  []temporal.ServerOption
 	portProvider     *portProvider
 	FrontendIP       string
 }
 
+var SupportedPragmas = map[string]struct{}{
+	"journal_mode": {},
+	"synchronous":  {},
+}
+
+func GetAllowedPragmas() []string {
+	var allowedPragmaList []string
+	for k := range SupportedPragmas {
+		allowedPragmaList = append(allowedPragmaList, k)
+	}
+	sort.Strings(allowedPragmaList)
+	return allowedPragmaList
+}
+
 func NewDefaultConfig() (*Config, error) {
 	userConfigDir, err := os.UserConfigDir()
 	if err != nil {
@@ -49,6 +65,7 @@ func NewDefaultConfig() (*Config, error) {
 		FrontendPort:     0,
 		DynamicPorts:     false,
 		Namespaces:       nil,
+		SQLitePragmas:    nil,
 		Logger: log.NewZapLogger(log.BuildZapLogger(log.Config{
 			Stdout:     true,
 			Level:      "debug",
@@ -79,6 +96,10 @@ func Convert(cfg *Config) *config.Config {
 		sqliteConfig.ConnectAttributes["mode"] = "rwc"
 	}
 
+	for k, v := range cfg.SQLitePragmas {
+		sqliteConfig.ConnectAttributes["_"+k] = v
+	}
+
 	var metricsPort, pprofPort int
 	if cfg.DynamicPorts {
 		if cfg.FrontendPort == 0 {

options.go

@@ -65,6 +65,18 @@ func WithNamespaces(namespaces ...string) ServerOption {
 	})
 }
 
+// WithSQLitePragmas applies pragma statements to SQLite on Temporal start.
+func WithSQLitePragmas(pragmas map[string]string) ServerOption {
+	return newApplyFuncContainer(func(cfg *liteconfig.Config) {
+		if cfg.SQLitePragmas == nil {
+			cfg.SQLitePragmas = make(map[string]string)
+		}
+		for k, v := range pragmas {
+			cfg.SQLitePragmas[k] = v
+		}
+	})
+}
+
 // WithUpstreamOptions registers Temporal server options.
 func WithUpstreamOptions(options ...temporal.ServerOption) ServerOption {
 	return newApplyFuncContainer(func(cfg *liteconfig.Config) {

server.go

@@ -8,6 +8,7 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"strings"
 	"time"
 
 	"github.com/DataDog/temporalite/internal/liteconfig"
@@ -39,6 +40,13 @@ func NewServer(opts ...ServerOption) (*Server, error) {
 	for _, opt := range opts {
 		opt.apply(c)
 	}
+
+	for pragma := range c.SQLitePragmas {
+		if _, ok := liteconfig.SupportedPragmas[strings.ToLower(pragma)]; !ok {
+			return nil, fmt.Errorf("ERROR: unsupported pragma %q, %v allowed", pragma, liteconfig.GetAllowedPragmas())
+		}
+	}
+
 	cfg := liteconfig.Convert(c)
 	sqlConfig := cfg.Persistence.DataStores[liteconfig.PersistenceStoreName].SQL