Implement gRPC server for evaluator

Author: pvgupta24

evaluator.go

@@ -1,42 +1,50 @@
-// Get Results
-// Check output and send back results
-// Queue
-
 package main
 
 import (
 	"io/ioutil"
 	"log"
 	"os"
+
+	"github.com/udhos/equalfile"
 	// "io"
 	// "bytes"
-	"github.com/udhos/equalfile"
 )
 
-func EvaluateSubmission(submissionPath string, expectedOutputPath string) int32 {
+// EvaluateSubmission : Evaluates the submission
+func EvaluateSubmission(submissionID string, questionID string) int32 {
+	// Path refers to path inside the cpjudge_webserver container because
+	// directory is already mounted.
+	base := "/media/vaibhav/Coding/go/src/github.com/cpjudge/cpjudge_webserver"
+	submissionsPath := base + "/submissions/" + submissionID
+	expectedOutputPath := base + "/questions/testcases/" +
+		questionID +
+		"/output/"
 
 	expectedOutputFiles, err := ioutil.ReadDir(expectedOutputPath)
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	for _, f := range expectedOutputFiles {
-		errorFilePath := submissionPath + "error/" + f.Name()
-		outputFilePath := submissionPath + "output/" + f.Name()
+		errorFilePath := submissionsPath + "/error/" + f.Name()
+		compilationErrorFilePath := submissionsPath + "/compilation_error.err"
+		outputFilePath := submissionsPath + "/output/" + f.Name()
 		expectedOutputFilePath := expectedOutputPath + f.Name()
 
-		if fileInfo, _ := os.Stat(errorFilePath); fileInfo.Size() != 0 {
-			return 4 //Runtime Error
+		if fileInfo, err := os.Stat(compilationErrorFilePath); err == nil {
+			if fileInfo.Size() != 0 {
+				return 3 //Compilation Error
+			}
+		}
+		if fileInfo, err := os.Stat(errorFilePath); err == nil {
+			if fileInfo.Size() != 0 {
+				return 4 //Runtime Error
+			}
 		}
 		cmp := equalfile.New(nil, equalfile.Options{Debug: false})
 		if equal, _ := cmp.CompareFile(outputFilePath, expectedOutputFilePath); !equal {
 			return 1 // Wrong Answer
 		}
-		// if !deepCompare(outputFilePath, expectedOutputFilePath)	{
-		// 	return 1
-		// }
 	}
-
-	log.Println("CORRECT")
 	return 0 // Correct Answer
 }

sandbox_client.go

@@ -7,19 +7,19 @@ import (
 	"time"
 
 	pb "github.com/cpjudge/proto/submission"
+
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/testdata"
 )
 
 var (
-	tls                = flag.Bool("tls", false, "Connection uses TLS if true, else plain TCP")
+	address            = "172.17.0.1:10000"
 	caFile             = flag.String("ca_file", "", "The file containning the CA root cert file")
-	serverAddr         = flag.String("server_addr", "127.0.0.1:10000", "The server address in the format of host:port")
 	serverHostOverride = flag.String("server_host_override", "x.test.youtube.com", "The server name use to verify the hostname returned by TLS handshake")
 )
 
-// Submits the code to sandbox service and gets submission status
+// Internal function to call the sandbox service and submit the code.
 func submitCode(client pb.SandboxClient, submission *pb.Submission) *pb.CodeStatus {
 	log.Printf("Submitting code for submission_id: %s", submission.GetSubmissionId())
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
@@ -28,22 +28,13 @@ func submitCode(client pb.SandboxClient, submission *pb.Submission) *pb.CodeStat
 	if err != nil {
 		log.Fatalf("%v.SubmitCode(_) = _, %v: ", client, err)
 	}
-	log.Println(codeStatus)
-
-	expectedOutputPath := "/media/pvgupta24/MyZone/Projects/go/src/github.com/cpjudge/testcases/1/output/"
-
-	if codeStatus.CodeStatus == pb.SubmissionStatus_TO_BE_EVALUATED {
-		codeStatus.CodeStatus = pb.SubmissionStatus(
-				EvaluateSubmission(submission.SubmissionPath, expectedOutputPath))
-	}
-
-	log.Println(codeStatus)
-
+	log.Println("After sandbox execution: ", codeStatus)
 	return codeStatus
 }
 
-
-func main() {
+// SubmitCode : Spawns a connection to sandbox service and calls submitCode()
+func SubmitCode(submission *pb.Submission) *pb.CodeStatus {
+	// Establish a connection with the sandbox service.
 	flag.Parse()
 	var opts []grpc.DialOption
 	if *tls {
@@ -58,20 +49,13 @@ func main() {
 	} else {
 		opts = append(opts, grpc.WithInsecure())
 	}
-	conn, err := grpc.Dial(*serverAddr, opts...)
+	conn, err := grpc.Dial(address, opts...)
 	if err != nil {
 		log.Fatalf("fail to dial: %v", err)
 	}
 	defer conn.Close()
 	client := pb.NewSandboxClient(conn)
-
-
-	submitCode(client, &pb.Submission{
-		Language: "cpp",
-		QuestionId: "1",
-		SubmissionId: "1",
-		SubmissionPath: "/media/pvgupta24/MyZone/Projects/go/src/github.com/cpjudge/submissions/1/",
-		TestcasesPath: "/media/pvgupta24/MyZone/Projects/go/src/github.com/cpjudge/testcases/1/input/",
-		UserId: "mahim23",
-	})
+	// Call internal function to submit code to sandbox service
+	codeStatus := submitCode(client, submission)
+	return codeStatus
 }

server.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"log"
+	"net"
+
+	epb "github.com/cpjudge/proto/evaluator"
+	spb "github.com/cpjudge/proto/submission"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/testdata"
+)
+
+var (
+	tls        = flag.Bool("tls", false, "Connection uses TLS if true, else plain TCP")
+	certFile   = flag.String("cert_file", "", "The TLS cert file")
+	keyFile    = flag.String("key_file", "", "The TLS key file")
+	jsonDBFile = flag.String("json_db_file", "", "A json file containing a list of features")
+	serverAddr = flag.String("server_addr", "172.17.0.1:12000", "The server address in the format of host:port")
+)
+
+type evaluatorServer struct{}
+
+func (e *evaluatorServer) EvaluateCode(ctx context.Context, submission *spb.Submission) (*epb.CodeStatus, error) {
+	codeStatus := SubmitCode(submission)
+	evaluateCodeStatus := &epb.CodeStatus{}
+	switch codeStatus.CodeStatus {
+	case spb.SubmissionStatus_TO_BE_EVALUATED:
+		evaluateStatus := EvaluateSubmission(submission.SubmissionId, submission.QuestionId)
+		switch evaluateStatus {
+		case 0:
+			evaluateCodeStatus.CodeStatus = epb.EvaluationStatus_CORRECT_ANSWER
+		case 2:
+			evaluateCodeStatus.CodeStatus = epb.EvaluationStatus_TIME_LIMIT_EXCEEDED
+		case 3:
+			evaluateCodeStatus.CodeStatus = epb.EvaluationStatus_COMPILATION_ERROR
+		case 4:
+			evaluateCodeStatus.CodeStatus = epb.EvaluationStatus_RUNTIME_ERROR
+		default:
+			evaluateCodeStatus.CodeStatus = epb.EvaluationStatus_WRONG_ANSWER
+		}
+	case spb.SubmissionStatus_TIME_LIMIT_EXCEEDED:
+		evaluateCodeStatus.CodeStatus = epb.EvaluationStatus_TIME_LIMIT_EXCEEDED
+	case spb.SubmissionStatus_COMPILATION_ERROR:
+		evaluateCodeStatus.CodeStatus = epb.EvaluationStatus_COMPILATION_ERROR
+	default:
+		evaluateCodeStatus.CodeStatus = epb.EvaluationStatus_WRONG_ANSWER
+	}
+	return evaluateCodeStatus, nil
+}
+
+func main() {
+	flag.Parse()
+	lis, err := net.Listen("tcp", *serverAddr)
+	if err != nil {
+		log.Fatalf("failed to listen: %v", err)
+	}
+	var opts []grpc.ServerOption
+	if *tls {
+		if *certFile == "" {
+			*certFile = testdata.Path("server1.pem")
+		}
+		if *keyFile == "" {
+			*keyFile = testdata.Path("server1.key")
+		}
+		creds, err := credentials.NewServerTLSFromFile(*certFile, *keyFile)
+		if err != nil {
+			log.Fatalf("Failed to generate credentials %v", err)
+		}
+		opts = []grpc.ServerOption{grpc.Creds(creds)}
+	}
+	grpcServer := grpc.NewServer(opts...)
+	epb.RegisterEvaluatorServer(grpcServer, &evaluatorServer{})
+	grpcServer.Serve(lis)
+}