Refactor to use conndata as menustorageservice conn arg

cmd/africastalking/main.go

@@ -8,7 +8,6 @@ import (
 	"os"
 	"os/signal"
 	"path"
-	"path/filepath"
 	"strconv"
 	"syscall"
 
@@ -34,6 +33,7 @@ var (
 func init() {
 	initializers.LoadEnvVariables()
 }
+
 func main() {
 	config.LoadConfig()
 
@@ -47,19 +47,20 @@ func main() {
 	var err error
 
 	flag.StringVar(&resourceDir, "resourcedir", path.Join("services", "registration"), "resource dir")
-	flag.StringVar(&connStr, "c", ".", "connection string")
+	flag.StringVar(&connStr, "c", ".state", "connection string")
 	flag.BoolVar(&engineDebug, "d", false, "use engine debug output")
 	flag.UintVar(&size, "s", 160, "max size of output")
 	flag.StringVar(&host, "h", initializers.GetEnv("HOST", "127.0.0.1"), "http host")
 	flag.UintVar(&port, "p", initializers.GetEnvUint("PORT", 7123), "http port")
 	flag.Parse()
 
-	if connStr == "." {
-		connStr, err = filepath.Abs(".state/state.gdbm")
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "auto connstr generate error: %v", err)
-			os.Exit(1)
-		}
+	if connStr != "" {
+		connStr = config.DbConn
+	}
+	connData, err := storage.ToConnData(config.DbConn)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "connstr err: %v", err)
+		os.Exit(1)
 	}
 
 	logg.Infof("start command", "build", build, "dbdir", connStr, "resourcedir", resourceDir, "outputsize", size)
@@ -80,7 +81,7 @@ func main() {
 	}
 
 	menuStorageService := storage.NewMenuStorageService(resourceDir)
-	err = menuStorageService.SetConn(connStr)
+	menuStorageService = menuStorageService.WithConn(connData)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, err.Error())
 		os.Exit(1)

cmd/async/main.go

@@ -7,7 +7,6 @@ import (
 	"os"
 	"os/signal"
 	"path"
-	"path/filepath"
 	"syscall"
 
 	"git.defalsify.org/vise.git/engine"
@@ -47,8 +46,8 @@ func (p *asyncRequestParser) GetInput(r any) ([]byte, error) {
 func main() {
 	config.LoadConfig()
 
-	var sessionId string
 	var connStr string
+	var sessionId string
 	var resourceDir string
 	var size uint
 	var database string
@@ -59,19 +58,20 @@ func main() {
 
 	flag.StringVar(&sessionId, "session-id", "075xx2123", "session id")
 	flag.StringVar(&resourceDir, "resourcedir", path.Join("services", "registration"), "resource dir")
-	flag.StringVar(&connStr, "c", ".", "connection string")
+	flag.StringVar(&connStr, "c", "", "connection string")
 	flag.BoolVar(&engineDebug, "d", false, "use engine debug output")
 	flag.UintVar(&size, "s", 160, "max size of output")
 	flag.StringVar(&host, "h", initializers.GetEnv("HOST", "127.0.0.1"), "http host")
 	flag.UintVar(&port, "p", initializers.GetEnvUint("PORT", 7123), "http port")
 	flag.Parse()
 
-	if connStr == "." {
-		connStr, err = filepath.Abs(".state/state.gdbm")
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "auto connstr generate error: %v", err)
-			os.Exit(1)
-		}
+	if connStr != "" {
+		connStr = config.DbConn
+	}
+	connData, err := storage.ToConnData(config.DbConn)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "connstr err: %v", err)
+		os.Exit(1)
 	}
 
 	logg.Infof("start command", "connstr", connStr, "resourcedir", resourceDir, "outputsize", size, "sessionId", sessionId)
@@ -92,7 +92,7 @@ func main() {
 	}
 
 	menuStorageService := storage.NewMenuStorageService(resourceDir)
-	err = menuStorageService.SetConn(connStr)
+	menuStorageService = menuStorageService.WithConn(connData)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, err.Error())
 		os.Exit(1)

cmd/http/main.go

