~ knotless Search/
↑↓ move↵ open⇧↵ all results

johnandersen777.bsky.social/socialweb-computer-console

console.socialweb.computer: kcp, kubectl and ssh compiled to wasm in a browser tab with a terminal; a kcp fork

0
0
main
162 lines · 4.8 KB Raw History
/*
Copyright 2022 The kcp Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package main

import (
	"context"
	"errors"
	"flag"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strings"

	"k8s.io/apimachinery/pkg/util/wait"
	genericapiserver "k8s.io/apiserver/pkg/server"

	"github.com/kcp-dev/sdk/testing/third_party/library-go/crypto"

	shard "github.com/kcp-dev/kcp/cmd/test-server/kcp"
)

// Start a kcp server with the configuration expected by the e2e
// tests. Useful for developing with a persistent server.
//
// Repeatably start a persistent test server:
//
//	$ rm -rf .kcp/ && make build && ./bin/test-server 2>&1 | tee kcp.log
//
// Run the e2e suite against a persistent server:
//
//	$ TEST_ARGS='-args --use-default-kcp-server' E2E_PARALLELISM=6 make test-e2e
//
// Run individual tests against a persistent server:
//
//	$ go test -v --use-default-kcp-server
func main() {
	workDirPath := flag.String("work-dir-path", "", "Directory for work files. If empty, .kcp is used.")
	logDirPath := flag.String("log-dir-path", "", "Directory for log files. If empty, .kcp is used.")
	quiet := flag.Bool("quiet", false, "Suppress output of the subprocesses")

	// split flags into --shard-* and everything else (generic). The former are
	// passed to the respective components. Everything after "--" is considered a shard flag.
	var shardFlags, genericFlags []string
	for i, arg := range os.Args[1:] {
		if arg == "--" {
			shardFlags = append(shardFlags, os.Args[i+2:]...)
			break
		}
		if strings.HasPrefix(arg, "--shard-") {
			shardFlags = append(shardFlags, "-"+strings.TrimPrefix(arg, "--shard"))
		} else {
			genericFlags = append(genericFlags, arg)
		}
	}
	if err := flag.CommandLine.Parse(genericFlags); err != nil {
		fmt.Fprintf(os.Stderr, "error: %v\n", err)
		os.Exit(1)
	}

	if err := start(shardFlags, *workDirPath, *logDirPath, *quiet); err != nil {
		var exitErr *exec.ExitError
		if errors.As(err, &exitErr) {
			os.Exit(exitErr.ExitCode())
		}
		fmt.Fprintf(os.Stderr, "error: %v\n", err)
		os.Exit(1)
	}
}

func start(shardFlags []string, workDirPath, logDirPath string, quiet bool) error {
	// We use a shutdown context to know that it's time to gather metrics, before stopping the shard
	shutdownCtx, shutdownCancel := context.WithCancel(genericapiserver.SetupSignalContext())
	defer shutdownCancel()

	// This context controls the life of the shard
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	// create client CA and kcp-admin client cert to connect through front-proxy
	_, err := crypto.MakeSelfSignedCA(
		filepath.Join(workDirPath, ".kcp", "client-ca.crt"),
		filepath.Join(workDirPath, ".kcp", "client-ca.key"),
		filepath.Join(workDirPath, ".kcp", "client-ca-serial.txt"),
		"kcp-client-ca",
		365,
	)
	if err != nil {
		return fmt.Errorf("failed to create client-ca: %w", err)
	}

	logFilePath := filepath.Join(workDirPath, ".kcp", "kcp.log")
	if logDirPath != "" {
		logFilePath = filepath.Join(logDirPath, "kcp.log")
	}

	s := shard.NewShard(
		"kcp",
		filepath.Join(workDirPath, ".kcp"),
		logFilePath,
		append(shardFlags,
			"--audit-log-path", filepath.Join(filepath.Dir(logFilePath), "audit.log"),
			"--client-ca-file", filepath.Join(workDirPath, ".kcp", "client-ca.crt"),
		),
	)
	if err := s.Start(ctx, quiet); err != nil {
		return err
	}

	errCh, err := s.WaitForReady(ctx)
	if err != nil {
		return err
	}

	err = shard.ScrapeMetrics(ctx, s, ".")
	if err != nil {
		return err
	}

	readyToTestFile, err := os.Create(filepath.Join(workDirPath, ".kcp", "ready-to-test"))
	if err != nil {
		return fmt.Errorf("error creating ready-to-test file: %w", err)
	}
	defer readyToTestFile.Close()

	// Wait for either a premature termination error from the shard, or for the test server process to shut down
	select {
	case err := <-errCh:
		return err
	case <-shutdownCtx.Done():
	}

	// We've received the notice to shut down, so try to gather metrics. Use a new context with a fixed timeout.
	metricsCtx, metricsCancel := context.WithTimeout(ctx, wait.ForeverTestTimeout)
	defer metricsCancel()

	s.GatherMetrics(metricsCtx)

	// Stop the shard and wait for its process to actually exit before we
	// return, instead of relying on the deferred cancel() above, which
	// only asynchronously triggers termination. Without this, main() can
	// return - and the process running it can exit - while the shard is
	// still shutting down and flushing its log/audit files.
	cancel()
	<-errCh

	return nil
}