Merge lp:~free.ekanayaka/landscape-client/drop-cloud-registration into lp:~free.ekanayaka/landscape-client/drop-old-juju-info

[Free Ekanayaka]

Drop the cloud registration code and associated tests.

[lp:~free.ekanayaka/landscape-client/drop-cloud-registration]

783. By Free Ekanayaka on 2014-07-17

Address review comments

Unmerged revisions

783. By Free Ekanayaka on 2014-07-17

Address review comments

782. By Free Ekanayaka on 2014-07-16

Add comment

781. By Free Ekanayaka on 2014-07-16

Revert drop-juju-info

780. By Free Ekanayaka on 2014-07-13

Merge from drop-old-juju-info

779. By Free Ekanayaka on 2014-07-13

Merge from drop-old-juju-info

778. By Free Ekanayaka on 2014-07-10

Drop cloud registration

=== removed file 'debian/cloud-default.conf'
--- debian/cloud-default.conf	2009-03-28 19:04:34 +0000
+++ debian/cloud-default.conf	1970-01-01 00:00:00 +0000
@@ -1,7 +0,0 @@
-[client]
-cloud = True
-url = https://landscape.canonical.com/message-system
-data_path = /var/lib/landscape/client
-ping_url = http://landscape.canonical.com/ping
-include_manager_plugins = ScriptExecution
-script_users = ALL
 
=== modified file 'debian/landscape-client.init'
--- debian/landscape-client.init	2012-09-05 15:37:17 +0000
+++ debian/landscape-client.init	2014-07-16 10:26:46 +0000
@@ -31,24 +31,8 @@
     # This $RUN check should match the semantics of
     # l.sysvconfig.SysVConfig.is_configured_to_run.
     if [ $RUN -eq 0 ]; then
-	    if [ $CLOUD -eq 1 ]; then
-		    if landscape-is-cloud-managed; then
-			    # Install the cloud default configuration file
-			    cp /usr/share/landscape/cloud-default.conf /etc/landscape/client.conf
-			    # Override default file for not going in this conditional again at
-			    # next startup
-			    sed -i "s/^RUN=.*/RUN=1/" $LANDSCAPE_DEFAULTS
-			    if ! grep -q "^RUN=" $LANDSCAPE_DEFAULTS; then
-				    echo "RUN=1" >> $LANDSCAPE_DEFAULTS
-			    fi
-		    else
-			    echo "$NAME is not configured, please run landscape-config."
-			    exit 0
-		    fi
-	    else
-		    echo "$NAME is not configured, please run landscape-config."
-		    exit 0
-	    fi
+	echo "$NAME is not configured, please run landscape-config."
+	exit 0
     fi
 }
 
 
=== modified file 'debian/landscape-client.install'
--- debian/landscape-client.install	2013-05-16 09:15:13 +0000
+++ debian/landscape-client.install	2014-07-16 10:26:46 +0000
@@ -7,7 +7,6 @@
 usr/bin/landscape-package-changer
 usr/bin/landscape-package-reporter
 usr/bin/landscape-release-upgrader
-usr/bin/landscape-is-cloud-managed
 usr/bin/landscape-dbus-proxy
 usr/share/landscape/cloud-default.conf
 usr/lib/landscape
 
=== modified file 'landscape/broker/config.py'
--- landscape/broker/config.py	2014-03-25 15:21:52 +0000
+++ landscape/broker/config.py	2014-07-16 10:26:46 +0000
@@ -32,8 +32,6 @@
               - C{urgent_exchange_interval} (C{1*60})
               - C{http_proxy}
               - C{https_proxy}
-              - C{cloud}
-              - C{otp}
               - C{provisioning_otp}
         """
         parser = super(BrokerConfiguration, self).make_parser()
@@ -60,10 +58,6 @@
                           help="The URL of the HTTP proxy, if one is needed.")
         parser.add_option("--https-proxy", metavar="URL",
                           help="The URL of the HTTPS proxy, if one is needed.")
-        parser.add_option("--cloud", action="store_true",
-                          help="Set this if your computer is in an EC2 cloud.")
-        parser.add_option("--otp", default="",
-                          help="The OTP to use in cloud configuration.")
         parser.add_option("--access-group", default="",
                           help="Suggested access group for this computer.")
         parser.add_option("--tags",
 
=== modified file 'landscape/broker/registration.py'
--- landscape/broker/registration.py	2014-07-13 07:19:38 +0000
+++ landscape/broker/registration.py	2014-07-16 10:26:46 +0000
@@ -8,25 +8,16 @@
 credentials yet and that the server accepts registration messages, so it
 will craft an appropriate one and send it out.
 """
-import time
 import logging
-import socket
 
 from twisted.internet.defer import Deferred
 
-from landscape.lib.bpickle import loads
-from landscape.lib.log import log_failure
 from landscape.lib.juju import get_juju_info
-from landscape.lib.fetch import fetch, FetchError
 from landscape.lib.tag import is_valid_tag_list
 from landscape.lib.network import get_fqdn
 from landscape.lib.vm_info import get_vm_info, get_container_info
 
 
-EC2_HOST = "169.254.169.254"
-EC2_API = "http://%s/latest" % (EC2_HOST,)
-
-
 class InvalidCredentialsError(Exception):
     """
     Raised when an invalid account title and/or registration key
@@ -99,7 +90,6 @@
         self._exchange = exchange
         self._pinger = pinger
         self._message_store = message_store
-        self._reactor.call_on("run", self._fetch_ec2_data)
         self._reactor.call_on("run", self._get_juju_data)
         self._reactor.call_on("pre-exchange", self._handle_pre_exchange)
         self._reactor.call_on("exchange-done", self._handle_exchange_done)
@@ -109,21 +99,15 @@
                                         self._handle_registration)
         self._should_register = None
         self._fetch_async = fetch_async
-        self._otp = None
         self._ec2_data = None
         self._juju_data = None
 
     def should_register(self):
         id = self._identity
         if id.secure_id:
-            # We already have a secure ID, no need to register
-            logging.info("Machine already has a secure-id. Skipping "
-                         "registration.")
             return False
 
-        if self._config.cloud:
-            return self._message_store.accepts("register-cloud-vm")
-        elif self._config.provisioning_otp:
+        if self._config.provisioning_otp:
             return self._message_store.accepts("register-provisioned-machine")
 
         return bool(id.computer_title and id.account_name
@@ -157,94 +141,6 @@
         """
         return self._fetch_async(EC2_API + path).addCallback(accumulate.append)
 
