Merge lp:~blake-rouse/maas/create-bcache-ui into lp:~maas-committers/maas/trunk

[Blake Rouse]

Add the ability to create and delete cache sets. Add the ability to create a bcache device by selecting an available disk, its cache set, and its caching mode. Include cache sets in the JSON result over the websocket. Render the cache sets in their own section under filesystems.

[Andres Rodriguez (andreserl)]

lgtm!

review: Approve

=== modified file 'src/maasserver/models/blockdevice.py'
--- src/maasserver/models/blockdevice.py	2015-10-19 17:56:35 +0000
+++ src/maasserver/models/blockdevice.py	2015-10-21 17:51:26 +0000
@@ -232,24 +232,12 @@
     @property
     def used_size(self):
         """Return the used size on the block device."""
-        filesystem = self.get_effective_filesystem()
-        if filesystem is not None:
-            return self.size
-        partitiontable = self.get_partitiontable()
-        if partitiontable is not None:
-            return partitiontable.get_used_size()
-        return 0
+        return self.get_used_size()
 
     @property
     def available_size(self):
         """Return the available size on the block device."""
-        filesystem = self.get_effective_filesystem()
-        if filesystem is not None:
-            return 0
-        partitiontable = self.get_partitiontable()
-        if partitiontable is not None:
-            return partitiontable.get_available_size()
-        return self.size
+        return self.get_available_size()
 
     @property
     def used_for(self):
@@ -261,6 +249,30 @@
             size=human_readable_bytes(self.size),
             node=self.node)
 
