예제 #1
0
파일: setting.go 프로젝트: weisd/api
func initHosts() error {
	m := multiconfig.NewWithPath("conf/hosts.toml")
	err := m.Load(Cfg)
	if err != nil {
		return err
	}

	return nil
}
예제 #2
0
파일: setting.go 프로젝트: weisd/api
func newRedisService() {
	configPath := getUserConfigFile("redis.toml")

	m := multiconfig.NewWithPath(configPath)
	err := m.Load(Cfg)
	if err != nil {
		panic(err)
	}
}
예제 #3
0
파일: setting.go 프로젝트: weisd/api
func appConfig() {
	configPath := getUserConfigFile("app.toml")

	m := multiconfig.NewWithPath(configPath)
	err := m.Load(Cfg)
	if err != nil {
		panic(err)
	}
}
예제 #4
0
func main() {
	printVer := flag.Bool("version", false, "print version")
	config_path := flag.String("config", "config.toml", "配置文件路径")
	flag.String("addr", ":5050", "绑定地址")
	flag.Parse()

	if *printVer {
		fmt.Println("TcpRoute2 version", version)
		return
	}

	config_dir := filepath.Dir(*config_path)

	m := multiconfig.NewWithPath(*config_path)

	serverConfig := new(ServerConfig)
	m.MustLoad(serverConfig)

	if len(serverConfig.PreHttpPorts) == 0 && len(serverConfig.PreHttpsPorts) == 0 {
		log.Printf("未配置是否启用 客户端dns解析纠正功能,默认将在发现浏览器进行了dns本地解析时强制改为为代理服务器进行dns解析。")
		serverConfig.PreHttpPorts = []int{80}
		serverConfig.PreHttpsPorts = []int{443}
	}
	preHttpPorts = serverConfig.PreHttpPorts
	preHttpsPorts = serverConfig.PreHttpsPorts

	if err := netchan.HostsDns.Config(&netchan.DnschanHostsConfig{BashPath: config_dir,
		Hostss:        serverConfig.Hosts,
		CheckInterval: 1 * time.Minute,
	}); err != nil {
		panic(err)
	}

	// 创建 tcpping 上层代理
	upStream := NewTcppingUpStream()

	for _, up := range serverConfig.UpStreams {
		if up.Name == "" {
			up.Name = up.ProxyUrl
		}

		if err := upStream.AddUpStream(up.Name, up.ProxyUrl, up.DnsResolve, up.Credit, time.Duration(up.Sleep)*time.Millisecond, time.Duration(up.CorrectDelay)*time.Millisecond); err != nil {
			panic(err)
		}
	}

	// 服务器监听
	srv := NewServer(serverConfig.Addr, upStream)

	// TODO: DNS 配置

	// TODO: 各端口需要的安全级别

	srv.ListAndServe()
}
예제 #5
0
파일: setting.go 프로젝트: weisd/api
func newLogService() {
	f := "logs.toml"
	configPath := getUserConfigFile(f)

	m := multiconfig.NewWithPath(configPath)
	err := m.Load(Cfg)
	if err != nil {
		panic(err)
	}

	log.Info("k \n %v", Cfg.Logs)

}
예제 #6
0
func main() {
	m := multiconfig.NewWithPath("config.toml") // supports TOML and JSON

	// Get an empty struct for your configuration
	serverConf := new(Server)

	// Populated the serverConf struct
	m.MustLoad(serverConf) // Check for error

	fmt.Println("After Loading: ")
	fmt.Printf("%+v\n", serverConf)

	if serverConf.Enabled {
		fmt.Println("Enabled field is set to true")
	} else {
		fmt.Println("Enabled field is set to false")
	}
}
예제 #7
0
파일: main.go 프로젝트: amyangfei/redsnif
func initConfig(configFile string) error {
	m := multiconfig.NewWithPath(configFile)
	mcfg := new(MainConfig)
	m.MustLoad(mcfg)

	Config = &redsnif.SniffConfig{}
	Config.Device = mcfg.Network.Device
	Config.Snaplen = int32(mcfg.Network.Snaplen)
	Config.Timeout = time.Duration(time.Millisecond * time.Duration(mcfg.Network.Timeout))
	Config.Promiscuous = mcfg.Network.Promiscuous
	Config.UseZeroCopy = mcfg.Network.UseZeroCopy
	Config.Host = mcfg.Redis.Host
	Config.Port = mcfg.Redis.Port
	Config.MaxBufSize = mcfg.Redis.MaxBufSize
	Config.AzConfig = &redsnif.AnalyzeConfig{
		ReadHitAnalyze: mcfg.Analyze.ReadHitAnalyze,
		SaveCmdTypes:   mcfg.Analyze.SaveCmdTypes,
		SaveDetail:     mcfg.Analyze.SaveDetail,
	}

	return nil
}
예제 #8
0
파일: main.go 프로젝트: nadoo/reportd
func main() {
	m := multiconfig.NewWithPath("config.toml")
	err := m.Load(conf)
	if err != nil {
		log.Fatal(err)
	}

	if !conf.Debug {
		gin.SetMode(gin.ReleaseMode)
	}

	db, err := sqlx.Open(conf.DBType, conf.DBConn)
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()
	reportd := Reportd{db: db}

	router := gin.Default()
	router.LoadHTMLGlob("templates/*")
	router.GET("/", reportd.getIndex)
	router.GET("/json", reportd.getIndexJson)
	router.Run(conf.Listen)
}
예제 #9
0
파일: setting.go 프로젝트: hzmnet/api
func newLogService() {
	f := "logs.toml"
	configPath := getUserConfigFile(f)

	m := multiconfig.NewWithPath(configPath)
	err := m.Load(Cfg)
	if err != nil {
		panic(err)
	}

	for _, conf := range Cfg.Logs {
		if !conf.ENABLE {
			continue
		}
		level, ok := logLevels[conf.LEVEL]
		if !ok {
			log.Fatal(4, "Unknown log level: %s", conf.LEVEL)
		}

		str := ""
		switch conf.MODE {
		case "console":
			str = fmt.Sprintf(`{"level":%s}`, level)
		case "file":
			str = fmt.Sprintf(
				`{"level":%s,"filename":"%s","rotate":%v,"maxlines":%d,"maxsize":%d,"daily":%v,"maxdays":%d}`,
				level,
				conf.FILE_NAME,
				conf.LOG_ROTATE,
				conf.MAX_LINES,
				1<<uint(conf.MAX_SIZE_SHIFT),
				conf.DAILY_ROTATE, conf.MAX_DAYS,
			)
		case "conn":
			str = fmt.Sprintf(`{"level":%s,"reconnectOnMsg":%v,"reconnect":%v,"net":"%s","addr":"%s"}`, level,
				conf.RECONNECT_ON_MSG,
				conf.RECONNECT,
				conf.PROTOCOL,
				conf.ADDR)
		case "smtp":

			tos, err := json.Marshal(conf.RECEIVERS)
			if err != nil {
				log.Error(4, "json.Marshal(conf.RECEIVERS) err %v", err)
				continue
			}

			str = fmt.Sprintf(`{"level":%s,"username":"******","password":"******","host":"%s","sendTos":%s,"subject":"%s"}`, level,
				conf.USER,
				conf.PASSWD,
				conf.HOST,
				tos,
				conf.SUBJECT)
		case "database":
			str = fmt.Sprintf(`{"level":%s,"driver":"%s","conn":"%s"}`, level,
				conf.DRIVER,
				conf.CONN)
		default:
			continue
		}

		log.Info(str)
		log.NewLogger(conf.BUFFER_LEN, conf.MODE, str)
		log.Info("Log Mode: %s(%s)", conf.MODE, conf.LEVEL)
	}

}
예제 #10
0
//read config file
func readConfig() {
	m := multiconfig.NewWithPath("config.toml") // supports TOML and JSON
	// Populated the serverConf struct
	m.MustLoad(config) // Check for error
}
예제 #11
0
파일: main.go 프로젝트: dheminsgi/TcpRoute2
func main() {
	printVer := flag.Bool("version", false, "print version")
	config_path := flag.String("config", "config.toml", "配置文件路径")
	flag.String("addr", ":5050", "绑定地址")
	flag.Parse()

	if *printVer {
		fmt.Println("TcpRoute2 version", version)
		return
	}

	config_dir := filepath.Dir(*config_path)

	m := multiconfig.NewWithPath(*config_path)

	serverConfig := new(ServerConfig)
	m.MustLoad(serverConfig)

	if len(serverConfig.PreHttpPorts) == 0 && len(serverConfig.PreHttpsPorts) == 0 {
		log.Printf("未配置是否启用 客户端dns解析纠正功能,默认将在发现浏览器进行了dns本地解析时强制改为为代理服务器进行dns解析。")
		serverConfig.PreHttpPorts = []int{80}
		serverConfig.PreHttpsPorts = []int{443}
	}
	preHttpPorts = serverConfig.PreHttpPorts
	preHttpsPorts = serverConfig.PreHttpsPorts

	if err := netchan.HostsDns.Config(&netchan.DnschanHostsConfig{BashPath: config_dir,
		Hostss:        serverConfig.Hosts,
		CheckInterval: 1 * time.Minute,
	}); err != nil {
		log.Print(err)
		return
	}

	// 获得线路列表
	configDialClients := ConfigDialClients{
		UpStreams: serverConfig.UpStreams,
		BasePath:  config_dir,
	}

	dialClients, err := NewDialClients(&configDialClients)
	if err != nil {
		log.Print(err)
		return
	}

	// 创建 tcpping 上层代理
	upStream := NewTcppingUpStream(dialClients)

	// 服务器监听
	srv := NewServer(serverConfig.Addr, upStream)

	// TODO: DNS 配置

	// TODO: 各端口需要的安全级别

	if err := srv.ListAndServe(); err != nil {
		log.Print(err)
		return
	}
}
예제 #12
0
파일: main.go 프로젝트: pgpst/tunnel
func main() {
	// Load the configuration
	m := multiconfig.NewWithPath(os.Getenv("config"))
	cfg := &dns.Config{}
	m.MustLoad(cfg)

	// Parse the log level
	lvl, err := log.LvlFromString(cfg.LogLevel)
	if err != nil {
		panic(err)
	}

	// Create a new logger
	l := log.New()
	l.SetHandler(
		log.LvlFilterHandler(lvl, log.StdoutHandler),
	)

	// Start the initialization
	il := l.New("module", "init")
	il.Info("Starting up the application")

	// Parse the Redis connection string
	url := redisurl.Parse(cfg.Redis)

	// Create an options list
	opts := []redis.DialOption{}
	if url.Database != 0 {
		opts = append(opts, redis.DialDatabase(url.Database))
	}
	if url.Password != "" {
		opts = append(opts, redis.DialPassword(url.Password))
	}

	// Verify the DNS setup
	results, err := net.LookupNS(cfg.Domain)
	if err != nil {
		il.Warn("Unable to look up the NS of domain", "domain", cfg.Domain, "error", err.Error())
	}
	if len(results) > 0 {
		found := false
		for _, record := range results {
			if record.Host == cfg.Hostname {
				found = true
			}
		}
		if !found {
			existing := []string{}
			for _, record := range results {
				existing = append(existing, record.Host)
			}

			il.Warn("Invalid NS records for the domain", "domain", cfg.Domain, "records", existing)
		}
	} else {
		il.Warn("No NS records found for domain", "domain", cfg.Domain, "error", err.Error())
	}

	// Dial the server
	rc, err := redis.Dial("tcp", url.Host+":"+strconv.Itoa(url.Port), opts...)
	if err != nil {
		il.Crit("Unable to connect to the Redis server", "error", err.Error())
		return
	}

	// Initialize the DNS server
	ds := &dns.DNS{
		Config: cfg,
		Redis:  rc,
	}
	if err := ds.ListenAndServe(); err != nil {
		il.Crit("Error while listening to the specified port", "error", err.Error())
	}
}