Merge lp:~ubuntudotcom1/maas/bug-1391228 into lp:~maas-committers/maas/trunk

[ubuntudotcom1]

Addresses bug 1391228 with a new api operation for retrieving event logs (per the MAAS team Event API spec).

Addresses bug 1391228 with a new api operation for retrieving event logs (per the MAAS team Event API spec).

[Blake Rouse (blake-rouse)]

Overall the implementation looks good. Just a few things that need to be fixed. The biggest one is that 'id' should be renamed to 'system_id'.

review: Needs Fixing

[ubuntudotcom1 (ubuntudotcom1)]

Address comments. Moved log levels to inverse dict in models/eventtype.py as LOGGING_LEVELS_BY_NAME.

[Blake Rouse (blake-rouse)]

Thanks for all the fixes. Looks good.

review: Approve

[MAAS Lander (maas-lander)]

The attempt to merge lp:~ubuntudotcom1/maas/bug-1391228 into lp:maas failed. Below is the output from the failed tests.

Ign http://security.ubuntu.com trusty-security InRelease
Get:1 http://security.ubuntu.com trusty-security Release.gpg [933 B]
Ign http://nova.clouds.archive.ubuntu.com trusty InRelease
Get:2 http://security.ubuntu.com trusty-security Release [63.5 kB]
Ign http://nova.clouds.archive.ubuntu.com trusty-updates InRelease
Hit http://nova.clouds.archive.ubuntu.com trusty Release.gpg
Get:3 http://nova.clouds.archive.ubuntu.com trusty-updates Release.gpg [933 B]
Hit http://nova.clouds.archive.ubuntu.com trusty Release
Get:4 http://nova.clouds.archive.ubuntu.com trusty-updates Release [63.5 kB]
Get:5 http://security.ubuntu.com trusty-security/main Sources [76.1 kB]
Get:6 http://security.ubuntu.com trusty-security/universe Sources [19.1 kB]
Hit http://nova.clouds.archive.ubuntu.com trusty/main Sources
Get:7 http://security.ubuntu.com trusty-security/main amd64 Packages [251 kB]
Hit http://nova.clouds.archive.ubuntu.com trusty/universe Sources
Hit http://nova.clouds.archive.ubuntu.com trusty/main amd64 Packages
Hit http://nova.clouds.archive.ubuntu.com trusty/universe amd64 Packages
Hit http://nova.clouds.archive.ubuntu.com trusty/main Translation-en
Get:8 http://security.ubuntu.com trusty-security/universe amd64 Packages [91.6 kB]
Hit http://nova.clouds.archive.ubuntu.com trusty/universe Translation-en
Get:9 http://nova.clouds.archive.ubuntu.com trusty-updates/main Sources [190 kB]
Hit http://security.ubuntu.com trusty-security/main Translation-en
Hit http://security.ubuntu.com trusty-security/universe Translation-en
Get:10 http://nova.clouds.archive.ubuntu.com trusty-updates/universe Sources [108 kB]
Get:11 http://nova.clouds.archive.ubuntu.com trusty-updates/main amd64 Packages [490 kB]
Get:12 http://nova.clouds.archive.ubuntu.com trusty-updates/universe amd64 Packages [263 kB]
Hit http://nova.clouds.archive.ubuntu.com trusty-updates/main Translation-en
Hit http://nova.clouds.archive.ubuntu.com trusty-updates/universe Translation-en
Ign http://nova.clouds.archive.ubuntu.com trusty/main Translation-en_US
Ign http://nova.clouds.archive.ubuntu.com trusty/universe Translation-en_US
Fetched 1,618 kB in 3s (488 kB/s)
Reading package lists...
sudo DEBIAN_FRONTEND=noninteractive apt-get -y \
     --no-install-recommends install apache2 authbind bind9 bind9utils build-essential bzr-builddeb chromium-browser chromium-chromedriver curl daemontools debhelper dh-apport dh-systemd distro-info dnsutils firefox freeipmi-tools gjs ipython isc-dhcp-common libjs-angularjs libjs-jquery libjs-jquery-hotkeys libjs-yui3-full libjs-yui3-min libpq-dev make nodejs-legacy npm pep8 postgresql pyflakes python-apt python-bson python-bzrlib python-convoy python-coverage python-crochet python-cssselect python-curtin python-dev python-distro-info python-django python-django-piston python-django-south python-djorm-ext-pgarray python-docutils python-extras python-fixtures python-flake8 python-formencode python-hivex python-httplib2 python-iscpy python-jinja2 python-jsonschema python-lockfile python-lxml python-mock python-netaddr python-netifaces python-nose python-...

[MAAS Lander (maas-lander)]

The attempt to merge lp:~ubuntudotcom1/maas/bug-1391228 into lp:maas failed. Below is the output from the failed tests.

Ign http://security.ubuntu.com trusty-security InRelease
Hit http://security.ubuntu.com trusty-security Release.gpg
Hit http://security.ubuntu.com trusty-security Release
Ign http://nova.clouds.archive.ubuntu.com trusty InRelease
Ign http://nova.clouds.archive.ubuntu.com trusty-updates InRelease
Hit http://nova.clouds.archive.ubuntu.com trusty Release.gpg
Hit http://nova.clouds.archive.ubuntu.com trusty-updates Release.gpg
Hit http://nova.clouds.archive.ubuntu.com trusty Release
Hit http://security.ubuntu.com trusty-security/main Sources
Hit http://nova.clouds.archive.ubuntu.com trusty-updates Release
Hit http://security.ubuntu.com trusty-security/universe Sources
Hit http://nova.clouds.archive.ubuntu.com trusty/main Sources
Hit http://security.ubuntu.com trusty-security/main amd64 Packages
Hit http://security.ubuntu.com trusty-security/universe amd64 Packages
Hit http://nova.clouds.archive.ubuntu.com trusty/universe Sources
Hit http://security.ubuntu.com trusty-security/main Translation-en
Hit http://security.ubuntu.com trusty-security/universe Translation-en
Hit http://nova.clouds.archive.ubuntu.com trusty/main amd64 Packages
Hit http://nova.clouds.archive.ubuntu.com trusty/universe amd64 Packages
Hit http://nova.clouds.archive.ubuntu.com trusty/main Translation-en
Hit http://nova.clouds.archive.ubuntu.com trusty/universe Translation-en
Hit http://nova.clouds.archive.ubuntu.com trusty-updates/main Sources
Hit http://nova.clouds.archive.ubuntu.com trusty-updates/universe Sources
Hit http://nova.clouds.archive.ubuntu.com trusty-updates/main amd64 Packages
Hit http://nova.clouds.archive.ubuntu.com trusty-updates/universe amd64 Packages
Hit http://nova.clouds.archive.ubuntu.com trusty-updates/main Translation-en
Hit http://nova.clouds.archive.ubuntu.com trusty-updates/universe Translation-en
Ign http://nova.clouds.archive.ubuntu.com trusty/main Translation-en_US
Ign http://nova.clouds.archive.ubuntu.com trusty/universe Translation-en_US
Reading package lists...
sudo DEBIAN_FRONTEND=noninteractive apt-get -y \
     --no-install-recommends install apache2 authbind bind9 bind9utils build-essential bzr-builddeb chromium-browser chromium-chromedriver curl daemontools debhelper dh-apport dh-systemd distro-info dnsutils firefox freeipmi-tools gjs ipython isc-dhcp-common libjs-angularjs libjs-jquery libjs-jquery-hotkeys libjs-yui3-full libjs-yui3-min libpq-dev make nodejs-legacy npm pep8 postgresql pyflakes python-apt python-bson python-bzrlib python-convoy python-coverage python-crochet python-cssselect python-curtin python-dev python-distro-info python-django python-django-piston python-django-south python-djorm-ext-pgarray python-docutils python-extras python-fixtures python-flake8 python-formencode python-hivex python-httplib2 python-iscpy python-jinja2 python-jsonschema python-lockfile python-lxml python-mock python-netaddr python-netifaces python-nose python-oauth python-openssl python-paramiko python-pexpect python-pip python-pocket-lint python-psycopg2 python-pyinotify python-pyparsing python-seamicroclient python-simplejson ...

=== modified file 'src/maasserver/api/nodes.py'
--- src/maasserver/api/nodes.py	2015-03-30 18:17:56 +0000
+++ src/maasserver/api/nodes.py	2015-04-03 19:28:00 +0000
@@ -5,7 +5,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -14,17 +14,22 @@
     "AnonNodesHandler",
     "NodeHandler",
     "NodesHandler",
+    "EventsHandler",
     "store_node_power_parameters",
-    ]
+]
 
 from base64 import b64decode
+import logging
+import urllib
 
 import bson
 import crochet
 from django.conf import settings
 from django.core.exceptions import PermissionDenied
+from django.core.urlresolvers import reverse
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404
+from formencode.validators import Int
 from maasserver import locks
 from maasserver.api.logger import maaslog
 from maasserver.api.support import (
@@ -38,6 +43,7 @@
     get_oauth_token,
     get_optional_list,
     get_optional_param,
+    get_overridden_query_dict,
 )
 from maasserver.clusterrpc.power_parameters import get_power_types
 from maasserver.dns.config import dns_update_zones
@@ -64,9 +70,11 @@
     NodeActionForm,
 )
 from maasserver.models import (
+    Event,
     MACAddress,
     Node,
 )
+from maasserver.models.eventtype import LOGGING_LEVELS_BY_NAME
 from maasserver.models.node import RELEASABLE_STATUSES
 from maasserver.models.nodeprobeddetails import get_single_probed_details
 from maasserver.node_action import Commission
@@ -74,6 +82,7 @@
 from maasserver.rpc import getClientFor
 from maasserver.utils import find_nodegroup
 from maasserver.utils.orm import get_first
+from maasserver.views.nodes import event_to_dict
 from piston.utils import rc
 from provisioningserver.power.poweraction import (
     PowerActionFail,
@@ -118,8 +127,11 @@
         'model',
         'serial',
         'tags',
-        )),
-    )
+    )),
+)
+
+MAX_EVENT_LOG_COUNT = 1000
+DEFAULT_EVENT_LOG_LIMIT = 100
 
 
 def store_node_power_parameters(node, request):
@@ -148,6 +160,195 @@
     node.save()
 
 
