Ejemplo n.º 1
0
func LoadConfigs() {
	defer setDefaults(&cfg) // Load the defaults at the end of the function call
	cfg = Config{}
	gcfg.ReadFileInto(&cfg, globalFile)
	gcfg.ReadFileInto(&cfg, configFile)
	gcfg.ReadFileInto(&cfg, overrideFile)
}
Ejemplo n.º 2
0
func ParseConfig(inputFile string) (subnets []*scanner.Subnet, params Params, e error) {
	type Config struct {
		Parameters Params
		Subnet     map[string]*struct {
			Network string
		}
	}
	config := Config{}
	e = gcfg.ReadFileInto(&config, inputFile)
	if e != nil {
		return nil, Params{}, e
	}

	params = config.Parameters
	for subnetName, network := range config.Subnet {
		log.Printf("Adding subnet %s %s", subnetName, network.Network)
		_, ipNet, e := net.ParseCIDR(network.Network)
		if e != nil {
			return nil, Params{}, e
		}
		sub := scanner.NewSubnet(subnetName, ipNet.String())
		generateAllInSubnet(ipNet, sub)
		subnets = append(subnets, sub)
	}
	return
}
Ejemplo n.º 3
0
// ReadConfiguration loads a client configuration from a local configuration file
// and verifies that GnuPG's secring is available
func ReadConfiguration(file string) (conf Configuration, err error) {
	defer func() {
		if e := recover(); e != nil {
			err = fmt.Errorf("ReadConfiguration() -> %v", e)
		}
	}()
	_, err = os.Stat(file)
	if err != nil {
		fmt.Fprintf(os.Stderr, "no configuration file found at %s\n", file)
		err = MakeConfiguration(file)
		if err != nil {
			panic(err)
		}
	}
	err = gcfg.ReadFileInto(&conf, file)
	if conf.GPG.Home == "" {
		gnupgdir := os.Getenv("GNUPGHOME")
		if gnupgdir == "" {
			gnupgdir = "/.gnupg"
		}
		conf.GPG.Home = FindHomedir() + gnupgdir
	}
	_, err = os.Stat(conf.GPG.Home + "/secring.gpg")
	if err != nil {
		panic("secring.gpg not found")
	}
	// if trailing slash is missing from API url, add it
	if conf.API.URL[len(conf.API.URL)-1] != '/' {
		conf.API.URL += "/"
	}
	return
}
Ejemplo n.º 4
0
func BootstrapConfig() (*Config, error) {
	home := os.Getenv("STF_HOME")
	if home == "" {
		var err error
		home, err = os.Getwd()
		if err != nil {
			log.Fatalf("Failed to get home from env and Getwd: %s", err)
		}
	}

	cfg := Config{}
	file := os.Getenv("STF_CONFIG")
	if file == "" {
		file = path.Join("etc", "config.gcfg")
	}
	if !filepath.IsAbs(file) {
		file = path.Join(home, file)
	}

	err := gcfg.ReadFileInto(&cfg, file)
	if err != nil {
		return nil, errors.New(
			fmt.Sprintf(
				"Failed to load config file '%s': %s",
				file,
				err,
			),
		)
	}

	cfg.FileName = file
	cfg.Prepare()
	return &cfg, nil
}
Ejemplo n.º 5
0
func init() {
	err := gcfg.ReadFileInto(&MasterConfig, "kirisurf.conf")
	log.Debug("Read configuration successfully")
	if err != nil {
		panic(err.Error())
	}
}
Ejemplo n.º 6
0
func main() {
	configFilePath := flag.String("config", "./etc/goahead.ini", "Configuration file path")
	help := flag.Bool("help", false, "Show me the help!")
	run := flag.Bool("run", false, "Run server")
	build := flag.Bool("build", false, "Create the scaffold")

	flag.Parse()

	if *help || (!(*run) && !(*build)) {
		showHelp()
		return
	}

	err := gcfg.ReadFileInto(&_cfg, *configFilePath)
	if err != nil {
		log.Fatal(err)
	}
	db := database.Create(&(_cfg.Database))
	err = db.IsValid()
	if err != nil {
		log.Fatal(err)
	}

	if *build {
		buildScaffold(db)
		return
	}

	if *run {
		runServer(db)
		return
	}

}
Ejemplo n.º 7
0
func parseConfigFile(filename string, cfg *Config) error {
	// Just testing config structs
	err := gcfg.ReadFileInto(cfg, configFile)
	if err != nil {
		panic(err)
	}
}
Ejemplo n.º 8
0
func ReadConfig(cfg *Config, path string) (ok bool) {
	err := gcfg.ReadFileInto(cfg, path)
	if err != nil {
		return false
	}
	return true
}
Ejemplo n.º 9
0
// Read configuration.
func getCfg() *cfgType {
	var c cfgType
	var errorSeen bool

	// set up some sane default configuration settings:
	c.Main.Zpoolstatusrefresh = 10
	c.Main.Zpoolstatuscmd = "zpool status"
	c.Main.Zfslistrefresh = 60
	c.Main.Zfslistcmd = "zfs list -H -o name,avail,used,usedsnap,usedds,usedrefreserv,usedchild,refer,mountpoint -d 0"
	c.Main.Zfslistusagecmd = "zfs list -H -o name,avail,used,usedsnap,usedds,usedrefreserv,usedchild,refer,mountpoint -r -t all"
	c.Leds.Ledctlcmd = "ledctl"
	c.Severity.Pooladded = notifier.INFO
	c.Severity.Poolremoved = notifier.INFO
	c.Severity.Poolstatuschanged = notifier.INFO
	c.Severity.Poolstatuscleared = notifier.INFO
	c.Severity.Poolerrorschanged = notifier.INFO
	c.Severity.Devadded = notifier.INFO
	c.Severity.Devremoved = notifier.INFO
	c.Severity.Devreaderrorsincreased = notifier.INFO
	c.Severity.Devwriteerrorsincreased = notifier.INFO
	c.Severity.Devcksumerrorsincreased = notifier.INFO
	c.Severity.Devadditionalinfochanged = notifier.INFO
	c.Severity.Devadditionalinfocleared = notifier.INFO

	// read configuration settings:
	err := gcfg.ReadFileInto(&c, cfgFile)
	checkCfgErr(cfgFile, "", "", "", err, &errorSeen)

	if errorSeen {
		return nil
	}
	return &c
}
Ejemplo n.º 10
0
func LoadConfig(filename string) (Config, error) {
	var c Config

	err := gcfg.ReadFileInto(&c, filename)

	return c, err
}
Ejemplo n.º 11
0
func init() {
	flag.Parse()
	err := gcfg.ReadFileInto(&cfg, *configFile)
	if err != nil {
		log.Fatal(err)
	}

	session, err = r.Connect(r.ConnectOpts{
		Address:  cfg.Database.Host + ":" + cfg.Database.Port, //localhost:28015
		Database: cfg.Database.DB,                             //DB: cats
	})
	if err != nil {
		log.Fatal("Could not connect")
	}
	res, err := r.DBCreate(cfg.Database.DB).RunWrite(session)
	if err != nil {
		log.Println(err.Error())
	}

	fmt.Printf("%d DB created\n", res.DBsCreated)
	r.DB(cfg.Database.DB).TableCreate("instacat").Run(session)
	log.Println("Create table instacat.")
	r.Table("instacat").IndexCreate("time").Run(session)
	log.Println("Create index time.")
	r.Table("instacat").IndexCreate("place", r.IndexCreateOpts{Geo: true}).Run(session)
	log.Println("Create index place.")
}
Ejemplo n.º 12
0
func main() {
	var (
		err  error
		conf Config
	)
	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "%s - a worker verifying agents that fail to authenticate\n", os.Args[0])
		flag.PrintDefaults()
	}
	var configPath = flag.String("c", "/etc/mig/agent_verif_worker.cfg", "Load configuration from file")
	flag.Parse()
	err = gcfg.ReadFileInto(&conf, *configPath)
	if err != nil {
		panic(err)
	}
	// set a binding to route events from event.Q_Agt_Auth_Fail into the queue named after the worker
	// and return a channel that consumes the queue
	workerQueue := "migevent.worker." + workerName
	consumerChan, err := workers.InitMqWithConsumer(conf.Mq, workerQueue, event.Q_Agt_Auth_Fail)
	if err != nil {
		panic(err)
	}
	fmt.Println("started worker", workerName, "consuming queue", workerQueue, "from key", event.Q_Agt_Auth_Fail)
	for event := range consumerChan {
		fmt.Printf("%s\n", event.Body)
	}
	return
}
Ejemplo n.º 13
0
func readConfig() {

	err := gcfg.ReadFileInto(&IcerayCfg, *ConfigPath)
	if err != nil {
		log.Fatal("Error opening config file: " + err.Error())
	}

	if *Hostname == DEFAULT_HOSTNAME && IcerayCfg.Server.Hostname != "" {
		*Hostname = IcerayCfg.Server.Hostname
	}

	if *Port == DEFAULT_PORT && IcerayCfg.Server.Port != 0 {
		*Port = IcerayCfg.Server.Port
	}

	mountpoint := IcerayCfg.Server.Mount
	if mountpoint[0] != '/' {
		mountpoint = "/" + mountpoint
	}

	if *Mount == DEFAULT_MOUNTPOINT && IcerayCfg.Server.Mount != "" {
		*Mount = IcerayCfg.Server.Mount
	}

	if *Username == DEFAULT_USERNAME && IcerayCfg.Server.User != "" {
		*Username = IcerayCfg.Server.User
	}

	if *Password == DEFAULT_PASSWORD && IcerayCfg.Server.Password != "" {
		*Password = IcerayCfg.Server.Password
	}
}
Ejemplo n.º 14
0
// LoadConfig loads the configuration from given file path
func LoadConfig(filename string) {
	err := gcfg.ReadFileInto(&Config, filename)
	if err != nil {
		logger.Logger.Print("Config: ", err)
		log.Fatal("Config: ", err)
	}
}
Ejemplo n.º 15
0
func main() {
	var (
		confPath string
	)

	flag.StringVar(&confPath, "f", "./ipcapcom.conf", "path to config file")
	flag.Parse()
	err := gcfg.ReadFileInto(&cfg, confPath)
	if err != nil {
		fmt.Fprintf(os.Stderr, "error reading config file: %v\n", err)
		os.Exit(1)
	}

	r := mux.NewRouter()
	r.HandleFunc("/ping", handlePing).Methods("GET")
	r.HandleFunc("/apply", handleApply).Methods("POST")
	r.HandleFunc("/purge", handlePurge).Methods("GET")
	r.PathPrefix("/").Handler(http.FileServer(http.Dir(cfg.General.StaticDir)))
	http.Handle("/", context.ClearHandler(r))
	go reaper()
	err = http.ListenAndServe(":"+cfg.General.ListenPort, nil)
	if err != nil {
		fmt.Fprintf(os.Stderr, "error: %v\n", err)
		os.Exit(1)
	}
}
Ejemplo n.º 16
0
func main() {
	flag.Parse()
	if *ticket_number == 0 {
		log.Fatal("You must specify a ticket number. View usage for details.")
	}
	if *link_with == 0 {
		log.Print("No linking ticket specified. Will create Sprint.ly ticket.")
	}

	config := ConfigFile{}
	err := gcfg.ReadFileInto(&config, os.ExpandEnv(*config_location))
	if err != nil {
		log.Fatal(err)
	}
	err = config.validate()
	if err != nil {
		log.Fatalf("Invalid config file: %s", err)
	}

	uv_client := uservoice.NewUservoiceClient(config.Uservoice)

	// get ticket from uservoice
	ticket, err := uv_client.GetTicketByNumber(*ticket_number)
	if err != nil {
		log.Fatalf("Error fetching ticket by number: %s\n", err)
	}

	s_client := sprintly.NewSprintlyClient(
		config.Sprintly.Email,
		config.Sprintly.ApiKey,
		config.Sprintly.ProductId,
	)

	var url string
	if *link_with == 0 {
		// post to sprint.ly
		if len(ticket.Messages) > 0 {
			message := fmt.Sprintf("%s\n\n(Link to Uservoice)[%s]",
				ticket.Messages[len(ticket.Messages)-1].PlaintextBody,
				uv_client.UrlForTicket(ticket.Number))
			url, err = s_client.CreateDefect(ticket.Subject, message)
			if err != nil {
				log.Fatalf("Couldn't create Sprint.ly defect: %s\n", err)
			}
		} else {
			log.Fatal("There were no messages in the provided ticket.")
		}
	} else {
		url = s_client.ItemLink(*link_with)
		s_client.AddAnnotation(*link_with,
			"uservoice", "received a message from a customer",
			fmt.Sprintf("[%d](%s)", ticket.Number,
				uv_client.UrlForTicket(ticket.Number)))
	}

	// post url of sprintly ticket as note to uservoice
	uv_client.PostNote(ticket.Id, url)

	fmt.Printf("Ticket ( %s ) posted from Uservoice #%v\n", url, *ticket_number)
}
Ejemplo n.º 17
0
func LoadConfig() error {
	err := gcfg.ReadFileInto(&config, "/etc/disco/disco.conf")
	if err != nil {
		return err
	}
	return nil
}
Ejemplo n.º 18
0
func main() {
	var err error
	flag.Parse()

	// Read config
	c := dalga.NewConfig()
	if *configPath != "" {
		err = gcfg.ReadFileInto(c, *configPath)
		if err != nil {
			log.Fatalln(err)
		}
		fmt.Println("Read config: ", c)
	}

	// Initialize Dalga object
	d := dalga.NewDalga(c)

	// Create jobs table
	if *createTable {
		err = d.CreateTable()
		if err != nil {
			log.Fatalln(err)
		}
		fmt.Println("Table created successfully")
		return
	}

	// Run Dalga
	err = d.Run()
	if err != nil {
		log.Fatalln(err)
	}
}
Ejemplo n.º 19
0
func readConfig() *FactomdConfig {
	cfg := new(FactomdConfig)
	filename := getHomeDir() + "/.factom/factomd.conf"
	log.Println("read factom config file: ", filename)

	// This makes factom config file located at
	//   POSIX (Linux/BSD): ~/.factom/factom.conf
	//   Mac OS: $HOME/Library/Application Support/Factom/factom.conf
	//   Windows: %LOCALAPPDATA%\Factom\factom.conf
	//   Plan 9: $home/factom/factom.conf
	//factomHomeDir := btcutil.AppDataDir("factom", false)
	//defaultConfigFile := filepath.Join(factomHomeDir, "factomd.conf")
	//
	// eventually we need to make data dir as following
	//defaultDataDir   = filepath.Join(factomHomeDir, "data")
	//LdbPath					 = filepath.Join(defaultDataDir, "ldb9")
	//DataStorePath		 = filepath.Join(defaultDataDir, "store/seed/")

	err := gcfg.ReadFileInto(cfg, filename)
	if err != nil {
		log.Println("Server starting with default settings...")
		gcfg.ReadStringInto(cfg, defaultConfig)
	}
	return cfg
}
Ejemplo n.º 20
0
// Loads config.gcfg into jew.conf, a variable type of JewConfig
func loadConfiguration() error {
	if gcfg.ReadFileInto(&jew.conf, fmt.Sprintf("%s/jewvis/config.gcfg", jew.homeDir)) == nil {
		return nil
	}
	fmt.Printf("%s/jewvis/config.gcfg\n", jew.homeDir)
	return errors.New("Configuration load failed.")
}
Ejemplo n.º 21
0
func main() {
	flag.Parse()

	// Test cfgfile exists
	res := testcfgfile()
	if res != nil {
		fmt.Println("Configuration file error: " + res.Error())
		os.Exit(1)
	}

	// Parse in config file
	err := gcfg.ReadFileInto(&config, cfgfile)
	if err != nil {
		fmt.Println("Configuration file error: " + err.Error())
		os.Exit(1)
	}

	if chkping && pcount == 0 {
		pcount = config.Ping.Packets
	}

	if chkdns {
		dns.TestHosts(config.Dns.Host, debug)
	}

	if chkping {
		ping.PingHosts(config.Ping.Host, pcount, debug)
	}
}
Ejemplo n.º 22
0
func loadConfigurations() {
	cfg := struct {
		Wallet struct {
			WalletStorePath string
		}
	}{}

	var sf = "wallet.conf"
	wd, err := os.Getwd()
	if err != nil {
		log.Println(err)
	} else {
		sf = wd + "/" + sf
	}

	err = gcfg.ReadFileInto(&cfg, sf)
	if err != nil {
		log.Println(err)
		log.Println("Wallet using default settings...")
	} else {
		log.Println("Walet using settings from: " + sf)
		log.Println(cfg)

		walletStorePath = cfg.Wallet.WalletStorePath
	}

}
Ejemplo n.º 23
0
func LoadConfig(cfgPath string) *Config {
	var cfg Config
	err := gcfg.ReadFileInto(&cfg, cfgPath)
	if err != nil {
		log.Printf("Error while reading configuration: %s", err.Error())
		panic(err)
	}

	// do some basic checking
	if len(cfg.Billing.Currency) != 3 {
		log.Printf("Warning: currency is set to [%s], but currency codes should be three characters", cfg.Billing.Currency)
	}
	if cfg.Billing.BandwidthOverageFee == 0 {
		log.Printf("Warning: bandwidth overage fee not set")
	}
	if cfg.Billing.StorageFee == 0 {
		log.Printf("Warning: storage fee not set")
	}
	if cfg.Billing.BillingInterval == 0 {
		log.Printf("Warning: billing interval not set, defaulting to 60 minutes")
		cfg.Billing.BillingInterval = 60
	}
	if cfg.Billing.BillingVmMinimum < 1 {
		log.Printf("Warning: minimum VM billing intervals less than 1, setting to 1")
		cfg.Billing.BillingVmMinimum = 1
	}

	return &cfg
}
Ejemplo n.º 24
0
func main() {
	// Parse command line arguments
	var (
		config_file = flag.String("config", "", "Path to configuration file")
	)
	flag.Parse()

	// Load configuration into package variable Config
	config_error := gcfg.ReadFileInto(&Config, *config_file)
	if config_error != nil {
		log.Fatal("Could not load config file: " + config_error.Error())
	}

	// Instantiate StatsD connection
	if Config.Statsd.Host == "" {
		StatsD = g2s.Noop()
	} else {
		StatsD, _ = g2s.Dial(Config.Statsd.Protocol, Config.Statsd.Host+":"+Config.Statsd.Port)
	}

	// Log startup
	log.Println("go-airbrake-proxy started")

	// Fire up an HTTP server and handle it
	http.HandleFunc("/", httpHandler)
	http.ListenAndServe(Config.Listen.Host+":"+Config.Listen.Port, nil)
}
Ejemplo n.º 25
0
func NewEntityFactory(cfgFile string) (EntityFactory, error) {
	ef := &entityFactoryStruct{
		Unit:  make(map[string]*unit.UnitType),
		Tower: make(map[string]*tower.TowerType),
	}

	err := gcfg.ReadFileInto(ef, cfgFile)
	if err != nil {
		return nil, err
	}

	for name, u := range ef.Unit {
		if name != u.Name {
			return nil, fmt.Errorf("Unit is listed as '%s' but name = '%s'", name, u.Name)
		}
	}

	for name, t := range ef.Tower {
		if name != t.Name {
			return nil, fmt.Errorf("Tower is listed as '%s' but name = '%s'", name, t.Name)
		}
	}

	return ef, nil
}
Ejemplo n.º 26
0
func (c *Config) getConfig() error {
	flag.Parse()

	if c.General.Configs != "" {
		configs := filepath.SplitList(c.General.Configs)
		for _, config := range configs {
			err := gcfg.ReadFileInto(c, config)
			if err != nil {
				fmt.Fprintf(os.Stderr, "Error loading config: %s\n\n%s\n", config, err.Error())
				os.Exit(2)
			}
		}
	}

	if c.General.Path == "" {
		fmt.Fprintf(os.Stderr, "Missing path\n")
		flag.Usage()
		os.Exit(2)
	}
	if c.General.Mountpoint == "" {
		fmt.Fprintf(os.Stderr, "Missing mount point\n")
		flag.Usage()
		os.Exit(2)
	}

	return nil
}
Ejemplo n.º 27
0
func LoadConfig(home string) (*Config, error) {
	cfg := &Config{}
	file := os.Getenv("STF_CONFIG")
	if file == "" {
		file = path.Join("etc", "config.gcfg")
	}
	if !filepath.IsAbs(file) {
		file = path.Join(home, file)
	}
	log.Printf("Loading config file %s", file)

	err := gcfg.ReadFileInto(cfg, file)
	if err != nil {
		return nil, errors.New(
			fmt.Sprintf(
				"Failed to load config file '%s': %s",
				file,
				err,
			),
		)
	}

	cfg.FileName = file
	cfg.Prepare()

	return cfg, nil
}
Ejemplo n.º 28
0
func configReader(fileName string) error {

	stat, err := os.Stat(fileName)
	if err != nil {
		log.Printf("Failed to find config file: %s\n", err)
		return err
	}

	if !stat.ModTime().After(lastReadConfig) {
		return err
	}

	lastReadConfig = time.Now()

	log.Printf("Loading config: %s\n", fileName)

	cfg := new(AppConfig)

	err = gcfg.ReadFileInto(cfg, fileName)
	if err != nil {
		log.Printf("Failed to parse config data: %s\n", err)
		return err
	}

	cfg.Flags.HasStatHat = len(cfg.StatHat.ApiKey) > 0

	// log.Println("STATHAT APIKEY:", cfg.StatHat.ApiKey)
	// log.Println("STATHAT FLAG  :", cfg.Flags.HasStatHat)

	Config = cfg

	return nil
}
Ejemplo n.º 29
0
// Loads mumbledj.gcfg into dj.conf, a variable of type DjConfig.
func loadConfiguration() error {
	if gcfg.ReadFileInto(&dj.conf, fmt.Sprintf("%s/.mumbledj/config/mumbledj.gcfg", dj.homeDir)) == nil {
		return nil
	}
	fmt.Printf("%s/.mumbledj/config/mumbledj.gcfg\n", dj.homeDir)
	return errors.New("Configuration load failed.")
}
Ejemplo n.º 30
0
func loadConfig() error {
	err := gcfg.ReadFileInto(&cfg, configFile)
	if err != nil {
		return err
	}
	return nil
}