func NewConfig() (cfg Config) { err := gcfg.ReadFileInto(&cfg, "demo.gcfg") if err != nil { panic(err) } flag.StringVar(&cfg.Service.Host, "host", getLocalIp().String(), "host ip Address") flag.StringVar(&cfg.Service.Restcomm, "restcomm", cfg.Service.Restcomm, "Restcomm ip Address") flag.StringVar(&cfg.Service.Redis, "redis", cfg.Service.Redis, "Redis ip Address") flag.StringVar(&cfg.Service.Recorder, "rec", cfg.Service.Recorder, "Recorder host") flag.StringVar(&cfg.Auth.User, "r-user", cfg.Auth.User, "Restcomm user") flag.StringVar(&cfg.Auth.Pass, "r-pass", cfg.Auth.Pass, "Restcomm password") flag.StringVar(&cfg.Callback.Phone, "r-phone-incom", cfg.Callback.Phone, "Incoming phone number") flag.StringVar(&cfg.Callback.Conference, "r-phone-conf", cfg.Callback.Conference, "Conference phone number") flag.StringVar(&cfg.Callback.Sms, "r-phone-sms", cfg.Callback.Sms, "Sms phone number") flag.StringVar(&cfg.Sip.DidProvider, "dp", cfg.Sip.DidProvider, "Did provider sip domain") l := flag.String("l", "INFO", "Log level: TRACE, INFO") flag.Parse() var traceHandle io.Writer if *l == "TRACE" { traceHandle = os.Stdout } else { traceHandle = ioutil.Discard } InitLog(traceHandle, os.Stdout, os.Stdout, os.Stdout) return cfg }
func LoadLocalize() error { if !base.IsFile(LocalizeConfigFile) { os.MkdirAll(path.Dir(LocalizeConfigFile), os.ModePerm) os.Create(LocalizeConfigFile) } data := struct { Domain map[string]*struct { Depth int Download string } }{} if err := gcfg.ReadFileInto(&data, LocalizeConfigFile); err != nil { return err } for domain, config := range data.Domain { if config.Depth <= 0 { config.Depth = 3 } Localizes = append(Localizes, &goconfig.Localize{ Domain: domain, RootDepth: config.Depth, Download: config.Download, }) } return nil }
func LoadConfig(cfgFile string, cfg *config) { err := gcfg.ReadFileInto(cfg, cfgFile) if err != nil { Log.Fatal("Couldnt read config file: " + err.Error()) } }
// 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.") }
// Loads mumblejew.gcfg into jew.conf, a variable of type jewConfig. func loadConfig() error { if gcfg.ReadFileInto(&jew.conf, fmt.Sprintf("%s/jewbot/config.gcfg", jew.homeDir)) == nil { return nil } fmt.Printf("%s/jewbot/config.gcfg\n", jew.homeDir) return errors.New("Configuration load failed.") }
func TestParseConfig(t *testing.T) { c := &Config{} err := gcfg.ReadFileInto(c, "../../../etc/duke.ini") if err != nil { t.Fatal(err) } }
func ReadConfig(file string) (*Config, error) { var config Config err := gcfg.ReadFileInto(&config, file) if err != nil { return nil, err } return &config, nil }
func main() { flag.Usage = usage help := flag.Bool("help", false, "show this message") version := flag.Bool("version", false, "show version") resume := flag.String("resume", "", "resume path") flag.Parse() if *help { flag.Usage() os.Exit(0) } if *version { fmt.Fprintf(os.Stderr, "%s version %s, Copyright (c) 2013 Uwe Hoffmann. All rights reserved.\n", os.Args[0], versionStr) os.Exit(0) } config := new(Config) err := gcfg.ReadFileInto(config, "depot.ini") if err != nil { fmt.Fprintf(os.Stderr, "reading depot.ini failed: %v\n", err) os.Exit(1) } for i := 0; i < len(config.Depot.MaxSize); i++ { config.Depot.MaxSize[i] *= int64(archive.GB) } depot, err := archive.NewDepot(config.Depot.Root, config.Depot.MaxSize, new(db.NoOpDB), 8) if err != nil { fmt.Fprintf(os.Stderr, "creating depot failed: %v\n", err) os.Exit(1) } resumeLoggerFile, err := os.Create("archive-resume.log") if err != nil { fmt.Fprintf(os.Stderr, "creating archive-resume.log failed: %v\n", err) os.Exit(1) } defer resumeLoggerFile.Close() archiveLoggerFile, err := os.Create("archive-work.log") if err != nil { fmt.Fprintf(os.Stderr, "creating archive-work.log failed: %v\n", err) os.Exit(1) } defer archiveLoggerFile.Close() err = depot.Archive(flag.Args(), *resume, log.New(resumeLoggerFile, "", 0), log.New(archiveLoggerFile, "", 0)) if err != nil { fmt.Fprintf(os.Stderr, "archiving failed: %v\n", err) os.Exit(1) } }
func main() { var cfg Config var locationName string var nodeList nodelist check(gcfg.ReadFileInto(&cfg, "myconfig.gcfg")) now := time.Now().Add(-cfg.Config.UpdateInterval * time.Hour) anaconda.SetConsumerKey(cfg.Anaconda.ConsumerKey) anaconda.SetConsumerSecret(cfg.Anaconda.ConsumerSecret) api := anaconda.NewTwitterApi(cfg.Anaconda.AccessToken, cfg.Anaconda.AccessTokenSecret) check(LoadJson(cfg.Freifunk.NodelistUrl, &nodeList)) for i := range nodeList.Nodes { t, err := time.Parse("2006-01-02T15:04:05", nodeList.Nodes[i].Status.Firstcontact) check(err) if t.After(now) && nodeList.Nodes[i].Position.Lat != 0 { jsonUrl := "https://nominatim.openstreetmap.org/reverse?format=json&lat=" + strconv.FormatFloat(nodeList.Nodes[i].Position.Lat, 'f', 5, 64) + "&lon=" + strconv.FormatFloat(nodeList.Nodes[i].Position.Long, 'f', 5, 64) + "&zoom=16&addressdetails=1" if len(cfg.Config.Email) > 0 { jsonUrl += "&email=" + cfg.Config.Email } var nodeAddress address check(LoadJson(jsonUrl, &nodeAddress)) if nodeAddress.Address.Suburb != "" { locationName = nodeAddress.Address.Suburb } else if nodeAddress.Address.CityDistrict != "" { locationName = nodeAddress.Address.CityDistrict } else if nodeAddress.Address.Village != "" { locationName = nodeAddress.Address.Village } else if nodeAddress.Address.Town != "" { locationName = nodeAddress.Address.Town } else if nodeAddress.Address.City != "" { locationName = nodeAddress.Address.City } else { locationName = "*hust*" } if cfg.Config.Debug { fmt.Println(locationName + " " + nodeList.Nodes[i].Name + " " + cfg.Freifunk.MapUrl + "#!v:m;n:" + nodeList.Nodes[i].ID) } else { update, err := api.PostTweet("In "+locationName+" gibt es einen neuen #Freifunk-Knoten: "+nodeList.Nodes[i].Name+" "+cfg.Freifunk.MapUrl+"#!v:m;n:"+nodeList.Nodes[i].ID, nil) check(err) fmt.Println(update) } time.Sleep(1100 * time.Millisecond) } } }
func main() { err := gcfg.ReadFileInto(&cfg, "gatekeeper.cfg") if err != nil { log.Fatalf("Failed to parse gcfg data: %s", err) os.Exit(1) } file, err := os.OpenFile(cfg.Gatekeeper.LogFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666) if err != nil { log.Fatalln("Failed to open log file", "auth-utils.log", ":", err) } multi := io.MultiWriter(file, ioutil.Discard) Initlogger(ioutil.Discard, os.Stdout, os.Stdout, os.Stderr, multi) //logger has been initialized at this point InitMsgs() dbArg = "file:foo.db?cache=shared&mode=rwc" dbArg = strings.Replace(dbArg, "foo.db", cfg.Gatekeeper.DbFile, 1) dbCheck := CheckDB(dbArg) if dbCheck { MyFileInfo.Println("Table already exists in DB, nothing to do, proceeding normally.") } else { InitDB(dbArg) } r := mux.NewRouter().StrictSlash(false) r.HandleFunc("/", HomeHandler) users := r.Path("/admin/user/").Subrouter() users.Methods("GET").HandlerFunc(UserListHandler) users.Methods("POST").HandlerFunc(UserCreateHandler) user := r.Path("/admin/user/{id}").Subrouter() user.Methods("GET").HandlerFunc(UserDetailsHandler) user.Methods("PUT").HandlerFunc(UserUpdateHandler) user.Methods("DELETE").HandlerFunc(UserDeleteHandler) auth := r.Path("/auth/{id}").Subrouter() auth.Methods("GET").HandlerFunc(UserAuthHandler) tokens := r.Path("/token/").Subrouter() tokens.Methods("POST").HandlerFunc(TokenGenHandler) tokenval := r.Path("/token/validate/{id}").Subrouter() tokenval.Methods("GET").HandlerFunc(TokenValidateHandler) services := r.Path("/admin/service/").Subrouter() services.Methods("GET").HandlerFunc(ServiceListHandler) services.Methods("POST").HandlerFunc(ServiceRegisterHandler) portArg := ":port" portArg = strings.Replace(portArg, "port", cfg.Gatekeeper.Port, 1) MyFileInfo.Println("Starting server on", portArg) http.ListenAndServe(portArg, r) MyFileInfo.Println("Stopping server on", portArg) }
// NewConfig returns a new Config based on given location (or default). // // If zero value ("") location is given, then the default locations are tried: // ./ezgliding.cfg, ~/.ezgliding.cfg, ~/.ezgliding func NewConfig(location string) (Config, error) { cfg := Config{} var err error locations := []string{location} if location == "" { usr, _ := user.Current() locations = append(locations, "./ezgliding.cfg", usr.HomeDir+"/.ezgliding.cfg", usr.HomeDir+"/.ezgliding") } for _, l := range locations { _, err = os.Stat(l) if err == nil { err = gcfg.ReadFileInto(&cfg, l) break } } return cfg, err }
func LoadConfig(cfgFile string) (AppConfig, error) { var err error var cfg AppConfig // isExists := util.IsExist(cfgFile) // if !isExists { // return cfg, errors.New("Config file is not exists!") // } err = gcfg.ReadFileInto(&cfg, cfgFile) if err != nil { //panic(err) return cfg, err } return cfg, nil }
func main() { flag.Parse() conf = new(config.Config) err := gcfg.ReadFileInto(conf, *cfgFile) if err != nil { panic(err) } resp, err := http.Get(conf.Client.URL + "/lookup?user=" + flag.Arg(0)) defer resp.Body.Close() _, err = io.Copy(os.Stdout, resp.Body) if err != nil { panic(err) } }
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 } if cfg.BillingNotifications.LowBalanceIntervals == cfg.BillingTermination.SuspendBalanceIntervals { log.Printf("Warning: low balance intervals is set the same as suspend balance intervals") } if cfg.BillingNotifications.Frequency == 0 { log.Printf("Warning: billing notifications frequency not set, defaulting to 24 hours") cfg.BillingNotifications.Frequency = 24 } return &cfg }
func main() { cfg := new(config.Config) iniPath, err := findINI() if err != nil { fmt.Fprintf(os.Stderr, "finding romba ini failed: %v\n", err) os.Exit(1) } err = gcfg.ReadFileInto(cfg, iniPath) if err != nil { fmt.Fprintf(os.Stderr, "reading romba ini from %s failed: %v\n", iniPath, err) os.Exit(1) } for i := 0; i < len(cfg.Depot.MaxSize); i++ { cfg.Depot.MaxSize[i] *= int64(archive.GB) } cfg.General.LogDir, err = filepath.Abs(cfg.General.LogDir) if err != nil { fmt.Fprintf(os.Stderr, "reading romba ini failed: %v\n", err) os.Exit(1) } cfg.General.TmpDir, err = filepath.Abs(cfg.General.TmpDir) if err != nil { fmt.Fprintf(os.Stderr, "reading romba ini failed: %v\n", err) os.Exit(1) } for i, pv := range cfg.Depot.Root { cfg.Depot.Root[i], err = filepath.Abs(pv) if err != nil { fmt.Fprintf(os.Stderr, "reading romba ini failed: %v\n", err) os.Exit(1) } } cfg.Index.Dats, err = filepath.Abs(cfg.Index.Dats) if err != nil { fmt.Fprintf(os.Stderr, "reading romba ini failed: %v\n", err) os.Exit(1) } cfg.Index.Db, err = filepath.Abs(cfg.Index.Db) if err != nil { fmt.Fprintf(os.Stderr, "reading romba ini failed: %v\n", err) os.Exit(1) } cfg.General.WebDir, err = filepath.Abs(cfg.General.WebDir) if err != nil { fmt.Fprintf(os.Stderr, "reading romba ini failed: %v\n", err) os.Exit(1) } cfg.General.BadDir, err = filepath.Abs(cfg.General.BadDir) if err != nil { fmt.Fprintf(os.Stderr, "reading romba ini failed: %v\n", err) os.Exit(1) } config.GlobalConfig = cfg runtime.GOMAXPROCS(cfg.General.Cores) flag.Set("log_dir", cfg.General.LogDir) flag.Set("alsologtostderr", "true") flag.Set("v", strconv.Itoa(cfg.General.Verbosity)) flag.Parse() romDB, err := db.New(cfg.Index.Db) if err != nil { fmt.Fprintf(os.Stderr, "opening db failed: %v\n", err) os.Exit(1) } depot, err := archive.NewDepot(cfg.Depot.Root, cfg.Depot.MaxSize, romDB) if err != nil { fmt.Fprintf(os.Stderr, "creating depot failed: %v\n", err) os.Exit(1) } rs := service.NewRombaService(romDB, depot, cfg) go signalCatcher(rs) s := rpc.NewServer() s.RegisterCodec(json2.NewCustomCodec(&rpc.CompressionSelector{}), "application/json") s.RegisterService(rs, "") http.Handle("/", http.StripPrefix("/", http.FileServer(http.Dir(cfg.General.WebDir)))) http.Handle("/jsonrpc/", s) http.Handle("/progress", websocket.Handler(rs.SendProgress)) fmt.Printf("starting romba server version %s at localhost:%d/romba.html\n", service.Version, cfg.Server.Port) log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", cfg.Server.Port), nil)) }
func ReadConfig(filename string) (ConfigFormat, error) { err := gcfg.ReadFileInto(&Config, filename) return Config, err }
func main() { flag.Parse() conf = new(config.Config) err := gcfg.ReadFileInto(conf, *cfgFile) if err != nil { panic(err) } bdb, err := bolt.Open(conf.Server.DataLocation, 0600, nil) if err != nil { panic(err) } defer bdb.Close() switch conf.Server.Format { case "xml": db = stow.NewXMLStore(bdb, []byte("duke-xml")) case "json": db = stow.NewJSONStore(bdb, []byte("duke-json")) case "gob": db = stow.NewStore(bdb, []byte("duke-gob")) default: panic("no set data store in " + *cfgFile) } db.Put([]byte("foo"), "bar") mux := http.NewServeMux() mux.HandleFunc("/lookup", func(rw http.ResponseWriter, r *http.Request) { if r.Method != "GET" { rw.WriteHeader(http.StatusNotAcceptable) fmt.Fprintf(rw, "Wrong method") return } user := r.URL.Query().Get("user") if len(user) == 0 { rw.WriteHeader(http.StatusNotAcceptable) fmt.Fprintf(rw, "Need user parameter") return } rw.WriteHeader(http.StatusOK) db.ForEach(func(key *duke.Key) { if key.Username == user { rw.Write([]byte(fmt.Sprintf("# for %s with fp %s\n", key.Username, key.Fingerprint))) rw.Write([]byte(key.String())) rw.Write([]byte("\n")) } }) }) mux.HandleFunc("/add", func(rw http.ResponseWriter, r *http.Request) { if r.Method != "POST" { rw.WriteHeader(http.StatusNotAcceptable) fmt.Fprintf(rw, "Wrong method") return } user := r.URL.Query().Get("user") if len(user) == 0 { rw.WriteHeader(http.StatusNotAcceptable) fmt.Fprintf(rw, "Need user parameter") return } body, err := ioutil.ReadAll(r.Body) if err != nil { panic(err) // should never happen } k := duke.NewKey(user, string(body)) err = db.Put([]byte(k.Fingerprint), k) if err != nil { panic(err) } rw.WriteHeader(http.StatusOK) }) mux.HandleFunc("/remove", func(rw http.ResponseWriter, r *http.Request) { if r.Method != "DELETE" { rw.WriteHeader(http.StatusNotAcceptable) fmt.Fprintf(rw, "Wrong method") return } fingerprint := r.URL.Query().Get("fingerprint") if len(fingerprint) == 0 { rw.WriteHeader(http.StatusNotAcceptable) fmt.Fprintf(rw, "Need fingerprint parameter") return } var k = new(duke.Key) err := db.Pull([]byte(fingerprint), k) if err != nil { panic(err) } rw.WriteHeader(http.StatusOK) fmt.Fprintf(rw, "Key with FP %s for user %s deleted.", k.Fingerprint, k.Username) }) n := negroni.Classic() n.UseHandler(mux) n.Run(conf.Server.Listen) }
// ParseConfig loads and parses a configuration file for Stevenbooru. func ParseConfig(fname string) (Config, error) { cfg := Config{} return cfg, gcfg.ReadFileInto(&cfg, fname) }