func main() {
log.InitWithConfig(log.Config{Name: "console"})
app := cli.NewApp()
app.Name = "vulcanbundle"
app.Usage = "Command line interface to compile plugins into vulcan binary"
app.Commands = []cli.Command{
{
Name: "init",
Usage: "Init bundle",
Action: initBundle,
Flags: []cli.Flag{
cli.StringSliceFlag{
Name: "middleware, m",
Value: &cli.StringSlice{},
Usage: "Path to repo and revision, e.g. github.com/vulcand/vulcand-plugins/auth",
},
},
},
}
err := app.Run(os.Args)
if err != nil {
log.Errorf("Error: %s\n", err)
}
}
func main() {
log.InitWithConfig(log.Config{Name: "console"})
cmd := command.NewCommand(registry.GetRegistry())
err := cmd.Run(os.Args)
if err != nil {
log.Errorf("error: %s\n", err)
}
}
func (s *EtcdSuite) SetUpSuite(c *C) {
log.InitWithConfig(log.Config{Name: "console"})
key, err := secret.NewKeyString()
if err != nil {
panic(err)
}
s.key = key
nodes_string := os.Getenv("VULCAND_TEST_ETCD_NODES")
if nodes_string == "" {
// Skips the entire suite
c.Skip("This test requires etcd, provide comma separated nodes in VULCAND_TEST_ETCD_NODES environment variable")
return
}
s.nodes = strings.Split(nodes_string, ",")
}
func (s *VESuite) SetUpSuite(c *C) {
log.InitWithConfig(log.Config{Name: "console"})
etcdNodes := os.Getenv("VULCAND_TEST_ETCD_NODES")
if etcdNodes == "" {
c.Skip("This test requires running Etcd, please provide url via VULCAND_TEST_ETCD_NODES environment variable")
return
}
s.etcdNodes = strings.Split(etcdNodes, ",")
s.client = etcd.NewClient(s.etcdNodes)
s.etcdPrefix = os.Getenv("VULCAND_TEST_ETCD_PREFIX")
if s.etcdPrefix == "" {
c.Skip("This test requires Etcd prefix, please provide url via VULCAND_TEST_ETCD_PREFIX environment variable")
return
}
s.apiUrl = os.Getenv("VULCAND_TEST_API_URL")
if s.apiUrl == "" {
c.Skip("This test requires running vulcand daemon, provide API url via VULCAND_TEST_API_URL environment variable")
return
}
s.serviceUrl = os.Getenv("VULCAND_TEST_SERVICE_URL")
if s.serviceUrl == "" {
c.Skip("This test requires running vulcand daemon, provide API url via VULCAND_TEST_SERVICE_URL environment variable")
return
}
s.sealKey = os.Getenv("VULCAND_TEST_SEAL_KEY")
if s.sealKey == "" {
c.Skip("This test requires running vulcand daemon, provide API url via VULCAND_TEST_SEAL_KEY environment variable")
return
}
key, err := secret.KeyFromString(s.sealKey)
c.Assert(err, IsNil)
box, err := secret.NewBox(key)
c.Assert(err, IsNil)
s.box = box
}
func (s *StaplerSuite) SetUpSuite(c *C) {
log.InitWithConfig(log.Config{Name: "console"})
s.re = testutils.OCSPResponse
}
func (s *ApiSuite) SetUpSuite(c *C) {
log.InitWithConfig(log.Config{Name: "console"})
}
func (s *Service) Start() error {
log.InitWithConfig(log.Config{
Name: s.options.Log,
Severity: s.options.LogSeverity.S.String(),
})
log.Infof("Service starts with options: %#v", s.options)
if s.options.PidPath != "" {
ioutil.WriteFile(s.options.PidPath, []byte(fmt.Sprint(os.Getpid())), 0644)
}
if s.options.StatsdAddr != "" {
var err error
s.metricsClient, err = metrics.NewWithOptions(s.options.StatsdAddr, s.options.StatsdPrefix, metrics.Options{UseBuffering: true})
if err != nil {
return err
}
}
apiFile, muxFiles, err := s.getFiles()
if err != nil {
return err
}
if err := s.newEngine(); err != nil {
return err
}
s.stapler = stapler.New()
s.supervisor = supervisor.New(
s.newProxy, s.ng, s.errorC, supervisor.Options{Files: muxFiles})
// Tells configurator to perform initial proxy configuration and start watching changes
if err := s.supervisor.Start(); err != nil {
return err
}
if err := s.initApi(); err != nil {
return err
}
go func() {
s.errorC <- s.startApi(apiFile)
}()
if s.metricsClient != nil {
go s.reportSystemMetrics()
}
signal.Notify(s.sigC, os.Interrupt, os.Kill, syscall.SIGTERM, syscall.SIGUSR2, syscall.SIGCHLD)
// Block until a signal is received or we got an error
for {
select {
case signal := <-s.sigC:
switch signal {
case syscall.SIGTERM, syscall.SIGINT:
log.Infof("Got signal '%s', shutting down gracefully", signal)
s.supervisor.Stop(true)
log.Infof("All servers stopped")
return nil
case syscall.SIGKILL:
log.Infof("Got signal '%s', exiting now without waiting", signal)
s.supervisor.Stop(false)
return nil
case syscall.SIGUSR2:
log.Infof("Got signal '%s', forking a new self", signal)
if err := s.startChild(); err != nil {
log.Infof("Failed to start self: %s", err)
} else {
log.Infof("Successfully started self")
}
case syscall.SIGCHLD:
log.Warningf("Child exited, got '%s', collecting status", signal)
var wait syscall.WaitStatus
syscall.Wait4(-1, &wait, syscall.WNOHANG, nil)
log.Warningf("Collected exit status from child")
default:
log.Infof("Ignoring '%s'", signal)
}
case err := <-s.errorC:
log.Infof("Got request to shutdown with error: %s", err)
return err
}
}
}
func (s *SupervisorSuite) SetUpSuite(c *C) {
log.InitWithConfig(log.Config{Name: "console"})
}