@@ -8,7 +8,6 @@ import (
 	"os"
 	"os/signal"
 	"path"
-	"path/filepath"
 	"strconv"
 	"syscall"
 
@@ -47,19 +46,20 @@ func main() {
 	var err error
 
 	flag.StringVar(&resourceDir, "resourcedir", path.Join("services", "registration"), "resource dir")
-	flag.StringVar(&connStr, "c", ".", "connection string")
+	flag.StringVar(&connStr, "c", "", "connection string")
 	flag.BoolVar(&engineDebug, "d", false, "use engine debug output")
 	flag.UintVar(&size, "s", 160, "max size of output")
 	flag.StringVar(&host, "h", initializers.GetEnv("HOST", "127.0.0.1"), "http host")
 	flag.UintVar(&port, "p", initializers.GetEnvUint("PORT", 7123), "http port")
 	flag.Parse()
 
-	if connStr == "." {
-		connStr, err = filepath.Abs(".state/state.gdbm")
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "auto connstr generate error: %v", err)
-			os.Exit(1)
-		}
+	if connStr != "" {
+		connStr = config.DbConn
+	}
+	connData, err := storage.ToConnData(config.DbConn)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "connstr err: %v", err)
+		os.Exit(1)
 	}
 
 	logg.Infof("start command", "connstr", connStr, "resourcedir", resourceDir, "outputsize", size)
@@ -80,12 +80,8 @@ func main() {
 	}
 
 	menuStorageService := storage.NewMenuStorageService(resourceDir)
-	err = menuStorageService.SetConn(connStr)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
-		os.Exit(1)
-	}
-
+	menuStorageService = menuStorageService.WithConn(connData)
+	
 	rs, err := menuStorageService.GetResource(ctx)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, err.Error())

cmd/main.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"os"
 	"path"
-	"path/filepath"
 
 	"git.defalsify.org/vise.git/engine"
 	"git.defalsify.org/vise.git/logging"
@@ -39,17 +38,18 @@ func main() {
 	var err error
 
 	flag.StringVar(&sessionId, "session-id", "075xx2123", "session id")
-	flag.StringVar(&connStr, "c", ".", "connection string")
+	flag.StringVar(&connStr, "c", "", "connection string")
 	flag.BoolVar(&engineDebug, "d", false, "use engine debug output")
 	flag.UintVar(&size, "s", 160, "max size of output")
 	flag.Parse()
 
-	if connStr == "." {
-		connStr, err = filepath.Abs(".state/state.gdbm")
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "auto connstr generate error: %v", err)
-			os.Exit(1)
-		}
+	if connStr != "" {
+		connStr = config.DbConn
+	}
+	connData, err := storage.ToConnData(config.DbConn)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "connstr err: %v", err)
+		os.Exit(1)
 	}
 
 	logg.Infof("start command", "connstr", connStr, "outputsize", size)
