rewrote packages

keyservice joinservice upgrade-agent measurement-reader debugd disk-mapper rewrote joinservice main rewrote some unit tests rewrote upgrade-agent + some grpc functions rewrote measurement-reader rewrote debugd removed unused import removed forgotten zap reference in measurements reader rewrote disk-mapper + tests rewrote packages verify disk-mapper malicious join bootstrapper attestationconfigapi versionapi internal/cloud/azure disk-mapper tests image/upload/internal/cmd rewrote verify (WIP with loglevel increase) rewrote forgotten zap references in disk-mapper rewrote malicious join rewrote bootstrapper rewrote parts of internal/ rewrote attestationconfigapi (WIP) rewrote versionapi cli rewrote internal/cloud/azure rewrote disk-mapper tests (untested by me rn) rewrote image/upload/internal/cmd removed forgotten zap references in verify/cmd rewrote packages hack/oci-pin hack/qemu-metadata-api debugd/internal/debugd/deploy hack/bazel-deps-mirror cli/internal/cmd cli-k8s-compatibility rewrote hack/qemu-metadata-api/server rewrote debugd/internal/debugd/deploy rewrote hack/bazel-deps-mirror rewrote rest of hack/qemu-metadata-api rewrote forgotten zap references in joinservice server rewrote cli/internal/cmd rewrote cli-k8s-compatibility rewrote packages internal/staticupload e2d/internal/upgrade internal/constellation/helm internal/attestation/aws/snp internal/attestation/azure/trustedlaunch joinservice/internal/certcache/amkds some missed unit tests rewrote e2e/internal/upgrade rewrote internal/constellation/helm internal/attestation/aws/snp internal/attestation/azure/trustedlaunch joinservice/internal/certcache/amkds search and replace test logging over all left *_test.go
2025-05-14 12:12:25 -04:00 · 2023-12-29 15:18:59 +01:00 · 2023-12-29 15:18:59 +01:00 · f16ccf5679
commit f16ccf5679
parent 48d5a157dd
158 changed files with 3400 additions and 1278 deletions
--- a/hack/qemu-metadata-api/main.go
+++ b/hack/qemu-metadata-api/main.go
@ -9,33 +9,34 @@ SPDX-License-Identifier: AGPL-3.0-only
 package main

 import (
-	"flag"
+  "flag"
+  "log/slog"
+  "os"

-	"github.com/edgelesssys/constellation/v2/hack/qemu-metadata-api/server"
-	"github.com/edgelesssys/constellation/v2/hack/qemu-metadata-api/virtwrapper"
-	"github.com/edgelesssys/constellation/v2/internal/logger"
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-	"libvirt.org/go/libvirt"
+  "github.com/edgelesssys/constellation/v2/hack/qemu-metadata-api/server"
+  "github.com/edgelesssys/constellation/v2/hack/qemu-metadata-api/virtwrapper"
+  "libvirt.org/go/libvirt"
 )

 func main() {
-	bindPort := flag.String("port", "8080", "Port to bind to")
-	targetNetwork := flag.String("network", "constellation-network", "Name of the network in QEMU to use")
-	libvirtURI := flag.String("libvirt-uri", "qemu:///system", "URI of the libvirt connection")
-	initSecretHash := flag.String("initsecrethash", "", "brcypt hash of the init secret")
-	flag.Parse()
+  bindPort := flag.String("port", "8080", "Port to bind to")
+  targetNetwork := flag.String("network", "constellation-network", "Name of the network in QEMU to use")
+  libvirtURI := flag.String("libvirt-uri", "qemu:///system", "URI of the libvirt connection")
+  initSecretHash := flag.String("initsecrethash", "", "brcypt hash of the init secret")
+  flag.Parse()

-	log := logger.New(logger.JSONLog, zapcore.InfoLevel)
+  log := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))

-	conn, err := libvirt.NewConnect(*libvirtURI)
-	if err != nil {
-		log.With(zap.Error(err)).Fatalf("Failed to connect to libvirt")
-	}
-	defer conn.Close()
+  conn, err := libvirt.NewConnect(*libvirtURI)
+  if err != nil {
+    log.With(slog.Any("error", err)).Error("Failed to connect to libvirt")
+    os.Exit(1)
+  }
+  defer conn.Close()

