コード例 #1
0
ファイル: test_tasks.py プロジェクト: boostrack/ichnaea
    def test_scan_lacs_remove(self):
        session = self.db_master_session
        redis_client = self.redis_client

        # create an orphaned lac entry
        key = dict(radio=1, mcc=1, mnc=1, lac=1)
        session.add(CellArea(**key))
        session.flush()
        enqueue_lacs(session, redis_client, [CellArea.to_hashkey(key)],
                     UPDATE_KEY['cell_lac'])

        # after scanning the orphaned record gets removed
        self.assertEqual(scan_lacs.delay().get(), 1)
        lacs = session.query(CellArea).all()
        self.assertEqual(lacs, [])
コード例 #2
0
ファイル: test_locate.py プロジェクト: boostrack/ichnaea
    def test_cell(self):
        session = self.db_slave_session
        london = self.geoip_data['London']
        cell_key = {
            'radio': RADIO_TYPE['gsm'], 'mcc': GB_MCC, 'mnc': 1, 'lac': 1,
        }
        session.add(Cell(
            lat=GB_LAT, lon=GB_LON, range=6000, cid=1, **cell_key))
        session.add(CellArea(
            lat=GB_LAT, lon=GB_LON, range=9000, **cell_key))
        session.flush()

        result = self._make_query(data={'cell': [dict(cid=1, **cell_key)]},
                                  client_addr=london['ip'], api_key_log=True)
        self.assertEqual(result,
                         {'lat': GB_LAT,
                          'lon': GB_LON,
                          'accuracy': 6000})

        self.check_stats(
            counter=[
                'm.cell_hit',
                ('m.geoip_hit', 0),
                'm.api_log.test.cell_hit',
                ('m.api_log.test.geoip_hit', 0),
            ],
        )
コード例 #3
0
ファイル: test_locate.py プロジェクト: boostrack/ichnaea
    def test_cell_agrees_with_lac(self):
        # This test checks that when a cell is at a lat/lon that
        # is inside its enclosing LAC, we accept it and tighten
        # our accuracy accordingly.

        session = self.db_slave_session
        key = dict(mcc=BRAZIL_MCC, mnc=VIVO_MNC, lac=12345)
        data = [
            Cell(lat=SAO_PAULO_LAT + 0.002,
                 lon=SAO_PAULO_LON + 0.002,
                 range=1000,
                 radio=RADIO_TYPE['gsm'], cid=6789, **key),
            CellArea(lat=SAO_PAULO_LAT,
                     lon=SAO_PAULO_LON,
                     range=10000,
                     radio=RADIO_TYPE['gsm'], **key),
        ]
        session.add_all(data)
        session.flush()

        result = self._make_query(data={
            "cell": [dict(radio="gsm", cid=6789, **key)]})
        self.assertEqual(result,
                         {'lat': SAO_PAULO_LAT + 0.002,
                          'lon': SAO_PAULO_LON + 0.002,
                          'accuracy': CELL_MIN_ACCURACY})

        self.check_stats(
            counter=[
                ('m.cell_lac_hit', 0),
                ('m.cell_hit', 1),
            ]
        )
コード例 #4
0
ファイル: test_locate.py プロジェクト: boostrack/ichnaea
    def test_cell_disagrees_with_lac(self):
        # This test checks that when a cell is at a lat/lon that
        # is not in the LAC associated with it, we drop back
        # to the LAC. This likely represents some kind of internal
        # database consistency error, but it might also just be a
        # new cell that hasn't been integrated yet or something.

        session = self.db_slave_session
        key = dict(mcc=BRAZIL_MCC, mnc=VIVO_MNC, lac=12345)
        data = [
            Cell(lat=PORTO_ALEGRE_LAT,
                 lon=PORTO_ALEGRE_LON,
                 range=1000,
                 radio=RADIO_TYPE['gsm'], cid=6789, **key),
            CellArea(lat=SAO_PAULO_LAT,
                     lon=SAO_PAULO_LON,
                     range=10000,
                     radio=RADIO_TYPE['gsm'], **key),
        ]
        session.add_all(data)
        session.flush()

        result = self._make_query(
            data={"cell": [dict(radio="gsm", cid=6789, **key)]})
        self.assertEqual(result,
                         {'lat': SAO_PAULO_LAT,
                          'lon': SAO_PAULO_LON,
                          'accuracy': LAC_MIN_ACCURACY})

        self.check_stats(
            counter=[
                ('m.cell_lac_hit', 1),
            ]
        )