+def filtered_nodes_list_from_request(request):
+    """List Nodes visible to the user, optionally filtered by criteria.
+
+    :param hostname: An optional hostname. Only events relating to the node
+        with the matching hostname will be returned. This can be specified
+        multiple times to get events relating to more than one node.
+    :param mac_address: An optional MAC address. Only events relating to the
+        node owning the specified MAC address will be returned. This can be
+        specified multiple times to get events relating to more than one node.
+    :param id: An optional list of system ids.  Only events relating to the
+        nodes with matching system ids will be returned.
+    :param zone: An optional name for a physical zone. Only events relating to
+        the nodes in the zone will be returned.
+    :param agent_name: An optional agent name.  Only events relating to the
+        nodes with matching agent names will be returned.
+    """
+    # Get filters from request.
+    match_ids = get_optional_list(request.GET, 'id')
+
+    match_macs = get_optional_list(request.GET, 'mac_address')
+    if match_macs is not None:
+        invalid_macs = [
+            mac for mac in match_macs if MAC_RE.match(mac) is None]
+        if len(invalid_macs) != 0:
+            raise MAASAPIValidationError(
+                "Invalid MAC address(es): %s" % ", ".join(invalid_macs))
+
+    # Fetch nodes and apply filters.
+    nodes = Node.nodes.get_nodes(
+        request.user, NODE_PERMISSION.VIEW, ids=match_ids)
+    if match_macs is not None:
+        nodes = nodes.filter(macaddress__mac_address__in=match_macs)
+    match_hostnames = get_optional_list(request.GET, 'hostname')
+    if match_hostnames is not None:
+        nodes = nodes.filter(hostname__in=match_hostnames)
+    match_zone_name = request.GET.get('zone', None)
+    if match_zone_name is not None:
+        nodes = nodes.filter(zone__name=match_zone_name)
+    match_agent_name = request.GET.get('agent_name', None)
+    if match_agent_name is not None:
+        nodes = nodes.filter(agent_name=match_agent_name)
+
+    return nodes
+
+
+class EventsHandler(OperationsHandler):
+    """Retrieve filtered node events.
+
+    A specific Node's events is identified by specifying one or more
+    ids, hostnames, or mac addresses as a list.
+    """
+    api_doc_section_name = "Events"
+
+    create = read = update = delete = None
+
+    model = Event
+
+    all_params = (
+        'after',
+        'agent_name',
+        'id',
+        'level',
+        'limit',
+        'mac_address',
+        'op',
+        'zone')
+
+    @classmethod
+    def resource_uri(cls, *args, **kwargs):
+        return ('events_handler', [])
+
+    @operation(idempotent=True)
+    def query(self, request):
+        """List Node events, optionally filtered by various criteria via
+        URL query parameters.
+
+        :param hostname: An optional hostname. Only events relating to the node
+            with the matching hostname will be returned. This can be specified
+            multiple times to get events relating to more than one node.
+        :param mac_address: An optional list of MAC addresses.  Only
+            nodes with matching MAC addresses will be returned.
+        :param id: An optional list of system ids.  Only nodes with
+            matching system ids will be returned.
+        :param zone: An optional name for a physical zone. Only nodes in the
+            zone will be returned.
+        :param agent_name: An optional agent name.  Only nodes with
+            matching agent names will be returned.
+        :param level: Desired minimum log level of returned events. Returns
+            this level of events and greater. Choose from: %(log_levels)s.
+            The default is INFO.
+        """
+
+        # Filter first by optional node id, hostname, or mac
+        nodes = filtered_nodes_list_from_request(request)
+        limit = get_optional_param(
+            request.GET, "limit", DEFAULT_EVENT_LOG_LIMIT, Int)
+
+        start_event_id_param = get_optional_param(
+            request.GET, 'after', None, Int)
+
+        log_level = get_optional_param(request.GET, 'level', 'INFO')
+
+        if limit > MAX_EVENT_LOG_COUNT:
+            raise MAASAPIBadRequest((
+                "Requested number of events %d is greater than"
+                " limit: %d") % (limit, MAX_EVENT_LOG_COUNT))
+
+        if start_event_id_param is not None:
+            node_events = Event.objects.filter(
+                id__gte=start_event_id_param,
+                node=nodes)
+            start_event_id = start_event_id_param
+        else:
+            node_events = Event.objects.filter(node=nodes)
+            start_event_id = 0
+
+        # Filter next by log level >= to 'level', if specified
+        if log_level is None and log_level != 'NOTSET':
+            numeric_log_level = logging.NOTSET
+        elif log_level in LOGGING_LEVELS_BY_NAME:
+            numeric_log_level = LOGGING_LEVELS_BY_NAME[log_level]
+            assert isinstance(numeric_log_level, int)
+        else:
+            raise MAASAPIBadRequest(
+                "Unknown log level: %s" % log_level)
+
+        if log_level is not None and log_level != 'NOTSET':
+            node_events = node_events.exclude(
+                type__level__lt=numeric_log_level)
+
+        # Future feature:
+        # This is where we would filter for events 'since last node deployment'
+        # using a query param like since_last_deployed=true, but we aren't
+        # right now because we don't currently record a timestamp of the last
+        # deployment, and we don't have an event subtype for node status
+        # changes to filter for the deploying status event.
+
+        base_path = reverse('events_handler')
+
+        prev_uri_params = get_overridden_query_dict(
+            request.GET,
+            {'after': max(0, start_event_id - limit)}, self.all_params)
+        prev_uri = '%s?%s' % (base_path,
+                              urllib.urlencode(
+                                  prev_uri_params,
+                                  doseq=True))
+
+        next_uri_params = get_overridden_query_dict(
+            request.GET,
+            {'after': start_event_id + limit}, self.all_params)
+        next_uri = '%s?%s' % (base_path,
+                              urllib.urlencode(
+                                  next_uri_params,
+                                  doseq=True))
+
+        node_events = (
+            node_events.all().order_by('id')
+            .prefetch_related('type')
+            .prefetch_related('node'))
+
+        # Lastly, order by id and return up to 'limit' events
+        if start_event_id_param is not None:
+            # If start_event_id is specified, limit to a window of
+            # 'limit' events with 'start_event_id' being the id
+            # of the oldest event
+            node_events = node_events.order_by('id')
+            node_events = reversed(node_events[:limit])
+        else:
+            # If start_event_id is not specified, limit to most recent
+            # 'limit' events
+            node_events = node_events.order_by('-id')
+            node_events = node_events[:limit]
+
+        # We need to load all of these events at some point, so save them
+        # into a list now so that len() is cheap.
+        node_events = list(node_events)
+
+        displayed_events_count = len(node_events)
+        events_dict = dict(
+            count=displayed_events_count,
+            events=[event_to_dict(event) for event in node_events],
+            next_uri=next_uri,
+            prev_uri=prev_uri,
+        )
+        return events_dict
+
+    query.__doc__ %= {"log_levels": ", ".join(LOGGING_LEVELS_BY_NAME)}
+
+
 class NodeHandler(OperationsHandler):
     """Manage an individual Node.
 
@@ -174,7 +375,7 @@
         old_deployed_status_aliases = [
             NODE_STATUS.RELEASING, NODE_STATUS.DISK_ERASING,
             NODE_STATUS.FAILED_RELEASING, NODE_STATUS.FAILED_DISK_ERASING,
-            ]
+        ]
         deployed_aliases = (
             old_allocated_status_aliases + old_deployed_status_aliases)
         if node.status in deployed_aliases:
@@ -515,9 +716,9 @@
             alloc_type=IPADDRESS_TYPE.STICKY, ip=address)
 
         if len(deallocated_ips) == 0 and address is not None:
-                raise MAASAPIBadRequest(
-                    "%s: could not deallocate sticky IP address: %s",
-                    node.hostname, address)
+            raise MAASAPIBadRequest(
+                "%s: could not deallocate sticky IP address: %s",
+                node.hostname, address)
         else:
             maaslog.info(
                 "%s: Sticky IP address(es) deallocated: %s", node.hostname,
@@ -909,7 +1110,7 @@
             'commissioning': NODE_STATUS.COMMISSIONING,
             'failed_tests': NODE_STATUS.FAILED_COMMISSIONING,
             'minutes': settings.COMMISSIONING_TIMEOUT
-            }
+        }
         query = Node.nodes.raw("""
             UPDATE maasserver_node
             SET
@@ -978,48 +1179,7 @@
 
     @operation(idempotent=True)
     def list(self, request):
-        """List Nodes visible to the user, optionally filtered by criteria.
-
-        :param hostname: An optional list of hostnames.  Only nodes with
-            matching hostnames will be returned.
-        :type hostname: iterable
-        :param mac_address: An optional list of MAC addresses.  Only
-            nodes with matching MAC addresses will be returned.
-        :type mac_address: iterable
-        :param id: An optional list of system ids.  Only nodes with
-            matching system ids will be returned.
-        :type id: iterable
-        :param zone: An optional name for a physical zone. Only nodes in the
-            zone will be returned.
-        :type zone: unicode
-        :param agent_name: An optional agent name.  Only nodes with
-            matching agent names will be returned.
-        :type agent_name: unicode
-        """
-        # Get filters from request.
-        match_ids = get_optional_list(request.GET, 'id')
-        match_macs = get_optional_list(request.GET, 'mac_address')
-        if match_macs is not None:
-            invalid_macs = [
-                mac for mac in match_macs if MAC_RE.match(mac) is None]
-            if len(invalid_macs) != 0:
-                raise MAASAPIValidationError(
-                    "Invalid MAC address(es): %s" % ", ".join(invalid_macs))
-
-        # Fetch nodes and apply filters.
-        nodes = Node.nodes.get_nodes(
-            request.user, NODE_PERMISSION.VIEW, ids=match_ids)
-        if match_macs is not None:
-            nodes = nodes.filter(macaddress__mac_address__in=match_macs)
-        match_hostnames = get_optional_list(request.GET, 'hostname')
-        if match_hostnames is not None:
-            nodes = nodes.filter(hostname__in=match_hostnames)
-        match_zone_name = request.GET.get('zone', None)
-        if match_zone_name is not None:
-            nodes = nodes.filter(zone__name=match_zone_name)
-        match_agent_name = request.GET.get('agent_name', None)
-        if match_agent_name is not None:
-            nodes = nodes.filter(agent_name=match_agent_name)
+        nodes = filtered_nodes_list_from_request(request)
 
         # Prefetch related objects that are needed for rendering the result.
         nodes = nodes.prefetch_related('macaddress_set__node')