-    def _fetch_ec2_data(self):
-        """Retrieve available EC2 information, if in a EC2 compatible cloud."""
-        id = self._identity
-        if self._config.cloud and not id.secure_id:
-            # Fetch data from the EC2 API, to be used later in the registration
-            # process
-            # We ignore errors from user-data because it's common for the
-            # URL to return a 404 when the data is unavailable.
-            ec2_data = []
-            deferred = self._fetch_async(EC2_API + "/user-data").addErrback(
-                log_failure).addCallback(ec2_data.append)
-            paths = [
-                "/meta-data/instance-id",
-                "/meta-data/reservation-id",
-                "/meta-data/local-hostname",
-                "/meta-data/public-hostname",
-                "/meta-data/ami-launch-index",
-                "/meta-data/ami-id",
-                "/meta-data/local-ipv4",
-                "/meta-data/public-ipv4"]
-            # We're not using a DeferredList here because we want to keep the
-            # number of connections to the backend minimal. See lp:567515.
-            for path in paths:
-                deferred.addCallback(
-                    lambda ignore, path=path: self._get_data(path, ec2_data))
-            # Special case the ramdisk retrieval, because it may not be present
-            deferred.addCallback(
-                lambda ignore: self._fetch_async(
-                    EC2_API + "/meta-data/ramdisk-id").addErrback(log_failure))
-            deferred.addCallback(ec2_data.append)
-            # And same for kernel
-            deferred.addCallback(
-                lambda ignore: self._fetch_async(
-                    EC2_API + "/meta-data/kernel-id").addErrback(log_failure))
-            deferred.addCallback(ec2_data.append)
-
-            def record_data(ignore):
-                """Record the instance data returned by the EC2 API."""
-                (raw_user_data, instance_key, reservation_key,
-                 local_hostname, public_hostname, launch_index,
-                 ami_key, local_ip, public_ip, ramdisk_key,
-                 kernel_key) = ec2_data
-                self._ec2_data = {
-                    "instance_key": instance_key,
-                    "reservation_key": reservation_key,
-                    "local_hostname": local_hostname,
-                    "public_hostname": public_hostname,
-                    "launch_index": launch_index,
-                    "kernel_key": kernel_key,
-                    "ramdisk_key": ramdisk_key,
-                    "image_key": ami_key,
-                    "public_ipv4": public_ip,
-                    "local_ipv4": local_ip}
-                for k, v in self._ec2_data.items():
-                    if v is None and k in ("ramdisk_key", "kernel_key"):
-                        continue
-                    self._ec2_data[k] = v.decode("utf-8")
-                self._ec2_data["launch_index"] = int(
-                    self._ec2_data["launch_index"])
-
-                if self._config.otp:
-                    self._otp = self._config.otp
-                    return
-                instance_data = _extract_ec2_instance_data(
-                    raw_user_data, int(launch_index))
-                if instance_data is not None:
-                    self._otp = instance_data["otp"]
-                    exchange_url = instance_data["exchange-url"]
-                    ping_url = instance_data["ping-url"]
-                    self._exchange._transport.set_url(exchange_url)
-                    self._config.url = exchange_url
-                    self._config.ping_url = ping_url
-                    if "ssl-ca-certificate" in instance_data:
-                        from landscape.configuration import \
-                            store_public_key_data
-                        public_key_file = store_public_key_data(
-                            self._config, instance_data["ssl-ca-certificate"])
-                        self._config.ssl_public_key = public_key_file
-                        self._exchange._transport._pubkey = public_key_file
-                    self._config.write()
-
-            def log_error(error):
-                log_failure(error, msg="Got error while fetching meta-data: %r"
-                            % (error.value,))
-
-            deferred.addCallback(record_data)
-            deferred.addErrback(log_error)
-
     def _handle_exchange_done(self):
         """Registered handler for the C{"exchange-done"} event.
 
@@ -264,12 +160,8 @@
         message with the server.
 
         A computer can fall into several categories:
-            - a "cloud VM"
             - a "normal" computer
             - a "provisionned machine".
-
-        Furthermore, Cloud VMs can be registered with either a One Time
-        Password (OTP), or with a normal registration password.
         """
         registration_failed = False
 
@@ -293,10 +185,9 @@
 
         if not is_valid_tag_list(tags):
             tags = None
-            logging.error("Invalid tags provided for cloud registration.")
+            logging.error("Invalid tags provided for registration.")
 
         message = {"type": None,  # either "register" or "register-cloud-vm"
-                   "otp": None,
                    "hostname": get_fqdn(),
                    "account_name": identity.account_name,
                    "registration_password": None,
@@ -306,28 +197,7 @@
         if group:
             message["access_group"] = group
 
-        if self._config.cloud and self._ec2_data is not None:
-            # This is the "cloud VM" case.
-            message["type"] = "register-cloud-vm"
-
-            message.update(self._ec2_data)
-            if self._otp:
-                logging.info("Queueing message to register with OTP")
-                message["otp"] = self._otp
-
-            elif account_name:
-                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"
-                    u"as an EC2 instance." % (
-                        account_name, with_group, with_tags))
-                message["registration_password"] = registration_key
-
-            else:
-                registration_failed = True
-
-        elif account_name:
+        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 ""
@@ -342,6 +212,9 @@
             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:
@@ -430,80 +303,3 @@
     def _failed(self):
         self.deferred.errback(InvalidCredentialsError())
         self._cancel_calls()
