Merge lp:~gary-lasker/software-center/recommender-profile-uploads-lp944693 into lp:software-center

[Gary Lasker]

This branch implements the fix for bug 944693. A timed check is added that is set to run 45 seconds after each startup of Software Center (this purpose of the delay is to avoid impacting startup time). The current profile (list of installed apps) is compared to the previous uploaded profile, and if they differ the new profile data is uploaded to the recommender service. If the profile is found to be unchanged since the previous upload, the server upload is skipped.

[lp:~gary-lasker/software-center/recommender-profile-uploads-lp944693]

2920. By Gary Lasker on 2012-04-02

update unit test for the changed submit-profile-finished call

[Michael Vogt (mvo)]

Thanks, that looks good and works nicely!

Reading the comment about that we should use a singleton made me think a bit and I would like to
propose some tweaks where we might get away without having to use one. But I will ask you for review
on this approach once I added code for it.

review: Approve

[Gary Lasker (gary-lasker)]

Thanks Michael, that sounds great! I definitely also prefer we only use a single agent object instance, even if we don't enforce it as a singleton (which really should not be necessary). I appreciate your help with this and look forward to seeing your branch!

[lp:~gary-lasker/software-center/recommender-profile-uploads-lp944693]

2921. By Gary Lasker on 2012-04-02

merged lp:~mvo/software-center/recagent-almost-singleton, very nice improvements, many thanks Michael

=== modified file 'softwarecenter/backend/recagent.py'
--- softwarecenter/backend/recagent.py	2012-03-19 17:08:56 +0000
+++ softwarecenter/backend/recagent.py	2012-04-02 16:58:19 +0000
@@ -21,6 +21,7 @@
 
 from gi.repository import GObject
 import logging
+import hashlib
 
 import softwarecenter.paths
 from spawn_helper import SpawnHelper
