feat(tester): migrate from gRPC to REST

internal/tester/usecase/contests_usecase.go

@@ -0,0 +1,47 @@
+package usecase
+
+import (
+	"context"
+	"git.sch9.ru/new_gate/ms-tester/internal/models"
+	"git.sch9.ru/new_gate/ms-tester/internal/tester"
+)
+
+type ContestUseCase struct {
+	contestRepo tester.ContestRepository
+}
+
+func NewContestUseCase(
+	contestRepo tester.ContestRepository,
+) *ContestUseCase {
+	return &ContestUseCase{
+		contestRepo: contestRepo,
+	}
+}
+
+func (uc *ContestUseCase) CreateContest(ctx context.Context, title string) (int32, error) {
+	return uc.contestRepo.CreateContest(ctx, title)
+}
+
+func (uc *ContestUseCase) ReadContestById(ctx context.Context, id int32) (*models.Contest, error) {
+	return uc.contestRepo.ReadContestById(ctx, id)
+}
+
+func (uc *ContestUseCase) DeleteContest(ctx context.Context, id int32) error {
+	return uc.contestRepo.DeleteContest(ctx, id)
+}
+
+func (uc *ContestUseCase) AddTask(ctx context.Context, contestId int32, taskId int32) (id int32, err error) {
+	return uc.contestRepo.AddTask(ctx, contestId, taskId)
+}
+
+func (uc *ContestUseCase) DeleteTask(ctx context.Context, taskId int32) error {
+	return uc.contestRepo.DeleteTask(ctx, taskId)
+}
+
+func (uc *ContestUseCase) AddParticipant(ctx context.Context, contestId int32, userId int32) (id int32, err error) {
+	return uc.contestRepo.AddParticipant(ctx, contestId, userId)
+}
+
+func (uc *ContestUseCase) DeleteParticipant(ctx context.Context, participantId int32) error {
+	return uc.contestRepo.DeleteParticipant(ctx, participantId)
+}

internal/tester/usecase/problems_usecase.go

@@ -0,0 +1,34 @@
+package usecase
+
+import (
+	"context"
+	"git.sch9.ru/new_gate/ms-tester/internal/models"
+	"git.sch9.ru/new_gate/ms-tester/internal/tester"
+)
+
+type ProblemUseCase struct {
+	problemRepo tester.ProblemPostgresRepository
+	//pandocClient pandoc.PandocClient
+}
+
+func NewProblemUseCase(
+	problemRepo tester.ProblemPostgresRepository,
+	// pandocClient pandoc.PandocClient,
+) *ProblemUseCase {
+	return &ProblemUseCase{
+		problemRepo: problemRepo,
+		//pandocClient: pandocClient,
+	}
+}
+
+func (u *ProblemUseCase) CreateProblem(ctx context.Context, title string) (int32, error) {
+	return u.problemRepo.CreateProblem(ctx, title)
+}
+
+func (u *ProblemUseCase) ReadProblemById(ctx context.Context, id int32) (*models.Problem, error) {
+	return u.problemRepo.ReadProblemById(ctx, id)
+}
+
+func (u *ProblemUseCase) DeleteProblem(ctx context.Context, id int32) error {
+	return u.problemRepo.DeleteProblem(ctx, id)
+}

internal/tester/usecase/usecase.go

@@ -1,107 +0,0 @@
-package usecase
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"math/rand"
-	"sync"
-)
-
-const (
-	MaxSimultaneousTestingProcesses = 5000
-	MaxMessagesPerSolution          = 500
-)
-
-type TesterUseCase struct {
-	publicChannels  sync.Map
-	privateChannels sync.Map
-	testingChannel  chan int32
-}
-
-func NewTesterUseCase() *TesterUseCase {
-	return &TesterUseCase{
-		testingChannel: make(chan int32, MaxSimultaneousTestingProcesses),
-	}
-}
-
-func (u *TesterUseCase) CreateSolution(ctx context.Context, taskId int32, solution string, language int32) (int32, error) {
-	return rand.Int31(), nil
-}
-
-func (u *TesterUseCase) ProcessTesting(ctx context.Context, solutionId int32) (<-chan string, error) {
-	u.testingChannel <- solutionId
-
-	publicChannel := u.newPublicChannel(solutionId)
-
-	go func() {
-		privateChannel := u.newPrivateChannel(solutionId)
-		defer func() {
-			err := u.closeAndDeletePrivateChannel(solutionId)
-			if err != nil {
-				panic(err)
-			}
-			err = u.closeAndDeletePublicChannel(solutionId)
-			if err != nil {
-				panic(err)
-			}
-		}()
-
-		c := 0
-		for res := range privateChannel {
-			c += 1
-			publicChannel <- res
-			if c == 15 {
-				fmt.Println("finished")
-				break
-			}
-		}
-	}()
-
-	return publicChannel, nil
-}
-
-func (u *TesterUseCase) ProcessResult(ctx context.Context, solutionId int32, result string) error {
-	ch, ok := u.privateChannels.Load(solutionId)
-	if !ok {
-		return errors.New("")
-	}
-	ch.(chan string) <- result
-	return nil
-}
-
-func (u *TesterUseCase) TestingChannel() chan int32 {
-	return u.testingChannel
-}
-
-func (u *TesterUseCase) newPublicChannel(solutionId int32) chan string {
-	userCh := make(chan string, MaxMessagesPerSolution)
-	u.publicChannels.Store(solutionId, userCh)
-	return userCh
-}
-
-func (u *TesterUseCase) newPrivateChannel(solutionId int32) chan string {
-	userCh := make(chan string, MaxMessagesPerSolution)
-	u.privateChannels.Store(solutionId, userCh)
-	return userCh
-}
-
-func (u *TesterUseCase) closeAndDeletePublicChannel(solutionId int32) error {
-	ch, ok := u.publicChannels.Load(solutionId)
-	if !ok {
-		return errors.New("")
-	}
-	close(ch.(chan string))
-	u.publicChannels.Delete(solutionId)
-	return nil
-}
-
-func (u *TesterUseCase) closeAndDeletePrivateChannel(solutionId int32) error {
-	ch, ok := u.privateChannels.Load(solutionId)
-	if !ok {
-		return errors.New("")
-	}
-	close(ch.(chan string))
-	u.privateChannels.Delete(solutionId)
-	return nil
-}