=== modified file 'src/maasserver/api/tests/test_nodes.py'
--- src/maasserver/api/tests/test_nodes.py	2015-03-27 06:41:39 +0000
+++ src/maasserver/api/tests/test_nodes.py	2015-04-03 19:28:00 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -15,26 +15,39 @@
 __all__ = []
 
 import httplib
+from itertools import combinations
 import json
+import logging
 import random
+from random import randint
+from urlparse import (
+    parse_qsl,
+    urlparse,
+)
 
 import crochet
 from django.core.urlresolvers import reverse
+from django.http import QueryDict
 from maasserver import forms
 from maasserver.api import nodes as nodes_module
+from maasserver.api.utils import get_overridden_query_dict
 from maasserver.enum import (
     NODE_STATUS,
     NODE_STATUS_CHOICES_DICT,
     NODEGROUP_STATUS,
     NODEGROUPINTERFACE_MANAGEMENT,
 )
-from maasserver.exceptions import ClusterUnavailable
+from maasserver.exceptions import (
+    ClusterUnavailable,
+    MAASAPIValidationError,
+)
 from maasserver.fields import MAC
 from maasserver.models import (
     Config,
     Node,
     NodeGroup,
 )
+from maasserver.models.eventtype import LOGGING_LEVELS
 from maasserver.models.node import RELEASABLE_STATUSES
 from maasserver.models.user import (
     create_auth_token,
@@ -77,7 +90,7 @@
     scenarios = [
         ('user', dict(userfactory=factory.make_User)),
         ('admin', dict(userfactory=factory.make_admin)),
-        ]
+    ]
 
     def test_GET_list_returns_fqdn_with_domain_name_from_cluster(self):
         # If DNS management is enabled, the domain part of a hostname
@@ -155,6 +168,807 @@
     return [node.get('system_id') for node in parsed_result]
 
 
