jan/openreplay
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Moved http handlers to a separate dir

Browse source
This commit is contained in:
Alexander Zavorotynskiy 2022-05-02 15:05:45 +02:00
parent f01ef3ea03
commit c347198fc1
11 changed files with 117 additions and 108 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
backend/cmd/http/main.go
View file

@ -2,7 +2,9 @@ package main
import (
"log"
"openreplay/backend/internal/config"
"openreplay/backend/internal/http"
"openreplay/backend/internal/router"
"openreplay/backend/pkg/db/cache"
"openreplay/backend/pkg/db/postgres"
"openreplay/backend/pkg/pprof"
@ -17,7 +19,7 @@ func main() {
pprof.StartProfilingServer()
// Load configuration
cfg := http.NewConfig()
cfg := config.New()
// Connect to queue
producer := queue.NewProducer()
@ -31,7 +33,7 @@ func main() {
services := http.NewServiceBuilder(cfg, producer, dbConn)
// Init server's routes
router, err := http.NewRouter(cfg, services)
router, err := router.NewRouter(cfg, services)
if err != nil {
log.Fatalf("failed while creating engine: %s", err)
}

10
backend/internal/http/config.go → backend/internal/config/config.go
View file

@ -1,11 +1,11 @@
package http
package config
import (
"openreplay/backend/pkg/env"
"time"
)
type config struct {
type Config struct {
HTTPHost string
HTTPPort string
HTTPTimeout time.Duration
@ -25,9 +25,9 @@ type config struct {
WorkerID uint16
}
func NewConfig() *config {
return &config{
HTTPHost: "",
func New() *Config {
return &Config{
HTTPHost: "", // empty by default
HTTPPort: env.String("HTTP_PORT"),
HTTPTimeout: time.Second * 60,
TopicRawWeb: env.String("TOPIC_RAW_WEB"),

6
backend/internal/http/model.go
View file

@ -1,6 +1,6 @@
package http
type startSessionRequest struct {
type StartSessionRequest struct {
Token string `json:"token"`
UserUUID *string `json:"userUUID"`
RevID string `json:"revID"`
@ -14,7 +14,7 @@ type startSessionRequest struct {
UserID string `json:"userID"`
}
type startSessionResponse struct {
type StartSessionResponse struct {
Timestamp int64 `json:"timestamp"`
Delay int64 `json:"delay"`
Token string `json:"token"`
@ -23,7 +23,7 @@ type startSessionResponse struct {
BeaconSizeLimit int64 `json:"beaconSizeLimit"`
}
type notStartedRequest struct {
type NotStartedRequest struct {
ProjectKey *string `json:"projectKey"`
TrackerVersion string `json:"trackerVersion"`
DoNotTrack bool `json:"DoNotTrack"`

6
backend/internal/http/response.go
View file

@ -6,7 +6,7 @@ import (
"net/http"
)
func responseWithJSON(w http.ResponseWriter, res interface{}) {
func ResponseWithJSON(w http.ResponseWriter, res interface{}) {
body, err := json.Marshal(res)
if err != nil {
log.Println(err)
@ -15,10 +15,10 @@ func responseWithJSON(w http.ResponseWriter, res interface{}) {
w.Write(body)
}
func responseWithError(w http.ResponseWriter, code int, err error) {
func ResponseWithError(w http.ResponseWriter, code int, err error) {
type response struct {
Error string `json:"error"`
}
w.WriteHeader(code)
responseWithJSON(w, &response{err.Error()})
ResponseWithJSON(w, &response{err.Error()})
}

35
backend/internal/http/service.go
View file

@ -1,6 +1,7 @@
package http
import (
"openreplay/backend/internal/config"
"openreplay/backend/internal/http/geoip"
"openreplay/backend/internal/http/uaparser"
"openreplay/backend/pkg/db/cache"
@ -12,25 +13,25 @@ import (
)
type ServiceBuilder struct {
pgconn *cache.PGCache
producer types.Producer
rewriter *assets.Rewriter
flaker *flakeid.Flaker
uaParser *uaparser.UAParser
geoIP *geoip.GeoIP
tokenizer *token.Tokenizer
s3 *storage.S3
Pgconn *cache.PGCache
Producer types.Producer
Rewriter *assets.Rewriter
Flaker *flakeid.Flaker
UaParser *uaparser.UAParser
GeoIP *geoip.GeoIP
Tokenizer *token.Tokenizer
S3 *storage.S3
}
func NewServiceBuilder(cfg *config, producer types.Producer, pgconn *cache.PGCache) *ServiceBuilder {
func NewServiceBuilder(cfg *config.Config, producer types.Producer, pgconn *cache.PGCache) *ServiceBuilder {
return &ServiceBuilder{
pgconn: pgconn,
producer: producer,
rewriter: assets.NewRewriter(cfg.AssetsOrigin),
s3: storage.NewS3(cfg.AWSRegion, cfg.S3BucketIOSImages),
tokenizer: token.NewTokenizer(cfg.TokenSecret),
uaParser: uaparser.NewUAParser(cfg.UAParserFile),
geoIP: geoip.NewGeoIP(cfg.MaxMinDBFile),
flaker: flakeid.NewFlaker(cfg.WorkerID),
Pgconn: pgconn,
Producer: producer,
Rewriter: assets.NewRewriter(cfg.AssetsOrigin),
S3: storage.NewS3(cfg.AWSRegion, cfg.S3BucketIOSImages),
Tokenizer: token.NewTokenizer(cfg.TokenSecret),
UaParser: uaparser.NewUAParser(cfg.UAParserFile),
GeoIP: geoip.NewGeoIP(cfg.MaxMinDBFile),
Flaker: flakeid.NewFlaker(cfg.WorkerID),
}
}

8
backend/internal/http/assets.go → backend/internal/router/assets.go
View file

@ -1,4 +1,4 @@
package http
package router
import (
"openreplay/backend/pkg/messages"
@ -7,7 +7,7 @@ import (
func (e *Router) sendAssetForCache(sessionID uint64, baseURL string, relativeURL string) {
if fullURL, cacheable := assets.GetFullCachableURL(baseURL, relativeURL); cacheable {
e.services.producer.Produce(e.cfg.TopicCache, sessionID, messages.Encode(&messages.AssetCache{
e.services.Producer.Produce(e.cfg.TopicCache, sessionID, messages.Encode(&messages.AssetCache{
URL: fullURL,
}))
}
@ -22,7 +22,7 @@ func (e *Router) sendAssetsForCacheFromCSS(sessionID uint64, baseURL string, css
func (e *Router) handleURL(sessionID uint64, baseURL string, url string) string {
if e.cfg.CacheAssets {
e.sendAssetForCache(sessionID, baseURL, url)
return e.services.rewriter.RewriteURL(sessionID, baseURL, url)
return e.services.Rewriter.RewriteURL(sessionID, baseURL, url)
}
return assets.ResolveURL(baseURL, url)
}
@ -30,7 +30,7 @@ func (e *Router) handleURL(sessionID uint64, baseURL string, url string) string
func (e *Router) handleCSS(sessionID uint64, baseURL string, css string) string {
if e.cfg.CacheAssets {
e.sendAssetsForCacheFromCSS(sessionID, baseURL, css)
return e.services.rewriter.RewriteCSS(sessionID, baseURL, css)
return e.services.Rewriter.RewriteCSS(sessionID, baseURL, css)
}
return assets.ResolveCSS(baseURL, css)
}

62
backend/internal/http/handlers-ios.go → backend/internal/router/handlers-ios.go
View file

@ -1,4 +1,4 @@
package http
package router
import (
"encoding/json"
@ -6,6 +6,8 @@ import (
"log"
"math/rand"
"net/http"
http2 "openreplay/backend/internal/http"
"openreplay/backend/internal/uuid"
"strconv"
"time"
@ -39,52 +41,52 @@ func (e *Router) startSessionHandlerIOS(w http.ResponseWriter, r *http.Request)
body := http.MaxBytesReader(w, r.Body, e.cfg.JsonSizeLimit)
defer body.Close()
if err := json.NewDecoder(body).Decode(req); err != nil {
responseWithError(w, http.StatusBadRequest, err)
http2.ResponseWithError(w, http.StatusBadRequest, err)
return
}
if req.ProjectKey == nil {
responseWithError(w, http.StatusForbidden, errors.New("ProjectKey value required"))
http2.ResponseWithError(w, http.StatusForbidden, errors.New("ProjectKey value required"))
return
}
p, err := e.services.pgconn.GetProjectByKey(*req.ProjectKey)
p, err := e.services.Pgconn.GetProjectByKey(*req.ProjectKey)
if err != nil {
if postgres.IsNoRowsErr(err) {
responseWithError(w, http.StatusNotFound, errors.New("Project doesn't exist or is not active"))
http2.ResponseWithError(w, http.StatusNotFound, errors.New("Project doesn't exist or is not active"))
} else {
responseWithError(w, http.StatusInternalServerError, err) // TODO: send error here only on staging
http2.ResponseWithError(w, http.StatusInternalServerError, err) // TODO: send error here only on staging
}
return
}
userUUID := getUUID(req.UserUUID)
tokenData, err := e.services.tokenizer.Parse(req.Token)
userUUID := uuid.GetUUID(req.UserUUID)
tokenData, err := e.services.Tokenizer.Parse(req.Token)
if err != nil { // Starting the new one
dice := byte(rand.Intn(100)) // [0, 100)
if dice >= p.SampleRate {
responseWithError(w, http.StatusForbidden, errors.New("cancel"))
http2.ResponseWithError(w, http.StatusForbidden, errors.New("cancel"))
return
}
ua := e.services.uaParser.ParseFromHTTPRequest(r)
ua := e.services.UaParser.ParseFromHTTPRequest(r)
if ua == nil {
responseWithError(w, http.StatusForbidden, errors.New("browser not recognized"))
http2.ResponseWithError(w, http.StatusForbidden, errors.New("browser not recognized"))
return
}
sessionID, err := e.services.flaker.Compose(uint64(startTime.UnixMilli()))
sessionID, err := e.services.Flaker.Compose(uint64(startTime.UnixMilli()))
if err != nil {
responseWithError(w, http.StatusInternalServerError, err)
http2.ResponseWithError(w, http.StatusInternalServerError, err)
return
}
// TODO: if EXPIRED => send message for two sessions association
expTime := startTime.Add(time.Duration(p.MaxSessionDuration) * time.Millisecond)
tokenData = &token.TokenData{sessionID, expTime.UnixMilli()}
country := e.services.geoIP.ExtractISOCodeFromHTTPRequest(r)
country := e.services.GeoIP.ExtractISOCodeFromHTTPRequest(r)
// The difference with web is mostly here:
e.services.producer.Produce(e.cfg.TopicRawIOS, tokenData.ID, Encode(&IOSSessionStart{
e.services.Producer.Produce(e.cfg.TopicRawIOS, tokenData.ID, Encode(&IOSSessionStart{
Timestamp: req.Timestamp,
ProjectID: uint64(p.ProjectID),
TrackerVersion: req.TrackerVersion,
@ -92,14 +94,14 @@ func (e *Router) startSessionHandlerIOS(w http.ResponseWriter, r *http.Request)
UserUUID: userUUID,
UserOS: "IOS",
UserOSVersion: req.UserOSVersion,
UserDevice: MapIOSDevice(req.UserDevice),
UserDeviceType: GetIOSDeviceType(req.UserDevice),
UserDevice: http2.MapIOSDevice(req.UserDevice),
UserDeviceType: http2.GetIOSDeviceType(req.UserDevice),
UserCountry: country,
}))
}
responseWithJSON(w, &response{
Token: e.services.tokenizer.Compose(*tokenData),
http2.ResponseWithJSON(w, &response{
Token: e.services.Tokenizer.Compose(*tokenData),
UserUUID: userUUID,
SessionID: strconv.FormatUint(tokenData.ID, 10),
BeaconSizeLimit: e.cfg.BeaconSizeLimit,
@ -107,18 +109,18 @@ func (e *Router) startSessionHandlerIOS(w http.ResponseWriter, r *http.Request)
}
func (e *Router) pushMessagesHandlerIOS(w http.ResponseWriter, r *http.Request) {
sessionData, err := e.services.tokenizer.ParseFromHTTPRequest(r)
sessionData, err := e.services.Tokenizer.ParseFromHTTPRequest(r)
if err != nil {
responseWithError(w, http.StatusUnauthorized, err)
http2.ResponseWithError(w, http.StatusUnauthorized, err)
return
}
e.pushMessages(w, r, sessionData.ID, e.cfg.TopicRawIOS)
}
func (e *Router) pushLateMessagesHandlerIOS(w http.ResponseWriter, r *http.Request) {
sessionData, err := e.services.tokenizer.ParseFromHTTPRequest(r)
sessionData, err := e.services.Tokenizer.ParseFromHTTPRequest(r)
if err != nil && err != token.EXPIRED {
responseWithError(w, http.StatusUnauthorized, err)
http2.ResponseWithError(w, http.StatusUnauthorized, err)
return
}
// Check timestamps here?
@ -128,9 +130,9 @@ func (e *Router) pushLateMessagesHandlerIOS(w http.ResponseWriter, r *http.Reque
func (e *Router) imagesUploadHandlerIOS(w http.ResponseWriter, r *http.Request) {
log.Printf("recieved imagerequest")
sessionData, err := e.services.tokenizer.ParseFromHTTPRequest(r)
sessionData, err := e.services.Tokenizer.ParseFromHTTPRequest(r)
if err != nil { // Should accept expired token?
responseWithError(w, http.StatusUnauthorized, err)
http2.ResponseWithError(w, http.StatusUnauthorized, err)
return
}
@ -138,18 +140,18 @@ func (e *Router) imagesUploadHandlerIOS(w http.ResponseWriter, r *http.Request)
defer r.Body.Close()
err = r.ParseMultipartForm(1e6) // ~1Mb
if err == http.ErrNotMultipart || err == http.ErrMissingBoundary {
responseWithError(w, http.StatusUnsupportedMediaType, err)
http2.ResponseWithError(w, http.StatusUnsupportedMediaType, err)
// } else if err == multipart.ErrMessageTooLarge // if non-files part exceeds 10 MB
} else if err != nil {
responseWithError(w, http.StatusInternalServerError, err) // TODO: send error here only on staging
http2.ResponseWithError(w, http.StatusInternalServerError, err) // TODO: send error here only on staging
}
if r.MultipartForm == nil {
responseWithError(w, http.StatusInternalServerError, errors.New("Multipart not parsed"))
http2.ResponseWithError(w, http.StatusInternalServerError, errors.New("Multipart not parsed"))
}
if len(r.MultipartForm.Value["projectKey"]) == 0 {
responseWithError(w, http.StatusBadRequest, errors.New("projectKey parameter missing")) // status for missing/wrong parameter?
http2.ResponseWithError(w, http.StatusBadRequest, errors.New("projectKey parameter missing")) // status for missing/wrong parameter?
return
}
@ -164,7 +166,7 @@ func (e *Router) imagesUploadHandlerIOS(w http.ResponseWriter, r *http.Request)
key := prefix + fileHeader.Filename
log.Printf("Uploading image... %v", key)
go func() { //TODO: mime type from header
if err := e.services.s3.Upload(file, key, "image/jpeg", false); err != nil {
if err := e.services.S3.Upload(file, key, "image/jpeg", false); err != nil {
log.Printf("Upload ios screen error. %v", err)
}
}()

66
backend/internal/http/handlers-web.go → backend/internal/router/handlers-web.go
View file

@ -1,4 +1,4 @@
package http
package router
import (
"bytes"
@ -7,6 +7,8 @@ import (
"log"
"math/rand"
"net/http"
http2 "openreplay/backend/internal/http"
"openreplay/backend/internal/uuid"
"strconv"
"time"
@ -20,58 +22,58 @@ func (e *Router) startSessionHandlerWeb(w http.ResponseWriter, r *http.Request)
// Check request body
if r.Body == nil {
responseWithError(w, http.StatusBadRequest, errors.New("request body is empty"))
http2.ResponseWithError(w, http.StatusBadRequest, errors.New("request body is empty"))
}
body := http.MaxBytesReader(w, r.Body, e.cfg.JsonSizeLimit)
defer body.Close()
// Parse request body
req := &startSessionRequest{}
req := &http2.StartSessionRequest{}
if err := json.NewDecoder(body).Decode(req); err != nil {
responseWithError(w, http.StatusBadRequest, err)
http2.ResponseWithError(w, http.StatusBadRequest, err)
return
}
// Handler's logic
if req.ProjectKey == nil {
responseWithError(w, http.StatusForbidden, errors.New("ProjectKey value required"))
http2.ResponseWithError(w, http.StatusForbidden, errors.New("ProjectKey value required"))
return
}
p, err := e.services.pgconn.GetProjectByKey(*req.ProjectKey)
p, err := e.services.Pgconn.GetProjectByKey(*req.ProjectKey)
if err != nil {
if postgres.IsNoRowsErr(err) {
responseWithError(w, http.StatusNotFound, errors.New("Project doesn't exist or capture limit has been reached"))
http2.ResponseWithError(w, http.StatusNotFound, errors.New("Project doesn't exist or capture limit has been reached"))
} else {
responseWithError(w, http.StatusInternalServerError, err) // TODO: send error here only on staging
http2.ResponseWithError(w, http.StatusInternalServerError, err) // TODO: send error here only on staging
}
return
}
userUUID := getUUID(req.UserUUID)
tokenData, err := e.services.tokenizer.Parse(req.Token)
userUUID := uuid.GetUUID(req.UserUUID)
tokenData, err := e.services.Tokenizer.Parse(req.Token)
if err != nil || req.Reset { // Starting the new one
dice := byte(rand.Intn(100)) // [0, 100)
if dice >= p.SampleRate {
responseWithError(w, http.StatusForbidden, errors.New("cancel"))
http2.ResponseWithError(w, http.StatusForbidden, errors.New("cancel"))
return
}
ua := e.services.uaParser.ParseFromHTTPRequest(r)
ua := e.services.UaParser.ParseFromHTTPRequest(r)
if ua == nil {
responseWithError(w, http.StatusForbidden, errors.New("browser not recognized"))
http2.ResponseWithError(w, http.StatusForbidden, errors.New("browser not recognized"))
return
}
sessionID, err := e.services.flaker.Compose(uint64(startTime.UnixNano() / 1e6))
sessionID, err := e.services.Flaker.Compose(uint64(startTime.UnixNano() / 1e6))
if err != nil {
responseWithError(w, http.StatusInternalServerError, err)
http2.ResponseWithError(w, http.StatusInternalServerError, err)
return
}
// TODO: if EXPIRED => send message for two sessions association
expTime := startTime.Add(time.Duration(p.MaxSessionDuration) * time.Millisecond)
tokenData = &token.TokenData{ID: sessionID, ExpTime: expTime.UnixNano() / 1e6}
e.services.producer.Produce(e.cfg.TopicRawWeb, tokenData.ID, Encode(&SessionStart{
e.services.Producer.Produce(e.cfg.TopicRawWeb, tokenData.ID, Encode(&SessionStart{
Timestamp: req.Timestamp,
ProjectID: uint64(p.ProjectID),
TrackerVersion: req.TrackerVersion,
@ -84,15 +86,15 @@ func (e *Router) startSessionHandlerWeb(w http.ResponseWriter, r *http.Request)
UserBrowserVersion: ua.BrowserVersion,
UserDevice: ua.Device,
UserDeviceType: ua.DeviceType,
UserCountry: e.services.geoIP.ExtractISOCodeFromHTTPRequest(r),
UserCountry: e.services.GeoIP.ExtractISOCodeFromHTTPRequest(r),
UserDeviceMemorySize: req.DeviceMemory,
UserDeviceHeapSize: req.JsHeapSizeLimit,
UserID: req.UserID,
}))
}
responseWithJSON(w, &startSessionResponse{
Token: e.services.tokenizer.Compose(*tokenData),
http2.ResponseWithJSON(w, &http2.StartSessionResponse{
Token: e.services.Tokenizer.Compose(*tokenData),
UserUUID: userUUID,
SessionID: strconv.FormatUint(tokenData.ID, 10),
BeaconSizeLimit: e.cfg.BeaconSizeLimit,
@ -101,15 +103,15 @@ func (e *Router) startSessionHandlerWeb(w http.ResponseWriter, r *http.Request)
func (e *Router) pushMessagesHandlerWeb(w http.ResponseWriter, r *http.Request) {
// Check authorization
sessionData, err := e.services.tokenizer.ParseFromHTTPRequest(r)
sessionData, err := e.services.Tokenizer.ParseFromHTTPRequest(r)
if err != nil {
responseWithError(w, http.StatusUnauthorized, err)
http2.ResponseWithError(w, http.StatusUnauthorized, err)
return
}
// Check request body
if r.Body == nil {
responseWithError(w, http.StatusBadRequest, errors.New("request body is empty"))
http2.ResponseWithError(w, http.StatusBadRequest, errors.New("request body is empty"))
}
body := http.MaxBytesReader(w, r.Body, e.cfg.BeaconSizeLimit)
defer body.Close()
@ -148,12 +150,12 @@ func (e *Router) pushMessagesHandlerWeb(w http.ResponseWriter, r *http.Request)
handledMessages.Write(msg.Encode())
})
if err != nil {
responseWithError(w, http.StatusForbidden, err)
http2.ResponseWithError(w, http.StatusForbidden, err)
return
}
// Send processed messages to queue as array of bytes
err = e.services.producer.Produce(e.cfg.TopicRawWeb, sessionData.ID, handledMessages.Bytes())
err = e.services.Producer.Produce(e.cfg.TopicRawWeb, sessionData.ID, handledMessages.Bytes())
if err != nil {
log.Printf("can't send processed messages to queue: %s", err)
}
@ -164,30 +166,30 @@ func (e *Router) pushMessagesHandlerWeb(w http.ResponseWriter, r *http.Request)
func (e *Router) notStartedHandlerWeb(w http.ResponseWriter, r *http.Request) {
// Check request body
if r.Body == nil {
responseWithError(w, http.StatusBadRequest, errors.New("request body is empty"))
http2.ResponseWithError(w, http.StatusBadRequest, errors.New("request body is empty"))
}
body := http.MaxBytesReader(w, r.Body, e.cfg.JsonSizeLimit)
defer body.Close()
// Parse request body
req := &notStartedRequest{}
req := &http2.NotStartedRequest{}
if err := json.NewDecoder(body).Decode(req); err != nil {
responseWithError(w, http.StatusBadRequest, err)
http2.ResponseWithError(w, http.StatusBadRequest, err)
return
}
// Handler's logic
if req.ProjectKey == nil {
responseWithError(w, http.StatusForbidden, errors.New("ProjectKey value required"))
http2.ResponseWithError(w, http.StatusForbidden, errors.New("ProjectKey value required"))
return
}
ua := e.services.uaParser.ParseFromHTTPRequest(r) // TODO?: insert anyway
ua := e.services.UaParser.ParseFromHTTPRequest(r) // TODO?: insert anyway
if ua == nil {
responseWithError(w, http.StatusForbidden, errors.New("browser not recognized"))
http2.ResponseWithError(w, http.StatusForbidden, errors.New("browser not recognized"))
return
}
country := e.services.geoIP.ExtractISOCodeFromHTTPRequest(r)
err := e.services.pgconn.InsertUnstartedSession(postgres.UnstartedSession{
country := e.services.GeoIP.ExtractISOCodeFromHTTPRequest(r)
err := e.services.Pgconn.InsertUnstartedSession(postgres.UnstartedSession{
ProjectKey: *req.ProjectKey,
TrackerVersion: req.TrackerVersion,
DoNotTrack: req.DoNotTrack,

12
backend/internal/http/handlers.go → backend/internal/router/handlers.go
View file

@ -1,12 +1,12 @@
package http
package router
import (
gzip "github.com/klauspost/pgzip"
"io"
"io/ioutil"
"log"
"net/http"
gzip "github.com/klauspost/pgzip"
http2 "openreplay/backend/internal/http"
)
func (e *Router) pushMessages(w http.ResponseWriter, r *http.Request, sessionID uint64, topicName string) {
@ -20,7 +20,7 @@ func (e *Router) pushMessages(w http.ResponseWriter, r *http.Request, sessionID
reader, err = gzip.NewReader(body)
if err != nil {
responseWithError(w, http.StatusInternalServerError, err) // TODO: stage-dependent responce
http2.ResponseWithError(w, http.StatusInternalServerError, err) // TODO: stage-dependent responce
return
}
log.Println("Gzip reader init", reader)
@ -31,9 +31,9 @@ func (e *Router) pushMessages(w http.ResponseWriter, r *http.Request, sessionID
log.Println("Reader after switch:", reader)
buf, err := ioutil.ReadAll(reader)
if err != nil {
responseWithError(w, http.StatusInternalServerError, err) // TODO: send error here only on staging
http2.ResponseWithError(w, http.StatusInternalServerError, err) // TODO: send error here only on staging
return
}
e.services.producer.Produce(topicName, sessionID, buf) // What if not able to send?
e.services.Producer.Produce(topicName, sessionID, buf) // What if not able to send?
w.WriteHeader(http.StatusOK)
}

10
backend/internal/http/router.go → backend/internal/router/router.go
View file

@ -1,18 +1,20 @@
package http
package router
import (
"github.com/gorilla/mux"
"log"
"net/http"
"openreplay/backend/internal/config"
http2 "openreplay/backend/internal/http"
)
type Router struct {
router *mux.Router
cfg *config
services *ServiceBuilder
cfg *config.Config
services *http2.ServiceBuilder
}
func NewRouter(cfg *config, services *ServiceBuilder) (*Router, error) {
func NewRouter(cfg *config.Config, services *http2.ServiceBuilder) (*Router, error) {
e := &Router{
cfg: cfg,
services: services,

4
backend/internal/http/uuid.go → backend/internal/uuid/uuid.go
View file

@ -1,10 +1,10 @@
package http
package uuid
import (
"github.com/google/uuid"
)
func getUUID(u *string) string {
func GetUUID(u *string) string {
if u != nil {
_, err := uuid.Parse(*u)
if err == nil {