Example #1
0
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))
	}
}
Example #2
0
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)
}
Example #3
0
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("-----------------------------------------")
	}
}
Example #4
0
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)
}
Example #5
0
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")
}
Example #6
0
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())
	}
}
Example #7
0
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)
}
Example #8
0
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))
}
Example #9
0
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)
}
Example #10
0
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)
	}
}
Example #11
0
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)
}
Example #12
0
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) // ожидаем обработки, иначе не успеет
}