ISM rewrite

Signed-off-by: arzumify <jliwin98@danwin1210.de>

build.sh

@@ -28,6 +28,6 @@ find -L "$searchDir" -type f -name "build.sh" | while read -r buildScript; do
 done
 clear
 fancy "\033[1;105m" "Building Fulgens..."
-go build --ldflags "-s -w" -o "$path/fulgens" || exit 1
+go build -C "$path" --ldflags "-s -w" -o "$path/fulgens" || exit 1
 clear
 fancy "\033[1;102m" "Fulgens has been built successfully!"

go.mod

@@ -3,33 +3,33 @@ module git.ailur.dev/ailur/fulgens
 go 1.23.3
 
 require (
-	git.ailur.dev/ailur/fg-library/v2 v2.1.2
+	git.ailur.dev/ailur/fg-library/v3 v3.5.0
 	git.ailur.dev/ailur/fg-nucleus-library v1.0.5
-	git.ailur.dev/ailur/pow v1.0.2
+	git.ailur.dev/ailur/pow v1.0.3
 	github.com/CAFxX/httpcompression v0.0.9
 	github.com/cespare/xxhash/v2 v2.3.0
-	github.com/go-chi/chi/v5 v5.1.0
+	github.com/go-chi/chi/v5 v5.2.0
-	github.com/go-playground/validator/v10 v10.22.1
+	github.com/go-playground/validator/v10 v10.23.0
 	github.com/golang-jwt/jwt/v5 v5.2.1
 	github.com/google/uuid v1.6.0
 	github.com/klauspost/compress v1.17.11
 	github.com/lib/pq v1.10.9
 	github.com/mattn/go-sqlite3 v1.14.24
-	golang.org/x/crypto v0.29.0
 	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
 	github.com/andybalholm/brotli v1.1.1 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.6 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.8 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
 	github.com/kr/pretty v0.3.1 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/rogpeppe/go-internal v1.13.1 // indirect
-	github.com/stretchr/testify v1.9.0 // indirect
+	github.com/stretchr/testify v1.10.0 // indirect
-	golang.org/x/net v0.31.0 // indirect
+	golang.org/x/crypto v0.32.0 // indirect
-	golang.org/x/sys v0.27.0 // indirect
+	golang.org/x/net v0.34.0 // indirect
-	golang.org/x/text v0.20.0 // indirect
+	golang.org/x/sys v0.29.0 // indirect
+	golang.org/x/text v0.21.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
 )

go.sum

@@ -1,9 +1,17 @@
 git.ailur.dev/ailur/fg-library/v2 v2.1.2 h1:Gk8ztytJfV2GYhsnfTDRWmvTzJ3Cn19V5p2suFCvu4E=
 git.ailur.dev/ailur/fg-library/v2 v2.1.2/go.mod h1:gBnZQDV70YON6cnuwB+Jawm2EABbf9dGlV0Qw4obtxs=
+git.ailur.dev/ailur/fg-library/v3 v3.2.0 h1:SXVj6iCPQ6sR2ZmCZXhAU51mPgH9ERN7KZbMUB03/p4=
+git.ailur.dev/ailur/fg-library/v3 v3.2.0/go.mod h1:ArNsafpqES2JuxQM5aM+bNe0FwHLIsL6pbjpiWvDwGs=
+git.ailur.dev/ailur/fg-library/v3 v3.3.0 h1:VRe/shTbIfD00OWaywclb4flduAqRY81lMBXGHmMz5g=
+git.ailur.dev/ailur/fg-library/v3 v3.3.0/go.mod h1:ArNsafpqES2JuxQM5aM+bNe0FwHLIsL6pbjpiWvDwGs=
+git.ailur.dev/ailur/fg-library/v3 v3.4.0 h1:8Et4J6Psh7GBpQiDsQEd/hqftLzq6IMuB2AcCG+rsQA=
+git.ailur.dev/ailur/fg-library/v3 v3.4.0/go.mod h1:ArNsafpqES2JuxQM5aM+bNe0FwHLIsL6pbjpiWvDwGs=
+git.ailur.dev/ailur/fg-library/v3 v3.5.0 h1:BGDlS4nQ2PyZWNU4gH3eckVqhZUFIM/zKIj/HXx8RmA=
+git.ailur.dev/ailur/fg-library/v3 v3.5.0/go.mod h1:ArNsafpqES2JuxQM5aM+bNe0FwHLIsL6pbjpiWvDwGs=
 git.ailur.dev/ailur/fg-nucleus-library v1.0.5 h1:0YVSHFOeydGR/pfq5AfiKQ5gWuxSnx8u2K8mHvEDDTI=
 git.ailur.dev/ailur/fg-nucleus-library v1.0.5/go.mod h1:nKYjJ+zJD1YcrEGWlyyA5r6CrzW8DWHVAnL9hkn2tNw=
