Merge lp:~blake-rouse/maas/multipart-image-upload into lp:~maas-committers/maas/trunk

[Blake Rouse]

Added the ability to create a boot resource without any content, this requires passing the size and sha256 for the file. New upload api added giving the ability to upload the content of the boot resource file in sections.

[Jason Hobbs (jason-hobbs)]

Looks good, comments inline but no blockers.

review: Approve

[MAAS Lander (maas-lander)]

The attempt to merge lp:~blake-rouse/maas/multipart-image-upload into lp:maas failed. Below is the output from the failed tests.

Ign http://security.ubuntu.com trusty-security InRelease
Ign http://nova.clouds.archive.ubuntu.com trusty InRelease
Get:1 http://security.ubuntu.com trusty-security Release.gpg [933 B]
Ign http://nova.clouds.archive.ubuntu.com trusty-updates InRelease
Get:2 http://security.ubuntu.com trusty-security Release [59.7 kB]
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 [59.7 kB]
Hit http://nova.clouds.archive.ubuntu.com trusty/main Sources
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
Hit http://nova.clouds.archive.ubuntu.com trusty/universe Translation-en
Get:5 http://security.ubuntu.com trusty-security/main Sources [42.3 kB]
Get:6 http://security.ubuntu.com trusty-security/universe Sources [10.8 kB]
Get:7 http://security.ubuntu.com trusty-security/main amd64 Packages [135 kB]
Get:8 http://security.ubuntu.com trusty-security/universe amd64 Packages [47.0 kB]
Hit http://security.ubuntu.com trusty-security/main Translation-en
Hit http://security.ubuntu.com trusty-security/universe Translation-en
Get:9 http://nova.clouds.archive.ubuntu.com trusty-updates/main Sources [114 kB]
Get:10 http://nova.clouds.archive.ubuntu.com trusty-updates/universe Sources [78.7 kB]
Get:11 http://nova.clouds.archive.ubuntu.com trusty-updates/main amd64 Packages [308 kB]
Get:12 http://nova.clouds.archive.ubuntu.com trusty-updates/universe amd64 Packages [192 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,049 kB in 0s (1,809 kB/s)
Reading package lists...
sudo DEBIAN_FRONTEND=noninteractive apt-get -y \
     --no-install-recommends install apache2 authbind bind9 bind9utils build-essential bzr-builddeb curl daemontools debhelper dh-apport distro-info dnsutils firefox freeipmi-tools ipython isc-dhcp-common libjs-raphael libjs-yui3-full libjs-yui3-min libpq-dev make pep8 postgresql pyflakes python-amqplib python-bzrlib python-celery python-convoy 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-jinja2 python-jsonschema python-lockfile python-lxml python-mimeparse python-mock python-netaddr python-netifaces python-nose python-oauth python-oops python-oops-amqp python-oops-datedir-repo python-oops-twisted python-oops-wsgi pytho...

=== modified file 'src/maasserver/api/boot_resources.py'
--- src/maasserver/api/boot_resources.py	2014-08-31 02:47:48 +0000
+++ src/maasserver/api/boot_resources.py	2014-09-03 13:27:07 +0000
@@ -15,9 +15,11 @@
 __all__ = [
     'BootResourceHandler',
     'BootResourcesHandler',
+    'BootResourceFileUploadHandler',
     ]
 
 import httplib
+import os
 
 from django.core.exceptions import ValidationError
 from django.core.files.uploadedfile import SimpleUploadedFile
@@ -29,16 +31,23 @@
     operation,
     OperationsHandler,
     )
-from maasserver.api.utils import get_mandatory_param
+from maasserver.api.utils import get_optional_param
 from maasserver.bootresources import import_resources
 from maasserver.enum import (
     BOOT_RESOURCE_TYPE,
     BOOT_RESOURCE_TYPE_CHOICES_DICT,
     )