-	serv := server.New(log, *targetNetwork, *initSecretHash, &virtwrapper.Connect{Conn: conn})
-	if err := serv.ListenAndServe(*bindPort); err != nil {
-		log.With(zap.Error(err)).Fatalf("Failed to serve")
-	}
+  serv := server.New(log, *targetNetwork, *initSecretHash, &virtwrapper.Connect{Conn: conn})
+  if err := serv.ListenAndServe(*bindPort); err != nil {
+    log.With(slog.Any("error", err)).Error("Failed to serve")
+    os.Exit(1)
+  }
 }
--- a/hack/qemu-metadata-api/server/server.go
+++ b/hack/qemu-metadata-api/server/server.go
@ -9,27 +9,27 @@ package server
 import (
 	"encoding/json"
 	"fmt"
+	"io"
+	"log/slog"
 	"net"
 	"net/http"
 	"strings"

 	"github.com/edgelesssys/constellation/v2/hack/qemu-metadata-api/virtwrapper"
 	"github.com/edgelesssys/constellation/v2/internal/cloud/metadata"
-	"github.com/edgelesssys/constellation/v2/internal/logger"
 	"github.com/edgelesssys/constellation/v2/internal/role"
-	"go.uber.org/zap"
 )

 // Server that provides QEMU metadata.
 type Server struct {
-	log               *logger.Logger
+	log               *slog.Logger
 	virt              virConnect
 	network           string
 	initSecretHashVal []byte
 }

 // New creates a new Server.
