Web dashboard, task release, logs api

storage/database.go

@@ -2,7 +2,6 @@ package storage
 
 import (
 	"database/sql"
-	"fmt"
 	"github.com/Sirupsen/logrus"
 	_ "github.com/lib/pq"
 	"io/ioutil"
@@ -11,6 +10,7 @@ import (
 )
 
 type Database struct {
+	db *sql.DB
 }
 
 func (database *Database) Reset() {
@@ -25,29 +25,24 @@ func (database *Database) Reset() {
 	_, 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)
+func (database *Database) getDB() *sql.DB {
+
+	if database.db == nil {
+		db, err := sql.Open("postgres", config.Cfg.DbConnStr)
+		if err != nil {
+			logrus.Fatal(err)
+		}
+
+		database.db = db
+	} else {
+		err := database.db.Ping()
+		handleErr(err)
 	}
 
-	return db
+	return database.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/log.go

@@ -0,0 +1,71 @@
+package storage
+
+import (
+	"database/sql"
+	"encoding/json"
+	"github.com/Sirupsen/logrus"
+	"src/task_tracker/config"
+)
+
+type LogEntry struct {
+	Message   string `json:"message"`
+	Timestamp int64  `json:"timestamp"`
+	Data      string `json:"data"`
+	Level     string `json:"level"`
+}
+type sqlLogHook struct {
+	database *Database
+}
+
+func (h sqlLogHook) Levels() []logrus.Level {
+	return config.Cfg.DbLogLevels
+}
+
+func (h sqlLogHook) Fire(entry *logrus.Entry) error {
+
+	db := h.database.getDB()
+
+	jsonData, err := json.Marshal(entry.Data)
+	if err != nil {
+		return err
+	}
+
+	_, err = db.Exec("INSERT INTO log_entry (message, level, message_data, timestamp) VALUES ($1,$2,$3,$4)",
+		entry.Message, entry.Level.String(), jsonData, entry.Time.Unix())
+	return err
+}
+
+func (database *Database) SetupLoggerHook() {
+	hook := sqlLogHook{}
+	hook.database = database
+	logrus.AddHook(hook)
+}
+
+func (database *Database) GetLogs(since int64, level logrus.Level) *[]LogEntry {
+
+	db := database.getDB()
+	logs := getLogs(since, level, db)
+
+	return logs
+}
+
+func getLogs(since int64, level logrus.Level, db *sql.DB) *[]LogEntry {
+
+	var logs []LogEntry
+
+	rows, err := db.Query("SELECT * FROM log_entry WHERE timestamp > $1 AND level=$2",
+		since, level.String())
+	handleErr(err)
+
+	for rows.Next() {
+
+		e := LogEntry{}
+
+		err := rows.Scan(&e.Level, &e.Message, &e.Data, &e.Timestamp)
+		handleErr(err)
+
+		logs = append(logs, e)
+	}
+
+	return &logs
+}

storage/project.go

@@ -3,6 +3,7 @@ package storage
 import (
 	"database/sql"
 	"github.com/Sirupsen/logrus"
+	"github.com/google/uuid"
 	"strings"
 )
 
@@ -13,22 +14,34 @@ type Project struct {
 	CloneUrl string `json:"clone_url"`
 	GitRepo  string `json:"git_repo"`
 	Version  string `json:"version"`
+	Motd     string `json:"motd"`
+}
+
+type AssignedTasks struct {
+	Assignee  uuid.UUID `json:"assignee"`
+	TaskCount int64     `json:"task_count"`
+}
+
+type ProjectStats struct {
+	Project         *Project         `json:"project"`
+	NewTaskCount    int64            `json:"new_task_count"`
+	FailedTaskCount int64            `json:"failed_task_count"`
+	ClosedTaskCount int64            `json:"closed_task_count"`
+	Assignees       []*AssignedTasks `json:"assignees"`
 }
 
 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_repo, clone_url, version, priority)
-		VALUES ($1,$2,$3,$4,$5) RETURNING id`,
-		project.Name, project.GitRepo, project.CloneUrl, project.Version, project.Priority)
+	row := db.QueryRow(`INSERT INTO project (name, git_repo, clone_url, version, priority, motd)
+		VALUES ($1,$2,$3,$4,$5,$6) RETURNING id`,
+		project.Name, project.GitRepo, project.CloneUrl, project.Version, project.Priority, project.Motd)
 
 	var id int64
 	err := row.Scan(&id)
@@ -40,6 +53,8 @@ func saveProject(project *Project, db *sql.DB) (int64, error) {
 		return -1, err
 	}
 
+	project.Id = id
+
 	logrus.WithFields(logrus.Fields{
 		"id":      id,
 		"project": project,
@@ -52,8 +67,6 @@ func (database *Database) GetProject(id int64) *Project {
 
 	db := database.getDB()
 	project := getProject(id, db)
-	err := db.Close()
-	handleErr(err)
 	return project
 }
 
@@ -80,8 +93,8 @@ func getProject(id int64, db *sql.DB) *Project {
 func scanProject(row *sql.Row) (*Project, error) {
 
 	project := &Project{}
-	err := row.Scan(&project.Id, &project.Priority, &project.Name, &project.CloneUrl, &project.GitRepo,
-		&project.Version)
+	err := row.Scan(&project.Id, &project.Priority, &project.Motd, &project.Name, &project.CloneUrl,
+		&project.GitRepo, &project.Version)
 
 	return project, err
 }
@@ -90,20 +103,18 @@ func (database *Database) GetProjectWithRepoName(repoName string) *Project {
 
 	db := database.getDB()
 	project := getProjectWithRepoName(repoName, db)
-	err := db.Close()
-	handleErr(err)
 	return project
 }
 
 func getProjectWithRepoName(repoName string, db *sql.DB) *Project {
 
-	row := db.QueryRow(`SELECT * FROm project WHERE LOWER(git_repo)=$1`, strings.ToLower(repoName))
+	row := db.QueryRow(`SELECT * FROM project WHERE LOWER(git_repo)=$1`, strings.ToLower(repoName))
 
 	project, err := scanProject(row)
 	if err != nil {
 		logrus.WithError(err).WithFields(logrus.Fields{
 			"repoName": repoName,
-		}).Error("Database.getProjectWithRepoName SELECT project NOT FOUND")
+		}).Warn("Database.getProjectWithRepoName SELECT project NOT FOUND")
 		return nil
 	}
 
@@ -114,15 +125,13 @@ func (database *Database) UpdateProject(project *Project) {
 
 	db := database.getDB()
 	updateProject(project, db)
-	err := db.Close()
-	handleErr(err)
 }
 
 func updateProject(project *Project, db *sql.DB) {
 
 	res, err := db.Exec(`UPDATE project 
-		SET (priority, name, clone_url, git_repo, version) = ($1,$2,$3,$4,$5) WHERE id=$6`,
-		project.Priority, project.Name, project.CloneUrl, project.GitRepo, project.Version, project.Id)
+		SET (priority, name, clone_url, git_repo, version, motd) = ($1,$2,$3,$4,$5,$6) WHERE id=$7`,
+		project.Priority, project.Name, project.CloneUrl, project.GitRepo, project.Version, project.Motd, project.Id)
 	handleErr(err)
 
 	rowsAffected, _ := res.RowsAffected()
@@ -134,3 +143,47 @@ func updateProject(project *Project, db *sql.DB) {
 
 	return
 }
+
+func (database *Database) GetProjectStats(id int64) *ProjectStats {
+
+	db := database.getDB()
+	stats := getProjectStats(id, db)
+
+	return stats
+}
+
+func getProjectStats(id int64, db *sql.DB) *ProjectStats {
+
+	stats := ProjectStats{}
+
+	stats.Project = getProject(id, db)
+
+	if stats.Project != nil {
+		row := db.QueryRow(`SELECT 
+       SUM(CASE WHEN status='new' THEN 1 ELSE 0 END) newCount,
+       SUM(CASE WHEN status='failed' THEN 1 ELSE 0 END) failedCount,
+       SUM(CASE WHEN status='closed' THEN 1 ELSE 0 END) closedCount
+       FROM task WHERE project=$1 GROUP BY project`, id)
+
+		err := row.Scan(&stats.NewTaskCount, &stats.FailedTaskCount, &stats.ClosedTaskCount)
+		if err != nil {
+			logrus.WithError(err).WithFields(logrus.Fields{
+				"id": id,
+			}).Warn("???") //todo
+			return nil
+		}
+
+		rows, err := db.Query(`SELECT assignee, COUNT(*) FROM TASK
+  			LEFT JOIN worker ON TASK.assignee = worker.id WHERE project=$1 GROUP BY assignee`, id)
+
+		for rows.Next() {
+			assignee := AssignedTasks{}
+			err = rows.Scan(&assignee.Assignee, &assignee.TaskCount)
+			handleErr(err)
+
+			stats.Assignees = append(stats.Assignees, &assignee)
+		}
+	}
+
+	return &stats
+}

storage/task.go

@@ -21,8 +21,6 @@ func (database *Database) SaveTask(task *Task, project int64) error {
 
 	db := database.getDB()
 	taskErr := saveTask(task, project, db)
-	err := db.Close()
-	handleErr(err)
 
 	return taskErr
 }
@@ -55,8 +53,6 @@ func (database *Database) GetTask(worker *Worker) *Task {
 
 	db := database.getDB()
 	task := getTask(worker, db)
-	err := db.Close()
-	handleErr(err)
 
 	return task
 }
@@ -112,12 +108,41 @@ func getTaskById(id int64, db *sql.DB) *Task {
 	return task
 }
 
+func (database Database) ReleaseTask(id int64, workerId *uuid.UUID, success bool) bool {
+
+	db := database.getDB()
+	res := releaseTask(workerId, id, success, db)
+
+	return res
+}
+
+func releaseTask(workerId *uuid.UUID, id int64, success bool, db *sql.DB) bool {
+
+	var res sql.Result
+	var err error
+	if success {
+		res, err = db.Exec(`UPDATE task SET (status, assignee) = ('closed', NULL)
+		WHERE id=$2 AND task.assignee=$2`, id, workerId)
+	} else {
+		res, err = db.Exec(`UPDATE task SET (status, assignee, retries) = 
+  		(CASE WHEN retries+1 >= max_retries THEN 'failed' ELSE 'new' END, NULL, retries+1)
+		WHERE id=$2 AND assignee=$2`, id, workerId)
+	}
+	handleErr(err)
+
+	rowsAffected, _ := res.RowsAffected()
+
+	logrus.WithFields(logrus.Fields{
+		"rowsAffected": rowsAffected,
+	})
+
+	return rowsAffected == 1
+}
+
 func (database *Database) GetTaskFromProject(worker *Worker, project int64) *Task {
 
 	db := database.getDB()
 	task := getTaskFromProject(worker, project, db)
-	err := db.Close()
-	handleErr(err)
 
 	return task
 }
@@ -165,7 +190,7 @@ func scanTask(row *sql.Row) *Task {
 
 	err := row.Scan(&task.Id, &task.Priority, &project.Id, &task.Assignee,
 		&task.Retries, &task.MaxRetries, &task.Status, &task.Recipe, &project.Id,
-		&project.Priority, &project.Name, &project.CloneUrl, &project.GitRepo, &project.Version)
+		&project.Priority, &project.Motd, &project.Name, &project.CloneUrl, &project.GitRepo, &project.Version)
 	handleErr(err)
 
 	return task

storage/worker.go

@@ -22,16 +22,12 @@ 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
 }