-from maasserver.exceptions import MAASAPIBadRequest
-from maasserver.forms import BootResourceForm
+from maasserver.exceptions import (
+    MAASAPIBadRequest,
+    MAASAPIForbidden,
+    )
+from maasserver.forms import (
+    BootResourceForm,
+    BootResourceNoContentForm,
+    )
 from maasserver.models import (
     BootResource,
+    BootResourceFile,
     NodeGroup,
     )
 from piston.emitters import JSONEmitter
@@ -53,10 +62,21 @@
 }
 
 
+# XXX blake_r 2014-09-22 bug=1361370: We currently allow both generated and
+# uploaded resource to be uploaded. This is until the MAAS can generate its
+# own images.
+ALLOW_UPLOAD_RTYPES = [
+    BOOT_RESOURCE_TYPE.GENERATED,
+    BOOT_RESOURCE_TYPE.UPLOADED,
+    ]
+
+
 def get_content_parameter(request):
     """Get the "content" parameter from a POST or PUT."""
-    content_file = get_mandatory_param(request.FILES, 'content')
-    return content_file.read()
+    content = get_optional_param(request.FILES, 'content', None)
+    if content is None:
+        return None
+    return content.read()
 
 
 def boot_resource_file_to_dict(rfile):
@@ -70,6 +90,12 @@
         }
     if not dict_representation['complete']:
         dict_representation['progress'] = rfile.largefile.progress
+        resource = rfile.resource_set.resource
+        if resource.rtype in ALLOW_UPLOAD_RTYPES:
+            dict_representation['upload_uri'] = reverse(
+                'boot_resource_file_upload_handler',
+                args=[resource.id, rfile.id])
+
     return dict_representation
 
 
@@ -166,18 +192,26 @@
         data = request.data
         if data is None:
             data = {}
-        content = SimpleUploadedFile(
-            content=get_content_parameter(request),
-            name='file', content_type='application/octet-stream')
         if 'filetype' not in data:
             data['filetype'] = 'tgz'
-        form = BootResourceForm(data=data, files={'content': content})
+        file_content = get_content_parameter(request)
+        if file_content is not None:
+            content = SimpleUploadedFile(
+                content=file_content, name='file',
+                content_type='application/octet-stream')
+            form = BootResourceForm(data=data, files={
+                'content': content,
+                })
+        else:
+            form = BootResourceNoContentForm(data=data)
         if not form.is_valid():
             raise ValidationError(form.errors)
         resource = form.save()
 
-        # Boot resource is now available. Have the clusters sync boot images.
-        NodeGroup.objects.import_boot_images_on_accepted_clusters()
+        # If an upload contained the full file, then we can have the clusters
+        # sync a new resource.
+        if file_content is not None:
+            NodeGroup.objects.import_boot_images_on_accepted_clusters()
 
         stream = json_object(
             boot_resource_to_dict(resource, with_sets=True), request)
@@ -200,17 +234,14 @@
 
 
 class BootResourceHandler(OperationsHandler):
-    """Manage a boot resource.
-
-    This functionality is only available to administrators.
-    """
+    """Manage a boot resource."""
     api_doc_section_name = "Boot resource"
     model = BootResource
 
     create = update = None
 
     def read(self, request, id):
-        """Read a boot source."""
+        """Read a boot resource."""
         resource = get_object_or_404(BootResource, id=id)
         stream = json_object(
             boot_resource_to_dict(resource, with_sets=True), request)
@@ -233,3 +264,61 @@
         else:
             id = resource.id
         return ('boot_resource_handler', (id, ))