+def extract_system_ids_from_nodes(nodes):
+    return [node.system_id for node in nodes]
+
+
+def extract_event_desc(parsed_result):
+    """List the system_ids of the nodes in `parsed_result`'s events."""
+    return [event.get('description') for event in parsed_result['events']]
+
+
+def extract_event_ids(parsed_result):
+    """List the system_ids of the nodes in `parsed_result`'s events."""
+    return [event.get('id') for event in parsed_result['events']]
+
+
+class RequestFixture:
+    def __init__(self, dict, fields):
+        self.user = factory.make_User()
+        self.GET = get_overridden_query_dict(dict, QueryDict(''), fields)
+
+
+class TestFilteredNodesListFromRequest(APITestCase):
+
+    def test_node_list_with_id_returns_matching_nodes(self):
+        # The "list" operation takes optional "id" parameters.  Only
+        # nodes with matching ids will be returned.
+        ids = [factory.make_Node().system_id for _ in range(3)]
+        matching_id = ids[0]
+        query = RequestFixture({'id': [matching_id]}, 'id')
+        response = nodes_module.filtered_nodes_list_from_request(query)
+
+        self.assertItemsEqual(
+            [matching_id],
+            extract_system_ids_from_nodes(response))
+
+    def test_node_list_with_nonexistent_id_returns_empty_list(self):
+        # Trying to list a nonexistent node id returns a list containing
+        # no nodes -- even if other (non-matching) nodes exist.
+        existing_id = factory.make_Node().system_id
+        nonexistent_id = existing_id + factory.make_string()
+        query = RequestFixture({'id': [nonexistent_id]}, 'id')
+        response = nodes_module.filtered_nodes_list_from_request(query)
+
+        self.assertItemsEqual(
+            [],
+            extract_system_ids_from_nodes(response))
+
+    def test_node_list_with_ids_orders_by_id(self):
+        # Even when ids are passed to "list," nodes are returned in id
+        # order, not necessarily in the order of the id arguments.
+        ids = [factory.make_Node().system_id for _ in range(3)]
+        random.shuffle(ids)
+
+        query = RequestFixture({'id': list(ids)}, 'id')
+        response = nodes_module.filtered_nodes_list_from_request(query)
+
+        self.assertSequenceEqual(
+            sorted(ids),
+            extract_system_ids_from_nodes(response))
+
+    def test_node_list_with_some_matching_ids_returns_matching_nodes(self):
+        # If some nodes match the requested ids and some don't, only the
+        # matching ones are returned.
+        existing_id = factory.make_Node().system_id
+        nonexistent_id = existing_id + factory.make_string()
+
+        query = RequestFixture({'id': [existing_id, nonexistent_id]}, 'id')
+        response = nodes_module.filtered_nodes_list_from_request(query)
+
+        self.assertItemsEqual(
+            [existing_id],
+            extract_system_ids_from_nodes(response))
+
+    def test_node_list_with_hostname_returns_matching_nodes(self):
+        # The list operation takes optional "hostname" parameters. Only nodes
+        # with matching hostnames will be returned.
+        nodes = [factory.make_Node() for _ in range(3)]
+        matching_hostname = nodes[0].hostname
+        matching_system_id = nodes[0].system_id
+
+        query = RequestFixture({'hostname': [matching_hostname]}, 'hostname')
+        response = nodes_module.filtered_nodes_list_from_request(query)
+
+        self.assertItemsEqual(
+            [matching_system_id],
+            extract_system_ids_from_nodes(response))
+
+    def test_node_list_with_macs_returns_matching_nodes(self):
+        # The "list" operation takes optional "mac_address" parameters. Only
+        # nodes with matching MAC addresses will be returned.
+        macs = [factory.make_MACAddress_with_Node() for _ in range(3)]
+        matching_mac = unicode(macs[0].mac_address)
+        matching_system_id = macs[0].node.system_id
+
+        query = RequestFixture({'mac_address': [matching_mac]}, 'mac_address')
+        response = nodes_module.filtered_nodes_list_from_request(query)
+
+        self.assertItemsEqual(
+            [matching_system_id],
+            extract_system_ids_from_nodes(response))
+
+    def test_node_list_with_invalid_macs_returns_sensible_error(self):
+        # If specifying an invalid MAC, make sure the error that's
+        # returned is not a crazy stack trace, but something nice to
+        # humans.
+        bad_mac1 = '00:E0:81:DD:D1:ZZ'  # ZZ is bad.
+        bad_mac2 = '00:E0:81:DD:D1:XX'  # XX is bad.
+        ok_mac = unicode(factory.make_MACAddress_with_Node())
+        mac_list = [bad_mac1, bad_mac2, ok_mac]
+
+        query = RequestFixture({'mac_address': mac_list}, 'mac_address')
+        expected_msg = ("[u'Invalid MAC address(es): 00:E0:81:DD:D1:ZZ, "
+                        "00:E0:81:DD:D1:XX']")
+
+        ex = self.assertRaises(MAASAPIValidationError,
+                               nodes_module.filtered_nodes_list_from_request,
+                               query)
+        self.assertEqual(expected_msg, unicode(ex))
+
+    def test_node_list_with_agent_name_filters_by_agent_name(self):
+        non_listed_node = factory.make_Node(
+            agent_name=factory.make_name('agent_name'))
+        ignore_unused(non_listed_node)
+        agent_name = factory.make_name('agent-name')
+        node = factory.make_Node(agent_name=agent_name)
+
+        query = RequestFixture({'agent_name': agent_name}, 'agent_name')
+        response = nodes_module.filtered_nodes_list_from_request(query)
+
+        self.assertSequenceEqual(
+            [node.system_id],
+            extract_system_ids_from_nodes(response))
+
+    def test_node_list_with_agent_name_filters_with_empty_string(self):
+        factory.make_Node(agent_name=factory.make_name('agent-name'))
+        node = factory.make_Node(agent_name='')
+
+        query = RequestFixture({'agent_name': ''}, 'agent_name')
+        response = nodes_module.filtered_nodes_list_from_request(query)
+
+        self.assertSequenceEqual(
+            [node.system_id],
+            extract_system_ids_from_nodes(response))
+
+    def test_node_list_without_agent_name_does_not_filter(self):
+        nodes = [
+            factory.make_Node(agent_name=factory.make_name('agent-name'))
+            for _ in range(3)]
+
+        query = RequestFixture({}, '')
+        response = nodes_module.filtered_nodes_list_from_request(query)
+
+        self.assertSequenceEqual(
+            [node.system_id for node in nodes],
+            extract_system_ids_from_nodes(response))
+
+    def test_node_list_doesnt_list_devices(self):
+        nodes = [
+            factory.make_Node(agent_name=factory.make_name('agent-name'))
+            for _ in range(3)]
+        # Create devices.
+        nodes = [
+            factory.make_Node(installable=False)
+            for _ in range(3)]
+
+        query = RequestFixture({}, '')
+        response = nodes_module.filtered_nodes_list_from_request(query)
+
+        system_ids = extract_system_ids_from_nodes(response)
+        self.assertEqual(
+            [],
+            [node.system_id for node in nodes if node.system_id in system_ids],
+            "Node listing contains devices.")
+
+    def test_node_list_with_zone_filters_by_zone(self):
+        non_listed_node = factory.make_Node(
+            zone=factory.make_Zone(name='twilight'))
+        ignore_unused(non_listed_node)
+        zone = factory.make_Zone()
+        node = factory.make_Node(zone=zone)
+
+        query = RequestFixture({'zone': zone.name}, 'zone')
+        response = nodes_module.filtered_nodes_list_from_request(query)
+
+        self.assertSequenceEqual(
+            [node.system_id], extract_system_ids_from_nodes(response))
+
+    def test_node_list_without_zone_does_not_filter(self):
+        nodes = [factory.make_Node(zone=factory.make_Zone())
+                 for _ in range(3)]
+
+        query = RequestFixture({}, '')
+        response = nodes_module.filtered_nodes_list_from_request(query)
+
+        self.assertSequenceEqual(
+            [node.system_id for node in nodes],
+            extract_system_ids_from_nodes(response))
+
+
+def make_events_with_log_levels(log_levels_dict, events_per_level=2):
+    return [factory.make_Event(
+        type=factory.make_EventType(
+            level=level[1])).id
+            for level in log_levels_dict
+            for _ in range(events_per_level)
+            ]
+
+
+class TestEventsAPI(APITestCase):
+    """Tests for /api/1.0/events/."""
+    log_levels = (('CRITICAL', logging.CRITICAL),
+                  ('ERROR', logging.ERROR),
+                  ('WARNING', logging.WARNING),
+                  ('INFO', logging.INFO),
+                  ('DEBUG', logging.DEBUG),
+                  )
+
+    def test_handler_path(self):
+        self.assertEqual(
+            '/api/1.0/events/', reverse('events_handler'))
+
+    def create_nodes_in_group_with_events(
+            self, nodegroup, number_nodes=2, number_events=2):
+        for _ in range(number_nodes):
+            node = factory.make_Node(nodegroup=nodegroup, mac=True)
+            for _ in range(number_events):
+                factory.make_Event(node=node)
+
+    def test_GET_query_without_events_returns_empty_list(self):
+        # If there are no nodes to list, the "list" op still works but
+        # returns an empty list.
+        response = self.client.get(
+            reverse('events_handler'), {
+                'op': 'query'})
+
+        self.assertItemsEqual(
+            {'count': 0,
+             'events': [],
+             'prev_uri': '',
+             'next_uri': ''},
+            json.loads(response.content))
+
+    def test_GET_query_orders_by_reverse_id(self):
+        # Events are returned in reverse id order (newest first).
+        node = factory.make_Node()
+        event_ids = [factory.make_Event(node=node).id for _ in range(3)]
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'level': 'DEBUG'}
+        )
+        parsed_result = json.loads(response.content)
+        self.assertSequenceEqual(
+            list(reversed(event_ids)), extract_event_ids(parsed_result))
+        self.assertEqual(parsed_result['count'], len(event_ids))
+
+    def test_GET_query_with_id_returns_matching_nodes(self):
+        # The "list" operation takes optional "id" parameters.  Only
+        # events from nodes with matching ids will be returned.
+        nodes = [factory.make_Node() for _ in range(3)]
+        ids = [node.system_id for node in nodes]
+        events = [factory.make_Event(node=node) for node in nodes]
+        matching_id = ids[0]
+        matching_events = events[0].id
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'id': [matching_id],
+            'level': 'DEBUG'
+        })
+        parsed_result = json.loads(response.content)
+        self.assertItemsEqual(
+            [matching_events], extract_event_ids(parsed_result))
+        self.assertEqual(parsed_result['count'], len([matching_events]))
+
+    def test_GET_query_with_nonexistent_id_returns_empty_list(self):
+        # Trying to list events for a nonexistent node id returns a list
+        # containing no nodes -- even if other (non-matching) nodes exist.
+        node = factory.make_Node()
+        [factory.make_Event(node=node) for _ in range(3)]
+        existing_id = node.system_id
+        nonexistent_id = existing_id + factory.make_string()
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'id': [nonexistent_id],
+        })
+        self.assertItemsEqual({'count': 0,
+                               'events': [],
+                               'prev_uri': '',
+                               'next_uri': ''},
+                              json.loads(response.content))
+
+    def test_GET_query_with_ids_orders_by_id_reverse(self):
+        # Even when node ids are passed to "list," events for nodes are
+        # returned in event id order, not necessarily in the order of the
+        # node id arguments.
+        nodes = [factory.make_Node() for _ in range(3)]
+        ids = [node.system_id for node in nodes]
+        events = [factory.make_Event(node=node) for node in nodes]
+        event_ids = [event.id for event in reversed(events)]
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'id': list(reversed(ids)),
+            'level': 'DEBUG'
+        })
+        parsed_result = json.loads(response.content)
+        self.assertSequenceEqual(
+            event_ids, extract_event_ids(parsed_result))
+        self.assertEqual(parsed_result['count'], len(event_ids))
+        self.assertNumQueries(1)
+
+    def test_GET_query_with_some_matching_ids_returns_matching_nodes(self):
+        # If some nodes match the requested ids and some don't, only the
+        # events matching nodes specified are returned.
+        existing_node = factory.make_Node()
+        existing_id = existing_node.system_id
+        existing_event_ids = [
+            factory.make_Event(
+                node=existing_node).id for _ in range(3)]
+        nonexistent_id = existing_id + factory.make_string()
+        # Generate some non-matching events as well
+        [factory.make_Event().id for counter in range(3)]
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'id': [existing_id, nonexistent_id],
+            'level': 'DEBUG'
+        })
+        parsed_result = json.loads(response.content)
+        self.assertItemsEqual(
+            reversed(existing_event_ids), extract_event_ids(parsed_result))
+        self.assertEqual(parsed_result['count'], len(existing_event_ids))
+
+    def test_GET_query_with_hostname_returns_matching_nodes(self):
+        # The list operation takes optional "hostname" parameters. Only events
+        # for nodes with matching hostnames will be returned.
+        nodes = [factory.make_Node() for _ in range(3)]
+        events = [factory.make_Event(node=node) for node in nodes]
+
+        matching_hostname = nodes[0].hostname
+        matching_event_id = events[0].id
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'hostname': [matching_hostname],
+            'level': 'DEBUG'
+        })
+        parsed_result = json.loads(response.content)
+        self.assertItemsEqual(
+            [matching_event_id], extract_event_ids(parsed_result))
+        self.assertEqual(parsed_result['count'], len([matching_event_id]))
+
+    def test_GET_query_with_macs_returns_matching_nodes(self):
+        # The "list" operation takes optional "mac_address" parameters. Only
+        # events for nodes with matching MAC addresses will be returned.
+        macs = [factory.make_MACAddress_with_Node() for _ in range(3)]
+        events = [factory.make_Event(node=mac.node) for mac in macs]
+        matching_mac = macs[0].mac_address
+        matching_event_id = events[0].id
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'mac_address': [matching_mac],
+            'level': 'DEBUG'
+        })
+        parsed_result = json.loads(response.content)
+        self.assertItemsEqual(
+            [matching_event_id], extract_event_ids(parsed_result))
+        self.assertEqual(parsed_result['count'], len([matching_event_id]))
+
+    def test_GET_query_with_invalid_macs_returns_sensible_error(self):
+        # If specifying an invalid MAC, make sure the error that's
+        # returned is not a crazy stack trace, but something nice to
+        # humans.
+        bad_mac1 = '00:E0:81:DD:D1:ZZ'  # ZZ is bad.
+        bad_mac2 = '00:E0:81:DD:D1:XX'  # XX is bad.
+        ok_mac = factory.make_MACAddress_with_Node()
+        [factory.make_Event(node=ok_mac.node) for _ in range(3)]
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'mac_address': [bad_mac1, bad_mac2, ok_mac],
+            'level': 'DEBUG'
+        })
+        observed = response.status_code, response.content
+        expected = (
+            Equals(httplib.BAD_REQUEST),
+            Contains(
+                "Invalid MAC address(es): 00:E0:81:DD:D1:ZZ, "
+                "00:E0:81:DD:D1:XX"),
+        )
+        self.assertThat(observed, MatchesListwise(expected))
+
+    def test_GET_query_with_agent_name_filters_by_agent_name(self):
+        non_listed_node = factory.make_Node(
+            agent_name=factory.make_name('agent_name'))
+        ignore_unused(non_listed_node)
+        agent_name = factory.make_name('agent-name')
+        node = factory.make_Node(agent_name=agent_name)
+
+        [factory.make_Event(node=non_listed_node) for _ in range(3)]
+        matching_event_ids = [
+            factory.make_Event(
+                node=node).id for _ in range(3)]
+
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'agent_name': agent_name,
+            'level': 'DEBUG',
+        })
+
+        self.assertEqual(httplib.OK, response.status_code)
+        parsed_result = json.loads(response.content)
+
+        matching_event_ids = list(reversed(matching_event_ids))
+        self.assertSequenceEqual(
+            matching_event_ids, extract_event_ids(parsed_result))
+        self.assertEqual(parsed_result['count'], len(matching_event_ids))
+
+    def test_GET_query_with_agent_name_filters_with_empty_string(self):
+        non_listed_node = factory.make_Node(
+            agent_name=factory.make_name('agent-name'))
+        node = factory.make_Node(agent_name='')
+
+        [factory.make_Event(node=non_listed_node) for _ in range(3)]
+        matching_event_ids = [
+            factory.make_Event(
+                node=node).id for _ in range(3)]
+
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'agent_name': '',
+            'level': 'DEBUG'
+        })
+        self.assertEqual(httplib.OK, response.status_code)
+        parsed_result = json.loads(response.content)
+        matching_event_ids = list(reversed(matching_event_ids))
+        self.assertSequenceEqual(
+            matching_event_ids, extract_event_ids(parsed_result))
+        self.assertEqual(parsed_result['count'], len(matching_event_ids))
+
+    def test_GET_query_without_agent_name_does_not_filter(self):
+        nodes = [
+            factory.make_Node(agent_name=factory.make_name('agent-name'))
+            for _ in range(3)]
+        matching_event_ids = [
+            factory.make_Event(
+                node=node).id for node in nodes]
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'level': 'DEBUG'
+        }
+        )
+        self.assertEqual(httplib.OK, response.status_code)
+        parsed_result = json.loads(response.content)
+        matching_event_ids = list(reversed(matching_event_ids))
+        self.assertSequenceEqual(
+            matching_event_ids,
+            extract_event_ids(parsed_result))
+        self.assertEqual(parsed_result['count'], len(matching_event_ids))
+
+    def test_GET_query_doesnt_list_devices(self):
+        nodes = [
+            factory.make_Node(agent_name=factory.make_name('agent-name'))
+            for _ in range(3)]
+        [factory.make_Event(node=node) for node in nodes]
+
+        # Create devices.
+        device_nodes = [
+            factory.make_Node(installable=False)
+            for _ in range(3)]
+        [factory.make_Event(node=node) for node in device_nodes]
+
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'level': 'DEBUG',
+        }
+        )
+        self.assertEqual(httplib.OK, response.status_code)
+        parsed_result = json.loads(response.content)
+        system_ids = extract_event_ids(parsed_result)
+        self.assertEqual(
+            [],
+            [node.system_id for node in
+             device_nodes if node.system_id in system_ids],
+            "Node listing contains devices.")
+        self.assertEqual(parsed_result['count'], len(nodes))
+
+    def test_GET_query_with_zone_filters_by_zone(self):
+        non_listed_node = factory.make_Node(
+            zone=factory.make_Zone(name='twilight'))
+        [factory.make_Event(node=non_listed_node) for _ in range(3)]
+        zone = factory.make_Zone()
+        node = factory.make_Node(zone=zone)
+        matching_event_ids = [
+            factory.make_Event(
+                node=node).id for _ in range(3)]
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'zone': zone.name,
+            'level': 'DEBUG'
+        })
+        self.assertEqual(httplib.OK, response.status_code)
+        parsed_result = json.loads(response.content)
+        matching_event_ids = list(reversed(matching_event_ids))
+        self.assertSequenceEqual(
+            matching_event_ids, extract_event_ids(parsed_result))
+        self.assertEqual(parsed_result['count'], len(matching_event_ids))
+
+    def test_GET_query_with_limit_limits_with_most_recent_events(self):
+        test_limit = 5
+        # Events are returned in id order.
+        event_ids = [factory.make_Event().id for _
+                     in range(test_limit + 1)]
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'limit': unicode(test_limit),
+            'level': 'DEBUG'
+        })
+
+        parsed_result = json.loads(response.content)
+
+        self.assertSequenceEqual(
+            list(reversed(event_ids))[:test_limit],
+            extract_event_ids(parsed_result))
+        self.assertEqual(parsed_result['count'], test_limit)
+
+    def test_GET_query_with_limit_over_hard_limit_raises_error_with_msg(self):
+        artificial_limit = 5
+        test_limit = artificial_limit + 1
+        self.patch(nodes_module, 'MAX_EVENT_LOG_COUNT', artificial_limit)
+
+        [factory.make_Event().id for _ in range(test_limit)]
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'limit': unicode(test_limit),
+        })
+
+        expected_msg = ("Requested number of events %d is greater than"
+                        " limit: %d" % (test_limit,
+                                        nodes_module.MAX_EVENT_LOG_COUNT))
+
+        observed = response.status_code, response.content
+        expected = (
+            Equals(httplib.BAD_REQUEST),
+            Contains(expected_msg),
+        )
+        self.assertThat(observed, MatchesListwise(expected))
+
+    def test_GET_query_with_without_limit_limits_to_default_newest(self):
+        artificial_limit = 5
+        test_limit = artificial_limit + 1
+        self.patch(
+            nodes_module,
+            'DEFAULT_EVENT_LOG_LIMIT',
+            artificial_limit)
+
+        # Nodes are returned in id order.
+        event_ids = [factory.make_Event().id for _ in range(test_limit)]
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'level': 'DEBUG'
+        })
+
+        parsed_result = json.loads(response.content)
+
+        self.assertSequenceEqual(
+            list(reversed(event_ids))[:artificial_limit],
+            extract_event_ids(parsed_result))
+        self.assertEqual(parsed_result['count'], artificial_limit)
+
+    def test_GET_query_with_start_event_id_with_limit(self):
+        test_limit = 5
+        (_, _, test_event_3, test_event_4,
+         test_event_5) = (factory.make_Event(), factory.make_Event(),
+                          factory.make_Event(), factory.make_Event(),
+                          factory.make_Event())
+        ignore_unused(_)
+
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'after': unicode(test_event_3.id),
+            'limit': unicode(test_limit),
+            'level': 'DEBUG'
+        })
+        parsed_result = json.loads(response.content)
+        expected_result = list(
+            [test_event_5.id, test_event_4.id, test_event_3.id])
+        observed_result = extract_event_ids(parsed_result)
+
+        self.assertSequenceEqual(
+            expected_result, observed_result)
+        self.assertEqual(parsed_result['count'], len(expected_result))
+
+    def test_GET_query_with_start_event_id_without_limit(self):
+        (_, _, test_event_3, test_event_4,
+         test_event_5) = (factory.make_Event(), factory.make_Event(),
+                          factory.make_Event(), factory.make_Event(),
+                          factory.make_Event())
+        ignore_unused(_)
+
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'after': unicode(test_event_3.id),
+            'level': 'DEBUG'
+        })
+        parsed_result = json.loads(response.content)
+        expected_result = list(
+            [test_event_5.id, test_event_4.id, test_event_3.id])
+        observed_result = extract_event_ids(parsed_result)
+
+        self.assertSequenceEqual(
+            expected_result, observed_result)
+        self.assertEqual(parsed_result['count'], len(expected_result))
+
+    def test_GET_query_with_invalid_log_level_raises_error_with_msg(self):
+        [factory.make_Event().id for _ in range(3)]
+        invalid_level = factory.make_name('invalid_log_level')
+        response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'level': invalid_level,
+        })
+
+        expected_msg = ("Unknown log level: %s" % invalid_level)
+
+        observed = response.status_code, response.content
+        expected = (
+            Equals(httplib.BAD_REQUEST),
+            Contains(expected_msg),
+        )
+        self.assertThat(observed, MatchesListwise(expected))
+
+    def test_GET_query_with_log_level_returns_that_level_and_greater(self):
+        events_per_level = 2
+        event_ids = make_events_with_log_levels(
+            self.log_levels,
+            events_per_level)
+
+        for idx, level in enumerate(self.log_levels):
+            response = self.client.get(reverse('events_handler'), {
+                'op': 'query',
+                'level': level[0],
+            })
+
+            parsed_result = json.loads(response.content)
+
+            expected_result = list(
+                reversed(event_ids[:(idx + 1) * events_per_level]))
+            observed_result = extract_event_ids(parsed_result)
+
+            self.assertSequenceEqual(
+                expected_result, observed_result)
+            self.assertEqual(parsed_result['count'], len(expected_result))
+
+    def test_GET_query_with_default_log_level_is_info(self):
+        make_events_with_log_levels(self.log_levels)
+
+        info_response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+            'level': 'INFO',
+        })
+
+        default_response = self.client.get(reverse('events_handler'), {
+            'op': 'query',
+        })
+
+        expected_result = json.loads(info_response.content)
+        observed_result = json.loads(default_response.content)
+        expected_result_ids = extract_event_ids(expected_result)
+
+        self.assertSequenceEqual(
+            expected_result['events'], observed_result['events'])
+        self.assertEqual(observed_result['count'],
+                         len(expected_result_ids))
+        # Don't compare the URIs. They will be different.
+
+    def test_GET_query_prev_next_uris_preserves_query_params(self):
+        test_events = 6
+        test_params = list(nodes_module.EventsHandler.all_params)
+        if 'op' in test_params:
+            test_params.remove('op')
+        expected_uri_path = reverse('events_handler')
+
+        # Try all cardinalities of combinations of query parameters
+        for r in range(len(test_params) + 1):
+            for params in combinations(test_params, r):
+                # Generate test values for all params
+                test_values = \
+                    {'after': unicode(randint(1, test_events)),
+                     'agent_name': factory.make_string(),
+                     'id': factory.make_string(),
+                     'level': random.choice(LOGGING_LEVELS.values()),
+                     'limit': unicode(randint(1, test_events)),
+                     'mac_address':
+                     unicode(factory.make_MACAddress_with_Node()),
+                     'zone': factory.make_string()}
+
+                # Build a query dictionary for the given combination of params
+                expected_params = {}
+                for param_name in params:
+                    expected_params[param_name] = test_values[param_name]
+
+                # Ensure that op is always included
+                expected_params['op'] = 'query'
+
+                response = self.client.get(
+                    reverse('events_handler'), expected_params)
+
+                self.assertEqual(httplib.OK, response.status_code)
+
+                # Parse the returned JSON and check URI path
+                parsed_result = json.loads(response.content)
+
+                next_uri = urlparse(parsed_result['next_uri'])
+                prev_uri = urlparse(parsed_result['prev_uri'])
+
+                self.assertEqual(
+                    (expected_uri_path, '', '', '', ''),
+                    (next_uri.path,
+                     next_uri.scheme,
+                     next_uri.netloc,
+                     next_uri.params,
+                     next_uri.fragment))
+
+                self.assertEqual(
+                    (expected_uri_path, '', '', '', ''),
+                    (prev_uri.path,
+                     prev_uri.scheme,
+                     prev_uri.netloc,
+                     prev_uri.params,
+                     prev_uri.fragment))
+                self.assertEqual(expected_uri_path, prev_uri.path)
+
+                # Parse URI query strings
+                next_uri_params = dict(parse_qsl(
+                    next_uri.query,
+                    keep_blank_values=True))
+
+                prev_uri_params = dict(parse_qsl(
+                    prev_uri.query,
+                    keep_blank_values=True))
+
+                # Calculate the expected values for limit
+                # and start event id
+                limit = nodes_module.DEFAULT_EVENT_LOG_LIMIT \
+                    if not 'limit' in expected_params \
+                    else int(expected_params['limit'])
+
+                start_id = 0 if not 'after' in expected_params \
+                    else int(expected_params['after'])
+
+                expected_params['after'] = unicode(start_id + limit)
+                self.assertDictEqual(expected_params, next_uri_params)
+
+                expected_params['after'] = \
+                    unicode(max(start_id - limit, 0))
+                self.assertDictEqual(expected_params, prev_uri_params)
+
+    def test_query_num_queries_is_independent_of_num_nodes_and_events(self):
+        # 1 query for select event +
+        # 1 query to prefetch eventtype +
+        # 1 query to prefetch node details
+        expected_queries = 3
+        events_per_node = 5
+        num_nodes_per_group = 5
+        events_per_group = num_nodes_per_group * events_per_node
+
+        nodegroup_1 = factory.make_NodeGroup()
+        nodegroup_2 = factory.make_NodeGroup()
+
+        self.create_nodes_in_group_with_events(
+            nodegroup_1, num_nodes_per_group, events_per_node)
+
+        handler = nodes_module.EventsHandler()
+
+        query_1_count, query_1_result = count_queries(
+            handler.query, RequestFixture(
+                {
+                    'op': 'query',
+                    'level': 'DEBUG',
+                }, ['op', 'level']
+            ))
+
+        self.create_nodes_in_group_with_events(
+            nodegroup_2, num_nodes_per_group, events_per_node)
+
+        query_2_count, query_2_result = count_queries(
+            handler.query, RequestFixture(
+                {
+                    'op': 'query',
+                    'level': 'DEBUG',
+                }, ['op', 'level']
+            ))
+
+        # This check is to notify the developer that a change was made that
+        # affects the number of queries performed when doing an event listing.
+        # If this happens, consider your prefetching and adjust accordingly.
+        self.assertEquals(events_per_group, int(query_1_result['count']))
+        self.assertEquals(
+            expected_queries, query_1_count,
+            "Number of queries has changed, make sure this is expected.")
+
+        self.assertEquals(events_per_group * 2, int(query_2_result['count']))
+        self.assertEquals(
+            expected_queries, query_2_count,
+            "Number of queries is not independent to the number of nodes.")
+
+
 class TestNodesAPI(APITestCase):
     """Tests for /api/1.0/nodes/."""
 
