Merge lp:~mardy/location-service/old-location-1551686 into lp:location-service/trunk

[Alberto Mardegan]

Decrease accuracy according to the update's age

Decrease accuracy according to the update's age

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:222
http://jenkins.qa.ubuntu.com/job/location-service-ci/429/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/location-service-vivid-amd64-ci/101
    SUCCESS: http://jenkins.qa.ubuntu.com/job/location-service-vivid-armhf-ci/101
        deb: http://jenkins.qa.ubuntu.com/job/location-service-vivid-armhf-ci/101/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/location-service-vivid-i386-ci/101

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/location-service-ci/429/rebuild

review: Approve (continuous-integration)

Unmerged revisions

222. By Alberto Mardegan on 2016-04-27

Merge trunk

* Small fixes around provider loading added: tests/mock_engine.h
* Use a fusion engine provider to generate higher quality position
  updates added:
  include/location_service/com/ubuntu/location/fusion_provider.h
  include/location_service/com/ubuntu/location/fusion_provider_selecti
  on_policy.h
  include/location_service/com/ubuntu/location/newer_or_more_accurate_
  update_selector.h
  include/location_service/com/ubuntu/location/newer_update_selector.h
  include/location_service/com/ubuntu/location/update_selector.h
  src/location_service/com/ubuntu/location/fusion_provider.cpp
  src/location_service/com/ubuntu/location/fusion_provider_selection_p
  olicy.cpp
* Enable dual landings according to https://wiki.ubuntu.com/citrain/LandingProcess#Dual-landing_for_stable_and_devel:
  * Both vivid+overlay and xenial packages are built from the same
    source.
  * To account for differences in major revisions (necessary to handle
    the g++ 5 ABI break), we generate install files on the fly.
* Lower number of concurrent clients to stabilize acceptance test on
  loaded builders.
* No change rebuild.
* No change rebuild.
* libubuntu-location-service3: Replaces libubuntu-location-service2,
  config file /etc/gps.conf in both packages.
* Bump major revision and fix LP:#1478750 to account for toolchain update.
* Log to stderr by default, relying on upstart to rotate logs
  appropriately. (LP: #1447110)
* Add SntpClient for querying reference time information.

221. By Alberto Mardegan on 2016-03-18

Add tests

220. By Alberto Mardegan on 2016-03-17

Fix tests

219. By Alberto Mardegan on 2016-03-17

Move aging function into new obfuscator class

218. By Alberto Mardegan on 2016-03-14

WIP first draft

=== modified file 'src/location_service/com/ubuntu/location/CMakeLists.txt'
--- src/location_service/com/ubuntu/location/CMakeLists.txt	2016-04-05 21:26:06 +0000
+++ src/location_service/com/ubuntu/location/CMakeLists.txt	2016-04-27 10:14:29 +0000
@@ -53,6 +53,7 @@
   service/trust_store_permission_manager.cpp
 
   service/implementation.cpp
+  service/position_obfuscator.cpp
   service/skeleton.cpp
   service/stub.cpp
 

=== modified file 'src/location_service/com/ubuntu/location/service/daemon.cpp'
--- src/location_service/com/ubuntu/location/service/daemon.cpp	2016-03-31 20:31:05 +0000
+++ src/location_service/com/ubuntu/location/service/daemon.cpp	2016-04-27 10:14:29 +0000
@@ -246,7 +246,8 @@
         {
             std::make_shared<dummy::ConnectivityManager>(),
             std::make_shared<NullReporter>()
-        }
+        },
+        location::service::PositionObfuscator::Configuration(),
     };
 
     auto location_service = std::make_shared<location::service::Implementation>(configuration);

=== modified file 'src/location_service/com/ubuntu/location/service/implementation.cpp'
--- src/location_service/com/ubuntu/location/service/implementation.cpp	2015-12-09 15:18:14 +0000
+++ src/location_service/com/ubuntu/location/service/implementation.cpp	2016-04-27 10:14:29 +0000
@@ -64,6 +64,7 @@
       },
       configuration(config),
       harvester(config.harvester),