コード例 #5
0
ファイル: test_locate.py プロジェクト: boostrack/ichnaea
    def test_cell_hit_ignores_lac(self):
        session = self.db_slave_session
        lat = PARIS_LAT
        lon = PARIS_LON
        key = dict(mcc=FRANCE_MCC, mnc=2, lac=3)
        data = [
            Cell(lat=lat, lon=lon, range=1000,
                 radio=2, cid=4, **key),
            Cell(lat=lat + 0.002, lon=lon + 0.004, range=1000,
                 radio=2, cid=5, **key),
            Cell(lat=lat + 0.006, lon=lon + 0.006, range=1000,
                 radio=2, cid=6, **key),
            CellArea(lat=lat + 0.0026666,
                     lon=lon + 0.0033333, radio=2,
                     range=50000, **key),
        ]
        session.add_all(data)
        session.flush()

        result = self._make_query(
            data={"cell": [dict(radio="umts", cid=5, **key)]})
        self.assertEqual(result,
                         {'lat': PARIS_LAT + 0.002,
                          'lon': PARIS_LON + 0.004,
                          'accuracy': CELL_MIN_ACCURACY})
コード例 #6
0
ファイル: test_locate.py プロジェクト: boostrack/ichnaea
    def test_cell_multiple_country_codes_from_mcc(self):
        session = self.db_slave_session
        cell_key = {
            'radio': RADIO_TYPE['gsm'], 'mcc': GB_MCC, 'mnc': 1, 'lac': 1,
        }
        session.add(Cell(
            lat=GB_LAT, lon=GB_LON, range=6000, cid=1, **cell_key))
        session.add(CellArea(
            lat=GB_LAT, lon=GB_LON, range=9000, **cell_key))
        session.flush()

        # Without a GeoIP, the mcc results in 4 different equally common
        # mcc values, GB not being the first one. We need to make sure
        # that we accept any of the country codes as a possible match
        # and don't discard otherwise good cell data based on this.
        result = self._make_query(data={'cell': [dict(cid=1, **cell_key)]})
        self.assertEqual(result,
                         {'lat': GB_LAT,
                          'lon': GB_LON,
                          'accuracy': 6000})

        self.check_stats(
            counter=[
                'm.cell_hit',
            ],
        )
コード例 #7
0
ファイル: test_locate.py プロジェクト: boostrack/ichnaea
    def test_cell_miss_lac_hit(self):
        session = self.db_slave_session
        lat = PARIS_LAT
        lon = PARIS_LON
        key = dict(mcc=FRANCE_MCC, mnc=2, lac=3)
        umts = RADIO_TYPE['umts']
        data = [
            Cell(lat=lat, lon=lon, radio=umts, cid=4, **key),
            Cell(lat=lat + 0.002, lon=lon + 0.004, radio=umts, cid=5, **key),
            Cell(lat=lat + 0.006, lon=lon + 0.006, radio=umts, cid=6, **key),
            CellArea(lat=lat + 0.0026666, lon=lon + 0.0033333,
                     radio=umts,
                     range=500000, **key),
        ]
        session.add_all(data)
        session.flush()

        result = self._make_query(
            data={"cell": [dict(radio="umts", cid=7, **key)]},
            api_key_log=True)
        self.assertEqual(result,
                         {'lat': PARIS_LAT + 0.0026666,
                          'lon': PARIS_LON + 0.0033333,
                          'accuracy': 500000})

        self.check_stats(
            counter=[
                'm.cell_lac_hit',
                'm.api_log.test.cell_lac_hit',
                ('m.api_log.test.cell_hit', 0),
                ('m.api_log.test.cell_miss', 0),
            ],
        )
