Added Sentry into go, added proper exit codes for coreconsole and rewrote some error handling.

FM1337 · FM1337 · commit cc1963214d6b · 2023-06-11T11:49:24.000-03:00
diff --git a/.env.example b/.env.example
@@ -3,4 +3,5 @@ ENV=
 CONFIGURED=false
 SESSION_KEY=
 HTTP_VALIDATION_KEY=
-HTTP_ENCRYPTION_KEY=
+HTTP_ENCRYPTION_KEY=
+LOGGGING_SENTRY_DSN=https://sentry.io/...
diff --git a/Makefile b/Makefile
@@ -43,11 +43,14 @@ docker-build:
 
 cs-build-release:
 	cd coreconsole && \
-	dotnet build -c Release -o ../cc
+	dotnet build coreconsole.csproj -c Release -o ../cc && \
+	cp data ../cc/data -r
+
 
 cs-build-debug:
 	cd coreconsole && \
-	dotnet build -c Debug -o ../cc
+	dotnet build coreconsole.csproj -c Debug -o ../cc && \
+	cp data ../cc/data -r
 
 cs-clean:
 	/bin/rm -rfv cc
diff --git a/coreconsole/Program.cs b/coreconsole/Program.cs
@@ -14,68 +14,64 @@ public static class MainClass
 {
     public static void Main(string[] args)
     {
-        if(!Helpers.LoadEnv()) return;
-        
-        using (SentrySdk.Init(o =>
-               {
-                   o.Dsn = Environment.GetEnvironmentVariable("SENTRY_DSN");
-               }))
+        if (!Helpers.LoadEnv()) Environment.Exit((int)enums.ExitCode.EnvNotConfigured);
+
+        using (SentrySdk.Init(o => { o.Dsn = Environment.GetEnvironmentVariable("SENTRY_DSN"); }))
         {
-                 var pokemonArg = new Argument<string>(
-            "pokemon",
-            "The pokemon file (in base64 format)."
-        );
+            var pokemonArg = new Argument<string>(
+                "pokemon",
+                "The pokemon file (in base64 format)."
+            );
 
-        var generationOption = new Option<EntityContext?>(
-            "--generation",
-            "Used to determine desired generation when generation could be 6/7 or 8/8b"
-        );
+            var generationOption = new Option<EntityContext?>(
+                "--generation",
+                "Used to determine desired generation when generation could be 6/7 or 8/8b"
+            );
 
-        var cmd1 = new Command("summary", "Returns the summary for a given pokemon.")
-        {
-            pokemonArg,
-            generationOption
-        };
-        cmd1.SetHandler(Summary.SummaryHandler, pokemonArg, generationOption);
+            var cmd1 = new Command("summary", "Returns the summary for a given pokemon.")
+            {
+                pokemonArg,
+                generationOption
+            };
+            cmd1.SetHandler(Summary.SummaryHandler, pokemonArg, generationOption);
 
-        var cmd2 = new Command("legality", "Returns the legality status for a Pokemon, including what checks fail.")
-        {
-            pokemonArg,
-            generationOption
-        };
+            var cmd2 = new Command("legality", "Returns the legality status for a Pokemon, including what checks fail.")
+            {
+                pokemonArg,
+                generationOption
+            };
 
-        cmd2.SetHandler(Legality.LegalityCheckHandler, pokemonArg, generationOption);
+            cmd2.SetHandler(Legality.LegalityCheckHandler, pokemonArg, generationOption);
 
-        var legalizationGenerationOverride = new Option<int?>("--legalization-generation",
-            "Forces the legalized Pokemon to use the provided generation (may cause legalization to fail).");
+            var legalizationGenerationOverride = new Option<int?>("--legalization-generation",
+                "Forces the legalized Pokemon to use the provided generation (may cause legalization to fail).");
 
-        var legalizationGameVersionOverride = new Option<GameVersion?>("--version",
-            "Game Version to use in trying to legalize the Pokemon (may cause legalization to fail).");
+            var legalizationGameVersionOverride = new Option<GameVersion?>("--version",
+                "Game Version to use in trying to legalize the Pokemon (may cause legalization to fail).");
 
-        var cmd3 = new Command("legalize", "Attempts to auto legalize a pokemon and returns it if successful.")
-        {
-            pokemonArg,
-            generationOption,
-            legalizationGenerationOverride,
-            legalizationGameVersionOverride
-        };
-        cmd3.SetHandler(Legality.LegalizeHandler, pokemonArg, generationOption,
-            legalizationGenerationOverride, legalizationGameVersionOverride);
+            var cmd3 = new Command("legalize", "Attempts to auto legalize a pokemon and returns it if successful.")
+            {
+                pokemonArg,
+                generationOption,
+                legalizationGenerationOverride,
+                legalizationGameVersionOverride
+            };
+            cmd3.SetHandler(Legality.LegalizeHandler, pokemonArg, generationOption,
+                legalizationGenerationOverride, legalizationGameVersionOverride);
 
-        var cmd4 = new Command("version", "Returns the version for ALM/PKHeX");
-        cmd4.SetHandler(() =>
-        {
-           Console.WriteLine(JsonSerializer.Serialize(new Version()));
-        });
+            var cmd4 = new Command("version", "Returns the version for ALM/PKHeX");
+            cmd4.SetHandler(() => { Console.WriteLine(JsonSerializer.Serialize(new Version())); });
 
-        var cli = new RootCommand("CoreConsole - a tool for interacting with PKHeX and Auto Legality via CLI.")
-        {
-            cmd1,
-            cmd2,
-            cmd3,
-            cmd4
-        };
-        cli.Invoke(args);   
+            var cli = new RootCommand("CoreConsole - a tool for interacting with PKHeX and Auto Legality via CLI.")
+            {
+                cmd1,
+                cmd2,
+                cmd3,
+                cmd4
+            };
+            cli.Invoke(args);
         }
+
+        Environment.Exit((int)enums.ExitCode.Success);
     }
 }