-
-
-def _extract_ec2_instance_data(raw_user_data, launch_index):
-    """
-    Given the raw string of EC2 User Data, parse it and return the dict of
-    instance data for this particular instance.
-
-    If the data can't be parsed, a debug message will be logged and None
-    will be returned.
-    """
-    try:
-        user_data = loads(raw_user_data)
-    except ValueError:
-        logging.debug("Got invalid user-data %r" % (raw_user_data,))
-        return
-
-    if not isinstance(user_data, dict):
-        logging.debug("user-data %r is not a dict" % (user_data,))
-        return
-    for key in "otps", "exchange-url", "ping-url":
-        if key not in user_data:
-            logging.debug("user-data %r doesn't have key %r."
-                          % (user_data, key))
-            return
-    if len(user_data["otps"]) <= launch_index:
-        logging.debug("user-data %r doesn't have OTP for launch index %d"
-                      % (user_data, launch_index))
-        return
-    instance_data = {"otp": user_data["otps"][launch_index],
-                     "exchange-url": user_data["exchange-url"],
-                     "ping-url": user_data["ping-url"]}
-    if "ssl-ca-certificate" in user_data:
-        instance_data["ssl-ca-certificate"] = user_data["ssl-ca-certificate"]
-    return instance_data
-
-
-def _wait_for_network():
-    """
-    Keep trying to connect to the EC2 metadata server until it becomes
-    accessible or until five minutes pass.
-
-    This is necessary because the networking init script on Ubuntu is
-    asynchronous; the network may not actually be up by the time the
-    landscape-client init script is invoked.
-    """
-    timeout = 5 * 60
-    port = 80
-
-    start = time.time()
-    while True:
-        s = socket.socket()
-        try:
-            s.connect((EC2_HOST, port))
-            s.close()
-            return
-        except socket.error:
-            time.sleep(1)
-            if time.time() - start > timeout:
-                break
-
-
-def is_cloud_managed(fetch=fetch):
-    """
-    Return C{True} if the machine has been started by Landscape, i.e. if we can
-    find the expected data inside the EC2 user-data field.
-    """
-    _wait_for_network()
-    try:
-        raw_user_data = fetch(EC2_API + "/user-data",
-                              connect_timeout=5)
-        launch_index = fetch(EC2_API + "/meta-data/ami-launch-index",
-                             connect_timeout=5)
-    except FetchError:
-        return False
-    instance_data = _extract_ec2_instance_data(
-        raw_user_data, int(launch_index))
-    return instance_data is not None
 
=== modified file 'landscape/broker/tests/test_registration.py'
--- landscape/broker/tests/test_registration.py	2014-07-13 07:01:19 +0000
+++ landscape/broker/tests/test_registration.py	2014-07-16 10:26:46 +0000
@@ -1,24 +1,15 @@
 import json
-import os
 import logging
-import pycurl
 import socket
 
-from twisted.internet.defer import succeed, fail
-
 from landscape.broker.registration import (
-    InvalidCredentialsError, RegistrationHandler, is_cloud_managed, EC2_HOST,
-    EC2_API, Identity)
+    InvalidCredentialsError, Identity)
 
-from landscape.broker.config import BrokerConfiguration
 from landscape.tests.helpers import LandscapeTest
 from landscape.broker.tests.helpers import (
     BrokerConfigurationHelper, RegistrationHelper)
-from landscape.lib.bpickle import dumps
-from landscape.lib.fetch import HTTPCodeError, FetchError
 from landscape.lib.persist import Persist
 from landscape.lib.vm_info import get_vm_info
-from landscape.configuration import print_text
 
 
 class IdentityTest(LandscapeTest):
