Datasource for UpCloud (#743)

New datasource utilizing UpCloud metadata API, including relevant unit
tests and documentation.

11 files changed, 752 insertions, 1 deletions

diff --git a/cloudinit/apport.py b/cloudinit/apport.py
index 9bded16c..25f254e3 100644
--- a/cloudinit/apport.py
+++ b/cloudinit/apport.py
@@ -39,6 +39,7 @@ KNOWN_CLOUD_NAMES = [
     'SAP Converged Cloud',
     'Scaleway',
     'SmartOS',
+    'UpCloud',
     'VMware',
     'ZStack',
     'Other'
diff --git a/cloudinit/settings.py b/cloudinit/settings.py
index 7516e17b..91e1bfe7 100644
--- a/cloudinit/settings.py
+++ b/cloudinit/settings.py
@@ -41,6 +41,7 @@ CFG_BUILTIN = {
         'Oracle',
         'Exoscale',
         'RbxCloud',
+        'UpCloud',
         # At the end to act as a 'catch' when none of the above work...
         'None',
     ],
diff --git a/cloudinit/sources/DataSourceUpCloud.py b/cloudinit/sources/DataSourceUpCloud.py
new file mode 100644
index 00000000..209b9672
--- /dev/null
+++ b/cloudinit/sources/DataSourceUpCloud.py
@@ -0,0 +1,165 @@
+# Author: Antti Myyrä <antti.myyra@upcloud.com>
+#
+# This file is part of cloud-init. See LICENSE file for license information.
+
+# UpCloud server metadata API:
+# https://developers.upcloud.com/1.3/8-servers/#metadata-service
+
+from cloudinit import log as logging
+from cloudinit import sources
+from cloudinit import util
+from cloudinit import net as cloudnet
+from cloudinit.net.dhcp import EphemeralDHCPv4, NoDHCPLeaseError
+
+
+from cloudinit.sources.helpers import upcloud as uc_helper
+
+LOG = logging.getLogger(__name__)
+
+BUILTIN_DS_CONFIG = {"metadata_url": "http://169.254.169.254/metadata/v1.json"}
+
+# Wait for a up to a minute, retrying the meta-data server
+# every 2 seconds.
+MD_RETRIES = 30
+MD_TIMEOUT = 2
+MD_WAIT_RETRY = 2
+
+
+class DataSourceUpCloud(sources.DataSource):
+
+    dsname = "UpCloud"
+
+    # We'll perform DHCP setup only in init-local, see DataSourceUpCloudLocal
+    perform_dhcp_setup = False
+
+    def __init__(self, sys_cfg, distro, paths):
+        sources.DataSource.__init__(self, sys_cfg, distro, paths)
+        self.distro = distro
+        self.metadata = dict()
+        self.ds_cfg = util.mergemanydict(
+            [
+                util.get_cfg_by_path(sys_cfg, ["datasource", "UpCloud"], {}),
+                BUILTIN_DS_CONFIG,
+            ]
+        )
+        self.metadata_address = self.ds_cfg["metadata_url"]
+        self.retries = self.ds_cfg.get("retries", MD_RETRIES)
+        self.timeout = self.ds_cfg.get("timeout", MD_TIMEOUT)
+        self.wait_retry = self.ds_cfg.get("wait_retry", MD_WAIT_RETRY)
+        self._network_config = None
+
+    def _get_sysinfo(self):
+        return uc_helper.read_sysinfo()
+
+    def _read_metadata(self):
+        return uc_helper.read_metadata(
+            self.metadata_address,
+            timeout=self.timeout,
+            sec_between=self.wait_retry,
+            retries=self.retries,
+        )
+
+    def _get_data(self):
+        (is_upcloud, server_uuid) = self._get_sysinfo()
+
+        # only proceed if we know we are on UpCloud
+        if not is_upcloud:
+            return False
+
+        LOG.info("Running on UpCloud. server_uuid=%s", server_uuid)
+
+        if self.perform_dhcp_setup:  # Setup networking in init-local stage.
+            try:
+                LOG.debug("Finding a fallback NIC")
+                nic = cloudnet.find_fallback_nic()
+                LOG.debug("Discovering metadata via DHCP interface %s", nic)
+                with EphemeralDHCPv4(nic):
+                    md = util.log_time(
+                        logfunc=LOG.debug,
+                        msg="Reading from metadata service",
+                        func=self._read_metadata,
+                    )
+            except (NoDHCPLeaseError, sources.InvalidMetaDataException) as e:
+                util.logexc(LOG, str(e))
+                return False
+        else:
+            try:
+                LOG.debug(
+                    "Discovering metadata without DHCP-configured networking"
+                )
+                md = util.log_time(
+                    logfunc=LOG.debug,
+                    msg="Reading from metadata service",
+                    func=self._read_metadata,
+                )
+            except sources.InvalidMetaDataException as e:
+                util.logexc(LOG, str(e))
+                LOG.info(
+                    "No DHCP-enabled interfaces available, "
+                    "unable to fetch metadata for %s",
+                    server_uuid,
+                )
+                return False
+
+        self.metadata_full = md
+        self.metadata["instance-id"] = md.get("instance_id", server_uuid)
+        self.metadata["local-hostname"] = md.get("hostname")
+        self.metadata["network"] = md.get("network")
+        self.metadata["public-keys"] = md.get("public_keys")
+        self.metadata["availability_zone"] = md.get("region", "default")
+        self.vendordata_raw = md.get("vendor_data", None)
+        self.userdata_raw = md.get("user_data", None)
+
+        return True
+
+    def check_instance_id(self, sys_cfg):
+        return sources.instance_id_matches_system_uuid(self.get_instance_id())
+
+    @property
+    def network_config(self):
+        """
+        Configure the networking. This needs to be done each boot,
+        since the IP and interface information might have changed
+        due to reconfiguration.
+        """
+
+        if self._network_config:
+            return self._network_config
+
+        raw_network_config = self.metadata.get("network")
+        if not raw_network_config:
+            raise Exception("Unable to get network meta-data from server....")
+
+        self._network_config = uc_helper.convert_network_config(
+            raw_network_config,
+        )
+
+        return self._network_config
+
+
+class DataSourceUpCloudLocal(DataSourceUpCloud):
+    """
+    Run in init-local using a DHCP discovery prior to metadata crawl.
+
+    In init-local, no network is available. This subclass sets up minimal
+    networking with dhclient on a viable nic so that it can talk to the
+    metadata service. If the metadata service provides network configuration
+    then render the network configuration for that instance based on metadata.
+    """
+
+    perform_dhcp_setup = True  # Get metadata network config if present
+
+
+# Used to match classes to dependencies
+datasources = [
+    (DataSourceUpCloudLocal, (sources.DEP_FILESYSTEM, )),
+    (DataSourceUpCloud, (sources.DEP_FILESYSTEM, sources.DEP_NETWORK)),
+]
+
+
+# Return a list of data sources that match this set of dependencies
+def get_datasource_list(depends):
+    return sources.list_from_depends(depends, datasources)
+
+
+# vi: ts=4 expandtab
diff --git a/cloudinit/sources/helpers/upcloud.py b/cloudinit/sources/helpers/upcloud.py
new file mode 100644
index 00000000..199baa58
--- /dev/null
+++ b/cloudinit/sources/helpers/upcloud.py
@@ -0,0 +1,231 @@
+# Author: Antti Myyrä <antti.myyra@upcloud.com>
+#
+# This file is part of cloud-init. See LICENSE file for license information.
+
+import json
+
+from cloudinit import dmi
+from cloudinit import log as logging
+from cloudinit import net as cloudnet
+from cloudinit import url_helper
+
+LOG = logging.getLogger(__name__)
+
+
+def convert_to_network_config_v1(config):
+    """
+    Convert the UpCloud network metadata description into
+    Cloud-init's version 1 netconfig format.
+
+    Example JSON:
+    {
+      "interfaces": [
+        {
+          "index": 1,
+          "ip_addresses": [
+            {
+              "address": "94.237.105.53",
+              "dhcp": true,
+              "dns": [
+                "94.237.127.9",
+                "94.237.40.9"
+              ],
+              "family": "IPv4",
+              "floating": false,
+              "gateway": "94.237.104.1",
+              "network": "94.237.104.0/22"
+            },
+            {
+              "address": "94.237.105.50",
+              "dhcp": false,
+              "dns": [],
+              "family": "IPv4",
+              "floating": true,
+              "gateway": "",
+              "network": "94.237.105.50/32"
+            }
+          ],
+          "mac": "32:d5:ba:4a:36:e7",
+          "network_id": "031457f4-0f8c-483c-96f2-eccede02909c",
+          "type": "public"
+        },
+        {
+          "index": 2,
+          "ip_addresses": [
+            {
+              "address": "10.6.3.27",
+              "dhcp": true,
+              "dns": [],
+              "family": "IPv4",
+              "floating": false,
+              "gateway": "10.6.0.1",
+              "network": "10.6.0.0/22"
+            }
+          ],
+          "mac": "32:d5:ba:4a:84:cc",
+          "network_id": "03d82553-5bea-4132-b29a-e1cf67ec2dd1",
+          "type": "utility"
+        },
+        {
+          "index": 3,
+          "ip_addresses": [
+            {
+              "address": "2a04:3545:1000:720:38d6:baff:fe4a:63e7",
+              "dhcp": true,
+              "dns": [
+                "2a04:3540:53::1",
+                "2a04:3544:53::1"
+              ],
+              "family": "IPv6",
+              "floating": false,
+              "gateway": "2a04:3545:1000:720::1",
+              "network": "2a04:3545:1000:720::/64"
+            }
+          ],
+          "mac": "32:d5:ba:4a:63:e7",
+          "network_id": "03000000-0000-4000-8046-000000000000",
+          "type": "public"
+        },
+        {
+          "index": 4,
+          "ip_addresses": [
+            {
+              "address": "172.30.1.10",
+              "dhcp": true,
+              "dns": [],
+              "family": "IPv4",
+              "floating": false,
+              "gateway": "172.30.1.1",
+              "network": "172.30.1.0/24"
+            }
+          ],
+          "mac": "32:d5:ba:4a:8a:e1",
+          "network_id": "035a0a4a-77b4-4de5-820d-189fc8135714",
+          "type": "private"
+        }
+      ],
+      "dns": [
+        "94.237.127.9",
+        "94.237.40.9"
+      ]
+    }
+    """
+
+    def _get_subnet_config(ip_addr, dns):
+        if ip_addr.get("dhcp"):
+            dhcp_type = "dhcp"
+            if ip_addr.get("family") == "IPv6":
+                # UpCloud currently passes IPv6 addresses via
+                # StateLess Address Auto Configuration (SLAAC)
+                dhcp_type = "ipv6_dhcpv6-stateless"
+            return {"type": dhcp_type}
+
+        static_type = "static"
+        if ip_addr.get("family") == "IPv6":
+            static_type = "static6"
+        subpart = {
+            "type": static_type,
+            "control": "auto",
+            "address": ip_addr.get("address"),
+        }
+
+        if ip_addr.get("gateway"):
+            subpart["gateway"] = ip_addr.get("gateway")
+
+        if "/" in ip_addr.get("network"):
+            subpart["netmask"] = ip_addr.get("network").split("/")[1]
+
+        if dns != ip_addr.get("dns") and ip_addr.get("dns"):
+            subpart["dns_nameservers"] = ip_addr.get("dns")
+
+        return subpart
+
+    nic_configs = []
+    macs_to_interfaces = cloudnet.get_interfaces_by_mac()
+    LOG.debug("NIC mapping: %s", macs_to_interfaces)
+
+    for raw_iface in config.get("interfaces"):
+        LOG.debug("Considering %s", raw_iface)
+
+        mac_address = raw_iface.get("mac")
+        if mac_address not in macs_to_interfaces:
+            raise RuntimeError(
+                "Did not find network interface on system "
+                "with mac '%s'. Cannot apply configuration: %s"
+                % (mac_address, raw_iface)
+            )
+
+        iface_type = raw_iface.get("type")
+        sysfs_name = macs_to_interfaces.get(mac_address)
+
+        LOG.debug(
+            "Found %s interface '%s' with address '%s' (index %d)",
+            iface_type,
+            sysfs_name,
+            mac_address,
+            raw_iface.get("index"),
+        )
+
+        interface = {
+            "type": "physical",
+            "name": sysfs_name,
+            "mac_address": mac_address
+        }
+
+        subnets = []
+        for ip_address in raw_iface.get("ip_addresses"):
+            sub_part = _get_subnet_config(ip_address, config.get("dns"))
+            subnets.append(sub_part)
+
+        interface["subnets"] = subnets
+        nic_configs.append(interface)
+
+    if config.get("dns"):
+        LOG.debug("Setting DNS nameservers to %s", config.get("dns"))
+        nic_configs.append({
+            "type": "nameserver",
+            "address": config.get("dns")
+        })
+
+    return {"version": 1, "config": nic_configs}
+
+
+def convert_network_config(config):
+    return convert_to_network_config_v1(config)
+
+
+def read_metadata(url, timeout=2, sec_between=2, retries=30):
+    response = url_helper.readurl(
+        url, timeout=timeout, sec_between=sec_between, retries=retries
+    )
+    if not response.ok():
+        raise RuntimeError("unable to read metadata at %s" % url)
+    return json.loads(response.contents.decode())
+
+
+def read_sysinfo():
+    # UpCloud embeds vendor ID and server UUID in the
+    # SMBIOS information
+
+    # Detect if we are on UpCloud and return the UUID
+
+    vendor_name = dmi.read_dmi_data("system-manufacturer")
+    if vendor_name != "UpCloud":
+        return False, None
+
+    server_uuid = dmi.read_dmi_data("system-uuid")
+    if server_uuid:
+        LOG.debug(
+            "system identified via SMBIOS as UpCloud server: %s",
+            server_uuid
+        )
+    else:
+        msg = (
+            "system identified via SMBIOS as a UpCloud server, but "
+            "did not provide an ID. Please contact support via"
+            "https://hub.upcloud.com or via email with support@upcloud.com"
+        )
+        LOG.critical(msg)
+        raise RuntimeError(msg)
+
+    return True, server_uuid
diff --git a/doc/rtd/topics/availability.rst b/doc/rtd/topics/availability.rst
index 8f56a7d2..f58b2b38 100644
--- a/doc/rtd/topics/availability.rst
+++ b/doc/rtd/topics/availability.rst
@@ -55,6 +55,7 @@ environments in the public cloud:
 - CloudStack
 - AltCloud
 - SmartOS
+- UpCloud
 
 Additionally, cloud-init is supported on these private clouds:
 
diff --git a/doc/rtd/topics/datasources.rst b/doc/rtd/topics/datasources.rst
index 3d026143..228173d2 100644
--- a/doc/rtd/topics/datasources.rst
+++ b/doc/rtd/topics/datasources.rst
@@ -47,6 +47,7 @@ The following is a list of documents for each supported datasource:
    datasources/ovf.rst
    datasources/rbxcloud.rst
    datasources/smartos.rst
+   datasources/upcloud.rst
    datasources/zstack.rst
 
 
diff --git a/doc/rtd/topics/datasources/upcloud.rst b/doc/rtd/topics/datasources/upcloud.rst
new file mode 100644
index 00000000..0b7a9bb0
--- /dev/null
+++ b/doc/rtd/topics/datasources/upcloud.rst
@@ -0,0 +1,24 @@
+.. _datasource_upcloud:
+
+UpCloud
+=============
+
+The `UpCloud`_ datasource consumes information from UpCloud's `metadata
+service`_. This metadata service serves information about the
+running server via HTTP over the address 169.254.169.254 available in every
+DHCP-configured interface. The metadata API endpoints are fully described in
+UpCloud API documentation at
+`https://developers.upcloud.com/1.3/8-servers/#metadata-service
+<https://developers.upcloud.com/1.3/8-servers/#metadata-service>`_.
+
+Providing user-data
+-------------------
+
+When creating a server, user-data is provided by specifying it as `user_data`
+in the API or via the server creation tool in the control panel. User-data is
+immutable during server's lifetime and can be removed by deleting the server.
+
+.. _UpCloud: https://upcloud.com/
+.. _metadata service: https://upcloud.com/community/tutorials/upcloud-metadata-service/
+
+.. vi: textwidth=78
diff --git a/doc/rtd/topics/network-config.rst b/doc/rtd/topics/network-config.rst
index 08db04d8..07cad765 100644
--- a/doc/rtd/topics/network-config.rst
+++ b/doc/rtd/topics/network-config.rst
@@ -144,6 +144,10 @@ The following Datasources optionally provide network configuration:
 
   - `SmartOS JSON Metadata`_
 
+- :ref:`datasource_upcloud`
+
+  - `UpCloud JSON metadata`_
+
 For more information on network configuration formats
 
 .. toctree::
@@ -257,5 +261,6 @@ Example output converting V2 to sysconfig:
 .. _DigitalOcean JSON metadata: https://developers.digitalocean.com/documentation/metadata/#network-interfaces-index
 .. _OpenStack Metadata Service Network: https://specs.openstack.org/openstack/nova-specs/specs/liberty/implemented/metadata-service-network-info.html
 .. _SmartOS JSON Metadata: https://eng.joyent.com/mdata/datadict.html
+.. _UpCloud JSON metadata: https://developers.upcloud.com/1.3/8-servers/#metadata-service
 
 .. vi: textwidth=78
diff --git a/tests/unittests/test_datasource/test_common.py b/tests/unittests/test_datasource/test_common.py
index 4ab5d471..5912f7ee 100644
--- a/tests/unittests/test_datasource/test_common.py
+++ b/tests/unittests/test_datasource/test_common.py
@@ -27,6 +27,7 @@ from cloudinit.sources import (
     DataSourceRbxCloud as RbxCloud,
     DataSourceScaleway as Scaleway,
     DataSourceSmartOS as SmartOS,
+    DataSourceUpCloud as UpCloud,
 )
 from cloudinit.sources import DataSourceNone as DSNone
 
@@ -48,6 +49,7 @@ DEFAULT_LOCAL = [
     OpenStack.DataSourceOpenStackLocal,
     RbxCloud.DataSourceRbxCloud,
     Scaleway.DataSourceScaleway,
+    UpCloud.DataSourceUpCloudLocal,
 ]
 
 DEFAULT_NETWORK = [
@@ -63,6 +65,7 @@ DEFAULT_NETWORK = [
     NoCloud.DataSourceNoCloudNet,
     OpenStack.DataSourceOpenStack,
     OVF.DataSourceOVFNet,
+    UpCloud.DataSourceUpCloud,
 ]
 
 
diff --git a/tests/unittests/test_datasource/test_upcloud.py b/tests/unittests/test_datasource/test_upcloud.py
new file mode 100644
index 00000000..cec48b4b
--- /dev/null
+++ b/tests/unittests/test_datasource/test_upcloud.py
@@ -0,0 +1,314 @@
+# Author: Antti Myyrä <antti.myyra@upcloud.com>
+#
+# This file is part of cloud-init. See LICENSE file for license information.
+
+import json
+
+from cloudinit import helpers
+from cloudinit import settings
+from cloudinit import sources
+from cloudinit.sources.DataSourceUpCloud import DataSourceUpCloud, \
+    DataSourceUpCloudLocal
+
+from cloudinit.tests.helpers import mock, CiTestCase
+
+UC_METADATA = json.loads("""
+{
+  "cloud_name": "upcloud",
+  "instance_id": "00322b68-0096-4042-9406-faad61922128",
+  "hostname": "test.example.com",
+  "platform": "servers",
+  "subplatform": "metadata (http://169.254.169.254)",
+  "public_keys": [
+    "ssh-rsa AAAAB.... test1@example.com",
+    "ssh-rsa AAAAB.... test2@example.com"
+  ],
+  "region": "fi-hel2",
+  "network": {
+    "interfaces": [
+      {
+        "index": 1,
+        "ip_addresses": [
+          {
+            "address": "94.237.105.53",
+            "dhcp": true,
+            "dns": [
+              "94.237.127.9",
+              "94.237.40.9"
+            ],
+            "family": "IPv4",
+            "floating": false,
+            "gateway": "94.237.104.1",
+            "network": "94.237.104.0/22"
+          },
+          {
+            "address": "94.237.105.50",
+            "dhcp": false,
+            "dns": null,
+            "family": "IPv4",
+            "floating": true,
+            "gateway": "",
+            "network": "94.237.105.50/32"
+          }
+        ],
+        "mac": "3a:d6:ba:4a:36:e7",
+        "network_id": "031457f4-0f8c-483c-96f2-eccede02909c",
+        "type": "public"
+      },
+      {
+        "index": 2,
+        "ip_addresses": [
+          {
+            "address": "10.6.3.27",
+            "dhcp": true,
+            "dns": null,
+            "family": "IPv4",
+            "floating": false,
+            "gateway": "10.6.0.1",
+            "network": "10.6.0.0/22"
+          }
+        ],
+        "mac": "3a:d6:ba:4a:84:cc",
+        "network_id": "03d82553-5bea-4132-b29a-e1cf67ec2dd1",
+        "type": "utility"
+      },
+      {
+        "index": 3,
+        "ip_addresses": [
+          {
+            "address": "2a04:3545:1000:720:38d6:baff:fe4a:63e7",
+            "dhcp": true,
+            "dns": [
+              "2a04:3540:53::1",
+              "2a04:3544:53::1"
+            ],
+            "family": "IPv6",
+            "floating": false,
+            "gateway": "2a04:3545:1000:720::1",
+            "network": "2a04:3545:1000:720::/64"
+          }
+        ],
+        "mac": "3a:d6:ba:4a:63:e7",
+        "network_id": "03000000-0000-4000-8046-000000000000",
+        "type": "public"
+      },
+      {
+        "index": 4,
+        "ip_addresses": [
+          {
+            "address": "172.30.1.10",
+            "dhcp": true,
+            "dns": null,
+            "family": "IPv4",
+            "floating": false,
+            "gateway": "172.30.1.1",
+            "network": "172.30.1.0/24"
+          }
+        ],
+        "mac": "3a:d6:ba:4a:8a:e1",
+        "network_id": "035a0a4a-7704-4de5-820d-189fc8132714",
+        "type": "private"
+      }
+    ],
+    "dns": [
+      "94.237.127.9",
+      "94.237.40.9"
+    ]
+  },
+  "storage": {
+    "disks": [
+      {
+        "id": "014efb65-223b-4d44-8f0a-c29535b88dcf",
+        "serial": "014efb65223b4d448f0a",
+        "size": 10240,
+        "type": "disk",
+        "tier": "maxiops"
+      }
+    ]
+  },
+  "tags": [],
+  "user_data": "",
+  "vendor_data": ""
+}
+""")
+
+UC_METADATA["user_data"] = b"""#cloud-config
+runcmd:
+- [touch, /root/cloud-init-worked ]
+"""
+
+MD_URL = 'http://169.254.169.254/metadata/v1.json'
+
+
+def _mock_dmi():
+    return True, "00322b68-0096-4042-9406-faad61922128"
+
+
+class TestUpCloudMetadata(CiTestCase):
+    """
+    Test reading the meta-data
+    """
+    def setUp(self):
+        super(TestUpCloudMetadata, self).setUp()
+        self.tmp = self.tmp_dir()
+
+    def get_ds(self, get_sysinfo=_mock_dmi):
+        ds = DataSourceUpCloud(
+            settings.CFG_BUILTIN, None, helpers.Paths({'run_dir': self.tmp}))
+        if get_sysinfo:
+            ds._get_sysinfo = get_sysinfo
+        return ds
+
+    @mock.patch('cloudinit.sources.helpers.upcloud.read_sysinfo')
+    def test_returns_false_not_on_upcloud(self, m_read_sysinfo):
+        m_read_sysinfo.return_value = (False, None)
+        ds = self.get_ds(get_sysinfo=None)
+        self.assertEqual(False, ds.get_data())
+        self.assertTrue(m_read_sysinfo.called)
+
+    @mock.patch('cloudinit.sources.helpers.upcloud.read_metadata')
+    def test_metadata(self, mock_readmd):
+        mock_readmd.return_value = UC_METADATA.copy()
+
+        ds = self.get_ds()
+        ds.perform_dhcp_setup = False
+
+        ret = ds.get_data()
+        self.assertTrue(ret)
+
+        self.assertTrue(mock_readmd.called)
+
+        self.assertEqual(UC_METADATA.get('user_data'), ds.get_userdata_raw())
+        self.assertEqual(UC_METADATA.get('vendor_data'),
+                         ds.get_vendordata_raw())
+        self.assertEqual(UC_METADATA.get('region'), ds.availability_zone)
+        self.assertEqual(UC_METADATA.get('instance_id'), ds.get_instance_id())
+        self.assertEqual(UC_METADATA.get('cloud_name'), ds.cloud_name)
+
+        self.assertEqual(UC_METADATA.get('public_keys'),
+                         ds.get_public_ssh_keys())
+        self.assertIsInstance(ds.get_public_ssh_keys(), list)
+
+
+class TestUpCloudNetworkSetup(CiTestCase):
+    """
+    Test reading the meta-data on networked context
+    """
+
+    def setUp(self):
+        super(TestUpCloudNetworkSetup, self).setUp()
+        self.tmp = self.tmp_dir()
+
+    def get_ds(self, get_sysinfo=_mock_dmi):
+        ds = DataSourceUpCloudLocal(
+            settings.CFG_BUILTIN, None, helpers.Paths({'run_dir': self.tmp}))
+        if get_sysinfo:
+            ds._get_sysinfo = get_sysinfo
+        return ds
+
+    @mock.patch('cloudinit.sources.helpers.upcloud.read_metadata')
+    @mock.patch('cloudinit.net.find_fallback_nic')
+    @mock.patch('cloudinit.net.dhcp.maybe_perform_dhcp_discovery')
+    @mock.patch('cloudinit.net.dhcp.EphemeralIPv4Network')
+    def test_network_configured_metadata(self, m_net, m_dhcp,
+                                         m_fallback_nic, mock_readmd):
+        mock_readmd.return_value = UC_METADATA.copy()
+
+        m_fallback_nic.return_value = 'eth1'
+        m_dhcp.return_value = [{
+            'interface': 'eth1', 'fixed-address': '10.6.3.27',
+            'routers': '10.6.0.1', 'subnet-mask': '22',
+            'broadcast-address': '10.6.3.255'}
+        ]
+
+        ds = self.get_ds()
+
+        ret = ds.get_data()
+        self.assertTrue(ret)
+
+        self.assertTrue(m_dhcp.called)
+        m_dhcp.assert_called_with('eth1', None)
+
+        m_net.assert_called_once_with(
+            broadcast='10.6.3.255', interface='eth1',
+            ip='10.6.3.27', prefix_or_mask='22',
+            router='10.6.0.1', static_routes=None
+        )
+
+        self.assertTrue(mock_readmd.called)
+
+        self.assertEqual(UC_METADATA.get('region'), ds.availability_zone)
+        self.assertEqual(UC_METADATA.get('instance_id'), ds.get_instance_id())
+        self.assertEqual(UC_METADATA.get('cloud_name'), ds.cloud_name)
+
+    @mock.patch('cloudinit.sources.helpers.upcloud.read_metadata')
+    @mock.patch('cloudinit.net.get_interfaces_by_mac')
+    def test_network_configuration(self, m_get_by_mac, mock_readmd):
+        mock_readmd.return_value = UC_METADATA.copy()
+
+        raw_ifaces = UC_METADATA.get('network').get('interfaces')
+        self.assertEqual(4, len(raw_ifaces))
+
+        m_get_by_mac.return_value = {
+            raw_ifaces[0].get('mac'): 'eth0',
+            raw_ifaces[1].get('mac'): 'eth1',
+            raw_ifaces[2].get('mac'): 'eth2',
+            raw_ifaces[3].get('mac'): 'eth3',
+        }
+
+        ds = self.get_ds()
+        ds.perform_dhcp_setup = False
+
+        ret = ds.get_data()
+        self.assertTrue(ret)
+
+        self.assertTrue(mock_readmd.called)
+
+        netcfg = ds.network_config
+
+        self.assertEqual(1, netcfg.get('version'))
+
+        config = netcfg.get('config')
+        self.assertIsInstance(config, list)
+        self.assertEqual(5, len(config))
+        self.assertEqual('physical', config[3].get('type'))
+
+        self.assertEqual(raw_ifaces[2].get('mac'), config[2]
+                         .get('mac_address'))
+        self.assertEqual(1, len(config[2].get('subnets')))
+        self.assertEqual('ipv6_dhcpv6-stateless', config[2].get('subnets')[0]
+                         .get('type'))
+
+        self.assertEqual(2, len(config[0].get('subnets')))
+        self.assertEqual('static', config[0].get('subnets')[1].get('type'))
+
+        dns = config[4]
+        self.assertEqual('nameserver', dns.get('type'))
+        self.assertEqual(2, len(dns.get('address')))
+        self.assertEqual(
+            UC_METADATA.get('network').get('dns')[1],
+            dns.get('address')[1]
+        )
+
+
+class TestUpCloudDatasourceLoading(CiTestCase):
+    def test_get_datasource_list_returns_in_local(self):
+        deps = (sources.DEP_FILESYSTEM, )
+        ds_list = sources.DataSourceUpCloud.get_datasource_list(deps)
+        self.assertEqual(ds_list,
+                         [DataSourceUpCloudLocal])
+
+    def test_get_datasource_list_returns_in_normal(self):
+        deps = (sources.DEP_FILESYSTEM, sources.DEP_NETWORK)
+        ds_list = sources.DataSourceUpCloud.get_datasource_list(deps)
+        self.assertEqual(ds_list,
+                         [DataSourceUpCloud])
+
+    def test_list_sources_finds_ds(self):
+        found = sources.list_sources(
+            ['UpCloud'], (sources.DEP_FILESYSTEM, sources.DEP_NETWORK),
+            ['cloudinit.sources'])
+        self.assertEqual([DataSourceUpCloud],
+                         found)
+
+# vi: ts=4 expandtab
diff --git a/tools/ds-identify b/tools/ds-identify
index 496dbb8a..2f2486f7 100755
--- a/tools/ds-identify
+++ b/tools/ds-identify
@@ -125,7 +125,7 @@ DI_DSNAME=""
 # be searched if there is no setting found in config.
 DI_DSLIST_DEFAULT="MAAS ConfigDrive NoCloud AltCloud Azure Bigstep \
 CloudSigma CloudStack DigitalOcean AliYun Ec2 GCE OpenNebula OpenStack \
-OVF SmartOS Scaleway Hetzner IBMCloud Oracle Exoscale RbxCloud"
+OVF SmartOS Scaleway Hetzner IBMCloud Oracle Exoscale RbxCloud UpCloud"
 DI_DSLIST=""
 DI_MODE=""
 DI_ON_FOUND=""
@@ -883,6 +883,11 @@ dscheck_RbxCloud() {
     return ${DS_NOT_FOUND}
 }
 
+dscheck_UpCloud() {
+    dmi_sys_vendor_is UpCloud && return ${DS_FOUND}
+    return ${DS_NOT_FOUND}
+}
+
 ovf_vmware_guest_customization() {
     # vmware guest customization