+
+
+class BootResourceFileUploadHandler(OperationsHandler):
+    """Upload a boot resource file."""
+    api_doc_section_name = "Boot resource file upload"
+    model = BootResource
+
+    read = create = delete = None
+
+    @admin_method
+    def update(self, request, id, file_id):
+        """Upload piece of boot resource file."""
+        resource = get_object_or_404(BootResource, id=id)
+        rfile = get_object_or_404(BootResourceFile, id=file_id)
+        size = request.META.get('CONTENT_LENGTH', 0)
+        data = request.body
+        if size == 0:
+            raise MAASAPIBadRequest("Missing data.")
+        if size != len(data):
+            raise MAASAPIBadRequest(
+                "Content-Length doesn't equal size of recieved data.")
+        if resource.rtype not in ALLOW_UPLOAD_RTYPES:
+            raise MAASAPIForbidden(
+                "Cannot upload to a resource of type: %s. " % resource.rtype)
+        if rfile.largefile.complete:
+            raise MAASAPIBadRequest(
+                "Cannot upload to a complete file.")
+
+        with rfile.largefile.content.open('wb') as stream:
+            stream.seek(0, os.SEEK_END)
+
+            # Check that the uploading data will not make the file larger
+            # than expected.
+            current_size = stream.tell()
+            if current_size + size > rfile.largefile.total_size:
+                raise MAASAPIBadRequest(
+                    "Too much data recieved.")
+
+            stream.write(data)
+
+        if rfile.largefile.complete:
+            if not rfile.largefile.valid:
+                raise MAASAPIBadRequest(
+                    "Saved content does not match given SHA256 value.")
+            NodeGroup.objects.import_boot_images_on_accepted_clusters()
+        return rc.ALL_OK
+
+    @classmethod
+    def resource_uri(cls, resource=None, rfile=None):
+        if resource is None:
+            id = 'id'
+        else:
+            id = resource.id
+        if rfile is None:
+            file_id = 'id'
+        else:
+            file_id = rfile.id
+        return ('boot_resource_file_upload_handler', (id, file_id))

=== modified file 'src/maasserver/api/tests/test_boot_resources.py'
--- src/maasserver/api/tests/test_boot_resources.py	2014-08-31 02:47:48 +0000
+++ src/maasserver/api/tests/test_boot_resources.py	2014-09-03 13:27:07 +0000
@@ -30,7 +30,11 @@
     BOOT_RESOURCE_TYPE,
     BOOT_RESOURCE_TYPE_CHOICES_DICT,
     )
-from maasserver.models import BootResource
+from maasserver.fields import LargeObjectFile
+from maasserver.models import (
+    BootResource,
+    LargeFile,
+    )
 from maasserver.testing.api import APITestCase
 from maasserver.testing.architecture import make_usable_architecture
 from maasserver.testing.factory import factory
@@ -56,7 +60,8 @@
         total_size = random.randint(1024, 2048)
         content = factory.make_string(size)
         largefile = factory.make_large_file(content=content, size=total_size)
-        resource = factory.make_boot_resource()
+        resource = factory.make_boot_resource(
+            rtype=BOOT_RESOURCE_TYPE.UPLOADED)
         resource_set = factory.make_boot_resource_set(resource)
         rfile = factory.make_boot_resource_file(resource_set, largefile)
         dict_representation = boot_resource_file_to_dict(rfile)
@@ -67,6 +72,11 @@
         self.assertEqual(False, dict_representation['complete'])
         self.assertEqual(
             rfile.largefile.progress, dict_representation['progress'])
+        self.assertEqual(
+            reverse(
+                'boot_resource_file_upload_handler',
+                args=[resource.id, rfile.id]),
+            dict_representation['upload_uri'])
 
     def test_boot_resource_set_to_dict(self):
         resource = factory.make_boot_resource()
@@ -111,7 +121,7 @@
             dict_representation['sets'][resource_set.version])
 
 
-class TestBootSourcesAPI(APITestCase):
+class TestBootResourcesAPI(APITestCase):
     """Test the the boot resource API."""
 
     def test_handler_path(self):
@@ -254,6 +264,73 @@
         rfile = resource_set.files.first()
         self.assertEqual(BOOT_RESOURCE_FILE_TYPE.ROOT_TGZ, rfile.filetype)
 