コード例 #8
0
ファイル: test_locate.py プロジェクト: boostrack/ichnaea
    def test_cell_multiple_lac_hit(self):
        session = self.db_slave_session
        lat = PARIS_LAT
        lon = PARIS_LON
        gsm = RADIO_TYPE['gsm']

        key = dict(mcc=FRANCE_MCC, mnc=2, lac=3)
        key2 = dict(mcc=FRANCE_MCC, mnc=2, lac=4)

        expected_lac = CellArea(
            lat=lat + 0.2, lon=lon + 0.2, radio=gsm,
            range=20000, **key)

        data = [
            Cell(lat=lat + 0.02, lon=lon + 0.02, radio=gsm,
                 cid=4, range=2000, **key2),
            Cell(lat=lat + 0.04, lon=lon + 0.04, radio=gsm,
                 cid=5, range=3000, **key2),
            Cell(lat=lat + 0.2, lon=lon + 0.4, radio=gsm,
                 cid=5, range=1000, **key),
            CellArea(lat=lat, lon=lon, radio=gsm,
                     range=30000, **key2),
            expected_lac,
        ]
        session.add_all(data)
        session.flush()

        # We have two lacs, both with two cells, but only know about
        # one cell in one of them and two in the other.
        # The lac with two known cells wins and we use both their
        # positions to calculate the final result.
        result = self._make_query(data={
            "cell": [
                dict(radio="gsm", cid=4, **key),
                dict(radio="gsm", cid=9, **key),
                dict(radio="gsm", cid=4, **key2),
                dict(radio="gsm", cid=5, **key2),
            ]
        })
        self.assertEqual(result,
                         {'lat': expected_lac.lat,
                          'lon': expected_lac.lon,
                          'accuracy': expected_lac.range})
コード例 #9
0
ファイル: tasks.py プロジェクト: mrthomas108/ichnaea
def import_stations(session, pipe, filename, fields):
    today = util.utcnow().date()

    def commit_batch(ins, rows, commit=True):
        result = session.execute(ins, rows)
        count = result.rowcount
        # apply trick to avoid querying for existing rows,
        # MySQL claims 1 row for an inserted row, 2 for an updated row
        inserted_rows = 2 * len(rows) - count
        changed_rows = count - len(rows)
        assert inserted_rows + changed_rows == len(rows)
        StatCounter(StatKey.unique_ocid_cell, today).incr(pipe, inserted_rows)
        if commit:
            session.commit()
        else:  # pragma: no cover
            session.flush()

    with GzipFile(filename, 'rb') as zip_file:
        csv_reader = csv.DictReader(zip_file, fields)
        batch = 10000
        rows = []
        area_keys = set()
        ins = OCIDCell.__table__.insert(
            on_duplicate=((
                'changeable = values(changeable), '
                'modified = values(modified), '
                'total_measures = values(total_measures), '
                'lat = values(lat), '
                'lon = values(lon), '
                'psc = values(psc), '
                '`range` = values(`range`)')))

        for row in csv_reader:
            # skip any header row
            if csv_reader.line_num == 1 and \
               'radio' in row.values():  # pragma: no cover
                continue

            data = make_ocid_cell_import_dict(row)
            if data is not None:
                rows.append(data)
                area_keys.add(CellArea.to_hashkey(data))

            if len(rows) == batch:  # pragma: no cover
                commit_batch(ins, rows, commit=False)
                rows = []

        if rows:
            commit_batch(ins, rows)

        for area_key in area_keys:
            update_area.delay(area_key, cell_type='ocid')
