Make all services output proper JSON

Author: terminalnode

client/run.go

@@ -2,8 +2,10 @@ package main
 
 import (
 	"bytes"
+	"encoding/json"
 	"flag"
 	"fmt"
+	"github.com/terminalnode/adventofcode2024/common/util"
 	"io"
 	"net/http"
 	"os"
@@ -64,17 +66,23 @@ func runSolution(
 	url string,
 	day int,
 	part int,
-	input string,
+	rawInput string,
 ) (string, error) {
 	url = fmt.Sprintf("http://%s/day%02d/%d", url, day, part)
 	fmt.Printf("Running day %d, part %d with URL '%s'\n", day, part, url)
 	client := &http.Client{}
 
-	req, err := http.NewRequest("POST", url, bytes.NewBuffer([]byte(input)))
+	input := util.AocInput{Input: rawInput}
+	jsonData, err := json.Marshal(input)
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal JSON: %v", err)
+	}
+
+	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
 	if err != nil {
 		return "", err
 	}
-	req.Header.Set("Content-Type", "text/plain")
+	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := client.Do(req)
 	if err != nil {

common/proto/grpc.go

@@ -41,18 +41,30 @@ func CreateGRPCServer(
 	return grpcServer
 }
 
+// This part of the architecture is a bit #YOLO
+// But at least I got to play around a little with gRPC
+// Throughout the entire process I've only used the Kubernetes solution over HTTP
+
 func (s *server) SolvePart1(
 	ctx context.Context,
 	req *InputData,
 ) (*InputResponse, error) {
-	result := s.solvePart1(req.Input)
-	return &InputResponse{Result: result}, nil
+	result, err := s.solvePart1(util.AocInput{Input: req.Input})
+	if s := result.Solution; s != "" {
+		return &InputResponse{Result: s}, nil
+	} else {
+		return &InputResponse{Result: err.Error()}, nil
+	}
 }
 
 func (s *server) SolvePart2(
 	ctx context.Context,
 	req *InputData,
 ) (*InputResponse, error) {
-	result := s.solvePart2(req.Input)
-	return &InputResponse{Result: result}, nil
+	result, err := s.solvePart2(util.AocInput{Input: req.Input})
+	if s := result.Solution; s != "" {
+		return &InputResponse{Result: s}, nil
+	} else {
+		return &InputResponse{Result: err.Error()}, nil
+	}
 }

common/util/aoc_error.go

@@ -0,0 +1,36 @@
+package util
+
+type ErrorType int
+
+const (
+	NotImplemented ErrorType = iota
+	InputParsingError
+	ParsingError
+	StringToNumber
+	ProcessingError
+)
+
+func (et ErrorType) String() string {
+	switch et {
+	case NotImplemented:
+		return "NotImplemented"
+	case ParsingError:
+		return "ParsingError"
+	case StringToNumber:
+		return "StringToNumber"
+	default:
+		return "UnknownError"
+	}
+}
+
+type AocError struct {
+	Message string `json:"message"`
+	Type    string `json:"type"`
+	IsError bool   `json:"-"`
+}
+
+func (
+	e AocError,
+) Error() string {
+	return e.Message
+}

common/util/solution.go

@@ -1,3 +1,33 @@
 package util
 
-type Solution = func(string) string
+import "fmt"
+
+type AocInput struct {
+	Input string `json:"input"`
+}
+
+type AocSolution struct {
+	Solution string `json:"solution"`
+}
+
+type Solution = func(AocInput) (AocSolution, AocError)
+
+func NewAocError(
+	m string,
+	t ErrorType,
+) (AocSolution, AocError) {
+	return AocSolution{}, AocError{Message: m, Type: t.String()}
+}
+
+func NewAocSolution(
+	solution string,
+) (AocSolution, AocError) {
+	return AocSolution{Solution: solution}, AocError{}
+}
+
+func FormatAocSolution(
+	format string,
+	a ...any,
+) (AocSolution, AocError) {
+	return NewAocSolution(fmt.Sprintf(format, a...))
+}

common/web/http_util.go

@@ -1,8 +1,9 @@
 package web
 
 import (
+	"encoding/json"
 	"fmt"
-	"io"
+	"github.com/terminalnode/adventofcode2024/common/util"
 	"net/http"
 )
 
@@ -13,12 +14,11 @@ func addPrefix(prefix string, url string) string {
 	return fmt.Sprintf("/%s%s", prefix, url)
 }
 
-func readInput(r *http.Request) (string, error) {
-	body, err := io.ReadAll(r.Body)
-	if err != nil {
-		return "", err
+func readInput(r *http.Request) (util.AocInput, error) {
+	var input util.AocInput
+	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
+		return util.AocInput{}, err
 	}
-
 	defer r.Body.Close()
-	return string(body), nil
+	return input, nil
 }

common/web/solution_handler.go

@@ -1,6 +1,8 @@
 package web
 
 import (
+	"encoding/json"
+	"errors"
 	"fmt"
 	"github.com/terminalnode/adventofcode2024/common/util"
 	"net/http"
@@ -9,7 +11,7 @@ import (
 func createSolutionHandler(
 	day int,
 	part int,
-	solution func(string) string,
+	solution util.Solution,
 ) func(http.ResponseWriter, *http.Request) {
 	if solution == nil {
 		solution = defaultSolutionHandler(day, part)
@@ -27,10 +29,13 @@ func createSolutionHandler(
 			return
 		}
 
-		result := solution(input)
-		if _, err = w.Write([]byte(result)); err != nil {
-			http.Error(w, "Error", http.StatusInternalServerError)
-			return
+		aocSolution, aocErr := solution(input)
+		w.Header().Set("Content-Type", "application/json")
+		encoder := json.NewEncoder(w)
+		if errors.Is(err, util.AocError{}) {
+			encoder.Encode(aocErr)
+		} else {
+			encoder.Encode(aocSolution)
 		}
 	}
 }
@@ -39,7 +44,10 @@ func defaultSolutionHandler(
 	day int,
 	part int,
 ) util.Solution {
-	return func(input string) string {
-		return fmt.Sprintf("Solution for day %d part %d not implemented yet", day, part)
+	return func(input util.AocInput) (util.AocSolution, util.AocError) {
+		return util.NewAocError(
+			fmt.Sprintf("Solution for day %d part %d not implemented yet", day, part),
+			util.NotImplemented,
+		)
 	}
 }

solutions/day01/main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"github.com/terminalnode/adventofcode2024/common"
+	"github.com/terminalnode/adventofcode2024/common/util"
 	"slices"
 	"strconv"
 	"strings"
@@ -40,10 +41,12 @@ func createLists(input string) ([]int, []int, error) {
 	return left, right, nil
 }
 
-func part1(input string) string {
-	left, right, err := createLists(input)
+func part1(
+	input util.AocInput,
+) (util.AocSolution, util.AocError) {
+	left, right, err := createLists(input.Input)
 	if err != nil {
-		return err.Error()
+		return util.NewAocError(err.Error(), util.InputParsingError)
 	}
 
 	// Sort the lists
@@ -60,13 +63,15 @@ func part1(input string) string {
 		sum += diff
 	}
 
-	return fmt.Sprintf("Result for part 1: %d", sum)
+	return util.FormatAocSolution("Result for part 1: %d", sum)
 }
 
-func part2(input string) string {
-	left, right, err := createLists(input)
+func part2(
+	input util.AocInput,
+) (util.AocSolution, util.AocError) {
+	left, right, err := createLists(input.Input)
 	if err != nil {
-		return err.Error()
+		return util.NewAocError(err.Error(), util.InputParsingError)
 	}
 
 	rightMap := make(map[int]int)
@@ -79,5 +84,5 @@ func part2(input string) string {
 		sum += l * rightMap[l]
 	}
 
-	return fmt.Sprintf("Result for part 2: %d", sum)
+	return util.FormatAocSolution("Result for part 2: %d", sum)
 }

solutions/day02/main.go

@@ -1,8 +1,8 @@
 package main
 
 import (
-	"fmt"
 	"github.com/terminalnode/adventofcode2024/common"
+	"github.com/terminalnode/adventofcode2024/common/util"
 	"strconv"
 	"strings"
 )
@@ -119,23 +119,23 @@ func countSafe(
 }
 
 func part1(
-	input string,
-) string {
-	reports, err := parseAllReports(input, false)
+	input util.AocInput,
+) (util.AocSolution, util.AocError) {
+	reports, err := parseAllReports(input.Input, false)
 	if err != nil {
-		return fmt.Sprintf("Failed to parse reports: %v", err)
+		return util.NewAocError(err.Error(), util.InputParsingError)
 	}
 
-	return fmt.Sprintf("Number of safe reports: %d", countSafe(reports))
+	return util.FormatAocSolution("Number of safe reports: %d", countSafe(reports))
 }
 
 func part2(
-	input string,
-) string {
-	reports, err := parseAllReports(input, true)
+	input util.AocInput,
+) (util.AocSolution, util.AocError) {
+	reports, err := parseAllReports(input.Input, true)
 	if err != nil {
-		return fmt.Sprintf("Failed to parse reports: %v", err)
+		return util.NewAocError(err.Error(), util.InputParsingError)
 	}
 
-	return fmt.Sprintf("Number of safe reports: %d", countSafe(reports))
+	return util.FormatAocSolution("Number of safe reports: %d", countSafe(reports))
 }

solutions/day03/main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"github.com/terminalnode/adventofcode2024/common"
+	"github.com/terminalnode/adventofcode2024/common/util"
 	"regexp"
 	"strconv"
 )
@@ -14,9 +15,9 @@ func main() {
 }
 
 func part1(
-	input string,
-) string {
-	finds := r.FindAllSubmatch([]byte(input), -1)
+	input util.AocInput,
+) (util.AocSolution, util.AocError) {
+	finds := r.FindAllSubmatch([]byte(input.Input), -1)
 	sum := 0
 	for _, match := range finds {
 		verb := string(match[1])
@@ -26,17 +27,17 @@ func part1(
 
 		multiplied, err := mul(string(match[3]), string(match[4]))
 		if err != nil {
-			return fmt.Sprintf("Failed to parse multiplication of %q:\n%v\n", match, err)
+			return util.NewAocError(fmt.Sprintf("Failed to parse multiplication of %q:\n%v\n", match, err), util.ParsingError)
 		}
 		sum += multiplied
 	}
-	return fmt.Sprintf("Result: %d", sum)
+	return util.FormatAocSolution("Result: %d", sum)
 }
 
 func part2(
-	input string,
-) string {
-	finds := r.FindAllSubmatch([]byte(input), -1)
+	input util.AocInput,
+) (util.AocSolution, util.AocError) {
+	finds := r.FindAllSubmatch([]byte(input.Input), -1)
 	sum := 0
 
 	enabled := true
@@ -47,7 +48,7 @@ func part2(
 			if enabled {
 				multiplied, err := mul(string(match[3]), string(match[4]))
 				if err != nil {
-					return fmt.Sprintf("Failed to parse multiplication of %q:\n%v\n", match, err)
+					return util.NewAocError(fmt.Sprintf("Failed to parse multiplication of %q:\n%v\n", match, err), util.ParsingError)
 				}
 				sum += multiplied
 			}
@@ -58,7 +59,7 @@ func part2(
 		}
 	}
 
-	return fmt.Sprintf("Result: %d", sum)
+	return util.FormatAocSolution("Result: %d", sum)
 }
 
 func mul(sub1 string, sub2 string) (int, error) {