+    def test_POST_creates_boot_resource_with_already_existing_largefile(self):
+        self.become_admin()
+
+        largefile = factory.make_large_file()
+        name = factory.make_name('name')
+        architecture = make_usable_architecture(self)
+        params = {
+            'name': name,
+            'architecture': architecture,
+            'sha256': largefile.sha256,
+            'size': largefile.total_size,
+        }
+        response = self.client.post(
+            reverse('boot_resources_handler'), params)
+        self.assertEqual(httplib.CREATED, response.status_code)
+        parsed_result = json.loads(response.content)
+
+        resource = BootResource.objects.get(id=parsed_result['id'])
+        resource_set = resource.sets.first()
+        rfile = resource_set.files.first()
+        self.assertEqual(largefile, rfile.largefile)
+
+    def test_POST_creates_boot_resource_with_empty_largefile(self):
+        self.become_admin()
+
+        # Create a largefile to get a random sha256 and size. We delete it
+        # immediately so the new resource does not pick it up.
+        largefile = factory.make_large_file()
+        largefile.delete()
+
+        name = factory.make_name('name')
+        architecture = make_usable_architecture(self)
+        params = {
+            'name': name,
+            'architecture': architecture,
+            'sha256': largefile.sha256,
+            'size': largefile.total_size,
+        }
+        response = self.client.post(
+            reverse('boot_resources_handler'), params)
+        self.assertEqual(httplib.CREATED, response.status_code)
+        parsed_result = json.loads(response.content)
+
+        resource = BootResource.objects.get(id=parsed_result['id'])
+        resource_set = resource.sets.first()
+        rfile = resource_set.files.first()
+        self.assertEqual(
+            (largefile.sha256, largefile.total_size, False),
+            (rfile.largefile.sha256, rfile.largefile.total_size,
+                rfile.largefile.complete))
+
+    def test_POST_validates_size_matches_total_size_for_largefile(self):
+        self.become_admin()
+
+        largefile = factory.make_large_file()
+        name = factory.make_name('name')
+        architecture = make_usable_architecture(self)
+        params = {
+            'name': name,
+            'architecture': architecture,
+            'sha256': largefile.sha256,
+            'size': largefile.total_size + 1,
+        }
+        response = self.client.post(
+            reverse('boot_resources_handler'), params)
+        self.assertEqual(httplib.BAD_REQUEST, response.status_code)
+
     def test_POST_returns_full_definition_of_boot_resource(self):
         self.become_admin()
 
@@ -342,3 +419,141 @@
         resource = factory.make_boot_resource()
         response = self.client.delete(get_boot_resource_uri(resource))
         self.assertEqual(httplib.FORBIDDEN, response.status_code)