コード例 #10
0
ファイル: test_locate.py プロジェクト: boostrack/ichnaea
    def test_cell_multiple_lac_lower_range_wins(self):
        session = self.db_slave_session
        lat = PARIS_LAT
        lon = PARIS_LON
        gsm = RADIO_TYPE['gsm']

        key = dict(mcc=FRANCE_MCC, mnc=2, lac=3)
        key2 = dict(mcc=FRANCE_MCC, mnc=2, lac=4)

        expected_lac = CellArea(
            lat=lat + 0.2, lon=lon + 0.2, radio=gsm,
            range=10000, **key)

        data = [
            Cell(lat=lat + 0.02, lon=lon + 0.02, radio=gsm,
                 cid=4, range=2000, **key2),
            Cell(lat=lat + 0.2, lon=lon + 0.4, radio=gsm,
                 cid=4, range=4000, **key),
            CellArea(lat=lat, lon=lon, radio=gsm,
                     range=20000, **key2),
            expected_lac,
        ]

        session.add_all(data)
        session.flush()

        # We have two lacs with each one known cell.
        # The lac with the smallest cell wins.
        result = self._make_query(data={
            "cell": [
                dict(radio="gsm", cid=4, **key),
                dict(radio="gsm", cid=4, **key2),
            ]
        })
        self.assertEqual(result,
                         {'lat': expected_lac.lat,
                          'lon': expected_lac.lon,
                          'accuracy': LAC_MIN_ACCURACY})
コード例 #11
0
ファイル: test_area.py プロジェクト: SOFTowaha/ichnaea
    def test_new(self):
        cell = CellFactory()
        self.session.flush()

        area_key = CellArea.to_hashkey(cell)
        self.area_queue.enqueue([area_key])
        self.assertEqual(scan_areas.delay().get(), 1)

        area = self.session.query(CellArea).one()
        self.assertAlmostEqual(area.lat, cell.lat)
        self.assertAlmostEqual(area.lon, cell.lon)
        self.assertEqual(area.range, 0)
        self.assertEqual(area.num_cells, 1)
        self.assertEqual(area.avg_cell_range, cell.range)
コード例 #12
0
ファイル: station.py プロジェクト: therewillbecode/ichnaea
    def __call__(self, cell_keys):
        cells_removed = 0
        changed_areas = set()
        area_queue = self.task.app.data_queues['update_cellarea']

        for key in cell_keys:
            query = Cell.querykey(self.session, key)
            cells_removed += query.delete()
            changed_areas.add(CellArea.to_hashkey(key))

        if changed_areas:
            area_queue.enqueue(changed_areas, pipe=self.pipe)

        return cells_removed
コード例 #13
0
    def remove(self, cell_keys):
        cells_removed = 0
        changed_areas = set()

        for key in cell_keys:
            query = Cell.querykey(self.session, key)
            cells_removed += query.delete()
            changed_areas.add(CellArea.to_hashkey(key))

        if changed_areas:
            self.session.on_post_commit(enqueue_areas, self.redis_client,
                                        changed_areas, UPDATE_KEY['cell_lac'])

        return cells_removed
コード例 #14
0
ファイル: test_locate.py プロジェクト: boostrack/ichnaea
    def test_cell_multiple_radio_lac_hit_with_min_lac_accuracy(self):
        session = self.db_slave_session
        lat = PARIS_LAT
        lon = PARIS_LON
        gsm = RADIO_TYPE['gsm']
        lte = RADIO_TYPE['lte']

        key = dict(mcc=FRANCE_MCC, mnc=3, lac=4)
        key2 = dict(mcc=FRANCE_MCC, mnc=2, lac=3)

        expected_lac = CellArea(
            lat=lat + 0.2, lon=lon + 0.2, radio=gsm,
            range=3000, **key)

        data = [
            Cell(lat=lat + 0.01, lon=lon + 0.02, radio=lte,
                 cid=4, range=2000, **key2),
            Cell(lat=lat + 0.2, lon=lon + 0.4, radio=gsm,
                 cid=5, range=500, **key),
            CellArea(lat=lat, lon=lon, radio=lte,
                     range=10000, **key2),
            expected_lac,
        ]
        session.add_all(data)
        session.flush()

        # GSM lac-only hit (cid 9 instead of 5) and a LTE cell hit
        result = self._make_query(data={
            "cell": [
                dict(radio="gsm", cid=9, **key),
                dict(radio="lte", cid=4, **key2),
            ]
        })
        self.assertEqual(result,
                         {'lat': expected_lac.lat,
                          'lon': expected_lac.lon,
                          'accuracy': LAC_MIN_ACCURACY})
