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)
}