+
+
+class TestBootResourceFileUploadAPI(APITestCase):
+
+    def get_boot_resource_file_upload_uri(self, rfile):
+        """Return a boot resource file's URI on the API."""
+        return reverse(
+            'boot_resource_file_upload_handler',
+            args=[rfile.resource_set.resource.id, rfile.id])
+
+    def make_empty_resource_file(self, rtype=None, content=None):
+        # Create a largefile to use the generated content,
+        # sha256, and total_size.
+        if content is None:
+            content = factory.make_bytes(1024)
+        total_size = len(content)
+        largefile = factory.make_large_file(content=content, size=total_size)
+        sha256 = largefile.sha256
+        with largefile.content.open('rb') as stream:
+            content = stream.read()
+        largefile.delete()
+
+        # Empty largefile
+        largeobject = LargeObjectFile()
+        largeobject.open().close()
+        largefile = LargeFile.objects.create(
+            sha256=sha256, total_size=total_size, content=largeobject)
+
+        if rtype is None:
+            rtype = BOOT_RESOURCE_TYPE.UPLOADED
+        resource = factory.make_boot_resource(rtype=rtype)
+        resource_set = factory.make_boot_resource_set(resource)
+        rfile = factory.make_boot_resource_file(resource_set, largefile)
+        return rfile, content
+
+    def read_content(self, rfile):
+        """Return the content saved in resource file."""
+        with rfile.largefile.content.open('rb') as stream:
+            return stream.read()
+
+    def test_handler_path(self):
+        self.assertEqual(
+            '/api/1.0/boot-resources/3/upload/5/',
+            reverse('boot_resource_file_upload_handler', args=['3', '5']))
+
+    def test_PUT_resource_file_writes_content(self):
+        self.become_admin()
+        rfile, content = self.make_empty_resource_file()
+        response = self.client.put(
+            self.get_boot_resource_file_upload_uri(rfile), data=content)
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        self.assertEqual(content, self.read_content(rfile))
+
+    def test_PUT_requires_admin(self):
+        rfile, content = self.make_empty_resource_file()
+        response = self.client.put(
+            self.get_boot_resource_file_upload_uri(rfile), data=content)
+        self.assertEqual(
+            httplib.FORBIDDEN, response.status_code, response.content)
+
+    def test_PUT_returns_bad_request_when_no_content(self):
+        self.become_admin()
+        rfile, _ = self.make_empty_resource_file()
+        response = self.client.put(
+            self.get_boot_resource_file_upload_uri(rfile))
+        self.assertEqual(
+            httplib.BAD_REQUEST, response.status_code, response.content)
+
+    def test_PUT_returns_forbidden_when_resource_is_synced(self):
+        self.become_admin()
+        rfile, content = self.make_empty_resource_file(
+            BOOT_RESOURCE_TYPE.SYNCED)
+        response = self.client.put(
+            self.get_boot_resource_file_upload_uri(rfile), data=content)
+        self.assertEqual(
+            httplib.FORBIDDEN, response.status_code, response.content)
+
+    def test_PUT_returns_bad_request_when_resource_file_is_complete(self):
+        self.become_admin()
+        rfile, content = self.make_empty_resource_file()
+        with rfile.largefile.content.open('wb') as stream:
+            stream.write(content)
+
+        response = self.client.put(
+            self.get_boot_resource_file_upload_uri(rfile), data=content)
+        self.assertEqual(
+            httplib.BAD_REQUEST, response.status_code, response.content)
+
+    def test_PUT_returns_bad_request_when_content_is_too_large(self):
+        self.become_admin()
+        rfile, content = self.make_empty_resource_file()
+        content = factory.make_bytes(len(content) + 1)
+        response = self.client.put(
+            self.get_boot_resource_file_upload_uri(rfile), data=content)
+        self.assertEqual(
+            httplib.BAD_REQUEST, response.status_code, response.content)
+
+    def test_PUT_returns_bad_request_when_content_doesnt_match_sha256(self):
+        self.become_admin()
+        rfile, content = self.make_empty_resource_file()
+        content = factory.make_bytes(size=len(content))
+        response = self.client.put(
+            self.get_boot_resource_file_upload_uri(rfile), data=content)
+        self.assertEqual(
+            httplib.BAD_REQUEST, response.status_code, response.content)
+
+    def test_PUT_on_complete_calls_clusters_to_import_boot_images(self):
+        self.become_admin()
+        nodegroup = MagicMock()
+        self.patch(boot_resources, 'NodeGroup', nodegroup)
+
+        rfile, content = self.make_empty_resource_file()
+        response = self.client.put(
+            self.get_boot_resource_file_upload_uri(rfile), data=content)
+        self.assertEqual(
+            httplib.OK, response.status_code, response.content)
+        self.assertThat(
+            nodegroup.objects.import_boot_images_on_accepted_clusters,
+            MockCalledOnceWith())
+
+    def test_PUT_with_multiple_requests_and_large_content(self):
+        self.become_admin()
+
+        # Get large amount of data to test with
+        content = factory.make_bytes(1 << 24)  # 16MB
+        rfile, _ = self.make_empty_resource_file(content=content)
+        split_content = [
+            content[i:i + (1 << 22)]
+            for i in range(0, len(content), 1 << 22)  # Loop a total of 4 times
+            ]
+
+        for send_content in split_content:
+            response = self.client.put(
+                self.get_boot_resource_file_upload_uri(rfile),
+                data=send_content)
+            self.assertEqual(
+                httplib.OK, response.status_code, response.content)
+        self.assertEqual(content, self.read_content(rfile))