コード例 #15
0
ファイル: station.py プロジェクト: thebent/ichnaea
    def remove(self, cell_keys):
        cells_removed = 0
        changed_areas = set()

        for key in cell_keys:
            query = Cell.querykey(self.session, key)
            cells_removed += query.delete()
            changed_areas.add(CellArea.to_hashkey(key))

        if changed_areas:
            redis_key = self.task.app.data_queues['cell_area_update']
            self.session.on_post_commit(enqueue_areas, self.redis_client,
                                        changed_areas, redis_key)

        return cells_removed
コード例 #16
0
def remove_cell(self, cell_keys):
    cells_removed = 0
    redis_client = self.app.redis_client
    with self.db_session() as session:
        changed_lacs = set()

        for k in cell_keys:
            key = Cell.to_hashkey(k)
            query = session.query(Cell).filter(*Cell.joinkey(key))
            cells_removed += query.delete()
            changed_lacs.add(CellArea.to_hashkey(key))

        if changed_lacs:
            session.on_post_commit(enqueue_lacs, redis_client, changed_lacs,
                                   UPDATE_KEY['cell_lac'])

        session.commit()
    return cells_removed
コード例 #17
0
ファイル: test_locate.py プロジェクト: boostrack/ichnaea
    def test_geoip_mcc_mismatch(self):
        session = self.db_slave_session
        gsm = RADIO_TYPE['gsm']
        bhutan = self.geoip_data['Bhutan']
        key = {'mcc': USA_MCC, 'mnc': 1, 'lac': 1, 'cid': 1}
        key2 = {'mcc': USA_MCC, 'mnc': 1, 'lac': 1, }
        session.add(Cell(radio=gsm, lat=FREMONT_LAT, lon=FREMONT_LON,
                         range=1000, **key))
        session.add(CellArea(radio=gsm, lat=FREMONT_LAT,
                             lon=FREMONT_LON, range=10000, **key2))
        session.flush()

        result = self._make_query(data={'cell': [dict(radio='gsm', **key)]},
                                  client_addr=bhutan['ip'])
        self.assertEqual(result,
                         {'lat': FREMONT_LAT,
                          'lon': FREMONT_LON,
                          'accuracy': CELL_MIN_ACCURACY})
コード例 #18
0
ファイル: station.py プロジェクト: awoland/ichnaea
    def remove(self, cell_keys):
        cells_removed = 0
        changed_areas = set()

        for key in cell_keys:
            query = Cell.querykey(self.session, key)
            cells_removed += query.delete()
            changed_areas.add(CellArea.to_hashkey(key))

        if changed_areas:
            redis_key = self.task.app.data_queues['cell_area_update']
            self.session.on_post_commit(
                enqueue_areas,
                self.redis_client,
                changed_areas,
                redis_key)

        return cells_removed
コード例 #19
0
def scan_lacs(self, batch=100):
    """
    Find cell LACs that have changed and update the bounding box.
    This includes adding new LAC entries and removing them.
    """
    redis_client = self.app.redis_client
    redis_lacs = dequeue_lacs(redis_client,
                              UPDATE_KEY['cell_lac'],
                              batch=batch)
    lacs = set([CellArea.to_hashkey(lac) for lac in redis_lacs])

    for lac in lacs:
        update_lac.delay(lac.radio,
                         lac.mcc,
                         lac.mnc,
                         lac.lac,
                         cell_model_key='cell',
                         cell_area_model_key='cell_area')
    return len(lacs)
コード例 #20
0
ファイル: tasks.py プロジェクト: boostrack/ichnaea
def import_stations(session, filename, fields):
    with GzipFile(filename, 'rb') as zip_file:
        csv_reader = csv.DictReader(zip_file, fields)
        batch = 10000
        rows = []
        lacs = set()
        ins = OCIDCell.__table__.insert(
            on_duplicate=(('changeable = values(changeable), '
                           'modified = values(modified), '
                           'total_measures = values(total_measures), '
                           'lat = values(lat), '
                           'lon = values(lon), '
                           'psc = values(psc), '
                           '`range` = values(`range`)')))

        for row in csv_reader:
            # skip any header row
            if csv_reader.line_num == 1 and \
               'radio' in row.values():  # pragma: no cover
                continue

            data = make_ocid_cell_import_dict(row)
            if data is not None:
                rows.append(data)
                lacs.add(CellArea.to_hashkey(data))

            if len(rows) == batch:  # pragma: no cover
                session.execute(ins, rows)
                session.commit()
                rows = []

        if rows:
            session.execute(ins, rows)
            session.commit()

        for lac in lacs:
            update_lac.delay(lac.radio,
                             lac.mcc,
                             lac.mnc,
                             lac.lac,
                             cell_model_key='ocid_cell',
                             cell_area_model_key='ocid_cell_area')