-git.ailur.dev/ailur/pow v1.0.2 h1:8tb6mXZdyQYjrKRW+AUmWMi5wJoHh9Ch3oRqiJr/ivs=
+git.ailur.dev/ailur/pow v1.0.3 h1:LjLSol4ax+M+SoajVjbBoDjfmjH6pKu3fDka7bl2KGY=
-git.ailur.dev/ailur/pow v1.0.2/go.mod h1:fjFb1z5KtF6V14HRhGWiDmmJKggO8KyAP20Lr5OJI/g=
+git.ailur.dev/ailur/pow v1.0.3/go.mod h1:ClAmIdHQ/N9wTq5S4YWhQ5d9CPUBcEjVuOkT07zBdJ4=
 github.com/CAFxX/httpcompression v0.0.9 h1:0ue2X8dOLEpxTm8tt+OdHcgA+gbDge0OqFQWGKSqgrg=
 github.com/CAFxX/httpcompression v0.0.9/go.mod h1:XX8oPZA+4IDcfZ0A71Hz0mZsv/YJOgYygkFhizVPilM=
 github.com/andybalholm/brotli v1.0.5/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
@@ -15,18 +23,20 @@ github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ3
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/gabriel-vasile/mimetype v1.4.6 h1:3+PzJTKLkvgjeTbts6msPJt4DixhT4YtFNf1gtGe3zc=
+github.com/gabriel-vasile/mimetype v1.4.7 h1:SKFKl7kD0RiPdbht0s7hFtjl489WcQ1VyPW8ZzUMYCA=
-github.com/gabriel-vasile/mimetype v1.4.6/go.mod h1:JX1qVKqZd40hUPpAfiNTe0Sne7hdfKSbOqqmkq8GCXc=
+github.com/gabriel-vasile/mimetype v1.4.7/go.mod h1:GDlAgAyIRT27BhFl53XNAFtfjzOkLaF35JdEG0P7LtU=
-github.com/go-chi/chi/v5 v5.1.0 h1:acVI1TYaD+hhedDJ3r54HyA6sExp3HfXq7QWEEY/xMw=
+github.com/gabriel-vasile/mimetype v1.4.8 h1:FfZ3gj38NjllZIeJAmMhr+qKL8Wu+nOoI3GqacKw1NM=
-github.com/go-chi/chi/v5 v5.1.0/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8=
+github.com/gabriel-vasile/mimetype v1.4.8/go.mod h1:ByKUIKGjh1ODkGM1asKUbQZOLGrPjydw3hYPU2YU9t8=
+github.com/go-chi/chi/v5 v5.2.0 h1:Aj1EtB0qR2Rdo2dG4O94RIU35w2lvQSj6BRA4+qwFL0=
+github.com/go-chi/chi/v5 v5.2.0/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8=
 github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
 github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
 github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
 github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
 github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
-github.com/go-playground/validator/v10 v10.22.1 h1:40JcKH+bBNGFczGuoBYgX4I6m/i27HYW8P9FDk5PbgA=
+github.com/go-playground/validator/v10 v10.23.0 h1:/PwmTwZhS0dPkav3cdK9kV1FsAmrL8sThn8IHr/sO+o=
-github.com/go-playground/validator/v10 v10.22.1/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
+github.com/go-playground/validator/v10 v10.23.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
 github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk=
 github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
 github.com/google/brotli/go/cbrotli v0.0.0-20230829110029-ed738e842d2f h1:jopqB+UTSdJGEJT8tEqYyE29zN91fi2827oLET8tl7k=
