Initial commit

storage/database.go

@@ -0,0 +1,53 @@
+package storage
+
+import (
+	"database/sql"
+	"fmt"
+	"github.com/Sirupsen/logrus"
+	_ "github.com/lib/pq"
+	"io/ioutil"
+	"os"
+	"src/task_tracker/config"
+)
+
+type Database struct {
+}
+
+func (database *Database) Reset() {
+
+	file, err := os.Open("./schema.sql")
+	handleErr(err)
+
+	buffer, err := ioutil.ReadAll(file)
+	handleErr(err)
+
+	db := database.getDB()
+	_, err = db.Exec(string(buffer))
+	handleErr(err)
+
+	db.Close()
+	file.Close()
+
+	logrus.Info("Database has been reset")
+}
+
+func (database *Database) getDB () *sql.DB {
+	db, err := sql.Open("postgres", config.Cfg.DbConnStr)
+	if err != nil {
+		logrus.Fatal(err)
+	}
+
+	return db
+}
+
+func (database *Database) Test() {
+
+	db := database.getDB()
+
+	rows, err := db.Query("SELECT name FROM Task")
+	if err != nil {
+		logrus.Fatal(err)
+	}
+	fmt.Println(rows)
+
+}

storage/error.go

@@ -0,0 +1,7 @@
+package storage
+
+func handleErr(err error) {
+	if err != nil {
+		panic(err)
+	}
+}

storage/project.go

@@ -0,0 +1,77 @@
+package storage
+
+import (
+	"database/sql"
+	"github.com/Sirupsen/logrus"
+)
+
+type Project struct {
+	Id int64 `json:"id"`
+	Name string `json:"name"`
+	GitUrl string `json:"git_url"`
+	Version string `json:"version"`
+}
+
+func (database *Database) SaveProject(project *Project) (int64, error) {
+	db := database.getDB()
+	id, projectErr := saveProject(project, db)
+	err := db.Close()
+	handleErr(err)
+
+	return id, projectErr
+}
+
+func saveProject(project *Project, db *sql.DB) (int64, error) {
+
+	row := db.QueryRow("INSERT INTO project (name, git_url, version) VALUES ($1,$2,$3) RETURNING id",
+		project.Name, project.GitUrl, project.Version)
+
+	var id int64
+	err := row.Scan(&id)
+
+	if err != nil {
+		logrus.WithError(err).WithFields(logrus.Fields{
+			"project": project,
+		}).Warn("Database.saveProject INSERT project ERROR")
+		return -1, err
+	}
+
+	logrus.WithFields(logrus.Fields{
+		"id": id,
+		"project": project,
+	}).Trace("Database.saveProject INSERT project")
+
+	return id, nil
+}
+
+func (database *Database) GetProject(id int64) *Project {
+
+	db := database.getDB()
+	project := getProject(id, db)
+	err := db.Close()
+	handleErr(err)
+	return project
+}
+
+func getProject(id int64, db *sql.DB) *Project {
+
+	project := &Project{}
+
+	row := db.QueryRow("SELECT id, name, git_url, version FROM project WHERE id=$1",
+		id)
+
+	err := row.Scan(&project.Id, &project.Name, &project.GitUrl, &project.Version)
+	if err != nil {
+		logrus.WithFields(logrus.Fields{
+			"id": id,
+		}).Warn("Database.getProject SELECT project NOT FOUND")
+		return nil
+	}
+
+	logrus.WithFields(logrus.Fields{
+		"id": id,
+		"project": project,
+	}).Trace("Database.saveProject SELECT project")
+
+	return project
+}

storage/task.go

@@ -0,0 +1,50 @@
+package storage
+
+import (
+	"database/sql"
+	"github.com/Sirupsen/logrus"
+	"github.com/google/uuid"
+)
+
+type Task struct {
+	Id         int64
+	Project    int64
+	Assignee   uuid.UUID
+	Retries    int64
+	MaxRetries int64
+	Status     string
+	Recipe     string
+}
+
+func (database *Database) SaveTask(task *Task) error {
+
+	db := database.getDB()
+	taskErr := saveTask(task, db)
+	err := db.Close()
+	handleErr(err)
+
+	return taskErr
+}
+
+func saveTask(task *Task, db *sql.DB) error {
+
+	res, err := db.Exec("INSERT INTO task (project, max_retries, recipe) "+
+		"VALUES ($1,$2,$3)",
+		task.Project, task.MaxRetries, task.Recipe)
+	if err != nil {
+		logrus.WithError(err).WithFields(logrus.Fields{
+			"task": task,
+		}).Warn("Database.saveTask INSERT task ERROR")
+		return err
+	}
+
+	rowsAffected, err := res.RowsAffected()
+	handleErr(err)
+
+	logrus.WithFields(logrus.Fields{
+		"rowsAffected": rowsAffected,
+		"task":         task,
+	}).Trace("Database.saveTask INSERT task")
+
+	return nil
+}