コード例 #21
0
def location_update_cell(self, min_new=10, max_new=100, batch=10):
    cells = []
    redis_client = self.app.redis_client
    with self.db_session() as session:
        emit_new_observation_metric(self.stats_client, session, self.shortname,
                                    Cell, min_new, max_new)
        query = (session.query(Cell).filter(
            Cell.new_measures >= min_new).filter(
                Cell.new_measures < max_new).limit(batch))
        cells = query.all()
        if not cells:
            return 0
        moving_cells = set()
        updated_lacs = set()
        for cell in cells:
            query = session.query(
                CellObservation.lat, CellObservation.lon,
                CellObservation.id).filter(*CellObservation.joinkey(cell))
            # only take the last X new_measures
            query = query.order_by(CellObservation.created.desc()).limit(
                cell.new_measures)
            observations = query.all()

            if observations:
                moving = calculate_new_position(cell, observations,
                                                CELL_MAX_DIST_KM)
                if moving:
                    moving_cells.add(cell)

                updated_lacs.add(CellArea.to_hashkey(cell))

        if updated_lacs:
            session.on_post_commit(enqueue_lacs, redis_client, updated_lacs,
                                   UPDATE_KEY['cell_lac'])

        if moving_cells:
            # some cells found to be moving too much
            blacklist_and_remove_moving_cells(session, moving_cells)

        session.commit()

    return (len(cells), len(moving_cells))
コード例 #22
0
ファイル: test_locate.py プロジェクト: boostrack/ichnaea
    def test_lac_miss(self):
        session = self.db_slave_session
        key = dict(mcc=FRANCE_MCC, mnc=2, lac=3)
        lat = PARIS_LAT
        lon = PARIS_LON
        gsm = RADIO_TYPE['gsm']
        data = [
            Cell(lat=lat, lon=lon, radio=gsm, cid=4, **key),
            Cell(lat=lat + 0.002, lon=lon + 0.004, radio=gsm, cid=5, **key),
            Cell(lat=1.006, lon=1.006, radio=gsm, cid=6, **key),
            CellArea(lat=1.0026666, lon=1.0033333, radio=gsm,
                     range=50000, **key),
        ]
        session.add_all(data)
        session.flush()

        result = self._make_query(
            data={"cell": [dict(radio="gsm", mcc=FRANCE_MCC,
                                mnc=2, lac=4, cid=5)]})
        self.assertTrue(result is None)
コード例 #23
0
ファイル: test_locate.py プロジェクト: boostrack/ichnaea
    def test_wifi_agrees_with_cell_and_lac(self):
        # This test checks that when a wifi is at a lat/lon that
        # is inside its enclosing LAC and cell, we accept it and
        # tighten our accuracy accordingly.

        session = self.db_slave_session
        key = dict(mcc=BRAZIL_MCC, mnc=VIVO_MNC, lac=12345)
        wifi1 = dict(key="1234567890ab")
        wifi2 = dict(key="1234890ab567")
        wifi3 = dict(key="4321890ab567")
        lat = SAO_PAULO_LAT + 0.002
        lon = SAO_PAULO_LON + 0.002
        data = [
            Wifi(lat=lat, lon=lon, **wifi1),
            Wifi(lat=lat, lon=lon, **wifi2),
            Wifi(lat=lat, lon=lon, **wifi3),
            Cell(lat=SAO_PAULO_LAT,
                 lon=SAO_PAULO_LON,
                 range=1000,
                 radio=RADIO_TYPE['gsm'], cid=6789, **key),
            CellArea(lat=SAO_PAULO_LAT,
                     lon=SAO_PAULO_LON,
                     range=10000,
                     radio=RADIO_TYPE['gsm'], **key),
        ]
        session.add_all(data)
        session.flush()

        result = self._make_query(data={
            "cell": [dict(radio="gsm", cid=6789, **key)],
            "wifi": [wifi1, wifi2, wifi3]})
        self.assertEqual(result,
                         {'lat': SAO_PAULO_LAT + 0.002,
                          'lon': SAO_PAULO_LON + 0.002,
                          'accuracy': WIFI_MIN_ACCURACY})

        self.check_stats(
            counter=[
                ('m.wifi_hit', 1),
            ]
        )