+    def get_block_size(self):
+        """Return the block size for the block device."""
+        return self.block_size
+
+    def get_used_size(self):
+        """Return the used size on the block device."""
+        filesystem = self.get_effective_filesystem()
+        if filesystem is not None:
+            return self.size
+        partitiontable = self.get_partitiontable()
+        if partitiontable is not None:
+            return partitiontable.get_used_size()
+        return 0
+
+    def get_available_size(self):
+        """Return the available size on the block device."""
+        filesystem = self.get_effective_filesystem()
+        if filesystem is not None:
+            return 0
+        partitiontable = self.get_partitiontable()
+        if partitiontable is not None:
+            return partitiontable.get_available_size()
+        return self.size
+
     def delete(self):
         """Delete the block device.
 

=== modified file 'src/maasserver/static/js/angular/controllers/node_details_storage.js'
--- src/maasserver/static/js/angular/controllers/node_details_storage.js	2015-10-19 20:12:24 +0000
+++ src/maasserver/static/js/angular/controllers/node_details_storage.js	2015-10-21 17:51:26 +0000
@@ -4,6 +4,44 @@
  * MAAS Node Storage Controller
  */
 
+
+// Filter that is specific to the NodeStorageController. Remove the available
+// disks from the list if being used in the availableNew.
+angular.module('MAAS').filter('removeAvailableByNew', function() {
+    return function(disks, availableNew) {
+        if(!angular.isObject(availableNew) || (
+            !angular.isObject(availableNew.device) &&
+            !angular.isArray(availableNew.devices))) {
+            return disks;
+        }
+
+        var filtered = [];
+        var single = true;
+        if(angular.isArray(availableNew.devices)) {
+            single = false;
+        }
+        angular.forEach(disks, function(disk) {
+            if(single) {
+                if(disk !== availableNew.device) {
+                    filtered.push(disk);
+                }
+            } else {
+                var i, found = false;
+                for(i = 0; i < availableNew.devices.length; i++) {
+                    if(disk === availableNew.devices[i]) {
+                        found = true;
+                        break;
+                    }
+                }
+                if(!found) {
+                    filtered.push(disk);
+                }
+            }
+        });
+        return filtered;
+    };
+});
+
 angular.module('MAAS').controller('NodeStorageController', [
     '$scope', 'NodesManager', 'ConverterService',
     function($scope, NodesManager, ConverterService) {
@@ -19,7 +57,8 @@
             UNFORMAT: "unformat",
             DELETE: "delete",
             FORMAT_AND_MOUNT: "format-mount",
-            PARTITION: "partition"
+            PARTITION: "partition",
+            BCACHE: "bcache"
         };
 
         $scope.editing = false;
@@ -30,10 +69,15 @@
         $scope.filesystemsMap = {};
         $scope.filesystemMode = SELECTION_MODE.NONE;
         $scope.filesystemAllSelected = false;
+        $scope.cachesets = [];
+        $scope.cachesetsMap = {};
+        $scope.cachesetsMode = SELECTION_MODE.NONE;
+        $scope.cachesetsAllSelected = false;
         $scope.available = [];
         $scope.availableMap = {};
         $scope.availableMode = SELECTION_MODE.NONE;
         $scope.availableAllSelected = false;
+        $scope.availableNew = {};
         $scope.used = [];
 
         // Give $parent which is the NodeDetailsController access to this scope
@@ -62,7 +106,9 @@
 
         // Return True if the item is in use.
         function isInUse(item) {
-            if(angular.isObject(item.filesystem)) {
+            if(item.type === "cache-set") {
+                return true;
+            } else if(angular.isObject(item.filesystem)) {
                 if(item.filesystem.is_format_fstype &&
                     angular.isString(item.filesystem.mount_point) &&
                     item.filesystem.mount_point !== "") {
@@ -84,6 +130,19 @@
             return tags;
         }
 
+        // Return a unique key that will never change.
+        function getUniqueKey(disk) {
+            if(disk.type === "cache-set") {
+                return "cache-set-" + disk.cache_set_id;
+            } else {
+                var key = disk.type + "-" + disk.block_id;
+                if(angular.isNumber(disk.partition_id)) {
+                    key += "-" + disk.partition_id;
+                }
+                return key;
+            }
+        }
+
         // Update the list of filesystems. Only filesystems with a mount point
         // set go here. If no mount point is set, it goes in available.
         function updateFilesystems() {
@@ -92,6 +151,7 @@
             angular.forEach($scope.node.disks, function(disk) {
                 if(hasMountedFilesystem(disk)) {
                     filesystems.push({
+                        "type": "filesystem",
                         "name": disk.name,
                         "size_human": disk.size_human,
                         "fstype": disk.filesystem.fstype,
@@ -103,6 +163,7 @@
                 angular.forEach(disk.partitions, function(partition) {
                     if(hasMountedFilesystem(partition)) {
                         filesystems.push({
+                            "type": "filesystem",
                             "name": partition.name,
                             "size_human": partition.size_human,
                             "fstype": partition.filesystem.fstype,
@@ -117,7 +178,8 @@
             // Update the selected filesystems with the currently selected
             // filesystems.
             angular.forEach(filesystems, function(filesystem) {
-                var oldFilesystem = $scope.filesystemsMap[filesystem.name];
+                var key = getUniqueKey(filesystem);
+                var oldFilesystem = $scope.filesystemsMap[key];
                 if(angular.isObject(oldFilesystem)) {
                     filesystem.$selected = oldFilesystem.$selected;
                 } else {
@@ -129,13 +191,52 @@
             $scope.filesystems = filesystems;
             $scope.filesystemsMap = {};
             angular.forEach(filesystems, function(filesystem) {
-                $scope.filesystemsMap[filesystem.name] = filesystem;
+                $scope.filesystemsMap[getUniqueKey(filesystem)] = filesystem;
             });
 
             // Update the selection mode.
             $scope.updateFilesystemSelection(false);
         }
 
+        // Update the list of cache sets.
+        function updateCacheSets() {
+            // Create the new list of cache sets.
+            var cachesets = [];
+            angular.forEach($scope.node.disks, function(disk) {
+                if(disk.type === "cache-set") {
+                    cachesets.push({
+                        "type": "cache-set",
+                        "name": disk.name,
+                        "size_human": disk.size_human,
+                        "cache_set_id": disk.id,
+                        "used_by": disk.used_for
+                    });
+                }
+            });
+
+            // Update the selected cache sets with the currently selected
+            // cache sets.
+            angular.forEach(cachesets, function(cacheset) {
+                var key = getUniqueKey(cacheset);
+                var oldCacheSet = $scope.cachesetsMap[key];
+                if(angular.isObject(oldCacheSet)) {
+                    cacheset.$selected = oldCacheSet.$selected;
+                } else {
+                    cacheset.$selected = false;
+                }
+            });
+
+            // Update the cachesets and cachesetsMap on the scope.
+            $scope.cachesets = cachesets;
+            $scope.cachesetsMap = {};
+            angular.forEach(cachesets, function(cacheset) {
+                $scope.cachesetsMap[getUniqueKey(cacheset)] = cacheset;
+            });
+
+            // Update the selection mode.
+            $scope.updateCacheSetsSelection(false);
+        }
+
         // Update list of all available disks.
         function updateAvailable() {
             var available = [];
@@ -192,7 +293,8 @@
             // available disks. Also copy the $options so they are not lost
             // for the current action.
             angular.forEach(available, function(disk) {
-                var oldDisk = $scope.availableMap[disk.name];
+                var key = getUniqueKey(disk);
+                var oldDisk = $scope.availableMap[key];
                 if(angular.isObject(oldDisk)) {
                     disk.$selected = oldDisk.$selected;
                     disk.$options = oldDisk.$options;
@@ -206,9 +308,31 @@
             $scope.available = available;
             $scope.availableMap = {};
             angular.forEach(available, function(disk) {
-                $scope.availableMap[disk.name] = disk;
+                $scope.availableMap[getUniqueKey(disk)] = disk;
             });
 
+            // Update device or devices on the availableNew object to be
+            // there new objects.
+            if(angular.isObject($scope.availableNew)) {
+                // Update device.
+                if(angular.isObject($scope.availableNew.device)) {
+                    var key = getUniqueKey($scope.availableNew.device);
+                    $scope.availableNew.device = $scope.availableMap[key];
+                // Update devices.
+                } else if(angular.isArray($scope.availableNew.devices)) {
+                    var newDevices = [];
+                    angular.forEach(
+                        $scope.availableNew.devices, function(device) {
+                            var key = getUniqueKey(device);
+                            var newDevice = $scope.availableMap[key];
+                            if(angular.isObject(newDevice)) {
+                                newDevices.push(newDevice);
+                            }
+                        });
+                    $scope.availableNew.devices = newDevices;
+                }
+            }
+
             // Update the selection mode.
             $scope.updateAvailableSelection(false);
         }
@@ -217,18 +341,22 @@
         function updateUsed() {
             var used = [];
             angular.forEach($scope.node.disks, function(disk) {
-                if(isInUse(disk)) {
-                    used.push({
+                if(isInUse(disk) && disk.type !== "cache-set") {
+                    var data = {
                         "name": disk.name,
                         "type": disk.type,
                         "model": disk.model,
                         "serial": disk.serial,
                         "tags": getTags(disk),
                         "used_for": disk.used_for
-                    });
+                    };
+                    if(disk.type === "virtual") {
+                        data.parent_type = disk.parent.type;
+                    }
+                    used.push(data);
                 }
                 angular.forEach(disk.partitions, function(partition) {
-                    if(isInUse(partition)) {
+                    if(isInUse(partition) && partition.type !== "cache-set") {
                         used.push({
                             "name": partition.name,
                             "type": "partition",
@@ -248,6 +376,7 @@
             if(angular.isArray($scope.node.disks)) {
                 $scope.has_disks = $scope.node.disks.length > 0;
                 updateFilesystems();
+                updateCacheSets();
                 updateAvailable();
                 updateUsed();
             } else {
@@ -256,10 +385,15 @@
                 $scope.filesystemsMap = {};
                 $scope.filesystemMode = SELECTION_MODE.NONE;
                 $scope.filesystemAllSelected = false;
+                $scope.cachesets = [];
+                $scope.cachesetsMap = {};
+                $scope.cachesetsMode = SELECTION_MODE.NONE;
+                $scope.cachesetsAllSelected = false;
                 $scope.available = [];
                 $scope.availableMap = {};
                 $scope.availableMode = SELECTION_MODE.NONE;
                 $scope.availableAllSelected = false;
+                $scope.availableNew = {};
                 $scope.used = [];
             }
         }
@@ -282,18 +416,33 @@
             return pattern.test(string);
         }
 
-        // Convert the string to a byte.
-        function convertToBytes(string, units) {
-            var value = parseFloat(string);
-            if(units === "mb") {
-                return value * 1000 * 1000;
-            } else if(units === "gb") {
-                return value * 1000 * 1000 * 1000;
-            } else if(units === "tb") {
-                return value * 1000 * 1000 * 1000 * 1000;
+        // Extract the index from the bcache name.
+        function getBcacheIndexFromName(name) {
+            var pattern = /^bcache([0-9]+)$/;
+            var match = pattern.exec(name);
+            if(angular.isArray(match) && match.length === 2) {
+                return parseInt(match[1], 10);
             }
         }
 
+        // Get the next bcache device name.
+        function getNextBcacheName() {
+            var idx = -1;
+            angular.forEach($scope.node.disks, function(disk) {
+                var bcacheIdx = getBcacheIndexFromName(disk.name);
+                if(angular.isNumber(bcacheIdx)) {
+                    idx = Math.max(idx, bcacheIdx);
+                }
+                angular.forEach(disk.partitions, function(partition) {
+                    bcacheIdx = getBcacheIndexFromName(partition.name);
+                    if(angular.isNumber(bcacheIdx)) {
+                        idx = Math.max(idx, bcacheIdx);
+                    }
+                });
+            });
+            return "bcache" + (idx + 1);
+        }
+
         // Called by $parent when the node has been loaded.
         $scope.nodeLoaded = function() {
             $scope.$watch("node.disks", updateDisks);
@@ -413,6 +562,10 @@
 
         // Return the device type for the disk.
         $scope.getDeviceType = function(disk) {
+            if(angular.isUndefined(disk)) {
+                return "";
+            }
+
             if(disk.type === "virtual") {
                 if(disk.parent_type === "lvm-vg") {
                     return "Logical Volume";
@@ -551,6 +704,7 @@
         // Cancel the current available operation.
         $scope.availableCancel = function() {
             $scope.updateAvailableSelection(true);
+            $scope.availableNew = {};
         };
 
         // Enter unformat mode.
@@ -653,7 +807,7 @@
         // Return true if the disk can be deleted.
         $scope.canDelete = function(disk) {
             if(!disk.has_partitions && (
-                    !angular.isString(disk.fstype) || disk.fstype === "")) {
+                !angular.isString(disk.fstype) || disk.fstype === "")) {
                 return true;
             } else {
                 return false;
@@ -777,6 +931,7 @@
             }
         };
 
+        // Confirm the partition creation.
         $scope.availableConfirmPartition = function(disk) {
             // Do nothing if not valid.
             if($scope.isAddPartitionSizeInvalid(disk)) {
@@ -820,6 +975,231 @@
             $scope.updateAvailableSelection(true);
         };
 
+        // Return array of selected cache sets.
+        $scope.getSelectedCacheSets = function() {
+            var cachesets = [];
+            angular.forEach($scope.cachesets, function(cacheset) {
+                if(cacheset.$selected) {
+                    cachesets.push(cacheset);
+                }
+            });
+            return cachesets;
+        };
+
+        // Update the currect mode for the cache sets section and the all
+        // selected value.
+        $scope.updateCacheSetsSelection = function(force) {
+            if(angular.isUndefined(force)) {
+                force = false;
+            }
+            var cachesets = $scope.getSelectedCacheSets();
+            if(cachesets.length === 0) {
+                $scope.cachesetsMode = SELECTION_MODE.NONE;
+            } else if(cachesets.length === 1 && force) {
+                $scope.cachesetsMode = SELECTION_MODE.SINGLE;
+            } else if(force) {
+                $scope.cachesetsMode = SELECTION_MODE.MUTLI;
+            }
+
+            if($scope.cachesets.length === 0) {
+                $scope.cachesetsAllSelected = false;
+            } else if(cachesets.length === $scope.cachesets.length) {
+                $scope.cachesetsAllSelected = true;
+            } else {
+                $scope.cachesetsAllSelected = false;
+            }
+        };
+
+        // Toggle the selection of the filesystem.
+        $scope.toggleCacheSetSelect = function(cacheset) {
+            cacheset.$selected = !cacheset.$selected;
+            $scope.updateCacheSetsSelection(true);
+        };
+
+        // Toggle the selection of all filesystems.
+        $scope.toggleCacheSetAllSelect = function() {
+            angular.forEach($scope.cachesets, function(cacheset) {
+                if($scope.cachesetsAllSelected) {
+                    cacheset.$selected = false;
+                } else {
+                    cacheset.$selected = true;
+                }
+            });
+            $scope.updateCacheSetsSelection(true);
+        };
+
+        // Return true if checkboxes in the cache sets section should be
+        // disabled.
+        $scope.isCacheSetsDisabled = function() {
+            return (
+                $scope.cachesetsMode !== SELECTION_MODE.NONE &&
+                $scope.cachesetsMode !== SELECTION_MODE.SINGLE &&
+                $scope.cachesetsMode !== SELECTION_MODE.MUTLI);
+        };
+
+        // Cancel the current cache set operation.
+        $scope.cacheSetCancel = function() {
+            $scope.updateCacheSetsSelection(true);
+        };
+
+        // Can delete the cache set.
+        $scope.canDeleteCacheSet = function(cacheset) {
+            return cacheset.used_by === "";
+        };
+
+        // Enter delete mode.
+        $scope.cacheSetDelete = function() {
+            $scope.cachesetsMode = SELECTION_MODE.DELETE;
+        };
+
+        // Quickly enter delete by selecting the cache set first.
+        $scope.quickCacheSetDelete = function(cacheset) {
+            deselectAll($scope.cachesets);
+            cacheset.$selected = true;
+            $scope.updateCacheSetsSelection(true);
+            $scope.cacheSetDelete();
+        };
+
+        // Confirm the delete action for cache set.
+        $scope.cacheSetConfirmDelete = function(cacheset) {
+            NodesManager.deleteCacheSet(
+                $scope.node, cacheset.cache_set_id);
+
+            var idx = $scope.cachesets.indexOf(cacheset);
+            $scope.cachesets.splice(idx, 1);
+            $scope.updateCacheSetsSelection();
+        };
+
+        // Return true if a cache set can be created.
+        $scope.canCreateCacheSet = function() {
+            if($scope.isAvailableDisabled()) {
+                return false;
+            }
+
+            var selected = $scope.getSelectedAvailable();
+            if(selected.length === 1) {
+                return !$scope.hasUnmountedFilesystem(selected[0]);
+            }
+            return false;
+        };
+
+        // Called to create a cache set.
+        $scope.createCacheSet = function() {
+            if(!$scope.canCreateCacheSet()) {
+                return;
+            }
+
+            // Create cache set.
+            var disk = $scope.getSelectedAvailable()[0];
+            NodesManager.createCacheSet(
+                $scope.node, disk.block_id, disk.partition_id);
+
+            // Remove from available.
+            var idx = $scope.available.indexOf(disk);
+            $scope.available.splice(idx, 1);
+        };
+
+        // Return true if a bcache can be created.
+        $scope.canCreateBcache = function() {
+            if($scope.isAvailableDisabled()) {
+                return false;
+            }
+
+            var selected = $scope.getSelectedAvailable();
+            if(selected.length === 1) {
+                var allowed = !$scope.hasUnmountedFilesystem(selected[0]);
+                return allowed && $scope.cachesets.length > 0;
+            }
+            return false;
+        };
+
+        // Enter bcache mode.
+        $scope.createBcache = function() {
+            if(!$scope.canCreateBcache()) {
+                return;
+            }
+            $scope.availableMode = SELECTION_MODE.BCACHE;
+            $scope.availableNew = {
+                name: getNextBcacheName(),
+                device: $scope.getSelectedAvailable()[0],
+                cacheset: $scope.cachesets[0],
+                cacheMode: "writeback",
+                fstype: null,
+                mountPoint: ""
+            };
+        };
+
+        // Return true when the name of the new disk is invalid.
+        $scope.isNewDiskNameInvalid = function() {
+            if(!angular.isObject($scope.node) ||
+                !angular.isArray($scope.node.disks)) {
+                return true;
+            }
+
+            if($scope.availableNew.name === "") {
+                return true;
+            } else {
+                var i, j;
+                for(i = 0; i < $scope.node.disks.length; i++) {
+                    var disk = $scope.node.disks[i];
+                    if($scope.availableNew.name === disk.name) {
+                        return true;
+                    }
+                    if(angular.isArray(disk.partitions)) {
+                        for(j = 0; j < disk.partitions.length; j++) {
+                            var partition = disk.partitions[j];
+                            if($scope.availableNew.name === partition.name) {
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+            return false;
+        };
+
+        // Return true if bcache can be saved.
+        $scope.createBcacheCanSave = function() {
+            return (
+                !$scope.isNewDiskNameInvalid() &&
+                !$scope.isMountPointInvalid($scope.availableNew.mountPoint));
+        };
+
+        // Confirm and create the bcache device.
+        $scope.availableConfirmCreateBcache = function() {
+            if(!$scope.createBcacheCanSave()) {
+                return;
+            }
+
+            // Create the bcache.
+            var params = {
+                name: $scope.availableNew.name,
+                cache_set: $scope.availableNew.cacheset.cache_set_id,
+                cache_mode: $scope.availableNew.cacheMode
+            };
+            if($scope.availableNew.device.type === "partition") {
+                params.partition_id = $scope.availableNew.device.partition_id;
+            } else {
+                params.block_id = $scope.availableNew.device.block_id;
+            }
+            if(angular.isString($scope.availableNew.fstype) &&
+                $scope.availableNew.fstype !== "") {
+                params.fstype = $scope.availableNew.fstype;
+                if($scope.availableNew.mountPoint !== "") {
+                    params.mount_point = $scope.availableNew.mountPoint;
+                }
+            }
+            NodesManager.createBcache($scope.node, params);
+
+            // Remove device from available.
+            var idx = $scope.available.indexOf($scope.availableNew.device);
+            $scope.available.splice(idx, 1);
+            $scope.availableNew = {};
+
+            // Update the selection.
+            $scope.updateAvailableSelection(true);
+        };
+
         // Called to enter tag editing mode
         $scope.editTags = function() {
             if($scope.$parent.canEdit() && !$scope.editing) {

=== modified file 'src/maasserver/static/js/angular/controllers/tests/test_node_details_networking.js'
--- src/maasserver/static/js/angular/controllers/tests/test_node_details_networking.js	2015-10-19 20:12:24 +0000
+++ src/maasserver/static/js/angular/controllers/tests/test_node_details_networking.js	2015-10-21 17:51:26 +0000
@@ -2687,7 +2687,7 @@
                 type: "alias"
             };
             var nic2 = {
-                id: makeInteger(0, 100),
+                id: makeInteger(101, 200),
                 link_id: makeInteger(0, 100),
                 type: "alias"
             };
@@ -2711,7 +2711,7 @@
                 vlan: {}
             };
             var nic2 = {
-                id: makeInteger(0, 100),
+                id: makeInteger(101, 200),
                 link_id: makeInteger(0, 100),
                 type: "physical",
                 vlan: {}
@@ -2737,7 +2737,7 @@
                 vlan: vlan
             };
             var nic2 = {
-                id: makeInteger(0, 100),
+                id: makeInteger(101, 200),
                 link_id: makeInteger(0, 100),
                 type: "physical",
                 vlan: vlan

=== modified file 'src/maasserver/static/js/angular/controllers/tests/test_node_details_storage.js'
--- src/maasserver/static/js/angular/controllers/tests/test_node_details_storage.js	2015-10-19 20:12:24 +0000
+++ src/maasserver/static/js/angular/controllers/tests/test_node_details_storage.js	2015-10-21 17:51:26 +0000
@@ -4,6 +4,79 @@
  * Unit tests for NodeStorageController.
  */
 
+describe("removeAvailableByNew", function() {
+
+    // Load the MAAS module.
+    beforeEach(module("MAAS"));
+
+    // Load the removeAvailableByNew.
+    var removeAvailableByNew;
+    beforeEach(inject(function($filter) {
+        removeAvailableByNew = $filter("removeAvailableByNew");
+    }));
+
+    it("returns disks if undefined availableNew", function() {
+        var i, disk, disks = [];
+        for(i = 0; i < 3; i++) {
+            disk = {
+                id: i
+            };
+            disks.push(disk);
+        }
+        expect(removeAvailableByNew(disks)).toBe(disks);
+    });
+
+    it("returns disks if undefined device(s) in availableNew", function() {
+        var i, disk, disks = [];
+        for(i = 0; i < 3; i++) {
+            disk = {
+                id: i
+            };
+            disks.push(disk);
+        }
+        var availableNew = {};
+        expect(removeAvailableByNew(disks, availableNew)).toBe(disks);
+    });
+
+    it("removes availableNew.device from disks", function() {
+        var i, disk, disks = [];
+        for(i = 0; i < 3; i++) {
+            disk = {
+                id: i
+            };
+            disks.push(disk);
+        }
+
+        var availableNew = {
+            device: disks[0]
+        };
+        var expectedDisks = angular.copy(disks);
+        expectedDisks.splice(0, 1);
+
+        expect(removeAvailableByNew(disks, availableNew)).toEqual(
+            expectedDisks);
+    });
+
+    it("removes availableNew.devices from disks", function() {
+        var i, disk, disks = [];
+        for(i = 0; i < 6; i++) {
+            disk = {
+                id: i
+            };
+            disks.push(disk);
+        }
+
+        var availableNew = {
+            devices: [disks[0], disks[1]]
+        };
+        var expectedDisks = angular.copy(disks);
+        expectedDisks.splice(0, 2);
+
+        expect(removeAvailableByNew(disks, availableNew)).toEqual(
+            expectedDisks);
+    });
+});
+
 describe("NodeStorageController", function() {
     // Load the MAAS module.
     beforeEach(module("MAAS"));
@@ -154,6 +227,25 @@
                         used_for: "ext4 formatted filesystem mounted at /mnt."
                     }
                 ]
+            },
+            {
+                // Disk that is a cache set.
+                id: 4,
+                name: "cache0",
+                model: "",
+                serial: "",
+                tags: [],
+                type: "cache-set",
+                size: Math.pow(1024, 4),
+                size_human: "1024 GB",
+                available_size: 0,
+                available_size_human: "0 GB",
+                used_size: Math.pow(1024, 4),
+                used_size_human: "1024 GB",
+                partition_table_type: null,
+                used_for: "",
+                filesystem: null,
+                partitions: null
             }
         ];
     }
@@ -171,6 +263,10 @@
         expect($scope.availableMap).toEqual({});
         expect($scope.availableMode).toBeNull();
         expect($scope.availableAllSelected).toBe(false);
+        expect($scope.cachesets).toEqual([]);
+        expect($scope.cachesetsMap).toEqual({});
+        expect($scope.cachesetsMode).toBeNull();
+        expect($scope.cachesetsAllSelected).toBe(false);
         expect($scope.used).toEqual([]);
     });
 
@@ -195,6 +291,7 @@
 
         var filesystems = [
             {
+                type: "filesystem",
                 name: disks[2].name,
                 size_human: disks[2].size_human,
                 fstype: disks[2].filesystem.fstype,
@@ -204,6 +301,7 @@
                 $selected: false
             },
             {
+                type: "filesystem",
                 name: disks[3].partitions[1].name,
                 size_human: disks[3].partitions[1].size_human,
                 fstype: disks[3].partitions[1].filesystem.fstype,
@@ -213,6 +311,16 @@
                 $selected: false
             }
         ];
+        var cachesets = [
+            {
+                type: "cache-set",
+                name: disks[4].name,
+                size_human: disks[4].size_human,
+                cache_set_id: disks[4].id,
+                used_by: disks[4].used_for,
+                $selected: false
+            }
+        ];
         var available = [
             {
                 name: disks[0].name,
@@ -297,6 +405,7 @@
         $rootScope.$digest();
         expect($scope.has_disks).toEqual(true);
         expect($scope.filesystems).toEqual(filesystems);
+        expect($scope.cachesets).toEqual(cachesets);
         expect($scope.available).toEqual(available);
         expect($scope.used).toEqual(used);
     });
@@ -306,14 +415,17 @@
         var disks = makeDisks();
         node.disks = disks;
 
-        // Load the filesystems, available, and used once.
+        // Load the filesystems, cachesets, available, and used once.
         $scope.nodeLoaded();
         $rootScope.$digest();
 
-        // Set all filesystems and available to selected.
+        // Set all filesystems, cachesets, and available to selected.
         angular.forEach($scope.filesystems, function(filesystem) {
             filesystem.$selected = true;
         });
+        angular.forEach($scope.cachesets, function(cacheset) {
+            cacheset.$selected = true;
+        });
         angular.forEach($scope.available, function(disk) {
             disk.$selected = true;
         });
@@ -324,18 +436,21 @@
             options.push(disk.$options);
         });
 
-        // Force the disks to change so the filesystems, available, and used
-        // are reloaded.
+        // Force the disks to change so the filesystems, cachesets, available,
+        // and used are reloaded.
         var firstFilesystem = $scope.filesystems[0];
         node.disks = angular.copy(node.disks);
         $rootScope.$digest();
         expect($scope.filesystems[0]).not.toBe(firstFilesystem);
         expect($scope.filesystems[0]).toEqual(firstFilesystem);
 
-        // All filesystems and available should be selected.
+        // All filesystems, cachesets and available should be selected.
         angular.forEach($scope.filesystems, function(filesystem) {
             expect(filesystem.$selected).toBe(true);
         });
+        angular.forEach($scope.cachesets, function(cacheset) {
+            expect(cacheset.$selected).toBe(true);
+        });
         angular.forEach($scope.available, function(disk) {
             expect(disk.$selected).toBe(true);
         });
@@ -346,6 +461,51 @@
         });
     });
 
+    it("availableNew.device object is updated", function() {
+        var controller = makeController();
+        var disks = makeDisks();
+        node.disks = disks;
+
+        // Load the filesystems, cachesets, available, and used once.
+        $scope.nodeLoaded();
+        $rootScope.$digest();
+
+        // Set availableNew.device to a disk from available.
+        var disk = $scope.available[0];
+        $scope.availableNew.device = disk;
+
+        // Force the update. The device should be the same value but
+        // a new object.
+        node.disks = angular.copy(node.disks);
+        $rootScope.$digest();
+        expect($scope.availableNew.device).toEqual(disk);
+        expect($scope.availableNew.device).not.toBe(disk);
+    });
+
+    it("availableNew.devices array is updated", function() {
+        var controller = makeController();
+        var disks = makeDisks();
+        node.disks = disks;
+
+        // Load the filesystems, cachesets, available, and used once.
+        $scope.nodeLoaded();
+        $rootScope.$digest();
+
+        // Set availableNew.device to a disk from available.
+        var disk0 = $scope.available[0];
+        var disk1 = $scope.available[1];
+        $scope.availableNew.devices = [disk0, disk1];
+
+        // Force the update. The devices should be the same values but
+        // a new objects.
+        node.disks = angular.copy(node.disks);
+        $rootScope.$digest();
+        expect($scope.availableNew.devices[0]).toEqual(disk0);
+        expect($scope.availableNew.devices[0]).not.toBe(disk0);
+        expect($scope.availableNew.devices[1]).toEqual(disk1);
+        expect($scope.availableNew.devices[1]).not.toBe(disk1);
+    });
+
     describe("getSelectedFilesystems", function() {
 
         it("returns selected filesystems", function() {
@@ -1834,6 +1994,644 @@
             });
     });
 
+    describe("getSelectedCacheSets", function() {
+
+        it("returns selected cachesets", function() {
+            var controller = makeController();
+            var cachesets = [
+                { $selected: true },
+                { $selected: true },
+                { $selected: false },
+                { $selected: false }
+            ];
+            $scope.cachesets = cachesets;
+            expect($scope.getSelectedCacheSets()).toEqual(
+                [cachesets[0], cachesets[1]]);
+        });
+    });
+
+    describe("updateCacheSetsSelection", function() {
+
+        it("sets cachesetsMode to NONE when none selected", function() {
+            var controller = makeController();
+            spyOn($scope, "getSelectedCacheSets").and.returnValue([]);
+            $scope.cachesetsMode = "other";
+
+            $scope.updateCacheSetsSelection();
+
+            expect($scope.cachesetsMode).toBeNull();
+        });
+
+        it("doesn't sets cachesetsMode to SINGLE when not force", function() {
+            var controller = makeController();
+            spyOn($scope, "getSelectedCacheSets").and.returnValue([{}]);
+            $scope.cachesetsMode = "other";
+
+            $scope.updateCacheSetsSelection();
+
+            expect($scope.cachesetsMode).toBe("other");
+        });
+
+        it("sets cachesetsMode to SINGLE when force", function() {
+            var controller = makeController();
+            spyOn($scope, "getSelectedCacheSets").and.returnValue([{}]);
+            $scope.cachesetsMode = "other";
+
+            $scope.updateCacheSetsSelection(true);
+
+            expect($scope.cachesetsMode).toBe("single");
+        });
+
+        it("doesn't sets cachesetsMode to MUTLI when not force", function() {
+            var controller = makeController();
+            spyOn($scope, "getSelectedCacheSets").and.returnValue([{}, {}]);
+            $scope.cachesetsMode = "other";
+
+            $scope.updateCacheSetsSelection();
+
+            expect($scope.cachesetsMode).toBe("other");
+        });
+
+        it("sets cachesetsMode to MULTI when force", function() {
+            var controller = makeController();
+            spyOn($scope, "getSelectedCacheSets").and.returnValue([{}, {}]);
+            $scope.cachesetsMode = "other";
+
+            $scope.updateCacheSetsSelection(true);
+
+            expect($scope.cachesetsMode).toBe("multi");
+        });
+
+        it("sets cachesetsAllSelected to false when none selected",
+            function() {
+                var controller = makeController();
+                spyOn($scope, "getSelectedCacheSets").and.returnValue([]);
+                $scope.cachesetsAllSelected = true;
+
+                $scope.updateCacheSetsSelection();
+
+                expect($scope.cachesetsAllSelected).toBe(false);
+            });
+
+        it("sets cachesetsAllSelected to false when not all selected",
+            function() {
+                var controller = makeController();
+                $scope.cachesets = [{}, {}];
+                spyOn($scope, "getSelectedCacheSets").and.returnValue([{}]);
+                $scope.cachesetsAllSelected = true;
+
+                $scope.updateCacheSetsSelection();
+
+                expect($scope.cachesetsAllSelected).toBe(false);
+            });
+
+        it("sets cachesetsAllSelected to true when all selected",
+            function() {
+                var controller = makeController();
+                $scope.cachesets = [{}, {}];
+                spyOn($scope, "getSelectedCacheSets").and.returnValue(
+                    [{}, {}]);
+                $scope.cachesetsAllSelected = false;
+
+                $scope.updateCacheSetsSelection();
+
+                expect($scope.cachesetsAllSelected).toBe(true);
+            });
+    });
+
+    describe("toggleCacheSetSelect", function() {
+
+        it("inverts $selected", function() {
+            var controller = makeController();
+            var cacheset = { $selected: true };
+            spyOn($scope, "updateCacheSetsSelection");
+
+            $scope.toggleCacheSetSelect(cacheset);
+
+            expect(cacheset.$selected).toBe(false);
+            $scope.toggleCacheSetSelect(cacheset);
+            expect(cacheset.$selected).toBe(true);
+            expect($scope.updateCacheSetsSelection).toHaveBeenCalledWith(
+                true);
+        });
+    });
+
+    describe("toggleCacheSetAllSelect", function() {
+
+        it("sets all to true if not all selected", function() {
+            var controller = makeController();
+            var cachesets = [{ $selected: true }, { $selected: false }];
+            $scope.cachesets = cachesets;
+            $scope.cachesetsAllSelected = false;
+            spyOn($scope, "updateCacheSetsSelection");
+
+            $scope.toggleCacheSetAllSelect();
+
+            expect(cachesets[0].$selected).toBe(true);
+            expect(cachesets[1].$selected).toBe(true);
+            expect($scope.updateCacheSetsSelection).toHaveBeenCalledWith(
+                true);
+        });
+
+        it("sets all to false if all selected", function() {
+            var controller = makeController();
+            var cachesets = [{ $selected: true }, { $selected: true }];
+            $scope.cachesets = cachesets;
+            $scope.cachesetsAllSelected = true;
+            spyOn($scope, "updateCacheSetsSelection");
+
+            $scope.toggleCacheSetAllSelect();
+
+            expect(cachesets[0].$selected).toBe(false);
+            expect(cachesets[1].$selected).toBe(false);
+            expect($scope.updateCacheSetsSelection).toHaveBeenCalledWith(
+                true);
+        });
+    });
+
+    describe("isCacheSetsDisabled", function() {
+
+        it("returns false for NONE", function() {
+            var controller = makeController();
+            $scope.cachesetsMode = null;
+
+            expect($scope.isCacheSetsDisabled()).toBe(false);
+        });
+
+        it("returns false for SINGLE", function() {
+            var controller = makeController();
+            $scope.cachesetsMode = "single";
+
+            expect($scope.isCacheSetsDisabled()).toBe(false);
+        });
+
+        it("returns false for MULTI", function() {
+            var controller = makeController();
+            $scope.cachesetsMode = "multi";
+
+            expect($scope.isCacheSetsDisabled()).toBe(false);
+        });
+
+        it("returns true for DELETE", function() {
+            var controller = makeController();
+            $scope.cachesetsMode = "delete";
+
+            expect($scope.isCacheSetsDisabled()).toBe(true);
+        });
+    });
+
+    describe("cacheSetCancel", function() {
+
+        it("calls updateCacheSetsSelection with force true", function() {
+            var controller = makeController();
+            spyOn($scope, "updateCacheSetsSelection");
+
+            $scope.cacheSetCancel();
+
+            expect($scope.updateCacheSetsSelection).toHaveBeenCalledWith(
+                true);
+        });
+    });
+
+    describe("canDeleteCacheSet", function() {
+
+        it("returns true when not being used", function() {
+            var controller = makeController();
+            var cacheset = { used_by: "" };
+
+            expect($scope.canDeleteCacheSet(cacheset)).toBe(true);
+        });
+
+        it("returns false when being used", function() {
+            var controller = makeController();
+            var cacheset = { used_by: "bcache0" };
+
+            expect($scope.canDeleteCacheSet(cacheset)).toBe(false);
+        });
+    });
+
+    describe("cacheSetDelete", function() {
+
+        it("sets cachesetsMode to DELETE", function() {
+            var controller = makeController();
+            $scope.cachesetsMode = "other";
+
+            $scope.cacheSetDelete();
+
+            expect($scope.cachesetsMode).toBe("delete");
+        });
+    });
+
+    describe("quickCacheSetDelete", function() {
+
+        it("selects cacheset and calls cacheSetDelete", function() {
+            var controller = makeController();
+            var cachesets = [{ $selected: true }, { $selected: false }];
+            $scope.cachesets = cachesets;
+            spyOn($scope, "updateCacheSetsSelection");
+            spyOn($scope, "cacheSetDelete");
+
+            $scope.quickCacheSetDelete(cachesets[1]);
+
+            expect(cachesets[0].$selected).toBe(false);
+            expect(cachesets[1].$selected).toBe(true);
+            expect($scope.updateCacheSetsSelection).toHaveBeenCalledWith(
+                true);
+            expect($scope.cacheSetDelete).toHaveBeenCalled();
+        });
+    });
+
+    describe("cacheSetConfirmDelete", function() {
+
+        it("calls NodesManager.deleteCacheSet and removes from list",
+            function() {
+                var controller = makeController();
+                var cacheset = {
+                    cache_set_id: makeInteger(0, 100)
+                };
+                $scope.cachesets = [cacheset];
+                spyOn(NodesManager, "deleteCacheSet");
+                spyOn($scope, "updateCacheSetsSelection");
+
+                $scope.cacheSetConfirmDelete(cacheset);
+
+                expect(NodesManager.deleteCacheSet).toHaveBeenCalledWith(
+                    node, cacheset.cache_set_id);
+                expect($scope.cachesets).toEqual([]);
+                expect($scope.updateCacheSetsSelection).toHaveBeenCalledWith();
+            });
+    });
+
+    describe("canCreateCacheSet", function() {
+
+        it("returns false if isAvailableDisabled returns true", function() {
+            var controller = makeController();
+            spyOn($scope, "isAvailableDisabled").and.returnValue(true);
+
+            expect($scope.canCreateCacheSet()).toBe(false);
+        });
+
+        it("returns false if two selected", function() {
+            var controller = makeController();
+            spyOn($scope, "isAvailableDisabled").and.returnValue(false);
+            $scope.available = [ { $selected: true }, { $selected: true }];
+
+            expect($scope.canCreateCacheSet()).toBe(false);
+        });
+
+        it("returns false if selected has fstype", function() {
+            var controller = makeController();
+            spyOn($scope, "isAvailableDisabled").and.returnValue(false);
+            $scope.available = [
+                {
+                    fstype: "ext4",
+                    $selected: true
+                }
+            ];
+
+            expect($scope.canCreateCacheSet()).toBe(false);
+        });
+
+        it("returns true if selected has no fstype", function() {
+            var controller = makeController();
+            spyOn($scope, "isAvailableDisabled").and.returnValue(false);
+            $scope.available = [
+                {
+                    fstype: null,
+                    $selected: true
+                }
+            ];
+
+            expect($scope.canCreateCacheSet()).toBe(true);
+        });
+    });
+
+    describe("createCacheSet", function() {
+
+        it("does nothing if canCreateCacheSet returns false", function() {
+            var controller = makeController();
+            var disk = {
+                block_id: makeInteger(0, 100),
+                partition_id: makeInteger(0, 100),
+                $selected: true
+            };
+            $scope.available = [disk];
+            spyOn($scope, "canCreateCacheSet").and.returnValue(false);
+            spyOn(NodesManager, "createCacheSet");
+
+            $scope.createCacheSet();
+            expect(NodesManager.createCacheSet).not.toHaveBeenCalled();
+        });
+
+        it("calls NodesManager.createCacheSet and removes from available",
+            function() {
+                var controller = makeController();
+                var disk = {
+                    block_id: makeInteger(0, 100),
+                    partition_id: makeInteger(0, 100),
+                    $selected: true
+                };
+                $scope.available = [disk];
+                spyOn($scope, "canCreateCacheSet").and.returnValue(true);
+                spyOn(NodesManager, "createCacheSet");
+
+                $scope.createCacheSet();
+                expect(NodesManager.createCacheSet).toHaveBeenCalledWith(
+                    node, disk.block_id, disk.partition_id);
+                expect($scope.available).toEqual([]);
+            });
+    });
+
+    describe("canCreateBcache", function() {
+
+        it("returns false when isAvailableDisabled is true", function() {
+            var controller = makeController();
+            spyOn($scope, "isAvailableDisabled").and.returnValue(true);
+
+            expect($scope.canCreateBcache()).toBe(false);
+        });
+
+        it("returns false if two selected", function() {
+            var controller = makeController();
+            spyOn($scope, "isAvailableDisabled").and.returnValue(false);
+            $scope.available = [ { $selected: true }, { $selected: true }];
+
+            expect($scope.canCreateBcache()).toBe(false);
+        });
+
+        it("returns false if selected has fstype", function() {
+            var controller = makeController();
+            spyOn($scope, "isAvailableDisabled").and.returnValue(false);
+            $scope.available = [
+                {
+                    fstype: "ext4",
+                    $selected: true
+                }
+            ];
+            $scope.cachesets = [{}];
+
+            expect($scope.canCreateBcache()).toBe(false);
+        });
+
+        it("returns false if selected has no fstype but not cachesets ",
+            function() {
+                var controller = makeController();
+                spyOn($scope, "isAvailableDisabled").and.returnValue(false);
+                $scope.available = [
+                    {
+                        fstype: null,
+                        $selected: true
+                    }
+                ];
+                $scope.cachesets = [];
+
+                expect($scope.canCreateBcache()).toBe(false);
+            });
+
+        it("returns true if selected has no fstype but has cachesets ",
+            function() {
+                var controller = makeController();
+                spyOn($scope, "isAvailableDisabled").and.returnValue(false);
+                $scope.available = [
+                    {
+                        fstype: null,
+                        $selected: true
+                    }
+                ];
+                $scope.cachesets = [{}];
+
+                expect($scope.canCreateBcache()).toBe(true);
+            });
+    });
+
+    describe("createBcache", function() {
+
+        it("does nothing if canCreateBcache returns false", function() {
+            var controller = makeController();
+            $scope.availableMode = "other";
+            spyOn($scope, "canCreateBcache").and.returnValue(false);
+
+            $scope.createBcache();
+            expect($scope.availableMode).toBe("other");
+        });
+
+        it("sets availableMode and availableNew", function() {
+            var controller = makeController();
+            $scope.availableMode = "other";
+            spyOn($scope, "canCreateBcache").and.returnValue(true);
+
+            // Add bcache name to create a name after that index.
+            var otherBcache = {
+                name: "bcache4"
+            };
+            node.disks = [otherBcache];
+
+            // Will be set as the device.
+            var disk = {
+                $selected: true
+            };
+            $scope.available = [disk];
+
+            // Will be set as the cacheset.
+            var cacheset = {};
+            $scope.cachesets = [cacheset];
+
+            $scope.createBcache();
+            expect($scope.availableMode).toBe("bcache");
+            expect($scope.availableNew).toEqual({
+                name: "bcache5",
+                device: disk,
+                cacheset: cacheset,
+                cacheMode: "writeback",
+                fstype: null,
+                mountPoint: ""
+            });
+            expect($scope.availableNew.device).toBe(disk);
+            expect($scope.availableNew.cacheset).toBe(cacheset);
+        });
+    });
+
+    describe("isNewDiskNameInvalid", function() {
+
+        it("returns true if blank name", function() {
+            var controller = makeController();
+            $scope.node.disks = [];
+            $scope.availableNew.name = "";
+
+            expect($scope.isNewDiskNameInvalid()).toBe(true);
+        });
+
+        it("returns true if name used by disk", function() {
+            var controller = makeController();
+            var name = makeName("disk");
+            $scope.node.disks = [{
+                name: name
+            }];
+            $scope.availableNew.name = name;
+
+            expect($scope.isNewDiskNameInvalid()).toBe(true);
+        });
+
+        it("returns true if name used by partition", function() {
+            var controller = makeController();
+            var name = makeName("disk");
+            $scope.node.disks = [{
+                name: makeName("other"),
+                partitions: [
+                    {
+                        name: name
+                    }
+                ]
+            }];
+            $scope.availableNew.name = name;
+
+            expect($scope.isNewDiskNameInvalid()).toBe(true);
+        });
+
+        it("returns false if the name is not already used", function() {
+            var controller = makeController();
+            var name = makeName("disk");
+            $scope.node.disks = [{
+                name: makeName("other"),
+                partitions: [
+                    {
+                        name: makeName("part")
+                    }
+                ]
+            }];
+            $scope.availableNew.name = name;
+
+            expect($scope.isNewDiskNameInvalid()).toBe(false);
+        });
+    });
+
+    describe("createBcacheCanSave", function() {
+
+        it("returns false if isNewDiskNameInvalid returns true", function() {
+            var controller = makeController();
+            $scope.availableNew.mountPoint = "/";
+            spyOn($scope, "isNewDiskNameInvalid").and.returnValue(true);
+
+            expect($scope.createBcacheCanSave()).toBe(false);
+        });
+
+        it("returns false if isMountPointInvalid returns true", function() {
+            var controller = makeController();
+            $scope.availableNew.mountPoint = "not/absolute";
+            spyOn($scope, "isNewDiskNameInvalid").and.returnValue(false);
+
+            expect($scope.createBcacheCanSave()).toBe(false);
+        });
+
+        it("returns true if both return false", function() {
+            var controller = makeController();
+            $scope.availableNew.mountPoint = "/";
+            spyOn($scope, "isNewDiskNameInvalid").and.returnValue(false);
+
+            expect($scope.createBcacheCanSave()).toBe(true);
+        });
+    });
+
+    describe("availableConfirmCreateBcache", function() {
+
+        it("does nothing if createBcacheCanSave returns false", function() {
+            var controller = makeController();
+            spyOn($scope, "createBcacheCanSave").and.returnValue(false);
+            var availableNew = {
+                name: makeName("bcache"),
+                cacheset: {
+                    cache_set_id: makeInteger(0, 100)
+                },
+                cacheMode: "writearound",
+                device: {
+                    type: "partition",
+                    partition_id: makeInteger(0, 100)
+                },
+                fstype: null,
+                mountPoint: ""
+            };
+            $scope.availableNew = availableNew;
+            spyOn(NodesManager, "createBcache");
+
+            $scope.availableConfirmCreateBcache();
+            expect(NodesManager.createBcache).not.toHaveBeenCalled();
+        });
+
+        it("calls NodesManager.createBcache for partition", function() {
+            var controller = makeController();
+            spyOn($scope, "createBcacheCanSave").and.returnValue(true);
+            var device = {
+                type: "partition",
+                partition_id: makeInteger(0, 100),
+                $selected: true
+            };
+            var availableNew = {
+                name: makeName("bcache"),
+                cacheset: {
+                    cache_set_id: makeInteger(0, 100)
+                },
+                cacheMode: "writearound",
+                device: device,
+                fstype: "ext4",
+                mountPoint: "/"
+            };
+            $scope.available = [device];
+            $scope.availableNew = availableNew;
+            spyOn(NodesManager, "createBcache");
+            spyOn($scope, "updateAvailableSelection");
+
+            $scope.availableConfirmCreateBcache();
+            expect(NodesManager.createBcache).toHaveBeenCalledWith(
+                node, {
+                    name: availableNew.name,
+                    cache_set: availableNew.cacheset.cache_set_id,
+                    cache_mode: "writearound",
+                    partition_id: device.partition_id,
+                    fstype: "ext4",
+                    mount_point: "/"
+                });
+            expect($scope.available).toEqual([]);
+            expect($scope.updateAvailableSelection).toHaveBeenCalledWith(
+                true);
+        });
+
+        it("calls NodesManager.createBcache for block device", function() {
+            var controller = makeController();
+            spyOn($scope, "createBcacheCanSave").and.returnValue(true);
+            var device = {
+                type: "physical",
+                block_id: makeInteger(0, 100),
+                $selected: true
+            };
+            var availableNew = {
+                name: makeName("bcache"),
+                cacheset: {
+                    cache_set_id: makeInteger(0, 100)
+                },
+                cacheMode: "writearound",
+                device: device,
+                fstype: null,
+                mountPoint: "/"
+            };
+            $scope.available = [device];
+            $scope.availableNew = availableNew;
+            spyOn(NodesManager, "createBcache");
+            spyOn($scope, "updateAvailableSelection");
+
+            $scope.availableConfirmCreateBcache();
+            expect(NodesManager.createBcache).toHaveBeenCalledWith(
+                node, {
+                    name: availableNew.name,
+                    cache_set: availableNew.cacheset.cache_set_id,
+                    cache_mode: "writearound",
+                    block_id: device.block_id
+                });
+            expect($scope.available).toEqual([]);
+            expect($scope.updateAvailableSelection).toHaveBeenCalledWith(
+                true);
+        });
+    });
+
     describe("editTags", function() {
 
         it("doesnt sets editing to true if cannot edit", function() {

=== modified file 'src/maasserver/static/js/angular/factories/nodes.js'
--- src/maasserver/static/js/angular/factories/nodes.js	2015-10-19 17:56:35 +0000
+++ src/maasserver/static/js/angular/factories/nodes.js	2015-10-21 17:51:26 +0000
@@ -211,6 +211,19 @@
                 return RegionConnection.callMethod(method, params);
             };
 
+        // Delete a cache set.
+        NodesManager.prototype.deleteCacheSet = function(
+            node, cache_set_id) {
+                var self = this;
+                var method = this._handler + ".delete_cache_set";
+                var params = {
+                    system_id: node.system_id,
+                    cache_set_id: cache_set_id
+                };
+                return RegionConnection.callMethod(method, params);
+            };
+
+        // Create a new partition.
         NodesManager.prototype.createPartition = function(
             node, block_id, size) {
                 var self = this;
@@ -223,5 +236,29 @@
                 return RegionConnection.callMethod(method, params);
             };
 
+        // Create a new cache set.
+        NodesManager.prototype.createCacheSet = function(
+            node, block_id, partition_id) {
+                var self = this;
+                var method = this._handler + ".create_cache_set";
+                var params = {
+                    system_id: node.system_id,
+                    block_id: block_id,
+                    partition_id: partition_id
+                };
+                return RegionConnection.callMethod(method, params);
+            };
+
+        // Create a new bcache device.
+        NodesManager.prototype.createBcache = function(
+            node, params) {
+                if(!angular.isObject(params)) {
+                    params = {};
+                }
+                params.system_id = node.system_id;
+                return RegionConnection.callMethod(
+                    "node.create_bcache", params);
+            };
+
         return new NodesManager();
     }]);

=== modified file 'src/maasserver/static/js/angular/factories/tests/test_nodes.js'
--- src/maasserver/static/js/angular/factories/tests/test_nodes.js	2015-10-19 20:12:24 +0000
+++ src/maasserver/static/js/angular/factories/tests/test_nodes.js	2015-10-21 17:51:26 +0000
@@ -476,6 +476,27 @@
             });
     });
 
+    describe("deleteCacheSet", function() {
+
+        it("calls node.delete_cache_set with correct params",
+            function(done) {
+                var node = makeNode(), cache_set_id = makeInteger(0, 100);
+                webSocket.returnData.push(makeFakeResponse("deleted"));
+                NodesManager.deleteCacheSet(node, cache_set_id).then(
+                    function() {
+                        var sentObject = angular.fromJson(
+                            webSocket.sentData[0]);
+                        expect(sentObject.method).toBe(
+                            "node.delete_cache_set");
+                        expect(sentObject.params.system_id).toBe(
+                            node.system_id);
+                        expect(sentObject.params.cache_set_id).toBe(
+                            cache_set_id);
+                        done();
+                    });
+            });
+    });
+
     describe("createPartition", function() {
 
         it("calls node.create_partition with correct params",
@@ -499,4 +520,69 @@
                     });
             });
     });
+
+    describe("createCacheSet", function() {
+
+        it("calls node.create_cache_set", function(done) {
+            var fakeNode = makeNode();
+            webSocket.returnData.push(makeFakeResponse(null));
+            NodesManager.createCacheSet(
+                    fakeNode, "", "").then(function() {
+                var sentObject = angular.fromJson(webSocket.sentData[0]);
+                expect(sentObject.method).toBe("node.create_cache_set");
+                done();
+            });
+        });
+
+        it("calls node.create_cache_set with params", function(done) {
+            var fakeNode = makeNode();
+            var block_id = makeName("block_id");
+            var partition_id = makeName("block_id");
+            webSocket.returnData.push(makeFakeResponse(null));
+            NodesManager.createCacheSet(
+                    fakeNode, block_id, partition_id).then(
+                        function() {
+                var sentObject = angular.fromJson(webSocket.sentData[0]);
+                expect(sentObject.method).toBe("node.create_cache_set");
+                expect(sentObject.params.system_id).toBe(fakeNode.system_id);
+                expect(sentObject.params.block_id).toBe(block_id);
+                expect(sentObject.params.partition_id).toBe(partition_id);
+                done();
+            });
+        });
+    });
+
+    describe("createBcache", function() {
+
+        it("calls node.create_bcache", function(done) {
+            var fakeNode = makeNode();
+            webSocket.returnData.push(makeFakeResponse(null));
+            NodesManager.createBcache(
+                    fakeNode, {}).then(function() {
+                var sentObject = angular.fromJson(webSocket.sentData[0]);
+                expect(sentObject.method).toBe("node.create_bcache");
+                done();
+            });
+        });
+
+        it("calls node.create_bcache with params", function(done) {
+            var fakeNode = makeNode();
+            var params = {
+                block_id: makeName("block_id"),
+                partition_id: makeName("block_id")
+            };
+            webSocket.returnData.push(makeFakeResponse(null));
+            NodesManager.createBcache(
+                    fakeNode, params).then(
+                        function() {
+                var sentObject = angular.fromJson(webSocket.sentData[0]);
+                expect(sentObject.method).toBe("node.create_bcache");
+                expect(sentObject.params.system_id).toBe(fakeNode.system_id);
+                expect(sentObject.params.block_id).toBe(params.block_id);
+                expect(sentObject.params.partition_id).toBe(
+                    params.partition_id);
+                done();
+            });
+        });
+    });
 });

=== modified file 'src/maasserver/static/partials/node-details.html'
--- src/maasserver/static/partials/node-details.html	2015-10-21 12:36:21 +0000
+++ src/maasserver/static/partials/node-details.html	2015-10-21 17:51:26 +0000
@@ -106,7 +106,7 @@
 
                     <div class="page-header__feedback ng-hide" data-ng-show="hasActionPowerError(actionOption.name)">
                         <p class="page-header__feedback-message info">
-                            Node cannot be {$ actionOption.sentence $}, because power control software for the 
+                            Node cannot be {$ actionOption.sentence $}, because power control software for the
                             node is missing from its cluster controller. To proceed, install the
                             {$ getPowerErrors() $} on the {$ node.nodegroup.cluster_name $} cluster.
                         </p>
@@ -681,6 +681,70 @@
                         </main>
                     </section>
                 </div>
+                <div class="twelve-col padding-bottom" data-ng-show="cachesets.length">
+                    <h3>Available cache sets</h3>
+                    <section class="table">
+                        <header class="table__head">
+                            <div class="table__row">
+                                <div class="table__header table__column--3">
+                                    <input class="checkbox" type="checkbox" id="cachesets-check-all"
+                                        data-ng-checked="cachesetsAllSelected"
+                                        data-ng-click="toggleCacheSetAllSelect()"
+                                        data-ng-disabled="isCacheSetsDisabled()" />
+                                    <label class="checkbox-label" for="cachesets-check-all"></label>
+                                </div>
+                                <div class="table__header table__column--15">Name</div>
+                                <div class="table__header table__column--27">Size</div>
+                                <div class="table__header table__column--55">Used by</div>
+                            </div>
+
+                        </header>
+                        <main class="table__body">
+                            <div data-ng-repeat="cacheset in cachesets">
+                                <div class="table__row"
+                                    data-ng-class="{ active: cacheset.$selected }">
+                                    <div class="table__data table__column--3">
+                                        <input class="checkbox" type="checkbox" id="{$ cacheset.name $}"
+                                            data-ng-checked="cacheset.$selected"
+                                            data-ng-click="toggleCacheSetSelect(cacheset)"
+                                            data-ng-disabled="isCacheSetsDisabled()" />
+                                        <label class="checkbox-label" for="{$ cacheset.name $}" ></label>
+                                    </div>
+                                    <div class="table__data table__column--15">{$ cacheset.name $}</div>
+                                    <div class="table__data table__column--27">{$ cacheset.size_human $}</div>
+                                    <div class="table__data table__column--45">{$ cacheset.used_by $}</div>
+                                    <div class="table__data table__column--10">
+                                        <div class="table__controls">
+                                            <a class="icon delete"
+                                                data-ng-show="canDeleteCacheSet(cacheset)"
+                                                data-ng-click="quickCacheSetDelete(cacheset)">Remove</a>
+                                        </div>
+                                    </div>
+                                    <div class="table__dropdown">
+                                        <div class="table__row table__dropdown-row">
+                                            <div class="ng-hide" data-ng-show="cachesetsMode === 'single' && canDeleteCacheSet(cacheset)">
+                                                <div class="table__data left">
+                                                      <a class="link-cta-ubuntu text-button"
+                                                        data-ng-show="canDeleteCacheSet(cacheset)"
+                                                        data-ng-click="cacheSetDelete()">Remove</a>
+                                                </div>
+                                            </div>
+                                            <div class="ng-hide" data-ng-show="cachesetsMode === 'delete'">
+                                                <div class="table__data left margin-top--five">
+                                                      <p><span class="icon warning margin-right--ten"></span> Are you sure you want to delete this cache set?</p>
+                                                </div>
+                                                <div class="table__data right">
+                                                      <a class="link-cta-ubuntu text-button" data-ng-click="cacheSetCancel()">Cancel</a>
+                                                      <button class="cta-ubuntu" data-ng-click="cacheSetConfirmDelete(cacheset)">Remove</button>
+                                                </div>
+                                            </div>
+                                        </div>
+                                    </div>
+                                </div>
+                            </div>
+                        </main>
+                    </section>
+                </div>
                 <div class="twelve-col padding-bottom">
                     <h3>Available disks and partitions</h3>
                     <section class="table margin-bottom">
@@ -712,7 +776,7 @@
                                     No available disks or partitions.
                                 </div>
                             </div>
-                            <div data-ng-repeat="item in available">
+                            <div data-ng-repeat="item in available | removeAvailableByNew:availableNew">
                                 <div class="table__row"
                                     data-ng-class="{ active: item.$selected }">
                                     <div class="table__data table__column--3">
@@ -753,8 +817,8 @@
                                                 data-ng-show="canAddPartition(item)"
                                                 data-ng-click="availableQuickPartition(item)">Partition</a>
                                             <a class="icon delete"
-                                                data-ng-show="canDelete(item)"
-                                                data-ng-click="availableQuickDelete(item)">Delete</a>
+                                                data-ng-show="hasUnmountedFilesystem(item) || canDelete(item)"
+                                                data-ng-click="availableQuickDelete(item)">Remove</a>
                                         </div>
                                     </div>
                                     <div class="table__dropdown">
@@ -806,10 +870,10 @@
                                         <div class="table__row table__dropdown-row">
                                             <div class="ng-hide" data-ng-show="availableMode === 'single'">
                                                 <div class="table__data left">
-                                                    <button class="cta-ubuntu"
+                                                    <button class="cta-ubuntu secondary"
                                                         data-ng-show="canFormatAndMount(item)"
                                                         data-ng-click="availableFormatAndMount(item)">{$ getFormatAndMountButtonText (item) $}</button>
-                                                    <button class="cta-ubuntu"
+                                                    <button class="cta-ubuntu secondary"
                                                         data-ng-show="canAddPartition(item)"
                                                         data-ng-click="availablePartiton(item)">{$ getPartitionButtonText(item) $}</button>
                                                     <a class="link-cta-ubuntu text-button"
@@ -858,13 +922,91 @@
                                     </div>
                                 </div>
                             </div>
+                            <div class="table__row active" data-ng-show="availableMode === 'bcache'">
+                                <div class="table__data table__column--3">
+                                  <input class="checkbox" type="checkbox" id="bcache-create" disabled="disabled" checked />
+                                  <label class="checkbox-label" for="bcache-create"></label>
+                                </div>
+                                <div class="table__data table__column--15">
+                                    <input type="text" class="table__input"
+                                        data-ng-class="{ invalid: isNewDiskNameInvalid() }"
+                                        data-ng-model="availableNew.name">
+                                </div>
+                                <div class="table__data table__column--15">{$ availableNew.device.size_human $}</div>
+                                <div class="table__data table__column--15">Bcache</div>
+                                <div class="table__data table__column--45"></div>
+                                <div class="table__data table__column--7"></div>
+                                <div class="table__dropdown">
+                                    <div class="table__row table__dropdown-row padding-bottom--ten">
+                                        <div class="table__data table__column--3"></div>
+                                        <div class="table__data table__column--15">
+                                            <label for="type">Cache set</label>
+                                            <select name="cache-set" id="cache-set"
+                                                data-ng-model="availableNew.cacheset"
+                                                data-ng-options="cacheset as cacheset.name for cacheset in cachesets">
+                                            </select>
+                                        </div>
+                                        <div class="table__data table__column--15">
+                                            <label for="type">Cache mode</label>
+                                            <select name="cache-mode" id="cache-mode"
+                                                data-ng-model="availableNew.cacheMode">
+                                                <option value="writeback">writeback</option>
+                                                <option value="writethrough">writethrough</option>
+                                                <option value="writearound">writearound</option>
+                                            </select>
+                                        </div>
+                                        <div class="table__data table__column--15"></div>
+                                        <div class="table__data table__column--15">
+                                            <label for="type">File system</label>
+                                            <select name="filesys"
+                                                data-ng-model="availableNew.fstype"
+                                                data-ng-options="fs.key as fs.key for fs in node.supported_filesystems">
+                                                <option value="">Unformatted</option>
+                                            </select>
+                                        </div>
+                                        <div class="table__data table__column--30">
+                                            <label for="mountpoint">Mount point</label>
+                                            <input type="text" id="mountpoint"
+                                                ng-model="availableNew.mountPoint"
+                                                ng-class="{ invalid: isMountPointInvalid(availableNew.mountPoint) }">
+                                        </div>
+                                        <div class="table__data table__column--7"></div>
+                                    </div>
+                                    <div class="table__row table__dropdown-row table__dropdown-row--head">
+                                        <div class="table__header table__column--5"></div>
+                                        <div class="table__header table__column--15">Name</div>
+                                        <div class="table__header table__column--15">Size</div>
+                                        <div class="table__header table__column--15">Device type</div>
+                                        <div class="table__header table__column--40"></div>
+                                    </div>
+                                    <div class="table__row table__dropdown-row no-border">
+                                        <div class="table__data no-padding-top table__column--5"></div>
+                                        <div class="table__data no-padding-top table__column--15">{$ availableNew.device.name $}</div>
+                                        <div class="table__data no-padding-top table__column--15">{$ availableNew.device.size_human $}</div>
+                                        <div class="table__data no-padding-top table__column--15">{$ getDeviceType(availableNew.device) $}</div>
+                                        <div class="table__data no-padding-top table__column--40"></div>
+                                    </div>
+                                    <div class="table__row table__dropdown-row">
+                                        <div class="table__data right">
+                                            <a class="link-cta-ubuntu text-button"
+                                                data-ng-click="availableCancel()">Cancel</a>
+                                            <button class="cta-ubuntu"
+                                                data-ng-disabled="!createBcacheCanSave()"
+                                                data-ng-click="availableConfirmCreateBcache()">Create Bcache</button>
+                                        </div>
+                                    </div>
+                                </div>
+                            </div>
                         </main>
                     </section>
-                    <div class="ng-hide">
-                        <a class="link-cta-ubuntu secondary margin-right">Create RAID</a>
-                        <a class="link-cta-ubuntu secondary margin-right">Create BCache</a>
-                        <a class="link-cta-ubuntu secondary">Create LVM</a>
-                    </div>
+                    <a class="link-cta-ubuntu secondary margin-right ng-hide">Create RAID</a>
+                    <a class="link-cta-ubuntu secondary margin-right ng-hide">Create LVM</a>
+                    <a class="link-cta-ubuntu secondary margin-right"
+                        data-ng-disabled="!canCreateCacheSet()"
+                        data-ng-click="createCacheSet()">Create Cache Set</a>
+                    <a class="link-cta-ubuntu secondary"
+                        data-ng-disabled="!canCreateBcache()"
+                        data-ng-click="createBcache()">Create Bcache</a>
                 </div>
                 <div class="twelve-col padding-bottom">
                     <h3>Used disks and partitions</h3>
@@ -904,68 +1046,6 @@
 
                 <!--
 
-                // XXX ltrager 2015-09-16 - Mock static storage, to be transformed into
-                //                          something more angular friendly
-
-                // Available disks & Block devices (CREATE PARTITION ROW)
-
-                // Markup for a row when create a partition has been clicked. All
-                // Form elements creating the partition will be in table__dropdown
-                // and the original table__row has a class of active applied
-
-                <div class="table__row active">
-                    <div class="table__data table__column--3">
-                        <input class="checkbox" type="checkbox" id="sdb" />
-                        <label class="checkbox-label" for="sdb"></label>
-                    </div>
-                    <div class="table__data table__column--15">
-                        <input type="text" value="sdb" class="table__input">
-                    </div>
-                    <div class="table__data table__column--15">8.5 G</div>
-                    <div class="table__data table__column--15">Physical</div>
-                    <div class="table__data table__column--15">
-                        fat32 <a class="table__controls table__controls--secondary margin-left--ten">Mount</a>
-                    </div>
-                    <div class="table__data table__column--15">QEMU HARDDISK</div>
-                    <div class="table__data table__column--15 ng-hide">937368252</div>
-                    <div class="table__data table__column--15">
-                        <div class="table__tags">rotary, storage, test, hp, machine<span class="table__controls table__controls--secondary">, <a>edit</a></span></div>
-                    </div>
-                    <div class="table__data table__column--7">
-                        <div class="table__controls">
-                            <a class="icon partition">Partition</a>
-                            <a class="icon delete">Delete</a>
-                        </div>
-                    </div>
-                    <div class="table__dropdown">
-                        <div class="table__row table__dropdown-row padding-bottom--ten">
-                            <div class="table__data table__column--3"></div>
-                            <div class="table__data table__column--15">
-                                <label for="filesys">Filesystem</label>
-                                <select name="filesys" id="filesys">
-                                    <option value="fat32">fat32</option>
-                                </select>
-                            </div>
-                            <div class="table__data table__column--30">
-                                <label for="mountpoint">Mountpoint</label>
-                                <input type="text" id="mountpoint">
-                            </div>
-                            <div class="table__data table__column--52">
-                            </div>
-                        </div>
-                        <div class="table__row table__dropdown-row">
-                            <div class="table__data right">
-                                  <a class="link-cta-ubuntu text-button">Cancel</a>
-                                  <button class="cta-ubuntu">Mount</button>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-
-                -->
-
-                <!--
-
                 // Creating a Volume Group
 
                 // First state of creating a volume group. This row shows once you have
@@ -1236,95 +1316,6 @@
                 </div>
 
                 -->
-
-                <!--
-
-                // Create Bchache
-
-                <div class="table__row active">
-                    <div class="table__data table__column--3">
-                      <input class="checkbox" type="checkbox" id="check-all" />
-                      <label class="checkbox-label" for="check-all"></label>
-                    </div>
-                    <div class="table__data table__column--15">
-                        <input type="text" value="BChache0" class="table__input">
-                    </div>
-                    <div class="table__data table__column--15">34 G</div>
-                    <div class="table__data table__column--15">BChache</div>
-                    <div class="table__data table__column--45"></div>
-                    <div class="table__data table__column--7">
-                        <div class="table__controls">
-                            <a class="icon partition">Partition</a>
-                            <a class="icon delete">Delete</a>
-                        </div>
-                    </div>
-                    <div class="table__dropdown">
-                        <div class="table__row table__dropdown-row padding-bottom--ten">
-                          <div class="table__data table__column--3">
-                          </div>
-                          <div class="table__data table__column--15">
-                              <label for="type">BCache setting</label>
-                              <select name="type" id="type">
-                                  <option value="raid5">Setting</option>
-                              </select>
-                          </div>
-                          <div class="table__data table__column--30"></div>
-                          <div class="table__data table__column--15">
-                              <label for="type">File system</label>
-                              <select name="type" id="type">
-                                  <option value="raid5">fat32</option>
-                              </select>
-                          </div>
-                          <div class="table__data table__column--30">
-                              <label for="mtPoint">Mount point</label>
-                              <input type="text">
-                          </div>
-                          <div class="table__data table__column--7"></div>
-                        </div>
-                        <div class="table__row table__dropdown-row table__dropdown-row--head">
-                            <div class="table__header table__column--5"></div>
-                            <div class="table__header table__column--15">Name</div>
-                            <div class="table__header table__column--15">Size</div>
-                            <div class="table__header table__column--15">Device type</div>
-                            <div class="table__header table__column--10">Caching</div>
-                            <div class="table__header table__column--15">Backing</div>
-                            <div class="table__header table__column--25"></div>
-                        </div>
-                        <div class="table__row table__dropdown-row no-border">
-                            <div class="table__data no-padding-top table__column--5"></div>
-                            <div class="table__data no-padding-top table__column--15">sda</div>
-                            <div class="table__data no-padding-top table__column--15">8.5 G</div>
-                            <div class="table__data no-padding-top table__column--15">Physical</div>
-                            <div class="table__data no-padding-top table__column--10">
-                                <input type="radio" name="active" value="active">
-                            </div>
-                            <div class="table__data no-padding-top table__column--15">
-                                <input type="radio" name="active" value="spare">
-                            </div>
-                            <div class="table__data no-padding-top table__column--25"></div>
-                        </div>
-                        <div class="table__row table__dropdown-row no-border">
-                            <div class="table__data no-padding-top table__column--5"></div>
-                            <div class="table__data no-padding-top table__column--15">sdb</div>
-                            <div class="table__data no-padding-top table__column--15">8.5 G</div>
-                            <div class="table__data no-padding-top table__column--15">Physical</div>
-                            <div class="table__data no-padding-top table__column--10">
-                                <input type="radio" name="active" value="active">
-                            </div>
-                            <div class="table__data no-padding-top table__column--15">
-                                <input type="radio" name="active" value="spare" selected>
-                            </div>
-                            <div class="table__data no-padding-top table__column--25"></div>
-                        </div>
-                        <div class="table__row table__dropdown-row">
-                            <div class="table__data right">
-                                <a href="" class="link-cta-ubuntu text-button">Cancel</a>
-                                <button class="cta-ubuntu">Save</button>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-                -->
             </form>
         </div>
     </div>

=== modified file 'src/maasserver/websockets/handlers/node.py'
--- src/maasserver/websockets/handlers/node.py	2015-10-19 17:56:35 +0000
+++ src/maasserver/websockets/handlers/node.py	2015-10-21 17:51:26 +0000
@@ -33,6 +33,8 @@
 from maasserver.forms import (
     AddPartitionForm,
     AdminNodeWithMACAddressesForm,
+    CreateBcacheForm,
+    CreateCacheSetForm,
     FormatBlockDeviceForm,
     FormatPartitionForm,
     MountBlockDeviceForm,
@@ -45,6 +47,7 @@
 )
 from maasserver.forms_interface_link import InterfaceLinkForm
 from maasserver.models.blockdevice import BlockDevice
+from maasserver.models.cacheset import CacheSet
 from maasserver.models.config import Config
 from maasserver.models.event import Event
 from maasserver.models.filesystemgroup import VolumeGroup
@@ -134,7 +137,10 @@
             'delete_disk',
             'delete_partition',
             'delete_volume_group',
+            'delete_cache_set',
             'create_partition',
+            'create_cache_set',
+            'create_bcache',
         ]
         form = AdminNodeWithMACAddressesForm
         exclude = [
@@ -277,6 +283,9 @@
             data["disks"] = data["disks"] + [
                 self.dehydrate_volume_group(volume_group)
                 for volume_group in VolumeGroup.objects.filter_by_node(obj)
+            ] + [
+                self.dehydrate_cache_set(cache_set)
+                for cache_set in CacheSet.objects.get_cache_sets_for_node(obj)
             ]
             data["disks"] = sorted(data["disks"], key=itemgetter("name"))
             data["supported_filesystems"] = [
@@ -373,7 +382,7 @@
         return data
 
     def dehydrate_volume_group(self, volume_group):
-        """Return `BlockDevice` formatted for JSON encoding."""
+        """Return `VolumeGroup` formatted for JSON encoding."""
         size = volume_group.get_size()
         available_size = volume_group.get_lvm_free_space()
         used_size = volume_group.get_lvm_allocated_size()
@@ -398,6 +407,36 @@
             "partitions": None,
         }
 
+    def dehydrate_cache_set(self, cache_set):
+        """Return `CacheSet` formatted for JSON encoding."""
+        device = cache_set.get_device()
+        used_size = device.get_used_size()
+        available_size = device.get_available_size()
+        bcache_devices = sorted([
+            bcache.name
+            for bcache in cache_set.filesystemgroup_set.all()
+        ])
+        return {
+            "id": cache_set.id,
+            "name": cache_set.name,
+            "tags": [],
+            "type": "cache-set",
+            "path": "",
+            "size": device.size,
+            "size_human": human_readable_bytes(device.size),
+            "used_size": used_size,
+            "used_size_human": human_readable_bytes(used_size),
+            "available_size": available_size,
+            "available_size_human": human_readable_bytes(available_size),
+            "block_size": device.get_block_size(),
+            "model": "",
+            "serial": "",
+            "partition_table_type": "",
+            "used_for": ", ".join(bcache_devices),
+            "filesystem": None,
+            "partitions": None,
+        }
+
     def dehydrate_partitions(self, partition_table):
         """Return `PartitionTable` formatted for JSON encoding."""
         if partition_table is None:
@@ -762,6 +801,19 @@
                 raise VolumeGroup.DoesNotExist()
             volume_group.delete()
 
+    def delete_cache_set(self, params):
+        # Only admin users can perform delete.
+        if not self.user.is_superuser:
+            raise HandlerPermissionError()
+
+        node = self.get_object(params)
+        cache_set_id = params.get('cache_set_id')
+        if cache_set_id is not None:
+            cache_set = CacheSet.objects.get(id=cache_set_id)
+            if cache_set.get_node() != node:
+                raise CacheSet.DoesNotExist()
+            cache_set.delete()
+
     def create_partition(self, params):
         """Create a partition."""
         node = self.get_object(params)
@@ -775,6 +827,58 @@
         else:
             form.save()
 
+    def create_cache_set(self, params):
+        """Create a cache set."""
+        node = self.get_object(params)
+        block_id = params.get('block_id')
+        partition_id = params.get('partition_id')
+
+        data = {}
+        if partition_id is not None:
+            data["cache_partition"] = partition_id
+        elif block_id is not None:
+            data["cache_device"] = block_id
+        else:
+            raise HandlerError(
+                "Either block_id or partition_id is required.")
+
+        form = CreateCacheSetForm(node=node, data=data)
+        if not form.is_valid():
+            raise HandlerError(form.errors)
+        else:
+            form.save()
+
+    def create_bcache(self, params):
+        """Create a bcache."""
+        node = self.get_object(params)
+        block_id = params.get('block_id')
+        partition_id = params.get('partition_id')
+
+        data = {
+            "name": params["name"],
+            "cache_set": params["cache_set"],
+            "cache_mode": params["cache_mode"],
+        }
+
+        if partition_id is not None:
+            data["backing_partition"] = partition_id
+        elif block_id is not None:
+            data["backing_device"] = block_id
+        else:
+            raise HandlerError(
+                "Either block_id or partition_id is required.")
+
+        form = CreateBcacheForm(node=node, data=data)
+        if not form.is_valid():
+            raise HandlerError(form.errors)
+        else:
+            bcache = form.save()
+
+        if 'fstype' in params:
+            self.update_blockdevice_filesystem(
+                node, bcache.virtual_device.id,
+                params.get("fstype"), params.get("mount_point"))
+
     def action(self, params):
         """Perform the action on the object."""
         obj = self.get_object(params)

=== modified file 'src/maasserver/websockets/handlers/tests/test_node.py'
--- src/maasserver/websockets/handlers/tests/test_node.py	2015-10-19 20:12:24 +0000
+++ src/maasserver/websockets/handlers/tests/test_node.py	2015-10-21 17:51:26 +0000
@@ -18,16 +18,17 @@
 from operator import itemgetter
 import random
 import re
-from unittest import skip
 
 from django.contrib.auth.models import User
 from django.core.exceptions import ValidationError
 from lxml import etree
 from maasserver.enum import (
     BOND_MODE,
+    CACHE_MODE_TYPE,
     FILESYSTEM_FORMAT_TYPE_CHOICES,
     FILESYSTEM_FORMAT_TYPE_CHOICES_DICT,
     FILESYSTEM_GROUP_TYPE,
+    FILESYSTEM_TYPE,
     INTERFACE_LINK_TYPE,
     INTERFACE_TYPE,
     IPADDRESS_TYPE,
@@ -37,8 +38,12 @@
 from maasserver.forms import AdminNodeWithMACAddressesForm
 from maasserver.models import interface as interface_module
 from maasserver.models.blockdevice import BlockDevice
+from maasserver.models.cacheset import CacheSet
 from maasserver.models.config import Config
-from maasserver.models.filesystemgroup import VolumeGroup
+from maasserver.models.filesystemgroup import (
+    Bcache,
+    VolumeGroup,
+)
 from maasserver.models.interface import Interface
 from maasserver.models.nodeprobeddetails import get_single_probed_details
 from maasserver.models.partition import Partition
@@ -123,6 +128,9 @@
         disks = disks + [
             handler.dehydrate_volume_group(volume_group)
             for volume_group in VolumeGroup.objects.filter_by_node(node)
+        ] + [
+            handler.dehydrate_cache_set(cache_set)
+            for cache_set in CacheSet.objects.get_cache_sets_for_node(node)
         ]
         disks = sorted(disks, key=itemgetter("name"))
         data = {
@@ -450,20 +458,62 @@
             "partitions": None,
             }, handler.dehydrate_volume_group(volume_group))
 
+    def test_dehydrate_cache_set(self):
+        owner = factory.make_User()
+        node = factory.make_Node(owner=owner)
+        handler = NodeHandler(owner, {})
+        cache_set = factory.make_CacheSet(node=node)
+        backings = []
+        for _ in range(3):
+            backing = factory.make_PhysicalBlockDevice(node=node)
+            fs = factory.make_Filesystem(
+                block_device=backing, fstype=FILESYSTEM_TYPE.BCACHE_BACKING)
+            backings.append(
+                factory.make_FilesystemGroup(
+                    group_type=FILESYSTEM_GROUP_TYPE.BCACHE,
+                    filesystems=[fs], cache_set=cache_set))
+        self.assertEquals({
+            "id": cache_set.id,
+            "name": cache_set.name,
+            "tags": [],
+            "type": "cache-set",
+            "path": "",
+            "size": cache_set.get_device().size,
+            "size_human": human_readable_bytes(
+                cache_set.get_device().size),
+            "used_size": cache_set.get_device().get_used_size(),
+            "used_size_human": human_readable_bytes(
+                cache_set.get_device().get_used_size()),
+            "available_size": cache_set.get_device().get_available_size(),
+            "available_size_human": human_readable_bytes(
+                cache_set.get_device().get_available_size()),
+            "block_size": cache_set.get_device().get_block_size(),
+            "model": "",
+            "serial": "",
+            "partition_table_type": "",
+            "used_for": ", ".join(sorted([
+                backing_device.name
+                for backing_device in backings
+                ])),
+            "filesystem": None,
+            "partitions": None,
+            }, handler.dehydrate_cache_set(cache_set))
+
     def test_dehydrate_partitions_returns_None(self):
         owner = factory.make_User()
         handler = NodeHandler(owner, {})
         self.assertIsNone(handler.dehydrate_partitions(None))
 
-    @skip("XXX: GavinPanella 2015-10-01 bug=1501753: Fails spuriously")
     def test_dehydrate_partitions_returns_list_of_partitions(self):
         owner = factory.make_User()
         node = factory.make_Node(owner=owner)
         handler = NodeHandler(owner, {})
-        blockdevice = factory.make_PhysicalBlockDevice(node=node)
+        blockdevice = factory.make_PhysicalBlockDevice(
+            node=node, size=10 * 1024 ** 3, block_size=512)
         partition_table = factory.make_PartitionTable(block_device=blockdevice)
         partitions = [
-            factory.make_Partition(partition_table=partition_table)
+            factory.make_Partition(
+                partition_table=partition_table, size=1 * 1024 ** 3)
             for _ in range(3)
         ]
         expected = []
@@ -1193,6 +1243,18 @@
             })
         self.assertIsNone(reload_object(volume_group))
 
+    def test_delete_cache_set(self):
+        user = factory.make_admin()
+        handler = NodeHandler(user, {})
+        architecture = make_usable_architecture(self)
+        node = factory.make_Node(interface=True, architecture=architecture)
+        cache_set = factory.make_CacheSet(node=node)
+        handler.delete_cache_set({
+            'system_id': node.system_id,
+            'cache_set_id': cache_set.id,
+            })
+        self.assertIsNone(reload_object(cache_set))
+
     def test_create_partition(self):
         user = factory.make_admin()
         handler = NodeHandler(user, {})
@@ -1211,6 +1273,155 @@
             human_readable_bytes(size),
             human_readable_bytes(Partition.objects.first().size))
 
+    def test_create_cache_set_for_partition(self):
+        user = factory.make_admin()
+        handler = NodeHandler(user, {})
+        architecture = make_usable_architecture(self)
+        node = factory.make_Node(interface=True, architecture=architecture)
+        partition = factory.make_Partition(node=node)
+        handler.create_cache_set({
+            'system_id': node.system_id,
+            'partition_id': partition.id
+            })
+        cache_set = CacheSet.objects.get_cache_sets_for_node(node).first()
+        self.assertIsNotNone(cache_set)
+        self.assertEquals(partition, cache_set.get_filesystem().partition)
+
+    def test_create_cache_set_for_block_device(self):
+        user = factory.make_admin()
+        handler = NodeHandler(user, {})
+        architecture = make_usable_architecture(self)
+        node = factory.make_Node(interface=True, architecture=architecture)
+        block_device = factory.make_PhysicalBlockDevice(node=node)
+        handler.create_cache_set({
+            'system_id': node.system_id,
+            'block_id': block_device.id
+            })
+        cache_set = CacheSet.objects.get_cache_sets_for_node(node).first()
+        self.assertIsNotNone(cache_set)
+        self.assertEquals(
+            block_device.id, cache_set.get_filesystem().block_device.id)
+
+    def test_create_bcache_for_partition(self):
+        user = factory.make_admin()
+        handler = NodeHandler(user, {})
+        architecture = make_usable_architecture(self)
+        node = factory.make_Node(interface=True, architecture=architecture)
+        partition = factory.make_Partition(node=node)
+        name = factory.make_name("bcache")
+        cache_set = factory.make_CacheSet(node=node)
+        cache_mode = factory.pick_enum(CACHE_MODE_TYPE)
+        handler.create_bcache({
+            'system_id': node.system_id,
+            'partition_id': partition.id,
+            'block_id': partition.partition_table.block_device.id,
+            'name': name,
+            'cache_set': cache_set.id,
+            'cache_mode': cache_mode,
+            })
+        bcache = Bcache.objects.filter_by_node(node).first()
+        self.assertIsNotNone(bcache)
+        self.assertEquals(name, bcache.name)
+        self.assertEquals(cache_set, bcache.cache_set)
+        self.assertEquals(cache_mode, bcache.cache_mode)
+        self.assertEquals(
+            partition, bcache.get_bcache_backing_filesystem().partition)
+
+    def test_create_bcache_for_partition_with_filesystem(self):
+        user = factory.make_admin()
+        handler = NodeHandler(user, {})
+        architecture = make_usable_architecture(self)
+        node = factory.make_Node(interface=True, architecture=architecture)
+        partition = factory.make_Partition(node=node)
+        name = factory.make_name("bcache")
+        cache_set = factory.make_CacheSet(node=node)
+        cache_mode = factory.pick_enum(CACHE_MODE_TYPE)
+        fstype = factory.pick_choice(FILESYSTEM_FORMAT_TYPE_CHOICES)
+        mount_point = factory.make_absolute_path()
+        handler.create_bcache({
+            'system_id': node.system_id,
+            'partition_id': partition.id,
+            'block_id': partition.partition_table.block_device.id,
+            'name': name,
+            'cache_set': cache_set.id,
+            'cache_mode': cache_mode,
+            'fstype': fstype,
+            'mount_point': mount_point,
+            })
+        bcache = Bcache.objects.filter_by_node(node).first()
+        self.assertIsNotNone(bcache)
+        self.assertEquals(name, bcache.name)
+        self.assertEquals(cache_set, bcache.cache_set)
+        self.assertEquals(cache_mode, bcache.cache_mode)
+        self.assertEquals(
+            partition, bcache.get_bcache_backing_filesystem().partition)
+        self.assertEquals(
+            fstype,
+            bcache.virtual_device.get_effective_filesystem().fstype)
+        self.assertEquals(
+            mount_point,
+            bcache.virtual_device.get_effective_filesystem().mount_point)
+
+    def test_create_bcache_for_block_device(self):
+        user = factory.make_admin()
+        handler = NodeHandler(user, {})
+        architecture = make_usable_architecture(self)
+        node = factory.make_Node(interface=True, architecture=architecture)
+        block_device = factory.make_PhysicalBlockDevice(node=node)
+        name = factory.make_name("bcache")
+        cache_set = factory.make_CacheSet(node=node)
+        cache_mode = factory.pick_enum(CACHE_MODE_TYPE)
+        handler.create_bcache({
+            'system_id': node.system_id,
+            'block_id': block_device.id,
+            'name': name,
+            'cache_set': cache_set.id,
+            'cache_mode': cache_mode,
+            })
+        bcache = Bcache.objects.filter_by_node(node).first()
+        self.assertIsNotNone(bcache)
+        self.assertEquals(name, bcache.name)
+        self.assertEquals(cache_set, bcache.cache_set)
+        self.assertEquals(cache_mode, bcache.cache_mode)
+        self.assertEquals(
+            block_device.id,
+            bcache.get_bcache_backing_filesystem().block_device.id)
+
+    def test_create_bcache_for_block_device_with_filesystem(self):
+        user = factory.make_admin()
+        handler = NodeHandler(user, {})
+        architecture = make_usable_architecture(self)
+        node = factory.make_Node(interface=True, architecture=architecture)
+        block_device = factory.make_PhysicalBlockDevice(node=node)
+        name = factory.make_name("bcache")
+        cache_set = factory.make_CacheSet(node=node)
+        cache_mode = factory.pick_enum(CACHE_MODE_TYPE)
+        fstype = factory.pick_choice(FILESYSTEM_FORMAT_TYPE_CHOICES)
+        mount_point = factory.make_absolute_path()
+        handler.create_bcache({
+            'system_id': node.system_id,
+            'block_id': block_device.id,
+            'name': name,
+            'cache_set': cache_set.id,
+            'cache_mode': cache_mode,
+            'fstype': fstype,
+            'mount_point': mount_point,
+            })
+        bcache = Bcache.objects.filter_by_node(node).first()
+        self.assertIsNotNone(bcache)
+        self.assertEquals(name, bcache.name)
+        self.assertEquals(cache_set, bcache.cache_set)
+        self.assertEquals(cache_mode, bcache.cache_mode)
+        self.assertEquals(
+            block_device.id,
+            bcache.get_bcache_backing_filesystem().block_device.id)
+        self.assertEquals(
+            fstype,
+            bcache.virtual_device.get_effective_filesystem().fstype)
+        self.assertEquals(
+            mount_point,
+            bcache.virtual_device.get_effective_filesystem().mount_point)
+
     def test_update_raise_HandlerError_if_tag_has_definition(self):
         user = factory.make_admin()
         handler = NodeHandler(user, {})