=== modified file 'src/maasserver/exceptions.py'
--- src/maasserver/exceptions.py	2014-08-27 09:48:49 +0000
+++ src/maasserver/exceptions.py	2014-09-03 13:27:07 +0000
@@ -77,6 +77,10 @@
     api_error = httplib.NOT_FOUND
 
 
+class MAASAPIForbidden(MAASAPIException):
+    api_error = httplib.FORBIDDEN
+
+
 class Unauthorized(MAASAPIException):
     """HTTP error 401: Unauthorized.  Login required."""
     api_error = httplib.UNAUTHORIZED

=== modified file 'src/maasserver/forms.py'
--- src/maasserver/forms.py	2014-09-03 09:07:15 +0000
+++ src/maasserver/forms.py	2014-09-03 13:27:07 +0000
@@ -88,6 +88,7 @@
     NodeActionError,
     )
 from maasserver.fields import (
+    LargeObjectFile,
     MACAddressFormField,
     NodeGroupFormField,
     )
@@ -2236,10 +2237,11 @@
         elif value == 'ddtgz':
             return BOOT_RESOURCE_FILE_TYPE.ROOT_DD
 
-    def create_resource_file(self, resource_set, filetype, content):
+    def create_resource_file(self, resource_set, data):
         """Creates a new `BootResourceFile` on the given resource set."""
-        filetype = self.get_resource_filetype(filetype)
-        largefile = LargeFile.objects.get_or_create_file_from_content(content)
+        filetype = self.get_resource_filetype(data['filetype'])
+        largefile = LargeFile.objects.get_or_create_file_from_content(
+            data['content'])
         return BootResourceFile.objects.create(
             resource_set=resource_set, largefile=largefile,
             filename=filetype, filetype=filetype)
@@ -2277,6 +2279,54 @@
         resource.save()
         resource_set = self.create_resource_set(resource, label)
         self.create_resource_file(
-            resource_set, self.cleaned_data['filetype'],
-            self.cleaned_data['content'])
+            resource_set, self.cleaned_data)
         return resource
+
+
+class BootResourceNoContentForm(BootResourceForm):
+    """Form for uploading boot resources with no content."""
+
+    class Meta:
+        model = BootResource
+        fields = (
+            'name',
+            'title',
+            'architecture',
+            'filetype',
+            'sha256',
+            'size',
+            )
+
+    sha256 = forms.CharField(
+        label="SHA256", max_length=64, min_length=64, required=True)
+
+    size = forms.IntegerField(
+        label="Size", required=True)
+
+    def __init__(self, *args, **kwargs):
+        super(BootResourceNoContentForm, self).__init__(*args, **kwargs)
+        # Remove content field, as this form does not use it
+        del self.fields['content']
+
+    def create_resource_file(self, resource_set, data):
+        """Creates a new `BootResourceFile` on the given resource set."""
+        filetype = self.get_resource_filetype(data['filetype'])
+        sha256 = data['sha256']
+        total_size = data['size']
+        largefile = LargeFile.objects.get_file(sha256)
+        if largefile is not None:
+            if total_size != largefile.total_size:
+                raise ValidationError(
+                    "File already exists with sha256 that is of "
+                    "different size.")
+        else:
+            # Create an empty large object. It must be opened and closed
+            # for the object to be created in the database.
+            largeobject = LargeObjectFile()
+            largeobject.open().close()
+            largefile = LargeFile.objects.create(
+                sha256=sha256, total_size=total_size,
+                content=largeobject)
+        return BootResourceFile.objects.create(
+            resource_set=resource_set, largefile=largefile,
+            filename=filetype, filetype=filetype)