@@ -169,7 +983,7 @@
         macs = {
             factory.make_mac_address()
             for _ in range(random.randint(1, 2))
-            }
+        }
         response = self.client.post(
             reverse('nodes_handler'),
             {
@@ -408,14 +1222,14 @@
         response = self.client.get(reverse('nodes_handler'), {
             'op': 'list',
             'mac_address': [bad_mac1, bad_mac2, ok_mac],
-            })
+        })
         observed = response.status_code, response.content
         expected = (
             Equals(httplib.BAD_REQUEST),
             Contains(
                 "Invalid MAC address(es): 00:E0:81:DD:D1:ZZ, "
                 "00:E0:81:DD:D1:XX"),
-            )
+        )
         self.assertThat(observed, MatchesListwise(expected))
 
     def test_GET_list_with_agent_name_filters_by_agent_name(self):
@@ -427,7 +1241,7 @@
         response = self.client.get(reverse('nodes_handler'), {
             'op': 'list',
             'agent_name': agent_name,
-            })
+        })
         self.assertEqual(httplib.OK, response.status_code)
         parsed_result = json.loads(response.content)
         self.assertSequenceEqual(
@@ -439,7 +1253,7 @@
         response = self.client.get(reverse('nodes_handler'), {
             'op': 'list',
             'agent_name': '',
-            })
+        })
         self.assertEqual(httplib.OK, response.status_code)
         parsed_result = json.loads(response.content)
         self.assertSequenceEqual(
@@ -482,7 +1296,7 @@
         response = self.client.get(reverse('nodes_handler'), {
             'op': 'list',
             'zone': zone.name,
-            })
+        })
         self.assertEqual(httplib.OK, response.status_code)
         parsed_result = json.loads(response.content)
         self.assertSequenceEqual(
@@ -619,7 +1433,7 @@
             reverse('nodes_handler'), {
                 'op': 'acquire',
                 'name': hostname,
-                })
+            })
         self.assertEqual(httplib.CONFLICT, response.status_code)
         self.assertEqual(
             "No available node matches constraints: name=%s" % hostname,
@@ -962,7 +1776,7 @@
                 node=factory.make_Node(status=NODE_STATUS.READY),
                 networks=[network])
             for network in networks
