Nucrea/Hermes
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #10 from Nucrea/feature/server-refactoring-07022025

Browse Source 
Feature/server refactoring 07022025
This commit is contained in:
Sergey Chubaryan 2025-02-15 09:40:16 +03:00 committed by GitHub
commit 9f735f68e0
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
29 changed files with 395 additions and 592 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cmd/backend/app.go
View File

@ -186,7 +186,7 @@ func (a *App) Run(p RunParams) {
}()
}
srv := server.New(
srv := server.NewServer(
server.NewServerOpts{
DebugMode: debugMode,
Logger: logger,

2
cmd/backend/config_defaults/config.yaml
View File

@ -1,5 +1,5 @@
port: 8080
postgres_url: "postgres://postgres:postgres@localhost:5432/postgres"
jwt_signing_key: "./jwt_signing_key"
jwt_signing_key: "./config_defaults/jwt_signing_key"
kafka_url: "localhost:9092"
kafka_topic: "backend_events"

78
cmd/backend/server/handlers/user_create_handler.go
View File

@ -2,16 +2,17 @@ package handlers
import (
"backend/internal/core/services"
httpserver "backend/internal/http_server"
"backend/pkg/logger"
"encoding/json"
"context"
"github.com/gin-gonic/gin"
)
type createUserInput struct {
Email string `json:"email"`
Password string `json:"password"`
Name string `json:"name"`
Email string `json:"email" validate:"required,email"`
Password string `json:"password" validate:"required"`
Name string `json:"name" validate:"required"`
}
type createUserOutput struct {
@ -20,54 +21,27 @@ type createUserOutput struct {
Name string `json:"name"`
}
func NewUserCreateHandler(logger logger.Logger, userService services.UserService) gin.HandlerFunc {
return func(c *gin.Context) {
ctxLogger := logger.WithContext(c)
func NewUserCreateHandler(log logger.Logger, userService services.UserService) gin.HandlerFunc {
return httpserver.WrapGin(log,
func(ctx context.Context, input createUserInput) (createUserOutput, error) {
user, err := userService.CreateUser(ctx,
services.UserCreateParams{
Email: input.Email,
Password: input.Password,
Name: input.Name,
},
)
params := createUserInput{}
if err := c.ShouldBindJSON(&params); err != nil {
ctxLogger.Error().Err(err).Msg("bad input body model")
c.Data(400, "plain/text", []byte(err.Error()))
return
}
out := createUserOutput{}
if err != nil {
return out, err
}
dto, err := userService.CreateUser(
c,
services.UserCreateParams{
Email: params.Email,
Password: params.Password,
Name: params.Name,
},
)
if err == services.ErrUserExists {
ctxLogger.Error().Err(err).Msg("user already exists")
c.Data(400, "plain/text", []byte(err.Error()))
return
}
if err == services.ErrUserBadPassword {
ctxLogger.Error().Err(err).Msg("password does not satisfy requirements")
c.Data(400, "plain/text", []byte(err.Error()))
return
}
if err != nil {
ctxLogger.Error().Err(err).Msg("unexpected create user error")
c.Data(500, "plain/text", []byte(err.Error()))
return
}
resultBody, err := json.Marshal(
createUserOutput{
Id: dto.Id,
Email: dto.Email,
Name: dto.Name,
},
)
if err != nil {
ctxLogger.Error().Err(err).Msg("marshal user model error")
c.Data(500, "plain/text", []byte(err.Error()))
return
}
c.Data(200, "application/json", resultBody)
}
return createUserOutput{
Id: user.Id,
Email: user.Email,
Name: user.Name,
}, nil
},
)
}

55
cmd/backend/server/handlers/user_login_handler.go
View File

@ -2,14 +2,15 @@ package handlers
import (
"backend/internal/core/services"
httpserver "backend/internal/http_server"
"backend/pkg/logger"
"encoding/json"
"context"
"github.com/gin-gonic/gin"
)
type loginUserInput struct {
Login string `json:"email"`
Login string `json:"email" validate:"required,email"`
Password string `json:"password"`
}
@ -17,43 +18,17 @@ type loginUserOutput struct {
Token string `json:"token"`
}
func NewUserLoginHandler(logger logger.Logger, userService services.UserService) gin.HandlerFunc {
return func(c *gin.Context) {
ctxLogger := logger.WithContext(c).WithPrefix("NewUserLoginHandler")
func NewUserLoginHandler(log logger.Logger, userService services.UserService) gin.HandlerFunc {
return httpserver.WrapGin(log,
func(ctx context.Context, input loginUserInput) (loginUserOutput, error) {
token, err := userService.AuthenticateUser(ctx, input.Login, input.Password)
if err != nil {
return loginUserOutput{}, err
}
params := loginUserInput{}
if err := c.ShouldBindJSON(&params); err != nil {
ctxLogger.Error().Err(err).Msg("bad input body model")
c.AbortWithError(400, err)
return
}
token, err := userService.AuthenticateUser(c, params.Login, params.Password)
if err == services.ErrUserNotExists {
ctxLogger.Error().Err(err).Msg("user does not exist")
c.AbortWithError(400, err)
return
}
if err == services.ErrUserWrongPassword {
ctxLogger.Error().Err(err).Msg("wrong password")
c.AbortWithError(400, err)
return
}
if err != nil {
ctxLogger.Error().Err(err).Msg("AuthenticateUser internal error")
c.AbortWithError(500, err)
return
}
resultBody, err := json.Marshal(loginUserOutput{
Token: token,
})
if err != nil {
ctxLogger.Error().Err(err).Msg("marshal json internal error")
c.AbortWithError(500, err)
return
}
c.Data(200, "application/json", resultBody)
}
return loginUserOutput{
Token: token,
}, nil
},
)
}

56
cmd/backend/server/middleware/request_log.go
View File

@ -1,56 +0,0 @@
package middleware
import (
"backend/internal/integrations"
log "backend/pkg/logger"
"time"
"github.com/gin-gonic/gin"
"github.com/google/uuid"
"go.opentelemetry.io/otel/trace"
)
func NewRequestLogMiddleware(logger log.Logger, tracer trace.Tracer, prometheus *integrations.Prometheus) gin.HandlerFunc {
return func(c *gin.Context) {
prometheus.RequestInc()
defer prometheus.RequestDec()
requestId := c.GetHeader("X-Request-Id")
if requestId == "" {
requestId = uuid.New().String()
}
c.Header("X-Request-Id", requestId)
c.Header("Access-Control-Allow-Origin", "*")
log.SetCtxRequestId(c, requestId)
path := c.Request.URL.Path
if c.Request.URL.RawQuery != "" {
path = path + "?" + c.Request.URL.RawQuery
}
start := time.Now()
c.Next()
latency := time.Since(start)
prometheus.AddRequestTime(float64(latency.Microseconds()))
method := c.Request.Method
statusCode := c.Writer.Status()
if statusCode >= 200 && statusCode < 400 {
return
}
ctxLogger := logger.WithContext(c)
if statusCode >= 400 && statusCode < 500 {
prometheus.Add4xxError()
ctxLogger.Warning().Msgf("Request %s %s %d %v", method, path, statusCode, latency)
return
}
prometheus.Add5xxError()
ctxLogger.Error().Msgf("Request %s %s %d %v", method, path, statusCode, latency)
}
}

62
cmd/backend/server/server.go
View File

@ -5,21 +5,14 @@ import (
"backend/cmd/backend/server/middleware"
"backend/cmd/backend/server/utils"
"backend/internal/core/services"
httpserver "backend/internal/http_server"
"backend/internal/integrations"
"backend/pkg/logger"
"context"
"fmt"
"net"
"github.com/gin-gonic/gin"
"go.opentelemetry.io/otel/trace"
)
type Server struct {
logger logger.Logger
ginEngine *gin.Engine
}
type NewServerOpts struct {
DebugMode bool
Logger logger.Logger
@ -28,7 +21,7 @@ type NewServerOpts struct {
Tracer trace.Tracer
}
func New(opts NewServerOpts) *Server {
func NewServer(opts NewServerOpts) *httpserver.Server {
if !opts.DebugMode {
gin.SetMode(gin.ReleaseMode)
}
@ -36,21 +29,25 @@ func New(opts NewServerOpts) *Server {
r := gin.New()
r.ContextWithFallback = true // Use it to allow getting values from c.Request.Context()
r.Static("/webapp", "./webapp")
// r.Static("/webapp", "./webapp")
r.GET("/health", handlers.NewDummyHandler())
prometheus := integrations.NewPrometheus()
r.Any("/metrics", gin.WrapH(prometheus.GetRequestHandler()))
r.Use(middleware.NewRecoveryMiddleware(opts.Logger, prometheus, opts.DebugMode))
r.Use(middleware.NewRequestLogMiddleware(opts.Logger, opts.Tracer, prometheus))
r.Use(middleware.NewTracingMiddleware(opts.Tracer))
r.Use(httpserver.NewRecoveryMiddleware(opts.Logger, prometheus, opts.DebugMode))
r.Use(httpserver.NewRequestLogMiddleware(opts.Logger, opts.Tracer, prometheus))
r.Use(httpserver.NewTracingMiddleware(opts.Tracer))
userGroup := r.Group("/user")
userGroup.POST("/create", handlers.NewUserCreateHandler(opts.Logger, opts.UserService))
userGroup.POST("/login", handlers.NewUserLoginHandler(opts.Logger, opts.UserService))
v1 := r.Group("/v1")
dummyGroup := r.Group("/dummy")
userGroup := v1.Group("/user")
{
userGroup.POST("/create", handlers.NewUserCreateHandler(opts.Logger, opts.UserService))
userGroup.POST("/login", handlers.NewUserLoginHandler(opts.Logger, opts.UserService))
}
dummyGroup := v1.Group("/dummy")
{
dummyGroup.Use(middleware.NewAuthMiddleware(opts.UserService))
dummyGroup.GET("", handlers.NewDummyHandler())
@ -60,29 +57,10 @@ func New(opts NewServerOpts) *Server {
})
}
return &Server{
logger: opts.Logger,
ginEngine: r,
}
}
func (s *Server) Run(ctx context.Context, port uint16) {
listenAddr := fmt.Sprintf("0.0.0.0:%d", port)
s.logger.Log().Msgf("server listening on %s", listenAddr)
listener, err := (&net.ListenConfig{}).Listen(ctx, "tcp", listenAddr)
if err != nil {
s.logger.Fatal().Err(err).Msg("can not create network listener")
}
go func() {
<-ctx.Done()
s.logger.Log().Msg("stopping tcp listener...")
listener.Close()
}()
err = s.ginEngine.RunListener(listener)
if err != nil && err == net.ErrClosed {
s.logger.Fatal().Err(err).Msg("server stopped with error")
}
return httpserver.New(
httpserver.NewServerOpts{
Logger: opts.Logger,
HttpServer: r,
},
)
}

31
cmd/shortlinks/grpc.go Normal file
View File

@ -0,0 +1,31 @@
package main
import (
"backend/internal/core/services"
"backend/internal/grpc_server/shortlinks"
httpserver "backend/internal/http_server"
"backend/pkg/logger"
"context"
)
func NewShortlinksGrpc(log logger.Logger, shortlinkService services.ShortlinkService, host string) *ShortlinksGrpc {
return &ShortlinksGrpc{
handler: NewCreateHandler(log, shortlinkService, host),
}
}
type ShortlinksGrpc struct {
shortlinks.UnimplementedShortlinksServer
handler httpserver.Handler[shortlinkCreateInput, shortlinkCreateOutput]
}
func (s *ShortlinksGrpc) Create(ctx context.Context, req *shortlinks.CreateRequest) (*shortlinks.CreateResponse, error) {
output, err := s.handler(ctx, shortlinkCreateInput{req.Url})
if err != nil {
return nil, err
}
return &shortlinks.CreateResponse{
Link: output.Link,
}, nil
}

83
cmd/shortlinks/handlers.go
View File

@ -2,93 +2,52 @@ package main
import (
"backend/internal/core/services"
"backend/internal/grpc_server/shortlinks"
httpserver "backend/internal/http_server"
"backend/pkg/logger"
"context"
"encoding/json"
"fmt"
"net/url"
"github.com/gin-gonic/gin"
)
type shortlinkCreateInput struct {
Url string `json:"url"`
}
type shortlinkCreateOutput struct {
Link string `json:"link"`
}
type ShortlinksGrpc struct {
shortlinks.UnimplementedShortlinksServer
log logger.Logger
host string
shortlinkService services.ShortlinkService
}
func NewCreateHandler(
log logger.Logger,
shortlinkService services.ShortlinkService,
host string,
) httpserver.Handler[shortlinkCreateInput, shortlinkCreateOutput] {
return func(ctx context.Context, input shortlinkCreateInput) (shortlinkCreateOutput, error) {
output := shortlinkCreateOutput{}
func (s *ShortlinksGrpc) Create(ctx context.Context, req *shortlinks.CreateRequest) (*shortlinks.CreateResponse, error) {
ctxLogger := s.log.WithContext(ctx)
rawUrl := req.GetUrl()
if rawUrl == "" {
ctxLogger.Error().Msg("url query param missing")
return nil, fmt.Errorf("url query param missing")
}
u, err := url.Parse(rawUrl)
if err != nil {
ctxLogger.Error().Err(err).Msg("error parsing url param")
return nil, err
}
u.Scheme = "https"
linkId, err := s.shortlinkService.CreateShortlink(ctx, u.String())
if err != nil {
ctxLogger.Error().Err(err).Msg("err creating shortlink")
return nil, err
}
return &shortlinks.CreateResponse{
Link: fmt.Sprintf("%s/s/%s", s.host, linkId),
}, nil
}
func NewShortlinkCreateHandler(logger logger.Logger, shortlinkService services.ShortlinkService, host string) gin.HandlerFunc {
return func(ctx *gin.Context) {
ctxLogger := logger.WithContext(ctx)
rawUrl := ctx.Query("url")
if rawUrl == "" {
ctxLogger.Error().Msg("url query param missing")
ctx.AbortWithError(400, fmt.Errorf("url query param missing"))
return
}
u, err := url.Parse(rawUrl)
u, err := url.Parse(input.Url)
if err != nil {
ctxLogger.Error().Err(err).Msg("error parsing url param")
ctx.Data(400, "plain/text", []byte(err.Error()))
return
return output, err
}
u.Scheme = "https"
linkId, err := shortlinkService.CreateShortlink(ctx, u.String())
if err != nil {
ctxLogger.Error().Err(err).Msg("err creating shortlink")
ctx.Data(500, "plain/text", []byte(err.Error()))
return
return output, err
}
resultBody, err := json.Marshal(shortlinkCreateOutput{
return shortlinkCreateOutput{
Link: fmt.Sprintf("%s/s/%s", host, linkId),
})
if err != nil {
ctxLogger.Error().Err(err).Msg("err marshalling shortlink")
ctx.AbortWithError(500, err)
return
}
ctx.Data(200, "application/json", resultBody)
}, nil
}
}
func NewShortlinkCreateHandler(log logger.Logger, shortlinkService services.ShortlinkService, host string) gin.HandlerFunc {
return httpserver.WrapGin(log, NewCreateHandler(log, shortlinkService, host))
}
func NewShortlinkResolveHandler(logger logger.Logger, shortlinkService services.ShortlinkService) gin.HandlerFunc {
return func(ctx *gin.Context) {
ctxLogger := logger.WithContext(ctx)

18
cmd/shortlinks/main.go
View File

@ -6,7 +6,6 @@ import (
grpcserver "backend/internal/grpc_server"
"backend/internal/grpc_server/shortlinks"
httpserver "backend/internal/http_server"
"backend/internal/http_server/middleware"
"backend/internal/integrations"
"backend/pkg/cache"
"backend/pkg/logger"
@ -94,22 +93,19 @@ func RunServer(ctx context.Context, log logger.Logger, tracer trace.Tracer, conf
ctx.Status(200)
})
r.Use(middleware.NewRecoveryMiddleware(log, prometheus, debugMode))
r.Use(middleware.NewRequestLogMiddleware(log, tracer, prometheus))
r.Use(middleware.NewTracingMiddleware(tracer))
r.Use(httpserver.NewRecoveryMiddleware(log, prometheus, debugMode))
r.Use(httpserver.NewRequestLogMiddleware(log, tracer, prometheus))
r.Use(httpserver.NewTracingMiddleware(tracer))
linkGroup := r.Group("/s")
linkGroup.POST("/new", NewShortlinkCreateHandler(log, shortlinkService, host))
linkGroup.GET("/:linkId", NewShortlinkResolveHandler(log, shortlinkService))
grpcObj := &ShortlinksGrpc{
log: log,
host: host,
shortlinkService: shortlinkService,
}
grpcUnderlying := grpc.NewServer()
shortlinks.RegisterShortlinksServer(grpcUnderlying, grpcObj)
shortlinks.RegisterShortlinksServer(
grpcUnderlying,
NewShortlinksGrpc(log, shortlinkService, host),
)
httpServer := httpserver.New(
httpserver.NewServerOpts{

2
deploy/prometheus.yml
View File

@ -34,6 +34,6 @@ scrape_configs:
- job_name: 'machine'
scrape_interval: 2s
static_configs:
- targets: ['host.docker.internal:9100']
- targets: ['node_exporter:9100']
labels:
group: 'backend'

72
docker-compose.yaml
View File

@ -56,15 +56,20 @@ services:
node_exporter:
image: quay.io/prometheus/node-exporter:latest
pid: host
command:
- '--path.rootfs=/host'
ports:
- 9100:9100
- '--path.procfs=/host/proc'
- '--path.rootfs=/rootfs'
- '--path.sysfs=/host/sys'
- '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'
volumes:
- /proc:/host/proc:ro
- /sys:/host/sys:ro
- /:/rootfs:ro
extra_hosts:
- "host.docker.internal:host-gateway"
pid: host
volumes:
- '/:/host:ro,rslave'
ports:
- 9100:9100
otel-collector:
image: otel/opentelemetry-collector-contrib:0.108.0
@ -97,12 +102,17 @@ services:
- tempo-init
kafka:
image: apache/kafka:3.8.0
image: &kafkaImage apache/kafka:3.8.0
healthcheck:
test: ["CMD-SHELL", "/opt/kafka/bin/kafka-cluster.sh cluster-id --bootstrap-server http://127.0.0.1:9092 || exit 1"]
interval: 1s
timeout: 30s
retries: 30
environment:
KAFKA_NODE_ID: 1
KAFKA_PROCESS_ROLES: broker,controller
KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9092,CONTROLLER://0.0.0.0:9093
KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092
KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092
KAFKA_CONTROLLER_LISTENER_NAMES: CONTROLLER
KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT
KAFKA_CONTROLLER_QUORUM_VOTERS: 1@localhost:9093
@ -113,18 +123,48 @@ services:
KAFKA_NUM_PARTITIONS: 3
ports:
- 9092:9092
# - 9093:9093
# backend:
# build: .
# # dockerfile: ./dockerfile
# volumes:
# - ./:/app
# ports:
# - 8080:8080
kafka-init:
image: *kafkaImage
depends_on:
kafka:
condition: service_healthy
entrypoint: >
/bin/bash -c "/opt/kafka/bin/kafka-topics.sh --bootstrap-server http://kafka:9092 --create --topic events --partitions 6"
minio:
image: quay.io/minio/minio:latest
command: ["server", "/data", "--console-address", ":9001"]
healthcheck:
test: 'mc ready local'
interval: 1s
environment:
MINIO_ROOT_USER: miniouser
MINIO_ROOT_PASSWORD: miniouser
MINIO_ACCESS_KEY: miniokey
MINIO_SECRET_KEY: miniokey
ports:
- 9000:9000
- 9001:9001
volumes:
- minio-volume:/data
minio-init:
image: quay.io/minio/mc:latest
depends_on:
- minio
entrypoint: >
/bin/sh -c "
/usr/bin/mc alias set myminio http://minio:9000 miniouser miniouser;
/usr/bin/mc mb minio/bucket;
/usr/bin/mc anonymous set public minio/bucket;
exit 0;
"
volumes:
postgres-volume:
grafana-volume:
tempo-volume:
prometheus-volume:
minio-volume:

155
internal/http_server/middleware/recovery.go
View File

@ -1,155 +0,0 @@
package middleware
// Modified recovery from gin, use own logger
import (
"backend/internal/integrations"
"backend/pkg/logger"
"bytes"
"errors"
"fmt"
"net"
"net/http"
"net/http/httputil"
"os"
"runtime"
"strings"
"time"
"github.com/gin-gonic/gin"
)
const (
reset = "\033[0m"
)
var (
dunno = []byte("???")
centerDot = []byte("·")
dot = []byte(".")
slash = []byte("/")
)
func NewRecoveryMiddleware(logger logger.Logger, prometheus *integrations.Prometheus, debugMode bool) gin.HandlerFunc {
handle := defaultHandleRecovery
return func(c *gin.Context) {
defer func() {
if err := recover(); err != nil {
prometheus.AddPanic()
// Check for a broken connection, as it is not really a
// condition that warrants a panic stack trace.
var brokenPipe bool
if ne, ok := err.(*net.OpError); ok {
var se *os.SyscallError
if errors.As(ne, &se) {
seStr := strings.ToLower(se.Error())
if strings.Contains(seStr, "broken pipe") ||
strings.Contains(seStr, "connection reset by peer") {
brokenPipe = true
}
}
}
if logger != nil {
stack := stack(3)
httpRequest, _ := httputil.DumpRequest(c.Request, false)
headers := strings.Split(string(httpRequest), "\r\n")
for idx, header := range headers {
current := strings.Split(header, ":")
if current[0] == "Authorization" {
headers[idx] = current[0] + ": *"
}
}
headersToStr := strings.Join(headers, "\r\n")
if brokenPipe {
logger.Printf("%s\n%s%s", err, headersToStr, reset)
} else if debugMode {
logger.Printf("[Recovery] %s panic recovered:\n%s\n%s\n%s%s",
timeFormat(time.Now()), headersToStr, err, stack, reset)
} else {
logger.Printf("[Recovery] %s panic recovered:\n%s\n%s%s",
timeFormat(time.Now()), err, stack, reset)
}
}
if brokenPipe {
// If the connection is dead, we can't write a status to it.
c.Error(err.(error)) //nolint: errcheck
c.Abort()
} else {
handle(c, err)
}
}
}()
c.Next()
}
}
func defaultHandleRecovery(c *gin.Context, _ any) {
c.AbortWithStatus(http.StatusInternalServerError)
}
// stack returns a nicely formatted stack frame, skipping skip frames.
func stack(skip int) []byte {
buf := new(bytes.Buffer) // the returned data
// As we loop, we open files and read them. These variables record the currently
// loaded file.
var lines [][]byte
var lastFile string
for i := skip; ; i++ { // Skip the expected number of frames
pc, file, line, ok := runtime.Caller(i)
if !ok {
break
}
// Print this much at least. If we can't find the source, it won't show.
fmt.Fprintf(buf, "%s:%d (0x%x)\n", file, line, pc)
if file != lastFile {
data, err := os.ReadFile(file)
if err != nil {
continue
}
lines = bytes.Split(data, []byte{'\n'})
lastFile = file
}
fmt.Fprintf(buf, "\t%s: %s\n", function(pc), source(lines, line))
}
return buf.Bytes()
}
// source returns a space-trimmed slice of the n'th line.
func source(lines [][]byte, n int) []byte {
n-- // in stack trace, lines are 1-indexed but our array is 0-indexed
if n < 0 || n >= len(lines) {
return dunno
}
return bytes.TrimSpace(lines[n])
}
// function returns, if possible, the name of the function containing the PC.
func function(pc uintptr) []byte {
fn := runtime.FuncForPC(pc)
if fn == nil {
return dunno
}
name := []byte(fn.Name())
// The name includes the path name to the package, which is unnecessary
// since the file name is already included. Plus, it has center dots.
// That is, we see
// runtime/debug.*T·ptrmethod
// and want
// *T.ptrmethod
// Also the package path might contain dot (e.g. code.google.com/...),
// so first eliminate the path prefix
if lastSlash := bytes.LastIndex(name, slash); lastSlash >= 0 {
name = name[lastSlash+1:]
}
if period := bytes.Index(name, dot); period >= 0 {
name = name[period+1:]
}
name = bytes.ReplaceAll(name, centerDot, dot)
return name
}
// timeFormat returns a customized time string for logger.
func timeFormat(t time.Time) string {
return t.Format("2006/01/02 - 15:04:05")
}

33
internal/http_server/middleware/tracing.go
View File

@ -1,33 +0,0 @@
package middleware
import (
"fmt"
"github.com/gin-gonic/gin"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/propagation"
"go.opentelemetry.io/otel/trace"
)
func NewTracingMiddleware(tracer trace.Tracer) gin.HandlerFunc {
prop := otel.GetTextMapPropagator()
return func(c *gin.Context) {
savedCtx := c.Request.Context()
defer func() {
c.Request = c.Request.WithContext(savedCtx)
}()
ctx := prop.Extract(savedCtx, propagation.HeaderCarrier(c.Request.Header))
ctx, span := tracer.Start(ctx, fmt.Sprintf("%s %s", c.Request.Method, c.Request.URL.Path))
defer span.End()
traceId := span.SpanContext().TraceID()
c.Header("X-Trace-Id", traceId.String())
c.Request = c.Request.WithContext(ctx)
c.Next()
}
}

2
cmd/backend/server/middleware/recovery.go → internal/http_server/recovery.go
View File

@ -1,4 +1,4 @@
package middleware
package httpserver
// Modified recovery from gin, use own logger

2
internal/http_server/middleware/request_log.go → internal/http_server/request_log.go
View File

@ -1,4 +1,4 @@
package middleware
package httpserver
import (
"backend/internal/integrations"

2
cmd/backend/server/middleware/tracing.go → internal/http_server/tracing.go
View File

@ -1,4 +1,4 @@
package middleware
package httpserver
import (
"fmt"

79
internal/http_server/wrapper.go Normal file
View File

@ -0,0 +1,79 @@
package httpserver
import (
"backend/pkg/logger"
"context"
"encoding/json"
"github.com/gin-gonic/gin"
)
type Handler[Input, Output interface{}] func(ctx context.Context, input Input) (Output, error)
type ResponseOk struct {
Status string `json:"status"`
Result interface{} `json:"result"`
}
type ResponseError struct {
Status string `json:"status"`
Error struct {
Id string `json:"id"`
Message string `json:"message"`
} `json:"error"`
}
func WrapGin[In, Out interface{}](log logger.Logger, handler Handler[In, Out]) gin.HandlerFunc {
return func(c *gin.Context) {
log := log.WithContext(c)
var input In
if err := c.ShouldBindJSON(&input); err != nil {
response := ResponseError{
Status: "error",
Error: struct {
Id string `json:"id"`
Message string `json:"message"`
}{
Id: "WrongBody",
Message: err.Error(),
},
}
body, _ := json.Marshal(response)
c.Data(400, "application/json", body)
return
}
var response interface{}
output, err := handler(c, input)
if err != nil {
log.Error().Err(err).Msg("error in request handler")
response = ResponseError{
Status: "error",
Error: struct {
Id string `json:"id"`
Message string `json:"message"`
}{
Id: "-",
Message: err.Error(),
},
}
} else {
response = ResponseOk{
Status: "success",
Result: output,
}
}
body, err := json.Marshal(response)
if err != nil {
log.Error().Err(err).Msg("marshal response error")
c.Data(500, "plain/text", []byte(err.Error()))
return
}
c.Data(200, "application/json", body)
}
}

2
internal/integrations/kafka.go
View File

@ -16,7 +16,7 @@ func NewKafka(addr, topic string) *Kafka {
Addr: kafka.TCP(addr),
Topic: topic,
Balancer: &kafka.RoundRobin{},
AllowAutoTopicCreation: true,
AllowAutoTopicCreation: false,
BatchSize: 100,
BatchTimeout: 100 * time.Millisecond,
}

84
load_tests/api.py
View File

@ -1,84 +0,0 @@
import random
import string
from locust import HttpUser, FastHttpUser
class Auth():
token: string
def __init__(self, token):
self.token = token
class User():
email: string
name: string
password: string
def __init__(self, email, password, name, token = ""):
self.email = email
self.password = password
self.name = name
self.token = token
class BackendApi():
http: FastHttpUser
def __init__(self, http: FastHttpUser):
self.http = http
def user_create(self) -> User:
email = ''.join(random.choices(string.ascii_lowercase + string.digits, k=10)) + '@test.test'
name = ''.join(random.choices(string.ascii_letters, k=10))
password = 'Abcdef1!!1'
response = self.http.client.post(
"/user/create",
json={
"email": email,
"password": password,
"name": name,
},
)
if response.status_code != 200:
raise AssertionError('can not create user')
return User(email, password, name)
def user_login(self, user: User) -> Auth:
response = self.http.client.post(
"/user/login",
json={
"email": user.email,
"password": user.password,
},
)
if response.status_code != 200:
raise AssertionError('can not login user')
token = response.json()['token']
if token == '':
raise AssertionError('empty user token')
return Auth(token)
def dummy_get(self, auth: Auth):
headers = {"X-Auth": auth.token}
response = self.http.client.get("/dummy", headers=headers)
if response.status_code != 200:
raise AssertionError('something wrong')
def health_get(self):
response = self.http.client.get("/health")
if response.status_code != 200:
raise AssertionError('something wrong')
def shortlink_create(self, url: string) -> string:
response = self.http.client.post("/s/new?url=" + url)
if response.status_code != 200:
raise AssertionError('can not login user')
link = response.json()['link']
if link == '':
raise AssertionError('empty user token')
return link

0
load_tests/.gitignore → tests/.gitignore vendored
View File

88
tests/api.py Normal file
View File

@ -0,0 +1,88 @@
import random
import string
import requests
class Requests():
def __init__(self, baseUrl):
self.baseUrl = baseUrl
def post(self, path, json = {}):
return requests.post(self.baseUrl + path, json=json)
class Auth():
token: string
def __init__(self, token):
self.token = token
class User():
id: string
email: string
name: string
password: string
def __init__(self, email, password, name, id="", token = ""):
self.email = email
self.password = password
self.name = name
self.token = token
class BackendApi():
def __init__(self, httpClient):
self.httpClient = httpClient
def parse_response(self, response):
if response.status != 200:
raise AssertionError('something wrong')
json = response.json()
if json['status'] == 'success':
if 'result' in json:
return json['result']
return None
error = json['error']
raise AssertionError(error['id'], error['message'])
def user_create(self, user: User | None) -> User:
if user == None:
email = ''.join(random.choices(string.ascii_lowercase + string.digits, k=10)) + '@test.test'
name = ''.join(random.choices(string.ascii_letters, k=10))
password = 'Abcdef1!!1'
user = User(email, password, name)
res = self.parse_response(
self.httpClient.post(
"/v1/user/create", json={
"email": user.email,
"password": user.password,
"name": user.name,
}
)
)
return User(res['email'], res['password'], res['name'], res['id'])
def user_login(self, user: User) -> Auth:
res = self.parse_response(
self.httpClient.post(
"/v1/user/login", json={
"email": user.email+"a",
"password": user.password,
},
)
)
return Auth(res['status'])
def dummy_get(self, auth: Auth):
headers = {"X-Auth": auth.token}
response = self.httpClient.get("/v1/dummy", headers=headers)
if response.status_code != 200:
raise AssertionError('something wrong')
def health_get(self):
response = self.httpClient.get("/health")
if response.status_code != 200:
raise AssertionError('something wrong')

14
tests/integration/test_user.py Normal file
View File

@ -0,0 +1,14 @@
from api import BackendApi, Requests
import requests
backendUrl = "http://localhost:8080"
class TestUser:
def test_create_user(self):
api = BackendApi(Requests(backendUrl))
api.user_create()
def test_login_user(self):
api = BackendApi(Requests(backendUrl))
user = api.user_create()
api.user_login(user)

7
load_tests/makefile → tests/makefile
View File

@ -15,7 +15,10 @@ install:
requirements:
pip freeze > requirements.txt
run-web:
locust -f tests,loads --class-picker --host http://localhost:8080 --processes 16
run-integration:
python3 -m pytest integration/
run-performance-web:
locust -f performance --class-picker --host http://localhost:8080 --processes 16

10
load_tests/tests/dummy.py → tests/performance/dummy.py
View File

@ -3,15 +3,13 @@ from locust import FastHttpUser, task
from api import BackendApi, Auth
class DummyGet(FastHttpUser):
api: BackendApi
auth: Auth
def on_start(self):
self.api = BackendApi(self.client)
user = self.api.user_create()
self.auth = self.api.user_login(user)
@task
def dummy_test(self):
self.api.dummy_get(self.auth)
def on_start(self):
self.api = BackendApi(self)
user = self.api.user_create()
self.auth = self.api.user_login(user)

6
load_tests/tests/health.py → tests/performance/health.py
View File

@ -3,11 +3,9 @@ from locust import FastHttpUser, task
from api import BackendApi
class HealthGet(FastHttpUser):
api: BackendApi
def on_start(self):
self.api = BackendApi(self.client)
@task
def user_create_test(self):
self.api.health_get()
def on_start(self):
self.api = BackendApi(self)

6
load_tests/loads/low_load.py → tests/performance/low_load.py
View File

@ -1,9 +1,9 @@
from locust import LoadTestShape
class LowLoad(LoadTestShape):
time_limit = 600
spawn_rate = 5
max_users = 100
time_limit = 60
spawn_rate = 2
max_users = 10
def tick(self) -> (tuple[float, int] | None):
user_count = self.spawn_rate * self.get_run_time()

8
load_tests/tests/shortlink.py → tests/performance/shortlink.py
View File

@ -3,11 +3,9 @@ from locust import FastHttpUser, task
from api import BackendApi
class ShortlinkCreate(FastHttpUser):
api: BackendApi
def on_start(self):
self.api = BackendApi(self.client)
@task
def user_create_test(self):
self.api.shortlink_create("https://ya.ru")
def on_start(self):
self.api = BackendApi(self)
self.api.shortlink_create("https://example.com")

15
load_tests/tests/user.py → tests/performance/user.py
View File

@ -3,23 +3,18 @@ from locust import FastHttpUser, task
from api import BackendApi, User
class UserCreate(FastHttpUser):
api: BackendApi
def on_start(self):
self.api = BackendApi(self.client)
@task
def user_create_test(self):
self.api.user_create()
def on_start(self):
self.api = BackendApi(self)
class UserLogin(FastHttpUser):
api: BackendApi
user: User
def on_start(self):
self.api = BackendApi(self)
self.user = self.api.user_create()
@task
def user_create_test(self):
self.api.user_login(self.user)
def on_start(self):
self.api = BackendApi(self)
self.user = self.api.user_create()

5
load_tests/requirements.txt → tests/requirements.txt
View File

@ -4,6 +4,7 @@ certifi==2024.7.4
charset-normalizer==3.3.2
click==8.1.7
ConfigArgParse==1.7
exceptiongroup==1.2.2
Flask==3.0.3
Flask-Cors==4.0.1
Flask-Login==0.6.3
@ -11,12 +12,16 @@ gevent==24.2.1
geventhttpclient==2.3.1
greenlet==3.0.3
idna==3.7
iniconfig==2.0.0
itsdangerous==2.2.0
Jinja2==3.1.4
locust==2.31.3
MarkupSafe==2.1.5
msgpack==1.0.8
packaging==24.2
pluggy==1.5.0
psutil==6.0.0
pytest==8.3.4
pyzmq==26.1.0
requests==2.32.3
tomli==2.0.1