@@ -69,12 +69,7 @@ func main() {
 
 	resourceDir := scriptDir
 	menuStorageService := storage.NewMenuStorageService(resourceDir)
-
-	err = menuStorageService.SetConn(connStr)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
-		os.Exit(1)
-	}
+	menuStorageService = menuStorageService.WithConn(connData)
 
 	rs, err := menuStorageService.GetResource(ctx)
 	if err != nil {

common/storage.go

@@ -23,19 +23,19 @@ type StorageServices interface {
 	GetPersister(ctx context.Context) (*persist.Persister, error)
 	GetUserdataDb(ctx context.Context) (db.Db, error)
 	GetResource(ctx context.Context) (resource.Resource, error)
-	SetConn(connStr string) error
+	SetConn(conn storage.ConnData)
 }
 
 type StorageService struct {
 	svc *storage.MenuStorageService
 }
 
-func NewStorageService(connStr string) (*StorageService, error) {
+func NewStorageService(conn storage.ConnData) (*StorageService, error) {
 	svc := &StorageService{
 		svc: storage.NewMenuStorageService(""),
 	}
-	err := svc.SetConn(connStr)
-	return svc, err
+	svc.SetConn(conn)
+	return svc, nil
 }
 
 func(ss *StorageService) GetPersister(ctx context.Context) (*persist.Persister, error) {
@@ -50,6 +50,6 @@ func(ss *StorageService) GetResource(ctx context.Context) (resource.Resource, er
 	return nil, errors.New("not implemented")
 }
 
-func(ss *StorageService) SetConn(connStr string) error {
-	return ss.svc.SetConn(connStr)
+func(ss *StorageService) SetConn(conn storage.ConnData) {
+	ss.svc = ss.svc.WithConn(conn)
 }

config/config.go

@@ -34,6 +34,7 @@ var (
 	VoucherTransfersURL string
 	VoucherDataURL      string
 	CheckAliasURL       string
+	DbConn		string
 )
 
 func setBase() error {
@@ -43,14 +44,20 @@ func setBase() error {
 	dataURLBase = initializers.GetEnv("DATA_URL_BASE", "http://localhost:5006")
 	BearerToken = initializers.GetEnv("BEARER_TOKEN", "")
 
-	_, err = url.JoinPath(custodialURLBase, "/foo")
+	_, err = url.Parse(custodialURLBase)
 	if err != nil {
 		return err
 	}
-	_, err = url.JoinPath(dataURLBase, "/bar")
+	_, err = url.Parse(dataURLBase)
 	if err != nil {
 		return err
 	}
+
+	return nil
+}
+
+func setConn() error {
+	DbConn = initializers.GetEnv("DB_CONN", "")
 	return nil
 }
 
@@ -60,6 +67,10 @@ func LoadConfig() error {
 	if err != nil {
 		return err
 	}
+	err = setConn()
+	if err != nil {
+		return err
+	}
 	CreateAccountURL, _ = url.JoinPath(custodialURLBase, createAccountPath)
 	TrackStatusURL, _ = url.JoinPath(custodialURLBase, trackStatusPath)
 	BalanceURL, _ = url.JoinPath(custodialURLBase, balancePathPrefix)

devtools/gen/main.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"os"
 	"path"
-	"path/filepath"
 
 	"git.defalsify.org/vise.git/logging"
 	"git.grassecon.net/urdt/ussd/config"
@@ -36,19 +35,20 @@ func main() {
 	var err error
 
 	flag.StringVar(&sessionId, "session-id", "075xx2123", "session id")
-	flag.StringVar(&connStr, "c", ".", "connection string")
+	flag.StringVar(&connStr, "c", "", "connection string")
 	flag.BoolVar(&engineDebug, "d", false, "use engine debug output")
 	flag.Parse()
 
-	if connStr == "." {
-		connStr, err = filepath.Abs(".state/state.gdbm")
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "auto connstr generate error: %v", err)
-			os.Exit(1)
-		}
+	if connStr != "" {
+		connStr = config.DbConn
+	}
+	connData, err := storage.ToConnData(config.DbConn)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "connstr err: %v", err)
+		os.Exit(1)
 	}
 
-	logg.Infof("start command", "connstr", connStr)
+	logg.Infof("start command", "conn", connData)
 
 	ctx := context.Background()
 	ctx = context.WithValue(ctx, "SessionId", sessionId)
@@ -56,12 +56,8 @@ func main() {
 
 	resourceDir := scriptDir
 	menuStorageService := storage.NewMenuStorageService(resourceDir)
-	err = menuStorageService.SetConn(connStr)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "connection string error: %v", err)
-		os.Exit(1)
-	}
-
+	menuStorageService = menuStorageService.WithConn(connData)
+	
 	store, err := menuStorageService.GetUserdataDb(ctx)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, err.Error())

devtools/store/main.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"os"
 	"path"
-	"path/filepath"
 
 	"git.grassecon.net/urdt/ussd/config"
 	"git.grassecon.net/urdt/ussd/initializers"
@@ -40,12 +39,13 @@ func main() {
 	flag.BoolVar(&engineDebug, "d", false, "use engine debug output")
 	flag.Parse()
 
-	if connStr == "." {
-		connStr, err = filepath.Abs(".state/state.gdbm")
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "auto connstr generate error: %v", err)
-			os.Exit(1)
-		}
+	if connStr != "" {
+		connStr = config.DbConn
+	}
+	connData, err := storage.ToConnData(config.DbConn)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "connstr err: %v", err)
+		os.Exit(1)
 	}
 
 	ctx := context.Background()
@@ -54,7 +54,7 @@ func main() {
 
 	resourceDir := scriptDir
 	menuStorageService := storage.NewMenuStorageService(resourceDir)
-	err = menuStorageService.SetConn(connStr)
+	menuStorageService = menuStorageService.WithConn(connData)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "connection string error: %v", err)
 		os.Exit(1)

internal/storage/parse.go

@@ -12,16 +12,16 @@ const (
 	DBTYPE_POSTGRES
 )
 
