コード例 #1
0
ファイル: config.go プロジェクト: nanopack/logvac
// AddFlags adds cli flags to logvac
func AddFlags(cmd *cobra.Command) {
	// collectors
	cmd.Flags().StringVarP(&ListenHttp, "listen-http", "a", ListenHttp, "API listen address (same endpoint for http log collection)")
	cmd.Flags().StringVarP(&ListenUdp, "listen-udp", "u", ListenUdp, "UDP log collection endpoint")
	cmd.Flags().StringVarP(&ListenTcp, "listen-tcp", "t", ListenTcp, "TCP log collection endpoint")

	// drains
	cmd.Flags().StringVarP(&PubAddress, "pub-address", "p", PubAddress, "Log publisher (mist) address (\"mist://127.0.0.1:1445\")")
	cmd.Flags().StringVarP(&PubAuth, "pub-auth", "P", PubAuth, "Log publisher (mist) auth token")
	cmd.Flags().StringVarP(&DbAddress, "db-address", "d", DbAddress, "Log storage address")

	// authenticator
	cmd.PersistentFlags().StringVarP(&AuthAddress, "auth-address", "A", AuthAddress, "Address or file location of authentication db. ('boltdb:///var/db/logvac.bolt' or 'postgresql://127.0.0.1')")

	// other
	cmd.Flags().StringVarP(&CorsAllow, "cors-allow", "C", CorsAllow, "Sets the 'Access-Control-Allow-Origin' header")
	cmd.Flags().StringVarP(&LogKeep, "log-keep", "k", LogKeep, "Age or number of logs to keep per type '{\"app\":\"2w\", \"deploy\": 10}' (int or X(m)in, (h)our,  (d)ay, (w)eek, (y)ear)")
	cmd.Flags().StringVarP(&LogLevel, "log-level", "l", LogLevel, "Level at which to log")
	cmd.Flags().StringVarP(&LogType, "log-type", "L", LogType, "Default type to apply to incoming logs (commonly used: app|deploy)")
	cmd.Flags().StringVarP(&Token, "token", "T", Token, "Administrative token to add/remove 'X-USER-TOKEN's used to pub/sub via http")
	cmd.Flags().BoolVarP(&Server, "server", "s", Server, "Run as server")
	cmd.Flags().BoolVarP(&Insecure, "insecure", "i", Insecure, "Don't use TLS (used for testing)")
	cmd.Flags().BoolVarP(&Version, "version", "v", Version, "Print version info and exit")

	Log = lumber.NewConsoleLogger(lumber.LvlInt("ERROR"))
}
コード例 #2
0
ファイル: scribble_test.go プロジェクト: nanopack/portal
func TestSetService(t *testing.T) {
	config.DatabaseConnection = "scribble:///tmp/scribbleTest"
	config.Log = lumber.NewConsoleLogger(lumber.LvlInt("FATAL"))

	// Backend = &database.ScribbleDatabase{}
	database.Init()

	if err := database.SetService(&testService1); err != nil {
		t.Errorf("Failed to SET service - %v", err)
	}

	service, err := ioutil.ReadFile("/tmp/scribbleTest/services/tcp-192_168_0_15-80.json")
	if err != nil {
		t.Error(err)
	}

	jService, err := toJson(testService1)
	if err != nil {
		t.Error(err)
	}

	if string(service) != string(jService) {
		t.Errorf("Read service differs from written service")
	}
}
コード例 #3
0
ファイル: commands_test.go プロジェクト: nanopack/shaman
// manually configure and start internals
func initialize() {
	config.Insecure = true
	config.L2Connect = "none://"
	config.ApiListen = "127.0.0.1:1634"
	config.Log = lumber.NewConsoleLogger(lumber.LvlInt("FATAL"))
	config.LogLevel = "FATAL"
}
コード例 #4
0
// New creates a new scribble database at the desired directory location, and
// returns a *Driver to then use for interacting with the database
func New(dir string, options *Options) (*Driver, error) {

	//
	dir = filepath.Clean(dir)

	// create default options
	opts := Options{}

	// if options are passed in, use those
	if options != nil {
		opts = *options
	}

	// if no logger is provided, create a default
	if opts.Logger == nil {
		opts.Logger = lumber.NewConsoleLogger(lumber.INFO)
	}

	//
	driver := Driver{
		dir:     dir,
		mutexes: make(map[string]sync.Mutex),
		log:     opts.Logger,
	}

	// if the database already exists, just use it
	if _, err := os.Stat(dir); err == nil {
		opts.Logger.Info("Using '%s' (database already exists)\n", dir)
		return &driver, nil
	}

	// if the database doesn't exist create it
	opts.Logger.Info("Creating scribble database at '%s'...\n", dir)
	return &driver, os.MkdirAll(dir, 0755)
}
コード例 #5
0
ファイル: main.go プロジェクト: nanopack/logvac
func startLogvac(ccmd *cobra.Command, args []string) error {
	// initialize logger
	lumber.Level(lumber.LvlInt(config.LogLevel)) // for clients using lumber too
	config.Log = lumber.NewConsoleLogger(lumber.LvlInt(config.LogLevel))

	// initialize logvac
	logvac.Init()

	// setup authenticator
	err := authenticator.Init()
	if err != nil {
		return fmt.Errorf("Authenticator failed to initialize - %v", err)
	}

	// initialize drains
	err = drain.Init()
	if err != nil {
		return fmt.Errorf("Drain failed to initialize - %v", err)
	}

	// initializes collectors
	err = collector.Init()
	if err != nil {
		return fmt.Errorf("Collector failed to initialize - %v", err)
	}

	err = api.Start(collector.CollectHandler)
	if err != nil {
		return fmt.Errorf("Api failed to initialize - %v", err)
	}

	return nil
}
コード例 #6
0
ファイル: collector_test.go プロジェクト: nanopack/logvac
// manually configure and start internals
func initialize() {
	config.ListenHttp = "127.0.0.1:4234"
	config.ListenTcp = "127.0.0.1:4235"
	config.ListenUdp = "127.0.0.1:4234"
	config.DbAddress = "boltdb:///tmp/syslogTest/logvac.bolt"
	config.AuthAddress = ""
	config.Insecure = true
	config.Log = lumber.NewConsoleLogger(lumber.LvlInt("ERROR"))

	// initialize logvac
	logvac.Init()

	// setup authenticator
	err := authenticator.Init()
	if err != nil {
		config.Log.Fatal("Authenticator failed to initialize - %v", err)
		os.Exit(1)
	}

	// initialize drains
	err = drain.Init()
	if err != nil {
		config.Log.Fatal("Drain failed to initialize - %v", err)
		os.Exit(1)
	}

	// initializes collectors
	err = collector.Init()
	if err != nil {
		config.Log.Fatal("Collector failed to initialize - %v", err)
		os.Exit(1)
	}
}
コード例 #7
0
ファイル: main.go プロジェクト: nanopack/shaman
func startShaman(ccmd *cobra.Command, args []string) error {
	config.Log = lumber.NewConsoleLogger(lumber.LvlInt(config.LogLevel))

	// initialize cache
	err := cache.Initialize()
	if err != nil {
		config.Log.Fatal(err.Error())
		return err
	}

	// make channel for errors
	errors := make(chan error)

	go func() {
		errors <- api.Start()
	}()
	go func() {
		errors <- server.Start()
	}()

	// break if any of them return an error (blocks exit)
	if err := <-errors; err != nil {
		config.Log.Fatal(err.Error())
	}
	return err
}
コード例 #8
0
ファイル: lvs_test.go プロジェクト: nanopack/portal
func initialize() {
	ifIptables, err := exec.Command("iptables", "-S").CombinedOutput()
	if err != nil {
		fmt.Printf("Failed to run iptables - %s%v\n", ifIptables, err.Error())
		skip = true
	}
	ifIpvsadm, err := exec.Command("ipvsadm", "--version").CombinedOutput()
	if err != nil {
		fmt.Printf("Failed to run ipvsadm - %s%v\n", ifIpvsadm, err.Error())
		skip = true
	}

	config.Log = lumber.NewConsoleLogger(lumber.LvlInt("FATAL"))

	if !skip {
		// todo: find more friendly way to clear crufty rules only
		err = exec.Command("iptables", "-F", "portal").Run()
		if err != nil {
			fmt.Printf("Failed to clear iptables - %v\n", err.Error())
			os.Exit(1)
		}
		err = exec.Command("ipvsadm", "-C").Run()
		if err != nil {
			fmt.Printf("Failed to clear ipvsadm - %v\n", err.Error())
			os.Exit(1)
		}

		balance.Init()
	}
}
コード例 #9
0
ファイル: boltdb_test.go プロジェクト: nanopack/logvac
// manually configure and start internals
func initialize() error {
	var err error
	drain.CleanFreq = 1
	config.LogKeep = `{"app": "1s", "deploy":0}`
	config.LogKeep = `{"app": "1s", "deploy":0, "a":"1m", "aa":"1h", "b":"1d", "c":"1w", "d":"1y", "e":"1"}`
	config.Log = lumber.NewConsoleLogger(lumber.LvlInt("ERROR"))

	// initialize logvac
	logvac.Init()

	// initialize archiver
	// Doing broke db
	config.DbAddress = "~!@#$%^&*()"
	drain.Init()

	// Doing file db
	config.DbAddress = "file:///tmp/boltdbTest/logvac.bolt"
	drain.Init()
	drain.Archiver.(*drain.BoltArchive).Close()

	// Doing no db
	config.DbAddress = "/tmp/boltdbTest/logvac.bolt"
	drain.Init()
	drain.Archiver.(*drain.BoltArchive).Close()

	// Doing bolt db
	config.DbAddress = "boltdb:///tmp/boltdbTest/logvac.bolt"
	drain.Init()

	return err
}
コード例 #10
0
ファイル: mist_test.go プロジェクト: nanopack/logvac
// manually configure and start internals
func mistInitialize() error {
	var err error
	drain.CleanFreq = 1
	config.LogKeep = `{"app": "1s", "deploy":0}`
	config.LogKeep = `{"app": "1s", "deploy":0, "a":"1m", "aa":"1h", "b":"1d", "c":"1w", "d":"1y", "e":"1"}`
	config.Log = lumber.NewConsoleLogger(lumber.LvlInt("ERROR"))
	config.DbAddress = "boltdb:///tmp/boltdbTest/logvac.bolt"

	server.StartTCP(PubAddress, nil)

	// initialize logvac
	logvac.Init()

	// initialize publisher
	// Doing broke publisher
	config.PubAddress = "~!@#$%^&*()"
	drain.Init()
	drain.Archiver.(*drain.BoltArchive).Close()

	// Doing schemeless publisher
	config.PubAddress = "127.0.0.1:2445"
	drain.Init()
	drain.Archiver.(*drain.BoltArchive).Close()
	drain.Publisher.(*drain.Mist).Close()

	// Doing real publisher
	config.PubAddress = "mist://127.0.0.1:2445"
	err = drain.Init()

	return err
}
コード例 #11
0
ファイル: utils.go プロジェクト: schollz/cowyo
func init() {
	rand.Seed(time.Now().Unix())
	animalsText, _ := ioutil.ReadFile(path.Join(RuntimeArgs.SourcePath, "static/text/animals"))
	animals = strings.Split(string(animalsText), ",")
	adjectivesText, _ := ioutil.ReadFile(path.Join(RuntimeArgs.SourcePath, "static/text/adjectives"))
	adjectives = strings.Split(string(adjectivesText), "\n")
	logger = lumber.NewConsoleLogger(lumber.INFO)
}
コード例 #12
0
ファイル: config.go プロジェクト: Lanzafame/butter
func Parse(configFile string) {
	c := map[string]string{}

	bytes, err := ioutil.ReadFile(configFile)
	if err != nil {
		Log.Error("unable to read config file: %v\n", err)
	}
	err = yaml.Unmarshal(bytes, &c)
	if err != nil {
		Log.Error("err parsing config file: %v\n", err)
		Log.Error("falling back to default values")
	}

	Log = lumber.NewConsoleLogger(lumber.LvlInt(c["log_level"]))
	if c["ssh_listen_address"] != "" {
		SshListenAddress = c["ssh_listen_address"]
	}
	if c["http_listen_address"] != "" {
		HttpListenAddress = c["http_listen_address"]
	}
	if c["key_path"] != "" {
		KeyPath = c["key_path"]
	}
	if c["repo_type"] != "" {
		RepoType = c["repo_type"]
	}
	if c["repo_location"] != "" {
		RepoLocation = c["repo_location"]
	}
	if c["key_auth_type"] != "" {
		KeyAuthType = c["key_auth_type"]
	}
	if c["key_auth_location"] != "" {
		KeyAuthLocation = c["key_auth_location"]
	}
	if c["repo_type"] != "" {
		RepoType = c["repo_type"]
	}
	if c["repo_location"] != "" {
		RepoLocation = c["repo_location"]
	}
	if c["repo_type"] != "" {
		RepoType = c["repo_type"]
	}
	if c["repo_location"] != "" {
		RepoLocation = c["repo_location"]
	}
	if c["repo_type"] != "" {
		RepoType = c["repo_type"]
	}
	if c["repo_location"] != "" {
		RepoLocation = c["repo_location"]
	}
	if c["token"] != "" {
		Token = c["token"]
	}
}
コード例 #13
0
ファイル: shaman_test.go プロジェクト: nanopack/shaman
func TestMain(m *testing.M) {
	shamanClear()
	// manually configure
	config.Log = lumber.NewConsoleLogger(lumber.LvlInt("FATAL"))

	// run tests
	rtn := m.Run()

	os.Exit(rtn)
}
コード例 #14
0
ファイル: cache_test.go プロジェクト: nanopack/shaman
func TestMain(m *testing.M) {
	// manually configure
	// config.Log = lumber.NewConsoleLogger(lumber.LvlInt("trace"))
	config.Log = lumber.NewConsoleLogger(lumber.LvlInt("FATAL"))

	// run tests
	rtn := m.Run()

	os.Exit(rtn)
}
コード例 #15
0
ファイル: log.go プロジェクト: rubysolo/nanobox
// init
func init() {

	// create a console logger
	Console = lumber.NewConsoleLogger(lumber.INFO)

	// create a file logger
	if Log, err = lumber.NewAppendLogger(Root + "/nanobox.log"); err != nil {
		Fatal("[config/log] lumber.NewAppendLogger() failed", err.Error())
	}
}
コード例 #16
0
ファイル: dns_test.go プロジェクト: nanopack/shaman
func TestMain(m *testing.M) {
	// manually configure
	config.DnsListen = "127.0.0.1:8053"
	config.Log = lumber.NewConsoleLogger(lumber.LvlInt("FATAL"))

	// start dns server
	go server.Start()
	<-time.After(time.Second)

	// run tests
	rtn := m.Run()

	os.Exit(rtn)
}
コード例 #17
0
ファイル: redis_test.go プロジェクト: nanopack/portal
func initialize() {
	rExec, err := exec.Command("redis-server", "-v").CombinedOutput()
	if err != nil {
		fmt.Printf("Failed to run redis-server - %s%v\n", rExec, err.Error())
		skip = true
	}

	config.RouteHttp = "0.0.0.0:9082"
	config.RouteTls = "0.0.0.0:9445"
	config.LogLevel = "FATAL"
	config.Log = lumber.NewConsoleLogger(lumber.LvlInt(config.LogLevel))

	if !skip {
		config.ClusterConnection = "redis://127.0.0.1:6379"
		config.DatabaseConnection = "scribble:///tmp/clusterTest"

		err = database.Init()
		if err != nil {
			fmt.Printf("database init failed - %v\n", err)
			os.Exit(1)
		}

		balance.Balancer = &database.ScribbleDatabase{}
		err = balance.Balancer.Init()
		if err != nil {
			fmt.Printf("balance init failed - %v\n", err)
			os.Exit(1)
		}

		// initialize proxymgr
		err = proxymgr.Init()
		if err != nil {
			fmt.Printf("Proxymgr init failed - %v\n", err)
			os.Exit(1)
		}

		// initialize vipmgr
		err = vipmgr.Init()
		if err != nil {
			fmt.Printf("Vipmgr init failed - %v\n", err)
			os.Exit(1)
		}

		err = cluster.Init()
		if err != nil {
			fmt.Printf("Cluster init failed - %v\n", err)
			os.Exit(1)
		}
	}
}
コード例 #18
0
ファイル: authenticator_test.go プロジェクト: nanopack/logvac
// manually configure and start internals
func initialize() error {
	http.DefaultTransport.(*http.Transport).TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
	config.ListenHttp = "127.0.0.1:3234"
	config.ListenTcp = "127.0.0.1:3235"
	config.ListenUdp = "127.0.0.1:3234"
	config.DbAddress = "boltdb:///tmp/authTest/logvac.bolt"
	config.Log = lumber.NewConsoleLogger(lumber.LvlInt("ERROR"))

	// initialize logvac
	logvac.Init()

	// setup authenticator
	config.AuthAddress = ""
	err := authenticator.Init()
	if err != nil {
		return fmt.Errorf("Authenticator failed to initialize - %v", err)
	}
	config.AuthAddress = "file:///tmp/authTest/logvac-auth.bolt"
	err = authenticator.Init()
	if err != nil {
		return fmt.Errorf("Authenticator failed to initialize - %v", err)
	}
	config.AuthAddress = "~!@#$%^&*()_"
	err = authenticator.Init()
	if err == nil {
		return fmt.Errorf("Authenticator failed to initialize - %v", err)
	}
	config.AuthAddress = "boltdb:///tmp/authTest/logvac-auth.bolt"
	err = authenticator.Init()
	if err != nil {
		return fmt.Errorf("Authenticator failed to initialize - %v", err)
	}

	// initialize drains
	err = drain.Init()
	if err != nil {
		return fmt.Errorf("Drain failed to initialize - %v", err)
	}

	// initializes collectors
	err = collector.Init()
	if err != nil {
		return fmt.Errorf("Collector failed to initialize - %v", err)
	}

	return nil
}
コード例 #19
0
ファイル: config.go プロジェクト: nanopack/sherpa
// create a new logger
func init() {
	Log = lumber.NewConsoleLogger(lumber.INFO)

	// create a new opts with default values
	Options = Opts{
		BuildGCInterval:           3600,
		BuildGCMarkFailedInterval: 60,
		DataDir:                   DEFAULT_DIR,
		DBConn:                    "postgres://postgres@localhost/sherpa", // not specifying a port will default to the default postgres port (:5432)
		Host:                      DEFAULT_HOST,
		Port:                      DEFAULT_PORT,
		TemplateGCInterval:        3600,
		URI:                       "http://" + DEFAULT_HOST + DEFAULT_PORT,
	}

	fmt.Printf("THING! %#v\n", Options)
}
コード例 #20
0
ファイル: main.go プロジェクト: nanopack/redundis
// startRedundis reads a specified config file, initializes the logger, and starts
// redundis
func startRedundis(ccmd *cobra.Command, args []string) {
	if err := config.ReadConfigFile(configFile); err != nil {
		config.Log.Fatal("Failed to read config - %v", err)
		os.Exit(1)
	}

	// initialize logger
	config.Log = lumber.NewConsoleLogger(lumber.LvlInt(config.LogLevel))
	config.Log.Prefix("[redundis]")

	// initialize redundis
	err := redundis.Start()
	if err != nil {
		config.Log.Fatal("Failed to listen - %v", err)
		os.Exit(1)
	}
}
コード例 #21
0
ファイル: commands_test.go プロジェクト: nanopack/portal
// manually configure and start internals
func initialize() {
	http.DefaultTransport.(*http.Transport).TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
	config.DatabaseConnection = "scribble:///tmp/cliTest"
	config.ClusterConnection = "none://"
	config.ApiHost = "127.0.0.1"
	config.ApiPort = "8445"
	config.ApiToken = ""
	config.RouteHttp = "0.0.0.0:9081"
	config.RouteTls = "0.0.0.0:9444"
	config.LogLevel = "FATAL"
	config.Log = lumber.NewConsoleLogger(lumber.LvlInt(config.LogLevel))
	apiAddr = fmt.Sprintf("%v:%v", config.ApiHost, config.ApiPort)

	// initialize database
	err := database.Init()
	if err != nil {
		fmt.Printf("Database init failed - %v\n", err)
		os.Exit(1)
	}
	// initialize balancer
	balance.Balancer = &database.ScribbleDatabase{}
	err = balance.Balancer.Init()
	if err != nil {
		fmt.Printf("Balancer init failed - %v\n", err)
		os.Exit(1)
	}
	// initialize proxymgr
	err = proxymgr.Init()
	if err != nil {
		fmt.Printf("Proxymgr init failed - %v\n", err)
		os.Exit(1)
	}
	// initialize vipmgr
	err = vipmgr.Init()
	if err != nil {
		fmt.Printf("Vipmgr init failed - %v\n", err)
		os.Exit(1)
	}
	// initialize clusterer
	err = cluster.Init()
	if err != nil {
		fmt.Printf("Clusterer init failed - %v\n", err)
		os.Exit(1)
	}
}
コード例 #22
0
ファイル: proxymgr_test.go プロジェクト: nanopack/portal
// initialize proxymgr
func initialize() {
	config.LogLevel = "FATAL"
	config.Log = lumber.NewConsoleLogger(lumber.LvlInt(config.LogLevel))

	// bad initialize proxymgr
	config.RouteHttp = "!@#$%^&*"
	err := proxymgr.Init()
	if err == nil {
		fmt.Printf("Proxymgr init succeeded when it should have failed\n")
		os.Exit(1)
	}

	// initialize proxymgr
	config.RouteHttp = "0.0.0.0:9083"
	config.RouteTls = "0.0.0.0:9446"
	err = proxymgr.Init()
	if err != nil {
		fmt.Printf("Proxymgr init failed - %v\n", err)
		os.Exit(1)
	}
}
コード例 #23
0
ファイル: postgres_test.go プロジェクト: nanopack/portal
// Requires SetService to be run first (initializes database)
func TestSetServicePg(t *testing.T) {
	config.DatabaseConnection = "postgres://[email protected]?sslmode=disable"
	config.Log = lumber.NewConsoleLogger(lumber.LvlInt("FATAL"))

	pgbackend = &database.PostgresDb{}
	err := pgbackend.Init()
	if err != nil {
		fmt.Printf("Failed to connect, skipping - %s\n", err.Error())
		pgskip = true
	}

	if pgskip {
		t.SkipNow()
	}

	if err := pgbackend.SetService(&testService1); err != nil {
		t.Errorf("Failed to SET service - %v", err)
	}

	svc, err := pgbackend.GetService("tcp-192_168_0_15-80")
	if err != nil {
		t.Error(err)
	}

	service, err := toJson(svc)
	if err != nil {
		t.Error(err)
	}

	jService, err := toJson(testService1)
	if err != nil {
		t.Error(err)
	}

	if string(service) != string(jService) {
		t.Errorf("Read service differs from written service")
	}
}
コード例 #24
0
ファイル: nginx_test.go プロジェクト: nanopack/portal
////////////////////////////////////////////////////////////////////////////////
// PRIVS
////////////////////////////////////////////////////////////////////////////////
func nginxPrep() bool {
	nginx, err := exec.Command("which", "nginx").CombinedOutput()
	// nginx, err := exec.Command("nginx", "-v").CombinedOutput()
	if err != nil {
		fmt.Printf("Failed to run nginx - %s%v\n", nginx, err.Error())
		return false
	}

	config.Log = lumber.NewConsoleLogger(lumber.LvlInt("FATAL"))

	config.Balancer = "nginx"
	config.WorkDir = "/tmp/portal"

	// todo: write config file for tests to /tmp/portal/portal-nginx.conf

	err = balance.Init()
	// skip tests if failed to init
	if err != nil {
		fmt.Printf("Failed to initialize nginx - %s%v\n", nginx, err.Error())
		return false
	}
	return true
}
コード例 #25
0
ファイル: api_test.go プロジェクト: nanopack/logvac
// manually configure and start internals
func initialize() {
	http.DefaultTransport.(*http.Transport).TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
	secureHttp = "127.0.0.1:2236"
	insecureHttp = "127.0.0.1:2234"
	config.Insecure = true
	config.ListenHttp = "127.0.0.1:2234"
	config.ListenTcp = "127.0.0.1:2235"
	config.ListenUdp = "127.0.0.1:2234"
	config.DbAddress = "boltdb:///tmp/apiTest/logvac.bolt"
	config.AuthAddress = ""
	config.Log = lumber.NewConsoleLogger(lumber.LvlInt("ERROR"))

	// initialize logvac
	logvac.Init()

	// setup authenticator
	err := authenticator.Init()
	if err != nil {
		config.Log.Fatal("Authenticator failed to initialize - %v", err)
		os.Exit(1)
	}

	// initialize drains
	err = drain.Init()
	if err != nil {
		config.Log.Fatal("Drain failed to initialize - %v", err)
		os.Exit(1)
	}

	// initializes collectors
	err = collector.Init()
	if err != nil {
		config.Log.Fatal("Collector failed to initialize - %v", err)
		os.Exit(1)
	}
}
コード例 #26
0
ファイル: config.go プロジェクト: josephyzhou/yoke
}

