func init() {
flag.Parse()
c, err := goconfig.ReadConfigFile("config")
if err != nil {
glog.Warningf("init(): readconfigfile(config)")
oauthCfg.ClientSecret = "a"
oauthCfg.ClientId = "b"
MyURL = "c"
oauthCfg.RedirectURL = "d"
return
}
oauthCfg.ClientId, err = c.GetString("Google", "ClientId")
if err != nil {
glog.Fatal("init(): readconfigfile(Google.ClientId), using dummy")
}
oauthCfg.ClientSecret, err = c.GetString("Google", "ClientSecret")
if err != nil {
glog.Fatal("init(): readconfigfile(Google.ClientSecret)")
}
url, err := c.GetString("Web", "url")
MyURL = url
if err != nil {
glog.Fatal("init(): readconfigfile(Web.url)")
}
oauthCfg.RedirectURL = url + "/oauth2callback"
}
func (conf *Config) ReadConf(file string) (*Config, error) {
if file == "" {
file = filepath.Join(DEFAULT_CONF_PATH, DEFAULT_CONF)
}
c, err := goconf.ReadConfigFile(file)
if err != nil {
return nil, err
}
//TODO: check
conf.log, _ = c.GetString("default", "log")
conf.level, _ = c.GetString("default", "level")
conf.topic, _ = c.GetString("default", "topic")
conf.kaddr, _ = c.GetString("default", "kafka_addr")
conf.sport, _ = c.GetString("default", "ssh_port")
conf.suser, _ = c.GetString("default", "ssh_user")
conf.skey, _ = c.GetString("default", "ssh_key")
conf.sto, err = c.GetInt64("default", "ssh_timeout")
if err != nil {
conf.sto = DEFAULT_SSH_TIMEOUT
}
conf.daemon, _ = c.GetBool("default", "daemon")
return conf, nil
}
func init() {
var err error
flag.Parse()
c, err := goconfig.ReadConfigFile("../config")
db_name, err := c.GetString("DB", "db")
if err != nil {
glog.Fatalf("init(): config.GetString(DB.db): %s", err)
}
db_host, err := c.GetString("DB", "host")
if err != nil {
glog.Fatalf("init(): config.GetString(DB.Host): %s", err)
}
db_user, err := c.GetString("DB", "user")
if err != nil {
glog.Fatalf("init(): config.GetString(DB.user): %s", err)
}
db_pass, err := c.GetString("DB", "pass")
if err != nil {
glog.Fatalf("init(): config.GetString(DB.pass): %s", err)
}
db, err = sql.Open("mysql", db_user+":"+db_pass+"@tcp("+db_host+")/"+db_name)
if err != nil {
glog.Fatalf("Init():sql.Open(mysql, %s:%s@%s/%s: %s", db_user, db_pass, db_host, db_name, err)
}
ebay_application_id, err = c.GetString("Ebay", "ApplicationID")
if err != nil {
glog.Fatalf("init():Config.GetString(Ebay,ApplicationID): %s", err)
}
eb = ebay.New(ebay_application_id)
ebay_url, err := c.GetString("Ebay", "URL")
if err == nil {
eb.URL = ebay_url
}
}
func init() {
var err error
flag.Parse()
c, err := goconfig.ReadConfigFile("config")
if port, err = c.GetString("Web", "port"); err != nil {
glog.Fatalf("init(): config.GetString(web.portal): %s", err)
}
if environment, err = c.GetString("Web", "environment"); err != nil {
glog.Fatalf("init(): config.GetString(Web.environment): %s", err)
}
db_name, err := c.GetString("DB", "db")
if err != nil {
glog.Fatalf("init(): config.GetString(DB.db): %s", err)
}
db_host, err := c.GetString("DB", "host")
if err != nil {
glog.Fatalf("init(): config.GetString(DB.Host): %s", err)
}
db_user, err := c.GetString("DB", "user")
if err != nil {
glog.Fatalf("init(): config.GetString(DB.user): %s", err)
}
db_pass, err := c.GetString("DB", "pass")
if err != nil {
glog.Fatalf("init(): config.GetString(DB.pass): %s", err)
}
db, err = sql.Open("mysql", db_user+":"+db_pass+"@tcp("+db_host+")/"+db_name)
if err != nil {
glog.Fatalf("Init():sql.Open(mysql, %s:%s@%s/%s: %s", db_user, db_pass, db_host, db_name, err)
}
cookieName = "gameslist_auth_" + environment
auth.Config("config")
auth.CookieName(cookieName)
auth.Environment(environment)
}
func ReadOptions(fpath string) {
c, err := goconfig.ReadConfigFile(fpath)
if err != nil {
panic("Could not read config.cfg at " + fpath)
}
UseRadians, err = c.GetBool("math", "UseRadians")
if err != nil {
panic("Bad config statement UseRadians")
}
SigFigs, err = c.GetInt64("math", "SignificantFigures")
if err != nil {
panic("Bad config statement SignificantFigures")
}
UseColoredOutput, err = c.GetBool("latex", "UseColoredOutput")
if err != nil {
panic("Bad config statement UseColoredOutput")
}
OutputColor, err = c.GetString("latex", "OutputColor")
if err != nil {
panic("Bad config statement OutputColor")
}
OrSymbol, err = c.GetString("latex", "OrSymbol")
if err != nil {
panic("Bad config statement OrSymbol")
}
DefinitionSymbol, err = c.GetString("latex", "DefinitionSymbol")
if err != nil {
panic("Bad config statement DefinitionSymbol")
}
}
func NewFromConfigFile(file string, client bool) Mgollective {
conf, err := goconfig.ReadConfigFile(file)
if err != nil {
log.Fatal("Couldn't open config ", err)
}
mgo := Mgollective{
logger: seelog.Disabled,
client: client,
config: *conf,
}
connectorname := mgo.GetStringDefault("connector", "class", "redis")
if factory, exists := connectorRegistry[connectorname]; exists {
mgo.Connector = factory(&mgo)
} else {
fmt.Printf("No connector called %s", connectorname)
panic("panic")
}
mgo.Connector.Connect()
mgo.Connector.Subscribe()
return mgo
}
func init() {
var err error
c, err := goconfig.ReadConfigFile("config")
if err != nil {
err.Error()
}
db_name, err = c.GetString("DB", "db")
if err != nil {
err.Error()
}
db_host, err = c.GetString("DB", "host")
if err != nil {
err.Error()
}
db_user, err = c.GetString("DB", "user")
if err != nil {
err.Error()
}
db_pass, err = c.GetString("DB", "pass")
if err != nil {
err.Error()
}
db, err = sql.Open("mysql", db_user+":"+db_pass+"@"+db_host+"/"+db_name)
if err != nil {
panic(err)
}
}
func Config(config string) {
c, err := goconfig.ReadConfigFile(config)
googleEnabled = true
facebookEnabled = true
if err != nil {
glog.Fatalf("init(): readconfigfile(config)")
}
GoogOauthCfg.ClientID, err = c.GetString("Google", "ClientID")
if err != nil {
googleEnabled = false
glog.Errorf("init(): readconfigfile(Google.ClientID)")
}
GoogOauthCfg.ClientSecret, err = c.GetString("Google", "ClientSecret")
if err != nil {
googleEnabled = false
glog.Errorf("init(): readconfigfile(Google.ClientSecret)")
}
FBOauthCfg.ClientID, err = c.GetString("Facebook", "ClientID")
if err != nil {
facebookEnabled = false
glog.Errorf("init(): readconfigfile(Facebook.ClientID)")
}
FBOauthCfg.ClientSecret, err = c.GetString("Facebook", "ClientSecret")
if err != nil {
facebookEnabled = false
glog.Errorf("init(): readconfigfile(Facebook.ClientSecret)")
}
url, err := c.GetString("Web", "url")
MyURL = url
if err != nil {
glog.Fatalf("init(): readconfigfile(Web.url)")
}
GoogOauthCfg.RedirectURL = url + "oauth2callback"
FBOauthCfg.RedirectURL = url + "fboauth2callback"
}
func new_address_matcher() *address_matcher {
// honor NOTMUCH_CONFIG
home := os.Getenv("NOTMUCH_CONFIG")
if home == "" {
home = os.Getenv("HOME")
}
cfg, err := goconfig.ReadConfigFile(path.Join(home, ".notmuch-config"))
if err != nil {
log.Fatalf("error loading config file:", err)
}
db_path, _ := cfg.GetString("database", "path")
primary_email, _ := cfg.GetString("user", "primary_email")
addrbook_tag, err := cfg.GetString("user", "addrbook_tag")
if err != nil {
addrbook_tag = "addressbook"
}
self := &address_matcher{db: nil,
user_db_path: db_path,
user_primary_email: primary_email,
user_addrbook_tag: addrbook_tag}
return self
}
func initGame() {
g, err := goconfig.ReadConfigFile("test_config")
db_name, err := g.GetString("DB", "db")
if err != nil {
err.Error()
fmt.Println(err)
}
db_host, err := g.GetString("DB", "host")
if err != nil {
err.Error()
fmt.Println(err)
}
db_user, err := g.GetString("DB", "user")
if err != nil {
err.Error()
fmt.Println(err)
}
db_pass, err := g.GetString("DB", "pass")
if err != nil {
err.Error()
fmt.Println(err)
}
db, err = sql.Open("mysql", db_user+":"+db_pass+"@tcp("+db_host+")/"+db_name)
if err != nil {
panic(err)
}
out, err := exec.Command("sh", "create_tables.sh").Output()
if err != nil {
glog.Errorf("sh create_tables.sh %s\n%s", err, out)
return
}
ConsoleDB(db)
GameDB(db)
}
func parseConfig() {
VERSION = "0.1.0.beta.5"
c, _ := goconfig.ReadConfigFile("config.ini")
nats_uri, _ = c.GetString("statistics", "nats_uri")
logname, _ := c.GetString("logging", "file")
logfile, err := os.OpenFile(logname, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0660)
if err != nil {
fmt.Printf("%s\r\n", err.Error())
}
logger = log.New(logfile, "\r", log.Ldate|log.Ltime)
//debug config
debug, _ := c.GetBool("debug", "enable")
node, _ := c.GetString("debug", "debug_node")
debug_node = node
fmt.Println(debug_node)
//puller config
ft, _ := c.GetInt64("puller", "fetch_interval")
fetch_interv = time.Duration(ft)
varz_user, _ := c.GetString("puller", "varz_user")
varz_pswd, _ := c.GetString("puller", "varz_pswd")
varz_api, _ := c.GetString("puller", "varz_api")
varz_port, _ := c.GetInt64("puller", "varz_port")
node_addr, _ = localIP(debug)
varz_uri = fmt.Sprintf("http://%s:%s@%s:%d/%s", varz_user,
varz_pswd, node_addr, varz_port, varz_api)
//sender config
nt, _ := c.GetInt64("sender", "node_data_interval")
ut, _ := c.GetInt64("sender", "instance_data_interval")
isd, _ := c.GetInt64("sender", "instance_data_delay")
collector_send_interv = time.Duration(ut)
node_interv = time.Duration(nt)
instance_data_delay = time.Duration(isd)
//checker config
it, _ := c.GetInt64("checker", "instance_interval")
ic, _ := c.GetInt64("checker", "instance_check_delay")
instance_check_interv = time.Duration(it)
instance_check_delay = time.Duration(ic)
//collector config
col_addr, _ := c.GetString("collector", "address")
base_full_data_api, _ := c.GetString("collector", "full_data_api")
base_incre_data_api, _ := c.GetString("collector", "incre_data_api")
base_node_data_api, _ := c.GetString("collector", "node_data_api")
base_ins_check_api, _ := c.GetString("collector", "ins_check_api")
ctm, _ := c.GetInt64("collector", "conn_timeout")
rwtm, _ := c.GetInt64("collector", "rw_timeout")
full_data_api = col_addr + base_full_data_api
incre_data_api = col_addr + base_incre_data_api
node_data_api = col_addr + base_node_data_api
ins_check_api = col_addr + base_ins_check_api
conn_timeout = time.Duration(ctm)
rw_timeout = time.Duration(rwtm)
}
func getConfig() *goconfig.ConfigFile {
confFile := filepath.Join(assetDir(), "gits3.ini")
conf, err := goconfig.ReadConfigFile(confFile)
if err != nil {
log.Fatal(err)
}
return conf
}
func initPool() {
configs, err := goconfig.ReadConfigFile(configFileName)
if err != nil {
logger.Criticalf("Can not read nsq configs from %s. Error: %s", configFileName, err)
panic(err)
}
options, err := configs.GetOptions(nsqdConfigSection)
if err != nil {
logger.Criticalf("Can not read nsqd config in %s. Error: $s", configFileName, err)
panic(err)
}
addrs := make([]string, 0, len(options))
for _, option := range options {
value, err := configs.GetString(nsqdConfigSection, option)
if err != nil {
logger.Errorf("Get error when reading section %s option %s in %s. Error: %s", nsqdConfigSection, option, configFileName, err)
continue
}
addrs = append(addrs, value)
}
if len(addrs) <= 0 {
logger.Criticalf("Read 0 configs for nsqd address in %s.", configFileName)
panic("Read 0 configs for nsqd address in config file " + configFileName)
}
pool = make(map[string]*gonsq.Producer)
lostConns = make([]string, 0)
for _, addr := range addrs {
config := gonsq.NewConfig()
producer, err := gonsq.NewProducer(addr, config)
if err != nil {
logger.Errorf("Can not create nsq producer for address: %s. Error: %s", addr, err)
continue
}
err = producer.Ping()
if err != nil {
logger.Errorf("Can not connect to address %s. Error: %s", addr, err)
lostConns = append(lostConns, addr)
}
pool[addr] = producer
}
go autoReconnect()
}
func ParseConfig() APPLICATION_MODE {
var aws_config_file string
var base_config_file string
var register bool
var send bool
var input_file string
var output_file string
var message_file string
flag.StringVar(&base_config_file, "baseConfig", "./config/base.conf", "The path to the base configuration file")
flag.StringVar(&aws_config_file, "awsConfig", "./config/aws.conf", "The path to the aws configuration file")
flag.BoolVar(®ister, "register", false, "Set flag to run in client mode and register a set of devices. If true inputFile and outputFile must be set.")
flag.BoolVar(&send, "send", false, "Set flag to run in client mode and send push notifications to a set of arns. If true inputFile and outputFile must be set.")
flag.StringVar(&input_file, "inputFile", "", "The path to the Device IDs or Arns file")
flag.StringVar(&output_file, "outputFile", "", "The path to the Device IDs or Arns file")
flag.StringVar(&message_file, "messageFile", "", "The path to the file containing the notificaito message to be sent out")
flag.Parse()
log.Printf("Using base configuration file: %s", base_config_file)
baseConfig, err := goconfig.ReadConfigFile(base_config_file)
checkError("Unable to parse base config", err)
log.Printf("Using aws configuration file: %s", aws_config_file)
awsConfig, err := goconfig.ReadConfigFile(aws_config_file)
checkError("Unable to parse AWS config", err)
parseBaseConfig(baseConfig)
parseAwsConfig(awsConfig)
if register {
log.Printf("Running in client mode, registering devices listed in %s, and printing arns in %s", input_file, output_file)
return REGISTER_MODE
} else if send {
log.Printf("Running in client mode, sending pusn notes to ARNs listed in %s, and printing results in %s", input_file, output_file)
return SEND_MODE
} else {
log.Printf("Running in server mode")
return SERVER_MODE
}
}
func ConfigFile() {
c, err := goconfig.ReadConfigFile("config.cfg")
if err != nil {
fmt.Println(err)
}
RedisAddress, _ = c.GetString("Redis", "RedisAddress")
RedisPort, _ = c.GetString("Redis", "RedisPort")
ESAPI, _ = c.GetString("ES", "API")
//fmt.Println(RedisAddress + ":" + RedisPort + ":" + ESAPI)
}
func main() {
c, err := goconfig.ReadConfigFile("config.cfg")
if err != nil {
fmt.Println("err")
}
// result is string :http://www.example.com/some/path"
str, _ := c.GetString("service-1", "url")
i, _ := c.GetInt64("service-1", "maxclients") // result is int 200
b, _ := c.GetBool("service-1", "delegation") // result is bool true
fmt.Println(str, i, b)
}
func initTest(t *testing.T) {
c, err := goconfig.ReadConfigFile("config")
db_name, err := c.GetString("DB", "db")
if err != nil {
err.Error()
fmt.Println(err)
}
db_host, err := c.GetString("DB", "host")
if err != nil {
err.Error()
fmt.Println(err)
}
db_user, err := c.GetString("DB", "user")
if err != nil {
err.Error()
fmt.Println(err)
}
db_pass, err := c.GetString("DB", "pass")
if err != nil {
err.Error()
fmt.Println(err)
}
db, err = sql.Open("mysql", db_user+":"+db_pass+"@"+db_host+"/"+db_name)
if err != nil {
panic(err)
}
_, err = db.Query("Drop table if exists users;")
ec(t, "drop table things", err)
_, err = db.Query("Drop table if exists sessions;")
ec(t, "drop table sessions", err)
DB(db)
userDB()
_, err = AddUser("a")
_, err = AddUser("1")
_, err = AddUser("2")
_, err = AddUser("3")
_, err = AddUser("4")
_, err = AddUser("5")
_, err = AddUser("6")
_, err = AddUser("7")
_, err = AddUser("8")
_, err = AddUser("9")
_, err = AddUser("0")
_, err = AddUser(te)
u, err := GetUserByEmail(te)
if err := u.AddSession(sid); err != nil {
t.Errorf("user.AddSession(%s): %s", sid, err)
}
}
func main() {
config, configError := goconfig.ReadConfigFile("spot-ec2-proxifier.ini")
if configError != nil {
fmt.Println(configError)
return
}
// Setup our AWS credentials
ak, _ := config.GetString("IAM", "access")
sk, _ := config.GetString("IAM", "secret")
rn, _ := config.GetString("EC2", "region")
e, err := setupEC2(ak, sk, rn)
if err != nil {
fmt.Println("Something wrong in EC2 config:", err)
return
}
// Get all current running instances
rep, err := e.Instances(nil, nil)
if err != nil {
fmt.Println("Couldn't list instances", err)
return
}
// Find whether any are ours
tag, _ := config.GetString("EC2", "tag")
inst, found := findTaggedInstance(rep.Reservations, tag)
if found {
fmt.Println("Found tagged instance:", inst.DNSName)
// Launch plink on that instance
bindPort, _ := config.GetInt64("Proxy", "bind_port")
keyPath, _ := config.GetString("Proxy", "key_file")
username, _ := config.GetString("EC2", "username")
if username == "" {
username = "******"
}
connectPlink(username, inst.DNSName, keyPath, int(bindPort))
} else {
fmt.Println("No instance up, creating a new one")
}
}
func initConsumer() {
configs, err := goconfig.ReadConfigFile(configFileName)
if err != nil {
logger.Criticalf("Can not read nsqlookup config from %s. Error: %s", configFileName, err)
panic(err)
}
options, err := configs.GetOptions(nsqlookupSection)
if err != nil {
logger.Criticalf("Can not find configs for nsqlookup in %s. Error: %s", configFileName, err)
panic(err)
}
}
func GetConfig(path string) *goconfig.ConfigFile {
if Config != nil {
return Config
}
if path == "" {
path = "gobb.conf"
}
var err error
Config, err = goconfig.ReadConfigFile(path)
if err != nil {
log.Fatalln("Could not read config file", err)
}
return Config
}
func main() {
flag.Parse()
var err error
var conn broker.Connection
config_file := os.Getenv("GOGIX_CONF")
if strings.TrimSpace(config_file) == "" {
config_file = "/etc/gogix/gogix.conf"
}
Cfg, err = goconfig.ReadConfigFile(config_file)
utils.CheckPanic(err, "File not found")
bind_addr, err := Cfg.GetString("server", "bind_addr")
utils.CheckPanic(err, "Unable to get bind_addr from gogix.conf")
conn.Queue, err = Cfg.GetString("transport", "queue")
utils.CheckPanic(err, "Unable to get queue from gogix.conf")
conn.Uri, err = Cfg.GetString("transport", "uri")
utils.CheckPanic(err, "Unable to get transport from gogix.conf")
conn.Expiration, err = Cfg.GetString("transport", "message_ttl")
utils.CheckPanic(err, "Unable to get message_ttl from gogix.conf")
addr, err := net.ResolveUDPAddr("udp", bind_addr)
utils.CheckPanic(err, "Unable to resolve bind address")
l, err := net.ListenUDP("udp", addr)
utils.CheckPanic(err, fmt.Sprintf("Unable to bind %s", addr))
if *debug == true {
fmt.Printf("Setting-Up Broker %s\n", conn.Uri)
}
conn.SetupBroker()
go conn.ReconnectOnClose()
for {
recv := make([]byte, 1024)
_, remote_addr, err := l.ReadFromUDP(recv)
utils.Check(err, "Problem receiving data")
fmt.Println(recv)
if err == nil {
ip := fmt.Sprintf("%s", remote_addr.IP)
go handle_data(string(recv), conn, ip)
}
}
conn.Close()
}
func (c *ConfigConf) parseFile(filename string) {
config, err := goconfig.ReadConfigFile(filename)
if err != nil {
fmt.Println(err)
log.Fatal(err.Error())
} else {
username, _ := config.GetString("default", "Username")
password, _ := config.GetString("default", "Password")
smtp, _ := config.GetString("default", "Smtphost")
c.EmailCfg.SetUsername(username)
c.EmailCfg.SetPassword(password)
c.EmailCfg.SetSmtp(smtp)
fmt.Println(username)
}
}
func init() {
var err error
flag.Parse()
c, err := goconfig.ReadConfigFile("config")
if err != nil {
err.Error()
}
port, err = c.GetString("Web", "port")
if err != nil {
err.Error()
}
environment, err = c.GetString("Web", "environment")
if err != nil {
err.Error()
}
cookieName = "feedinator_auth_" + environment
mc.Prefix = (environment)
db_name, err := c.GetString("DB", "db")
if err != nil {
glog.Fatalf("Config: %s", err)
}
db_host, err := c.GetString("DB", "host")
if err != nil {
glog.Fatalf("Config: %s", err)
}
db_user, err := c.GetString("DB", "user")
if err != nil {
glog.Fatalf("Config: %s", err)
}
db_pass, err := c.GetString("DB", "pass")
if err != nil {
glog.Fatalf("Config: %s", err)
}
db, err = sql.Open("mysql", db_user+":"+db_pass+"@tcp("+db_host+")/"+db_name)
if err != nil {
glog.Fatalf("Config: %s", err)
}
feed.Categoryinit(db, &mc)
feed.Feedinit()
feed.Entryinit()
auth.DB(db)
}
func (conf *Config) ReadConf(file string) (*Config, error) {
if file == "" {
file = filepath.Join(DEFAULT_CONF_PATH, DEFAULT_CONF)
}
c, err := goconf.ReadConfigFile(file)
if err != nil {
return nil, err
}
//TODO: check
conf.log, _ = c.GetString("default", "log")
conf.level, _ = c.GetString("default", "level")
//conf.timeout, _ = c.GetInt64("default", "timeout")
//conf.timeout = time.Duration(timeout) * time.Millisecond
conf.lport, _ = c.GetString("default", "listen_port")
conf.kaddr, _ = c.GetString("default", "kafka_addr")
return conf, nil
}
func init() {
var err error
flag.IntVar(&feed_id, "feed_id", 0, "Feed Id to update")
flag.IntVar(&feed_id, "f", 0, "Feed Id to update")
flag.StringVar(&config_file, "config", "../config", "Config file")
flag.StringVar(&config_file, "c", "../config", "Config file")
c, err := goconfig.ReadConfigFile(config_file)
if err != nil {
glog.Fatalf("Couldn't parse config file %s: %s", config_file, err)
}
environment, err = c.GetString("Web", "environment")
if err != nil {
glog.Fatalf("Config: %s", err)
}
db_name, err := c.GetString("DB", "db")
if err != nil {
glog.Fatalf("Config: %s", err)
}
db_host, err := c.GetString("DB", "host")
if err != nil {
glog.Fatalf("Config: %s", err)
}
db_user, err := c.GetString("DB", "user")
if err != nil {
glog.Fatalf("Config: %s", err)
}
db_pass, err := c.GetString("DB", "pass")
if err != nil {
glog.Fatalf("Config: %s", err)
}
db, err = sql.Open("mysql", db_user+":"+db_pass+"@tcp("+db_host+")/"+db_name)
if err != nil {
glog.Fatalf("Config: %s", err)
}
feed.Categoryinit(db, &mc)
feed.Feedinit()
feed.Entryinit()
mc.Prefix = (environment)
}
func init() {
//初始化配置
var configError error
config, configError = goconfig.ReadConfigFile("conf.ini")
if configError != nil {
log.Panic("can not read the config file")
}
//初始化主机名
var errHost error
hostname, errHost = os.Hostname()
if errHost != nil {
log.Fatal("Hostname can not obtain!")
}
AppCommUnitInit()
//端口
Port, _ = config.GetString("server", "port")
//初始化指令接收者
configConsumer := nsq.NewConfig()
consumerTopic, _ := config.GetString("message", "consumerTopic")
log.Println("aaaaaaa")
log.Println(consumerTopic)
q, _ = nsq.NewConsumer(consumerTopic, "ch", configConsumer)
//初始化指令发送者
configProducer := nsq.NewConfig()
nsq_url, _ := config.GetString("message", "nsq_url")
w, _ = nsq.NewProducer(nsq_url, configProducer)
delay, _ = config.GetInt64("message", "delay_time")
//指令回复处理handler
Receive(cs)
}
func GetEmailCfg(filename string) EmailCfg {
var cfg EmailCfg
config, err := goconfig.ReadConfigFile(filename)
if err != nil {
fmt.Println(err)
log.Fatal(err.Error())
} else {
username, _ := config.GetString("default", "Username")
password, _ := config.GetString("default", "Password")
smtp, _ := config.GetString("default", "Smtphost")
cfg.SetUsername(username)
cfg.SetPassword(password)
cfg.SetSmtp(smtp)
//fmt.Println(username, password, smtp)
}
return cfg
}
func main() {
var bytes int64
var bytesDone int64
flag.Parse()
debug = *debug_flag
log.Printf("loading config file from %s\n", *configFile)
configF, err := goconfig.ReadConfigFile(*configFile)
if err != nil {
log.Fatalf("ERROR: %s", err)
}
pool_config, err := configF.GetInt64("Client", "threads")
if err != nil {
log.Fatalf("ERROR: %s", err)
}
if *pool_flag != 0 {
pool = *pool_flag
} else {
pool = int(pool_config)
}
runtime.GOMAXPROCS(pool)
dirList, err := configF.GetString("Client", "backup_dirs_secure")
if err != nil {
log.Fatalf("ERROR: %s", err)
}
excludeList, err := configF.GetString("Client", "exclude_dirs")
if err != nil {
log.Fatalf("ERROR: %s", err)
}
dataBaseName, err := configF.GetString("Client", "sql_file")
if err != nil {
log.Fatalf("ERROR: %s", err)
}
queueBlobDir, err := configF.GetString("Client", "queue_blobs")
if err != nil {
log.Fatalf("ERROR: %s", err)
} else {
os.Mkdir(queueBlobDir+"/tmp", 0700)
os.Mkdir(queueBlobDir+"/blob", 0700)
}
db, err := bdrsql.Init_db(dataBaseName, *newDB, debug)
if err != nil {
log.Printf("could not open %s, error: %s", dataBaseName, err)
} else {
log.Printf("opened database %v\n", dataBaseName)
}
err = bdrsql.CreateClientTables(db)
if err != nil && debug == true {
log.Printf("couldn't create tables: %s", err)
} else {
log.Printf("created tables\n")
}
log.Printf("backing up these directories: %s\n", dirList)
log.Printf("start walking...")
t0 := time.Now()
err = backupDir(db, dirList, excludeList, dataBaseName)
t1 := time.Now()
duration := t1.Sub(t0)
if err != nil {
log.Printf("walking didn't finished successfully. Error: %s", err)
} else {
log.Printf("walking successfully finished")
}
log.Printf("walking took: %v\n", duration)
// shutdown database, make a copy, open it, backup copy of db
// db, _ = bdrsql.BackupDB(db,dataBaseName)
// launch server to receive uploads
tn0 := time.Now().UnixNano()
for i := 0; i < pool; i++ {
go bdrupload.Uploader(upchan, done, debug, queueBlobDir)
}
log.Printf("started %d uploaders\n", pool)
// send all files to be uploaded to server.
log.Printf("started sending files to uploaders...\n")
bdrsql.SQLUpload(db, upchan)
bytesDone = 0
bytes = 0
for i := 0; i < pool; i++ {
bytes = <-done
bytesDone += bytes
}
tn1 := time.Now().UnixNano()
if debug == true {
seconds := float64(tn1-tn0) / 1000000000
log.Printf("%d threads %s %s/sec in %4.2f seconds\n", pool, ByteSize(float64(bytesDone)), ByteSize(float64(bytesDone)/seconds), seconds)
}
log.Printf("uploading successfully finished\n")
}
func init() {
TaskBoardService = new(TaskBoardServiceImpl)
c, err := goconfig.ReadConfigFile("taskboard.ini")
if err != nil {
panic(err)
}
/*
* =======
* WEB
* =======
*/
ContentDir, _ = c.GetString("web", "dir")
ContentDir = replaceOsEnv(ContentDir)
fmt.Println("[web]dir=", ContentDir)
IpPort, _ = c.GetString("web", "ip_port")
IpPort = replaceOsEnv(IpPort)
fmt.Println("[web]ip_port=", IpPort)
HttpsOnly, _ = c.GetBool("web", "https_only")
fmt.Println("[web]https_only=", HttpsOnly)
postLimit, _ = c.GetInt64("web", "post_limit")
fmt.Println("[web]post_limit=", postLimit)
/*
* =======
* LOG
* =======
*/
//// log configuration - its the same the default
level, _ := c.GetString("log", "level")
level = replaceOsEnv(level)
fmt.Println("[log]level=", level)
file, _ := c.GetString("log", "file")
file = replaceOsEnv(file)
fmt.Println("[log]file=", file)
count, _ := c.GetInt64("log", "count")
fmt.Println("[log]count=", count)
size, _ := c.GetInt64("log", "size")
fmt.Println("[log]size=", size)
logToConsole, _ := c.GetBool("log", "console")
fmt.Println("[log]console=", logToConsole)
logLevel := log.ParseLevel(level, log.ERROR)
if logLevel <= log.INFO {
log.ShowCaller(true)
}
// setting root writers
writers := make([]log.LogWriter, 0)
writers = append(writers, log.NewRollingFileAppender(file, size, int(count), true))
if logToConsole {
writers = append(writers, log.NewConsoleAppender(false))
}
log.Register("/", logLevel, writers...)
//log.Register("/", logLevel, log.NewRollingFileAppender(file, size, int(count), true))
//master.SetLevel("pqp", log.LogLevel(level))
logger = log.LoggerFor("taskboad/biz/impl")
// smtp
SmtpHost, _ = c.GetString("smtp", "host")
SmtpHost = replaceOsEnv(SmtpHost)
fmt.Println("[smtp]host=", SmtpHost)
SmtpPort, _ = c.GetString("smtp", "port")
SmtpPort = replaceOsEnv(SmtpPort)
fmt.Println("[smtp]port=", SmtpPort)
SmtpUser, _ = c.GetString("smtp", "user")
SmtpUser = replaceOsEnv(SmtpUser)
fmt.Println("[smtp]user="******"smtp", "pass")
SmtpPass = replaceOsEnv(SmtpPass)
SmtpFrom, _ = c.GetString("smtp", "from")
SmtpFrom = replaceOsEnv(SmtpFrom)
fmt.Println("[smtp]from=", SmtpFrom)
/*
* =======================
* BEGIN DATABASE CONFIG
* =======================
*/
// database configuration
driverName, _ := c.GetString("database", "driver_name")
driverName = replaceOsEnv(driverName)
fmt.Println("[database]driver_name=", driverName)
dataSourceName, _ := c.GetString("database", "data_source_name")
dataSourceName = replaceOsEnv(dataSourceName)
fmt.Println("[database]data_source_name=", dataSourceName)
statementCache, _ := c.GetInt64("database", "statement_cache")
fmt.Println("[database]statement_cache=", statementCache)
idle, _ := c.GetInt64("database", "idle_connections")
fmt.Println("[database]idle_connections=", idle)
appDB, err := sql.Open(driverName, dataSourceName)
if err != nil {
panic(err)
}
if idle > 0 {
appDB.SetMaxIdleConns(int(idle))
}
// wake up the database pool
err = appDB.Ping()
if err != nil {
panic(err)
}
var translator = trx.NewMySQL5Translator()
TM = db.NewTransactionManager(
// database
appDB,
// databse context factory - called for each transaction
func(inTx *bool, c dbx.IConnection) db.IDb {
return db.NewDb(inTx, c, translator)
},
// statement cache
int(statementCache),
)
/*
* =======================
* END DATABASE CONFIG
* =======================
*/
Poll = poller.NewPoller(30 * time.Second)
}
package util
import (
"database/sql"
"fmt"
"github.com/hoisie/mustache"
_ "github.com/jbarham/gopgsqldriver"
"github.com/msbranco/goconfig"
)
var Config, _ = goconfig.ReadConfigFile("goblog.conf")
var db *sql.DB
type Entry struct {
Id int
Title, Content string
}
func GetDb() *sql.DB {
if db != nil {
return db
}
db_username, _ := Config.GetString("db", "username")
db_password, _ := Config.GetString("db", "password")
db_database, _ := Config.GetString("db", "database")
db_hostname, _ := Config.GetString("db", "hostname")
db_port, _ := Config.GetString("db", "port")
db, err := sql.Open("postgres", "user="******" password="******" dbname="+db_database+" host="+db_hostname+" port="+db_port)