-            ]
+        ]
         # We'll make it so that only the node and network at this index will
         # match the request.
         pick = 2
@@ -999,7 +1813,7 @@
         nodes = [
             factory.make_Node(status=NODE_STATUS.READY, zone=not_in_zone)
             for _ in range(5)
-            ]
+        ]
         # Pick a node in the middle to avoid false negatives if acquire()
         # always tries the oldest, or the newest, node first.
         eligible_node = nodes[2]
@@ -1057,7 +1871,7 @@
             NODE_STATUS.NEW,
             NODE_STATUS.COMMISSIONING,
             NODE_STATUS.READY,
-            ])
+        ])
         unacceptable_states = (
             set(map_enum(NODE_STATUS).values()) - acceptable_states)
         nodes = {
@@ -1068,7 +1882,7 @@
                 reverse('nodes_handler'), {
                     'op': 'accept',
                     'nodes': [node.system_id],
-                    })
+                })
             for status, node in nodes.items()}
         # All of these attempts are rejected with Conflict errors.
         self.assertEqual(
@@ -1121,7 +1935,7 @@
         response = self.client.post(reverse('nodes_handler'), {
             'op': 'accept',
             'nodes': node_ids,
-            })
+        })
         self.assertEqual(httplib.OK, response.status_code)
         self.assertEqual(
             [target_state] * len(nodes),
@@ -1133,13 +1947,13 @@
         acceptable_nodes = [
             factory.make_Node(status=NODE_STATUS.NEW)
             for counter in range(2)
-            ]
+        ]
         accepted_node = factory.make_Node(status=NODE_STATUS.READY)
         nodes = acceptable_nodes + [accepted_node]
         response = self.client.post(reverse('nodes_handler'), {
             'op': 'accept',
             'nodes': [node.system_id for node in nodes],
-            })
+        })
         self.assertEqual(httplib.OK, response.status_code)
         accepted_ids = [
             node['system_id'] for node in json.loads(response.content)]
@@ -1157,12 +1971,12 @@
         node_ids = {
             factory.make_Node(installable=False).system_id
             for _ in xrange(3)
-            }
+        }
         response = self.client.post(
             reverse('nodes_handler'), {
                 'op': 'release',
                 'nodes': node_ids
-                })
+            })
         self.assertEqual(httplib.BAD_REQUEST, response.status_code)
 
     def test_POST_release_rejects_request_from_unauthorized_user(self):
@@ -1172,7 +1986,7 @@
             reverse('nodes_handler'), {
                 'op': 'release',
                 'nodes': [node.system_id],
-                })
+            })
         self.assertEqual(httplib.FORBIDDEN, response.status_code)
         self.assertEqual(NODE_STATUS.ALLOCATED, reload_object(node).status)
 
@@ -1184,7 +1998,7 @@
             reverse('nodes_handler'), {
                 'op': 'release',
                 'nodes': node_ids
-                })
+            })
         # Awkward parsing, but the order may vary and it's not JSON
         s = response.content
         returned_ids = s[s.find(':') + 2:s.rfind('.')].split(', ')
@@ -1199,7 +2013,7 @@
                 status=NODE_STATUS.ALLOCATED,
                 owner=self.logged_in_user).system_id
             for _ in xrange(3)
-            }
+        }
         # And one with no owner
         another_node = factory.make_Node(status=NODE_STATUS.RESERVED)
         node_ids.add(another_node.system_id)
@@ -1207,7 +2021,7 @@
             reverse('nodes_handler'), {
                 'op': 'release',
                 'nodes': node_ids
-                })
+            })
         self.assertEqual(
             (httplib.FORBIDDEN,
                 "You don't have the required permission to release the "
@@ -1227,7 +2041,7 @@
             reverse('nodes_handler'), {
                 'op': 'release',
                 'nodes': [node.system_id for node in nodes],
-                })
+            })
         # Awkward parsing again, because a string is returned, not JSON
         expected = [
             "%s ('%s')" % (node.system_id, node.display_status())
@@ -1247,12 +2061,12 @@
         nodes = [
             factory.make_Node(status=status, owner=owner)
             for status in acceptable_states
-            ]
+        ]
         response = self.client.post(
             reverse('nodes_handler'), {
                 'op': 'release',
                 'nodes': [node.system_id for node in nodes],
-                })
+            })
         parsed_result = json.loads(response.content)
         self.assertEqual(httplib.OK, response.status_code)
         # The first node is READY, so shouldn't be touched.
@@ -1269,7 +2083,7 @@
             reverse('nodes_handler'), {
                 'op': 'release',
                 'nodes': [node.system_id],
-                })
+            })
         self.assertEqual(httplib.OK, response.status_code, response)
         node = reload_object(node)
         self.assertEqual(NODE_STATUS.DISK_ERASING, node.status)
@@ -1532,7 +2346,7 @@
         ('failed_releasing', dict(status=NODE_STATUS.FAILED_RELEASING)),
         ('disk_erasing', dict(status=NODE_STATUS.DISK_ERASING)),
         ('failed_disk_erasing', dict(status=NODE_STATUS.FAILED_DISK_ERASING)),
-        ]
+    ]
 
     old_allocated_status = 6
 

=== modified file 'src/maasserver/models/eventtype.py'
--- src/maasserver/models/eventtype.py	2015-03-25 15:33:23 +0000
+++ src/maasserver/models/eventtype.py	2015-04-03 19:28:00 +0000
@@ -7,14 +7,14 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
 __metaclass__ = type
 __all__ = [
     'EventType',
-    ]
+]
 
 
 import logging
@@ -42,6 +42,14 @@
     logging.CRITICAL: 'CRITICAL',
 }
 
+LOGGING_LEVELS_BY_NAME = {
+    'DEBUG': logging.DEBUG,
+    'INFO': logging.INFO,
+    'WARNING': logging.WARNING,
+    'ERROR': logging.ERROR,
+    'CRITICAL': logging.CRITICAL,
+}
+
 
 class EventTypeManager(Manager):
     """A utility to manage the collection of Events."""

=== modified file 'src/maasserver/urls_api.py'
--- src/maasserver/urls_api.py	2015-03-25 15:33:23 +0000
+++ src/maasserver/urls_api.py	2015-04-03 19:28:00 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -77,6 +77,7 @@
     NodeGroupsHandler,
 )
 from maasserver.api.nodes import (
+    EventsHandler,
     NodeHandler,
     NodesHandler,
 )
@@ -117,6 +118,7 @@
     BootResourceFileUploadHandler, authentication=api_auth)
 boot_resources_handler = RestrictedResource(
     BootResourcesHandler, authentication=api_auth)
+events_handler = RestrictedResource(EventsHandler, authentication=api_auth)
 files_handler = RestrictedResource(FilesHandler, authentication=api_auth)
 file_handler = RestrictedResource(FileHandler, authentication=api_auth)
 ipaddresses_handler = RestrictedResource(
@@ -216,6 +218,7 @@
         r'^devices/(?P<system_id>[\w\-]+)/$', device_handler,
         name='device_handler'),
     url(r'^devices/$', devices_handler, name='devices_handler'),
+    url(r'^events/$', events_handler, name='events_handler'),
     url(
         r'^nodegroups/(?P<uuid>[^/]+)/$',
         nodegroup_handler, name='nodegroup_handler'),