+      obfuscator(config.obfuscator),
       connections
       {
           is_online().changed().connect(
@@ -157,6 +158,7 @@
     session_iface->updates().position_status.changed().connect([this, session_weak](const session::Interface::Updates::Status& status)
     {
         cul::Optional<cul::Update<cul::Position>> last_known_position = configuration.engine->updates.last_known_location.get();
+        obfuscator.apply_age(last_known_position);
         bool has_last_known_position = last_known_position ? true : false;
         bool is_session_enabled = status == culs::session::Interface::Updates::Status::enabled;
         bool is_session_on_or_active = configuration.engine->configuration.engine_state != Engine::Status::off;

=== modified file 'src/location_service/com/ubuntu/location/service/implementation.h'
--- src/location_service/com/ubuntu/location/service/implementation.h	2014-08-01 12:51:25 +0000
+++ src/location_service/com/ubuntu/location/service/implementation.h	2016-04-27 10:14:29 +0000
@@ -21,6 +21,7 @@
 #include <com/ubuntu/location/engine.h>
 #include <com/ubuntu/location/connectivity/manager.h>
 #include <com/ubuntu/location/service/harvester.h>
+#include <com/ubuntu/location/service/position_obfuscator.h>
 #include <com/ubuntu/location/service/skeleton.h>
 
 #include <memory>
@@ -53,6 +54,8 @@
         PermissionManager::Ptr permission_manager;
         // All harvesting specific options.
         Harvester::Configuration harvester;
+        // Options for the position obfuscator.
+        PositionObfuscator::Configuration obfuscator;
     };
 
     // Creates a new instance of the service with the given configuration.
@@ -67,6 +70,8 @@
     Configuration configuration;
     // The harvester instance.
     Harvester harvester;
+    // The position obfuscator
+    PositionObfuscator obfuscator;
     // All event connections are automatically cut on destruction.
     struct
     {

=== added file 'src/location_service/com/ubuntu/location/service/position_obfuscator.cpp'
--- src/location_service/com/ubuntu/location/service/position_obfuscator.cpp	1970-01-01 00:00:00 +0000
+++ src/location_service/com/ubuntu/location/service/position_obfuscator.cpp	2016-04-27 10:14:29 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alberto Mardegan <[e-mail]>
+ */
+
+#include <com/ubuntu/location/service/position_obfuscator.h>
+
+#include <com/ubuntu/location/logging.h>
+
+namespace cul = com::ubuntu::location;
+namespace culs = com::ubuntu::location::service;
+
+culs::PositionObfuscator::PositionObfuscator(const culs::PositionObfuscator::Configuration& configuration)
+    : config(configuration)
+{
+}
+
+culs::PositionObfuscator::~PositionObfuscator()
+{
+}
+
+void culs::PositionObfuscator::apply_age(cul::Optional<cul::Update<cul::Position>>& optional_update) const
+{
+    if (!optional_update) return;
+
+    auto update = optional_update.get();
+    auto aged_update = cul::Update<cul::Position>(update.value);
+
+    std::chrono::duration<double> age = aged_update.when - update.when;
+    double meters_covered = age.count() * config.moving_speed;
+    double final_accuracy = meters_covered +
+        (update.value.accuracy.horizontal ? update.value.accuracy.horizontal.get().value() : 0);
+    if (final_accuracy > config.minimum_accuracy)
+    {
+        // this would be a meaningless update, let's just skip it
+        VLOG(10) << "Discarding update due to low accuracy after aging: " << update;
+        optional_update = cul::Optional<cul::Update<cul::Position>>{};
+        return;
+    }
+
+    aged_update.value.accuracy.horizontal =
+        cul::Position::Accuracy::Horizontal(final_accuracy * cul::units::Meters);
+
+    // similar treatment for vertical accuracy
+    if (update.value.altitude)
+    {
+        final_accuracy = meters_covered +
+            (update.value.accuracy.vertical ? update.value.accuracy.vertical.get().value() : 0);
+        aged_update.value.accuracy.vertical =
+            cul::Position::Accuracy::Vertical(final_accuracy * cul::units::Meters);
+
+    }
+
+    optional_update = aged_update;
+}

=== added file 'src/location_service/com/ubuntu/location/service/position_obfuscator.h'
--- src/location_service/com/ubuntu/location/service/position_obfuscator.h	1970-01-01 00:00:00 +0000
+++ src/location_service/com/ubuntu/location/service/position_obfuscator.h	2016-04-27 10:14:29 +0000
@@ -0,0 +1,74 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alberto Mardegan <[e-mail]>
+ */
+
+#ifndef LOCATION_SERVICE_COM_UBUNTU_LOCATION_SERVICE_POSITION_OBFUSCATOR_H_
+#define LOCATION_SERVICE_COM_UBUNTU_LOCATION_SERVICE_POSITION_OBFUSCATOR_H_
+
+#include <com/ubuntu/location/optional.h>
+#include <com/ubuntu/location/position.h>
+#include <com/ubuntu/location/update.h>
+
+namespace com
+{
+namespace ubuntu
+{
+namespace location
+{
+namespace service
+{
+/** @brief Tranform location updates based on age and client's permissions.
+ *
+ * @note Obfuscating the user location based on the client's permissions
+ * is not currently implemented.
+ */
+class PositionObfuscator
+{
+public:
+
+    /** @brief Configuration encapsulates all creation time options of class Harvester */
+    struct Configuration
+    {
+        /** Estimated speed, in m/s; the accuracy of a position update will be
+         * decreased according to this speed.
+         */
+        double moving_speed { 250 }; /* 900km/h, cruising speed of a plane */
+
+        /** Minimum accuracy, in metres: if the accuracy falls below this value,
+         * no position update will be reported.
+         */
+        int minimum_accuracy { 5000 * 1000 }; /* 5000 km */
+    };
+
+    /** @brief Creates a new instance based on the given configuration. */
+    PositionObfuscator(const Configuration& configuration);
+
+    /** @brief Frees all resources held by the instance. */
+    virtual ~PositionObfuscator();
+
+    /** @brief Decrease the accuracy of the given update based on its age. */
+    void apply_age(Optional<Update<Position>>& optional_update) const;
+
+private:
+    Configuration config;
+};
+}
+}
+}
+}
+
+#endif // LOCATION_SERVICE_COM_UBUNTU_LOCATION_SERVICE_POSITION_OBFUSCATOR_H_

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2016-03-31 10:15:53 +0000
+++ tests/CMakeLists.txt	2016-04-27 10:14:29 +0000
@@ -79,6 +79,7 @@
 LOCATION_SERVICE_ADD_TEST(default_permission_manager_test default_permission_manager_test.cpp)
 LOCATION_SERVICE_ADD_TEST(engine_test engine_test.cpp)
 LOCATION_SERVICE_ADD_TEST(harvester_test harvester_test.cpp)
+LOCATION_SERVICE_ADD_TEST(obfuscator_test obfuscator_test.cpp)
 LOCATION_SERVICE_ADD_TEST(demultiplexing_reporter_test demultiplexing_reporter_test.cpp)
 LOCATION_SERVICE_ADD_TEST(time_based_update_policy_test time_based_update_policy_test.cpp)
 

=== modified file 'tests/acceptance_tests.cpp'
--- tests/acceptance_tests.cpp	2016-03-11 13:51:03 +0000
+++ tests/acceptance_tests.cpp	2016-04-27 10:14:29 +0000
@@ -206,6 +206,8 @@
     {120. * cul::units::Degrees},
     timestamp
 };
+
+culs::PositionObfuscator::Configuration obfuscator_config;
 } // namespace
 
 TEST_F(LocationServiceStandalone, SessionsReceiveUpdatesViaDBus)
@@ -248,7 +250,8 @@
             {
                 cul::connectivity::platform_default_manager(),
                 std::make_shared<NullReporter>()
-            }
+            },
+            obfuscator_config,
         };
         auto location_service = std::make_shared<cul::service::Implementation>(configuration);
 
