Merge lp:~free.ekanayaka/landscape-client/drop-provisioning-registration-2 into lp:~landscape/landscape-client/trunk

[Free Ekanayaka]

Drop unused provisioning registration code.

Drop unused provisioning registration code.

[Alberto Donato (ack)]

Nice cleanup, +1

review: Approve

[Chris Glass (tribaal)]

Nice, thanks fro dropping that.

review: Approve

=== modified file 'landscape/broker/config.py'
--- landscape/broker/config.py	2014-07-10 18:51:49 +0000
+++ landscape/broker/config.py	2014-07-18 14:32:52 +0000
@@ -32,7 +32,6 @@
               - C{urgent_exchange_interval} (C{1*60})
               - C{http_proxy}
               - C{https_proxy}
-              - C{provisioning_otp}
         """
         parser = super(BrokerConfiguration, self).make_parser()
 
@@ -63,8 +62,6 @@
         parser.add_option("--tags",
                           help="Comma separated list of tag names to be sent "
                                "to the server.")
-        parser.add_option("--provisioning-otp", default="",
-                          help="The OTP to use for a provisioned machine.")
 
         return parser
 

=== modified file 'landscape/broker/registration.py'
--- landscape/broker/registration.py	2014-07-16 09:59:28 +0000
+++ landscape/broker/registration.py	2014-07-18 14:32:52 +0000
@@ -107,9 +107,6 @@
         if id.secure_id:
             return False
 
-        if self._config.provisioning_otp:
-            return self._message_store.accepts("register-provisioned-machine")
-
         return bool(id.computer_title and id.account_name
                     and self._message_store.accepts("register"))
 
@@ -134,13 +131,6 @@
             return None
         self._juju_data = juju_info  # A list of dicts
 
-    def _get_data(self, path, accumulate):
-        """
-        Get data at C{path} on the EC2 API endpoint, and add the result to the
-        C{accumulate} list.
-        """
-        return self._fetch_async(EC2_API + path).addCallback(accumulate.append)
-
     def _handle_exchange_done(self):
         """Registered handler for the C{"exchange-done"} event.
 
@@ -158,13 +148,7 @@
         An exchange is about to happen.  If we don't have a secure id already
         set, and we have the needed information available, queue a registration
         message with the server.
-
-        A computer can fall into several categories:
-            - a "normal" computer
-            - a "provisionned machine".
         """
-        registration_failed = False
-
         # The point of storing this flag is that if we should *not* register
         # now, and then after the exchange we *should*, we schedule an urgent
         # exchange again.  Without this flag we would just spin trying to
@@ -177,6 +161,11 @@
         # These are just to shorten the code.
         identity = self._identity
         account_name = identity.account_name
+
+        if not account_name:
+            self._reactor.fire("registration-failed")
+            return
+
         tags = identity.tags
         group = identity.access_group
         registration_key = identity.registration_key
@@ -187,51 +176,34 @@
             tags = None
             logging.error("Invalid tags provided for registration.")
 
-        message = {"type": None,  # either "register" or "register-cloud-vm"
+        message = {"type": "register",
                    "hostname": get_fqdn(),
-                   "account_name": identity.account_name,
-                   "registration_password": None,
+                   "account_name": account_name,
+                   "computer_title": identity.computer_title,
+                   "registration_password": identity.registration_key,
                    "tags": tags,
+                   "container-info": get_container_info(),
                    "vm-info": get_vm_info()}
 
         if group:
             message["access_group"] = group
 
-        if account_name:
-            # The computer is a normal computer, possibly a container.
-            with_word = "with" if bool(registration_key) else "without"
-            with_tags = "and tags %s " % tags if tags else ""
-            with_group = "in access group '%s' " % group if group else ""
-
-            logging.info(u"Queueing message to register with account %r %s%s"
-                         "%s a password." % (account_name, with_group,
-                                             with_tags, with_word))
-            message["type"] = "register"
-            message["computer_title"] = identity.computer_title
-            message["registration_password"] = identity.registration_key
-            message["container-info"] = get_container_info()
-
-            if self._juju_data is not None:
-                # For backwards compatibility, set the juju-info to be one of
-                # the juju infos (it used not to be a list).
-                message["juju-info"] = self._juju_data[0]
-                message["juju-info-list"] = self._juju_data
-
-        elif self._config.provisioning_otp:
-            # This is a newly provisionned machine.
-            # In this case message is overwritten because it's much simpler
-            logging.info(u"Queueing message to register with OTP as a"
-                         u" newly provisioned machine.")
-            message = {"type": "register-provisioned-machine",
-                       "otp": self._config.provisioning_otp}
-        else:
-            registration_failed = True
-
-        if registration_failed:
-            self._reactor.fire("registration-failed")
-        else:
-            logging.info("Sending registration message to exchange.")
-            self._exchange.send(message)
+        if self._juju_data is not None:
+            # For backwards compatibility, set the juju-info to be one of
+            # the juju infos (it used not to be a list).
+            message["juju-info"] = self._juju_data[0]
+            message["juju-info-list"] = self._juju_data
+
+        # The computer is a normal computer, possibly a container.
+        with_word = "with" if bool(registration_key) else "without"
+        with_tags = "and tags %s " % tags if tags else ""
+        with_group = "in access group '%s' " % group if group else ""
+
+        logging.info(
+            u"Queueing message to register with account %r %s%s"
+            "%s a password." % (
+                account_name, with_group, with_tags, with_word))
+        self._exchange.send(message)
 
     def _handle_set_id(self, message):
         """Registered handler for the C{"set-id"} event.

