First commit: Plain HTTP server + SMTP client for POST /email

.devcontainer/devcontainer.json

@@ -0,0 +1,17 @@
+{
+  "name": "corentin-regent/portfolio-back",
+  "image": "mcr.microsoft.com/devcontainers/go:bookworm",
+  "features": {
+    "ghcr.io/devcontainers/features/docker-in-docker": {}
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "bierner.markdown-preview-github-styles",
+        "github.vscode-github-actions",
+        "ms-azuretools.vscode-docker",
+        "yzhang.markdown-all-in-one"
+      ]
+    }
+  }
+}

.github/dependabot.yml

@@ -0,0 +1,17 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+
+  - package-ecosystem: gomod
+    directory: /
+    schedule:
+      interval: weekly
+    groups:
+      dependencies:
+        applies-to: version-updates
+        update-types:
+          - minor
+          - patch

.gitignore

@@ -0,0 +1,3 @@
+env.sh
+
+/portfolio-back

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Corentin Régent
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,3 @@
+# Backend for my portfolio website
+
+This is a Work In Progress

api/email.go

@@ -0,0 +1,176 @@
+package api
+
+import (
+	"context"
+	"crypto/tls"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net"
+	"net/http"
+	"net/smtp"
+	"net/url"
+	"sync"
+)
+
+const smtpsPort = "587"
+
+type smtpServer struct {
+	Host string
+	Port string
+}
+
+func (server *smtpServer) Name() string {
+	return server.Host + ":" + server.Port
+}
+
+type postEmailData struct {
+	Sender             string
+	Subject            string
+	Body               string
+	SuccessRedirectUrl string
+}
+
+func HandleEmail(
+	appContext context.Context,
+	shutdownWaitGroup *sync.WaitGroup,
+	getEnv func(string) string,
+) func(http.ResponseWriter, *http.Request) {
+
+	smtpClientDomain := getEnv("SMTP_CLIENT_DOMAIN")
+	smtpServerDomain := getEnv("SMTP_SERVER_DOMAIN")
+	targetEmailAddress := getEnv("TARGET_EMAIL_ADDRESS")
+	sourceEmailAddress := getEnv("SOURCE_EMAIL_ADDRESS")
+	sourceEmailPassword := getEnv("SOURCE_EMAIL_PASSWORD")
+
+	var (
+		initSmtp     sync.Once
+		smtpClient   *smtp.Client
+		smtpSetupErr error
+	)
+
+	buildMessage := func(email *postEmailData) string {
+		return fmt.Sprintf("To: %s\r\nSubject: %s\r\n\r\n%s\r\n\r\nSent by %s", targetEmailAddress, email.Subject, email.Body, email.Sender)
+	}
+
+	setupSmtpClient := func() (client *smtp.Client, err error) {
+		server := smtpServer{
+			Host: smtpServerDomain,
+			Port: smtpsPort,
+		}
+		tlsConfig := &tls.Config{
+			ServerName: server.Host,
+		}
+		auth := smtp.PlainAuth("", sourceEmailAddress, sourceEmailPassword, server.Host)
+
+		log.Println("[DEBUG] Establishing TCP connection with SMTP server")
+		conn, err := net.Dial("tcp", server.Name())
+		if err != nil {
+			return
+		}
+		log.Println("[DEBUG] Creating SMTP client")
+		client, err = smtp.NewClient(conn, server.Host)
+		if err != nil {
+			return
+		}
+		log.Println("[DEBUG] Sending HELLO to SMTP server")
+		if err = client.Hello(smtpClientDomain); err != nil {
+			return
+		}
+		log.Println("[DEBUG] Negotiating TLS encryption for SMTP communication")
+		if err = client.StartTLS(tlsConfig); err != nil {
+			return
+		}
+		log.Println("[DEBUG] Authenticating to the SMTP server")
+		err = client.Auth(auth)
+		return
+	}
+
+	sendEmail := func(client *smtp.Client, email *postEmailData) (err error) {
+		log.Println("[DEBUG] Setting SMTP email sender")
+		if err = client.Mail(sourceEmailAddress); err != nil {
+			return
+		}
+		log.Println("[DEBUG] Setting SMTP email receiver")
+		if err = client.Rcpt(targetEmailAddress); err != nil {
+			return
+		}
+		log.Println("[DEBUG] Starting SMTP email body")
+		messageWriter, err := client.Data()
+		if err != nil {
+			return
+		}
+		log.Println("[DEBUG] Writing SMTP email body")
+		_, err = messageWriter.Write([]byte(buildMessage(email)))
+		if err != nil {
+			return
+		}
+		log.Println("[DEBUG] Sending SMTP email")
+		err = messageWriter.Close()
+		return
+	}
+
+	failPostEmail := func(response http.ResponseWriter, request *http.Request, email postEmailData, err error) {
+		log.Printf("[ERROR] POST /email failed: %s\n", err)
+		failureRedirectUrl := fmt.Sprintf(
+			"mailto:%s?subject=%s&body=%s",
+			targetEmailAddress,
+			url.PathEscape(email.Subject),
+			url.PathEscape(email.Body),
+		)
+		http.Redirect(response, request, failureRedirectUrl, http.StatusSeeOther)
+	}
+
+	handlePostEmail := func(response http.ResponseWriter, request *http.Request) {
+		decoder := json.NewDecoder(request.Body)
+		var email postEmailData
+		err := decoder.Decode(&email)
+		if err != nil {
+			http.Error(response, err.Error(), http.StatusBadRequest)
+		}
+
+		initSmtp.Do(func() {
+			log.Println("[INFO] Setting up SMTP client")
+			smtpClient, smtpSetupErr = setupSmtpClient()
+			if smtpSetupErr == nil {
+				log.Println("[INFO] SMTP client is ready")
+			} else {
+				log.Printf("[ERROR] SMTP client setup failed: %s\n", smtpSetupErr)
+			}
+		})
+		if smtpSetupErr != nil {
+			failPostEmail(response, request, email, smtpSetupErr)
+			return
+		}
+
+		err = sendEmail(smtpClient, &email)
+		if err == nil {
+			http.Redirect(response, request, email.SuccessRedirectUrl, http.StatusFound)
+		} else {
+			failPostEmail(response, request, email, err)
+		}
+	}
+
+	shutdownWaitGroup.Add(1)
+	listenForShutdown := func() {
+		<-appContext.Done()
+		if smtpClient != nil {
+			log.Println("[INFO] Shutting down SMTP client")
+			err := smtpClient.Quit()
+			if err != nil {
+				log.Printf("[ERROR] SMTP client shutdown failed: %s\n", err.Error())
+			}
+		}
+		shutdownWaitGroup.Done()
+	}
+
+	go listenForShutdown()
+	return func(response http.ResponseWriter, request *http.Request) {
+		switch request.Method {
+		case http.MethodPost:
+			handlePostEmail(response, request)
+		default:
+			http.Error(response, fmt.Sprintf("unexpected method %q", request.Method), http.StatusBadRequest)
+		}
+	}
+}

