Enterprise Continuous Integration and Delivery Architecture Questions

package main

import (
	"crypto"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"crypto/x509"
	"encoding/base64"
	"encoding/json"
	"encoding/pem"
	"fmt"
	"io/ioutil"
	"os"
	"time"
)

// FileDigest represents a file path and its SHA256 digest.
// Use struct (not map) so encoding/json emits keys in declaration order for deterministic output.
type FileDigest struct {
	Path   string `json:"path"`
	SHA256 string `json:"sha256"`
}

// Attestation is the unsigned payload.
// Field order here controls JSON key ordering for determinism.
type Attestation struct {
	BuilderID string       `json:"builder_id"`
	Timestamp string       `json:"timestamp"`
	Inputs    []FileDigest `json:"inputs"`
	Outputs   []FileDigest `json:"outputs"`
}

// Envelope is the final JSON containing attestation and signature.
type Envelope struct {
	Attestation Attestation `json:"attestation"`
	Signature   string      `json:"signature"` // base64
}

func must(err error) {
	if err != nil {
		fmt.Fprintln(os.Stderr, "error:", err)
		os.Exit(1)
	}
}

func readJSONFile(path string, v interface{}) {
	b, err := ioutil.ReadFile(path)
	must(err)
	must(json.Unmarshal(b, v))
}

func parsePrivateKey(pemPath string) *rsa.PrivateKey {
	b, err := ioutil.ReadFile(pemPath)
	must(err)
	block, _ := pem.Decode(b)
	if block == nil {
		fmt.Fprintln(os.Stderr, "failed to parse PEM")
		os.Exit(1)
	}
	// Try PKCS1 then PKCS8
	if key, err := x509.ParsePKCS1PrivateKey(block.Bytes); err == nil {
		return key
	}
	pk, err := x509.ParsePKCS8PrivateKey(block.Bytes)
	must(err)
	rk, ok := pk.(*rsa.PrivateKey)
	if !ok {
		fmt.Fprintln(os.Stderr, "not an RSA private key")
		os.Exit(1)
	}
	return rk
}

func main() {
	if len(os.Args) != 4 {
		fmt.Fprintf(os.Stderr, "usage: %s inputs.json outputs.json private.pem\n", os.Args[0])
		os.Exit(1)
	}
	inputPath, outputPath, keyPath := os.Args[1], os.Args[2], os.Args[3]

	var inputs, outputs []FileDigest
	readJSONFile(inputPath, &inputs)
	readJSONFile(outputPath, &outputs)

	builder := os.Getenv("BUILDER_ID")
	if builder == "" {
		builder = "unknown"
	}

	att := Attestation{
		BuilderID: builder,
		Timestamp: time.Now().UTC().Format(time.RFC3339Nano),
		Inputs:    inputs,
		Outputs:   outputs,
	}

	// Marshal the attestation deterministically:
	// - Use struct types (no maps) so encoding/json preserves field order.
	// - Disable HTML escaping for stability.
	attBytes, err := json.Marshal(att)
	must(err)
	// Hash and sign
	h := sha256.Sum256(attBytes)
	priv := parsePrivateKey(keyPath)
	sig, err := rsa.SignPKCS1v15(rand.Reader, priv, crypto.SHA256, h[:])
	must(err)
	env := Envelope{
		Attestation: att,
		Signature:   base64.StdEncoding.EncodeToString(sig),
	}
	// Marshal final envelope (deterministic for same reasons)
	enc := json.NewEncoder(os.Stdout)
	enc.SetEscapeHTML(false)
	must(enc.Encode(env))
}

import math
from typing import List

def erlang_c(c, rho):
    # c servers, rho = traffic intensity (lambda/ mu * 1/c_total? we'll use offered load a = lambda/mu)
    # using offered load a = lambda / mu
    a = rho * c
    # compute sum_{k=0}^{c-1} a^k / k!
    s = sum((a**k)/math.factorial(k) for k in range(c))
    pc = (a**c / math.factorial(c)) * (1 / (1 - a/c))
    return pc / (s + pc)

def avg_wait_given_params(lmbda, mu, c):
    a = lmbda / mu
    if c * mu <= lmbda:
        return float('inf')
    C = erlang_c(c, lmbda/mu / c)  # pass rho = a/c
    return (C * (1 / (c * mu - lmbda)))  # E[W_q]

def predict_agents(arrival_rates: List[float], avg_duration_min: float, boot_time_min: int, target_p95_wait: float):
    mu = 1.0 / avg_duration_min
    n = len(arrival_rates)
    agents = [0]*n
    # lookahead to account for boot time
    for t in range(n):
        # consider arrivals at t+boot_time_min that will be served when agents come up
        look = min(n-1, t + boot_time_min)
        lam = arrival_rates[look]
        # find smallest c such that p95 wait <= target
        c = max(1, int(math.ceil(lam * avg_duration_min)))  # start guess
        while True:
            wq = avg_wait_given_params(lam, mu, c)
            if wq == float('inf'):
                c += 1
                continue
            # approximate p95 as 3 * mean_wait (exponential tail: -ln(0.05)=~3)
            p95 = -math.log(0.05) * wq
            if p95 <= target_p95_wait or c > 1000:
                agents[t] = c
                break
            c += 1
    return agents