=== modified file 'landscape/broker/tests/test_registration.py'
--- landscape/broker/tests/test_registration.py	2014-07-16 09:59:28 +0000
+++ landscape/broker/tests/test_registration.py	2014-07-18 14:32:52 +0000
@@ -161,8 +161,7 @@
         self.assertEqual("register", messages[0]["type"])
         self.assertEqual(self.logfile.getvalue().strip(),
                          "INFO: Queueing message to register with account "
-                         "'account_name' without a password.\n    "
-                         "INFO: Sending registration message to exchange.")
+                         "'account_name' without a password.")
 
     def test_queue_message_on_exchange_with_vm_info(self):
         """
@@ -182,8 +181,7 @@
         self.assertEqual("vmware", messages[0]["vm-info"])
         self.assertEqual(self.logfile.getvalue().strip(),
                          "INFO: Queueing message to register with account "
-                         "'account_name' without a password.\n    "
-                         "INFO: Sending registration message to exchange.")
+                         "'account_name' without a password.")
 
     def test_queue_message_on_exchange_with_lxc_container(self):
         """
@@ -214,8 +212,7 @@
         self.assertEqual("SEKRET", password)
         self.assertEqual(self.logfile.getvalue().strip(),
                          "INFO: Queueing message to register with account "
-                         "'account_name' with a password.\n    "
-                         "INFO: Sending registration message to exchange.")
+                         "'account_name' with a password.")
 
     def test_queue_message_on_exchange_with_tags(self):
         """
@@ -233,8 +230,7 @@
         self.assertEqual(self.logfile.getvalue().strip(),
                          "INFO: Queueing message to register with account "
                          "'account_name' and tags computer,tag with a "
-                         "password.\n    "
-                         "INFO: Sending registration message to exchange.")
+                         "password.")
 
     def test_queue_message_on_exchange_with_invalid_tags(self):
         """
@@ -253,8 +249,7 @@
         self.assertEqual(self.logfile.getvalue().strip(),
                          "ERROR: Invalid tags provided for registration.\n    "
                          "INFO: Queueing message to register with account "
-                         "'account_name' with a password.\n    "
-                         "INFO: Sending registration message to exchange.")
+                         "'account_name' with a password.")
 
     def test_queue_message_on_exchange_with_unicode_tags(self):
         """
@@ -274,8 +269,7 @@
         self.assertEqual(self.logfile.getvalue().strip(),
                          "INFO: Queueing message to register with account "
                          "'account_name' and tags prova\xc4\xb5o "
-                         "with a password.\n    "
-                         "INFO: Sending registration message to exchange.")
+                         "with a password.")
 
     def test_queue_message_on_exchange_with_access_group(self):
         """
@@ -292,8 +286,7 @@
         self.assertEqual(self.logfile.getvalue().strip(),
                          "INFO: Queueing message to register with account "
                          "'account_name' in access group 'dinosaurs' and "
-                         "tags server,london without a password.\n    "
-                         "INFO: Sending registration message to exchange.")
+                         "tags server,london without a password.")
 
     def test_queue_message_on_exchange_with_empty_access_group(self):
         """
@@ -575,40 +568,3 @@
                      "unit-name": "service-2/0",
                      "private-address": "127.0.0.1"}
         self.assertIn(expected2, juju_info)
-
-
-class ProvisioningRegistrationTest(RegistrationHandlerTestBase):
-
-    def test_provisioned_machine_registration_with_otp(self):
-        """
-        Register provisioned machines using an OTP.
-        """
-        self.mstore.set_accepted_types(["register-provisioned-machine"])
-        self.config.account_name = ""
-        self.config.provisioning_otp = "ohteepee"
-        self.reactor.fire("pre-exchange")
-
-        self.assertMessages([{"otp": "ohteepee", "timestamp": 0, "api": "3.2",
-                              "type": "register-provisioned-machine"}],
-                            self.mstore.get_pending_messages())
-        self.assertEqual(u"INFO: Queueing message to register with OTP as a"
-                         u" newly provisioned machine.\n    "
-                         "INFO: Sending registration message to exchange.",
-                         self.logfile.getvalue().strip())
-
-        self.exchanger.exchange()
-        self.assertMessages([{"otp": "ohteepee", "timestamp": 0, "api": "3.2",
-                              "type": "register-provisioned-machine"}],
-                            self.transport.payloads[0]["messages"])
-
-    def test_provisioned_machine_registration_with_empty_otp(self):
-        """
-        No message should be sent when an empty OTP is passed.
-        """
-        self.mstore.set_accepted_types(["register-provisioned-machine"])
-        self.config.account_name = ""
-        self.config.provisioning_otp = ""
-        self.reactor.fire("pre-exchange")
-
-        self.assertMessages([], self.mstore.get_pending_messages())
-        self.assertEqual(u"", self.logfile.getvalue().strip())

=== modified file 'landscape/configuration.py'
--- landscape/configuration.py	2014-07-10 19:16:56 +0000
+++ landscape/configuration.py	2014-07-18 14:32:52 +0000
@@ -472,11 +472,10 @@
 def check_account_name_and_password(config):
     """
     Ensure that silent configurations which plan to start landscape-client are