diff --git a/coreconsole/enums/ExitCode.cs b/coreconsole/enums/ExitCode.cs
@@ -0,0 +1,10 @@
+namespace coreconsole.enums;
+
+public enum ExitCode: int
+{
+    Success = 0,
+    BadBase64 = 1,
+    Base64NotPokemon = 2,
+    UnknownErrorDuringBase64ToPokemon = 3,
+    EnvNotConfigured = 4
+}
diff --git a/coreconsole/utils/Helpers.cs b/coreconsole/utils/Helpers.cs
@@ -5,9 +5,10 @@
 
 namespace coreconsole.utils;
 
-public class Helpers
+public static class Helpers
 {
     public static JsonSerializerOptions? SerializerOptions;
+
     // Used for tests
     public static byte[] StringToByteArray(string hex)
     {
@@ -22,40 +23,39 @@ public static void Init()
         EncounterEvent.RefreshMGDB(string.Empty);
         RibbonStrings.ResetDictionary(GameInfo.Strings.ribbons);
         Sprites.Init();
-        
+
         SerializerOptions = new JsonSerializerOptions
         {
             Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping
         };
     }
 
-    public static PKM? PokemonFromBase64(string pokemon, EntityContext context = EntityContext.None)
+    public static PKM PokemonFromBase64(string pokemon, EntityContext context = EntityContext.None)
     {
         try
         {
             var pkmnStrBytes = Convert.FromBase64String(pokemon);
 
             var pkmn = EntityFormat.GetFromBytes(pkmnStrBytes, context);
 
-            if (pkmn is null)
-            {
-                Console.Error.WriteLine("{\"error\": \"base64 is not a pokemon\"}");
-                SentrySdk.CaptureMessage(level: SentryLevel.Error, message: "base64 provided is not a pokemon");
-                return null;
-            }
-
-            return pkmn;
+            if (pkmn is not null) return pkmn;
+            Console.Error.WriteLine("{\"error\": \"base64 is not a pokemon\"}");
+            SentrySdk.CaptureMessage(level: SentryLevel.Error, message: "base64 provided is not a pokemon");
+            Environment.Exit((int)enums.ExitCode.Base64NotPokemon);
         }
         catch (Exception e) when (e is FormatException or ArgumentNullException)
         {
             Console.Error.WriteLine("{\"error\": \"invalid base64 string provided\"}");
             SentrySdk.CaptureException(e);
-            return null;
-        } catch (Exception e) when (e is not FormatException and not ArgumentNullException)
+            Environment.Exit((int)enums.ExitCode.BadBase64);
+        }
+        catch (Exception e) when (e is not FormatException and not ArgumentNullException)
         {
             SentrySdk.CaptureException(e);
-            return null;
+            Environment.Exit((int)enums.ExitCode.UnknownErrorDuringBase64ToPokemon);
         }
+
+        return null;
     }
 
     public static bool LoadEnv()
