Skip to content
Snippets Groups Projects
Select Git revision
  • 58fe87e7c67e53cc3c47e1946f5c806fa7b1640e
  • master default protected
  • v0.0.x
  • v0.0.31
  • v0.0.30
  • v0.0.29
  • v0.0.28
  • v0.0.28-rc1
  • v0.0.27
  • v0.0.26
  • v0.0.25
  • v0.0.24
  • v0.0.23
  • v0.0.22
  • v0.0.21
  • v0.0.20
  • v0.0.19
  • v0.0.18
  • v0.0.17
  • v0.0.16
  • v0.0.15
  • v0.0.14
  • v0.0.13
23 results

main.go

Blame
  • user avatar
    Sheng Yang authored
    58fe87e7
    History
    main.go 3.07 KiB
    package main
    
    import (
    	"fmt"
    	"os"
    	"os/signal"
    	"syscall"
    
    	"github.com/Sirupsen/logrus"
    	"github.com/pkg/errors"
    	"github.com/urfave/cli"
    
    	pvController "github.com/kubernetes-incubator/external-storage/lib/controller"
    	clientset "k8s.io/client-go/kubernetes"
    	"k8s.io/client-go/rest"
    )
    
    var (
    	VERSION = "0.0.1"
    
    	DefaultProvisionerName = "rancher.io/local-path"
    
    	FlagProvisionerName = "provisioner-name"
    	EnvProvisionerName  = "PROVISIONER_NAME"
    	FlagConfigFile      = "config"
    )
    
    func cmdNotFound(c *cli.Context, command string) {
    	panic(fmt.Errorf("Unrecognized command: %s", command))
    }
    
    func onUsageError(c *cli.Context, err error, isSubcommand bool) error {
    	panic(fmt.Errorf("Usage error, please check your command"))
    }
    
    func RegisterShutdownChannel(done chan struct{}) {
    	sigs := make(chan os.Signal, 1)
    	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
    	go func() {
    		sig := <-sigs
    		logrus.Infof("Receive %v to exit", sig)
    		close(done)
    	}()
    }
    
    func StartCmd() cli.Command {
    	return cli.Command{
    		Name: "start",
    		Flags: []cli.Flag{
    			cli.StringFlag{
    				Name:   FlagProvisionerName,
    				Usage:  "Optional. Specify provisioner name.",
    				EnvVar: EnvProvisionerName,
    				Value:  DefaultProvisionerName,
    			},
    			cli.StringFlag{
    				Name:  FlagConfigFile,
    				Usage: "Required. Provisioner configuration file.",
    				Value: "",
    			},
    		},
    		Action: func(c *cli.Context) {
    			if err := startDaemon(c); err != nil {
    				logrus.Fatalf("Error starting daemon: %v", err)
    			}
    		},
    	}
    }
    
    func startDaemon(c *cli.Context) error {
    	stopCh := make(chan struct{})
    	RegisterShutdownChannel(stopCh)
    
    	config, err := rest.InClusterConfig()
    	if err != nil {
    		return errors.Wrap(err, "unable to get client config")
    	}
    
    	kubeClient, err := clientset.NewForConfig(config)
    	if err != nil {
    		return errors.Wrap(err, "unable to get k8s client")
    	}
    
    	serverVersion, err := kubeClient.Discovery().ServerVersion()
    	if err != nil {
    		return errors.Wrap(err, "Cannot start Provisioner: failed to get Kubernetes server version")
    	}
    
    	provisionerName := c.String(FlagProvisionerName)
    	if provisionerName == "" {
    		return fmt.Errorf("invalid empty provisioner name")
    	}
    	configFile := c.String(FlagConfigFile)
    	provisioner, err := NewProvisioner(kubeClient, configFile)
    	if err != nil {
    		return err
    	}
    	pc := pvController.NewProvisionController(
    		kubeClient,
    		provisionerName,
    		provisioner,
    		serverVersion.GitVersion,
    	)
    	logrus.Debug("Provisioner started")
    	pc.Run(stopCh)
    	logrus.Debug("Provisioner stopped")
    	return nil
    }
    
    func main() {
    	logrus.SetFormatter(&logrus.TextFormatter{FullTimestamp: true})
    
    	a := cli.NewApp()
    	a.Version = VERSION
    	a.Usage = "Local Path Provisioner"
    
    	a.Before = func(c *cli.Context) error {
    		if c.GlobalBool("debug") {
    			logrus.SetLevel(logrus.DebugLevel)
    		}
    		return nil
    	}
    
    	a.Flags = []cli.Flag{
    		cli.BoolFlag{
    			Name:   "debug, d",
    			Usage:  "enable debug logging level",
    			EnvVar: "RANCHER_DEBUG",
    		},
    	}
    	a.Commands = []cli.Command{
    		StartCmd(),
    	}
    	a.CommandNotFound = cmdNotFound
    	a.OnUsageError = onUsageError
    
    	if err := a.Run(os.Args); err != nil {
    		logrus.Fatalf("Critical error: %v", err)
    	}
    }