def all_free_space_except_os_for_volume(self, spaces, volume_name):
        os_size = self.os_size(spaces)
        reserved_size = self.reserved_size(spaces)
        disk_sum_size = sum([disk["size"] for disk in only_disks(spaces)])
        vg_size = 0
        sum_lvm_meta = 0
        for disk in only_disks(spaces):
            for volume in disk["volumes"]:
                if volume.get("vg") == volume_name or volume.get("name") == volume_name:
                    vg_size += volume["size"]
                    vg_size -= volume.get("lvm_meta_size", 0)
                    sum_lvm_meta += volume.get("lvm_meta_size", 0)

        self.assertEqual(vg_size, disk_sum_size - os_size - reserved_size - sum_lvm_meta)

    def reserved_size(self, spaces):
        reserved_size = 0
        for disk in only_disks(spaces):
            reserved_size += DisksFormatConvertor.\
                calculate_service_partitions_size(disk['volumes'])

        return reserved_size

    def logical_volume_sizes_should_equal_all_phisical_volumes(self, spaces):
        vg_sizes = {}
        for vg in only_vg(spaces):
            for volume in vg['volumes']:
                vg_name = vg['id']
                if not vg_sizes.get(vg_name):
                    vg_sizes[vg_name] = 0
                vg_sizes[vg_name] += volume['size']

        pv_sizes = {}
        for disk in only_disks(spaces):
            for volume in disk['volumes']:
                # Skip cinder because it does not have
                # logical volumes
                if volume.get('vg') == 'cinder':
                    continue

                if volume['type'] == 'pv':
                    vg_name = volume['vg']
                    if not pv_sizes.get(vg_name):
                        pv_sizes[vg_name] = 0

                    pv_sizes[vg_name] += volume['size']
                    pv_sizes[vg_name] -= volume['lvm_meta_size']

        self.assertEqual(vg_sizes, pv_sizes)

 def volumes_sum_size(self, disks, vg):
     sum_size = 0
     for disk in only_disks(disks):
         volumes = filter(lambda volume: volume.get("vg") == vg, disk["volumes"])
         sum_size += sum(v["size"] for v in volumes)
     self.non_zero_size(sum_size)
     return sum_size

    def all_free_space_except_os_for_volume(self, spaces, volume_name):
        os_size = self.os_size(spaces)
        reserved_size = self.reserved_size(spaces)
        disk_sum_size = sum([disk['size'] for disk in only_disks(spaces)])
        vg_size = 0
        sum_lvm_meta = 0
        for disk in only_disks(spaces):
            for volume in disk['volumes']:
                if volume.get('vg') == volume_name or \
                   volume.get('name') == volume_name:
                    vg_size += volume['size']
                    vg_size -= volume.get('lvm_meta_size', 0)
                    sum_lvm_meta += volume.get('lvm_meta_size', 0)

        self.assertEqual(
            vg_size, disk_sum_size - os_size - reserved_size - sum_lvm_meta)

    def should_allocates_same_size(self, volumes, same_size_volume_names):
        disks = only_disks(volumes)

        actual_volumes_size = {}
        for disk in disks:
            for volume in disk['volumes']:
                name = volume.get('vg') or volume.get('name')
                if not name:
                    continue
                actual_volumes_size.setdefault(name, {})
                actual_volumes_size[name].setdefault('size', 0)
                actual_volumes_size[name].setdefault(
                    'type', volume.get('type'))
                actual_volumes_size[name]['size'] += volume.get('size')

        actual_volumes = [v for k, v in actual_volumes_size.iteritems()
                          if k in same_size_volume_names]

        # All pv should have equal size
        actual_pv_volumes = filter(
            lambda volume: volume['type'] == 'pv', actual_volumes)
        sum_pv_size = sum([volume['size'] for volume in actual_pv_volumes])
        average_size = sum_pv_size / len(actual_pv_volumes)
        for pv in actual_pv_volumes:
            # In cases where all volumes are created on one disk and
            # that disk has an odd-numbered size the volume sizes will
            # differ by 1.
            self.assertAlmostEqual(pv['size'], average_size, delta=1)

 def volumes_sum_size(self, disks, vg):
     sum_size = 0
     for disk in only_disks(disks):
         volumes = filter(
             lambda volume: volume.get('vg') == vg, disk['volumes']
         )
         sum_size += sum(v['size'] for v in volumes)
     self.non_zero_size(sum_size)
     return sum_size

    def test_get_default_attrs(self):
        self.env.create_node(api=False)
        node_db = self.env.nodes[0]
        volumes_from_api = self.get(node_db.id)

        default_volumes = node_db.volume_manager.gen_volumes_info()
        disks = only_disks(default_volumes)

        self.assertEqual(len(disks), len(volumes_from_api))

    def glance_size(self, disks):
        glance_sum_size = 0
        for disk in only_disks(disks):
            glance_volume = filter(
                lambda volume: volume.get('vg') == 'image', disk['volumes']
            )[0]
            glance_sum_size += glance_volume['size']

        self.non_zero_size(glance_sum_size)
        return glance_sum_size

    def os_size(self, disks, with_lvm_meta=True):
        os_sum_size = 0
        for disk in only_disks(disks):
            os_volume = filter(lambda volume: volume.get("vg") == "os", disk["volumes"])[0]
            os_sum_size += os_volume["size"]
            if not with_lvm_meta:
                os_sum_size -= os_volume["lvm_meta_size"]

        self.non_zero_size(os_sum_size)
        return os_sum_size

    def mysql_size(self, disks):
        mysql_sum_size = 0
        for disk in only_disks(disks):
            mysql_volume = filter(
                lambda volume: volume.get('vg') == 'mysql', disk['volumes']
            )[0]
            mysql_sum_size += mysql_volume['size']

        self.non_zero_size(mysql_sum_size)
        return mysql_sum_size

    def os_size(self, disks, with_lvm_meta=True):
        os_sum_size = 0
        for disk in only_disks(disks):
            os_volume = filter(
                lambda volume: volume.get('vg') == 'os', disk['volumes'])[0]
            os_sum_size += os_volume['size']
            if not with_lvm_meta:
                os_sum_size -= os_volume['lvm_meta_size']

        self.non_zero_size(os_sum_size)
        return os_sum_size

    def all_free_space_except_os_disks_for_volume(self, volume_manager, volume_name):
        spaces = volume_manager.volumes
        reserved_size = self.reserved_size(spaces)
        disk_sum_size = sum([disk["size"] for disk in only_disks(spaces)])
        boot_data_size = volume_manager.call_generator("calc_boot_size") + volume_manager.call_generator(
            "calc_boot_records_size"
        )
        vg_size = 0
        sum_lvm_meta = 0

        for disk in only_disks(spaces):
            for volume in disk["volumes"]:
                # Exclude disks with OS vg as Ceph won't be there
                if volume.get("vg") == "os" and volume.get("size", 0) > 0:
                    disk_sum_size -= disk["size"] - boot_data_size
                if volume.get("vg") == volume_name or volume.get("name") == volume_name:
                    vg_size += volume["size"]
                    vg_size -= volume.get("lvm_meta_size", 0)
                    sum_lvm_meta += volume.get("lvm_meta_size", 0)

        self.assertEqual(vg_size, disk_sum_size - reserved_size - sum_lvm_meta)

    def test_allocates_all_free_space_for_os_for_controller_role(self):
        node = self.create_node('controller')
        disks = only_disks(node.volume_manager.volumes)
        disks_size_sum = sum([disk['size'] for disk in disks])
        os_sum_size = self.os_size(disks)
        glance_sum_size = self.glance_size(disks)
        reserved_size = self.reserved_size(disks)

        self.assertEqual(disks_size_sum - reserved_size,
                         os_sum_size + glance_sum_size)
        self.logical_volume_sizes_should_equal_all_phisical_volumes(
            node.attributes.volumes)
        self.check_disk_size_equal_sum_of_all_volumes(node.attributes.volumes)

    def all_free_space_except_os_disks_for_volume(self, volume_manager,
                                                  volume_name):
        spaces = volume_manager.volumes
        reserved_size = self.reserved_size(spaces)
        disk_sum_size = sum([disk['size'] for disk in only_disks(spaces)])
        boot_data_size = volume_manager.call_generator('calc_boot_size') + \
            volume_manager.call_generator('calc_boot_records_size')
        vg_size = 0
        sum_lvm_meta = 0

        for disk in only_disks(spaces):
            for volume in disk['volumes']:
                # Exclude disks with OS vg as Ceph won't be there
                if volume.get('vg') == 'os' and volume.get('size', 0) > 0:
                    disk_sum_size -= (disk['size'] - boot_data_size)
                if volume.get('vg') == volume_name or \
                   volume.get('name') == volume_name:
                    vg_size += volume['size']
                    vg_size -= volume.get('lvm_meta_size', 0)
                    sum_lvm_meta += volume.get('lvm_meta_size', 0)

        self.assertEqual(
            vg_size, disk_sum_size - reserved_size - sum_lvm_meta)

    def test_allocates_all_free_space_for_os_for_controller_role(self):
        node = self.create_node("controller")
        disks = only_disks(node.volume_manager.volumes)
        disks_size_sum = sum([disk["size"] for disk in disks])
        os_sum_size = self.os_size(disks)
        mysql_sum_size = self.mysql_size(disks)
        glance_sum_size = self.glance_size(disks)
        horizon_sum_size = self.horizon_size(disks)
        logs_sum_size = self.logs_size(disks)
        reserved_size = self.reserved_size(disks)

        self.assertEqual(
            disks_size_sum - reserved_size,
            os_sum_size + glance_sum_size + mysql_sum_size + logs_sum_size + horizon_sum_size,
        )
        self.logical_volume_sizes_should_equal_all_phisical_volumes(VolumeManagerExtension.get_node_volumes(node))
        self.check_disk_size_equal_sum_of_all_volumes(VolumeManagerExtension.get_node_volumes(node))

    def check_disk_size_equal_sum_of_all_volumes(self, spaces):
        for disk in only_disks(spaces):
            volumes_size = sum(
                [volume.get('size', 0) for volume in disk['volumes']])

            self.assertEqual(volumes_size, disk['size'])

    def check_disk_size_equal_sum_of_all_volumes(self, spaces):
        for disk in only_disks(spaces):
            volumes_size = sum([volume.get("size", 0) for volume in disk["volumes"]])

            self.assertEqual(volumes_size, disk["size"])