=== modified file 'src/maasserver/models/largefile.py'
--- src/maasserver/models/largefile.py	2014-08-21 18:44:53 +0000
+++ src/maasserver/models/largefile.py	2014-09-03 13:27:07 +0000
@@ -126,6 +126,22 @@
         """`content` has been completely saved."""
         return (self.total_size == self.size)
 
+    @property
+    def valid(self):
+        """All content has been written and stored SHA256 value is the same
+        as the calculated SHA256 value stored in the database.
+
+        Note: Depending on the size of the file, this can take some time.
+        """
+        if not self.complete:
+            return False
+        sha256 = hashlib.sha256()
+        with self.content.open('rb') as stream:
+            for data in stream:
+                sha256.update(data)
+        hexdigest = sha256.hexdigest()
+        return hexdigest == self.sha256
+
     def delete(self, *args, **kwargs):
         """Delete this object.
 

=== modified file 'src/maasserver/models/tests/test_largefile.py'
--- src/maasserver/models/tests/test_largefile.py	2014-08-21 18:44:53 +0000
+++ src/maasserver/models/tests/test_largefile.py	2014-09-03 13:27:07 +0000
@@ -100,6 +100,23 @@
         largefile = factory.make_large_file()
         self.assertTrue(largefile.complete)
 
+    def test_valid_returns_False_when_complete_is_False(self):
+        size = randint(512, 1024)
+        total_size = randint(1025, 2048)
+        content = factory.make_string(size=size)
+        largefile = factory.make_large_file(content, size=total_size)
+        self.assertFalse(largefile.valid)
+
+    def test_valid_returns_False_when_content_doesnt_have_equal_sha256(self):
+        largefile = factory.make_large_file()
+        with largefile.content.open('wb') as stream:
+            stream.write(factory.make_string(size=largefile.total_size))
+        self.assertFalse(largefile.valid)
+
+    def test_valid_returns_True_when_content_has_equal_sha256(self):
+        largefile = factory.make_large_file()
+        self.assertTrue(largefile.valid)
+
     def test_delete_calls_unlink_on_content(self):
         largefile = factory.make_large_file()
         content = largefile.content

=== modified file 'src/maasserver/urls_api.py'
--- src/maasserver/urls_api.py	2014-08-28 16:08:16 +0000
+++ src/maasserver/urls_api.py	2014-09-03 13:27:07 +0000
@@ -22,6 +22,7 @@
 from maasserver.api.auth import api_auth
 from maasserver.api.boot_images import BootImagesHandler
 from maasserver.api.boot_resources import (
+    BootResourceFileUploadHandler,
     BootResourceHandler,
     BootResourcesHandler,
     )
@@ -107,6 +108,8 @@
 account_handler = RestrictedResource(AccountHandler, authentication=api_auth)
 boot_resource_handler = RestrictedResource(
     BootResourceHandler, authentication=api_auth)
+boot_resource_file_upload_handler = RestrictedResource(
+    BootResourceFileUploadHandler, authentication=api_auth)
 boot_resources_handler = RestrictedResource(
     BootResourcesHandler, authentication=api_auth)
 files_handler = RestrictedResource(FilesHandler, authentication=api_auth)
@@ -244,6 +247,10 @@
     url(
         r'^boot-resources/(?P<id>[^/]+)/$',
         boot_resource_handler, name='boot_resource_handler'),
+    url(
+        r'^boot-resources/(?P<id>[^/]+)/upload/(?P<file_id>[^/]+)/$',
+        boot_resource_file_upload_handler,
+        name='boot_resource_file_upload_handler'),
 )