5 files changed, 66 insertions(+), 59 deletions(-)

M config/config.go
M database/postgres.go
M graph/resolver.go
M graph/schema.resolvers.go
M server.go

@@ 1,62 1,63 @@
 package config
 
 import (
-	"log"
+	"fmt"
 	"strings"
 
 	"git.sr.ht/~emersion/go-scfg"
 )
 
-var Port string
-
-// ConnectionString is used to connect to the database
-var ConnectionString string
-
-// Admins array of steamID64 of users that should become admins
-var Admins []string
-
-var Maps []string
+type Config struct {
+	Port               string
+	DBConnectionString string
+	Admins             []string
+	Maps               []string
+}
 
-func ReadConfig(path string) {
+func ReadConfig(path string) (*Config, error) {
 	cfg, err := scfg.Load(path)
 	if err != nil {
-		log.Fatalf("could not read config file %q", path)
+		return nil, err
 	}
 
-	for _, d := range cfg {
-		switch d.Name {
-		case "port":
-			if err := d.ParseParams(&Port); err != nil {
-				log.Fatalf("could not parse port: %v", err)
-			}
-
-		case "connection-string":
-			if err := d.ParseParams(&ConnectionString); err != nil {
-				log.Fatalf("could not parse connection-string: %v", err)
-			}
-
-		case "admins":
-			var admins string
-			if err := d.ParseParams(&admins); err != nil {
-				log.Fatalf("could not parse admins: %v", err)
-			}
-
-			Admins = strings.Split(admins, ",")
+	config := new(Config)
+	// Set default values
+	config.Port = "8080"
 
-		case "maps":
-			var maps string
-			if err := d.ParseParams(&maps); err != nil {
-				log.Fatalf("could not parse maps: %v", err)
-			}
+	d := cfg.Get("port")
+	if d != nil {
+		if err := d.ParseParams(&config.Port); err != nil {
+			return nil, err
+		}
+	}
 
-			Maps = strings.Split(maps, ",")
+	d = cfg.Get("connection-string")
+	if d == nil {
+		return nil, fmt.Errorf("%q missing from config", "connection-string")
+	}
+	if err := d.ParseParams(&config.DBConnectionString); err != nil {
+		return nil, err
+	}
 
-		default:
-			log.Fatalf("illegal config value %q", d.Name)
+	d = cfg.Get("admins")
+	if d != nil {
+		var admins string
+		if err := d.ParseParams(&admins); err != nil {
+			return nil, err
 		}
+
+		config.Admins = strings.Split(admins, ",")
 	}
 
-	if ConnectionString == "" {
-		log.Fatalf("could not parse connection-string")
+	d = cfg.Get("maps")
+	var maps string
+	if d == nil {
+		return nil, fmt.Errorf("%q missing from config", "maps")
+	}
+	if err := d.ParseParams(&maps); err != nil {
+		return nil, err
 	}
+	config.Maps = strings.Split(maps, ",")
+
+	return config, nil
 }

@@ 4,7 4,6 @@ import (
 	"database/sql"
 	"errors"
 
-	"git.xenrox.net/~xenrox/10man-api/config"
 	// Import driver
 	_ "github.com/lib/pq"
 )


@@ 15,8 14,8 @@ type DB struct {
 }
 
 // Open opens a postgres database connection
-func Open() (*DB, error) {
-	database, err := sql.Open("postgres", config.ConnectionString)
+func Open(connectionString string) (*DB, error) {
+	database, err := sql.Open("postgres", connectionString)
 	if err != nil {
 		return nil, err
 	}

@@ 1,11 1,15 @@
 package graph
 
-import "git.xenrox.net/~xenrox/10man-api/database"
+import (
+	"git.xenrox.net/~xenrox/10man-api/config"
+	"git.xenrox.net/~xenrox/10man-api/database"
+)
 
 // This file will not be regenerated automatically.
 //
 // It serves as dependency injection for your app, add any dependencies you require here.
 
 type Resolver struct {
-	DB *database.DB
+	DB     *database.DB
+	Config config.Config
 }

@@ 14,7 14,6 @@ import (
 	"net/http"
 	"time"
 
-	"git.xenrox.net/~xenrox/10man-api/config"
 	"git.xenrox.net/~xenrox/10man-api/database"
 	"git.xenrox.net/~xenrox/10man-api/functions"
 	"git.xenrox.net/~xenrox/10man-api/graph/generated"


@@ 51,7 50,7 @@ func (r *mutationResolver) CreateUser(ctx context.Context, input model.NewUser) 
 
 	// get admin status
 	isAdmin := false
-	for _, adminID := range config.Admins {
+	for _, adminID := range r.Config.Admins {
 		if input.SteamID == adminID {
 			isAdmin = true
 			break


@@ 312,7 311,7 @@ func (r *mutationResolver) CreateMatch(ctx context.Context) (int, error) {
 	// initialize map vote (maps and random voter)
 	// reset slice; if any element is left over, go will not reassign the value
 	voteMaps = make([]string, 0)
-	voteMaps = config.Maps
+	voteMaps = r.Config.Maps
 	rand.Seed(time.Now().UTC().UnixNano())
 	voter := rand.Intn(2)
 	if voter == 0 {

@@ 1,6 1,7 @@
 package main
 
 import (
+	"flag"
 	"log"
 	"net/http"
 	"os"


@@ 19,27 20,30 @@ func main() {
 	flag.StringVar(&configPath, "config", "/etc/10man-api/config", "config file path")
 	flag.Parse()
 
-	config.ReadConfig(configPath)
-
-	port := os.Getenv("PORT")
-	if port == "" {
-		port = config.Port
-	}
-
 	sigs := make(chan os.Signal, 1)
 	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
 
-	db, err := database.Open()
+	cfg, err := config.ReadConfig(configPath)
+	if err != nil {
+		log.Fatalf("config: %v", err)
+	}
+
+	db, err := database.Open(cfg.DBConnectionString)
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	srv := handler.NewDefaultServer(generated.NewExecutableSchema(generated.Config{Resolvers: &graph.Resolver{}}))
+	srv := handler.NewDefaultServer(generated.NewExecutableSchema(generated.Config{
+		Resolvers: &graph.Resolver{
+			DB:     db,
+			Config: *cfg,
+		},
+	}))
 
 	http.Handle("/query", srv)
 
 	go func() {
-		log.Fatal(http.ListenAndServe(":"+port, nil))
+		log.Fatal(http.ListenAndServe(":"+cfg.Port, nil))
 	}()
 
 	shutdown(<-sigs, db)