@@ -45,7 +46,7 @@
                    ),
         "submit-profile-finished": (GObject.SIGNAL_RUN_LAST,
                                     GObject.TYPE_NONE,
-                                    (GObject.TYPE_PYOBJECT, str),
+                                    (GObject.TYPE_PYOBJECT,),
                                    ),
         "submit-anon-profile-finished": (GObject.SIGNAL_RUN_LAST,
                                          GObject.TYPE_NONE,
@@ -76,7 +77,6 @@
     def __init__(self, xid=None):
         GObject.GObject.__init__(self)
         self.xid = xid
-        self.recommender_uuid = self._get_recommender_uuid()
 
     def query_server_status(self):
         # build the command
@@ -88,29 +88,76 @@
         spawner.run_generic_piston_helper(
             "SoftwareCenterRecommenderAPI", "server_status")
 
+    def _calc_profile_id(self, profile):
+        """ Return a profile id (md5 hash of a profile) for the given profile
+        """
+        return hashlib.md5(str(profile)).hexdigest()
+
+    @property
+    def recommender_uuid(self):
+        config = get_config()
+        if config.has_option("general", "recommender_uuid"):
+            recommender_uuid = config.get("general",
+                                          "recommender_uuid")
+        else:
+            recommender_uuid = ""
+        return recommender_uuid
+
+    @property
+    def recommender_profile_id(self):
+        config = get_config()
+        if config.has_option("general", "recommender_profile_id"):
+            recommender_profile_id = config.get("general",
+                                                "recommender_profile_id")
+        else:
+            recommender_profile_id = ""
+        return recommender_profile_id
+
+    def _set_recommender_profile_id(self, profile_id):
+        config = get_config()
+        if not config.has_section("general"):
+            config.add_section("general")
+        config.set("general", "recommender_profile_id", profile_id)
+
+    def _set_recommender_uuid(self, uuid):
+        config = get_config()
+        if not config.has_section("general"):
+            config.add_section("general")
+        config.set("general", "recommender_uuid", uuid)
+
     def post_submit_profile(self, db):
         """ This will post the users profile to the recommender server
             and also generate the UUID for the user if that is not
             there yet
         """
-        # if we have not already set a recommender UUID, now is the time
-        # to do it
-        if not self.recommender_uuid:
-            self.recommender_uuid = get_uuid()
+        recommender_uuid = self.recommender_uuid
+        if not recommender_uuid:
+            # generate a new uuid, but do not save it yet, this will
+            # be done later in _on_submit_profile_data
+            recommender_uuid = get_uuid()
         installed_pkglist = [app.pkgname
                              for app in get_installed_apps_list(db)]
-        data = self._generate_submit_profile_data(self.recommender_uuid,
-                                                  installed_pkglist)
-        # build the command
-        spawner = SpawnHelper()
-        spawner.parent_xid = self.xid
-        spawner.needs_auth = True
-        spawner.connect("data-available", self._on_submit_profile_data)
-        spawner.connect("error", lambda spawner, err: self.emit("error", err))
-        spawner.run_generic_piston_helper(
-            "SoftwareCenterRecommenderAPI",
-            "submit_profile",
-            data=data)
+        profile = self._generate_submit_profile_data(recommender_uuid,
+                                                     installed_pkglist)
+
+        # compare profiles to see if there has been a change, and if there
+        # has, do the profile update
+        current_recommender_profile_id = self._calc_profile_id(profile)
+        if current_recommender_profile_id != self.recommender_profile_id:
+            LOG.info("Submitting recommendations profile to the server")
+            self._set_recommender_profile_id(current_recommender_profile_id)
+            # build the command and upload the profile
+            spawner = SpawnHelper()
+            spawner.parent_xid = self.xid
+            spawner.needs_auth = True
+            spawner.connect("data-available", self._on_submit_profile_data,
+                            recommender_uuid)
+            spawner.connect(
+                "error", lambda spawner, err: self.emit("error", err))
+            spawner.run_generic_piston_helper(
+                "SoftwareCenterRecommenderAPI",
+                "submit_profile",
+                data=profile)
 
     def post_submit_anon_profile(self, uuid, installed_packages, extra):
         # build the command
@@ -188,7 +235,9 @@
             return False
 
     def opt_out(self):
-        self.recommender_uuid = ""
+        config = get_config()
+        config.set("general", "recommender_uuid", "")
+        config.set("general", "recommender_profile_id", "")
 
     def _on_server_status_data(self, spawner, piston_server_status):
         self.emit("server-status", piston_server_status)
@@ -196,13 +245,14 @@
     def _on_profile_data(self, spawner, piston_profile):
         self.emit("profile", piston_profile)
 
-    def _on_submit_profile_data(self, spawner, piston_submit_profile):
+    def _on_submit_profile_data(self, spawner, piston_submit_profile,
+                                recommender_uuid):
+        self._set_recommender_uuid(recommender_uuid)
         self.emit("submit-profile-finished",
-                  piston_submit_profile,
-                  self.recommender_uuid)
+                  piston_submit_profile)
 
     def _on_submit_anon_profile_data(self, spawner,
-        piston_submit_anon_profile):
+                                     piston_submit_anon_profile):
         self.emit("submit-anon_profile", piston_submit_anon_profile)
 
     def _on_recommend_me_data(self, spawner, piston_me_apps):
@@ -217,18 +267,6 @@
     def _on_recommend_top_data(self, spawner, piston_top_apps):
         self.emit("recommend-top", piston_top_apps)
 