@@ -70,7 +70,7 @@ public static bool LoadEnv()
         {
             var parts = line.Split("=");
             if (parts.Length != 2) continue;
-            
+
             Environment.SetEnvironmentVariable(parts[0], parts[1]);
         }
 
diff --git a/go.mod b/go.mod
@@ -4,6 +4,7 @@ go 1.20
 
 require (
 	github.com/apex/log v1.9.0
+	github.com/getsentry/sentry-go v0.21.0
 	github.com/go-chi/chi/v5 v5.0.8
 	github.com/go-chi/httprate v0.7.4
 	github.com/lrstanley/chix v1.0.0
diff --git a/go.sum b/go.sum
@@ -66,10 +66,13 @@ github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBD
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
 github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
+github.com/getsentry/sentry-go v0.21.0 h1:c9l5F1nPF30JIppulk4veau90PK6Smu3abgVtVQWon4=
+github.com/getsentry/sentry-go v0.21.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY=
 github.com/go-chi/chi/v5 v5.0.8 h1:lD+NLqFcAi1ovnVZpsnObHGW4xb4J8lNmoYVfECH1Y0=
 github.com/go-chi/chi/v5 v5.0.8/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8=
 github.com/go-chi/httprate v0.7.4 h1:a2GIjv8he9LRf3712zxxnRdckQCm7I8y8yQhkJ84V6M=
 github.com/go-chi/httprate v0.7.4/go.mod h1:6GOYBSwnpra4CQfAKXu8sQZg+nZ0M1g9QnyFvxrAB8A=
+github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA=
 github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
@@ -204,6 +207,7 @@ github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyex
 github.com/mrjones/oauth v0.0.0-20180629183705-f4e24b6d100c/go.mod h1:skjdDftzkFALcuGzYSklqYd8gvat6F1gZJ4YPVbkZpM=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
diff --git a/internal/handlers/generalhandler/handler.go b/internal/handlers/generalhandler/handler.go
@@ -8,6 +8,7 @@ import (
 
 	"github.com/FlagBrew/CoreAPI/internal/models"
 	"github.com/FlagBrew/CoreAPI/internal/utils"
+	"github.com/getsentry/sentry-go"
 	"github.com/go-chi/chi/v5"
 	"github.com/lrstanley/chix"
 )
@@ -21,20 +22,39 @@ func NewHandler() *Handler {
 
 func (h *Handler) Route(r chi.Router) {
 	r.Get("/ping", h.ping)
+	r.Get("/kuma-ping", h.kumaPing)
+}
+
+func (h *Handler) kumaPing(w http.ResponseWriter, r *http.Request) {
+	chix.JSON(w, r, http.StatusOK, chix.M{
+		"status": "ok",
+	})
 }
 
 func (h *Handler) ping(w http.ResponseWriter, r *http.Request) {
 	start := time.Now()
 	version, err := utils.RunCoreConsole(r.Context(), "version", "")
 
 	if err != nil {
+		// if error code 4, the .env is missing for coreconsole, which should only happen if I forget to set it up, meaning we can tell the user that coreconsole is currently being set-up and to try again later
+		if err.Error() == "CoreConsole exited with code 4" {
+			w.Header().Set("Content-Type", "application/json")
+
+			chix.JSON(w, r, http.StatusServiceUnavailable, chix.M{
+				"error": "CoreConsole is currently being set-up, please try again later",
+			})
+			return
+		}
+
+		// If we got here, then something went wrong but likely wasn't caught by coreconsole inside sentry so we'll deal with it here.
+		sentry.CaptureException(err)
 		chix.Error(w, r, fmt.Errorf("something went wrong, please try again later"))
 		return
 	}
 
 	v := &models.ALMVersion{}
 	if err := json.Unmarshal([]byte(version), &v); err != nil {
-		fmt.Println(err)
+		sentry.CaptureException(err)
 		chix.Error(w, r, fmt.Errorf("something went wrong, please try again later"))
 		return
 	}
diff --git a/internal/handlers/infohandler/handler.go b/internal/handlers/infohandler/handler.go
@@ -1,12 +1,12 @@
 package infohandler
 
 import (
-	"encoding/json"
 	"fmt"
 	"net/http"
 
 	"github.com/FlagBrew/CoreAPI/internal/models"
 	"github.com/FlagBrew/CoreAPI/internal/utils"
+	"github.com/getsentry/sentry-go"
 	"github.com/go-chi/chi/v5"
 	"github.com/lrstanley/chix"
 )
@@ -31,7 +31,18 @@ func (h *Handler) getInfo(w http.ResponseWriter, r *http.Request) {
 
 	// Get the pkmn in base64
 	pkmn, err := utils.GetPkmnFromRequest(w, r)
-	if chix.Error(w, r, err) {
+	if err != nil {
+		if err.Error() == "file too large" {
+			w.Header().Set("Content-Type", "application/json")
+
+			chix.JSON(w, r, http.StatusRequestEntityTooLarge, chix.M{
+				"error": "file too large",
+			})
+			return
+		}
+
+		chix.Error(w, r, err)
+		sentry.CaptureException(err)
 		return
 	}
 
@@ -43,23 +54,34 @@ func (h *Handler) getInfo(w http.ResponseWriter, r *http.Request) {
 
 	output, err := utils.RunCoreConsole(r.Context(), "summary", pkmn, extraArgs...)
 	if err != nil {
-		if err.Error() != "exit status 1" {
-			chix.Error(w, r, err)
+		// if error code 1 or 2, the pkmn provided is invalid.
+		if err.Error() == "CoreConsole exited with code 1" || err.Error() == "CoreConsole exited with code 2" {
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusBadRequest)
+
+			w.Write([]byte(output))
 			return
 		}
 
-		// try to parse the output as JSON
-		var js json.RawMessage
-		if json.Unmarshal([]byte(output), &js) != nil {
-			// this is not JSON, DO NOT RETURN THIS TO THE USER
+		// if error code 3, something unknown happened, but should've been captured by sentry inside coreconsole itself.
+		if err.Error() == "CoreConsole exited with code 3" {
 			chix.Error(w, r, fmt.Errorf("something went wrong, please try again later"))
 			return
 		}
 
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusBadRequest)
+		// if error code 4, the .env is missing for coreconsole, which should only happen if I forget to set it up, meaning we can tell the user that coreconsole is currently being set-up and to try again later
+		if err.Error() == "CoreConsole exited with code 4" {
+			w.Header().Set("Content-Type", "application/json")
+
+			chix.JSON(w, r, http.StatusServiceUnavailable, chix.M{
+				"error": "CoreConsole is currently being set-up, please try again later",
+			})
+			return
+		}
 
-		w.Write([]byte(output))
+		// If we got here, then something went wrong but likely wasn't caught by coreconsole inside sentry so we'll deal with it here.
+		sentry.CaptureException(err)
+		chix.Error(w, r, fmt.Errorf("something went wrong, please try again later"))
 		return
 	}
 	// we got JSON back, so we can just write it to the response
diff --git a/internal/handlers/legalityhandler/handler.go b/internal/handlers/legalityhandler/handler.go
diff --git a/internal/models/flags.go b/internal/models/flags.go
diff --git a/internal/utils/csharp.go b/internal/utils/csharp.go
diff --git a/main.go b/main.go

Original file line number	Diff line number	Diff line change
`@@ -5,9 +5,10 @@`
`5`	`5`
`6`	`6`	`namespace coreconsole.utils;`
`7`	`7`
`8`		`-public class Helpers`
	`8`	`+public static class Helpers`
`9`	`9`	`{`
`10`	`10`	`public static JsonSerializerOptions? SerializerOptions;`
	`11`	`+`
`11`	`12`	`// Used for tests`
`12`	`13`	`public static byte[] StringToByteArray(string hex)`
`13`	`14`	`{`
`@@ -22,40 +23,39 @@ public static void Init()`
`22`	`23`	`EncounterEvent.RefreshMGDB(string.Empty);`
`23`	`24`	`RibbonStrings.ResetDictionary(GameInfo.Strings.ribbons);`
`24`	`25`	`Sprites.Init();`
`25`		`-`
	`26`	`+`
`26`	`27`	`SerializerOptions = new JsonSerializerOptions`
`27`	`28`	`{`
`28`	`29`	`Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping`
`29`	`30`	`};`
`30`	`31`	`}`
`31`	`32`
`32`		`- public static PKM? PokemonFromBase64(string pokemon, EntityContext context = EntityContext.None)`
	`33`	`+ public static PKM PokemonFromBase64(string pokemon, EntityContext context = EntityContext.None)`
`33`	`34`	`{`
`34`	`35`	`try`
`35`	`36`	`{`
`36`	`37`	`var pkmnStrBytes = Convert.FromBase64String(pokemon);`
`37`	`38`
`38`	`39`	`var pkmn = EntityFormat.GetFromBytes(pkmnStrBytes, context);`
`39`	`40`
`40`		`- if (pkmn is null)`
`41`		`- {`
`42`		`- Console.Error.WriteLine("{\"error\": \"base64 is not a pokemon\"}");`
`43`		`- SentrySdk.CaptureMessage(level: SentryLevel.Error, message: "base64 provided is not a pokemon");`
`44`		`- return null;`
`45`		`- }`
`46`		`-`
`47`		`- return pkmn;`
	`41`	`+ if (pkmn is not null) return pkmn;`
	`42`	`+ Console.Error.WriteLine("{\"error\": \"base64 is not a pokemon\"}");`
	`43`	`+ SentrySdk.CaptureMessage(level: SentryLevel.Error, message: "base64 provided is not a pokemon");`
	`44`	`+ Environment.Exit((int)enums.ExitCode.Base64NotPokemon);`
`48`	`45`	`}`
`49`	`46`	`catch (Exception e) when (e is FormatException or ArgumentNullException)`
`50`	`47`	`{`
`51`	`48`	`Console.Error.WriteLine("{\"error\": \"invalid base64 string provided\"}");`
`52`	`49`	`SentrySdk.CaptureException(e);`
`53`		`- return null;`
`54`		`- } catch (Exception e) when (e is not FormatException and not ArgumentNullException)`
	`50`	`+ Environment.Exit((int)enums.ExitCode.BadBase64);`
	`51`	`+ }`
	`52`	`+ catch (Exception e) when (e is not FormatException and not ArgumentNullException)`
`55`	`53`	`{`
`56`	`54`	`SentrySdk.CaptureException(e);`
`57`		`- return null;`
	`55`	`+ Environment.Exit((int)enums.ExitCode.UnknownErrorDuringBase64ToPokemon);`
`58`	`56`	`}`
	`57`	`+`
	`58`	`+ return null;`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`public static bool LoadEnv()`
`@@ -70,7 +70,7 @@ public static bool LoadEnv()`
`70`	`70`	`{`
`71`	`71`	`var parts = line.Split("=");`
`72`	`72`	`if (parts.Length != 2) continue;`
`73`		`-`
	`73`	`+`
`74`	`74`	`Environment.SetEnvironmentVariable(parts[0], parts[1]);`
`75`	`75`	`}`
`76`	`76`