Merge pull request 'master' (#37) from master into dev

Reviewed-on: #37

.deploy/deploy-dev.yaml

@@ -6,16 +6,17 @@ services:
     image: mathwave/sprint-repo:queues
     networks:
       - queues-development
+      - monitoring
+      - mongo-development
     environment:
-      MONGO_HOST: "mongo.develop.sprinthub.ru"
       MONGO_PASSWORD: $MONGO_PASSWORD_DEV
-      REDIS_HOST: "redis.develop.sprinthub.ru"
-      REDIS_PASSWORD: $REDIS_PASSWORD_DEV
       STAGE: "development"
     deploy:
       mode: replicated
       restart_policy:
         condition: any
+      placement:
+        constraints: [node.labels.stage == development]
       update_config:
         parallelism: 1
         order: start-first
@@ -23,3 +24,7 @@ services:
 networks:
   queues-development:
     external: true
+  monitoring:
+    external: true
+  mongo-development:
+    external: true

.deploy/deploy-prod.yaml

@@ -6,16 +6,18 @@ services:
     image: mathwave/sprint-repo:queues
     networks:
       - queues
+      - monitoring
+      - mongo
     environment:
       MONGO_HOST: "mongo.sprinthub.ru"
       MONGO_PASSWORD: $MONGO_PASSWORD_PROD
-      REDIS_HOST: "redis.sprinthub.ru"
-      REDIS_PASSWORD: $REDIS_PASSWORD_PROD
       STAGE: "production"
     deploy:
       mode: replicated
       restart_policy:
         condition: any
+      placement:
+        constraints: [node.labels.stage == production]
       update_config:
         parallelism: 1
         order: start-first
@@ -23,3 +25,7 @@ services:
 networks:
   queues:
     external: true
+  monitoring:
+    external: true
+  mongo:
+    external: true

.gitea/workflows/deploy-dev.yaml

@@ -9,7 +9,7 @@ on:
 jobs:
   build:
     name: Build
-    runs-on: [ dev ]
+    runs-on: [dev]
     steps:
       - name: login
         run: docker login -u mathwave -p ${{ secrets.DOCKERHUB_PASSWORD }}
@@ -21,7 +21,7 @@ jobs:
         run: docker build -t mathwave/sprint-repo:queues .
   push:
     name: Push
-    runs-on: [ dev ]
+    runs-on: [dev]
     needs: build
     steps:
       - name: push
@@ -41,4 +41,4 @@ jobs:
         env:
           MONGO_PASSWORD_DEV: ${{ secrets.MONGO_PASSWORD_DEV }}
           REDIS_PASSWORD_DEV: ${{ secrets.REDIS_PASSWORD_DEV }}
-        run: docker stack deploy --with-registry-auth -c ./.deploy/deploy-dev.yaml infra-development
+        run: docker stack deploy --with-registry-auth -c ./.deploy/deploy-dev.yaml queues-development

.gitea/workflows/deploy-prod.yaml

@@ -9,7 +9,7 @@ on:
 jobs:
   build:
     name: Build
-    runs-on: [ dev ]
+    runs-on: [dev]
     steps:
       - name: login
         run: docker login -u mathwave -p ${{ secrets.DOCKERHUB_PASSWORD }}
@@ -21,7 +21,7 @@ jobs:
         run: docker build -t mathwave/sprint-repo:queues .
   push:
     name: Push
-    runs-on: [ dev ]
+    runs-on: [dev]
     needs: build
     steps:
       - name: push
@@ -41,4 +41,4 @@ jobs:
         env:
           MONGO_PASSWORD_PROD: ${{ secrets.MONGO_PASSWORD_PROD }}
           REDIS_PASSWORD_PROD: ${{ secrets.REDIS_PASSWORD_PROD }}
-        run: docker stack deploy --with-registry-auth -c ./.deploy/deploy-prod.yaml infra
+        run: docker stack deploy --with-registry-auth -c ./.deploy/deploy-prod.yaml queues

app/routers/take.go

@@ -1,10 +1,14 @@
 package routers
 
 import (
+	"bytes"
 	"fmt"
+	"log"
 	"net/http"
+	"os"
 	tasks "queues-go/app/storage/mongo/collections"
-	"queues-go/app/storage/redis"
+	"strconv"
+	"sync"
 	"time"
 )
 
@@ -18,17 +22,34 @@ type TakeResponse struct {
 	Task *TaskResponse `json:"task"`
 }
 
+var MutexMap map[string]*sync.Mutex
+
+func sendLatency(timestamp time.Time, latency int) error {
+	loc, _ := time.LoadLocation("Europe/Moscow")
+
+	s := fmt.Sprintf(
+		`{"timestamp":"%s","service":"queues","environment":"%s","name":"latency","count":%s}`,
+		timestamp.In(loc).Format("2006-01-02T15:04:05Z"),
+		os.Getenv("STAGE"),
+		strconv.Itoa(latency),
+	)
+	data := []byte(s)
+	r := bytes.NewReader(data)
+	_, err := http.Post("http://monitoring:1237/api/v1/metrics/increment", "application/json", r)
+	if err != nil {
+		log.Printf("ERROR %s", err.Error())
+	}
+	return err
+}
+
 func Take(r *http.Request) (interface{}, int) {
 	queue := r.Header.Get("queue")
-	mutex := redis.Sync.NewMutex(fmt.Sprintf("lock_queues_%s", queue))
-	for {
-		err := mutex.Lock()
-		if err != nil {
-			time.Sleep(time.Millisecond * 5)
-		} else {
-			break
-		}
+	mutex, ok := MutexMap[queue]
+	if !ok {
+		mutex = &sync.Mutex{}
+		MutexMap[queue] = mutex
 	}
+	mutex.Lock()
 	task, err := tasks.Take(queue)
 	mutex.Unlock()
 	if err != nil {
@@ -44,6 +65,8 @@ func Take(r *http.Request) (interface{}, int) {
 			Attempt: task.Attempts,
 			Payload: task.Payload,
 		}
+		now := time.Now()
+		go sendLatency(now, int(now.Sub(task.PutAt).Milliseconds()))
 	}
 
 	return response, http.StatusOK

app/storage/mongo/client.go

@@ -12,7 +12,7 @@ import (
 var Database mongo.Database
 
 func Connect() {
-	connectionString := fmt.Sprintf("mongodb://mongo:%s@%s:27017/", utils.GetEnv("MONGO_PASSWORD", "password"), utils.GetEnv("MONGO_HOST", "localhost"))
+	connectionString := fmt.Sprintf("mongodb://mongo:%s@mongo:27017/", utils.GetEnv("MONGO_PASSWORD", "password"))
 	client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(connectionString))
 	if err != nil {
 		panic(err)

app/storage/mongo/collections/tasks.go

@@ -9,6 +9,7 @@ import (
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
 )
 
 type Task struct {
@@ -32,6 +33,14 @@ type InsertedTask struct {
 	Attempts         int        `bson:"attempts"`
 }
 
+func Count() (*int64, error) {
+	count, err := collection().CountDocuments(context.TODO(), bson.M{})
+	if err != nil {
+		return nil, err
+	}
+	return &count, nil
+}
+
 func Add(task InsertedTask) error {
 	_, err := collection().InsertOne(context.TODO(), task)
 	if err != nil {
@@ -62,7 +71,19 @@ func Take(queue string) (*Task, error) {
 	if task == nil {
 		return nil, nil
 	}
-	_, err = collection().UpdateByID(context.TODO(), task.Id, bson.M{"$set": bson.M{"taken_at": now, "attempts": task.Attempts + 1}})
+	_, err = collection().UpdateByID(
+		context.TODO(),
+		task.Id,
+		bson.M{
+			"$set": bson.M{
+				"taken_at": now,
+				"attempts": task.Attempts + 1,
+				"available_from": now.Add(
+					time.Duration(task.SecondsToExecute+task.Attempts) * time.Second,
+				),
+			},
+		},
+	)
 	if err != nil {
 		println("Error updaing")
 		println(err.Error())
@@ -78,6 +99,7 @@ func findTask(queue string, now time.Time) (*Task, error) {
 			"queue":          queue,
 			"available_from": bson.M{"$lte": now},
 		},
+		options.Find().SetSort(bson.D{{Key: "available_from", Value: 1}}).SetLimit(1),
 	)
 	if err != nil {
 		println("Error find")
@@ -94,14 +116,7 @@ func findTask(queue string, now time.Time) (*Task, error) {
 	}
 
 	for _, task := range results {
-		if task.TakenAt == nil {
-			return &task, nil
-		}
-		takenAt := *task.TakenAt
-
-		if takenAt.Add(time.Second * time.Duration(task.SecondsToExecute)).Before(now) {
-			return &task, nil
-		}
+		return &task, nil
 	}
 	return nil, nil
 }

main.go

@@ -1,15 +1,39 @@
 package main
 
 import (
+	"bytes"
 	"encoding/json"
+	"fmt"
 	"log"
 	"net/http"
+	"os"
 	"queues-go/app/routers"
 	client "queues-go/app/storage/mongo"
-	"queues-go/app/storage/redis"
+	tasks "queues-go/app/storage/mongo/collections"
+	"strconv"
+	"sync"
 	"time"
 )
 
+func writeMetric(timestamp time.Time, endpoint string, statusCode int, responseTime int, method string) {
+	loc, _ := time.LoadLocation("Europe/Moscow")
+	s := fmt.Sprintf(
+		`{"timestamp":"%s","service":"queues","environment":"%s","endpoint":"%s","status_code":%s,"response_time":%s,"method":"%s"}`,
+		timestamp.In(loc).Format("2006-01-02T15:04:05Z"),
+		os.Getenv("STAGE"),
+		endpoint,
+		strconv.Itoa(statusCode),
+		strconv.Itoa(responseTime),
+		method,
+	)
+	data := []byte(s)
+	r := bytes.NewReader(data)
+	_, err := http.Post("http://monitoring:1237/api/v1/metrics/endpoint", "application/json", r)
+	if err != nil {
+		log.Printf("Error sending metrics %s", err.Error())
+	}
+}
+
 func handlerWrapper(f func(*http.Request) (interface{}, int)) func(http.ResponseWriter, *http.Request) {
 	return func(w http.ResponseWriter, r *http.Request) {
 		start := time.Now()
@@ -25,16 +49,48 @@ func handlerWrapper(f func(*http.Request) (interface{}, int)) func(http.Response
 		} else {
 			w.WriteHeader(status)
 		}
+		go writeMetric(start, r.URL.Path, status, int(time.Since(start).Milliseconds()), r.Method)
 		log.Printf("%s %d %s", r.URL, status, time.Since(start))
 	}
 }
 
+func metricProxy(w http.ResponseWriter, r *http.Request) {
+	http.Post("http://monitoring:1237/api/v1/metrics/task", "application/json", r.Body)
+	w.WriteHeader(202)
+}
+
+func writeCount() {
+	for {
+		count, err := tasks.Count()
+		if err != nil {
+			log.Printf("Failed getting docs count: %s", err.Error())
+		} else {
+			loc, _ := time.LoadLocation("Europe/Moscow")
+			s := fmt.Sprintf(
+				`{"timestamp":"%s","service":"queues","environment":"%s","name":"tasks","count":%s}`,
+				time.Now().In(loc).Format("2006-01-02T15:04:05Z"),
+				os.Getenv("STAGE"),
+				strconv.Itoa(int(*count)),
+			)
+			data := []byte(s)
+			r := bytes.NewReader(data)
+			_, err := http.Post("http://monitoring:1237/api/v1/metrics/increment", "application/json", r)
+			if err != nil {
+				log.Printf("ERROR %s", err.Error())
+			}
+		}
+		time.Sleep(time.Second)
+	}
+}
+
 func main() {
 	client.Connect()
-	redis.Connect()
+	routers.MutexMap = make(map[string]*sync.Mutex)
 	http.HandleFunc("/api/v1/take", handlerWrapper(routers.Take))
 	http.HandleFunc("/api/v1/finish", handlerWrapper(routers.Finish))
 	http.HandleFunc("/api/v1/put", handlerWrapper(routers.Put))
+	http.HandleFunc("/api/v1/metric", metricProxy)
 	log.Printf("Server started")
+	go writeCount()
 	http.ListenAndServe(":1239", nil)
 }