Initial commit

server/database/auth.go

@@ -0,0 +1,67 @@
+package database
+
+import (
+	"golang.org/x/crypto/bcrypt"
+)
+
+type Auth struct {
+	User     *string `json:"user"`
+	Password *[]byte `json:"password"`
+}
+
+func NewAuth(user string, password []byte) (Auth, error) {
+	hash, err := bcrypt.GenerateFromPassword(password, bcrypt.DefaultCost)
+	if err != nil {
+		return Auth{}, err
+	}
+	return Auth{
+		&user,
+		&hash,
+	}, nil
+}
+
+func NewUnsafeAuth(user string, password []byte) Auth {
+	auth, _ := NewAuth(user, password)
+	return auth
+}
+
+func (db *Database) SetAuth(containerID string, auth Auth) error {
+	if auth.User != nil {
+		_, err := db.Exec("INSERT INTO auth (container_id, user) VALUES ($1, $2) ON CONFLICT (container_id) DO UPDATE SET user=$2", containerID, *auth.User)
+		if err != nil {
+			return err
+		}
+	}
+	if auth.Password != nil {
+		_, err := db.Exec("INSERT INTO auth (container_id, password) VALUES ($1, $2) ON CONFLICT (container_id) DO UPDATE SET password=$2", containerID, *auth.Password)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// GetAuthByContainer returns the auth by a container id
+func (db *Database) GetAuthByContainer(containerID string) (auth Auth, exists bool) {
+	if err := db.QueryRow("SELECT user, password FROM auth WHERE container_id=$1", containerID).Scan(&auth.User, &auth.Password); err != nil {
+		return Auth{}, false
+	}
+	return auth, true
+}
+
+func (db *Database) GetContainerByAuth(auth Auth) (containerID string, exists bool) {
+	// return true if `auth` contains a nil pointer or no auth was found in the database.
+	// hopefully this is no security issue
+	if auth.User == nil || auth.Password == nil {
+		return "", false
+	}
+	if err := db.QueryRow("SELECT container_id FROM auth WHERE user=$1 AND password=$2 OR password IS NULL", auth.User, auth.Password).Scan(&containerID); err != nil {
+		return "", false
+	}
+	return containerID, true
+}
+
+func (db *Database) DeleteAuth(containerID string) error {
+	_, err := db.Exec("DELETE FROM auth WHERE container_id=$1", containerID)
+	return err
+}

server/database/database.go

@@ -0,0 +1,34 @@
+package database
+
+import (
+	"database/sql"
+	_ "github.com/mattn/go-sqlite3"
+)
+
+var globalDB *Database
+
+type Database struct {
+	*sql.DB
+}
+
+func newDatabaseConnection(driverName, dataSource string) (*Database, error) {
+	database, err := sql.Open(driverName, dataSource)
+	if err != nil {
+		return nil, err
+	}
+	db := &Database{DB: database}
+
+	return db, nil
+}
+
+func NewSqlite3Connection(databaseFile string) (*Database, error) {
+	return newDatabaseConnection("sqlite3", databaseFile)
+}
+
+func GetDatabase() *Database {
+	return globalDB
+}
+
+func SetDatabase(database *Database) {
+	globalDB = database
+}

server/database/delete.go

@@ -0,0 +1,11 @@
+package database
+
+func (db *Database) Delete(containerID string) error {
+	if _, err := db.Exec("DELETE FROM auth WHERE container_id=$1", containerID); err != nil {
+		return err
+	}
+	if _, err := db.Exec("DELETE FROM settings WHERE container_id=$1", containerID); err != nil {
+		return err
+	}
+	return nil
+}

server/database/settings.go

@@ -0,0 +1,75 @@
+package database
+
+import (
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// Settings is the raw version of docker.Config
+type Settings struct {
+	NetworkMode        *int    `json:"network_mode"`
+	Configurable       *bool   `json:"configurable"`
+	RunLevel           *int    `json:"run_level"`
+	StartupInformation *bool   `json:"startup_information"`
+	ExitAfter          *string `json:"exit_after"`
+	KeepOnExit         *bool   `json:"keep_on_exit"`
+}
+
+func (db *Database) SettingsByContainerID(containerID string) (Settings, error) {
+	row := db.QueryRow("SELECT network_mode, configurable, run_level, startup_information, exit_after, keep_on_exit FROM settings WHERE container_id LIKE $1", fmt.Sprintf("%s%%", containerID))
+
+	var settings Settings
+
+	if err := row.Scan(&settings.NetworkMode, &settings.Configurable, &settings.RunLevel, &settings.StartupInformation, &settings.ExitAfter, &settings.KeepOnExit); err != nil {
+		return Settings{}, err
+	}
+	return settings, nil
+}
+
+func (db *Database) SetSettings(containerID string, settings Settings) error {
+	query := make(map[string]interface{}, 0)
+
+	body, _ := json.Marshal(settings)
+	json.Unmarshal(body, &query)
+
+	var keys, values []string
+	for k, v := range query {
+		if v != nil {
+			keys = append(keys, k)
+			switch reflect.ValueOf(v).Kind() {
+			case reflect.String:
+				values = append(values, fmt.Sprintf("\"%v\"", v))
+			case reflect.Bool:
+				if v.(bool) {
+					values = append(values, fmt.Sprintf("%v", 1))
+				} else {
+					values = append(values, fmt.Sprintf("%v", 0))
+				}
+			default:
+				values = append(values, fmt.Sprintf("%v", v))
+			}
+		}
+	}
+
+	err := db.QueryRow("SELECT 1 FROM settings WHERE container_id=$1", containerID).Scan()
+	if err == sql.ErrNoRows {
+		keys = append(keys, "container_id")
+		values = append(values, fmt.Sprintf("\"%s\"", containerID))
+
+		_, err = db.Exec(fmt.Sprintf("INSERT INTO settings (%s) VALUES (%s)", strings.Join(keys, ", "), strings.Join(values, ", ")))
+	} else if len(keys) > 0 {
+		var set []string
+
+		for i := 0; i < len(keys); i++ {
+			set = append(set, fmt.Sprintf("%s=%s", keys[i], values[i]))
+		}
+
+		_, err = db.Exec(fmt.Sprintf("UPDATE settings SET %s WHERE container_id=$1", strings.Join(set, ", ")), containerID)
+	} else {
+		err = nil
+	}
+	return err
+}