@@ -250,8 +241,7 @@
         If the admin has defined tags for this computer, but they are not
         valid, we drop them, and report an error.
         """
-        self.log_helper.ignore_errors("Invalid tags provided for cloud "
-                                      "registration")
+        self.log_helper.ignore_errors("Invalid tags provided for registration")
         self.mstore.set_accepted_types(["register"])
         self.config.computer_title = "Computer Title"
         self.config.account_name = "account_name"
@@ -261,8 +251,7 @@
         messages = self.mstore.get_pending_messages()
         self.assertIs(None, messages[0]["tags"])
         self.assertEqual(self.logfile.getvalue().strip(),
-                         "ERROR: Invalid tags provided for cloud "
-                         "registration.\n    "
+                         "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.")
@@ -536,6 +525,23 @@
                     "unit-name": "service/0"}
         self.assertEqual(expected, messages[0]["juju-info-list"][0])
 
+    def test_juju_info_compatibility_present(self):
+        """
+        When Juju information is found in $data_dir/juju-info.d/*.json,
+        the registration message also contains a "juju-info" key for
+        backwards compatibility with older servers.
+        """
+        self.mstore.set_accepted_types(["register"])
+        self.config.account_name = "account_name"
+        self.reactor.fire("run")
+        self.reactor.fire("pre-exchange")
+
+        messages = self.mstore.get_pending_messages()
+        expected = {"environment-uuid": "DEAD-BEEF",
+                    "api-addresses": ["10.0.3.1:17070"],
+                    "unit-name": "service/0"}
+        self.assertEqual(expected, messages[0]["juju-info"])
+
     def test_multiple_juju_information_added_when_present(self):
         """
         When Juju information is found in $data_dir/juju-info.json,
@@ -571,661 +577,6 @@
         self.assertIn(expected2, juju_info)
 
 
-class CloudRegistrationHandlerTest(RegistrationHandlerTestBase):
-
-    cloud = True
-
-    def setUp(self):
-        super(CloudRegistrationHandlerTest, self).setUp()
-        self.query_results = {}
-
-        def fetch_stub(url):
-            value = self.query_results[url]
-            if isinstance(value, Exception):
-                return fail(value)
-            else:
-                return succeed(value)
-
-        self.fetch_func = fetch_stub
-
-    def get_user_data(self, otps=None,
-                      exchange_url="https://example.com/message-system",
-                      ping_url="http://example.com/ping",
-                      ssl_ca_certificate=None):
-        if otps is None:
-            otps = ["otp1"]
-        user_data = {"otps": otps, "exchange-url": exchange_url,
-                     "ping-url": ping_url}
-        if ssl_ca_certificate is not None:
-            user_data["ssl-ca-certificate"] = ssl_ca_certificate
-        return user_data
-
-    def prepare_query_results(
-        self, user_data=None, instance_key="key1", launch_index=0,
-        local_hostname="ooga.local", public_hostname="ooga.amazon.com",
-        reservation_key=u"res1", ramdisk_key=u"ram1", kernel_key=u"kernel1",
-        image_key=u"image1", local_ip="10.0.0.1", public_ip="10.0.0.2",
-        ssl_ca_certificate=None):
-        if user_data is None:
-            user_data = self.get_user_data(
-                ssl_ca_certificate=ssl_ca_certificate)
-        if not isinstance(user_data, Exception):
-            user_data = dumps(user_data)
-        api_base = "http://169.254.169.254/latest"
-        self.query_results.clear()
-        for url_suffix, value in [
-            ("/user-data", user_data),
-            ("/meta-data/instance-id", instance_key),
-            ("/meta-data/reservation-id", reservation_key),
-            ("/meta-data/local-hostname", local_hostname),
-            ("/meta-data/public-hostname", public_hostname),
-            ("/meta-data/ami-launch-index", str(launch_index)),
-            ("/meta-data/kernel-id", kernel_key),
-            ("/meta-data/ramdisk-id", ramdisk_key),
-            ("/meta-data/ami-id", image_key),
-            ("/meta-data/local-ipv4", local_ip),
-            ("/meta-data/public-ipv4", public_ip),
-            ]:
-            self.query_results[api_base + url_suffix] = value
-
-    def prepare_cloud_registration(self, account_name=None,
-                                   registration_key=None, tags=None,
-                                   access_group=None):
-        # Set things up so that the client thinks it should register
-        self.mstore.set_accepted_types(list(self.mstore.get_accepted_types())
-                                       + ["register-cloud-vm"])
-        self.config.account_name = account_name
-        self.config.registration_key = registration_key
-        self.config.computer_title = None
-        self.config.tags = tags
-        self.config.access_group = access_group
-        self.identity.secure_id = None
-        self.assertTrue(self.handler.should_register())
-
-    def get_expected_cloud_message(self, **kwargs):
-        """
-        Return the message which is expected from a similar call to
-        L{get_registration_handler_for_cloud}.
-        """
-        message = dict(type="register-cloud-vm",
-                       otp="otp1",
-                       hostname="ooga.local",
-                       local_hostname="ooga.local",
-                       public_hostname="ooga.amazon.com",
-                       instance_key=u"key1",
-                       reservation_key=u"res1",
-                       ramdisk_key=u"ram1",
-                       kernel_key=u"kernel1",
-                       launch_index=0,
-                       image_key=u"image1",
-                       account_name=None,
-                       registration_password=None,
-                       local_ipv4=u"10.0.0.1",
-                       public_ipv4=u"10.0.0.2",
-                       tags=None)
-        # The get_vm_info() needs to be deferred to the else.  If vm-info is
-        # not specified in kwargs, get_vm_info() will typically be mocked.
-        if "vm_info" in kwargs:
-            message["vm-info"] = kwargs.pop("vm_info")
-        else:
-            message["vm-info"] = get_vm_info()
-        message.update(kwargs)
-        return message
-
-    def test_cloud_registration(self):
-        """
-        When the 'cloud' configuration variable is set, cloud registration is
-        done instead of normal password-based registration. This means:
-
-        - "Launch Data" is fetched from the EC2 Launch Data URL. This contains
-          a one-time password that is used during registration.
-        - A different "register-cloud-vm" message is sent to the server instead
-          of "register", containing the OTP. This message is handled by
-          immediately accepting the computer, instead of going through the
-          pending computer stage.
-        """
-        get_vm_info_mock = self.mocker.replace(get_vm_info)
-        get_vm_info_mock()
-        self.mocker.result("xen")
-        self.mocker.replay()
-        self.prepare_query_results()
-        self.prepare_cloud_registration(tags=u"server,london")
-
-        # metadata is fetched and stored at reactor startup:
-        self.reactor.fire("run")
-
-        # And the metadata returned determines the URLs that are used
-        self.assertEqual(self.transport.get_url(),
-                         "https://example.com/message-system")
-        self.assertEqual(self.pinger.get_url(),
-                         "http://example.com/ping")
-        # Lets make sure those values were written back to the config file
-        new_config = BrokerConfiguration()
-        new_config.load_configuration_file(self.config_filename)
-        self.assertEqual(new_config.url, "https://example.com/message-system")
-        self.assertEqual(new_config.ping_url, "http://example.com/ping")
-
-        # Okay! Exchange should cause the registration to happen.
-        self.exchanger.exchange()
-        # This *should* be asynchronous, but I think a billion tests are
-        # written like this
-        self.assertEqual(len(self.transport.payloads), 1)
-        self.assertMessages(
-            self.transport.payloads[0]["messages"],
-            [self.get_expected_cloud_message(tags=u"server,london",
-                                             vm_info="xen")])
-
-    def test_cloud_registration_with_access_group(self):
-        """
-        If the access_group field is presnet in the configuration, the
-        access_group field is present in the outgoing message for a VM
-        registration, and a notice appears in the logs.
-        """
-        self.prepare_query_results()
-        self.prepare_cloud_registration(access_group=u"dinosaurs",
-                                        tags=u"server,london")
-
-        self.reactor.fire("run")
-        self.exchanger.exchange()
-        self.assertEqual(len(self.transport.payloads), 1)
-        self.assertMessages(
-            self.transport.payloads[0]["messages"],
-            [self.get_expected_cloud_message(
-                access_group=u"dinosaurs", tags=u"server,london")])
-
-    def test_cloud_registration_with_otp(self):
-        """
-        If the OTP is present in the configuration, it's used to trigger the
-        registration instead of using the user data.
-        """
-        self.config.otp = "otp1"
-        self.prepare_query_results(user_data=None)
-
-        self.prepare_cloud_registration()
-
-        # metadata is fetched and stored at reactor startup:
-        self.reactor.fire("run")
-
-        # Okay! Exchange should cause the registration to happen.
-        self.exchanger.exchange()
-        # This *should* be asynchronous, but I think a billion tests are
-        # written like this
-        self.assertEqual(len(self.transport.payloads), 1)
-        self.assertMessages(
-            self.transport.payloads[0]["messages"],
-            [self.get_expected_cloud_message()])
-
-    def test_cloud_registration_with_invalid_tags(self):
-        """
-        Invalid tags in the configuration should result in the tags not being
-        sent to the server, and this fact logged.
-        """
-        self.log_helper.ignore_errors("Invalid tags provided for cloud "
-                                      "registration")
-        self.prepare_query_results()
-        self.prepare_cloud_registration(tags=u"<script>alert()</script>,hardy")
-
-        # metadata is fetched and stored at reactor startup:
-        self.reactor.fire("run")
-        self.exchanger.exchange()
-        self.assertEqual(len(self.transport.payloads), 1)
-        self.assertMessages(self.transport.payloads[0]["messages"],
-                            [self.get_expected_cloud_message(tags=None)])
-        self.assertEqual(self.logfile.getvalue().strip()[:-7],
-                         "ERROR: Invalid tags provided for cloud "
-                         "registration.\n    "
-                         "INFO: Queueing message to register with OTP\n    "
-                         "INFO: Sending registration message to exchange.\n   "
-                         " INFO: Starting message exchange with "
-                         "https://example.com/message-system.\n    "
-                         "INFO: Message exchange completed in")
-
-    def test_cloud_registration_with_ssl_ca_certificate(self):
-        """
-        If we have an SSL certificate CA included in the user-data, this should
-        be written out, and the configuration updated to reflect this.
-        """
-        key_filename = os.path.join(self.config.data_path,
-            "%s.ssl_public_key" % os.path.basename(self.config_filename))
-
-        print_text_mock = self.mocker.replace(print_text)
-        print_text_mock("Writing SSL CA certificate to %s..." %
-                        key_filename)
-        self.mocker.replay()
-        self.prepare_query_results(ssl_ca_certificate=u"1234567890")
-        self.prepare_cloud_registration(tags=u"server,london")
-        # metadata is fetched and stored at reactor startup:
-        self.reactor.fire("run")
-        # And the metadata returned determines the URLs that are used
-        self.assertEqual("https://example.com/message-system",
-                         self.transport.get_url())
-        self.assertEqual(key_filename, self.transport._pubkey)
-        self.assertEqual("http://example.com/ping",
-                         self.pinger.get_url())
-        # Let's make sure those values were written back to the config file
-        new_config = BrokerConfiguration()
-        new_config.load_configuration_file(self.config_filename)
-        self.assertEqual("https://example.com/message-system", new_config.url)
-        self.assertEqual("http://example.com/ping", new_config.ping_url)
-        self.assertEqual(key_filename, new_config.ssl_public_key)
-        self.assertEqual("1234567890", open(key_filename, "r").read())
-
-    def test_wrong_user_data(self):
-        self.prepare_query_results(user_data="other stuff, not a bpickle")
-        self.prepare_cloud_registration()
-
-        # Mock registration-failed call
-        reactor_mock = self.mocker.patch(self.reactor)
-        reactor_mock.fire("registration-failed")
-        self.mocker.replay()
-
-        self.reactor.fire("run")
-        self.exchanger.exchange()
-
-    def test_wrong_object_type_in_user_data(self):
-        self.prepare_query_results(user_data=True)
-        self.prepare_cloud_registration()
-
-        # Mock registration-failed call
-        reactor_mock = self.mocker.patch(self.reactor)
-        reactor_mock.fire("registration-failed")
-        self.mocker.replay()
-
-        self.reactor.fire("run")
-        self.exchanger.exchange()
-
-    def test_user_data_with_not_enough_elements(self):
-        """
-        If the AMI launch index isn't represented in the list of OTPs in the
-        user data then BOOM.
-        """
-        self.prepare_query_results(launch_index=1)
-        self.prepare_cloud_registration()
-
-        # Mock registration-failed call
-        reactor_mock = self.mocker.patch(self.reactor)
-        reactor_mock.fire("registration-failed")
-        self.mocker.replay()
-
-        self.reactor.fire("run")
-        self.exchanger.exchange()
-
-    def test_user_data_bpickle_without_otp(self):
-        self.prepare_query_results(user_data={"foo": "bar"})
-        self.prepare_cloud_registration()
-
-        # Mock registration-failed call
-        reactor_mock = self.mocker.patch(self.reactor)
-        reactor_mock.fire("registration-failed")
-        self.mocker.replay()
-
-        self.reactor.fire("run")
-        self.exchanger.exchange()
-
-    def test_no_otp_fallback_to_account(self):
-        self.prepare_query_results(user_data="other stuff, not a bpickle",
-                                   instance_key=u"key1")
-        self.prepare_cloud_registration(account_name=u"onward",
-                                        registration_key=u"password",
-                                        tags=u"london,server")
-
-        self.reactor.fire("run")
-        self.exchanger.exchange()
-
-        self.assertEqual(len(self.transport.payloads), 1)
-        self.assertMessages(self.transport.payloads[0]["messages"],
-                            [self.get_expected_cloud_message(
-                                otp=None,
-                                account_name=u"onward",
-                                registration_password=u"password",
-                                tags=u"london,server")])
-        self.assertEqual(self.logfile.getvalue().strip()[:-7],
-            "INFO: Queueing message to register with account u'onward' and "
-            "tags london,server as an EC2 instance.\n    "
-            "INFO: Sending registration message to exchange.\n    "
-            "INFO: Starting message exchange with http://localhost:91919.\n   "
-            " INFO: Message exchange completed in")
-
-    def test_queueing_cloud_registration_message_resets_message_store(self):
-        """
-        When a registration from a cloud is about to happen, the message store
-        is reset, because all previous messages are now meaningless.
-        """
-        self.mstore.set_accepted_types(list(self.mstore.get_accepted_types())
-                                       + ["test"])
-
-        self.mstore.add({"type": "test"})
-
-        self.prepare_query_results()
-
-        self.prepare_cloud_registration()
-
-        self.reactor.fire("run")
-        self.reactor.fire("pre-exchange")
-
-        messages = self.mstore.get_pending_messages()
-        self.assertEqual(len(messages), 1)
-        self.assertEqual(messages[0]["type"], "register-cloud-vm")
-
-    def test_cloud_registration_fetch_errors(self):
-        """
-        If fetching metadata fails, and we have no account details to fall
-        back to, we fire 'registration-failed'.
-        """
-        self.log_helper.ignore_errors(pycurl.error)
-
-        def fetch_stub(url):
-            return fail(pycurl.error(7, "couldn't connect to host"))
-
-        self.handler = RegistrationHandler(
-            self.config, self.identity, self.reactor, self.exchanger,
-            self.pinger, self.mstore, fetch_async=fetch_stub)
-
-        self.fetch_stub = fetch_stub
-        self.prepare_query_results()
-        self.fetch_stub = fetch_stub
-
-        self.prepare_cloud_registration()
-
-        failed = []
-        self.reactor.call_on(
-            "registration-failed", lambda: failed.append(True))
-
-        self.log_helper.ignore_errors("Got error while fetching meta-data")
-        self.reactor.fire("run")
-        self.exchanger.exchange()
-        self.assertEqual(failed, [True])
-        self.assertIn('error: (7, "couldn\'t connect to host")',
-                      self.logfile.getvalue())
-
-    def test_cloud_registration_continues_without_user_data(self):
-        """
-        If no user-data exists (i.e., the user-data URL returns a 404), then
-        register-cloud-vm still occurs.
-        """
-        self.log_helper.ignore_errors(HTTPCodeError)
-        self.prepare_query_results(user_data=HTTPCodeError(404, "ohno"))
-        self.prepare_cloud_registration(account_name="onward",
-                                        registration_key="password")
-
-        self.reactor.fire("run")
-        self.exchanger.exchange()
-        self.assertIn("HTTPCodeError: Server returned HTTP code 404",
-                      self.logfile.getvalue())
-        self.assertEqual(len(self.transport.payloads), 1)
-        self.assertMessages(self.transport.payloads[0]["messages"],
-                            [self.get_expected_cloud_message(
-                                otp=None,
-                                account_name=u"onward",
-                                registration_password=u"password")])
-
-    def test_cloud_registration_continues_without_ramdisk(self):
-        """
-        If the instance doesn't have a ramdisk (ie, the query for ramdisk
-        returns a 404), then register-cloud-vm still occurs.
-        """
-        self.log_helper.ignore_errors(HTTPCodeError)
-        self.prepare_query_results(ramdisk_key=HTTPCodeError(404, "ohno"))
-        self.prepare_cloud_registration()
-
-        self.reactor.fire("run")
-        self.exchanger.exchange()
-        self.assertIn("HTTPCodeError: Server returned HTTP code 404",
-                      self.logfile.getvalue())
-        self.assertEqual(len(self.transport.payloads), 1)
-        self.assertMessages(self.transport.payloads[0]["messages"],
-                            [self.get_expected_cloud_message(
-                                ramdisk_key=None)])
-
-    def test_cloud_registration_continues_without_kernel(self):
-        """
-        If the instance doesn't have a kernel (ie, the query for kernel
-        returns a 404), then register-cloud-vm still occurs.
-        """
-        self.log_helper.ignore_errors(HTTPCodeError)
-        self.prepare_query_results(kernel_key=HTTPCodeError(404, "ohno"))
-        self.prepare_cloud_registration()
-
-        self.reactor.fire("run")
-        self.exchanger.exchange()
-        self.assertIn("HTTPCodeError: Server returned HTTP code 404",
-                      self.logfile.getvalue())
-        self.assertEqual(len(self.transport.payloads), 1)
-        self.assertMessages(self.transport.payloads[0]["messages"],
-                            [self.get_expected_cloud_message(
-                                kernel_key=None)])
-
-    def test_fall_back_to_normal_registration_when_metadata_fetch_fails(self):
-        """
-        If fetching metadata fails, but we do have an account name, then we
-        fall back to normal 'register' registration.
-        """
-        self.mstore.set_accepted_types(["register"])
-        self.log_helper.ignore_errors(HTTPCodeError)
-        self.prepare_query_results(
-            public_hostname=HTTPCodeError(404, "ohnoes"))
-        self.prepare_cloud_registration(account_name="onward",
-                                        registration_key="password")
-        self.config.computer_title = "whatever"
-        self.reactor.fire("run")
-        self.exchanger.exchange()
-        self.assertIn("HTTPCodeError: Server returned HTTP code 404",
-                      self.logfile.getvalue())
-        self.assertEqual(len(self.transport.payloads), 1)
-        messages = self.transport.payloads[0]["messages"]
-        self.assertEqual("register", messages[0]["type"])
-
-    def test_should_register_in_cloud(self):
-        """
-        The client should register when it's in the cloud even though
-        it doesn't have the normal account details.
-        """
-        self.mstore.set_accepted_types(self.mstore.get_accepted_types()
-                                       + ("register-cloud-vm",))
-        self.config.account_name = None
-        self.config.registration_key = None
-        self.config.computer_title = None
-        self.identity.secure_id = None
-        self.assertTrue(self.handler.should_register())
-
-    def test_launch_index(self):
-        """
-        The client used the value in C{ami-launch-index} to choose the
-        appropriate OTP in the user data.
-        """
-        otp = "correct otp for launch index"
-        self.prepare_query_results(
-            user_data=self.get_user_data(otps=["wrong index", otp,
-                                               "wrong again"],),
-            instance_key="key1",
-            launch_index=1)
-
-        self.prepare_cloud_registration()
-
-        self.reactor.fire("run")
-        self.exchanger.exchange()
-        self.assertEqual(len(self.transport.payloads), 1)
-        self.assertMessages(self.transport.payloads[0]["messages"],
-                            [self.get_expected_cloud_message(otp=otp,
-                                                             launch_index=1)])
-
-    def test_should_not_register_in_cloud(self):
-        """
-        Having a secure ID means we shouldn't register, even in the cloud.
-        """
-        self.mstore.set_accepted_types(self.mstore.get_accepted_types()
-                                       + ("register-cloud-vm",))
-        self.config.account_name = None
-        self.config.registration_key = None
-        self.config.computer_title = None
-        self.identity.secure_id = "hello"
-        self.assertFalse(self.handler.should_register())
-
-    def test_should_not_register_without_register_cloud_vm(self):
-        """
-        If the server isn't accepting a 'register-cloud-vm' message,
-        we shouldn't register.
-        """
-        self.config.account_name = None
-        self.config.registration_key = None
-        self.config.computer_title = None
-        self.identity.secure_id = None
-        self.assertFalse(self.handler.should_register())
-
-
-class IsCloudManagedTests(LandscapeTest):
-
-    def setUp(self):
-        super(IsCloudManagedTests, self).setUp()
-        self.urls = []
-        self.responses = []
-
-    def fake_fetch(self, url, connect_timeout=None):
-        self.urls.append((url, connect_timeout))
-        return self.responses.pop(0)
-
-    def mock_socket(self):
-        """
-        Mock out socket usage by is_cloud_managed to wait for the network.
-        """
-        # Mock the socket.connect call that it also does
-        socket_class = self.mocker.replace("socket.socket", passthrough=False)
-        socket = socket_class()
-        socket.connect((EC2_HOST, 80))
-        socket.close()
-
-    def test_is_managed(self):
-        """
-        L{is_cloud_managed} returns True if the EC2 user-data contains
-        Landscape instance information.  It fetches the EC2 data with low
-        timeouts.
-        """
-        user_data = {"otps": ["otp1"], "exchange-url": "http://exchange",
-                     "ping-url": "http://ping"}
-        self.responses = [dumps(user_data), "0"]
-
-        self.mock_socket()
-        self.mocker.replay()
-
-        self.assertTrue(is_cloud_managed(self.fake_fetch))
-        self.assertEqual(
-            self.urls,
-            [(EC2_API + "/user-data", 5),
-             (EC2_API + "/meta-data/ami-launch-index", 5)])
-
-    def test_is_managed_index(self):
-        user_data = {"otps": ["otp1", "otp2"],
-                     "exchange-url": "http://exchange",
-                     "ping-url": "http://ping"}
-        self.responses = [dumps(user_data), "1"]
-        self.mock_socket()
-        self.mocker.replay()
-        self.assertTrue(is_cloud_managed(self.fake_fetch))
-
-    def test_is_managed_wrong_index(self):
-        user_data = {"otps": ["otp1"], "exchange-url": "http://exchange",
-                     "ping-url": "http://ping"}
-        self.responses = [dumps(user_data), "1"]
-        self.mock_socket()
-        self.mocker.replay()
-        self.assertFalse(is_cloud_managed(self.fake_fetch))
-
-    def test_is_managed_exchange_url(self):
-        user_data = {"otps": ["otp1"], "ping-url": "http://ping"}
-        self.responses = [dumps(user_data), "0"]
-        self.mock_socket()
-        self.mocker.replay()
-        self.assertFalse(is_cloud_managed(self.fake_fetch))
-
-    def test_is_managed_ping_url(self):
-        user_data = {"otps": ["otp1"], "exchange-url": "http://exchange"}
-        self.responses = [dumps(user_data), "0"]
-        self.mock_socket()
-        self.mocker.replay()
-        self.assertFalse(is_cloud_managed(self.fake_fetch))
-
-    def test_is_managed_bpickle(self):
-        self.responses = ["some other user data", "0"]
-        self.mock_socket()
-        self.mocker.replay()
-        self.assertFalse(is_cloud_managed(self.fake_fetch))
-
-    def test_is_managed_no_data(self):
-        self.responses = ["", "0"]
-        self.mock_socket()
-        self.mocker.replay()
-        self.assertFalse(is_cloud_managed(self.fake_fetch))
-
-    def test_is_managed_fetch_not_found(self):
-
-        def fake_fetch(url, connect_timeout=None):
-            raise HTTPCodeError(404, "ohnoes")
-
-        self.mock_socket()
-        self.mocker.replay()
-        self.assertFalse(is_cloud_managed(fake_fetch))
-
-    def test_is_managed_fetch_error(self):
-
-        def fake_fetch(url, connect_timeout=None):
-            raise FetchError(7, "couldn't connect to host")
-
-        self.mock_socket()
-        self.mocker.replay()
-        self.assertFalse(is_cloud_managed(fake_fetch))
-
-    def test_waits_for_network(self):
-        """
-        is_cloud_managed will wait until the network before trying to fetch
-        the EC2 user data.
-        """
-        user_data = {"otps": ["otp1"], "exchange-url": "http://exchange",
-                     "ping-url": "http://ping"}
-        self.responses = [dumps(user_data), "0"]
-
-        self.mocker.order()
-        time_sleep = self.mocker.replace("time.sleep", passthrough=False)
-        socket_class = self.mocker.replace("socket.socket", passthrough=False)
-        socket_obj = socket_class()
-        socket_obj.connect((EC2_HOST, 80))
-        self.mocker.throw(socket.error("woops"))
-        time_sleep(1)
-        socket_obj = socket_class()
-        socket_obj.connect((EC2_HOST, 80))
-        self.mocker.result(None)
-        socket_obj.close()
-        self.mocker.replay()
-        self.assertTrue(is_cloud_managed(self.fake_fetch))
-
-    def test_waiting_times_out(self):
-        """
-        We'll only wait five minutes for the network to come up.
-        """
-
-        def fake_fetch(url, connect_timeout=None):
-            raise FetchError(7, "couldn't connect to host")
-
-        self.mocker.order()
-        time_sleep = self.mocker.replace("time.sleep", passthrough=False)
-        time_time = self.mocker.replace("time.time", passthrough=False)
-        time_time()
-        self.mocker.result(100)
-        socket_class = self.mocker.replace("socket.socket", passthrough=False)
-        socket_obj = socket_class()
-        socket_obj.connect((EC2_HOST, 80))
-        self.mocker.throw(socket.error("woops"))
-        time_sleep(1)
-        time_time()
-        self.mocker.result(401)
-        self.mocker.replay()
-        # Mocking time.time is dangerous, because the test harness calls it. So
-        # we explicitly reset mocker before returning from the test.
-        try:
-            self.assertFalse(is_cloud_managed(fake_fetch))
-        finally:
-            self.mocker.reset()
-
-
 class ProvisioningRegistrationTest(RegistrationHandlerTestBase):
 
     def test_provisioned_machine_registration_with_otp(self):
 
=== modified file 'landscape/configuration.py'
--- landscape/configuration.py	2014-07-01 14:52:02 +0000
+++ landscape/configuration.py	2014-07-16 10:26:46 +0000
@@ -581,7 +581,7 @@
     decode_base64_ssl_public_certificate(config)
     config.write()
     # Restart the client to ensure that it's using the new configuration.
-    if not config.no_start and not config.otp:
+    if not config.no_start:
         try:
             sysvconfig.restart_landscape()
         except ProcessError:
 
=== modified file 'landscape/message_schemas.py'
--- landscape/message_schemas.py	2014-07-13 07:01:19 +0000
+++ landscape/message_schemas.py	2014-07-16 10:26:46 +0000
@@ -112,6 +112,11 @@
              "unit-name": Unicode(),
              "private-address": Unicode()}
 
+# The copy is needed because Message mutates the dictionary
+JUJU_INFO = Message("juju-info",
+                    juju_data.copy(),
+                    optional=["private-address"])
+
 JUJU_UNITS_INFO = Message("juju-units-info", {
     "juju-info-list": List(KeyDict(juju_data.copy(),
                                    optional=["private-address"]))
@@ -191,6 +196,9 @@
      "tags": Any(Unicode(), Constant(None)),
      "vm-info": Bytes(),
      "container-info": Unicode(),
+     "juju-info": KeyDict(juju_data, optional=["private-address"]),
+     # Because of backwards compatibility we need another member with the list
+     # of juju-info, so it can safely be ignored by old servers.
      "juju-info-list": List(KeyDict(juju_data, optional=["private-address"])),
      "access_group": Unicode()},
     optional=["registration_password", "hostname", "tags", "vm-info",
@@ -203,6 +211,8 @@
     {"otp": Bytes()})
 
 
+# XXX The register-cloud-vm message is obsolete, it's kept around just to not
+# break older LDS releases that import it. Eventually it shall be dropped.
 REGISTER_CLOUD_VM = Message(
     "register-cloud-vm",
     {"hostname": Unicode(),
@@ -476,5 +486,5 @@
                EUCALYPTUS_INFO_ERROR, 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_UNITS_INFO, CLOUD_METADATA]:
+               CHANGE_HA_SERVICE, JUJU_INFO, JUJU_UNITS_INFO, CLOUD_METADATA]:
     message_schemas[schema.type] = schema
 
=== modified file 'landscape/tests/test_configuration.py'
--- landscape/tests/test_configuration.py	2014-02-25 18:06:48 +0000
+++ landscape/tests/test_configuration.py	2014-07-16 10:26:46 +0000
@@ -820,7 +820,6 @@
                 "--ping-interval", "30",
                 "--http-proxy", "",
                 "--https-proxy", "",
-                "--otp", "",
                 "--tags", "",
                 "--provisioning-otp", ""]
         config = self.get_config(args)
@@ -837,7 +836,6 @@
             "https_proxy = \n"
             "url = https://landscape.canonical.com/message-system\n"
             "exchange_interval = 900\n"
-            "otp = \n"
             "ping_interval = 30\n"
             "ping_url = http://landscape.canonical.com/ping\n"
             "provisioning_otp = \n"
@@ -862,20 +860,6 @@
         config = self.get_config(["--silent", "-t", "rex"])
         self.assertRaises(ConfigurationError, setup, config)
 
-    def test_silent_setup_with_otp(self):
-        """
-        If the 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)
-        self.mocker.replay()
-
-        config = self.get_config(["--silent", "--otp", "otp1"])
-        setup(config)
-
-        self.assertEqual("otp1", config.otp)
-
     def test_silent_setup_with_provisioning_otp(self):
         """
         If the provisioning OTP is specified, there is no need to pass the
 
=== removed file 'scripts/landscape-is-cloud-managed'
--- scripts/landscape-is-cloud-managed	2009-04-09 14:32:45 +0000
+++ scripts/landscape-is-cloud-managed	1970-01-01 00:00:00 +0000
@@ -1,12 +0,0 @@
-#!/usr/bin/python
-import sys, os
-if os.path.dirname(os.path.abspath(sys.argv[0])) == os.path.abspath("scripts"):
-    sys.path.insert(0, "./")
-else:
-    from landscape.lib.warning import hide_warnings
-    hide_warnings()
-
-from landscape.broker.registration import is_cloud_managed
-
-# We return 0 if it succeeds
-sys.exit(not is_cloud_managed())
 
=== modified file 'setup.py'
--- setup.py	2013-06-03 12:26:30 +0000
+++ setup.py	2014-07-16 10:26:46 +0000
@@ -56,7 +56,6 @@
                "scripts/landscape-package-reporter",
                "scripts/landscape-release-upgrader",
                "scripts/landscape-sysinfo",
-               "scripts/landscape-is-cloud-managed",
                "scripts/landscape-dbus-proxy",
                "scripts/landscape-client-settings-mechanism",
                "scripts/landscape-client-registration-mechanism",