simon987/task_tracker
1
0
Fork 0
mirror of https://github.com/simon987/task_tracker.git synced 2025-04-19 18:16:45 +00:00
Code Issues Projects Releases Wiki Activity

worker id required for logging endpoint

Browse Source
This commit is contained in:
simon987 2019-01-29 20:12:59 -05:00
parent 3a88642c5c
commit 58f20aa33d
8 changed files with 356 additions and 254 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
api/git.go
View File

@ -54,11 +54,15 @@ func (api *WebAPI) ReceiveGitWebHook(r *Request) {
}
payload := &GitPayload{}
if r.GetJson(payload) {
err := json.Unmarshal(r.Ctx.Request.Body(), payload)
if err != nil {
r.Ctx.SetStatusCode(400)
return
}
logrus.WithFields(logrus.Fields{
"payload": payload,
}).Info("Received git WebHook")
}
if !isProductionBranch(payload) {
return
@ -72,7 +76,7 @@ func (api *WebAPI) ReceiveGitWebHook(r *Request) {
version := getVersion(payload)
project.Version = version
err := api.Database.UpdateProject(project)
err = api.Database.UpdateProject(project)
handleErr(err, r)
}

8
api/helper.go
View File

@ -37,11 +37,3 @@ func (r *Request) Json(object interface{}, code int) {
}
}
func (r *Request) GetJson(x interface{}) bool {
err := json.Unmarshal(r.Ctx.Request.Body(), x)
handleErr(err, r)
return err == nil
}

90
api/log.go
View File