// establish constants
// these are singleton values that are used throughout
// the package.
var (
	Conf = Config{
		AdvertisePort:   4400,
		PGPort:          5432,
		DataDir:         "/data/",
		StatusDir:       "./status/",
		SyncCommand:     "rsync -a --delete {{local_dir}} {{slave_ip}}:{{slave_dir}}",
		DecisionTimeout: 10,
		SystemUser:      SystemUser(),
	}
	Log = lumber.NewConsoleLogger(lumber.INFO)
)

// init Initializeds the config file and the other constants
func Init(path string) {

	//
	file, err := ini.LoadFile(path)
	if err != nil {
		Log.Error("[config.init]: Failed to load config file!\n%s\n", err)
		os.Exit(1)
	}

	// no conversion required for strings.
	if role, ok := file.Get("config", "role"); ok {
		Conf.Role = role
コード例 #27
0
ファイル: commands.go プロジェクト: nanopack/portal
func startPortal(ccmd *cobra.Command, args []string) error {
	if config.LogFile == "" {
		config.Log = lumber.NewConsoleLogger(lumber.LvlInt(config.LogLevel))
	} else {
		var err error
		config.Log, err = lumber.NewFileLogger(config.LogFile, lumber.LvlInt(config.LogLevel), lumber.ROTATE, 5000, 9, 100)
		if err != nil {
			config.Log.Fatal("File logger init failed - %v", err)
			return fmt.Errorf("")
		}
	}

	// ensure proxy ports are unique. we need to check because tls will not listen
	// until a cert is added. we want it to break sooner.
	if config.RouteHttp == config.RouteTls {
		config.Log.Fatal("Proxy addresses must be unique")
		return fmt.Errorf("")
	}
	// need ':' in case tls is double apiport (8080, 80)
	apiPort := fmt.Sprintf(":%s", config.ApiPort)
	if strings.HasSuffix(config.RouteTls, apiPort) {
		config.Log.Fatal("TLS proxy address must be unique")
		return fmt.Errorf("")
	}

	// initialize database
	err := database.Init()
	if err != nil {
		config.Log.Fatal("Database init failed - %v", err)
		return fmt.Errorf("")
	}
	// initialize balancer
	err = balance.Init()
	if err != nil {
		config.Log.Fatal("Balancer init failed - %v", err)
		return fmt.Errorf("")
	}
	// initialize proxymgr
	err = proxymgr.Init()
	if err != nil {
		config.Log.Fatal("Proxymgr init failed - %v", err)
		return fmt.Errorf("")
	}
	// initialize vipmgr
	err = vipmgr.Init()
	if err != nil {
		config.Log.Fatal("Vipmgr init failed - %v", err)
		return fmt.Errorf("")
	}
	// initialize cluster
	err = cluster.Init()
	if err != nil {
		config.Log.Fatal("Cluster init failed - %v", err)
		return fmt.Errorf("")
	}

	go sigHandle()

	// start api
	err = api.StartApi()
	if err != nil {
		config.Log.Fatal("Api start failed - %v", err)
		return fmt.Errorf("")
	}
	return nil
}
コード例 #28
0
ファイル: constants.go プロジェクト: jmptrader/postmaster
package postmaster

import (
	"github.com/jcelliott/lumber"
)

var (
	log lumber.Logger = lumber.NewConsoleLogger(lumber.INFO)
)

const (
	POSTMASTER_VERSION   = "0.2.0"
	POSTMASTER_SERVER_ID = "postmaster-" + POSTMASTER_VERSION
)

const ALLOWED_BACKLOG = 6

//Auth: wamp cra
const WAMP_BASE_URL = "http://api.wamp.ws/"
const WAMP_PROCEDURE_URL = WAMP_BASE_URL + "procedure#"
コード例 #29
0
ファイル: main.go プロジェクト: jshawl/mist
func main() {
	configFile := ""
	if len(os.Args) > 1 && !strings.HasPrefix(os.Args[1], "-") {
		configFile = os.Args[1]
	}

	defaults := map[string]string{
		"tcp_listen_address":  "127.0.0.1:1445",
		"http_listen_address": "127.0.0.1:8080",
		"log_level":           "INFO",
		"multicast_interface": "eth1",
		"pg_user":             "******",
		"pg_database":         "postgres",
		"pg_address":          "127.0.0.1:5432",
	}

	config.Load(defaults, configFile)

	level := lumber.LvlInt(config.Config["log_level"])

	mist := mist.New()
	api.Name = "MIST"
	api.Logger = lumber.NewConsoleLogger(level)
	api.User = mist

	user := config.Config["pg_user"]
	database := config.Config["pg_database"]
	address := config.Config["pg_address"]

	pgAuth, err := authenticate.NewPostgresqlAuthenticator(user, database, address)
	if err != nil {
		api.Logger.Fatal("unable to start postgresql authenticator %v", err)
		os.Exit(1)
	}

	authCommands := handlers.GenerateAdditionalCommands(pgAuth)

	listen := config.Config["tcp_listen_address"]
	server, err := mist.Listen(listen, authCommands)

	if err != nil {
		api.Logger.Fatal("unable to start mist tcp listener %v", err)
		os.Exit(1)
	}
	defer server.Close()

	// start discovering other mist nodes on the network
	discover, err := discovery.NewDiscovery(config.Config["multicast_interface"], "mist", time.Second*2)
	if err != nil {
		panic(err)
	}
	defer discover.Close()

	// advertise this nodes listen address
	discover.Add("mist", listen)

	// enable replication between mist nodes
	replicate := handlers.EnableReplication(mist, discover)
	go replicate.Monitor()

	// start up the authenticated websocket connection
	authenticator := authenticate.NewNoopAuthenticator()
	handlers.LoadWebsocketRoute(authenticator)
	api.Start(config.Config["http_listen_address"])
}
コード例 #30
0
ファイル: haproxy-rest.go プロジェクト: Oakleon/haproxy-rest
// override the standard Gin-Gonic middleware to add the CORS headers
func CORSMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {

		c.Writer.Header().Set("Content-Type", "application/json")
		c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
		c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization")
	}
}

// set some globally used vars
var (
	ConfigObj  *Config
	logFile, _ = lumber.NewFileLogger("/tmp/haproxy-rest.log", lumber.DEBUG, lumber.ROTATE, 1000, 3, 100)
	logConsole = lumber.NewConsoleLogger(lumber.DEBUG)
	log        = lumber.NewMultiLogger()
)

func main() {

	// log to console and file
	log.Prefix("Haproxy-rest")
	log.AddLoggers(logFile, logConsole)

	// implicit -h prints out help messages
	port := flag.Int("port", 10001, "Port/IP to use for the REST interface. Overrides $PORT0 env variable")
	configFile := flag.String("configFile", "resources/haproxy_new.cfg", "Location of the target HAproxy config file")
	templateFile := flag.String("template", "resources/haproxy_cfg.template", "Template file to build HAproxy config")
	binary := flag.String("binary", "/usr/local/bin/haproxy", "Path to the HAproxy binary")
	pidFile := flag.String("pidFile", "resources/haproxy-private.pid", "Location of the HAproxy PID file")