=== added file 'src/maasserver/views/nodes.py'
--- src/maasserver/views/nodes.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/views/nodes.py	2015-04-03 19:28:00 +0000
@@ -0,0 +1,626 @@
+# Copyright 2012-2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Nodes views."""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+)
+
+str = None
+
+__metaclass__ = type
+__all__ = [
+    'enlist_preseed_view',
+    'MacAdd',
+    'MacDelete',
+    'NodeDelete',
+    'NodeEventListView',
+    'NodePreseedView',
+    'NodeView',
+    'NodeEdit',
+    'prefetch_nodes_listing',
+]
+
+from cgi import escape
+import json
+import logging
+import re
+from textwrap import dedent
+
+from django.contrib import messages
+from django.core.urlresolvers import reverse
+from django.http import HttpResponse
+from django.shortcuts import (
+    get_object_or_404,
+    render_to_response,
+)
+from django.template import (
+    loader,
+    RequestContext,
+)
+from django.utils.safestring import mark_safe
+from django.views.generic import (
+    CreateView,
+    DetailView,
+    UpdateView,
+)
+from lxml import etree
+from maasserver.clusterrpc.power_parameters import get_power_types
+from maasserver.enum import (
+    NODE_BOOT,
+    NODE_PERMISSION,
+    NODE_STATUS,
+    NODE_STATUS_CHOICES_DICT,
+)
+from maasserver.exceptions import MAASAPIException
+from maasserver.forms import (
+    get_action_form,
+    get_node_edit_form,
+    MACAddressForm,
+)
+from maasserver.models import (
+    MACAddress,
+    Node,
+    StaticIPAddress,
+    Tag,
+)
+from maasserver.models.config import Config
+from maasserver.models.event import Event
+from maasserver.models.nodeprobeddetails import get_single_probed_details
+from maasserver.preseed import (
+    get_enlist_preseed,
+    get_preseed,
+    OS_WITH_IPv6_SUPPORT,
+)
+from maasserver.third_party_drivers import get_third_party_driver
+from maasserver.utils.converters import XMLToYAML
+from maasserver.views import (
+    HelpfulDeleteView,
+    PaginatedListView,
+)
+from metadataserver.enum import RESULT_TYPE
+from metadataserver.models import NodeResult
+from netaddr import IPAddress
+from provisioningserver.tags import merge_details_cleanly
+
+
+def message_from_form_stats(action, done, not_actionable, not_permitted):
+    """Return a message suitable for user display from the given stats."""
+    action_name = 'The action "%s"' % action.display
+    # singular/plural messages.
+    done_templates = [
+        '%s was successfully performed on %d node.',
+        '%s was successfully performed on %d nodes.'
+    ]
+    not_actionable_templates = [
+        ('%s could not be performed on %d node because its '
+         'state does not allow that action.'),
+        ('%s could not be performed on %d nodes because their '
+         'state does not allow that action.'),
+    ]
+    not_permitted_templates = [
+        ('%s could not be performed on %d node because that '
+         "action is not permitted on that node."),
+        ('%s could not be performed on %d nodes because that '
+         "action is not permitted on these nodes."),
+    ]
+    number_message = [
+        (done, done_templates),
+        (not_actionable, not_actionable_templates),
+        (not_permitted, not_permitted_templates)]
+    message = []
+    for index, (number, message_templates) in enumerate(number_message):
+        singular, plural = message_templates
+        if number != 0:
+            message_template = singular if number == 1 else plural
+            message.append(message_template % (action_name, number))
+            # Override the action name so that only the first sentence will
+            # contain the full name of the action.
+            action_name = 'It'
+            level = index
+    return ' '.join(message), ('info', 'warning', 'error')[level]
+
+
+def prefetch_nodes_listing(nodes_query):
+    """Prefetch any data needed to display a given query of nodes.
+
+    :param nodes_query: A query set of nodes.
+    :return: A version of `nodes_query` that prefetches any data needed for
+        displaying these nodes as a listing.
+    """
+    return (
+        nodes_query
+        .prefetch_related('macaddress_set')
+        .select_related('nodegroup')
+        .prefetch_related('nodegroup__nodegroupinterface_set')
+        .prefetch_related('zone'))
+
+
+def generate_js_power_types(nodegroup=None):
+    """Return a JavaScript definition of supported power-type choices.
+
+    Produces an array of power-type identifiers, starting with the opening
+    bracket and ending with the closing bracket, without line breaks on either
+    end.  Entries are one per line, sorted lexicographically.
+    """
+    if nodegroup is not None:
+        nodegroup = [nodegroup]
+    power_types = get_power_types(nodegroup, ignore_errors=True)
+    names = ['"%s"' % power_type for power_type in sorted(power_types)]
+    return mark_safe("[\n%s\n]" % ',\n'.join(names))
+
+
+def node_to_dict(node, event_log_count=0):
+    """Convert `Node` to a dictionary.
+
+    :param event_log_count: Number of entries from the event log to add to
+        the dictionary.
+    """
+    if node.owner is None:
+        owner = ""
+    else:
+        owner = '%s' % node.owner
+    pxe_mac = node.get_pxe_mac()
+    node_dict = dict(
+        id=node.id,
+        system_id=node.system_id,
+        url=reverse('node-view', args=[node.system_id]),
+        hostname=node.hostname,
+        architecture=node.architecture,
+        fqdn=node.fqdn,
+        status=node.display_status(),
+        owner=owner,
+        cpu_count=node.cpu_count,
+        memory=node.display_memory(),
+        storage=node.display_storage(),
+        power_state=node.power_state,
+        zone=node.zone.name,
+        zone_url=reverse('zone-view', args=[node.zone.name]),
+        mac=None if pxe_mac is None else pxe_mac.mac_address.get_raw(),
+        vendor=node.get_pxe_mac_vendor(),
+        macs=[mac.mac_address.get_raw() for mac in node.get_extra_macs()],
+    )
+    if event_log_count != 0:
+        # Add event information to the generated node dictionary. We exclude
+        # debug after we calculate the count, so we show the correct total
+        # number of events.
+        node_events = Event.objects.filter(node=node)
+        total_num_events = node_events.count()
+        non_debug_events = node_events.exclude(
+            type__level=logging.DEBUG).order_by('-id')
+        if event_log_count > 0:
+            # Limit the number of events.
+            events = non_debug_events.all()[:event_log_count]
+            displayed_events_count = len(events)
+        node_dict['events'] = dict(
+            total=total_num_events,
+            count=displayed_events_count,
+            events=[event_to_dict(event) for event in events],
+            more_url=reverse('node-event-list-view', args=[node.system_id]),
+        )
+    return node_dict
+
+
+def event_to_dict(event):
+    """Convert `Event` to a dictionary."""
+    return dict(
+        node=event.node.system_id,
+        hostname=event.node.hostname,
+        id=event.id,
+        level=event.type.level_str,
+        created=event.created.strftime('%a, %d %b. %Y %H:%M:%S'),
+        type=event.type.description,
+        description=event.description
+    )
+
+
+def convert_query_status(value):
+    """Convert the given value into a list of status integers."""
+    value = value.lower()
+    ids = []
+    for status_id, status_text in NODE_STATUS_CHOICES_DICT.items():
+        status_text = status_text.lower()
+        if value in status_text:
+            ids.append(status_id)
+    if len(ids) == 0:
+        return None
+    return ids
+
+
+def enlist_preseed_view(request):
+    """View method to display the enlistment preseed."""
+    warning_message = (
+        "The URL mentioned in the following enlistment preseed will "
+        "be different depending on which cluster controller is "
+        "responsible for the enlisting node.  The URL shown here is for "
+        "nodes handled by the cluster controller located in the region "
+        "controller's network."
+    )
+    context = RequestContext(request, {'warning_message': warning_message})
+    try:
+        preseed = get_enlist_preseed()
+    except NameError as e:
+        preseed = "ERROR RENDERING PRESEED\n" + unicode(e)
+    return render_to_response(
+        'maasserver/enlist_preseed.html',
+        {'preseed': mark_safe(preseed)},
+        context_instance=context)
+
+
+class NodeViewMixin:
+    """Mixin class used to fetch a node by system_id.
+
+    The logged-in user must have View permission to access this page.
+    """
+
+    context_object_name = 'node'
+
+    def get_object(self):
+        system_id = self.kwargs.get('system_id', None)
+        node = Node.objects.get_node_or_404(
+            system_id=system_id, user=self.request.user,
+            perm=NODE_PERMISSION.VIEW)
+        return node
+
+
+class NodePreseedView(NodeViewMixin, DetailView):
+    """View class to display a node's preseed."""
+
+    template_name = 'maasserver/node_preseed.html'
+
+    def get_context_data(self, **kwargs):
+        context = super(NodePreseedView, self).get_context_data(**kwargs)
+        node = self.get_object()
+        # Display the preseed content exactly as generated by
+        # `get_preseed`.  This will be rendered in a <pre> tag.
+        try:
+            preseed = get_preseed(node)
+        except NameError as e:
+            preseed = "ERROR RENDERING PRESEED\n" + unicode(e)
+        context['preseed'] = mark_safe(preseed)
+        context['is_commissioning'] = (
+            node.status == NODE_STATUS.COMMISSIONING)
+        return context
+
+
+# Info message displayed on the node page for COMMISSIONING
+# or READY nodes.
+NODE_BOOT_INFO = mark_safe("""
+You can boot this node using an adequately
+configured DHCP server.  See
+<a href="https://maas.ubuntu.com/docs/nodes.html"
+>https://maas.ubuntu.com/docs/nodes.html</a> for instructions.
+""")
+
+
+NO_POWER_SET = mark_safe("""
+This node does not have a power type set and MAAS will be unable to
+control it. Click 'Edit node' and set one.
+""")
+
+
+THIRD_PARTY_DRIVERS_NOTICE = dedent("""
+    Third party drivers may be used when booting or installing nodes.
+    These may be proprietary and closed-source.
+    """)
+
+
+THIRD_PARTY_DRIVERS_ADMIN_NOTICE = dedent("""
+    The installation of third party drivers can be disabled on the <a
+    href="%s#third_party_drivers">settings</a> page.
+    """)
+
+UNCONFIGURED_IPS_NOTICE = dedent("""
+    Automatic configuration of IPv6 addresses is currently only supported on
+    Ubuntu, using the fast installer.  To activate the IPv6 address(es) shown
+    here, configure them in the installed operating system.
+    """)
+
+
+def construct_third_party_drivers_notice(user_is_admin):
+    """Build and return the notice about third party drivers.
+
+    If `user_is_admin` is True, a link to the settings page will be
+    included in the message.
+
+    :param user_is_admin: True if the user is an administrator, False
+        otherwise.
+    """
+    if user_is_admin:
+        return mark_safe(
+            THIRD_PARTY_DRIVERS_NOTICE +
+            THIRD_PARTY_DRIVERS_ADMIN_NOTICE %
+            escape(reverse("settings"), quote=True))
+    else:
+        return mark_safe(THIRD_PARTY_DRIVERS_NOTICE)
+
+
+class NodeView(NodeViewMixin, UpdateView):
+    """View class to display a node's information and buttons for the actions
+    which can be performed on this node.
+    """
+
+    template_name = 'maasserver/node_view.html'
+
+    def get_form_class(self):
+        return get_action_form(self.request.user, self.request)
+
+    # The number of events shown on the node view page.
+    number_of_events_shown = 5
+
+    def get(self, request, *args, **kwargs):
+        """Handle a GET request."""
+        if request.is_ajax():
+            return self.handle_ajax_request(request, *args, **kwargs)
+        return super(NodeView, self).get(request, *args, **kwargs)
+
+    def warn_unconfigured_ip_addresses(self, node):
+        """Should the UI warn about unconfigured IPv6 addresses on the node?
+
+        Static IPv6 addresses are configured on the node using Curtin.  But
+        this is not yet supported for all operating systems and installers.
+        If a node has IPv6 addresses assigned but is not being deployed in a
+        way that supports configuring them, the node page should show a warning
+        to say that the user will need to configure the node to use those
+        addresses.
+
+        :return: Bool: should the UI show this warning?
+        """
+        supported_os = (node.get_osystem() in OS_WITH_IPv6_SUPPORT)
+        if supported_os and node.boot_type == NODE_BOOT.FASTPATH:
+            # MAAS knows how to configure IPv6 addresses on an Ubuntu node
+            # installed with the fast installer.  No warning needed.
+            return False
+        # For other installs, we need the warning if and only if the node has
+        # static IPv6 addresses.
+        static_ips = StaticIPAddress.objects.filter(macaddress__node=node)
+        return any(
+            IPAddress(static_ip.ip).version == 6
+            for static_ip in static_ips)
+
+    def get_context_data(self, **kwargs):
+        context = super(NodeView, self).get_context_data(**kwargs)
+        node = self.get_object()
+        context['can_edit'] = self.request.user.has_perm(
+            NODE_PERMISSION.EDIT, node)
+        if node.status in (NODE_STATUS.COMMISSIONING, NODE_STATUS.READY):
+            messages.info(self.request, NODE_BOOT_INFO)
+        if node.power_type == '':
+            messages.error(self.request, NO_POWER_SET)
+        if self.warn_unconfigured_ip_addresses(node):
+            messages.warning(self.request, UNCONFIGURED_IPS_NOTICE)
+            context['unconfigured_ips_warning'] = UNCONFIGURED_IPS_NOTICE
+
+        context['error_text'] = (
+            node.error if node.status == NODE_STATUS.FAILED_COMMISSIONING
+            else None)
+        context['status_text'] = (
+            node.error if node.status != NODE_STATUS.FAILED_COMMISSIONING
+            else None)
+        kernel_opts = node.get_effective_kernel_options()
+        context['kernel_opts'] = {
+            'is_global': kernel_opts[0] is None,
+            'is_tag': isinstance(kernel_opts[0], Tag),
+            'tag': kernel_opts[0],
+            'value': kernel_opts[1]
+        }
+        # Produce a "clean" composite details document.
+        probed_details = merge_details_cleanly(
+            get_single_probed_details(node.system_id))
+        # We check here if there's something to show instead of after
+        # the call to get_single_probed_details() because here the
+        # details will be guaranteed well-formed.
+        if len(probed_details.xpath('/*/*')) == 0:
+            context['probed_details_xml'] = None
+            context['probed_details_yaml'] = None
+        else:
+            context['probed_details_xml'] = etree.tostring(
+                probed_details, encoding=unicode, pretty_print=True)
+            context['probed_details_yaml'] = XMLToYAML(
+                etree.tostring(
+                    probed_details, encoding=unicode,
+                    pretty_print=True)).convert()
+
+        commissioning_results = NodeResult.objects.filter(
+            node=node, result_type=RESULT_TYPE.COMMISSIONING).count()
+        context['nodecommissionresults'] = commissioning_results
+
+        installation_results = NodeResult.objects.filter(
+            node=node, result_type=RESULT_TYPE.INSTALLATION)
+        if len(installation_results) > 1:
+            for result in installation_results:
+                result.name = re.sub('[_.]', ' ', result.name)
+            context['nodeinstallresults'] = installation_results
+        elif len(installation_results) == 1:
+            installation_results[0].name = "install log"
+            context['nodeinstallresults'] = installation_results
+
+        context['third_party_drivers_enabled'] = Config.objects.get_config(
+            'enable_third_party_drivers')
+        context['drivers'] = get_third_party_driver(node)
+
+        event_list = (
+            Event.objects.filter(node=self.get_object())
+            .exclude(type__level=logging.DEBUG)
+            .order_by('-id')[:self.number_of_events_shown])
+        context['event_list'] = event_list
+        context['event_count'] = Event.objects.filter(
+            node=self.get_object()).count()
+
+        return context
+
+    def dispatch(self, *args, **kwargs):
+        """Override from Django `View`: Handle MAAS exceptions.
+
+        Node actions may raise exceptions derived from
+        :class:`MAASAPIException`.  This type of exception contains an
+        http status code that we will forward to the client.
+        """
+        try:
+            return super(NodeView, self).dispatch(*args, **kwargs)
+        except MAASAPIException as e:
+            return e.make_http_response()
+
+    def get_success_url(self):
+        return reverse('node-view', args=[self.get_object().system_id])
+
+    def render_node_actions(self, request):
+        """Render the HTML for all the available node actions."""
+        template = loader.get_template('maasserver/node_actions.html')
+        self.object = self.get_object()
+        context = {
+            'node': self.object,
+            'can_edit': self.request.user.has_perm(
+                NODE_PERMISSION.EDIT, self.object),
+            'form': self.get_form(self.get_form_class()),
+        }
+        return template.render(RequestContext(request, context))
+
+    def handle_ajax_request(self, request, *args, **kwargs):
+        """JSON response to update the node view."""
+        node = self.get_object()
+        node = node_to_dict(
+            node, event_log_count=self.number_of_events_shown)
+        node['action_view'] = self.render_node_actions(request)
+        return HttpResponse(json.dumps(node), mimetype='application/json')
+
+
+class NodeEventListView(NodeViewMixin, PaginatedListView):
+
+    context_object_name = "event_list"
+
+    template_name = "maasserver/node_event_list.html"
+
+    def get_queryset(self):
+        return Event.objects.filter(
+            node=self.get_object()).order_by('-id')
+
+    def get_context_data(self, **kwargs):
+        context = super(NodeEventListView, self).get_context_data(**kwargs)
+        node = self.get_object()
+        context['node'] = node
+        return context
+
+
+class NodeEdit(UpdateView):
+
+    template_name = 'maasserver/node_edit.html'
+
+    def get_object(self):
+        system_id = self.kwargs.get('system_id', None)
+        node = Node.objects.get_node_or_404(
+            system_id=system_id, user=self.request.user,
+            perm=NODE_PERMISSION.EDIT)
+        return node
+
+    def get_form_class(self):
+        return get_node_edit_form(self.request.user)
+
+    def get_has_owner(self):
+        node = self.get_object()
+        if node is None or node.owner is None:
+            return mark_safe("false")
+        return mark_safe("true")
+
+    def get_form_kwargs(self):
+        # This is here so the request can be passed to the form. The
+        # form needs it because it sets error messages for the UI.
+        kwargs = super(NodeEdit, self).get_form_kwargs()
+        kwargs['request'] = self.request
+        kwargs['ui_submission'] = True
+        return kwargs
+
+    def get_success_url(self):
+        return reverse('node-view', args=[self.get_object().system_id])
+
+    def get_context_data(self, **kwargs):
+        context = super(NodeEdit, self).get_context_data(**kwargs)
+        context['power_types'] = generate_js_power_types(
+            self.get_object().nodegroup)
+        # 'os_release' lets us know if we should render the `OS`
+        # and `Release` choice fields in the UI.
+        context['os_release'] = self.get_has_owner()
+        return context
+
+
+class NodeDelete(HelpfulDeleteView):
+
+    template_name = 'maasserver/node_confirm_delete.html'
+    context_object_name = 'node_to_delete'
+    model = Node
+
+    def get_object(self):
+        system_id = self.kwargs.get('system_id', None)
+        node = Node.objects.get_node_or_404(
+            system_id=system_id, user=self.request.user,
+            perm=NODE_PERMISSION.ADMIN)
+        return node
+
+    def get_next_url(self):
+        return reverse('index') + "#/nodes"
+
+    def name_object(self, obj):
+        """See `HelpfulDeleteView`."""
+        return "Node %s" % obj.system_id
+
+
+class MacAdd(CreateView):
+    form_class = MACAddressForm
+    template_name = 'maasserver/node_add_mac.html'
+
+    def get_node(self):
+        system_id = self.kwargs.get('system_id', None)
+        node = Node.objects.get_node_or_404(
+            system_id=system_id, user=self.request.user,
+            perm=NODE_PERMISSION.EDIT)
+        return node
+
+    def get_form_kwargs(self):
+        kwargs = super(MacAdd, self).get_form_kwargs()
+        kwargs['node'] = self.get_node()
+        return kwargs
+
+    def form_valid(self, form):
+        res = super(MacAdd, self).form_valid(form)
+        messages.info(self.request, "MAC address added.")
+        return res
+
+    def get_success_url(self):
+        node = self.get_node()
+        return reverse('node-edit', args=[node.system_id])
+
+    def get_context_data(self, **kwargs):
+        context = super(MacAdd, self).get_context_data(**kwargs)
+        context.update({'node': self.get_node()})
+        return context
+
+
+class MacDelete(HelpfulDeleteView):
+
+    template_name = 'maasserver/mac_confirm_delete.html'
+    context_object_name = 'mac_to_delete'
+    model = MACAddress
+
+    def get_node(self):
+        system_id = self.kwargs.get('system_id', None)
+        node = Node.objects.get_node_or_404(
+            system_id=system_id, user=self.request.user,
+            perm=NODE_PERMISSION.EDIT)
+        return node
+
+    def get_object(self):
+        node = self.get_node()
+        mac_address = self.kwargs.get('mac_address', None)
+        return get_object_or_404(
+            MACAddress, node=node, mac_address=mac_address)
+
+    def get_next_url(self):
+        node = self.get_node()
+        return reverse('node-edit', args=[node.system_id])
+
+    def name_object(self, obj):
+        """See `HelpfulDeleteView`."""
+        return "MAC address %s" % obj.mac_address