// openDB opens and returns the IP database file or URL.
func openDB(c *Config) (*freegeoip.DB, error) {
u, err := url.Parse(c.DB)
if err != nil || len(u.Scheme) == 0 {
return freegeoip.Open(c.DB)
}
return freegeoip.OpenURL(c.DB, c.UpdateInterval, c.RetryInterval)
}
func TestHandler(t *testing.T) {
db, err := freegeoip.Open("../testdata/db.gz")
if err != nil {
t.Fatal(err)
}
defer db.Close()
s := httptest.NewServer(newTestHandler(db))
defer s.Close()
// query some known location...
resp, err := http.Get(s.URL + "/api/json/200.1.2.3")
if err != nil {
t.Fatal(err)
}
defer resp.Body.Close()
switch resp.StatusCode {
case http.StatusOK:
case http.StatusServiceUnavailable:
t.Skip("Redis available?")
default:
t.Fatal(resp.Status)
}
m := struct {
Country string `json:"country_name"`
City string `json:"city"`
}{}
if err = json.NewDecoder(resp.Body).Decode(&m); err != nil {
t.Fatal(err)
}
if m.Country != "Venezuela" && m.City != "Caracas" {
t.Fatalf("Query data does not match: want Caracas,Venezuela, have %q,%q",
m.City, m.Country)
}
}
// openDB opens and returns the IP database.
func openDB(dsn string, updateIntvl, maxRetryIntvl time.Duration) (db *freegeoip.DB, err error) {
u, err := url.Parse(dsn)
if err != nil || len(u.Scheme) == 0 {
db, err = freegeoip.Open(dsn)
} else {
db, err = freegeoip.OpenURL(dsn, updateIntvl, maxRetryIntvl)
}
return
}
func New(geoDataPath string) DB {
geoDb, err := freegeoip.Open(geoDataPath)
if err != nil {
log.Fatal.Pf("Can't read geo data file: %v", err)
panic(err)
}
return &db{geoDb}
}
// NewHub returns a pointer to a initialized and running Hub
func NewHub() *Hub {
// Handle the flags. TODO: add flags for redis
var dbPath string
flag.StringVar(&dbPath, "ipdb-path", os.Getenv("IPDB_PATH"),
"The path to the ip->location DB")
flag.Parse()
// Initialze the hub
log.Println("[Info] Starting the eventsource Hub")
var db *freegeoip.DB
var err error
if dbPath != "" {
log.Println("[Info] Using ip->location DB ", dbPath)
db, err = freegeoip.Open(dbPath)
if err != nil {
log.Fatal(err)
}
} else {
log.Println("[Info] No ip->location DB provided")
}
redisURLString := os.Getenv("REDIS_SSEQUEUE_URL")
if redisURLString == "" {
// Use db 2 by default for pub/sub
redisURLString = "redis://localhost:6379/2"
}
log.Println("[Info] Redis configuration used for pub/sub", redisURLString)
redisURL, err := nurl.Parse(redisURLString)
if err != nil {
log.Fatal("Could not read Redis string", err)
}
redisDb, err := strconv.Atoi(strings.TrimLeft(redisURL.Path, "/"))
if err != nil {
log.Fatal("[Error] Could not read Redis path", err)
}
server := eventsource.NewServer()
server.AllowCORS = true
h := Hub{
Data: make(map[string][]string),
Users: make(map[string]string),
register: make(chan Connection, 0),
unregister: make(chan string, 0),
messages: make(chan goredis.Message, 0),
srv: server,
client: goredis.Client{Addr: redisURL.Host, Db: redisDb},
ipdb: db,
}
go h.run()
return &h
}
// openDB opens and returns the IP database file or URL.
func openDB(c *Config) (*freegeoip.DB, error) {
// This is a paid product. Get the updates URL.
if len(c.UserID) > 0 && len(c.LicenseKey) > 0 {
var err error
c.DB, err = freegeoip.GeoIPUpdateURL(c.UpdatesHost, c.UserID, c.LicenseKey, c.ProductID)
if err != nil {
return nil, err
} else {
log.Println("Using updates URL:", c.DB)
}
}
u, err := url.Parse(c.DB)
if err != nil || len(u.Scheme) == 0 {
return freegeoip.Open(c.DB)
}
return freegeoip.OpenURL(c.DB, c.UpdateInterval, c.RetryInterval)
}