-func New(log *logger.Logger, network, initSecretHash string, conn virConnect) *Server {
+func New(log *slog.Logger, network, initSecretHash string, conn virConnect) *Server {
 	return &Server{
 		log:               log,
 		virt:              conn,
@ -55,25 +55,25 @@ func (s *Server) ListenAndServe(port string) error {
 		return err
 	}

-	s.log.Infof("Starting QEMU metadata API on %s", lis.Addr())
+	s.log.Info("Starting QEMU metadata API on %s", lis.Addr())
 	return server.Serve(lis)
 }

 // listSelf returns peer information about the instance issuing the request.
 func (s *Server) listSelf(w http.ResponseWriter, r *http.Request) {
-	log := s.log.With(zap.String("peer", r.RemoteAddr))
-	log.Infof("Serving GET request for /self")
+	log := s.log.With(slog.String("peer", r.RemoteAddr))
+	log.Info("Serving GET request for /self")

 	remoteIP, _, err := net.SplitHostPort(r.RemoteAddr)
 	if err != nil {
-		log.With(zap.Error(err)).Errorf("Failed to parse remote address")
+		log.With(slog.Any("error", err)).Error("Failed to parse remote address")
 		http.Error(w, fmt.Sprintf("Failed to parse remote address: %s\n", err), http.StatusInternalServerError)
 		return
 	}

 	peers, err := s.listAll()
 	if err != nil {
-		log.With(zap.Error(err)).Errorf("Failed to list peer metadata")
+		log.With(slog.Any("error", err)).Error("Failed to list peer metadata")
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
@ -85,23 +85,23 @@ func (s *Server) listSelf(w http.ResponseWriter, r *http.Request) {
 				http.Error(w, err.Error(), http.StatusInternalServerError)
 				return
 			}
-			log.Infof("Request successful")
+			log.Info("Request successful")
 			return
 		}
 	}

-	log.Errorf("Failed to find peer in active leases")
+	log.Error("Failed to find peer in active leases")
 	http.Error(w, "No matching peer found", http.StatusNotFound)
 }

 // listPeers returns a list of all active peers.
 func (s *Server) listPeers(w http.ResponseWriter, r *http.Request) {
-	log := s.log.With(zap.String("peer", r.RemoteAddr))
-	log.Infof("Serving GET request for /peers")
+	log := s.log.With(slog.String("peer", r.RemoteAddr))
+	log.Info("Serving GET request for /peers")

 	peers, err := s.listAll()
 	if err != nil {
-		log.With(zap.Error(err)).Errorf("Failed to list peer metadata")
+		log.With(slog.Any("error", err)).Error("Failed to list peer metadata")
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
@ -111,38 +111,38 @@ func (s *Server) listPeers(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
-	log.Infof("Request successful")
+	log.Info("Request successful")
 }

 // initSecretHash returns the hash of the init secret.
 func (s *Server) initSecretHash(w http.ResponseWriter, r *http.Request) {
-	log := s.log.With(zap.String("initSecretHash", r.RemoteAddr))
+	log := s.log.With(slog.String("initSecretHash", r.RemoteAddr))
 	if r.Method != http.MethodGet {
-		log.With(zap.String("method", r.Method)).Errorf("Invalid method for /initSecretHash")
+		log.With(slog.String("method", r.Method)).Error("Invalid method for /initSecretHash")
 		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 		return
 	}
-	log.Infof("Serving GET request for /initsecrethash")
+	log.Info("Serving GET request for /initsecrethash")

 	w.Header().Set("Content-Type", "text/plain")
 	_, err := w.Write(s.initSecretHashVal)
 	if err != nil {
-		log.With(zap.Error(err)).Errorf("Failed to write init secret hash")
+		log.With(slog.Any("error", err)).Error("Failed to write init secret hash")
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
-	log.Infof("Request successful")
+	log.Info("Request successful")
 }

 // getEndpoint returns the IP address of the first control-plane instance.
 // This allows us to fake a load balancer for QEMU instances.
 func (s *Server) getEndpoint(w http.ResponseWriter, r *http.Request) {
-	log := s.log.With(zap.String("peer", r.RemoteAddr))
-	log.Infof("Serving GET request for /endpoint")
+	log := s.log.With(slog.String("peer", r.RemoteAddr))
+	log.Info("Serving GET request for /endpoint")

 	net, err := s.virt.LookupNetworkByName(s.network)
 	if err != nil {
-		log.With(zap.Error(err)).Errorf("Failed to lookup network")
+		log.With(slog.Any("error", err)).Error("Failed to lookup network")
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
@ -150,7 +150,7 @@ func (s *Server) getEndpoint(w http.ResponseWriter, r *http.Request) {

 	leases, err := net.GetDHCPLeases()
 	if err != nil {
-		log.With(zap.Error(err)).Errorf("Failed to get DHCP leases")
+		log.With(slog.Any("error", err)).Error("Failed to get DHCP leases")
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 	}

@ -162,12 +162,12 @@ func (s *Server) getEndpoint(w http.ResponseWriter, r *http.Request) {
 				http.Error(w, err.Error(), http.StatusInternalServerError)
 				return
 			}
-			log.Infof("Request successful")
+			log.Info("Request successful")
 			return
 		}
 	}

-	log.Errorf("Failed to find control-plane peer in active leases")
+	log.Error("Failed to find control-plane peer in active leases")
 	http.Error(w, "No matching peer found", http.StatusNotFound)
 }

--- a/hack/qemu-metadata-api/server/server_test.go
+++ b/hack/qemu-metadata-api/server/server_test.go
@ -11,6 +11,7 @@ import (
 	"encoding/json"
 	"errors"
 	"io"
+	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@ -67,7 +68,7 @@ func TestListAll(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			assert := assert.New(t)

-			server := New(logger.NewTest(t), "test", "initSecretHash", tc.connect)
+      server := New(slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), "test", "initSecretHash", tc.connect)

 			res, err := server.listAll()

@ -138,7 +139,7 @@ func TestListSelf(t *testing.T) {
 			assert := assert.New(t)
 			require := require.New(t)

-			server := New(logger.NewTest(t), "test", "initSecretHash", tc.connect)
+      server := New(slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), "test", "initSecretHash", tc.connect)

 			req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://192.0.0.1/self", nil)
 			require.NoError(err)
@ -198,7 +199,7 @@ func TestListPeers(t *testing.T) {
 			assert := assert.New(t)
 			require := require.New(t)

-			server := New(logger.NewTest(t), "test", "initSecretHash", tc.connect)
+      server := New(slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), "test", "initSecretHash", tc.connect)

 			req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://192.0.0.1/peers", nil)
 			require.NoError(err)
@ -253,7 +254,7 @@ func TestInitSecretHash(t *testing.T) {
 			assert := assert.New(t)
 			require := require.New(t)

-			server := New(logger.NewTest(t), "test", tc.wantHash, defaultConnect)
+      server := New(slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), "test", tc.wantHash, defaultConnect)

 			req, err := http.NewRequestWithContext(context.Background(), tc.method, "http://192.0.0.1/initsecrethash", nil)
 			require.NoError(err)