-    either configured for OTP or have both an account_name and computer title.
+    have both an account_name and computer title.
     """
     if config.silent and not config.no_start:
-        if not (config.get("otp") or config.provisioning_otp or
-                (config.get("account_name") and config.get("computer_title"))):
+        if not (config.get("account_name") and config.get("computer_title")):
             raise ConfigurationError("An account name and computer title are "
                                      "required.")
 

=== modified file 'landscape/message_schemas.py'
--- landscape/message_schemas.py	2014-07-17 06:51:40 +0000
+++ landscape/message_schemas.py	2014-07-18 14:32:52 +0000
@@ -206,6 +206,9 @@
               "access_group"])
 
 
+# XXX The register-provisioned-machine message is obsolete, it's kept around
+# just to not break older LDS releases that import it the last LDS release
+# to have it is 14.07). Eventually it shall be dropped.
 REGISTER_PROVISIONED_MACHINE = Message(
     "register-provisioned-machine",
     {"otp": Bytes()})
@@ -479,12 +482,12 @@
                OPERATION_RESULT, COMPUTER_INFO, DISTRIBUTION_INFO,
                HARDWARE_INVENTORY, HARDWARE_INFO, LOAD_AVERAGE, MEMORY_INFO,
                RESYNCHRONIZE, MOUNT_ACTIVITY, MOUNT_INFO, FREE_SPACE,
-               REGISTER, REGISTER_CLOUD_VM, REGISTER_PROVISIONED_MACHINE,
+               REGISTER,
                TEMPERATURE, PROCESSOR_INFO, USERS, PACKAGES, PACKAGE_LOCKS,
                CHANGE_PACKAGES_RESULT, UNKNOWN_PACKAGE_HASHES,
                ADD_PACKAGES, PACKAGE_REPORTER_RESULT, TEXT_MESSAGE, TEST,
-               CUSTOM_GRAPH, REBOOT_REQUIRED, APT_PREFERENCES, EUCALYPTUS_INFO,
-               EUCALYPTUS_INFO_ERROR, NETWORK_DEVICE, NETWORK_ACTIVITY,
+               CUSTOM_GRAPH, REBOOT_REQUIRED, APT_PREFERENCES,
+               NETWORK_DEVICE, NETWORK_ACTIVITY,
                REBOOT_REQUIRED_INFO, UPDATE_MANAGER_INFO, CPU_USAGE,
                CEPH_USAGE, SWIFT_USAGE, SWIFT_DEVICE_INFO, KEYSTONE_TOKEN,
                CHANGE_HA_SERVICE, JUJU_INFO, JUJU_UNITS_INFO, CLOUD_METADATA]:

=== modified file 'landscape/tests/test_configuration.py'
--- landscape/tests/test_configuration.py	2014-07-10 19:16:56 +0000
+++ landscape/tests/test_configuration.py	2014-07-18 14:32:52 +0000
@@ -820,8 +820,7 @@
                 "--ping-interval", "30",
                 "--http-proxy", "",
                 "--https-proxy", "",
-                "--tags", "",
-                "--provisioning-otp", ""]
+                "--tags", ""]
         config = self.get_config(args)
         setup(config)
         self.assertConfigEqual(
@@ -838,9 +837,7 @@
             "exchange_interval = 900\n"
             "ping_interval = 30\n"
             "ping_url = http://landscape.canonical.com/ping\n"
-            "provisioning_otp = \n"
-            "urgent_exchange_interval = 60\n"
-             % config.data_path)
+            "urgent_exchange_interval = 60\n" % config.data_path)
 
     def test_silent_setup_without_computer_title(self):
         """A computer title is required."""
@@ -860,21 +857,6 @@
         config = self.get_config(["--silent", "-t", "rex"])
         self.assertRaises(ConfigurationError, setup, config)
 
-    def test_silent_setup_with_provisioning_otp(self):
-        """
-        If the provisioning OTP is specified, there is no need to pass the
-        account name and the computer title.
-        """
-        sysvconfig_mock = self.mocker.patch(SysVConfig)
-        sysvconfig_mock.set_start_on_boot(True)
-        sysvconfig_mock.restart_landscape()
-        self.mocker.replay()
-
-        config = self.get_config(["--silent", "--provisioning-otp", "otp1"])
-        setup(config)
-
-        self.assertEqual("otp1", config.provisioning_otp)
-
     def test_silent_script_users_imply_script_execution_plugin(self):
         """
         If C{--script-users} is specified, without C{ScriptExecution} in the