@@ -370,7 +373,8 @@
             {
                 cul::connectivity::platform_default_manager(),
                 std::make_shared<NullReporter>()
-            }
+            },
+            obfuscator_config,
         };
         configuration.engine->configuration.engine_state = cul::Engine::Status::on;
         auto location_service = std::make_shared<cul::service::Implementation>(configuration);
@@ -451,7 +455,8 @@
             {
                 cul::connectivity::platform_default_manager(),
                 std::make_shared<NullReporter>()
-            }
+            },
+            obfuscator_config,
         };
         configuration.engine->configuration.satellite_based_positioning_state.set(cul::SatelliteBasedPositioningState::on);
         auto location_service = std::make_shared<cul::service::Implementation>(configuration);
@@ -531,7 +536,8 @@
             {
                 cul::connectivity::platform_default_manager(),
                 std::make_shared<NullReporter>()
-            }
+            },
+            obfuscator_config,
         };
         auto location_service = std::make_shared<cul::service::Implementation>(configuration);
 
@@ -619,7 +625,8 @@
             {
                 cul::connectivity::platform_default_manager(),
                 std::make_shared<NullReporter>()
-            }
+            },
+            obfuscator_config,
         };
         auto location_service = std::make_shared<cul::service::Implementation>(configuration);
 
