func TestCache(t *testing.T) {
mongodb, err := mongo.Connect("mongodb://localhost/watch")
if err != nil {
t.Fatal(err)
}
defer mongodb.Close()
cache, err := InitCache(mongodb, token)
if err != nil {
t.Fatal(err)
}
for i := 0; i < 1000; i++ {
data, err := cache.Get(pointHome, DefaultProfile)
if err != nil {
t.Fatal(err)
}
// fmt.Println(data)
data, err = cache.Get(pointWork, DefaultProfile)
if err != nil {
t.Fatal(err)
}
// fmt.Println(data)
_ = data
// jsondata, err := json.Marshal(data)
// if err != nil {
// t.Fatal(err)
// }
// fmt.Println("json:", string(jsondata))
}
}
func TestPlaces(t *testing.T) {
mdb, err := mongo.Connect("mongodb://localhost/watch")
if err != nil {
log.Println("Error connecting to MongoDB:", err)
return
}
defer mdb.Close()
db, err := InitDB(mdb)
if err != nil {
t.Fatal(err)
}
var (
deviceID = "test0123456789"
groupID = users.SampleGroupID
)
places := []Place{
Place{Polygon: &geo.Polygon{{
{37.5667, 55.7152}, {37.5688, 55.7167}, {37.5703, 55.7169},
{37.5706, 55.7168}, {37.5726, 55.7159}, {37.5728, 55.7158},
{37.5731, 55.7159}, {37.5751, 55.7152}, {37.5758, 55.7148},
{37.5755, 55.7144}, {37.5749, 55.7141}, {37.5717, 55.7131},
{37.5709, 55.7128}, {37.5694, 55.7125}, {37.5661, 55.7145},
{37.5660, 55.7147}, {37.5667, 55.7152}}}, Name: "Работа"},
Place{Circle: &geo.Circle{geo.Point{37.589248, 55.765944}, 200.0}, Name: "Дом"},
Place{Polygon: &geo.Polygon{{
{37.6256, 55.7522}, {37.6304, 55.7523}, {37.6310, 55.7527},
{37.6322, 55.7526}, {37.6320, 55.7521}, {37.6326, 55.7517},
{37.6321, 55.7499}, {37.6305, 55.7499}, {37.6305, 55.7502},
{37.6264, 55.7504}, {37.6264, 55.7500}, {37.6254, 55.7500},
{37.6253, 55.7520}, {37.6256, 55.7522}}}, Name: "Знаменский монастырь"},
}
for _, place := range places {
place.GroupID = groupID
id, err := db.Save(place)
if err != nil {
t.Fatal(err)
}
fmt.Println("id:", id.Hex())
}
places, err = db.GetAll(groupID)
if err != nil {
t.Fatal(err)
}
fmt.Println("Places:", len(places))
// pretty.Println(places)
track := tracks.TrackData{
DeviceID: deviceID,
GroupID: groupID,
Time: time.Now(),
Location: geo.NewPoint(37.57351, 55.715084),
}
placeIDs, err := db.Track(track)
if err != nil {
t.Fatal(err)
}
fmt.Printf("In %d places\n%v\n", len(placeIDs), placeIDs)
}
func TestLocators(t *testing.T) {
google, err := geolocate.New(geolocate.Google, googleAPIKey)
if err != nil {
t.Fatal(err)
}
mozilla, err := geolocate.New(geolocate.Mozilla, "test")
if err != nil {
t.Fatal(err)
}
yandex, err := geolocate.New(geolocate.Yandex, yandexAPIKey)
if err != nil {
t.Fatal(err)
}
mongodb, err := mongo.Connect("mongodb://localhost/watch")
if err != nil {
t.Fatal(err)
}
defer mongodb.Close()
lbs, err := lbs.InitDB(mongodb)
if err != nil {
t.Fatal(err)
}
for _, s := range testData {
req, err := ParseLBS("gsm", s)
if err != nil {
t.Fatal(err)
}
resp, err := google.Get(*req)
if err != nil {
fmt.Printf("%8s error: %v\n", "Google", err)
t.Error(err)
} else {
fmt.Printf("%8s [%.7f,%.7f] %.2f\n", "Google", resp.Location.Lon, resp.Location.Lat, resp.Accuracy)
}
resp, err = yandex.Get(*req)
if err != nil {
fmt.Printf("%8s error: %v\n", "Yandex", err)
t.Error(err)
} else {
fmt.Printf("%8s [%.7f,%.7f] %.2f\n", "Yandex", resp.Location.Lon, resp.Location.Lat, resp.Accuracy)
}
resp, err = mozilla.Get(*req)
if err != nil {
fmt.Printf("%8s error: %v\n", "Mozilla", err)
t.Error(err)
} else {
fmt.Printf("%8s [%.7f,%.7f] %.2f\n", "Mozilla", resp.Location.Lon, resp.Location.Lat, resp.Accuracy)
}
resp, err = lbs.Get(*req)
if err != nil {
fmt.Printf("%8s error: %v\n", "Internal", err)
t.Error(err)
}
fmt.Printf("%8s [%.7f,%.7f] %.2f\n", "Internal", resp.Location.Lon, resp.Location.Lat, resp.Accuracy)
fmt.Println("-----------------------------------------")
}
}
func main() {
mongoURL := flag.String("mongodb", "mongodb://localhost/watch", "MongoDB connection URL")
addr := flag.String("http", ":8080", "Server address & port")
docker := flag.Bool("docker", false, "for docker")
flag.Parse()
// Если запускается внутри контейнера
if *docker {
tmp := os.Getenv("MONGODB")
mongoURL = &tmp
}
mdb, err := mongo.Connect(*mongoURL)
if err != nil {
log.Println("Error connecting to MongoDB:", err)
return
}
defer mdb.Close()
// инициализируем хранилище с информацией о треках
tracksDB, err = tracks.InitDB(mdb)
if err != nil {
log.Println("Error initializing TrackDB:", err)
return
}
// инициализируем хранилище с информацией о местах
placesDB, err = places.InitDB(mdb)
if err != nil {
log.Println("Error initializing PlaceDB:", err)
return
}
e := echo.New()
e.Use(middleware.Logger())
e.Use(middleware.Recover())
e.Use(middleware.Gzip())
e.SetRenderer(&Template{templates: template.Must(
template.ParseFiles("index.html", "current.html", "history.html"))})
e.Get("/", index)
e.Get("/:deviceid", current)
e.Get("/:deviceid/history", history)
e.ServeFile("/edit", "placeeditor.html")
e.Run(*addr)
}
func main() {
log.SetLevel(log.DebugLevel) // отладка
mongoURL := flag.String("mongodb", "mongodb://localhost/watch", "MongoDB connection URL")
natsURL := flag.String("nats", nats.DefaultURL, "NATS connection URL")
docker := flag.Bool("docker", false, "for docker")
flag.StringVar(&ubloxToken, "ublox", ubloxToken, "U-Blox token")
flag.Parse()
// Если запускается внутри контейнера
if *docker {
tmp1 := os.Getenv("NATSADDR")
tmp2 := os.Getenv("MONGODB")
natsURL = &tmp1
mongoURL = &tmp2
}
log.WithField("url", *mongoURL).Info("Connecting to MongoDB...")
mdb, err := mongo.Connect(*mongoURL)
if err != nil {
log.WithError(err).Error("Error connecting to MongoDB")
return
}
defer mdb.Close()
log.AddHook(mdb) // добавляем запись логов в MongoDB
log.WithField("url", *natsURL).Info("Connecting to NATS...")
nc, err := nats.Connect(*natsURL)
if err != nil {
log.WithError(err).Error("Error connecting to NATS")
return
}
defer nc.Close()
// запускаем подписку на получение данных и их обработку
if err := subscribe(mdb, nc); err != nil {
log.WithError(err).Error("Error initializing NATS subscription")
return
}
// блокируем дальнейший код до получения одного из сигналов
monitorSignals(os.Interrupt, os.Kill)
log.Debug("THE END")
}
func TestPlaces2(t *testing.T) {
mdb, err := mongo.Connect("mongodb://localhost/watch")
if err != nil {
log.Println("Error connecting to MongoDB:", err)
return
}
defer mdb.Close()
db, err := InitDB(mdb)
if err != nil {
t.Fatal(err)
}
var (
groupID = users.SampleGroupID
)
places := []Place{
Place{Polygon: &geo.Polygon{{
{37.5667, 55.7152}, {37.5688, 55.7167}, {37.5703, 55.7169},
{37.5706, 55.7168}, {37.5726, 55.7159}, {37.5728, 55.7158},
{37.5731, 55.7159}, {37.5751, 55.7152}, {37.5758, 55.7148},
{37.5755, 55.7144}, {37.5749, 55.7141}, {37.5717, 55.7131},
{37.5709, 55.7128}, {37.5694, 55.7125}, {37.5661, 55.7145},
{37.5660, 55.7147}, {37.5667, 55.7152}}}, Name: "Работа"},
Place{Circle: &geo.Circle{geo.Point{37.589248, 55.765944}, 200.0}, Name: "Дом Дмитрия"},
Place{Circle: &geo.Circle{geo.Point{37.539401, 55.77514}, 200.0}, Name: "Дом Сергея"},
Place{Circle: &geo.Circle{geo.Point{37.510511, 55.666675}, 200.0}, Name: "Дом Андрея"},
Place{Polygon: &geo.Polygon{{
{37.6256, 55.7522}, {37.6304, 55.7523}, {37.6310, 55.7527},
{37.6322, 55.7526}, {37.6320, 55.7521}, {37.6326, 55.7517},
{37.6321, 55.7499}, {37.6305, 55.7499}, {37.6305, 55.7502},
{37.6264, 55.7504}, {37.6264, 55.7500}, {37.6254, 55.7500},
{37.6253, 55.7520}, {37.6256, 55.7522}}}, Name: "Знаменский монастырь"},
}
for _, place := range places {
place.GroupID = groupID
id, err := db.Save(place)
if err != nil {
t.Fatal(err)
}
fmt.Println("id:", id.Hex())
}
}
func TestSearch(t *testing.T) {
mongodb, err := mongo.Connect("mongodb://localhost/watch")
if err != nil {
log.Println("Error connecting to MongoDB:", err)
return
}
defer mongodb.Close()
lbs, err := InitDB(mongodb)
if err != nil {
t.Fatal(err)
}
request := geolocate.Request{
CellTowers: []geolocate.CellTower{
{250, 2, 7743, 22517, -78, 0, 0},
{250, 2, 7743, 39696, -81, 0, 0},
{250, 2, 7743, 22518, -91, 0, 0},
{250, 2, 7743, 27306, -101, 0, 0},
{250, 2, 7743, 29909, -103, 0, 0},
{250, 2, 7743, 22516, -104, 0, 0},
{250, 2, 7743, 20736, -105, 0, 0},
},
}
cells, err := lbs.GetCells(request)
if err != nil {
t.Fatal(err)
}
for _, cell := range cells {
fmt.Println(cell)
}
resp, err := lbs.Get(request)
if err != nil {
t.Fatal(err)
}
fmt.Println(resp)
}
func TestUsers(t *testing.T) {
mdb, err := mongo.Connect("mongodb://localhost/watch")
if err != nil {
log.Println("Error connecting to MongoDB:", err)
return
}
defer mdb.Close()
db, err := InitDB(mdb)
if err != nil {
t.Fatal(err)
}
groupID := db.GetSampleGroupID()
groupInfo, err := db.GetGroup(groupID)
if err != nil {
t.Fatal(err)
}
data, err := json.MarshalIndent(groupInfo, "", "\t")
if err != nil {
t.Fatal(err)
}
fmt.Println(string(data))
}
func main() {
addr := flag.String("http", ":8080", "Server address & port")
mongoURL := flag.String("mongodb", "mongodb://localhost/watch", "MongoDB connection URL")
natsURL := flag.String("nats", nats.DefaultURL, "NATS connection URL")
docker := flag.Bool("docker", false, "for docker")
flag.Parse()
// Если запускается внутри контейнера
if *docker {
tmp1 := os.Getenv("NATSADDR")
tmp2 := os.Getenv("MONGODB")
natsURL = &tmp1
mongoURL = &tmp2
}
e = echo.New() // инициализируем HTTP-обработку
e.Debug() // режим отладки
e.SetLogPrefix("") // убираем префикс в логе
e.SetLogLevel(0) // устанавливаем уровень вывода всех сообщений (TRACE)
llog = e.Logger() // интерфейс вывода в лог
llog.Info("Connecting to MongoDB %q...", *mongoURL)
mdb, err := mongo.Connect(*mongoURL)
if err != nil {
llog.Error("Error connecting to MongoDB: %v", err)
return
}
defer mdb.Close()
if usersDB, err = users.InitDB(mdb); err != nil {
llog.Error("Error initializing UsersDB: %v", err)
return
}
if placesDB, err = places.InitDB(mdb); err != nil {
llog.Error("Error initializing PlacesDB: %v", err)
return
}
if tracksDB, err = tracks.InitDB(mdb); err != nil {
llog.Error("Error initializing TracksDB: %v", err)
return
}
if sensorsDB, err = sensors.InitDB(mdb); err != nil {
llog.Error("Error initializing SensorsDB: %v", err)
return
}
groupID = usersDB.GetSampleGroupID() // временная инициализация пользователей
log.Println("Connecting to NATS...")
nc, err := nats.Connect(*natsURL)
if err != nil {
log.Printf("Error connecting to NATS: %v", err)
return
}
defer nc.Close()
nce, err = nats.NewEncodedConn(nc, nats.JSON_ENCODER)
if err != nil {
log.Printf("Error initializing NATS encoder: %v", err)
return
}
// инициализируем работу с токенами
tokenEngine, err = token.Init("com.xyzrd.geotracker", time.Minute*30, nil)
if err != nil {
llog.Error("Error initializing Token Engine: %v", err)
return
}
llog.Debug("CryptoKey: %v", tokenEngine.CryptoKey())
e.Use(Logger())
e.Use(middleware.Recover())
e.Use(middleware.Gzip())
apiV1 := e.Group("/api/v1") // группа URL для обработки API версии 1.0.
apiV1.Get("/login", login) // авторизация пользователя
apiV1Sec := apiV1.Group("") // группа запросов с авторизацией
apiV1Sec.Use(auth) // добавляем проверку токена в заголовке
apiV1Sec.Get("/users", getUsers) // возвращает список пользователей
apiV1Sec.Get("/places", getPlaces) // возвращает список интересующих мест
apiV1Sec.Post("/places", postPlace) // добавляет определение нового места
apiV1Sec.Get("/places/:place-id", getPlace) // возвращает информацию об указаном месте
apiV1Sec.Put("/places/:place-id", putPlace) // изменяет определение места
apiV1Sec.Delete("/places/:place-id", deletePlace) // удаляет определение места
apiV1Sec.Get("/devices", getDevices) // возвращает список устройств
apiV1Sec.Post("/devices", postDevicePairing) // привязка устройства к группе
apiV1Sec.Post("/devices/:device-id", postDevicePairing) // привязка устройства к группе
apiV1Sec.Get("/devices/:device-id/tracks", getTracks) // возвращает список трекингов устройства
apiV1Sec.Post("/devices/:device-id/tracks", postTracks) // добавляет данные о треках устройства
apiV1Sec.Get("/devices/:device-id/sensors", getSensors) // возвращает список трекингов устройства
apiV1Sec.Post("/devices/:device-id/sensors", postSensors) // добавляет данные о треках устройства
apiV1Sec.Post("/push/:push-type", postRegister) // регистрирует устройство для отправки push-сообщений
apiV1Sec.Delete("/push/:push-type/:token", deleteRegister) // удаляет токен из хранилища
llog.Info("Starting HTTP server at %q...", *addr)
e.Run(*addr)
}
func TestBD(t *testing.T) {
mdb, err := mongo.Connect("mongodb://localhost/watch")
if err != nil {
log.Println("Error connecting to MongoDB:", err)
return
}
defer mdb.Close()
// подключаемся к хранилищу
db, err := InitDB(mdb)
if err != nil {
t.Fatal("Connect error:", err)
}
const deviceID = "test0123456789"
var (
groupID = users.SampleGroupID
points = []geo.Point{
{37.57351, 55.715084},
{37.595061, 55.736077},
{37.589248, 55.765944},
{37.587119, 55.752658},
{37.627804, 55.752541},
{37.642815, 55.74711},
{37.689024, 55.724109},
}
currentPoint = points[0] // текущая точка
destinationPointIndex = 1 // индекс точки назначения
destinationPoint = points[destinationPointIndex] // точка назначения
currentTime = time.Now().Add(time.Hour * -12) // время начала
interval time.Duration // интервал времени
)
const (
MaxSpeed = 4.5 * 1000 / 60 / 60 // максимальная скорость передвижения — 4.5 км/ч
MaxBearing = 45.0 // максимальное отклонение
)
for {
track := TrackData{
DeviceID: deviceID,
GroupID: groupID,
Time: currentTime,
Location: currentPoint,
Method: uint8(rand.Int31n(7)),
}
if err := db.Add(track); err != nil {
t.Fatal(err)
}
// случайный интервал до 10 минут
interval = time.Duration(rand.Int63n(int64(time.Minute * 10)))
currentTime = currentTime.Add(interval) // увеличиваем время
// вычисляем расстояние с учетом прошедшего времени
dist := rand.Float64() * MaxSpeed * float64(interval.Seconds())
// случайное отклонение от заданного направления
bearing := currentPoint.BearingTo(destinationPoint) + rand.Float64()*MaxBearing - (MaxBearing / 2)
// перемещаемся на заданное расстояние в заданном направлении
currentPoint = currentPoint.Move(dist, bearing)
// проверяем, что расстояние не меньше 150 метров
if currentPoint.Distance(destinationPoint) < 150.0 {
if len(points) == destinationPointIndex+1 {
log.Println("Мы достигли конечной точки назначения")
break
}
log.Println("Мы достигли точки назначения", destinationPointIndex)
currentPoint = destinationPoint
destinationPointIndex++
destinationPoint = points[destinationPointIndex]
}
if currentTime.After(time.Now()) {
log.Println("Время истекло")
break
}
}
var lastId bson.ObjectId
for {
// fmt.Println("lastID:", lastId.Hex())
tracks, err := db.Get(groupID, deviceID, 5, lastId.Hex())
if err != nil {
t.Fatal(err)
}
if len(tracks) == 0 {
fmt.Println("END")
break
}
fmt.Println(len(tracks),
tracks[0].Time.Format("15:04:05"), tracks[0].ID.Hex(), "-",
tracks[len(tracks)-1].Time.Format("15:04:05"), tracks[len(tracks)-1].ID.Hex())
lastId = tracks[len(tracks)-1].ID
}
track, err := db.GetLast(groupID, deviceID)
if err != nil {
t.Fatal(err)
}
fmt.Println("last:", track.Time.Format("15:04:05"), track.ID.Hex(), track.Location)
jsondata, err := json.MarshalIndent(track, "", "\t")
if err != nil {
t.Fatal(err)
}
fmt.Println(string(jsondata))
deviceIDs, err := db.GetDevicesID(groupID)
if err != nil {
t.Fatal(err)
}
fmt.Println("device ids:", strings.Join(deviceIDs, ", "))
_, err = db.GetDay(groupID, deviceID)
if err != nil {
t.Fatal(err)
}
}
func main() {
log.SetOutput(os.Stdout)
log.SetFlags(log.Ltime)
mongourl := flag.String("mongo", "mongodb://localhost/watch", "mongoDB connection URL")
radiofilter := flag.String("radio", "gsm", "filter for radio (comma separated)")
countryfilter := flag.String("country", "250", "filter for country (comma separated)")
minSamples := flag.Int64("minsample", 0, "filter for min samples count")
flag.Usage = func() {
fmt.Fprint(os.Stderr, "Import LBS database data\n")
fmt.Fprintf(os.Stderr, "%s [-params] datafile.csv\n", os.Args[0])
flag.PrintDefaults()
}
flag.Parse()
if flag.NArg() != 1 {
flag.Usage()
return
}
filename := flag.Arg(0)
// устанавливаем соединение с сервером MongoDB
log.Printf("Connecting to MongoDB %q...", *mongourl)
mdb, err := mongo.Connect(*mongourl)
if err != nil {
log.Printf("Error connecting to MongoDB: %v", err)
return
}
defer mdb.Close()
db, err := lbs.InitDB(mdb)
if err != nil {
log.Printf("Error initializing indexes: %v", err)
return
}
coll := db.GetCollection(lbs.CollectionName)
defer db.FreeCollection(coll)
bulk := coll.Bulk()
bulk.Unordered()
// разбираем фильтры и формируем соответствующие справочники
var (
filterRadio = make(map[string]bool)
filterCountry = make(map[uint16]bool)
)
for _, radio := range strings.Split(*radiofilter, ",") {
filterRadio[strings.ToLower(strings.TrimSpace(radio))] = true
}
for _, country := range strings.Split(*countryfilter, ",") {
mcc, err := strconv.ParseUint(country, 10, 16)
if err != nil {
continue
}
filterCountry[uint16(mcc)] = true
}
if len(filterRadio) > 0 || len(filterCountry) > 0 {
log.Printf("Filters country - %q, radio - %q",
strings.Join(strings.Split(*countryfilter, ","), ", "),
strings.Join(strings.Split(*radiofilter, ","), ", "))
}
log.Printf("Reading data from CSV %q...", filename)
file, err := os.Open(filename)
if err != nil {
log.Printf("Error opening CSV file: %v", err)
return
}
defer file.Close()
var counter, lines uint64 // счетчики
r := csv.NewReader(file)
for {
record, err := r.Read()
if err == io.EOF {
break
}
if err != nil {
log.Printf("Error parsing CSV file: %v", err)
return
}
lines++
if lines == 1 {
r.FieldsPerRecord = len(record) // устанавливаем количество полей
continue // пропускаем первую строку с заголовком в CSV-файле
}
fmt.Fprintf(os.Stderr, "\r* find %8d | skipped %8d records ", counter, lines-1-counter)
radio := strings.ToLower(record[0])
if len(filterRadio) > 0 && !filterRadio[radio] {
continue // игнорируем записи с неподдерживаемым типом радио
}
samples, err := strconv.ParseInt(record[9], 10, 32)
if err != nil {
log.Printf("[%d] bad Samples: %s", lines, record[9])
continue
}
if samples < *minSamples {
continue // не импортируем данные с маленьким количеством подтверждений
}
mcc, err := strconv.ParseUint(record[1], 10, 16)
if err != nil {
log.Printf("[%d] bad MCC: %s", lines, record[1])
continue
}
if len(filterCountry) > 0 && !filterCountry[uint16(mcc)] {
continue // игнорируем записи с неподдерживаемым типом радио
}
mnc, err := strconv.ParseUint(record[2], 10, 16)
if err != nil {
log.Printf("[%d] bad MNC: %s", lines, record[2])
continue
}
area, err := strconv.ParseUint(record[3], 10, 16)
if err != nil {
log.Printf("[%d] bad Area: %s", lines, record[3])
continue
}
cell, err := strconv.ParseUint(record[4], 10, 32)
if err != nil {
log.Printf("[%d] bad Cell: %s", lines, record[4])
continue
}
lon, err := strconv.ParseFloat(record[6], 64)
if err != nil {
log.Printf("[%d] bad longitude:", lines, record[6])
continue
}
lat, err := strconv.ParseFloat(record[7], 64)
if err != nil {
log.Printf("[%d] bad latitude:", lines, record[7])
continue
}
distance, err := strconv.ParseFloat(record[8], 64)
if err != nil {
log.Printf("[%d] bad range:", lines, record[8])
continue
}
key := lbs.Key{
RadioType: radio,
MobileCountryCode: uint16(mcc),
MobileNetworkCode: uint16(mnc),
LocationAreaCode: uint16(area),
CellId: uint32(cell),
}
data := lbs.Data{
Location: geo.NewPoint(lon, lat),
Accuracy: distance,
}
// created, err := strconv.ParseInt(record[11], 10, 64)
// if err != nil {
// log.Printf("[%d] bad Created: %s", lines, record[11])
// continue
// }
// updated, err := strconv.ParseInt(record[12], 10, 64)
// if err != nil {
// log.Printf("[%d] bad Updated: %s", lines, record[12])
// continue
// }
bulk.Upsert(key, bson.M{"$set": data})
counter++
}
fmt.Fprintln(os.Stderr, "")
if counter == 0 {
log.Println("No record for import. Exit...")
return
}
// если это не обновление, то подчищаем старые (не обновленные) данные
if !strings.Contains(filename, "diff") {
log.Println("Deleting old data...")
deleteResult, err := coll.RemoveAll(nil)
if err != nil {
log.Printf("MongoDB deleting old data error: %v", err)
return
}
if deleteResult.Removed > 0 {
log.Printf("Deleted %d records", deleteResult.Removed)
}
}
log.Printf("Bulk importing to MongoDB [%d records]...", counter)
bulkResult, err := bulk.Run()
if err != nil {
log.Printf("MongoDB bulk insert error: %v", err)
return
}
if bulkResult.Modified > 0 {
log.Printf("Modified %d records", bulkResult.Modified)
}
total, err := coll.Count()
if err != nil {
log.Printf("MongoDB total counting error: %v", err)
return
}
log.Printf("Total unique records in DB: %d", total)
}
func TestSubscription(t *testing.T) {
log.SetLevel(log.DebugLevel) // отладка
log.WithField("url", "mongodb://localhost/watch").Info("Connecting to MongoDB...")
mdb, err := mongo.Connect("mongodb://localhost/watch")
if err != nil {
log.WithError(err).Error("Error connecting to MongoDB")
return
}
defer mdb.Close()
log.AddHook(mdb) // добавляем запись логов в MongoDB
log.WithField("options", nats.DefaultOptions.Url).Info("Connecting to NATS...")
nc, err := nats.DefaultOptions.Connect()
if err != nil {
log.WithError(err).Error("Error connecting to NATS")
return
}
defer nc.Close()
// запускаем подписку на получение данных и их обработку
if err := subscribe(mdb, nc); err != nil {
log.WithError(err).Error("Error initializing NATS subscription")
return
}
nce, err := nats.NewEncodedConn(nc, nats.JSON_ENCODER)
if err != nil {
log.WithError(err).Fatal("Error initializing NATS encoder")
}
var (
timemout = 10 * time.Second
point = geo.Point{55.715084, 37.57351}
deviceID = "test0123456789"
groupID = users.SampleGroupID
)
{
req, err := parser.ParseLBS("gsm", `3D867293-13007-022970357-fa-2-1e3f-57f5-8b-1e3f-9b10-8a-1e3f-5100-79-1e3f-b6a6-78-1e3f-6aaa-78-1e3f-57f6-77-1e3f-5103-72`)
if err != nil {
log.WithError(err).Fatal("LBS Parse")
}
var data geolocate.Response
err = nce.Request(serviceNameLBS, *req, &data, timemout)
if err != nil {
log.WithError(err).Fatal("LBS Request")
}
}
{
var data []byte
err = nce.Request(serviceNameUblox, point, &data, timemout)
if err != nil {
log.WithError(err).Fatal("UBLOX Request")
}
}
{
var data users.GroupInfo
err = nce.Request(serviceNameIMEI, deviceID, &data, timemout)
if err != nil {
log.WithError(err).Fatal("IMEI Request")
}
groupID = data.GroupID
}
{
var data = tracks.TrackData{
GroupID: groupID,
DeviceID: deviceID,
Time: time.Now(),
Location: point,
}
err = nce.Publish(serviceNameTracks, []tracks.TrackData{data})
if err != nil {
log.WithError(err).Fatal("TRACKS publishing")
}
}
{
var data = sensors.SensorData{
GroupID: groupID,
DeviceID: deviceID,
Time: time.Now(),
Data: map[string]interface{}{
"sensor1": uint(1),
"sensor2": "sensor 2",
"sensor3": []uint{1, 2, 3},
},
}
err = nce.Publish(serviceNameSensors, []sensors.SensorData{data})
if err != nil {
log.WithError(err).Fatal("SENSORS publishing")
}
}
{
var key string
err = nce.Request(serviceNamePairing, deviceID, &key, timemout)
if err != nil {
log.WithError(err).Fatal("PAIRING Request")
}
if key == "" {
log.Fatal("empty key")
}
var newDeviceID string
err = nce.Request(serviceNamePairingKey, key, &newDeviceID, timemout)
if err != nil {
log.WithError(err).Fatal("PAIRING KEY Request")
}
if newDeviceID == "" {
log.Fatal("bad device pairing deviceid")
}
if newDeviceID != deviceID {
log.Fatal("bad device pairing")
}
}
time.Sleep(time.Second * 5) // ожидаем обработки, иначе не успеет
}