-type connData struct {
+type ConnData struct {
 	typ int
 	str string
 }
 
-func (cd *connData) DbType() int {
+func (cd *ConnData) DbType() int {
 	return cd.typ
 }
 
-func (cd *connData) String() string {
+func (cd *ConnData) String() string {
 	return cd.str
 }
 
@@ -40,15 +40,12 @@ func probeGdbm(s string) (string, bool) {
 	if !path.IsAbs(s) {
 		return "", false
 	}
-	if path.Ext(s) != ".gdbm" {
-		return "", false
-	}
 	s = path.Clean(s)
 	return s, true
 }
 
-func toConnData(connStr string) (connData, error) {
-	var o connData
+func ToConnData(connStr string) (ConnData, error) {
+	var o ConnData
 
 	if connStr == "" {
 		return o, nil

internal/storage/parse_test.go

@@ -5,32 +5,23 @@ import (
 )
 
 func TestParseConnStr(t *testing.T) {
-	svc := NewMenuStorageService("")
-	err := svc.SetConn("postgres://foo:bar@localhost:5432/baz")
+	_, err := ToConnData("postgres://foo:bar@localhost:5432/baz")
 	if err != nil {
 		t.Fatal(err)	
 	}
-	err = svc.SetConn("/foo/bar/baz.gdbm")
+	_, err = ToConnData("/foo/bar")
 	if err != nil {
 		t.Fatal(err)	
 	}
-	err = svc.SetConn("foo/bar/baz.gdbm")
+	_, err = ToConnData("/foo/bar/")
+	if err != nil {
+		t.Fatal(err)	
+	}
+	_, err = ToConnData("foo/bar")
 	if err == nil {
 		t.Fatalf("expected error")
 	}
-	err = svc.SetConn("http://foo/bar")
-	if err == nil {
-		t.Fatalf("expected error")
-	}
-	err = svc.SetConn("foo/bar/baz.txt")
-	if err == nil {
-		t.Fatalf("expected error")
-	}
-	err = svc.SetConn("/foo/bar")
-	if err == nil {
-		t.Fatalf("expected error")
-	}
-	err = svc.SetConn("foo/bar")
+	_, err = ToConnData("http://foo/bar")
 	if err == nil {
 		t.Fatalf("expected error")
 	}

internal/storage/storageservice.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"path"
 
 	"git.defalsify.org/vise.git/db"
 	fsdb "git.defalsify.org/vise.git/db/fs"
@@ -11,7 +12,6 @@ import (
 	"git.defalsify.org/vise.git/logging"
 	"git.defalsify.org/vise.git/persist"
 	"git.defalsify.org/vise.git/resource"
-	"git.grassecon.net/urdt/ussd/initializers"
 	gdbmstorage "git.grassecon.net/urdt/ussd/internal/storage/db/gdbm"
 )
 
@@ -27,58 +27,34 @@ type StorageService interface {
 }
 
 type MenuStorageService struct {
-	//dbDir         string
-	conn connData
+	conn ConnData
 	resourceDir   string
 	resourceStore db.Db
 	stateStore    db.Db
 	userDataStore db.Db
 }
 
-func buildConnStr() string {
-	host := initializers.GetEnv("DB_HOST", "localhost")
-	user := initializers.GetEnv("DB_USER", "postgres")
-	password := initializers.GetEnv("DB_PASSWORD", "")
-	dbName := initializers.GetEnv("DB_NAME", "")
-	port := initializers.GetEnv("DB_PORT", "5432")
-
-	connString := fmt.Sprintf(
-		"postgres://%s:%s@%s:%s/%s",
-		user, password, host, port, dbName,
-	)
-	logg.Debugf("pg conn string", "conn", connString)
-
-	return connString
-}
-
 func NewMenuStorageService(resourceDir string) *MenuStorageService {
 	return &MenuStorageService{
 		resourceDir: resourceDir,
 	}
 }
 
-func (ms *MenuStorageService) SetConn(connStr string) error {
-	o, err := toConnData(connStr)
-	if err != nil {
-		return err
-	}
-	ms.conn = o
-	return nil
+func (ms *MenuStorageService) WithConn(conn ConnData) *MenuStorageService {
+	ms.conn = conn
+	return ms
 }
 
-func (ms *MenuStorageService) getOrCreateDb(ctx context.Context, existingDb db.Db, fileName string) (db.Db, error) {
+func (ms *MenuStorageService) getOrCreateDb(ctx context.Context, existingDb db.Db, section string) (db.Db, error) {
 	var newDb db.Db
 	var err error
-//	database, ok := ctx.Value("Database").(string)
-//	if !ok {
-//		return nil, fmt.Errorf("failed to select the database")
-//	}
 
 	if existingDb != nil {
 		return existingDb, nil
 	}
 
 
+	connStr := ms.conn.String()
 	dbTyp := ms.conn.DbType()
 	if dbTyp == DBTYPE_POSTGRES {
 		newDb = postgres.NewPgDb()
@@ -87,11 +63,13 @@ func (ms *MenuStorageService) getOrCreateDb(ctx context.Context, existingDb db.D
 		if err != nil {
 			return nil, err
 		}
+		connStr = path.Join(connStr, section)
 		newDb = gdbmstorage.NewThreadGdbmDb()
 	} else {
 		return nil, fmt.Errorf("unsupported connection string: %s", ms.conn.String())
 	}
-	err = newDb.Connect(ctx, ms.conn.String())
+	logg.DebugCtxf(ctx, "connecting to db", "conn", connStr)
+	err = newDb.Connect(ctx, connStr)
 	if err != nil {
 		return nil, err
 	}

internal/testutil/engine.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 	"path"
+	"path/filepath"
 	"time"
 
 	"git.defalsify.org/vise.git/engine"
@@ -27,7 +28,6 @@ var (
 func TestEngine(sessionId string) (engine.Engine, func(), chan bool) {
 	ctx := context.Background()
 	ctx = context.WithValue(ctx, "SessionId", sessionId)
-	ctx = context.WithValue(ctx, "Database", "gdbm")
 	pfp := path.Join(scriptDir, "pp.csv")
 
 	var eventChannel = make(chan bool)
@@ -39,39 +39,46 @@ func TestEngine(sessionId string) (engine.Engine, func(), chan bool) {
 		FlagCount:  uint32(128),
 	}
 
-	dbDir := ".test_state"
+	connStr, err := filepath.Abs(".test_state/state.gdbm")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "connstr err: %v", err)
+		os.Exit(1)
+	}
+	conn, err := storage.ToConnData(connStr)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "connstr parse err: %v", err)
+		os.Exit(1)
+	}
 	resourceDir := scriptDir
-	//menuStorageService := storage.NewMenuStorageService(dbDir, resourceDir)
 	menuStorageService := storage.NewMenuStorageService(resourceDir)
 
-	//err := menuStorageService.EnsureDbDir()
-	err := menuStorageService.SetConn(dbDir)
+	menuStorageService.WithConn(conn)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
+		fmt.Fprintf(os.Stderr, "conn error: %v", err)
 		os.Exit(1)
 	}
 
 	rs, err := menuStorageService.GetResource(ctx)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
+		fmt.Fprintf(os.Stderr, "resource error: %v", err)
 		os.Exit(1)
 	}
 
 	pe, err := menuStorageService.GetPersister(ctx)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
+		fmt.Fprintf(os.Stderr, "persister error: %v", err)
 		os.Exit(1)
 	}
 
 	userDataStore, err := menuStorageService.GetUserdataDb(ctx)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
+		fmt.Fprintf(os.Stderr, "userdb error: %v", err)
 		os.Exit(1)
 	}
 
 	dbResource, ok := rs.(*resource.DbResource)
 	if !ok {
-		fmt.Fprintf(os.Stderr, err.Error())
+		fmt.Fprintf(os.Stderr, "dbresource cast error")
 		os.Exit(1)
 	}
 

internal/testutil/engine_test.go

@@ -0,0 +1,15 @@
+package testutil
+
+import (
+	"testing"
+)
+
+func TestCreateEngine(t *testing.T) {
+	o, clean, eventC := TestEngine("foo")
+	defer clean()
+	defer func() {
+		<-eventC
+		close(eventC)
+	}()
+	_ = o
+}

menutraversal_test/menu_traversal_test.go

@@ -7,6 +7,7 @@ import (
 	"log"
 	"math/rand"
 	"os"
+	"path/filepath"
 	"regexp"
 	"testing"
 
@@ -17,7 +18,6 @@ import (
 
 var (
 	testData  = driver.ReadData()
-	testStore = ".test_state"
 	sessionID string
 	src       = rand.NewSource(42)
 	g         = rand.New(src)
@@ -25,6 +25,11 @@ var (
 
 var groupTestFile = flag.String("test-file", "group_test.json", "The test file to use for running the group tests")
 
+func testStore() string {
+	v, _ :=  filepath.Abs(".test_state/state.gdbm")
+	return v
+}
+
 func GenerateSessionId() string {
 	uu := uuid.NewGenWithOptions(uuid.WithRandomReader(g))
 	v, err := uu.NewV4()
@@ -81,8 +86,8 @@ func extractSendAmount(response []byte) string {
 func TestMain(m *testing.M) {
 	sessionID = GenerateSessionId()
 	defer func() {
-		if err := os.RemoveAll(testStore); err != nil {
-			log.Fatalf("Failed to delete state store %s: %v", testStore, err)
+		if err := os.RemoveAll(testStore()); err != nil {
+			log.Fatalf("Failed to delete state store %s: %v", testStore(), err)
 		}
 	}()
 	m.Run()