@ -1,6 +1,7 @@
package api
import (
"encoding/json"
"errors"
"github.com/Sirupsen/logrus"
"github.com/valyala/fasthttp"
@ -20,6 +21,7 @@ type LogRequest struct {
Scope string `json:"scope"`
Message string `json:"Message"`
TimeStamp int64 `json:"timestamp"`
worker *storage.Worker
}
type GetLogResponse struct {
@ -52,63 +54,112 @@ func (api *WebAPI) SetupLogger() {
api.Database.SetupLoggerHook()
}
func parseLogEntry(r *Request) *LogRequest {
func (api *WebAPI) parseLogEntry(r *Request) (*LogRequest, error) {
worker, err := api.validateSignature(r)
if err != nil {
return nil, err
}
entry := LogRequest{}
if r.GetJson(&entry) {
if len(entry.Message) == 0 {
handleErr(errors.New("invalid message"), r)
} else if len(entry.Scope) == 0 {
handleErr(errors.New("invalid scope"), r)
} else if entry.TimeStamp <= 0 {
handleErr(errors.New("invalid timestamp"), r)
}
err = json.Unmarshal(r.Ctx.Request.Body(), &entry)
if err != nil {
return nil, err
}
return &entry
if len(entry.Message) == 0 {
return nil, errors.New("invalid message")
} else if len(entry.Scope) == 0 {
return nil, errors.New("invalid scope")
} else if entry.TimeStamp <= 0 {
return nil, errors.New("invalid timestamp")
}
entry.worker = worker
return &entry, nil
}
func LogTrace(r *Request) {
func (api *WebAPI) LogTrace(r *Request) {
entry := parseLogEntry(r)
entry, err := api.parseLogEntry(r)
if err != nil {
r.Json(GetLogResponse{
Ok: false,
Message: "Could not parse request",
}, 400)
return
}
logrus.WithFields(logrus.Fields{
"scope": entry.Scope,
"worker": entry.worker.Id,
}).WithTime(entry.Time()).Trace(entry.Message)
}
func LogInfo(r *Request) {
func (api *WebAPI) LogInfo(r *Request) {
entry := parseLogEntry(r)
entry, err := api.parseLogEntry(r)
if err != nil {
r.Json(GetLogResponse{
Ok: false,
Message: "Could not parse request",
}, 400)
return
}
logrus.WithFields(logrus.Fields{
"scope": entry.Scope,
"worker": entry.worker.Id,
}).WithTime(entry.Time()).Info(entry.Message)
}
func LogWarn(r *Request) {
func (api *WebAPI) LogWarn(r *Request) {
entry := parseLogEntry(r)
entry, err := api.parseLogEntry(r)
if err != nil {
r.Json(GetLogResponse{
Ok: false,
Message: "Could not parse request",
}, 400)
return
}
logrus.WithFields(logrus.Fields{
"scope": entry.Scope,
"worker": entry.worker.Id,
}).WithTime(entry.Time()).Warn(entry.Message)
}
func LogError(r *Request) {
func (api *WebAPI) LogError(r *Request) {
entry := parseLogEntry(r)
entry, err := api.parseLogEntry(r)
if err != nil {
r.Json(GetLogResponse{
Ok: false,
Message: "Could not parse request",
}, 400)
return
}
logrus.WithFields(logrus.Fields{
"scope": entry.Scope,
"worker": entry.worker.Id,
}).WithTime(entry.Time()).Error(entry.Message)
}
func (api *WebAPI) GetLog(r *Request) {
req := &GetLogRequest{}
if r.GetJson(req) {
err := json.Unmarshal(r.Ctx.Request.Body(), req)
if err != nil {
r.Json(GetLogResponse{
Ok: false,
Message: "Could not parse request",
}, 400)
return
}
if req.isValid() {
logs := api.Database.GetLogs(req.Since, req.Level)
@ -132,7 +183,6 @@ func (api *WebAPI) GetLog(r *Request) {
Message: "Invalid log request",
}, 400)
}
}
}
func (r GetLogRequest) isValid() bool {

8
api/main.go
View File

@ -43,10 +43,10 @@ func New() *WebAPI {
api.router.GET("/", LogRequestMiddleware(Index))
api.router.POST("/log/trace", LogRequestMiddleware(LogTrace))
api.router.POST("/log/info", LogRequestMiddleware(LogInfo))
api.router.POST("/log/warn", LogRequestMiddleware(LogWarn))
api.router.POST("/log/error", LogRequestMiddleware(LogError))
api.router.POST("/log/trace", LogRequestMiddleware(api.LogTrace))
api.router.POST("/log/info", LogRequestMiddleware(api.LogInfo))
api.router.POST("/log/warn", LogRequestMiddleware(api.LogWarn))
api.router.POST("/log/error", LogRequestMiddleware(api.LogError))
api.router.POST("/worker/create", LogRequestMiddleware(api.WorkerCreate))
api.router.POST("/worker/update", LogRequestMiddleware(api.WorkerUpdate))

40
api/project.go
View File

@ -1,6 +1,7 @@
package api
import (
"encoding/json"
"github.com/Sirupsen/logrus"
"src/task_tracker/storage"
"strconv"
@ -57,8 +58,14 @@ type GetAllProjectsStatsResponse struct {
func (api *WebAPI) ProjectCreate(r *Request) {
createReq := &CreateProjectRequest{}
if r.GetJson(createReq) {
err := json.Unmarshal(r.Ctx.Request.Body(), createReq)
if err != nil {
r.Json(CreateProjectResponse{
Ok: false,
Message: "Could not parse request",
}, 400)
return
}
project := &storage.Project{
Name: createReq.Name,
Version: createReq.Version,
@ -96,18 +103,28 @@ func (api *WebAPI) ProjectCreate(r *Request) {
Message: "Invalid project",
}, 400)
}
}
}
func (api *WebAPI) ProjectUpdate(r *Request) {
id, err := strconv.ParseInt(r.Ctx.UserValue("id").(string), 10, 64)
handleErr(err, r) //todo handle invalid id
if err != nil || id <= 0 {
r.Json(CreateProjectResponse{
Ok: false,
Message: "Invalid project id",
}, 400)
return
}
updateReq := &UpdateProjectRequest{}
if r.GetJson(updateReq) {
err = json.Unmarshal(r.Ctx.Request.Body(), updateReq)
if err != nil {
r.Json(CreateProjectResponse{
Ok: false,
Message: "Could not parse request",
}, 400)
return
}
project := &storage.Project{
Id: id,
Name: updateReq.Name,
@ -150,7 +167,6 @@ func (api *WebAPI) ProjectUpdate(r *Request) {
Message: "Invalid project",
}, 400)
}
}
}
func isValidProject(project *storage.Project) bool {
@ -187,7 +203,13 @@ func (api *WebAPI) ProjectGet(r *Request) {
func (api *WebAPI) ProjectGetStats(r *Request) {
id, err := strconv.ParseInt(r.Ctx.UserValue("id").(string), 10, 64)
handleErr(err, r)
if err != nil {
r.Json(GetProjectStatsResponse{
Ok: false,
Message: "Could not parse request",
}, 400)
return
}
stats := api.Database.GetProjectStats(id)

26
api/task.go
View File

@ -5,6 +5,7 @@ import (
"crypto"
"crypto/hmac"
"encoding/hex"
"encoding/json"
"errors"
"github.com/Sirupsen/logrus"
"github.com/dchest/siphash"
@ -45,9 +46,15 @@ type GetTaskResponse struct {
func (api *WebAPI) TaskCreate(r *Request) {
var createReq CreateTaskRequest
if r.GetJson(&createReq) {
createReq := &CreateTaskRequest{}
err := json.Unmarshal(r.Ctx.Request.Body(), createReq)
if err != nil {
r.Json(CreateProjectResponse{
Ok: false,
Message: "Could not parse request",
}, 400)
return
}
task := &storage.Task{
MaxRetries: createReq.MaxRetries,
Recipe: createReq.Recipe,
@ -84,7 +91,6 @@ func (api *WebAPI) TaskCreate(r *Request) {
Message: "Invalid task",
}, 400)
}
}
}
func (req *CreateTaskRequest) IsValid() bool {
@ -215,9 +221,14 @@ func (api *WebAPI) TaskRelease(r *Request) {
return
}
var req ReleaseTaskRequest
if r.GetJson(&req) {
req := &ReleaseTaskRequest{}
err = json.Unmarshal(r.Ctx.Request.Body(), req)
if err != nil {
r.Json(CreateProjectResponse{
Ok: false,
Message: "Could not parse request",
}, 400)
}
res := api.Database.ReleaseTask(req.TaskId, worker.Id, req.Success)
response := ReleaseTaskResponse{
@ -240,5 +251,4 @@ func (api *WebAPI) TaskRelease(r *Request) {
}
r.OkJson(response)
}
}

37
api/worker.go
View File

@ -1,6 +1,7 @@
package api
import (
"encoding/json"
"github.com/Sirupsen/logrus"
"math/rand"
"src/task_tracker/storage"
@ -46,12 +47,12 @@ type WorkerAccessResponse struct {
func (api *WebAPI) WorkerCreate(r *Request) {
workerReq := &CreateWorkerRequest{}
if !r.GetJson(workerReq) {
err := json.Unmarshal(r.Ctx.Request.Body(), workerReq)
if err != nil {
return
}
identity := getIdentity(r)
if !canCreateWorker(r, workerReq, identity) {
logrus.WithFields(logrus.Fields{
@ -123,7 +124,14 @@ func (api *WebAPI) WorkerGet(r *Request) {
func (api *WebAPI) WorkerGrantAccess(r *Request) {
req := &WorkerAccessRequest{}
if r.GetJson(req) {
err := json.Unmarshal(r.Ctx.Request.Body(), req)
if err != nil {
r.Json(GetTaskResponse{
Ok: false,
Message: "Could not parse request",
}, 400)
return
}
ok := api.Database.GrantAccess(req.WorkerId, req.ProjectId)
@ -137,14 +145,19 @@ func (api *WebAPI) WorkerGrantAccess(r *Request) {
Message: "Worker already has access to this project",
})
}
}
}
func (api *WebAPI) WorkerRemoveAccess(r *Request) {
req := &WorkerAccessRequest{}
if r.GetJson(req) {
err := json.Unmarshal(r.Ctx.Request.Body(), req)
if err != nil {
r.Json(GetTaskResponse{
Ok: false,
Message: "Could not parse request",
}, 400)
return
}
ok := api.Database.RemoveAccess(req.WorkerId, req.ProjectId)
if ok {
@ -157,7 +170,6 @@ func (api *WebAPI) WorkerRemoveAccess(r *Request) {
Message: "Worker did not have access to this project",
})
}
}
}
func (api *WebAPI) WorkerUpdate(r *Request) {
@ -172,8 +184,14 @@ func (api *WebAPI) WorkerUpdate(r *Request) {
}
req := &UpdateWorkerRequest{}
if r.GetJson(req) {
err = json.Unmarshal(r.Ctx.Request.Body(), req)
if err != nil {
r.Json(GetTaskResponse{
Ok: false,
Message: "Could not parse request",
}, 400)
return
}
worker.Alias = req.Alias
ok := api.Database.UpdateWorker(worker)
@ -188,7 +206,6 @@ func (api *WebAPI) WorkerUpdate(r *Request) {
Message: "Could not update worker",
})
}
}
}
func (api *WebAPI) workerCreate(request *CreateWorkerRequest, identity *storage.Identity) (*storage.Worker, error) {

51
test/api_log_test.go
View File

@ -12,11 +12,12 @@ import (
func TestTraceValid(t *testing.T) {
w := genWid()
r := Post("/log/trace", api.LogRequest{
Scope: "test",
Message: "This is a test message",
TimeStamp: time.Now().Unix(),
}, nil)
}, w)
if r.StatusCode != 200 {
t.Fail()
@ -24,64 +25,68 @@ func TestTraceValid(t *testing.T) {
}
func TestTraceInvalidScope(t *testing.T) {
w := genWid()
r := Post("/log/trace", api.LogRequest{
Message: "this is a test message",
TimeStamp: time.Now().Unix(),
}, nil)
}, w)
if r.StatusCode != 500 {
t.Fail()
if r.StatusCode == 200 {
t.Error()
}
r = Post("/log/trace", api.LogRequest{
Scope: "",
Message: "this is a test message",
TimeStamp: time.Now().Unix(),
}, nil)
}, w)
if r.StatusCode != 500 {
t.Fail()
if r.StatusCode == 200 {
t.Error()
}
if GenericJson(r.Body)["message"] != "invalid scope" {
t.Fail()
if len(GenericJson(r.Body)["message"].(string)) <= 0 {
t.Error()
}
}
func TestTraceInvalidMessage(t *testing.T) {
w := genWid()
r := Post("/log/trace", api.LogRequest{
Scope: "test",
Message: "",
TimeStamp: time.Now().Unix(),
}, nil)
}, w)
if r.StatusCode != 500 {
t.Fail()
if r.StatusCode == 200 {
t.Error()
}
if GenericJson(r.Body)["message"] != "invalid message" {
t.Fail()
if len(GenericJson(r.Body)["message"].(string)) <= 0 {
t.Error()
}
}
func TestTraceInvalidTime(t *testing.T) {
w := genWid()
r := Post("/log/trace", api.LogRequest{
Scope: "test",
Message: "test",
}, nil)
if r.StatusCode != 500 {
t.Fail()
}, w)
if r.StatusCode == 200 {
t.Error()
}
if GenericJson(r.Body)["message"] != "invalid timestamp" {
t.Fail()
if len(GenericJson(r.Body)["message"].(string)) <= 0 {
t.Error()
}
}
func TestWarnValid(t *testing.T) {
w := genWid()
r := Post("/log/warn", api.LogRequest{
Scope: "test",
Message: "test",
TimeStamp: time.Now().Unix(),
}, nil)
}, w)
if r.StatusCode != 200 {
t.Fail()
}
@ -89,11 +94,12 @@ func TestWarnValid(t *testing.T) {
func TestInfoValid(t *testing.T) {
w := genWid()
r := Post("/log/info", api.LogRequest{
Scope: "test",
Message: "test",
TimeStamp: time.Now().Unix(),
}, nil)
}, w)
if r.StatusCode != 200 {
t.Fail()
}
@ -101,11 +107,12 @@ func TestInfoValid(t *testing.T) {
func TestErrorValid(t *testing.T) {
w := genWid()
r := Post("/log/error", api.LogRequest{
Scope: "test",
Message: "test",
TimeStamp: time.Now().Unix(),
}, nil)
}, w)
if r.StatusCode != 200 {
t.Fail()
}