-    def _get_recommender_uuid(self):
-        """ returns the recommender UUID value, which can be empty if it
-            has not yet been set (indicating that the user has not yet
-            opted-in to the recommender service)
-        """
-        config = get_config()
-        if config.has_option("general", "recommender_uuid"):
-            recommender_uuid = config.get("general", "recommender_uuid")
-            if recommender_uuid:
-                return recommender_uuid
-        return ""
-
     def _generate_submit_profile_data(self, recommender_uuid, package_list):
         submit_profile_data = [{
             'uuid': recommender_uuid,
 
=== modified file 'softwarecenter/ui/gtk3/app.py'
--- softwarecenter/ui/gtk3/app.py	2012-03-23 09:45:35 +0000
+++ softwarecenter/ui/gtk3/app.py	2012-04-02 16:58:19 +0000
@@ -97,6 +97,7 @@
 from softwarecenter.config import get_config
 from softwarecenter.backend import get_install_backend
 from softwarecenter.backend.login_sso import get_sso_backend
+from softwarecenter.backend.recagent import RecommenderAgent
 
 from softwarecenter.backend.channel import AllInstalledChannel
 from softwarecenter.backend.reviews import get_review_loader, UsefulnessCache
@@ -269,7 +270,6 @@
         self.scagent = None
         self.sso = None
         self.available_for_me_query = None
-        self.recommender_uuid = ""
 
         Gtk.Window.set_default_icon_name("softwarecenter")
 
@@ -414,6 +414,10 @@
         # keep the cache clean
         GObject.timeout_add_seconds(15, self._run_expunge_cache_helper)
 
+        # check to see if a new recommendations profile upload is
+        # needed and upload if necessary
+        GObject.timeout_add_seconds(45, self._upload_recommendations_profile)
+
         # TODO: Remove the following two lines once we have remove repository
         #       support in aptdaemon (see LP: #723911)
         self.menu_file.remove(self.menuitem_deauthorize_computer)
@@ -493,9 +497,8 @@
 
     def on_available_pane_created(self, widget):
         self.available_pane.searchentry.grab_focus()
-        rec_panel = self.available_pane.cat_view.recommended_for_you_panel
         self._update_recommendations_menuitem(
-                        opted_in=rec_panel.recommender_agent.is_opted_in())
+                        opted_in=self._get_recommender_agent().is_opted_in())
         # connect a signal to monitor the recommendations opt-in state and
         # persist the recommendations uuid on an opt-in
         self.available_pane.cat_view.recommended_for_you_panel.connect(
@@ -509,14 +512,10 @@
     #~ def on_installed_pane_created(self, widget):
         #~ pass
 
-    def _on_recommendations_opt_in(self, rec_panel, recommender_uuid):
-        self.recommender_uuid = recommender_uuid
+    def _on_recommendations_opt_in(self, rec_panel):
         self._update_recommendations_menuitem(opted_in=True)
 
     def _on_recommendations_opt_out(self, rec_panel):
-        # if the user opts back out of the recommender service, we
-        # reset the recommender UUID to indicate it
-        self.recommender_uuid = ""
         self._update_recommendations_menuitem(opted_in=False)
 
     def _update_recommendations_menuitem(self, opted_in):
@@ -527,6 +526,16 @@
             self.menuitem_recommendations.set_label(
                                             _(u"Turn On Recommendations…"))
 
+    def _upload_recommendations_profile(self):
+        recommender_agent = self._get_recommender_agent()
+        if recommender_agent.is_opted_in():
+            recommender_agent.post_submit_profile(self.db)
+
+    def _get_recommender_agent(self):
+        if not hasattr(self, "_recommender_agent"):
+            self._recommender_agent = RecommenderAgent()
+        return self._recommender_agent
+
     def _on_update_software_center_agent_finished(self, pid, condition):
         LOG.info("software-center-agent finished with status %i" %
             os.WEXITSTATUS(condition))
@@ -780,7 +789,7 @@
 
     def on_menuitem_recommendations_activate(self, menu_item):
         rec_panel = self.available_pane.cat_view.recommended_for_you_panel
-        if rec_panel.recommender_agent.is_opted_in():
+        if self._get_recommender_agent().is_opted_in():
             rec_panel.opt_out_of_recommendations_service()
         else:
             # build and show the opt-in dialog
@@ -1294,9 +1303,6 @@
         else:
             # initial default state is to add to launcher, per spec
             self.available_pane.add_to_launcher_enabled = True
-        if self.config.has_option("general", "recommender_uuid"):
-            self.recommender_uuid = self.config.get("general",
-                                                    "recommender_uuid")
 
     def save_state(self):
         LOG.debug("save_state")
@@ -1318,9 +1324,13 @@
             self.config.set("general", "add_to_launcher", "True")
         else:
             self.config.set("general", "add_to_launcher", "False")
+        # store the recommender values
         self.config.set("general",
                         "recommender_uuid",
-                        self.recommender_uuid)
+                        self._get_recommender_agent().recommender_uuid)
+        self.config.set("general",
+                        "recommender_profile_id",
+                        self._get_recommender_agent().recommender_profile_id)
         self.config.write()
 
     def run(self, args):
 
=== modified file 'softwarecenter/ui/gtk3/widgets/recommendations.py'
--- softwarecenter/ui/gtk3/widgets/recommendations.py	2012-03-20 10:28:51 +0000
+++ softwarecenter/ui/gtk3/widgets/recommendations.py	2012-04-02 16:58:19 +0000
@@ -129,7 +129,7 @@
     __gsignals__ = {
         "recommendations-opt-in": (GObject.SIGNAL_RUN_LAST,
                                    GObject.TYPE_NONE,
-                                   (GObject.TYPE_STRING,),
+                                   (),
                                   ),
         "recommendations-opt-out": (GObject.SIGNAL_RUN_LAST,
                                     GObject.TYPE_NONE,
@@ -202,13 +202,7 @@
         self.remove_more_button()
         self.show_all()
         self.emit("recommendations-opt-out")
-        try:
-            self.recommender_agent.disconnect_by_func(
-                self._on_profile_submitted)
-            self.recommender_agent.disconnect_by_func(
-                self._on_profile_submitted_error)
-        except TypeError:
-            pass
+        self._disconnect_recommender_listeners()
 
     def _upload_user_profile_and_get_recommendations(self):
         # initiate upload of the user profile here
@@ -222,20 +216,35 @@
                                   self._on_profile_submitted_error)
         self.recommender_agent.post_submit_profile(self.catview.db)
 
-    def _on_profile_submitted(self, agent, profile, recommender_uuid):
+    def _on_profile_submitted(self, agent, profile):
         # after the user profile data has been uploaded, make the request
         # and load the the recommended_for_you content
-        LOG.debug("The recommendations profile has been successfully "
-                  "submitted to the recommender agent")
-        self.emit("recommendations-opt-in", recommender_uuid)
+        LOG.debug("The updated profile was successfully submitted to the "
+                  "recommender service")
+        # only detect the very first profile upload as that indicates
+        # the user's initial opt-in
         self._update_recommended_for_you_content()
+        self._disconnect_recommender_listeners()
+        self.emit("recommendations-opt-in")
 
     def _on_profile_submitted_error(self, agent, msg):
         LOG.warn("Error while submitting the recommendations profile to the "
                  "recommender agent: %s" % msg)
         # TODO: handle this! display an error message in the panel
+        # detect the very first profile upload as that indicates
+        # the user's initial opt-in
+        self._disconnect_recommender_listeners()
         self._hide_recommended_for_you_panel()
 
+    def _disconnect_recommender_listeners(self):
+        try:
+            self.recommender_agent.disconnect_by_func(
+                self._on_profile_submitted)
+            self.recommender_agent.disconnect_by_func(
+                self._on_profile_submitted_error)
+        except TypeError:
+            pass
+
 
 class RecommendationsPanelDetails(RecommendationsPanel):
     """
 
=== modified file 'test/test_recagent.py'
--- test/test_recagent.py	2012-03-20 09:27:18 +0000
+++ test/test_recagent.py	2012-04-02 16:58:19 +0000
@@ -3,7 +3,6 @@
 from gi.repository import GObject
 import unittest
 import os
-import uuid
 
 from mock import patch
 
@@ -40,20 +39,19 @@
         def _patched_on_submit_profile_data(*args, **kwargs):
             piston_submit_profile = {}
             recommender_agent.emit("submit-profile-finished", 
-                                   piston_submit_profile, 
-                                   uuid.uuid1())
+                                   piston_submit_profile)
         mock_spawn_helper_run.side_effect = _patched_on_submit_profile_data
         recommender_agent = RecommenderAgent()
         recommender_agent.connect("submit-profile-finished", self.on_query_done)
         recommender_agent.connect("error", self.on_query_error)
+        recommender_agent._calc_profile_id = lambda profile: "i-am-random"
         db = get_test_db()
         recommender_agent.post_submit_profile(db)
         self.assertFalse(self.error)
         args, kwargs =  mock_spawn_helper_run.call_args
-        self.assertNotEqual(kwargs['data'][0]['uuid'], None)
         self.assertNotEqual(kwargs['data'][0]['package_list'], [])
 
-    def on_query_done(self, recagent, data, uuid=""):
+    def on_query_done(self, recagent, data):
         print "query done, data: '%s'" % data
         self.loop.quit()