storage/worker.go

@@ -0,0 +1,116 @@
+package storage
+
+import (
+	"database/sql"
+	"errors"
+	"github.com/Sirupsen/logrus"
+	"github.com/google/uuid"
+)
+
+type Identity struct {
+	RemoteAddr string
+}
+
+type Worker struct {
+	Id uuid.UUID `json:"id"`
+	Created int64 `json:"created"`
+	Identity *Identity `json:"identity"`
+}
+
+func (database *Database) SaveWorker(worker *Worker) {
+
+	db := database.getDB()
+	saveWorker(worker, db)
+	err := db.Close()
+	handleErr(err)
+}
+
+func (database *Database) GetWorker(id uuid.UUID) *Worker {
+
+	db := database.getDB()
+	worker := getWorker(id, db)
+	err := db.Close()
+	handleErr(err)
+	return worker
+}
+
+func saveWorker(worker *Worker, db *sql.DB) {
+
+	identityId := getOrCreateIdentity(worker.Identity, db)
+
+	res, err := db.Exec("INSERT INTO worker (id, created, identity) VALUES ($1,$2,$3)",
+		worker.Id, worker.Created, identityId)
+	handleErr(err)
+
+	var rowsAffected, _ = res.RowsAffected()
+	logrus.WithFields(logrus.Fields{
+		"rowsAffected": rowsAffected,
+	}).Trace("Database.saveWorker INSERT worker")
+}
+
+func getWorker(id uuid.UUID, db *sql.DB) *Worker {
+
+	worker := &Worker{}
+	var identityId int64
+
+	row := db.QueryRow("SELECT id, created, identity FROM worker WHERE id=$1", id)
+	err := row.Scan(&worker.Id, &worker.Created, &identityId)
+	if err != nil {
+		logrus.WithFields(logrus.Fields{
+			"id": id,
+		}).Warn("Database.getWorker SELECT worker NOT FOUND")
+		return nil
+	}
+
+	worker.Identity, err = getIdentity(identityId, db)
+	handleErr(err)
+
+	logrus.WithFields(logrus.Fields{
+		"worker": worker,
+	}).Trace("Database.getWorker SELECT worker")
+
+	return worker
+}
+
+func getIdentity(id int64, db *sql.DB) (*Identity, error) {
+
+	identity := &Identity{}
+
+	row := db.QueryRow("SELECT (remote_addr) FROM workeridentity WHERE id=$1", id)
+	err := row.Scan(&identity.RemoteAddr)
+
+	if err != nil {
+		return nil, errors.New("identity not found")
+	}
+
+	logrus.WithFields(logrus.Fields{
+		"identity": identity,
+	}).Trace("Database.getIdentity SELECT workerIdentity")
+
+	return identity, nil
+}
+
+func getOrCreateIdentity(identity *Identity, db *sql.DB) int64 {
+
+	res, err := db.Exec("INSERT INTO workeridentity (remote_addr) VALUES ($1) ON CONFLICT DO NOTHING",
+		identity.RemoteAddr)
+	handleErr(err)
+
+	rowsAffected, err := res.RowsAffected()
+	logrus.WithFields(logrus.Fields{
+		"rowsAffected": rowsAffected,
+	}).Trace("Database.saveWorker INSERT workerIdentity")
+
+	row := db.QueryRow("SELECT (id) FROM workeridentity WHERE remote_addr=$1", identity.RemoteAddr)
+
+	var rowId int64
+	err = row.Scan(&rowId)
+	handleErr(err)
+
+	logrus.WithFields(logrus.Fields{
+		"rowId": rowId,
+	}).Trace("Database.saveWorker SELECT workerIdentity")
+
+	return rowId
+}
+