go.mod

@@ -0,0 +1,5 @@
+module portfolio-back
+
+go 1.22.6
+
+require github.com/rs/cors v1.11.0

go.sum

@@ -0,0 +1,2 @@
+github.com/rs/cors v1.11.0 h1:0B9GE/r9Bc2UxRMMtymBkHTenPkHDv0CW4Y98GBY+po=
+github.com/rs/cors v1.11.0/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU=

handler.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"context"
+	"net/http"
+	"sync"
+
+	"portfolio-back/middleware"
+)
+
+func NewHandler(
+	appContext context.Context,
+	shutdownWaitGroup *sync.WaitGroup,
+	getEnv func(string) string,
+) http.Handler {
+	serveMux := http.NewServeMux()
+	InstallRoutes(serveMux, appContext, shutdownWaitGroup, getEnv)
+	var handler http.Handler = middleware.Cors(serveMux, getEnv)
+	return handler
+}

main.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"sync"
+)
+
+func run(appContext context.Context, getEnv func(string) string) {
+	shutdownWaitGroup := &sync.WaitGroup{}
+	handler := NewHandler(appContext, shutdownWaitGroup, getEnv)
+	server := &http.Server{
+		Addr:    ":" + getEnv("HTTP_SERVER_PORT"),
+		Handler: handler,
+	}
+	go serve(server)
+	waitUntilShutdown(server, shutdownWaitGroup)
+}
+
+func serve(server *http.Server) {
+	log.Println("[INFO] HTTP server listening")
+	err := server.ListenAndServe()
+	if !errors.Is(err, http.ErrServerClosed) {
+		log.Printf("[ERROR] HTTP server crashed: %s\n", err)
+	}
+}
+
+func waitUntilShutdown(server *http.Server, shutdownWaitGroup *sync.WaitGroup) {
+	shutdownWaitGroup.Wait()
+	log.Println("[INFO] Shutting down HTTP server")
+	err := server.Shutdown(context.Background())
+	if err != nil {
+		log.Printf("[ERROR] HTTP server shutdown failed: %s\n", err)
+	}
+}
+
+func main() {
+	appContext, _ := signal.NotifyContext(context.Background(), os.Interrupt)
+	run(appContext, os.Getenv)
+}

middleware/cors.go

@@ -0,0 +1,16 @@
+package middleware
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/rs/cors"
+)
+
+func Cors(handler http.Handler, getEnv func(string) string) http.Handler {
+	corsConfig := cors.Options{
+		AllowedOrigins: strings.Split(getEnv("CORS_ALLOWED_ORIGINS"), " "),
+		AllowedMethods: []string{http.MethodPost},
+	}
+	return cors.New(corsConfig).Handler(handler)
+}

routes.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"context"
+	"net/http"
+	"sync"
+
+	"portfolio-back/api"
+)
+
+func InstallRoutes(
+	serveMux *http.ServeMux,
+	appContext context.Context,
+	shutdownWaitGroup *sync.WaitGroup,
+	getEnv func(string) string,
+) {
+	serveMux.HandleFunc("/email", api.HandleEmail(appContext, shutdownWaitGroup, getEnv))
+}