pacsoi service weight dist

Author: ponachte

README.md

@@ -101,7 +101,7 @@ More on accessing services in the [documentation](/docs/deploying-services.md)
 
 ### Cluster Management
 ```bash
-make init          # Create cluster, build & load containers, start cleaner
+make kind-init          # Create cluster, build & load containers, start cleaner
 make kind-start         # Create/start Kind cluster only
 make kind-stop          # Pause Kind cluster
 make kind-delete        # Delete Kind Cluster
@@ -164,12 +164,11 @@ sudo apt install -y golang-go
 
 ### Integration Tests
 
-Integration tests use the existing Kind cluster created by `make init`.
+Integration tests use the existing Kind cluster created by `make kind-init`.
 
 ```bash
 # First-time setup
-make init
-make deploy
+make kind-init
 
 # Run tests (uses existing cluster)
 make integration-test

containers/aggregator-server/config/client.go

@@ -3,6 +3,7 @@ package config
 import (
 	"aggregator/model"
 	"encoding/json"
+	"fmt"
 	"net/http"
 
 	"github.com/sirupsen/logrus"
@@ -13,14 +14,17 @@ type ClientIdentifierDocument struct {
 	ClientID string   `json:"client_id"`
 }
 
-var clientIdentifierJSONLD []byte
+var (
+	clientIdentifierJSON   []byte
+	clientIdentifierJSONLD []byte
+)
 
 func InitClientIdentifier(mux *http.ServeMux) {
 	logrus.Info("Initializing client identifier endpoint")
-	model.SolidClientId = model.ExternalURL() + "/client.jsonld"
 
-	var err error
+	model.SolidClientId = fmt.Sprintf("%s/id", model.ExternalURL())
 
+	var err error
 	// Pre-encode JSON-LD version (with context)
 	clientDocLD := ClientIdentifierDocument{
 		Context:  []string{"https://www.w3.org/ns/solid/oidc-context.jsonld"},
@@ -31,7 +35,16 @@ func InitClientIdentifier(mux *http.ServeMux) {
 		logrus.WithError(err).Fatal("Failed to marshal client identifier JSON-LD document")
 	}
 
-	mux.HandleFunc("/client.jsonld", handleClientIdentifier)
+	// Pre-encode JSON version (without context)
+	clientDocJSON := ClientIdentifierDocument{
+		ClientID: model.SolidClientId,
+	}
+	clientIdentifierJSON, err = json.Marshal(clientDocJSON)
+	if err != nil {
+		logrus.WithError(err).Fatal("Failed to marshal client identifier JSON document")
+	}
+
+	mux.HandleFunc("/id", handleClientIdentifier)
 	logrus.Info("Client identifier endpoint initialization completed")
 }
 
@@ -41,13 +54,28 @@ func handleClientIdentifier(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	w.Header().Set("Content-Type", "application/ld+json")
+	accept := r.Header.Get("Accept")
+
+	var contentType string
+	var body []byte
+
+	preferredType := negotiateContentType(accept, []string{"application/ld+json", "application/json"})
+
+	if preferredType == "application/json" {
+		contentType = "application/json"
+		body = clientIdentifierJSON
+	} else {
+		contentType = "application/ld+json"
+		body = clientIdentifierJSONLD
+	}
+
+	w.Header().Set("Content-Type", contentType)
 
 	if r.Method == http.MethodHead {
 		return
 	}
 
-	if _, err := w.Write(clientIdentifierJSONLD); err != nil {
+	if _, err := w.Write(body); err != nil {
 		logrus.WithError(err).Error("Failed to write client identifier document")
 	}
 }

containers/aggregator-server/config/description.go

@@ -12,7 +12,7 @@ type AggregatorServerDescription struct {
 	RegistrationEndpoint       string   `json:"registration_endpoint"`
 	SupportedRegistrationTypes []string `json:"supported_registration_types"`
 	Version                    string   `json:"version"`
-	ClientIdentifier           string   `json:"client_identifier"`
+	ClientIdentifier           string   `json:"client_identifier,omitempty"`
 	TransformationCatalog      string   `json:"transformation_catalog"`
 }
 
@@ -33,15 +33,12 @@ func handleServerDescription(w http.ResponseWriter, r *http.Request) {
 
 	// TODO: semantic representations need to be added at some point
 	supported := model.AllowedRegistrationTypes
-	if len(supported) == 0 {
-		supported = []string{"authorization_code"}
-	}
 
 	desc := AggregatorServerDescription{
 		RegistrationEndpoint:       fmt.Sprintf("%s%s", model.ExternalURL(), model.RegistrationEndpoint),
 		SupportedRegistrationTypes: supported,
 		Version:                    "1.0.0",
-		ClientIdentifier:           fmt.Sprintf("%s/client.jsonld", model.ExternalURL()),
+		ClientIdentifier:           model.SolidClientId,
 		TransformationCatalog:      fmt.Sprintf("%s%s", model.ExternalURL(), model.TransformationCatalog),
 	}
 

containers/aggregator-server/instance/deployment.go

@@ -4,12 +4,14 @@ import (
 	"aggregator/model"
 	"context"
 	"fmt"
+	"time"
 
 	appsv1 "k8s.io/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
 	networkingv1 "k8s.io/api/networking/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
+	"k8s.io/client-go/kubernetes"
 )
 
 func ensureDeployment(
@@ -183,6 +185,18 @@ func ensureDeployment(
 									ReadOnly:  true,
 								},
 							},
+							ReadinessProbe: &corev1.Probe{
+								ProbeHandler: corev1.ProbeHandler{
+									HTTPGet: &corev1.HTTPGetAction{
+										Path: "/healthz",
+										Port: intstr.FromInt(5000),
+									},
+								},
+								InitialDelaySeconds: 1,
+								PeriodSeconds:       2,
+								TimeoutSeconds:      5,
+								FailureThreshold:    5,
+							},
 						},
 					},
 					Volumes: []corev1.Volume{
@@ -206,5 +220,36 @@ func ensureDeployment(
 	if err != nil {
 		return fmt.Errorf("failed to create deployment: %w", err)
 	}
+
+	err = waitForDeploymentReady(model.Clientset, model.Namespace, deployment.Name, 2*time.Minute)
+	if err != nil {
+		return err
+	}
+
 	return nil
 }
+
+func waitForDeploymentReady(client kubernetes.Interface, namespace, name string, timeout time.Duration) error {
+	deadline := time.Now().Add(timeout)
+
+	for {
+		dep, err := client.AppsV1().
+			Deployments(namespace).
+			Get(context.TODO(), name, metav1.GetOptions{})
+		if err != nil {
+			return err
+		}
+
+		// Check if desired replicas are ready
+		if dep.Status.ReadyReplicas == *dep.Spec.Replicas &&
+			dep.Status.AvailableReplicas == *dep.Spec.Replicas {
+			return nil
+		}
+
+		if time.Now().After(deadline) {
+			return fmt.Errorf("timeout waiting for deployment to be ready")
+		}
+
+		time.Sleep(2 * time.Second)
+	}
+}

containers/aggregator-server/main.go

@@ -189,8 +189,10 @@ func main() {
 		logrus.WithError(err).Warn("Failed to set up configuration endpoint (UMA might be down)")
 	}
 
-	// Client Identifier endpoint
-	config.InitClientIdentifier(serverMux)
+	// Solid Client Identifier endpoint
+	if solidOIDCEnabled {
+		config.InitClientIdentifier(serverMux)
+	}
 
 	// Server Description endpoint
 	config.InitServerDescription(serverMux)

containers/aggregator-server/registration/registration.go

@@ -27,58 +27,95 @@ func RegistrationHandler(w http.ResponseWriter, r *http.Request) {
 
 // handleRegistrationPost handles POST requests for creating/updating aggregators
 func handleRegistrationPost(w http.ResponseWriter, r *http.Request) {
+	log := logrus.WithField("handler", "handleRegistrationPost")
+	log.Info("Incoming registration request")
+
 	// Parse request body
 	var req model.RegistrationRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		logrus.WithError(err).Warn("Invalid JSON body")
+		log.WithError(err).
+			WithField("stage", "decode_body").
+			Warn("Failed to decode JSON body")
 		http.Error(w, "Invalid JSON body", http.StatusBadRequest)
 		return
 	}
+	log.Debug("Request body successfully decoded")
 
-	// Validate registration_type is present
+	// Validate registration_type
 	if req.RegistrationType == "" {
-		logrus.Warn("Missing registration_type")
+		log.WithField("stage", "validation").
+			Error("Missing registration_type")
 		http.Error(w, "registration_type is required", http.StatusBadRequest)
 		return
 	}
 
 	registrationType := strings.ToLower(req.RegistrationType)
+	log = log.WithField("registration_type", registrationType)
+
 	if !isRegistrationTypeAllowed(registrationType) {
-		logrus.Warnf("Registration type not allowed: %s", registrationType)
+		log.WithField("stage", "validation").
+			Warn("Unsupported registration_type")
 		http.Error(w, "Unsupported registration_type", http.StatusBadRequest)
 		return
 	}
+	log.Debug("registration_type validated")
 
+	// Public flows (no auth required)
 	switch registrationType {
 	case "device_code":
+		log.Info("Routing to device_code flow")
 		handleDeviceCodeFlow(w, req)
+		return
+
 	case "none":
+		log.Info("Routing to none flow")
 		handleNoneFlow(w, req)
-	default:
-		issuer, id, mode, err := authenticateRequest(r)
-		if err != nil {
-			logrus.WithError(err).Warn("Authentication failed")
-			http.Error(w, "Unauthorized", http.StatusUnauthorized)
-			return
-		}
-		if id == "" {
-			logrus.Warn("Authentication missing for registration request")
-			http.Error(w, "Unauthorized", http.StatusUnauthorized)
-			return
-		}
+		return
+	}
 
-		// Route to appropriate handler based on registration_type
-		switch registrationType {
-		case "provision":
-			handleProvisionFlow(w, req, id)
-		case "authorization_code":
-			handleAuthorizationCodeFlow(w, req, issuer, id, mode)
-		case "client_credentials":
-			handleClientCredentialsFlow(w, req, issuer, id)
-		default:
-			logrus.Warnf("Unsupported registration_type: %s", registrationType)
-			http.Error(w, "Unsupported registration_type", http.StatusBadRequest)
-		}
+	// Authentication required for remaining flows
+	log.Debug("Authenticating request")
+	issuer, id, mode, err := authenticateRequest(r)
+	if err != nil {
+		log.WithError(err).
+			WithField("stage", "authentication").
+			Warn("Authentication failed")
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	if id == "" {
+		log.WithField("stage", "authentication").
+			Warn("Missing subject identifier in authentication")
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	log = log.WithFields(logrus.Fields{
+		"issuer":    issuer,
+		"client_id": id,
+		"auth_mode": mode,
+	})
+	log.Debug("Authentication successful")
+
+	// Route to authenticated flows
+	switch registrationType {
+	case "provision":
+		log.Info("Routing to provision flow")
+		handleProvisionFlow(w, req, id)
+
+	case "authorization_code":
+		log.Info("Routing to authorization_code flow")
+		handleAuthorizationCodeFlow(w, req, issuer, id, mode)
+
+	case "client_credentials":
+		log.Info("Routing to client_credentials flow")
+		handleClientCredentialsFlow(w, req, issuer, id)
+
+	default:
+		log.WithField("stage", "routing").
+			Warn("Reached unexpected registration_type")
+		http.Error(w, "Unsupported registration_type", http.StatusBadRequest)
 	}
 }