@@ -699,7 +706,8 @@
             {
                 cul::connectivity::platform_default_manager(),
                 std::make_shared<NullReporter>()
-            }
+            },
+            obfuscator_config,
         };
         auto location_service = std::make_shared<cul::service::Implementation>(configuration);
 
@@ -761,7 +769,11 @@
         if (t.joinable())
             t.join();
 
-        EXPECT_EQ(reference_position_update, position);
+        EXPECT_TRUE(position.when >= reference_position_update.when);
+        /* Clear the accuracy, since it has been altered by the obfuscator. */
+        cul::Position expectedPosition = reference_position_update.value;
+        expectedPosition.accuracy = position.value.accuracy = cul::Position::Accuracy();
+        EXPECT_EQ(expectedPosition, position.value);
 
         return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
     };

=== added file 'tests/obfuscator_test.cpp'
--- tests/obfuscator_test.cpp	1970-01-01 00:00:00 +0000
+++ tests/obfuscator_test.cpp	2016-04-27 10:14:29 +0000
@@ -0,0 +1,101 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alberto Mardegan <[e-mail]>
+ */
+
+#include <com/ubuntu/location/service/position_obfuscator.h>
+
+#include <gtest/gtest.h>
+
+namespace cul = com::ubuntu::location;
+namespace culs = com::ubuntu::location::service;
+typedef cul::Optional<cul::Update<cul::Position>> OptionalUpdate;
+
+TEST(Obfuscator, aging_no_update)
+{
+    using namespace ::testing;
+
+    culs::PositionObfuscator::Configuration config;
+    culs::PositionObfuscator obfuscator(config);
+
+    OptionalUpdate empty_update;
+    EXPECT_FALSE(empty_update);
+
+    obfuscator.apply_age(empty_update);
+    EXPECT_FALSE(empty_update);
+}
+
+TEST(Obfuscator, aging_still_valid)
+{
+    using namespace ::testing;
+
+    culs::PositionObfuscator::Configuration config;
+    config.moving_speed = 10.0;
+    config.minimum_accuracy = 10000;
+
+    culs::PositionObfuscator obfuscator(config);
+
+    auto test_time = cul::Clock::now();
+    cul::Update<cul::Position> update
+    {
+        {
+            cul::wgs84::Latitude{9. * cul::units::Degrees},
+            cul::wgs84::Longitude{53. * cul::units::Degrees},
+            cul::wgs84::Altitude{-2. * cul::units::Meters},
+            12 * cul::units::Meters,
+            9 * cul::units::Meters
+        },
+        test_time - std::chrono::seconds(100),
+    };
+
+    OptionalUpdate optional = update;
+    obfuscator.apply_age(optional);
+
+    EXPECT_TRUE(bool(optional));
+    cul::Update<cul::Position> aged_update = optional.get();
+
+    /* Make sure that the time has been updated since the original update */
+    EXPECT_TRUE(aged_update.when >= test_time);
+
+    /* Check that the accuracy is the one we would expect */
+    EXPECT_EQ(1012, int(aged_update.value.accuracy.horizontal.get() / cul::units::Meters));
+    EXPECT_EQ(1009, int(aged_update.value.accuracy.vertical.get() / cul::units::Meters));
+}
+
+TEST(Obfuscator, aging_too_inaccurate)
+{
+    using namespace ::testing;
+
+    culs::PositionObfuscator::Configuration config;
+    config.moving_speed = 1000.1;
+    config.minimum_accuracy = 100000;
+
+    culs::PositionObfuscator obfuscator(config);
+
+    cul::Update<cul::Position> update
+    {
+        {
+            cul::wgs84::Latitude{9. * cul::units::Degrees},
+            cul::wgs84::Longitude{53. * cul::units::Degrees},
+            cul::wgs84::Altitude{-2. * cul::units::Meters}
+        },
+        cul::Clock::now() - std::chrono::seconds(100),
+    };
+
+    OptionalUpdate optional = update;
+    obfuscator.apply_age(optional);
+    EXPECT_FALSE(optional);
+}