コード例 #24
0
ファイル: test_locate.py プロジェクト: boostrack/ichnaea
    def test_wifi_disagrees_with_lac(self):
        # This test checks that when a wifi is at a lat/lon that
        # is not in the LAC associated with our query, we drop back
        # to the LAC.

        session = self.db_slave_session
        key = dict(mcc=BRAZIL_MCC, mnc=VIVO_MNC, lac=12345)
        wifi1 = dict(key="1234567890ab")
        wifi2 = dict(key="1234890ab567")
        wifi3 = dict(key="4321890ab567")
        lat = PORTO_ALEGRE_LAT
        lon = PORTO_ALEGRE_LON
        data = [
            Wifi(lat=lat, lon=lon, **wifi1),
            Wifi(lat=lat, lon=lon, **wifi2),
            Wifi(lat=lat, lon=lon, **wifi3),
            CellArea(lat=SAO_PAULO_LAT,
                     lon=SAO_PAULO_LON,
                     range=10000,
                     radio=RADIO_TYPE['gsm'], **key),
        ]
        session.add_all(data)
        session.flush()

        result = self._make_query(data={
            "cell": [dict(radio="gsm", cid=6789, **key)],
            "wifi": [wifi1, wifi2, wifi3],
        })
        self.assertEqual(result,
                         {'lat': SAO_PAULO_LAT,
                          'lon': SAO_PAULO_LON,
                          'accuracy': LAC_MIN_ACCURACY})

        self.check_stats(
            counter=[
                ('m.wifi_hit', 0),
                ('m.cell_lac_hit', 1),
            ]
        )
コード例 #25
0
ファイル: tasks.py プロジェクト: awoland/ichnaea
def import_stations(session, filename, fields):
    with GzipFile(filename, 'rb') as zip_file:
        csv_reader = csv.DictReader(zip_file, fields)
        batch = 10000
        rows = []
        area_keys = set()
        ins = OCIDCell.__table__.insert(
            on_duplicate=((
                'changeable = values(changeable), '
                'modified = values(modified), '
                'total_measures = values(total_measures), '
                'lat = values(lat), '
                'lon = values(lon), '
                'psc = values(psc), '
                '`range` = values(`range`)')))

        for row in csv_reader:
            # skip any header row
            if csv_reader.line_num == 1 and \
               'radio' in row.values():  # pragma: no cover
                continue

            data = make_ocid_cell_import_dict(row)
            if data is not None:
                rows.append(data)
                area_keys.add(CellArea.to_hashkey(data))

            if len(rows) == batch:  # pragma: no cover
                session.execute(ins, rows)
                session.commit()
                rows = []

        if rows:
            session.execute(ins, rows)
            session.commit()

        for area_key in area_keys:
            update_area.delay(area_key, cell_type='ocid')
コード例 #26
0
 def add_area_update(self, station):
     self.updated_areas.add(CellArea.to_hashkey(station))
コード例 #27
0
ファイル: station.py プロジェクト: therewillbecode/ichnaea
 def add_area_update(self, station_key):
     area_key = CellArea.to_hashkey(station_key)
     self.updated_areas.add(area_key)
コード例 #28
0
ファイル: station.py プロジェクト: awoland/ichnaea
 def add_area_update(self, station):
     self.updated_areas.add(CellArea.to_hashkey(station))