@@ -64,21 +74,27 @@ github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpE
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/ulikunitz/xz v0.5.11/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
 github.com/valyala/gozstd v1.20.1 h1:xPnnnvjmaDDitMFfDxmQ4vpx0+3CdTg2o3lALvXTU/g=
 github.com/valyala/gozstd v1.20.1/go.mod h1:y5Ew47GLlP37EkTB+B4s7r6A5rdaeB7ftbl9zoYiIPQ=
 github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
 github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
-golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ=
+golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
-golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
-golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo=
+golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
-golang.org/x/net v0.31.0/go.mod h1:P4fl1q7dY2hnZFxEk4pPSkDHF+QqjitcnDjUQyMM+pM=
+golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
-golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s=
+golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
-golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
-golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug=
+golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
-golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4=
+golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
+golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
+golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=

services-src/auth/main.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	// Fulgens libraries
-	library "git.ailur.dev/ailur/fg-library/v2"
+	library "git.ailur.dev/ailur/fg-library/v3"
 	authLibrary "git.ailur.dev/ailur/fg-nucleus-library"
 	"git.ailur.dev/ailur/pow"
 
@@ -36,6 +36,7 @@ var ServiceInformation = library.Service{
 	Name: "Authentication",
 	Permissions: library.Permissions{
 		Authenticate:              false, // This service *is* the authentication service
+		Router:                    true,  // This service does require a router
 		Database:                  true,  // This service does require database access
 		BlobStorage:               false, // This service does not require blob storage
 		InterServiceCommunication: true,  // This service does require inter-service communication
@@ -44,6 +45,10 @@ var ServiceInformation = library.Service{
 	ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000004"),
 }
 
+var (
+	loggerService = uuid.MustParse("00000000-0000-0000-0000-000000000002")
+)
+
 func checkScopes(scopes []string) (bool, string, error) {
 	var clientKeyShare bool
 	for _, scope := range scopes {
@@ -65,15 +70,9 @@ func checkScopes(scopes []string) (bool, string, error) {
 	return clientKeyShare, string(scopeString), nil
 }
 
-func logFunc(message string, messageType uint64, information library.ServiceInitializationInformation) {
+func logFunc(message string, messageType library.MessageCode, information library.ServiceInitializationInformation) {
 	// Log the message to the logger service
-	information.Outbox <- library.InterServiceMessage{
+	information.SendISMessage(loggerService, messageType, message)
-		ServiceID:    ServiceInformation.ServiceID,
-		ForServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000002"), // Logger service
-		MessageType:  messageType,
-		SentAt:       time.Now(),
-		Message:      message,
-	}
 }
 
 func ensureTrailingSlash(url string) string {
@@ -194,6 +193,7 @@ func Main(information library.ServiceInitializationInformation) {
 	var mem *sql.DB
 	var publicKey ed25519.PublicKey
 	var privateKey ed25519.PrivateKey
+
 	// Load the configuration
 	privacyPolicy := information.Configuration["privacyPolicy"].(string)
 	hostName := information.Configuration["url"].(string)
@@ -205,22 +205,14 @@ func Main(information library.ServiceInitializationInformation) {
 	identifier := information.Configuration["identifier"].(string)
 	adminKey := information.Configuration["adminKey"].(string)
 
-	// Initiate a connection to the database
+	// Start the ISM processor
-	// Call service ID 1 to get the database connection information
+	go information.StartISProcessor()
-	information.Outbox <- library.InterServiceMessage{
-		ServiceID:    ServiceInformation.ServiceID,
-		ForServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"), // Service initialization service
-		MessageType:  1,                                                      // Request connection information
-		SentAt:       time.Now(),
-		Message:      nil,
-	}
 
-	// Wait for the response
+	// Initiate a connection to the database
-	response := <-information.Inbox
+	conn, err := information.GetDatabase()
-	if response.MessageType == 2 {
+	if err != nil {
-		// This is the connection information
+		logFunc(err.Error(), 3, information)
-		// Set up the database connection
+	}
-		conn = response.Message.(library.Database)
 	if conn.DBType == library.Sqlite {
 		// Create the global table
 		// Uniqueness check is a hack to ensure we only have one global row
@@ -257,7 +249,6 @@ func Main(information library.ServiceInitializationInformation) {
 		}
 	}
 	// Set up the in-memory cache
-		var err error
 	mem, err = sql.Open("sqlite3", "file:"+ServiceInformation.ServiceID.String()+"?mode=memory&cache=shared")
 	if err != nil {
 		logFunc(err.Error(), 3, information)
@@ -299,15 +290,10 @@ func Main(information library.ServiceInitializationInformation) {
 	if err != nil {
 		logFunc(err.Error(), 3, information)
 	}
-	} else {
-		// This is an error message
-		// Log the error message to the logger service
-		logFunc(response.Message.(error).Error(), 3, information)
-	}
 
 	// Set up the signing keys
 	// Check if the global table has the keys
-	err := conn.DB.QueryRow("SELECT key FROM global LIMIT 1").Scan(&privateKey)
+	err = conn.DB.QueryRow("SELECT key FROM global LIMIT 1").Scan(&privateKey)
 	if err != nil {
 		if errors.Is(err, sql.ErrNoRows) {
 			// Generate a new key
@@ -413,7 +399,6 @@ func Main(information library.ServiceInitializationInformation) {
 
 	router.Get("/authorize", func(w http.ResponseWriter, r *http.Request) {
 		if r.URL.Query().Get("client_id") != "" {
-			if conn.DBType == library.Sqlite {
 			var name string
 			var creator []byte
 			err := conn.DB.QueryRow("SELECT name, creator FROM oauth WHERE appId = $1", r.URL.Query().Get("client_id")).Scan(&name, &creator)
@@ -427,6 +412,7 @@ func Main(information library.ServiceInitializationInformation) {
 				return
 			}
 
+			// Check if the app is internal
 			if !bytes.Equal(creator, ServiceInformation.ServiceID[:]) {
 				renderTemplate(200, w, map[string]interface{}{
 					"identifier": identifier,
@@ -438,32 +424,6 @@ func Main(information library.ServiceInitializationInformation) {
 					"name":       name,
 				}, "autoAccept.html", information)
 			}
-			} else {
-				var name string
-				var creator []byte
-				err := conn.DB.QueryRow("SELECT name, creator FROM oauth WHERE appId = $1", r.URL.Query().Get("client_id")).Scan(&name, &creator)
-				if err != nil {
-					if errors.Is(err, sql.ErrNoRows) {
-						renderString(404, w, "App not found", information)
-					} else {
-						logFunc(err.Error(), 2, information)
-						renderString(500, w, "Sorry, something went wrong on our end. Error code: 03. Please report to the administrator.", information)
-					}
-					return
-				}
-
-				if uuid.Must(uuid.FromBytes(creator)) != ServiceInformation.ServiceID {
-					renderTemplate(200, w, map[string]interface{}{
-						"identifier": identifier,
-						"name":       name,
-					}, "authorize.html", information)
-				} else {
-					renderTemplate(200, w, map[string]interface{}{
-						"identifier": identifier,
-						"name":       name,
-					}, "autoAccept.html", information)
-				}
-			}
 		} else {
 			http.Redirect(w, r, "/dashboard", 301)
 		}
@@ -1632,33 +1592,20 @@ func Main(information library.ServiceInitializationInformation) {
 	go func() {
 		for {
 			// Wait for a message
-			message := <-information.Inbox
+			message := information.AcceptMessage()
 
-			if message.ServiceID != uuid.MustParse("00000000-0000-0000-0000-000000000001") {
 			// Check the message type
 			switch message.MessageType {
 			case 0:
-					// A service would like to know our hostname
+				// A service would like to have the hostname
 				// Send it to them
-					information.Outbox <- library.InterServiceMessage{
+				message.Respond(library.Success, hostName)
-						MessageType:  0,
-						ServiceID:    ServiceInformation.ServiceID,
-						ForServiceID: message.ServiceID,
-						Message:      hostName,
-						SentAt:       time.Now(),
-					}
 			case 1:
 				// A service would like to register a new OAuth entry
 				// Validate the scopes
 				clientKeyShare, scopes, err := checkScopes(message.Message.(authLibrary.OAuthInformation).Scopes)
 				if err != nil {
-						information.Outbox <- library.InterServiceMessage{
+					message.Respond(library.BadRequest, err)
-							MessageType:  2,
-							ServiceID:    ServiceInformation.ServiceID,
-							ForServiceID: message.ServiceID,
-							Message:      err.Error(),
-							SentAt:       time.Now(),
-						}
 					return
 				}
 
@@ -1674,27 +1621,15 @@ func Main(information library.ServiceInitializationInformation) {
 					}
 
 					if err != nil {
-							information.Outbox <- library.InterServiceMessage{
+						message.Respond(library.InternalError, err)
-								MessageType:  1,
-								ServiceID:    ServiceInformation.ServiceID,
-								ForServiceID: message.ServiceID,
-								Message:      "38",
-								SentAt:       time.Now(),
-							}
 						logFunc(err.Error(), 2, information)
 						return
 					}
 
-						information.Outbox <- library.InterServiceMessage{
+					message.Respond(library.Success, authLibrary.OAuthResponse{
-							MessageType:  0,
-							ServiceID:    ServiceInformation.ServiceID,
-							ForServiceID: message.ServiceID,
-							Message: authLibrary.OAuthResponse{
 						AppID:     appId,
 						SecretKey: secret,
-							},
+					})
-							SentAt: time.Now(),
-						}
 
 					return
 				}
@@ -1703,13 +1638,7 @@ func Main(information library.ServiceInitializationInformation) {
 				// It must be able to be sent via JSON, so we can't have pure-binary data
 				secret, err = randomChars(512)
 				if err != nil {
-						information.Outbox <- library.InterServiceMessage{
+					message.Respond(library.InternalError, err)
-							MessageType:  1,
-							ServiceID:    ServiceInformation.ServiceID,
-							ForServiceID: message.ServiceID,
-							Message:      "36",
-							SentAt:       time.Now(),
-						}
 					logFunc(err.Error(), 2, information)
 					return
 				}
@@ -1721,39 +1650,20 @@ func Main(information library.ServiceInitializationInformation) {
 					_, err = conn.DB.Exec("INSERT INTO oauth (appId, secret, creator, name, redirectUri, scopes) VALUES ($1, $2, $3, $4, $5, $6)", message.ServiceID.String(), secret, ServiceInformation.ServiceID[:], message.Message.(authLibrary.OAuthInformation).Name, message.Message.(authLibrary.OAuthInformation).RedirectUri, scopes)
 				}
 				if err != nil {
-						information.Outbox <- library.InterServiceMessage{
+					message.Respond(library.InternalError, err)
-							MessageType:  1,
-							ServiceID:    ServiceInformation.ServiceID,
-							ForServiceID: message.ServiceID,
-							Message:      "39",
-							SentAt:       time.Now(),
-						}
 					logFunc(err.Error(), 2, information)
 					return
 				}
 
 				// Return the appId and secret
-					information.Outbox <- library.InterServiceMessage{
+				message.Respond(library.Success, authLibrary.OAuthResponse{
-						MessageType:  0,
-						ServiceID:    ServiceInformation.ServiceID,
-						ForServiceID: message.ServiceID,
-						Message: authLibrary.OAuthResponse{
 					AppID:     appId,
 					SecretKey: secret,
-						},
+				})
-						SentAt: time.Now(),
-					}
 			case 2:
 				// A service would like to have the public key
 				// Send it to them
-					information.Outbox <- library.InterServiceMessage{
+				message.Respond(library.Success, publicKey)
-						MessageType:  2,
-						ServiceID:    ServiceInformation.ServiceID,
-						ForServiceID: message.ServiceID,
-						Message:      publicKey,
-						SentAt:       time.Now(),
-					}
-				}
 			}
 		}
 	}()

services-src/auth/resources/wasm/testApp/main.go

@@ -236,7 +236,7 @@ func main() {
 			// Redirect to the client key exchange endpoint
 			js.Global().Get("swipe").Get("classList").Call("add", "swipe-animate")
 			time.Sleep(sleepTime)
-			js.Global().Get("window").Get("location").Call("replace", "/clientKeyShare?ecdhPublicKey="+base64.URLEncoding.EncodeToString(privateKey.PublicKey().Bytes())+"&accessToken="+responseMap["access_token"].(string))
+			//			js.Global().Get("window").Get("location").Call("replace", "/clientKeyShare?ecdhPublicKey="+base64.URLEncoding.EncodeToString(privateKey.PublicKey().Bytes())+"&accessToken="+responseMap["access_token"].(string))
 			return
 		} else if response.StatusCode != 500 {
 			statusBox.Set("innerText", responseMap["error"].(string))

services-src/storage/main.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"bytes"
-	library "git.ailur.dev/ailur/fg-library/v2"
+	library "git.ailur.dev/ailur/fg-library/v3"
 	nucleusLibrary "git.ailur.dev/ailur/fg-nucleus-library"
 
 	"errors"
@@ -26,34 +26,26 @@ var ServiceInformation = library.Service{
 	ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000003"),
 }
 
-var conn library.Database
+var (
+	conn          library.Database
+	loggerService = uuid.MustParse("00000000-0000-0000-0000-000000000002")
+)
 
-func logFunc(message string, messageType uint64, information library.ServiceInitializationInformation) {
+func logFunc(message string, messageType library.MessageCode, information library.ServiceInitializationInformation) {
-	// Log the error message to the logger service
+	// Log the message to the logger service
-	information.Outbox <- library.InterServiceMessage{
+	information.SendISMessage(loggerService, messageType, message)
-		ServiceID:    ServiceInformation.ServiceID,
-		ForServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000002"), // Logger service
-		MessageType:  messageType,
-		SentAt:       time.Now(),
-		Message:      message,
-	}
 }
 
-func respondError(message string, information library.ServiceInitializationInformation, myFault bool, serviceID uuid.UUID) {
+func respondError(message library.InterServiceMessage, err error, information library.ServiceInitializationInformation, myFault bool) {
 	// Respond with an error message
-	var err uint64 = 1
+	var errCode = library.BadRequest
 	if myFault {
 		// Log the error message to the logger service
-		logFunc(message, 2, information)
+		logFunc(err.Error(), 2, information)
-		err = 2
+		errCode = library.InternalError
-	}
-	information.Outbox <- library.InterServiceMessage{
-		ServiceID:    ServiceInformation.ServiceID,
-		ForServiceID: serviceID,
-		MessageType:  err,
-		SentAt:       time.Now(),
-		Message:      errors.New(message),
 	}
+
+	message.Respond(errCode, err)
 }
 
 func checkUserExists(userID uuid.UUID) bool {
@@ -78,23 +70,17 @@ func addQuota(information library.ServiceInitializationInformation, message libr
 	if checkUserExists(userID) {
 		_, err := conn.DB.Exec("UPDATE users SET quota = quota + $1 WHERE id = $2", message.Message.(nucleusLibrary.Quota).Bytes, message.Message.(nucleusLibrary.Quota).User)
 		if err != nil {
-			respondError(err.Error(), information, true, message.ServiceID)
+			respondError(message, err, information, true)
 		}
 	} else {
 		_, err := conn.DB.Exec("INSERT INTO users (id, quota, reserved) VALUES ($1, $2, 0)", userID[:], int64(information.Configuration["defaultQuota"].(int))+message.Message.(nucleusLibrary.Quota).Bytes)
 		if err != nil {
-			respondError(err.Error(), information, true, message.ServiceID)
+			respondError(message, err, information, true)
 		}
 	}
 
 	// Success
-	information.Outbox <- library.InterServiceMessage{
+	message.Respond(library.Success, nil)
-		ServiceID:    ServiceInformation.ServiceID,
-		ForServiceID: message.ServiceID,
-		MessageType:  0,
-		SentAt:       time.Now(),
-		Message:      nil,
-	}
 }
 
 // And so does addReserved
@@ -105,40 +91,34 @@ func addReserved(information library.ServiceInitializationInformation, message l
 		// Check if the user has enough space
 		quota, err := getQuota(userID)
 		if err != nil {
-			respondError(err.Error(), information, true, message.ServiceID)
+			respondError(message, err, information, true)
 		}
 		used, err := getUsed(userID, information)
 		if err != nil {
-			respondError(err.Error(), information, true, message.ServiceID)
+			respondError(message, err, information, true)
 		}
 		if used+message.Message.(nucleusLibrary.Quota).Bytes > quota {
-			respondError("insufficient storage", information, false, message.ServiceID)
+			respondError(message, errors.New("insufficient storage"), information, false)
 			return
 		}
 		_, err = conn.DB.Exec("UPDATE users SET reserved = reserved + $1 WHERE id = $2", message.Message.(nucleusLibrary.Quota).Bytes, userID[:])
 		if err != nil {
-			respondError(err.Error(), information, true, message.ServiceID)
+			respondError(message, err, information, true)
 		}
 	} else {
 		// Check if the user has enough space
 		if int64(information.Configuration["defaultQuota"].(int)) < message.Message.(nucleusLibrary.Quota).Bytes {
-			respondError("insufficient storage", information, false, message.ServiceID)
+			respondError(message, errors.New("insufficient storage"), information, false)
 			return
 		}
 		_, err := conn.DB.Exec("INSERT INTO users (id, quota, reserved) VALUES ($1, $2, $3)", userID[:], int64(information.Configuration["defaultQuota"].(int)), message.Message.(nucleusLibrary.Quota).Bytes)
 		if err != nil {
-			respondError(err.Error(), information, true, message.ServiceID)
+			respondError(message, err, information, true)
 		}
 	}
 
 	// Success
-	information.Outbox <- library.InterServiceMessage{
+	message.Respond(library.Success, nil)
-		ServiceID:    ServiceInformation.ServiceID,
-		ForServiceID: message.ServiceID,
-		MessageType:  0,
-		SentAt:       time.Now(),
-		Message:      nil,
-	}
 }
 
 func getQuota(userID uuid.UUID) (int64, error) {
@@ -190,45 +170,49 @@ func modifyFile(information library.ServiceInitializationInformation, message li
 	// Check if the file already exists
 	path := filepath.Join(information.Configuration["path"].(string), message.Message.(nucleusLibrary.File).User.String(), message.Message.(nucleusLibrary.File).Name)
 
+	logFunc(path, 0, information)
+
 	_, err := os.Stat(path)
-	if os.IsNotExist(err) {
+	if err == nil {
 		// Delete the file
 		err = os.Remove(path)
 		if err != nil {
-			respondError(err.Error(), information, true, message.ServiceID)
+			respondError(message, err, information, true)
 		}
+	} else if !os.IsNotExist(err) {
+		respondError(message, err, information, true)
 	}
 
 	// Check if the user has enough space
 	quota, err := getQuota(message.Message.(nucleusLibrary.File).User)
 	if err != nil {
-		respondError(err.Error(), information, true, message.ServiceID)
+		respondError(message, err, information, true)
 	}
 	used, err := getUsed(message.Message.(nucleusLibrary.File).User, information)
 	if err != nil {
-		respondError(err.Error(), information, true, message.ServiceID)
+		respondError(message, err, information, true)
 	}
 	if used+int64(len(message.Message.(nucleusLibrary.File).Bytes)) > quota {
-		respondError("insufficient storage", information, false, message.ServiceID)
+		respondError(message, errors.New("insufficient storage"), information, false)
 		return
 	}
 
 	// Add a file to the user's storage
 	file, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0644)
 	if err != nil {
-		respondError(err.Error(), information, true, message.ServiceID)
+		respondError(message, err, information, true)
 	}
 
 	// Write the file
 	_, err = file.Write(message.Message.(nucleusLibrary.File).Bytes)
 	if err != nil {
-		respondError(err.Error(), information, true, message.ServiceID)
+		respondError(message, err, information, true)
 	}
 
 	// Close the file
 	err = file.Close()
 	if err != nil {
-		respondError(err.Error(), information, true, message.ServiceID)
+		respondError(message, err, information, true)
 	}
 
 	// Success
@@ -247,14 +231,14 @@ func getFile(information library.ServiceInitializationInformation, message libra
 
 	_, err := os.Stat(path)
 	if os.IsNotExist(err) {
-		respondError("file not found", information, false, message.ServiceID)
+		respondError(message, errors.New("file not found"), information, false)
 		return
 	}
 
 	// Open the file
 	file, err := os.Open(path)
 	if err != nil {
-		respondError(err.Error(), information, true, message.ServiceID)
+		respondError(message, err, information, true)
 	}
 
 	// Respond with the file
@@ -274,14 +258,14 @@ func deleteFile(information library.ServiceInitializationInformation, message li
 
 	_, err := os.Stat(path)
 	if os.IsNotExist(err) {
-		respondError("file not found", information, false, message.ServiceID)
+		respondError(message, errors.New("file not found"), information, false)
 		return
 	}
 
 	// Delete the file
 	err = os.Remove(path)
 	if err != nil {
-		respondError(err.Error(), information, true, message.ServiceID)
+		respondError(message, err, information, true)
 	}
 
 	// Success
@@ -298,7 +282,7 @@ func deleteFile(information library.ServiceInitializationInformation, message li
 func processInterServiceMessages(information library.ServiceInitializationInformation) {
 	// Listen for incoming messages
 	for {
-		message := <-information.Inbox
+		message := information.AcceptMessage()
 		switch message.MessageType {
 		case 1:
 			// Add quota
@@ -316,28 +300,21 @@ func processInterServiceMessages(information library.ServiceInitializationInform
 			deleteFile(information, message)
 		default:
 			// Respond with an error message
-			respondError("invalid message type", information, false, message.ServiceID)
+			respondError(message, errors.New("invalid message type"), information, false)
 		}
 	}
 }
 
 func Main(information library.ServiceInitializationInformation) {
-	// Initiate a connection to the database
+	// Start up the ISM processor
-	// Call service ID 1 to get the database connection information
+	information.StartISProcessor()
-	information.Outbox <- library.InterServiceMessage{
+
-		ServiceID:    ServiceInformation.ServiceID,
+	// Get the database connection
-		ForServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"), // Service initialization service
+	conn, err := information.GetDatabase()
-		MessageType:  1,                                                      // Request connection information
+	if err != nil {
-		SentAt:       time.Now(),
+		logFunc(err.Error(), 3, information)
-		Message:      nil,
 	}
 
-	// Wait for the response
-	response := <-information.Inbox
-	if response.MessageType == 2 {
-		// This is the connection information
-		// Set up the database connection
-		conn = response.Message.(library.Database)
 	// Create the quotas table if it doesn't exist
 	if conn.DBType == library.Sqlite {
 		_, err := conn.DB.Exec("CREATE TABLE IF NOT EXISTS users (id BLOB PRIMARY KEY, quota BIGINT, reserved BIGINT)")
@@ -350,11 +327,6 @@ func Main(information library.ServiceInitializationInformation) {
 			logFunc(err.Error(), 3, information)
 		}
 	}
-	} else {
-		// This is an error message
-		// Log the error message to the logger service
-		logFunc(response.Message.(error).Error(), 3, information)
-	}
 
 	// Listen for incoming messages
 	go processInterServiceMessages(information)