From 392cdbfd4d6262c5e32d31d005824921ecf9d790 Mon Sep 17 00:00:00 2001 From: nquidox Date: Tue, 30 Sep 2025 15:33:00 +0300 Subject: [PATCH 01/10] dockerfile created --- .dockerignore | 5 +++++ Dockerfile | 34 ++++++++++++++++++++++++++++++++++ 2 files changed, 39 insertions(+) create mode 100644 .dockerignore create mode 100644 Dockerfile diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..60bb581 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,5 @@ +.idea +.gitignore +api.env +gen-swag.sh +migrations.sql diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..3145ef8 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,34 @@ +FROM golang:1.25.1-alpine3.22 AS builder + +RUN apk add --no-cache \ + bash \ + curl \ + git \ + ca-certificates + + +RUN apk add --no-cache tzdata + +WORKDIR /app +COPY go.mod go.sum ./ +RUN go mod download +COPY . . +RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main ./cmd + + +FROM alpine:3.22 + +RUN apk add --no-cache \ + bash \ + curl \ + ca-certificates \ + tzdata + +COPY --from=builder /app/main /usr/local/bin/app + + +RUN chmod +x /usr/local/bin/app +RUN adduser -D -s /bin/bash appuser +USER appuser + +ENTRYPOINT ["app"] \ No newline at end of file From 9a83bac140da889b85942527921d451eb724c9b5 Mon Sep 17 00:00:00 2001 From: nquidox Date: Tue, 30 Sep 2025 16:59:51 +0300 Subject: [PATCH 02/10] update --- .dockerignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.dockerignore b/.dockerignore index 60bb581..a970c83 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,4 +1,5 @@ .idea +.git .gitignore api.env gen-swag.sh From 62337d39430f033e60238eba744303833bac2784 Mon Sep 17 00:00:00 2001 From: nquidox Date: Tue, 30 Sep 2025 17:00:04 +0300 Subject: [PATCH 03/10] action added --- .forgejo/workflows/make-image.yml | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 .forgejo/workflows/make-image.yml diff --git a/.forgejo/workflows/make-image.yml b/.forgejo/workflows/make-image.yml new file mode 100644 index 0000000..3dd5f21 --- /dev/null +++ b/.forgejo/workflows/make-image.yml @@ -0,0 +1,31 @@ +on: + push: + tags: + - 'v[0-9]+*' + +env: + IMAGE_NAME: repo-app + +jobs: + docker: + name: Make image + runs-on: docker + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Login to Docker Registry + run: echo "${{ secrets.DOCKER_PASSWORD }}" | docker login repo.nqws.ru -u "${{ secrets.DOCKER_USERNAME }}" --password-stdin + + - name: Extract version from tag + id: extract_version + run: | + VERSION=${GITHUB_REF#refs/tags/} + echo "VERSION=${VERSION}" >> $GITHUB_ENV + + - name: Make image + run: | + docker buildx build --platform linux/amd64 \ + --tag repo.nqws.ru/merch-tracker/repo-app-v2:latest \ + --tag repo.nqws.ru/merch-tracker/repo-app-v2:${{ env.VERSION }} \ + --push . From 7dd4a6830e55a40eec3b55b8509599891a2be2b2 Mon Sep 17 00:00:00 2001 From: nquidox Date: Tue, 30 Sep 2025 18:47:23 +0300 Subject: [PATCH 04/10] release option fix --- internal/router/handler.go | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/internal/router/handler.go b/internal/router/handler.go index b197ec3..70e882a 100644 --- a/internal/router/handler.go +++ b/internal/router/handler.go @@ -28,8 +28,13 @@ type Deps struct { } func NewRouter(deps Deps) interfaces.Router { - engine := gin.Default() + if deps.GinMode == "release" { + gin.SetMode(gin.ReleaseMode) + } else { + gin.SetMode(gin.DebugMode) + } + engine := gin.Default() if deps.GinMode == "release" { gin.SetMode(gin.ReleaseMode) err := engine.SetTrustedProxies([]string{"172.20.0.0/16"}) From a4097706de7e5eb8198b51189841c631dfad626b Mon Sep 17 00:00:00 2001 From: nquidox Date: Wed, 1 Oct 2025 11:00:39 +0300 Subject: [PATCH 05/10] merch update method refactor --- internal/api/merch/controller.go | 10 ++++----- internal/api/merch/dto.go | 7 ++++++ internal/api/merch/model.go | 9 ++++---- internal/api/merch/repository.go | 37 +++++++++++++++----------------- internal/api/merch/service.go | 13 +++++++++-- 5 files changed, 44 insertions(+), 32 deletions(-) diff --git a/internal/api/merch/controller.go b/internal/api/merch/controller.go index 2e31a66..2b23c34 100644 --- a/internal/api/merch/controller.go +++ b/internal/api/merch/controller.go @@ -134,16 +134,16 @@ func (co *controller) getAllMerch(c *gin.Context) { // @Description Обновить информацию про мерч по его uuid в json-е // @Tags Merch // @Security BearerAuth -// @Param body body MerchDTO true "merch_uuid" -// @Success 200 {object} MerchDTO +// @Param body body UpdateMerchDTO true "merch_uuid" +// @Success 200 // @Failure 400 {object} responses.ErrorResponse400 // @Failure 500 {object} responses.ErrorResponse500 -// @Router /merch/{uuid} [put] +// @Router /merch/ [put] func (co *controller) updateMerch(c *gin.Context) { - var payload MerchDTO + var payload UpdateMerchDTO if err := c.ShouldBind(&payload); err != nil { c.JSON(http.StatusBadRequest, responses.ErrorResponse400{Error: err.Error()}) - log.WithError(err).Error("Merch | Failed to bind JSON on add merch") + log.WithError(err).Error("Merch | Failed to bind JSON on update merch") return } diff --git a/internal/api/merch/dto.go b/internal/api/merch/dto.go index cce0e03..6e872a2 100644 --- a/internal/api/merch/dto.go +++ b/internal/api/merch/dto.go @@ -46,3 +46,10 @@ type PricesResponse struct { MerchUuid string `json:"merch_uuid"` Origins []OriginWithPrices `json:"origins"` } + +type UpdateMerchDTO struct { + MerchUuid string `json:"merch_uuid"` + Name string `json:"name"` + Origin string `json:"origin"` + Link string `json:"link"` +} diff --git a/internal/api/merch/model.go b/internal/api/merch/model.go index ed7e550..893fb25 100644 --- a/internal/api/merch/model.go +++ b/internal/api/merch/model.go @@ -20,11 +20,10 @@ func (Merch) TableName() string { } type Surugaya struct { - Id uint `gorm:"primary_key" json:"-"` - DeletedAt sql.NullTime `json:"-"` - MerchUuid string `json:"-"` - Link string `json:"link"` - CookieValues string `json:"cookie_values"` + Id uint `gorm:"primary_key" json:"-"` + DeletedAt sql.NullTime `json:"-"` + MerchUuid string `json:"-"` + Link string `json:"link"` } func (Surugaya) TableName() string { diff --git a/internal/api/merch/repository.go b/internal/api/merch/repository.go index e7a17e9..9639599 100644 --- a/internal/api/merch/repository.go +++ b/internal/api/merch/repository.go @@ -23,7 +23,7 @@ type repository interface { getSingleMerch(userUuid, merchUuid string) (merchBundle, error) getAllMerch(userUuid string) ([]ListResponse, error) - updateMerch(payload MerchDTO, userUuid string) error + updateMerch(payload UpdateMerchDTO, userUuid string) error deleteMerch(userUuid, merchUuid string) error @@ -99,7 +99,7 @@ func (r *Repo) getAllMerch(userUuid string) ([]ListResponse, error) { return list, nil } -func (r *Repo) updateMerch(payload MerchDTO, userUuid string) error { +func (r *Repo) updateMerch(payload UpdateMerchDTO, userUuid string) error { m := make(map[string]any) m["name"] = payload.Name m["updated_at"] = sql.NullTime{ @@ -115,27 +115,24 @@ func (r *Repo) updateMerch(payload MerchDTO, userUuid string) error { return err } - // surugaya - fields := make(map[string]any, 2) - if payload.OriginSurugaya.Link != "" { - fields["link"] = payload.OriginSurugaya.Link - } - - if len(fields) > 0 { - if err := r.db. - Model(&Surugaya{}). - Where("merch_uuid = ?", payload.MerchUuid). - Updates(fields).Error; err != nil { + switch payload.Origin { + case "surugaya": + var recordSurugaya Surugaya + err := r.db.Where("merch_uuid = ?", payload.MerchUuid).FirstOrCreate(&recordSurugaya, Surugaya{ + MerchUuid: payload.MerchUuid, + Link: payload.Link, + }).Error + if err != nil { return err } - } - // mandarake - if payload.OriginMandarake.Link != "" { - if err := r.db. - Model(&Mandarake{}). - Where("merch_uuid = ?", payload.MerchUuid). - Update("link", payload.OriginMandarake.Link).Error; err != nil { + case "mandarake": + var recordMandarake Mandarake + err := r.db.Where("merch_uuid = ?", payload.MerchUuid).FirstOrCreate(&recordMandarake, Mandarake{ + MerchUuid: payload.MerchUuid, + Link: payload.Link, + }).Error + if err != nil { return err } } diff --git a/internal/api/merch/service.go b/internal/api/merch/service.go index 0e17c8d..bbc5175 100644 --- a/internal/api/merch/service.go +++ b/internal/api/merch/service.go @@ -67,10 +67,19 @@ func (s *service) getAllMerch(userUuid string) ([]ListResponse, error) { return s.repo.getAllMerch(userUuid) } -func (s *service) updateMerch(payload MerchDTO, userUuid string) error { +func (s *service) updateMerch(payload UpdateMerchDTO, userUuid string) error { if payload.MerchUuid == "" { - return errors.New("no MerchUuid or empty payload") + return errors.New("no merch uuid provided") } + + if payload.Origin == "" { + return errors.New("no origin provided") + } + + if payload.Link == "" { + return errors.New("no link provided") + } + return s.repo.updateMerch(payload, userUuid) } From 4759e7638ce5e1ab12064969ad2cd35a2d134c8a Mon Sep 17 00:00:00 2001 From: nquidox Date: Wed, 1 Oct 2025 12:13:43 +0300 Subject: [PATCH 06/10] switch update to upsert --- internal/api/merch/repository.go | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/internal/api/merch/repository.go b/internal/api/merch/repository.go index 9639599..61a3bc5 100644 --- a/internal/api/merch/repository.go +++ b/internal/api/merch/repository.go @@ -4,6 +4,7 @@ import ( "database/sql" "errors" "gorm.io/gorm" + "gorm.io/gorm/clause" "time" ) @@ -117,22 +118,18 @@ func (r *Repo) updateMerch(payload UpdateMerchDTO, userUuid string) error { switch payload.Origin { case "surugaya": - var recordSurugaya Surugaya - err := r.db.Where("merch_uuid = ?", payload.MerchUuid).FirstOrCreate(&recordSurugaya, Surugaya{ + if err := r.upsertOrigin(&Surugaya{ MerchUuid: payload.MerchUuid, Link: payload.Link, - }).Error - if err != nil { + }); err != nil { return err } case "mandarake": - var recordMandarake Mandarake - err := r.db.Where("merch_uuid = ?", payload.MerchUuid).FirstOrCreate(&recordMandarake, Mandarake{ + if err := r.upsertOrigin(&Mandarake{ MerchUuid: payload.MerchUuid, Link: payload.Link, - }).Error - if err != nil { + }); err != nil { return err } } @@ -220,3 +217,10 @@ func (r *Repo) getDistinctPrices(userUuid, merchUuid string, period time.Time) ( } return prices, nil } + +func (r *Repo) upsertOrigin(model any) error { + return r.db.Clauses(clause.OnConflict{ + Columns: []clause.Column{{Name: "merch_uuid"}}, + DoUpdates: clause.AssignmentColumns([]string{"link"}), + }).Create(model).Error +} From 2ada5e5a9eae515ac6f0ed99c3b93899ce12187b Mon Sep 17 00:00:00 2001 From: nquidox Date: Wed, 1 Oct 2025 19:31:58 +0300 Subject: [PATCH 07/10] update --- go.mod | 4 +++- go.sum | 6 ++++++ 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/go.mod b/go.mod index 9091402..5a94d40 100644 --- a/go.mod +++ b/go.mod @@ -12,6 +12,8 @@ require ( github.com/swaggo/gin-swagger v1.6.1 github.com/swaggo/swag v1.16.6 golang.org/x/crypto v0.42.0 + google.golang.org/grpc v1.75.1 + google.golang.org/protobuf v1.36.9 gorm.io/driver/postgres v1.6.0 gorm.io/gorm v1.31.0 ) @@ -66,5 +68,5 @@ require ( golang.org/x/sys v0.36.0 // indirect golang.org/x/text v0.29.0 // indirect golang.org/x/tools v0.37.0 // indirect - google.golang.org/protobuf v1.36.9 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20250929231259-57b25ae835d4 // indirect ) diff --git a/go.sum b/go.sum index b4a9634..b2b1730 100644 --- a/go.sum +++ b/go.sum @@ -173,6 +173,12 @@ golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc golang.org/x/tools v0.37.0 h1:DVSRzp7FwePZW356yEAChSdNcQo6Nsp+fex1SUW09lE= golang.org/x/tools v0.37.0/go.mod h1:MBN5QPQtLMHVdvsbtarmTNukZDdgwdwlO5qGacAzF0w= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250707201910-8d1bb00bc6a7 h1:pFyd6EwwL2TqFf8emdthzeX+gZE1ElRq3iM8pui4KBY= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250707201910-8d1bb00bc6a7/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250929231259-57b25ae835d4 h1:i8QOKZfYg6AbGVZzUAY3LrNWCKF8O6zFisU9Wl9RER4= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250929231259-57b25ae835d4/go.mod h1:HSkG/KdJWusxU1F6CNrwNDjBMgisKxGnc5dAZfT0mjQ= +google.golang.org/grpc v1.75.1 h1:/ODCNEuf9VghjgO3rqLcfg8fiOP0nSluljWFlDxELLI= +google.golang.org/grpc v1.75.1/go.mod h1:JtPAzKiq4v1xcAB2hydNlWI2RnF85XXcV0mhKXr2ecQ= google.golang.org/protobuf v1.36.9 h1:w2gp2mA27hUeUzj9Ex9FBjsBm40zfaDtEWow293U7Iw= google.golang.org/protobuf v1.36.9/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= From 850fb38e160bb4d9c73cf4f667d4f070b8bf63c5 Mon Sep 17 00:00:00 2001 From: nquidox Date: Wed, 1 Oct 2025 19:32:06 +0300 Subject: [PATCH 08/10] removed --- internal/shared/routes.go | 6 ------ 1 file changed, 6 deletions(-) delete mode 100644 internal/shared/routes.go diff --git a/internal/shared/routes.go b/internal/shared/routes.go deleted file mode 100644 index 28aea9d..0000000 --- a/internal/shared/routes.go +++ /dev/null @@ -1,6 +0,0 @@ -package shared - -type ExcludeRoute struct { - Route string - Method string -} From 5e1017df69ac8cf742387e0a4646eb04169bc08c Mon Sep 17 00:00:00 2001 From: nquidox Date: Wed, 1 Oct 2025 19:32:27 +0300 Subject: [PATCH 09/10] created --- proto/task.proto | 41 +++ proto/taskProcessor/task.pb.go | 409 ++++++++++++++++++++++++++++ proto/taskProcessor/task_grpc.pb.go | 195 +++++++++++++ 3 files changed, 645 insertions(+) create mode 100644 proto/task.proto create mode 100644 proto/taskProcessor/task.pb.go create mode 100644 proto/taskProcessor/task_grpc.pb.go diff --git a/proto/task.proto b/proto/task.proto new file mode 100644 index 0000000..bb17f67 --- /dev/null +++ b/proto/task.proto @@ -0,0 +1,41 @@ +syntax = "proto3"; +import "google/protobuf/empty.proto"; + +package taskProcessor; +option go_package = "./taskProcessor"; + + +message Task{ + string merch_uuid = 1; + string origin_surugaya_link = 2; + string origin_mandarake_link = 3; +} + +message Result{ + string merch_uuid = 1; + string origin_name = 2; + uint32 price = 3; +} + +message ProcessorStatusRequest{} + +message ProcessorStatusResponse { + int64 appStart = 1; + int64 lastCheck = 2; + int32 tasksReceived = 3; + int32 tasksInProgress = 4; + int32 tasksFirstTry = 5; + int32 tasksDoneAfterRetry = 6; + int32 tasksFailed = 7; + string workStatus = 8; + int32 numCPUs = 9; + int32 checkPeriod = 10; + int32 retriesCount = 11; + int32 retriesMinutes = 12; +} + +service TaskProcessor { + rpc RequestTask(google.protobuf.Empty) returns (stream Task); + rpc SendResult(stream Result) returns (google.protobuf.Empty); + rpc ProcessorStatus(ProcessorStatusRequest) returns (ProcessorStatusResponse); +} \ No newline at end of file diff --git a/proto/taskProcessor/task.pb.go b/proto/taskProcessor/task.pb.go new file mode 100644 index 0000000..7ff9f0c --- /dev/null +++ b/proto/taskProcessor/task.pb.go @@ -0,0 +1,409 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.8 +// protoc v6.32.0 +// source: task.proto + +package taskProcessor + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + emptypb "google.golang.org/protobuf/types/known/emptypb" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type Task struct { + state protoimpl.MessageState `protogen:"open.v1"` + MerchUuid string `protobuf:"bytes,1,opt,name=merch_uuid,json=merchUuid,proto3" json:"merch_uuid,omitempty"` + OriginSurugayaLink string `protobuf:"bytes,2,opt,name=origin_surugaya_link,json=originSurugayaLink,proto3" json:"origin_surugaya_link,omitempty"` + OriginMandarakeLink string `protobuf:"bytes,3,opt,name=origin_mandarake_link,json=originMandarakeLink,proto3" json:"origin_mandarake_link,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Task) Reset() { + *x = Task{} + mi := &file_task_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Task) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Task) ProtoMessage() {} + +func (x *Task) ProtoReflect() protoreflect.Message { + mi := &file_task_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Task.ProtoReflect.Descriptor instead. +func (*Task) Descriptor() ([]byte, []int) { + return file_task_proto_rawDescGZIP(), []int{0} +} + +func (x *Task) GetMerchUuid() string { + if x != nil { + return x.MerchUuid + } + return "" +} + +func (x *Task) GetOriginSurugayaLink() string { + if x != nil { + return x.OriginSurugayaLink + } + return "" +} + +func (x *Task) GetOriginMandarakeLink() string { + if x != nil { + return x.OriginMandarakeLink + } + return "" +} + +type Result struct { + state protoimpl.MessageState `protogen:"open.v1"` + MerchUuid string `protobuf:"bytes,1,opt,name=merch_uuid,json=merchUuid,proto3" json:"merch_uuid,omitempty"` + OriginName string `protobuf:"bytes,2,opt,name=origin_name,json=originName,proto3" json:"origin_name,omitempty"` + Price uint32 `protobuf:"varint,3,opt,name=price,proto3" json:"price,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Result) Reset() { + *x = Result{} + mi := &file_task_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Result) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Result) ProtoMessage() {} + +func (x *Result) ProtoReflect() protoreflect.Message { + mi := &file_task_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Result.ProtoReflect.Descriptor instead. +func (*Result) Descriptor() ([]byte, []int) { + return file_task_proto_rawDescGZIP(), []int{1} +} + +func (x *Result) GetMerchUuid() string { + if x != nil { + return x.MerchUuid + } + return "" +} + +func (x *Result) GetOriginName() string { + if x != nil { + return x.OriginName + } + return "" +} + +func (x *Result) GetPrice() uint32 { + if x != nil { + return x.Price + } + return 0 +} + +type ProcessorStatusRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProcessorStatusRequest) Reset() { + *x = ProcessorStatusRequest{} + mi := &file_task_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProcessorStatusRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProcessorStatusRequest) ProtoMessage() {} + +func (x *ProcessorStatusRequest) ProtoReflect() protoreflect.Message { + mi := &file_task_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProcessorStatusRequest.ProtoReflect.Descriptor instead. +func (*ProcessorStatusRequest) Descriptor() ([]byte, []int) { + return file_task_proto_rawDescGZIP(), []int{2} +} + +type ProcessorStatusResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + AppStart int64 `protobuf:"varint,1,opt,name=appStart,proto3" json:"appStart,omitempty"` + LastCheck int64 `protobuf:"varint,2,opt,name=lastCheck,proto3" json:"lastCheck,omitempty"` + TasksReceived int32 `protobuf:"varint,3,opt,name=tasksReceived,proto3" json:"tasksReceived,omitempty"` + TasksInProgress int32 `protobuf:"varint,4,opt,name=tasksInProgress,proto3" json:"tasksInProgress,omitempty"` + TasksFirstTry int32 `protobuf:"varint,5,opt,name=tasksFirstTry,proto3" json:"tasksFirstTry,omitempty"` + TasksDoneAfterRetry int32 `protobuf:"varint,6,opt,name=tasksDoneAfterRetry,proto3" json:"tasksDoneAfterRetry,omitempty"` + TasksFailed int32 `protobuf:"varint,7,opt,name=tasksFailed,proto3" json:"tasksFailed,omitempty"` + WorkStatus string `protobuf:"bytes,8,opt,name=workStatus,proto3" json:"workStatus,omitempty"` + NumCPUs int32 `protobuf:"varint,9,opt,name=numCPUs,proto3" json:"numCPUs,omitempty"` + CheckPeriod int32 `protobuf:"varint,10,opt,name=checkPeriod,proto3" json:"checkPeriod,omitempty"` + RetriesCount int32 `protobuf:"varint,11,opt,name=retriesCount,proto3" json:"retriesCount,omitempty"` + RetriesMinutes int32 `protobuf:"varint,12,opt,name=retriesMinutes,proto3" json:"retriesMinutes,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProcessorStatusResponse) Reset() { + *x = ProcessorStatusResponse{} + mi := &file_task_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProcessorStatusResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProcessorStatusResponse) ProtoMessage() {} + +func (x *ProcessorStatusResponse) ProtoReflect() protoreflect.Message { + mi := &file_task_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProcessorStatusResponse.ProtoReflect.Descriptor instead. +func (*ProcessorStatusResponse) Descriptor() ([]byte, []int) { + return file_task_proto_rawDescGZIP(), []int{3} +} + +func (x *ProcessorStatusResponse) GetAppStart() int64 { + if x != nil { + return x.AppStart + } + return 0 +} + +func (x *ProcessorStatusResponse) GetLastCheck() int64 { + if x != nil { + return x.LastCheck + } + return 0 +} + +func (x *ProcessorStatusResponse) GetTasksReceived() int32 { + if x != nil { + return x.TasksReceived + } + return 0 +} + +func (x *ProcessorStatusResponse) GetTasksInProgress() int32 { + if x != nil { + return x.TasksInProgress + } + return 0 +} + +func (x *ProcessorStatusResponse) GetTasksFirstTry() int32 { + if x != nil { + return x.TasksFirstTry + } + return 0 +} + +func (x *ProcessorStatusResponse) GetTasksDoneAfterRetry() int32 { + if x != nil { + return x.TasksDoneAfterRetry + } + return 0 +} + +func (x *ProcessorStatusResponse) GetTasksFailed() int32 { + if x != nil { + return x.TasksFailed + } + return 0 +} + +func (x *ProcessorStatusResponse) GetWorkStatus() string { + if x != nil { + return x.WorkStatus + } + return "" +} + +func (x *ProcessorStatusResponse) GetNumCPUs() int32 { + if x != nil { + return x.NumCPUs + } + return 0 +} + +func (x *ProcessorStatusResponse) GetCheckPeriod() int32 { + if x != nil { + return x.CheckPeriod + } + return 0 +} + +func (x *ProcessorStatusResponse) GetRetriesCount() int32 { + if x != nil { + return x.RetriesCount + } + return 0 +} + +func (x *ProcessorStatusResponse) GetRetriesMinutes() int32 { + if x != nil { + return x.RetriesMinutes + } + return 0 +} + +var File_task_proto protoreflect.FileDescriptor + +const file_task_proto_rawDesc = "" + + "\n" + + "\n" + + "task.proto\x12\rtaskProcessor\x1a\x1bgoogle/protobuf/empty.proto\"\x8b\x01\n" + + "\x04Task\x12\x1d\n" + + "\n" + + "merch_uuid\x18\x01 \x01(\tR\tmerchUuid\x120\n" + + "\x14origin_surugaya_link\x18\x02 \x01(\tR\x12originSurugayaLink\x122\n" + + "\x15origin_mandarake_link\x18\x03 \x01(\tR\x13originMandarakeLink\"^\n" + + "\x06Result\x12\x1d\n" + + "\n" + + "merch_uuid\x18\x01 \x01(\tR\tmerchUuid\x12\x1f\n" + + "\vorigin_name\x18\x02 \x01(\tR\n" + + "originName\x12\x14\n" + + "\x05price\x18\x03 \x01(\rR\x05price\"\x18\n" + + "\x16ProcessorStatusRequest\"\xc5\x03\n" + + "\x17ProcessorStatusResponse\x12\x1a\n" + + "\bappStart\x18\x01 \x01(\x03R\bappStart\x12\x1c\n" + + "\tlastCheck\x18\x02 \x01(\x03R\tlastCheck\x12$\n" + + "\rtasksReceived\x18\x03 \x01(\x05R\rtasksReceived\x12(\n" + + "\x0ftasksInProgress\x18\x04 \x01(\x05R\x0ftasksInProgress\x12$\n" + + "\rtasksFirstTry\x18\x05 \x01(\x05R\rtasksFirstTry\x120\n" + + "\x13tasksDoneAfterRetry\x18\x06 \x01(\x05R\x13tasksDoneAfterRetry\x12 \n" + + "\vtasksFailed\x18\a \x01(\x05R\vtasksFailed\x12\x1e\n" + + "\n" + + "workStatus\x18\b \x01(\tR\n" + + "workStatus\x12\x18\n" + + "\anumCPUs\x18\t \x01(\x05R\anumCPUs\x12 \n" + + "\vcheckPeriod\x18\n" + + " \x01(\x05R\vcheckPeriod\x12\"\n" + + "\fretriesCount\x18\v \x01(\x05R\fretriesCount\x12&\n" + + "\x0eretriesMinutes\x18\f \x01(\x05R\x0eretriesMinutes2\xee\x01\n" + + "\rTaskProcessor\x12<\n" + + "\vRequestTask\x12\x16.google.protobuf.Empty\x1a\x13.taskProcessor.Task0\x01\x12=\n" + + "\n" + + "SendResult\x12\x15.taskProcessor.Result\x1a\x16.google.protobuf.Empty(\x01\x12`\n" + + "\x0fProcessorStatus\x12%.taskProcessor.ProcessorStatusRequest\x1a&.taskProcessor.ProcessorStatusResponseB\x11Z\x0f./taskProcessorb\x06proto3" + +var ( + file_task_proto_rawDescOnce sync.Once + file_task_proto_rawDescData []byte +) + +func file_task_proto_rawDescGZIP() []byte { + file_task_proto_rawDescOnce.Do(func() { + file_task_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_task_proto_rawDesc), len(file_task_proto_rawDesc))) + }) + return file_task_proto_rawDescData +} + +var file_task_proto_msgTypes = make([]protoimpl.MessageInfo, 4) +var file_task_proto_goTypes = []any{ + (*Task)(nil), // 0: taskProcessor.Task + (*Result)(nil), // 1: taskProcessor.Result + (*ProcessorStatusRequest)(nil), // 2: taskProcessor.ProcessorStatusRequest + (*ProcessorStatusResponse)(nil), // 3: taskProcessor.ProcessorStatusResponse + (*emptypb.Empty)(nil), // 4: google.protobuf.Empty +} +var file_task_proto_depIdxs = []int32{ + 4, // 0: taskProcessor.TaskProcessor.RequestTask:input_type -> google.protobuf.Empty + 1, // 1: taskProcessor.TaskProcessor.SendResult:input_type -> taskProcessor.Result + 2, // 2: taskProcessor.TaskProcessor.ProcessorStatus:input_type -> taskProcessor.ProcessorStatusRequest + 0, // 3: taskProcessor.TaskProcessor.RequestTask:output_type -> taskProcessor.Task + 4, // 4: taskProcessor.TaskProcessor.SendResult:output_type -> google.protobuf.Empty + 3, // 5: taskProcessor.TaskProcessor.ProcessorStatus:output_type -> taskProcessor.ProcessorStatusResponse + 3, // [3:6] is the sub-list for method output_type + 0, // [0:3] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_task_proto_init() } +func file_task_proto_init() { + if File_task_proto != nil { + return + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_task_proto_rawDesc), len(file_task_proto_rawDesc)), + NumEnums: 0, + NumMessages: 4, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_task_proto_goTypes, + DependencyIndexes: file_task_proto_depIdxs, + MessageInfos: file_task_proto_msgTypes, + }.Build() + File_task_proto = out.File + file_task_proto_goTypes = nil + file_task_proto_depIdxs = nil +} diff --git a/proto/taskProcessor/task_grpc.pb.go b/proto/taskProcessor/task_grpc.pb.go new file mode 100644 index 0000000..487a7d8 --- /dev/null +++ b/proto/taskProcessor/task_grpc.pb.go @@ -0,0 +1,195 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.5.1 +// - protoc v6.32.0 +// source: task.proto + +package taskProcessor + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + emptypb "google.golang.org/protobuf/types/known/emptypb" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 + +const ( + TaskProcessor_RequestTask_FullMethodName = "/taskProcessor.TaskProcessor/RequestTask" + TaskProcessor_SendResult_FullMethodName = "/taskProcessor.TaskProcessor/SendResult" + TaskProcessor_ProcessorStatus_FullMethodName = "/taskProcessor.TaskProcessor/ProcessorStatus" +) + +// TaskProcessorClient is the client API for TaskProcessor service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type TaskProcessorClient interface { + RequestTask(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[Task], error) + SendResult(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[Result, emptypb.Empty], error) + ProcessorStatus(ctx context.Context, in *ProcessorStatusRequest, opts ...grpc.CallOption) (*ProcessorStatusResponse, error) +} + +type taskProcessorClient struct { + cc grpc.ClientConnInterface +} + +func NewTaskProcessorClient(cc grpc.ClientConnInterface) TaskProcessorClient { + return &taskProcessorClient{cc} +} + +func (c *taskProcessorClient) RequestTask(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[Task], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &TaskProcessor_ServiceDesc.Streams[0], TaskProcessor_RequestTask_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[emptypb.Empty, Task]{ClientStream: stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type TaskProcessor_RequestTaskClient = grpc.ServerStreamingClient[Task] + +func (c *taskProcessorClient) SendResult(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[Result, emptypb.Empty], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &TaskProcessor_ServiceDesc.Streams[1], TaskProcessor_SendResult_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[Result, emptypb.Empty]{ClientStream: stream} + return x, nil +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type TaskProcessor_SendResultClient = grpc.ClientStreamingClient[Result, emptypb.Empty] + +func (c *taskProcessorClient) ProcessorStatus(ctx context.Context, in *ProcessorStatusRequest, opts ...grpc.CallOption) (*ProcessorStatusResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ProcessorStatusResponse) + err := c.cc.Invoke(ctx, TaskProcessor_ProcessorStatus_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// TaskProcessorServer is the server API for TaskProcessor service. +// All implementations must embed UnimplementedTaskProcessorServer +// for forward compatibility. +type TaskProcessorServer interface { + RequestTask(*emptypb.Empty, grpc.ServerStreamingServer[Task]) error + SendResult(grpc.ClientStreamingServer[Result, emptypb.Empty]) error + ProcessorStatus(context.Context, *ProcessorStatusRequest) (*ProcessorStatusResponse, error) + mustEmbedUnimplementedTaskProcessorServer() +} + +// UnimplementedTaskProcessorServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedTaskProcessorServer struct{} + +func (UnimplementedTaskProcessorServer) RequestTask(*emptypb.Empty, grpc.ServerStreamingServer[Task]) error { + return status.Errorf(codes.Unimplemented, "method RequestTask not implemented") +} +func (UnimplementedTaskProcessorServer) SendResult(grpc.ClientStreamingServer[Result, emptypb.Empty]) error { + return status.Errorf(codes.Unimplemented, "method SendResult not implemented") +} +func (UnimplementedTaskProcessorServer) ProcessorStatus(context.Context, *ProcessorStatusRequest) (*ProcessorStatusResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ProcessorStatus not implemented") +} +func (UnimplementedTaskProcessorServer) mustEmbedUnimplementedTaskProcessorServer() {} +func (UnimplementedTaskProcessorServer) testEmbeddedByValue() {} + +// UnsafeTaskProcessorServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to TaskProcessorServer will +// result in compilation errors. +type UnsafeTaskProcessorServer interface { + mustEmbedUnimplementedTaskProcessorServer() +} + +func RegisterTaskProcessorServer(s grpc.ServiceRegistrar, srv TaskProcessorServer) { + // If the following call pancis, it indicates UnimplementedTaskProcessorServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } + s.RegisterService(&TaskProcessor_ServiceDesc, srv) +} + +func _TaskProcessor_RequestTask_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(emptypb.Empty) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(TaskProcessorServer).RequestTask(m, &grpc.GenericServerStream[emptypb.Empty, Task]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type TaskProcessor_RequestTaskServer = grpc.ServerStreamingServer[Task] + +func _TaskProcessor_SendResult_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(TaskProcessorServer).SendResult(&grpc.GenericServerStream[Result, emptypb.Empty]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type TaskProcessor_SendResultServer = grpc.ClientStreamingServer[Result, emptypb.Empty] + +func _TaskProcessor_ProcessorStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ProcessorStatusRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(TaskProcessorServer).ProcessorStatus(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: TaskProcessor_ProcessorStatus_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(TaskProcessorServer).ProcessorStatus(ctx, req.(*ProcessorStatusRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// TaskProcessor_ServiceDesc is the grpc.ServiceDesc for TaskProcessor service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var TaskProcessor_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "taskProcessor.TaskProcessor", + HandlerType: (*TaskProcessorServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "ProcessorStatus", + Handler: _TaskProcessor_ProcessorStatus_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "RequestTask", + Handler: _TaskProcessor_RequestTask_Handler, + ServerStreams: true, + }, + { + StreamName: "SendResult", + Handler: _TaskProcessor_SendResult_Handler, + ClientStreams: true, + }, + }, + Metadata: "task.proto", +} From 6867d2d74e3fefd1b667089cee733b4c407223eb Mon Sep 17 00:00:00 2001 From: nquidox Date: Wed, 1 Oct 2025 19:32:56 +0300 Subject: [PATCH 10/10] grpc server added --- api.env | 3 + cmd/main.go | 18 ++++-- config/config.go | 17 ++++- internal/api/merch/provider.go | 93 ++++++++++++++++++++++++++++ internal/app/handler.go | 54 +++++++++++----- internal/grpcService/handler.go | 106 ++++++++++++++++++++++++++++++++ internal/interfaces/task.go | 8 +++ internal/router/handler.go | 10 ++- internal/shared/task.go | 13 ++++ 9 files changed, 294 insertions(+), 28 deletions(-) create mode 100644 internal/api/merch/provider.go create mode 100644 internal/grpcService/handler.go create mode 100644 internal/interfaces/task.go create mode 100644 internal/shared/task.go diff --git a/api.env b/api.env index 8622ace..843383b 100644 --- a/api.env +++ b/api.env @@ -5,6 +5,9 @@ APP_API_PREFIX=/api/v2 APP_GIN_MODE=development APP_ALLOWED_ORIGINS=http://localhost:5173, +GRPC_SERVER_PORT=9050 +GRPC_CLIENT_PORT=9060 + DB_HOST= DB_PORT= DB_USER= diff --git a/cmd/main.go b/cmd/main.go index 16f80b1..f16c4e3 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -8,6 +8,7 @@ import ( "merch-parser-api/internal/api/merch" "merch-parser-api/internal/api/user" "merch-parser-api/internal/app" + "merch-parser-api/internal/grpcService" "merch-parser-api/internal/interfaces" "merch-parser-api/internal/provider/auth" "merch-parser-api/internal/provider/token" @@ -66,6 +67,10 @@ func main() { }) log.Debug("Auth provider initialized") + tasksRepo := merch.NewTaskRepository(database) + tasksProvider := merch.NewTaskProvider(tasksRepo) + grpcServer := grpcService.NewGrpcServer(tasksProvider) + //register app modules users := user.NewHandler(user.Deps{ Auth: authProvider, @@ -87,11 +92,14 @@ func main() { //keep last appl := app.NewApp(app.Deps{ - Host: c.AppConf.Host, - Port: c.AppConf.Port, - ApiPrefix: c.AppConf.ApiPrefix, - RouterHandler: routerHandler, - Modules: modules, + Host: c.AppConf.Host, + Port: c.AppConf.Port, + ApiPrefix: c.AppConf.ApiPrefix, + RouterHandler: routerHandler, + Modules: modules, + GrpcServer: grpcServer, + GrpcServerPort: c.GrpcConf.GrpcServerPort, + GrpcClientPort: c.GrpcConf.GrpcClientPort, }) err = appl.Run(ctx) diff --git a/config/config.go b/config/config.go index 304e051..2646db5 100644 --- a/config/config.go +++ b/config/config.go @@ -3,9 +3,10 @@ package config import "strings" type Config struct { - AppConf AppConfig - DBConf DatabaseConfig - JWTConf JWTConfig + AppConf AppConfig + DBConf DatabaseConfig + JWTConf JWTConfig + GrpcConf GrpcConfig } type AppConfig struct { @@ -34,6 +35,11 @@ type JWTConfig struct { RefreshExpire string } +type GrpcConfig struct { + GrpcServerPort string + GrpcClientPort string +} + func NewConfig() *Config { return &Config{ AppConf: AppConfig{ @@ -61,5 +67,10 @@ func NewConfig() *Config { AccessExpire: getEnv("JWT_ACCESS_EXPIRE", ""), RefreshExpire: getEnv("JWT_REFRESH_EXPIRE", ""), }, + + GrpcConf: GrpcConfig{ + GrpcServerPort: getEnv("GRPC_SERVER_PORT", ""), + GrpcClientPort: getEnv("GRPC_CLIENT_PORT", ""), + }, } } diff --git a/internal/api/merch/provider.go b/internal/api/merch/provider.go new file mode 100644 index 0000000..f856fbd --- /dev/null +++ b/internal/api/merch/provider.go @@ -0,0 +1,93 @@ +package merch + +import ( + "gorm.io/gorm" + "merch-parser-api/internal/shared" +) + +type Link struct { + Surugaya []Surugaya + Mandarake []Mandarake +} + +type TaskProvider struct { + repo TaskRepository +} + +type TaskRepository interface { + GetLinks() (*Link, error) + InsertPrices() error +} + +type TaskRepo struct { + db *gorm.DB +} + +func NewTaskProvider(repo TaskRepository) *TaskProvider { + return &TaskProvider{ + repo: repo, + } +} + +func NewTaskRepository(db *gorm.DB) TaskRepository { + return &TaskRepo{db: db} +} + +func (p *TaskProvider) PrepareTasks() (map[string]shared.Task, error) { + getLinks, err := p.repo.GetLinks() + if err != nil { + return nil, err + } + + taskMap := make(map[string]shared.Task) + + for _, item := range getLinks.Surugaya { + if task, exists := taskMap[item.MerchUuid]; exists { + task.OriginSurugayaLink = item.Link + taskMap[item.MerchUuid] = task + } else { + taskMap[item.MerchUuid] = shared.Task{ + MerchUuid: item.MerchUuid, + OriginSurugayaLink: item.Link, + } + } + } + + for _, item := range getLinks.Mandarake { + if task, exists := taskMap[item.MerchUuid]; exists { + task.OriginMandarakeLink = item.Link + taskMap[item.MerchUuid] = task + } else { + taskMap[item.MerchUuid] = shared.Task{ + MerchUuid: item.MerchUuid, + OriginMandarakeLink: item.Link, + } + } + } + return taskMap, nil +} + +func (p *TaskProvider) InsertPrices([]shared.TaskResult) error { + return nil +} + +func (r *TaskRepo) GetLinks() (*Link, error) { + var surugayaList []Surugaya + if err := r.db.Model(&Surugaya{}).Find(&surugayaList).Error; err != nil { + return nil, err + } + + var mandarakeList []Mandarake + if err := r.db.Model(&Mandarake{}).Find(&mandarakeList).Error; err != nil { + return nil, err + } + + return &Link{ + Surugaya: surugayaList, + Mandarake: mandarakeList, + }, nil +} + +func (r *TaskRepo) InsertPrices() error { + return nil +} diff --git a/internal/app/handler.go b/internal/app/handler.go index 09de7e0..0164c13 100644 --- a/internal/app/handler.go +++ b/internal/app/handler.go @@ -4,33 +4,46 @@ import ( "context" "github.com/gin-gonic/gin" log "github.com/sirupsen/logrus" + "google.golang.org/grpc" "merch-parser-api/internal/interfaces" + "net" "net/http" "time" ) type App struct { - address string - apiPrefix string - modules []interfaces.Module - routerHandler interfaces.Router - router *gin.Engine + host string + address string + apiPrefix string + modules []interfaces.Module + routerHandler interfaces.Router + router *gin.Engine + grpcServer *grpc.Server + grpcServerPort string + grpcClientPort string } type Deps struct { - Host string - Port string - ApiPrefix string - Modules []interfaces.Module - RouterHandler interfaces.Router + Host string + Port string + ApiPrefix string + Modules []interfaces.Module + RouterHandler interfaces.Router + GrpcServer *grpc.Server + GrpcServerPort string + GrpcClientPort string } func NewApp(deps Deps) *App { app := &App{ - address: deps.Host + ":" + deps.Port, - apiPrefix: deps.ApiPrefix, - routerHandler: deps.RouterHandler, - modules: deps.Modules, + host: deps.Host, + address: deps.Host + ":" + deps.Port, + apiPrefix: deps.ApiPrefix, + routerHandler: deps.RouterHandler, + modules: deps.Modules, + grpcServer: deps.GrpcServer, + grpcServerPort: deps.GrpcServerPort, + grpcClientPort: deps.GrpcClientPort, } app.router = app.routerHandler.Set() @@ -62,6 +75,19 @@ func (a *App) Run(ctx context.Context) error { serverErr <- server.ListenAndServe() }() + go func() { + listener, err := net.Listen("tcp", net.JoinHostPort(a.host, a.grpcServerPort)) + if err != nil { + log.WithField("err", err).Fatal("gRPC Server | Listener") + } + + err = a.grpcServer.Serve(listener) + if err != nil { + log.WithField("err", err).Fatal("gRPC Server | Serve") + } + }() + log.Info("Starting gRPC server on port: ", a.grpcServerPort) + select { case <-ctx.Done(): log.Info("Shutting down server") diff --git a/internal/grpcService/handler.go b/internal/grpcService/handler.go new file mode 100644 index 0000000..6af20cf --- /dev/null +++ b/internal/grpcService/handler.go @@ -0,0 +1,106 @@ +package grpcService + +import ( + log "github.com/sirupsen/logrus" + "google.golang.org/grpc" + "google.golang.org/protobuf/types/known/emptypb" + "io" + "merch-parser-api/internal/interfaces" + "merch-parser-api/internal/shared" + pb "merch-parser-api/proto/taskProcessor" + "time" +) + +type repoServer struct { + pb.UnimplementedTaskProcessorServer + taskProvider interfaces.TaskProvider +} + +func NewGrpcServer(taskProvider interfaces.TaskProvider) *grpc.Server { + srv := grpc.NewServer() + repoSrv := &repoServer{ + taskProvider: taskProvider, + } + + pb.RegisterTaskProcessorServer(srv, repoSrv) + return srv +} + +func (r *repoServer) RequestTask(_ *emptypb.Empty, stream pb.TaskProcessor_RequestTaskServer) error { + tasks, err := r.taskProvider.PrepareTasks() + if err != nil { + log.WithField("err", err).Error("gRPC Server | Request task error") + return err + } + + for _, task := range tasks { + if err = stream.Send(&pb.Task{ + MerchUuid: task.MerchUuid, + OriginSurugayaLink: task.OriginSurugayaLink, + OriginMandarakeLink: task.OriginMandarakeLink, + }); err != nil { + log.WithField("err", err).Error("gRPC Server | Stream send error") + return err + } + } + return nil +} + +func (r *repoServer) SendResult(stream pb.TaskProcessor_SendResultServer) error { + saveInterval := time.Second * 2 + batch := make([]shared.TaskResult, 0) + + ticker := time.NewTicker(saveInterval) + defer ticker.Stop() + + done := make(chan struct{}) + + go func() { + for { + select { + case <-done: + return + case <-ticker.C: + if len(batch) > 0 { + err := r.taskProvider.InsertPrices(batch) + if err != nil { + log.WithField("err", err).Error("gRPC Server | Batch insert") + } + } + } + } + }() + + for { + response, err := stream.Recv() + if err == io.EOF { + log.Debug("gRPC EOF") + break + } + + if err != nil { + log.WithField("err", err).Error("gRPC Server | Receive") + return err + } + + entry := shared.TaskResult{ + MerchUuid: response.MerchUuid, + Origin: response.OriginName, + Price: response.Price, + } + + batch = append(batch, entry) + log.WithField("response", entry).Debug("gRPC Server | Receive success") + } + + close(done) + if len(batch) > 0 { + err := r.taskProvider.InsertPrices(batch) + if err != nil { + log.WithField("err", err).Error("gRPC Server | Last data batch insert") + return err + } + } + + return nil +} diff --git a/internal/interfaces/task.go b/internal/interfaces/task.go new file mode 100644 index 0000000..dd8e299 --- /dev/null +++ b/internal/interfaces/task.go @@ -0,0 +1,8 @@ +package interfaces + +import "merch-parser-api/internal/shared" + +type TaskProvider interface { + PrepareTasks() (map[string]shared.Task, error) + InsertPrices([]shared.TaskResult) error +} diff --git a/internal/router/handler.go b/internal/router/handler.go index 70e882a..328ab93 100644 --- a/internal/router/handler.go +++ b/internal/router/handler.go @@ -7,17 +7,15 @@ import ( swaggerFiles "github.com/swaggo/files" ginSwagger "github.com/swaggo/gin-swagger" "merch-parser-api/internal/interfaces" - "merch-parser-api/internal/shared" "net/http" "time" ) type router struct { - apiPrefix string - engine *gin.Engine - ginMode string - excludeRoutes map[string]shared.ExcludeRoute - tokenProv interfaces.JWTProvider + apiPrefix string + engine *gin.Engine + ginMode string + tokenProv interfaces.JWTProvider } type Deps struct { diff --git a/internal/shared/task.go b/internal/shared/task.go new file mode 100644 index 0000000..119babd --- /dev/null +++ b/internal/shared/task.go @@ -0,0 +1,13 @@ +package shared + +type Task struct { + MerchUuid string + OriginSurugayaLink string + OriginMandarakeLink string +} + +type TaskResult struct { + MerchUuid string + Origin string + Price uint32 +}