feat: init

pkg/csi/driver/driver.go

@@ -0,0 +1,149 @@
+package driver
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/container-storage-interface/spec/lib/go/csi"
+	"github.com/KubelanCloud/kks-csi-plugin/config"
+	"github.com/KubelanCloud/kks-csi-plugin/pkg/csi/client"
+	"github.com/KubelanCloud/kks-csi-plugin/pkg/csi/provisioner"
+	"go.uber.org/zap"
+	"google.golang.org/grpc"
+)
+
+type Driver struct {
+	cfg        *config.Config
+	log        *zap.SugaredLogger
+	backend    provisioner.Backend
+	storageID  string
+	identity   *IdentityServer
+	controller *ControllerServer
+	node       *NodeServer
+}
+
+func Run(ctx context.Context, cfg *config.Config, logger *zap.Logger) error {
+	if err := cfg.Validate(); err != nil {
+		return err
+	}
+	if logger == nil {
+		logger = zap.NewNop()
+	}
+	log := logger.Sugar()
+
+	backend := client.NewBackend(cfg.Client)
+	defer backend.Close()
+
+	cluster, err := backend.ClusterInfo(ctx)
+	if err != nil {
+		return fmt.Errorf("resolve storage info from csi server: %w", err)
+	}
+
+	d := &Driver{
+		cfg:       cfg,
+		log:       log,
+		backend:   backend,
+		storageID: cluster.StorageID,
+		identity:  newIdentityServer(cfg),
+	}
+
+	switch cfg.Driver.Mode {
+	case config.CSIModeController, config.CSIModeAll:
+		d.controller = newControllerServer(d)
+	case config.CSIModeNode:
+	}
+
+	switch cfg.Driver.Mode {
+	case config.CSIModeNode, config.CSIModeAll:
+		d.node = newNodeServer(d)
+	case config.CSIModeController:
+	}
+
+	endpoint, err := parseEndpoint(cfg.Driver.Endpoint)
+	if err != nil {
+		return err
+	}
+	if err := ensureSocketDir(endpoint); err != nil {
+		return err
+	}
+
+	listener, err := net.Listen(endpoint.network, endpoint.address)
+	if err != nil {
+		return fmt.Errorf("listen on %s: %w", cfg.Driver.Endpoint, err)
+	}
+	defer listener.Close()
+
+	server := grpc.NewServer()
+	csi.RegisterIdentityServer(server, d.identity)
+	if d.controller != nil {
+		csi.RegisterControllerServer(server, d.controller)
+	}
+	if d.node != nil {
+		csi.RegisterNodeServer(server, d.node)
+	}
+
+	log.Infof(
+		"starting csi client name=%s endpoint=%s mode=%s node_id=%s server=%s storage_id=%s",
+		cfg.Driver.Name,
+		cfg.Driver.Endpoint,
+		cfg.Driver.Mode,
+		cfg.Driver.NodeID,
+		cfg.Client.ServerURL,
+		cluster.StorageID,
+	)
+
+	errCh := make(chan error, 1)
+	go func() {
+		errCh <- server.Serve(listener)
+	}()
+
+	select {
+	case <-ctx.Done():
+		log.Info("shutting down csi client")
+		server.GracefulStop()
+		return nil
+	case err := <-errCh:
+		if err != nil {
+			return fmt.Errorf("csi grpc server stopped: %w", err)
+		}
+		return nil
+	}
+}
+
+type endpoint struct {
+	network string
+	address string
+}
+
+func parseEndpoint(raw string) (endpoint, error) {
+	if strings.HasPrefix(raw, "unix://") {
+		return endpoint{
+			network: "unix",
+			address: strings.TrimPrefix(raw, "unix://"),
+		}, nil
+	}
+	if strings.HasPrefix(raw, "tcp://") {
+		return endpoint{
+			network: "tcp",
+			address: strings.TrimPrefix(raw, "tcp://"),
+		}, nil
+	}
+	return endpoint{}, fmt.Errorf("unsupported endpoint %q (use unix:// or tcp://)", raw)
+}
+
+func ensureSocketDir(ep endpoint) error {
+	if ep.network != "unix" {
+		return nil
+	}
+	if err := os.MkdirAll(filepath.Dir(ep.address), 0o755); err != nil {
+		return fmt.Errorf("create socket directory: %w", err)
+	}
+	if err := os.Remove(ep.address); err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("remove stale socket: %w", err)
+	}
+	return nil
+}