starlingx
/
config
Code Issues Proposed changes

Remove img-conversions and gnocchi platform logical volumes 

These two partitions are no longer needed in a k8s deployment.
Both of them are now managed by the openstack application.

Change-Id: Id342c3eafc839a268683ff369353cf4a5f23027d
Story: 2004695
Task: 30052
Depends-On: https://review.openstack.org/#/c/639246/
Signed-off-by: Ovidiu Poncea <ovidiu.poncea@windriver.com>
This commit is contained in:
Ovidiu Poncea 2019-03-18 12:09:36 +02:00 committed by Tee Ngo
parent 56275fb5b0
commit 14cfe576c2
13 changed files with 76 additions and 360 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
controllerconfig/controllerconfig/controllerconfig/common/constants.py
View File

@ -35,26 +35,18 @@ LINK_MTU_DEFAULT = "1500"
CINDER_LVM_THIN = "thin"
CINDER_LVM_THICK = "thick"
DEFAULT_IMAGE_STOR_SIZE = \
sysinv_constants.DEFAULT_IMAGE_STOR_SIZE
DEFAULT_CGCS_STOR_SIZE = \
sysinv_constants.DEFAULT_CGCS_STOR_SIZE
DEFAULT_DATABASE_STOR_SIZE = \
sysinv_constants.DEFAULT_DATABASE_STOR_SIZE
DEFAULT_IMG_CONVERSION_STOR_SIZE = \
sysinv_constants.DEFAULT_IMG_CONVERSION_STOR_SIZE
DEFAULT_SMALL_IMAGE_STOR_SIZE = \
sysinv_constants.DEFAULT_SMALL_IMAGE_STOR_SIZE
DEFAULT_SMALL_CGCS_STOR_SIZE = \
sysinv_constants.DEFAULT_SMALL_CGCS_STOR_SIZE
DEFAULT_SMALL_DATABASE_STOR_SIZE = \
sysinv_constants.DEFAULT_SMALL_DATABASE_STOR_SIZE
DEFAULT_SMALL_IMG_CONVERSION_STOR_SIZE = \
sysinv_constants.DEFAULT_SMALL_IMG_CONVERSION_STOR_SIZE
DEFAULT_SMALL_BACKUP_STOR_SIZE = \
sysinv_constants.DEFAULT_SMALL_BACKUP_STOR_SIZE
DEFAULT_VIRTUAL_IMAGE_STOR_SIZE = \
sysinv_constants.DEFAULT_VIRTUAL_IMAGE_STOR_SIZE
DEFAULT_VIRTUAL_DATABASE_STOR_SIZE = \
sysinv_constants.DEFAULT_VIRTUAL_DATABASE_STOR_SIZE
DEFAULT_VIRTUAL_IMG_CONVERSION_STOR_SIZE = \
sysinv_constants.DEFAULT_VIRTUAL_IMG_CONVERSION_STOR_SIZE
DEFAULT_VIRTUAL_BACKUP_STOR_SIZE = \
sysinv_constants.DEFAULT_VIRTUAL_BACKUP_STOR_SIZE
DEFAULT_EXTENSION_STOR_SIZE = \

73
puppet-manifests/src/modules/platform/manifests/filesystem.pp
View File

@ -144,26 +144,6 @@ class platform::filesystem::scratch
}
}
class platform::filesystem::gnocchi::params (
$lv_size = '5',
$lv_name = 'gnocchi-lv',
$mountpoint = '/opt/gnocchi',
$devmapper = '/dev/mapper/cgts--vg-gnocchi--lv',
$fs_type = 'ext4',
$fs_options = '-i 8192'
) { }
class platform::filesystem::gnocchi
inherits ::platform::filesystem::gnocchi::params {
platform::filesystem { $lv_name:
lv_name => $lv_name,
lv_size => $lv_size,
mountpoint => $mountpoint,
fs_type => $fs_type,
fs_options => $fs_options
}
}
class platform::filesystem::docker::params (
$lv_size = '1',
@ -189,27 +169,6 @@ class platform::filesystem::docker
}
}
class platform::filesystem::img_conversions::params (
$lv_size = '8',
$lv_name = 'img-conversions-lv',
$mountpoint = '/opt/img-conversions',
$devmapper = '/dev/mapper/cgts--vg-img--conversions--lv',
$fs_type = 'ext4',
$fs_options = ' '
) {}
class platform::filesystem::img_conversions
inherits ::platform::filesystem::img_conversions::params {
platform::filesystem { $lv_name:
lv_name => $lv_name,
lv_size => $lv_size,
mountpoint => $mountpoint,
fs_type => $fs_type,
fs_options => $fs_options
}
}
class platform::filesystem::storage {
@ -238,8 +197,6 @@ class platform::filesystem::controller {
include ::platform::filesystem::backup
include ::platform::filesystem::scratch
include ::platform::filesystem::docker
include ::platform::filesystem::img_conversions
include ::platform::filesystem::gnocchi
}
@ -273,21 +230,6 @@ class platform::filesystem::scratch::runtime {
}
class platform::filesystem::gnocchi::runtime {
include ::platform::filesystem::gnocchi::params
$lv_name = $::platform::filesystem::gnocchi::params::lv_name
$lv_size = $::platform::filesystem::gnocchi::params::lv_size
$devmapper = $::platform::filesystem::gnocchi::params::devmapper
platform::filesystem::resize { $lv_name:
lv_name => $lv_name,
lv_size => $lv_size,
devmapper => $devmapper,
}
}
class platform::filesystem::docker::runtime {
include ::platform::filesystem::docker::params
@ -303,20 +245,6 @@ class platform::filesystem::docker::runtime {
}
class platform::filesystem::img_conversions::runtime {
include ::platform::filesystem::img_conversions::params
$lv_name = $::platform::filesystem::img_conversions::params::lv_name
$lv_size = $::platform::filesystem::img_conversions::params::lv_size
$devmapper = $::platform::filesystem::img_conversions::params::devmapper
platform::filesystem::resize { $lv_name:
lv_name => $lv_name,
lv_size => $lv_size,
devmapper => $devmapper,
}
}
class platform::filesystem::docker::params::bootstrap (
$lv_size = '30',
$lv_name = 'docker-lv',
@ -327,6 +255,7 @@ class platform::filesystem::docker::params::bootstrap (
$fs_use_all = false
) { }
class platform::filesystem::docker::bootstrap
inherits ::platform::filesystem::docker::params::bootstrap {

38
sysinv/sysinv/sysinv/sysinv/api/controllers/v1/controller_fs.py
View File

@ -65,16 +65,12 @@ class ControllerFs(base.APIBase):
/var/lib/postgresql (pgsql-lv)
The image GiB of controller_fs - maps to
/opt/cgcs (cgcs-lv)
The image conversion GiB of controller_fs - maps to
/opt/img-conversions (img-conversions-lv)
The backup GiB of controller_fs - maps to
/opt/backups (backup-lv)
The scratch GiB of controller_fs - maps to
/scratch (scratch-lv)
The extension GiB of controller_fs - maps to
/opt/extension (extension-lv)
The gnocchi GiB of controller_fs - maps to
/opt/gnocchi (gnocchi-lv)
"""
uuid = types.uuid
@ -272,7 +268,7 @@ def _check_controller_multi_fs(controller_fs_new_list,
if ceph_mon_gib_new:
msg = _(
"Total target growth size %s GiB for database "
"(doubled for upgrades), glance, img-conversions, "
"(doubled for upgrades), glance, "
"scratch, backup, extension and ceph-mon exceeds "
"growth limit of %s GiB." %
(cgtsvg_growth_gib, cgtsvg_max_free_GiB)
@ -280,7 +276,7 @@ def _check_controller_multi_fs(controller_fs_new_list,
else:
msg = _(
"Total target growth size %s GiB for database "
"(doubled for upgrades), glance, img-conversions, scratch, "
"(doubled for upgrades), glance, scratch, "
"backup and extension exceeds growth limit of %s GiB." %
(cgtsvg_growth_gib, cgtsvg_max_free_GiB)
)
@ -488,7 +484,7 @@ def _check_controller_fs(controller_fs_new=None,
if ceph_mon_gib_new:
msg = _(
"Total target growth size %s GiB for database "
"(doubled for upgrades), glance, img-conversions, "
"(doubled for upgrades), glance, "
"scratch, backup, extension and ceph-mon exceeds "
"growth limit of %s GiB." %
(cgtsvg_growth_gib, cgtsvg_max_free_GiB)
@ -496,43 +492,24 @@ def _check_controller_fs(controller_fs_new=None,
else:
msg = _(
"Total target growth size %s GiB for database "
"(doubled for upgrades), glance, img-conversions, scratch, "
"(doubled for upgrades), glance, scratch, "
"backup and extension exceeds growth limit of %s GiB." %
(cgtsvg_growth_gib, cgtsvg_max_free_GiB)
)
raise wsme.exc.ClientSideError(msg)
def _check_controller_multi_fs_data(context, controller_fs_list_new,
modified_fs):
def _check_controller_multi_fs_data(context, controller_fs_list_new):
""" Check controller filesystem data and return growth
returns: cgtsvg_growth_gib
"""
cgtsvg_growth_gib = 0
# Check if we need img_conversions
img_conversion_required = False
lvdisplay_keys = [constants.FILESYSTEM_LV_DICT[constants.FILESYSTEM_NAME_DATABASE],
constants.FILESYSTEM_LV_DICT[constants.FILESYSTEM_NAME_CGCS],
constants.FILESYSTEM_LV_DICT[constants.FILESYSTEM_NAME_BACKUP],
constants.FILESYSTEM_LV_DICT[constants.FILESYSTEM_NAME_SCRATCH],
constants.FILESYSTEM_LV_DICT[constants.FILESYSTEM_NAME_GNOCCHI]]
# On primary region, img-conversions always exists in controller_fs DB table.
# On secondary region, if both glance and cinder are sharing from the primary
# region, img-conversions won't exist in controller_fs DB table. We already
# have semantic check not to allow img-conversions resizing.
if (StorageBackendConfig.has_backend(pecan.request.dbapi, constants.SB_TYPE_LVM) or
StorageBackendConfig.has_backend(pecan.request.dbapi, constants.SB_TYPE_CEPH)):
img_conversion_required = True
lvdisplay_keys.append(constants.FILESYSTEM_LV_DICT[constants.FILESYSTEM_NAME_IMG_CONVERSIONS])
if (constants.FILESYSTEM_NAME_IMG_CONVERSIONS in modified_fs and
not img_conversion_required):
raise wsme.exc.ClientSideError(
_("%s is not modifiable: no cinder backend is "
"currently configured.") % constants.FILESYSTEM_NAME_IMG_CONVERSIONS)
constants.FILESYSTEM_LV_DICT[constants.FILESYSTEM_NAME_SCRATCH]]
lvdisplay_dict = pecan.request.rpcapi.get_controllerfs_lv_sizes(context)
@ -760,8 +737,7 @@ class ControllerFsController(rest.RestController):
cgtsvg_growth_gib = _check_controller_multi_fs_data(
pecan.request.context,
controller_fs_list_new,
modified_fs)
controller_fs_list_new)
if _check_controller_state():
_check_controller_multi_fs(controller_fs_list_new,

6
sysinv/sysinv/sysinv/sysinv/api/controllers/v1/storage_ceph.py
View File

@ -36,7 +36,6 @@ import wsmeext.pecan as wsme_pecan
from sysinv.api.controllers.v1 import base
from sysinv.api.controllers.v1 import collection
from sysinv.api.controllers.v1 import controller_fs as controller_fs_api
from sysinv.api.controllers.v1 import link
from sysinv.api.controllers.v1 import types
from sysinv.api.controllers.v1 import utils
@ -695,11 +694,6 @@ def _check_and_update_rbd_provisioner(new_storceph, remove=False):
def _apply_backend_changes(op, sb_obj):
services = api_helper.getListFromServices(sb_obj.as_dict())
# Make sure img_conversion partition is present
if (constants.SB_SVC_CINDER in services or
constants.SB_SVC_GLANCE in services):
StorageBackendConfig.set_img_conversions_defaults(
pecan.request.dbapi, controller_fs_api)
if op == constants.SB_API_OP_CREATE:
if sb_obj.name == constants.SB_DEFAULT_NAMES[

5
sysinv/sysinv/sysinv/sysinv/api/controllers/v1/storage_lvm.py
View File

@ -35,7 +35,6 @@ import wsmeext.pecan as wsme_pecan
from sysinv.api.controllers.v1 import base
from sysinv.api.controllers.v1 import collection
from sysinv.api.controllers.v1 import controller_fs as controller_fs_api
from sysinv.api.controllers.v1 import link
from sysinv.api.controllers.v1 import types
from sysinv.api.controllers.v1 import utils
@ -43,7 +42,6 @@ from sysinv.api.controllers.v1.utils import SBApiHelper as api_helper
from sysinv.common import constants
from sysinv.common import exception
from sysinv.common import utils as cutils
from sysinv.common.storage_backend_conf import StorageBackendConfig
from sysinv import objects
from sysinv.openstack.common import log
from sysinv.openstack.common import uuidutils
@ -515,9 +513,6 @@ def _create(storage_lvm):
storage_lvm,
storage_lvm.pop('confirmed', False))
StorageBackendConfig.set_img_conversions_defaults(pecan.request.dbapi,
controller_fs_api)
# We have a valid configuration. create it.
system = pecan.request.dbapi.isystem_get_one()
storage_lvm['forisystemid'] = system.id

23
sysinv/sysinv/sysinv/sysinv/common/constants.py
View File

@ -283,31 +283,25 @@ VSWITCH_TYPE_NUAGE_VRS = "nuage_vrs"
VSWITCH_TYPE_NONE = "none"
# Partition default sizes
DEFAULT_IMAGE_STOR_SIZE = 10
DEFAULT_CGCS_STOR_SIZE = 20
DEFAULT_DOCKER_STOR_SIZE = 1
DEFAULT_DOCKER_DISTRIBUTION_STOR_SIZE = 1
DEFAULT_DATABASE_STOR_SIZE = 20
DEFAULT_IMG_CONVERSION_STOR_SIZE = 20
DEFAULT_SMALL_IMAGE_STOR_SIZE = 10
DEFAULT_SMALL_CGCS_STOR_SIZE = 10
DEFAULT_SMALL_DATABASE_STOR_SIZE = 10
DEFAULT_SMALL_IMG_CONVERSION_STOR_SIZE = 10
DEFAULT_SMALL_BACKUP_STOR_SIZE = 40
DEFAULT_VIRTUAL_IMAGE_STOR_SIZE = 8
DEFAULT_VIRTUAL_DATABASE_STOR_SIZE = 5
DEFAULT_VIRTUAL_IMG_CONVERSION_STOR_SIZE = 8
DEFAULT_VIRTUAL_BACKUP_STOR_SIZE = 5
DEFAULT_EXTENSION_STOR_SIZE = 1
DEFAULT_PATCH_VAULT_STOR_SIZE = 8
DEFAULT_ETCD_STORE_SIZE = 1
DEFAULT_GNOCCHI_STOR_SIZE = 5
# The threshold between small and large disks is 240GiB
DEFAULT_SMALL_DISK_SIZE = 240
# The minimum disk size needed to create all partitions
# Value based on the following calculation:
# DEFAULT_SMALL_IMAGE_STOR_SIZE 10
# DEFAULT_SMALL_CGCS_STOR_SIZE 10
# 2*DEFAULT_SMALL_DATABASE_STOR_SIZE 20 (2*10)
# DEFAULT_SMALL_IMG_CONVERSION_STOR_SIZE 10
# DEFAULT_SMALL_BACKUP_STOR_SIZE 40
# LOG_VOL_SIZE (reserved in kickstarts) 8
# SCRATCH_VOL_SIZE (reserved in kickstarts) 8
@ -315,7 +309,6 @@ DEFAULT_SMALL_DISK_SIZE = 240
# PLATFORM_LV 2
# ANCHOR_LV 1
# DEFAULT_EXTENSION_STOR_SIZE 1
# DEFAULT_GNOCCHI_STOR_SIZE 5
# KUBERNETES_DOCKER_STOR_SIZE (--kubernetes) 30
# DOCKER_DISTRIBUTION_STOR_SIZE (--kubernetes) 16
# ETCD_STOR_SIZE (--kubernetes) 5
@ -325,8 +318,8 @@ DEFAULT_SMALL_DISK_SIZE = 240
# boot partition (created in kickstarts) 1
# buffer for partition creation 1
# -------------------------------------------------------
# 201
MINIMUM_DISK_SIZE = 201
# 186
MINIMUM_DISK_SIZE = 186
# Docker lv size when Kubernetes is configured
KUBERNETES_DOCKER_STOR_SIZE = 30
@ -510,14 +503,12 @@ FILESYSTEM_NAME_CGCS = 'cgcs'
FILESYSTEM_DISPLAY_NAME_CGCS = 'glance'
FILESYSTEM_NAME_CINDER = 'cinder'
FILESYSTEM_NAME_DATABASE = 'database'
FILESYSTEM_NAME_IMG_CONVERSIONS = 'img-conversions'
FILESYSTEM_NAME_SCRATCH = 'scratch'
FILESYSTEM_NAME_DOCKER = 'docker'
FILESYSTEM_NAME_DOCKER_DISTRIBUTION = 'docker-distribution'
FILESYSTEM_NAME_EXTENSION = 'extension'
FILESYSTEM_NAME_ETCD = 'etcd'
FILESYSTEM_NAME_PATCH_VAULT = 'patch-vault'
FILESYSTEM_NAME_GNOCCHI = 'gnocchi'
FILESYSTEM_LV_DICT = {
FILESYSTEM_NAME_CGCS: 'cgcs-lv',
@ -525,12 +516,10 @@ FILESYSTEM_LV_DICT = {
FILESYSTEM_NAME_SCRATCH: 'scratch-lv',
FILESYSTEM_NAME_DOCKER: 'docker-lv',
FILESYSTEM_NAME_DOCKER_DISTRIBUTION: 'dockerdistribution-lv',
FILESYSTEM_NAME_IMG_CONVERSIONS: 'img-conversions-lv',
FILESYSTEM_NAME_DATABASE: 'pgsql-lv',
FILESYSTEM_NAME_EXTENSION: 'extension-lv',
FILESYSTEM_NAME_ETCD: 'etcd-lv',
FILESYSTEM_NAME_PATCH_VAULT: 'patch-vault-lv',
FILESYSTEM_NAME_GNOCCHI: 'gnocchi-lv'
}
SUPPORTED_LOGICAL_VOLUME_LIST = FILESYSTEM_LV_DICT.values()
@ -541,13 +530,11 @@ SUPPORTED_FILEYSTEM_LIST = [
FILESYSTEM_NAME_CINDER,
FILESYSTEM_NAME_DATABASE,
FILESYSTEM_NAME_EXTENSION,
FILESYSTEM_NAME_IMG_CONVERSIONS,
FILESYSTEM_NAME_SCRATCH,
FILESYSTEM_NAME_DOCKER,
FILESYSTEM_NAME_DOCKER_DISTRIBUTION,
FILESYSTEM_NAME_PATCH_VAULT,
FILESYSTEM_NAME_ETCD,
FILESYSTEM_NAME_GNOCCHI
]
SUPPORTED_REPLICATED_FILEYSTEM_LIST = [

47
sysinv/sysinv/sysinv/sysinv/common/storage_backend_conf.py
View File

@ -12,13 +12,11 @@
import pecan
import wsme
import ast
from sysinv.common import constants
from sysinv.common import exception
from sysinv.common import utils as cutils
from sysinv.openstack.common.gettextutils import _
from sysinv.openstack.common import log
@ -380,51 +378,6 @@ class StorageBackendConfig(object):
constants.SB_TYPE_CEPH]:
return backend.task == constants.SB_TASK_RESTORE
@staticmethod
def set_img_conversions_defaults(dbapi, controller_fs_api):
"""
initialize img_conversion partitions with default values if not
already done
:param dbapi
:param controller_fs_api
"""
# Img conversions identification
values = {'name': constants.FILESYSTEM_NAME_IMG_CONVERSIONS,
'logical_volume': constants.FILESYSTEM_LV_DICT[
constants.FILESYSTEM_NAME_IMG_CONVERSIONS],
'replicated': False}
# Abort if is already defined
controller_fs_list = dbapi.controller_fs_get_list()
for fs in controller_fs_list:
if values['name'] == fs.name:
LOG.info("Image conversions already defined, "
"avoiding reseting values")
return
# Check if there is enough space available
cgtsvg_max_free_GiB = controller_fs_api._get_controller_cgtsvg_limit()
args = {'avail': cgtsvg_max_free_GiB,
'min': constants.DEFAULT_SMALL_IMG_CONVERSION_STOR_SIZE,
'lvg': constants.LVG_CGTS_VG}
if cgtsvg_max_free_GiB >= constants.DEFAULT_IMG_CONVERSION_STOR_SIZE:
img_conversions_gib = constants.DEFAULT_IMG_CONVERSION_STOR_SIZE
elif cgtsvg_max_free_GiB >= constants.DEFAULT_SMALL_IMG_CONVERSION_STOR_SIZE:
img_conversions_gib = constants.DEFAULT_SMALL_IMG_CONVERSION_STOR_SIZE
else:
msg = _("Not enough space for image conversion partition. "
"Please ensure that '%(lvg)s' VG has at least %(min)s GiB free space."
"Currently available: %(avail)s GiB." % args)
raise wsme.exc.ClientSideError(msg)
args['size'] = img_conversions_gib
LOG.info("Available space in '%(lvg)s' is %(avail)s GiB "
"from which img_conversions will use %(size)s GiB." % args)
# Create entry
values['size'] = img_conversions_gib
dbapi.controller_fs_create(values)
@staticmethod
def get_enabled_services(dbapi, filter_unconfigured=True,
filter_shared=False):

119
sysinv/sysinv/sysinv/sysinv/conductor/manager.py
View File

@ -5575,8 +5575,6 @@ class ConductorManager(service.PeriodicService):
classmap = {
constants.FILESYSTEM_NAME_BACKUP:
'platform::filesystem::backup::runtime',
constants.FILESYSTEM_NAME_IMG_CONVERSIONS:
'platform::filesystem::img_conversions::runtime',
constants.FILESYSTEM_NAME_SCRATCH:
'platform::filesystem::scratch::runtime',
constants.FILESYSTEM_NAME_DOCKER:
@ -5593,8 +5591,6 @@ class ConductorManager(service.PeriodicService):
'platform::drbd::patch_vault::runtime',
constants.FILESYSTEM_NAME_ETCD:
'platform::drbd::etcd::runtime',
constants.FILESYSTEM_NAME_GNOCCHI:
'platform::filesystem::gnocchi::runtime',
}
puppet_class = None
@ -5688,7 +5684,6 @@ class ConductorManager(service.PeriodicService):
classes = ['platform::partitions::runtime',
'platform::lvm::controller::runtime',
'platform::haproxy::runtime',
'platform::filesystem::img_conversions::runtime',
'platform::drbd::runtime',
'openstack::cinder::runtime',
'platform::sm::norestart::runtime']
@ -5796,7 +5791,6 @@ class ConductorManager(service.PeriodicService):
'platform::lvm::controller::runtime',
'platform::haproxy::runtime',
'openstack::keystone::endpoint::runtime',
'platform::filesystem::img_conversions::runtime',
'platform::ceph::runtime_base',
]
@ -5937,7 +5931,6 @@ class ConductorManager(service.PeriodicService):
'platform::lvm::controller::runtime',
'platform::haproxy::runtime',
'openstack::keystone::endpoint::runtime',
'platform::filesystem::img_conversions::runtime',
]
if constants.SB_SVC_GLANCE in services:
@ -6811,21 +6804,12 @@ class ConductorManager(service.PeriodicService):
# Add the extension storage
extension_lv_size = constants.DEFAULT_EXTENSION_STOR_SIZE
scratch_lv_size = cutils.get_controller_fs_scratch_size()
gnocchi_lv_size = constants.DEFAULT_GNOCCHI_STOR_SIZE
# Assume Non-region mode where glance is local as default
glance_local = True
img_conversions_lv_size = 0
system = self.dbapi.isystem_get_one()
system_dc_role = system.get('distributed_cloud_role', None)
region_config = system.capabilities.get('region_config', False)
kubernetes_config = system.capabilities.get('kubernetes_enabled', False)
LOG.info("Local Region Name: %s" % system.region_name)
# TODO: handle region mode case
if region_config:
glance_local = False
disk_size = cutils.get_disk_capacity_mib(rootfs_device)
disk_size = int(disk_size / 1024)
@ -6837,9 +6821,9 @@ class ConductorManager(service.PeriodicService):
# Defaults: 500G root disk
#
# Min size of the cgts-vg PV is:
# 218.0 G - PV for cgts-vg (specified in the kickstart)
# 202.0 G - PV for cgts-vg (specified in the kickstart)
# or
# 226.0 G - (for DCSC non-AIO)
# 210.0 G - (for DCSC non-AIO)
# 8 G - /var/log (reserved in kickstart)
# 8 G - /scratch (reserved in kickstart)
# 2 G - cgcs_lv (DRBD bootstrap manifest)
@ -6854,15 +6838,12 @@ class ConductorManager(service.PeriodicService):
# Final defaults view after controller manifests
# 8 G - /var/log (reserved in kickstart)
# 8 G - /scratch (reserved in kickstart)
# 10 G - /opt/cgcs
# 20 G - /opt/cgcs
# 40 G - /var/lib/postgresql
# 2 G - /var/lib/rabbitmq
# 2 G - /opt/platform
# 1 G - /opt/extension
# 20 G - /opt/img_conversions
# 50 G - /opt/backup
# 5 G - /opt/gnocchi
# 1 G - anchor_lv
# 30 G - /var/lib/docker (--kubernetes)
# 16 G - /var/lib/docker-distribution (--kubernetes)
# 5 G - /opt/etcd (--kubernetes)
@ -6870,17 +6851,17 @@ class ConductorManager(service.PeriodicService):
# 8 G - /opt/patch-vault (DRBD ctlr manifest for
# Distributed Cloud System Controller non-AIO only)
# -----
# 226 G (for DCSC non-AIO) or 218 G
# 210 G (for DCSC non-AIO) or 202
#
# The absolute minimum disk size for these default settings:
# 0.5 G - /boot
# 20.0 G - /
# 218.0 G - cgts-vg PV
# or 226.0 G - (DCSC non-AIO)
# 202.0 G - cgts-vg PV
# or 210.0 G - (DCSC non-AIO)
# -------
# 238.5 G => ~239G min size disk
# 222.5 G => ~223G min size disk
# or
# 246.5 G => ~247G min size disk
# 230.5 G => ~231G min size disk
#
# If required disk is size 500G:
# 1) Standard controller - will use all free space for the PV
@ -6891,20 +6872,12 @@ class ConductorManager(service.PeriodicService):
# 2) AIO - will leave unused space for further partitioning
# 0.5 G - /boot
# 20.0 G - /
# 218.0 G - cgts-vg PV
# 261.5 G - unpartitioned free space
# 202.0 G - cgts-vg PV
# 277.5 G - unpartitioned free space
#
database_storage = constants.DEFAULT_DATABASE_STOR_SIZE
if glance_local:
# When glance is local we need to set the
# img_conversion-lv size. Conversely in region
# mode conversions are done in the other region
# so there is no need to create the conversions
# volume or set lize.
img_conversions_lv_size = \
constants.DEFAULT_IMG_CONVERSION_STOR_SIZE
cgcs_lv_size = constants.DEFAULT_IMAGE_STOR_SIZE
cgcs_lv_size = constants.DEFAULT_CGCS_STOR_SIZE
backup_lv_size = database_storage + \
cgcs_lv_size + constants.BACKUP_OVERHEAD
@ -6915,9 +6888,9 @@ class ConductorManager(service.PeriodicService):
# Small disk: under 240G root disk
#
# Min size of the cgts-vg PV is:
# 178.0 G - PV for cgts-vg (specified in the kickstart)
# 170.0 G - PV for cgts-vg (specified in the kickstart)
# or
# 186.0 G - (for DCSC non-AIO)
# 162.0 G - (for DCSC non-AIO)
# 8 G - /var/log (reserved in kickstart)
# 8 G - /scratch (reserved in kickstart)
# 2 G - cgcs_lv (DRBD bootstrap manifest)
@ -6937,28 +6910,25 @@ class ConductorManager(service.PeriodicService):
# 2 G - /var/lib/rabbitmq
# 2 G - /opt/platform
# 1 G - /opt/extension
# 10 G - /opt/img_conversions
# 40 G - /opt/backup
# 5 G - /opt/gnocchi
# 1 G - anchor_lv
# 30 G - /var/lib/docker (--kubernetes)
# 16 G - /var/lib/docker-distribution (--kubernetes)
# 20 G - /var/lib/ceph/mon (--kubernetes)
# 5 G - /opt/etcd (--kubernetes)
# 8 G - /opt/patch-vault (DRBD ctlr manifest for DCSC non-AIO only)
# -----
# 186 G (for DCSC non-AIO) or 178 G
# 170 G (for DCSC non-AIO) or 162 G
#
# The absolute minimum disk size for these default settings:
# 0.5 G - /boot
# 20.0 G - /
# 178.0 G - cgts-vg PV
# 162.0 G - cgts-vg PV
# or
# 186.0 G - (for DCSC non-AIO)
# 170.0 G - (for DCSC non-AIO)
# -------
# 198.5 G => ~199G min size disk
# 182.5 G => ~183G min size disk
# or
# 206.5 G => ~207G min size disk
# 190.5 G => ~191G min size disk
#
# If required disk is size 240G:
# 1) Standard controller - will use all free space for the PV
@ -6968,16 +6938,13 @@ class ConductorManager(service.PeriodicService):
# 2) AIO - will leave unused space for further partitioning
# 0.5 G - /boot
# 20.0 G - /
# 178.0 G - cgts-vg PV
# 41.5 G - unpartitioned free space
# 162.0 G - cgts-vg PV
# 57.5 G - unpartitioned free space
#
database_storage = \
constants.DEFAULT_SMALL_DATABASE_STOR_SIZE
if glance_local:
img_conversions_lv_size = \
constants.DEFAULT_SMALL_IMG_CONVERSION_STOR_SIZE
cgcs_lv_size = constants.DEFAULT_SMALL_IMAGE_STOR_SIZE
cgcs_lv_size = constants.DEFAULT_SMALL_CGCS_STOR_SIZE
# Due to the small size of the disk we can't provide the
# proper amount of backup space which is (database + cgcs_lv
# + BACKUP_OVERHEAD) so we are using a smaller default.
@ -7030,29 +6997,6 @@ class ConductorManager(service.PeriodicService):
data['name'], data['logical_volume'], data['size']))
self.dbapi.controller_fs_create(data)
data = {
'name': constants.FILESYSTEM_NAME_GNOCCHI,
'size': gnocchi_lv_size,
'logical_volume': constants.FILESYSTEM_LV_DICT[
constants.FILESYSTEM_NAME_GNOCCHI],
'replicated': False,
}
LOG.info("Creating FS:%s:%s %d" % (
data['name'], data['logical_volume'], data['size']))
self.dbapi.controller_fs_create(data)
if glance_local:
data = {
'name': constants.FILESYSTEM_NAME_IMG_CONVERSIONS,
'size': img_conversions_lv_size,
'logical_volume': constants.FILESYSTEM_LV_DICT[
constants.FILESYSTEM_NAME_IMG_CONVERSIONS],
'replicated': False,
}
LOG.info("Creating FS:%s:%s %d" % (
data['name'], data['logical_volume'], data['size']))
self.dbapi.controller_fs_create(data)
data = {
'name': constants.FILESYSTEM_NAME_EXTENSION,
'size': extension_lv_size,
@ -7116,16 +7060,6 @@ class ConductorManager(service.PeriodicService):
data['name'], data['logical_volume'], data['size']))
self.dbapi.controller_fs_create(data)
if glance_local:
backends = self.dbapi.storage_backend_get_list()
for b in backends:
if b.backend == constants.SB_TYPE_FILE:
values = {
'services': constants.SB_SVC_GLANCE,
'state': constants.SB_STATE_CONFIGURED
}
self.dbapi.storage_backend_update(b.uuid, values)
else:
values = {
'services': constants.SB_SVC_GLANCE,
@ -9600,21 +9534,16 @@ class ConductorManager(service.PeriodicService):
def get_controllerfs_lv_sizes(self, context):
system = self.dbapi.isystem_get_one()
system_dc_role = system.get('distributed_cloud_role', None)
kubernetes_config = system.capabilities.get('kubernetes_enabled', False)
lvdisplay_command = 'lvdisplay --columns --options lv_size,lv_name ' \
'--units g --noheading --nosuffix ' \
'/dev/cgts-vg/pgsql-lv /dev/cgts-vg/backup-lv ' \
'/dev/cgts-vg/cgcs-lv ' \
'/dev/cgts-vg/img-conversions-lv ' \
'/dev/cgts-vg/scratch-lv ' \
'/dev/cgts-vg/extension-lv ' \
'/dev/cgts-vg/gnocchi-lv '
if kubernetes_config:
lvdisplay_command = lvdisplay_command + '/dev/cgts-vg/docker-lv '
lvdisplay_command = lvdisplay_command + '/dev/cgts-vg/etcd-lv '
lvdisplay_command = lvdisplay_command + '/dev/cgts-vg/dockerdistribution-lv '
'/dev/cgts-vg/docker-lv ' \
'/dev/cgts-vg/etcd-lv ' \
'/dev/cgts-vg/dockerdistribution-lv '
if (system_dc_role == constants.DISTRIBUTED_CLOUD_ROLE_SYSTEMCONTROLLER and
tsc.system_type != constants.TIS_AIO_BUILD):

10
sysinv/sysinv/sysinv/sysinv/db/api.py
View File

@ -2220,8 +2220,8 @@ class Connection(object):
:param values: A dict containing several items used to identify
and track the controller_fs.
Example:
values = {'name': constants.FILESYSTEM_NAME_IMG_CONVERSIONS,
'size': img_conversions_gib,
values = {'name': constants.DEFAULT_DOCKER_STOR_SIZE,
'size': 30,
'logical_volume': constants.FILESYSTEM_NAME_LV_DICT,
'replicated': False}
:returns: A controller_fs.
@ -2271,10 +2271,10 @@ class Connection(object):
:param controller_fs_id: The id or uuid of a controller_fs.
:param values: Dict of values to update. May be a partial list.
Example:
values = {'name': constants.FILESYSTEM_NAME_IMG_CONVERSIONS,
'size': img_conversions_gib,
values = {'name': constants.DEFAULT_DOCKER_STOR_SIZE,
'size': 30,
'logical_volume': constants.FILESYSTEM_LV_DICT[
constants.FILESYSTEM_NAME_IMG_CONVERSIONS],
constants.DEFAULT_DOCKER_STOR_SIZE],
'replicated': False}
:returns: A controller_fs.
"""

10
sysinv/sysinv/sysinv/sysinv/puppet/storage.py
View File

@ -54,11 +54,6 @@ class StoragePuppet(base.BasePuppet):
'platform::drbd::extension::params::lv_size':
controller_fs.size
})
elif controller_fs.name == constants.FILESYSTEM_NAME_IMG_CONVERSIONS:
config.update({
'platform::filesystem::img_conversions::params::lv_size':
controller_fs.size
})
elif controller_fs.name == constants.FILESYSTEM_NAME_PATCH_VAULT:
config.update({
'platform::drbd::patch_vault::params::service_enabled':
@ -81,11 +76,6 @@ class StoragePuppet(base.BasePuppet):
'platform::drbd::dockerdistribution::params::lv_size':
controller_fs.size
})
elif controller_fs.name == constants.FILESYSTEM_NAME_GNOCCHI:
config.update({
'platform::filesystem::gnocchi::params::lv_size':
controller_fs.size
})
return config

69
sysinv/sysinv/sysinv/sysinv/tests/api/test_storage_backends.py
View File

@ -329,8 +329,7 @@ class StorageBackendTestCases(base.FunctionalTest):
self.assertIn('WARNING : THIS OPERATION IS NOT REVERSIBLE AND CANNOT BE CANCELLED',
response.json['error_message'])
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
def test_post_lvm_without_svc_and_confirm(self, mock_img_conv):
def test_post_lvm_without_svc_and_confirm(self):
vals = {
'backend': constants.SB_TYPE_LVM,
'confirmed': True
@ -342,10 +341,9 @@ class StorageBackendTestCases(base.FunctionalTest):
self.assertIn('Service cinder is mandatory for the lvm backend.',
response.json['error_message'])
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._discover_and_validate_cinder_hiera_data')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._apply_backend_changes')
def test_post_lvm_with_valid_svc_all_svc_param_and_confirm(self, mock_apply, mock_validate, mock_img_conv):
def test_post_lvm_with_valid_svc_all_svc_param_and_confirm(self, mock_apply, mock_validate):
vals = {
'backend': constants.SB_TYPE_LVM,
'services': constants.SB_SVC_CINDER,
@ -406,10 +404,9 @@ class StorageBackendTestCases(base.FunctionalTest):
self.assertIn('Missing required cinder service parameter',
response.json['error_message'])
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._discover_and_validate_cinder_hiera_data')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._apply_backend_changes')
def test_post_lvm_and_remove_svc(self, mock_apply, mock_validate, mock_img_conv):
def test_post_lvm_and_remove_svc(self, mock_apply, mock_validate):
vals = {
'backend': constants.SB_TYPE_LVM,
'services': constants.SB_SVC_CINDER,
@ -431,13 +428,12 @@ class StorageBackendTestCases(base.FunctionalTest):
self.assertTrue(patch_response.json['error_message'])
self.assertIn('Removing cinder is not supported', patch_response.json['error_message'])
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._discover_and_validate_cinder_hiera_data')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._apply_backend_changes')
@mock.patch.object(SBApiHelper, 'set_backend_data',
side_effect=set_backend_state_configured)
def test_post_lvm_and_confirm_modify_with_invalid_svc(self, mock_set_backend_data, mock_apply,
mock_validate, mock_img_conv):
mock_validate):
vals = {
'backend': constants.SB_TYPE_LVM,
'services': constants.SB_SVC_CINDER,
@ -460,10 +456,9 @@ class StorageBackendTestCases(base.FunctionalTest):
self.assertTrue(patch_response.json['error_message'])
self.assertIn('Service glance is not supported', patch_response.json['error_message'])
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._discover_and_validate_cinder_hiera_data')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._apply_backend_changes')
def test_post_lvm_and_confirm_modify_with_no_changes(self, mock_apply, mock_validate, mock_img_conv):
def test_post_lvm_and_confirm_modify_with_no_changes(self, mock_apply, mock_validate):
vals = {
'backend': constants.SB_TYPE_LVM,
'services': constants.SB_SVC_CINDER,
@ -486,13 +481,12 @@ class StorageBackendTestCases(base.FunctionalTest):
self.assertIn('No changes to the existing backend settings were detected',
patch_response.json['error_message'])
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._discover_and_validate_cinder_hiera_data')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._apply_backend_changes')
@mock.patch.object(SBApiHelper, 'set_backend_data',
side_effect=set_backend_state_configured)
def test_post_lvm_and_confirm_modify_with_svc_with_params(self, mock_set_backend_data,
mock_apply, mock_validate, mock_img_conv):
mock_apply, mock_validate):
vals = {
'backend': constants.SB_TYPE_LVM,
'services': constants.SB_SVC_CINDER,
@ -518,10 +512,9 @@ class StorageBackendTestCases(base.FunctionalTest):
'test_cparam2': 'far2'}, # Expected
self.get_json('/storage_backend/%s/' % response.json['uuid'])['capabilities']) # Result
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._discover_and_validate_cinder_hiera_data')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._apply_backend_changes')
def test_post_lvm_and_list(self, mock_apply, mock_validate, mock_img_conv):
def test_post_lvm_and_list(self, mock_apply, mock_validate):
vals = {
'backend': constants.SB_TYPE_LVM,
'services': constants.SB_SVC_CINDER,
@ -569,8 +562,7 @@ class StorageBackendTestCases(base.FunctionalTest):
response.json['error_message'])
@mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses')
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
def test_post_ceph_and_confirm(self, mock_img_conv, mock_mon_ip):
def test_post_ceph_and_confirm(self, mock_mon_ip):
vals = {
'backend': constants.SB_TYPE_CEPH,
'capabilities': {'test_bparam3': 'foo'},
@ -636,10 +628,9 @@ class StorageBackendTestCases(base.FunctionalTest):
response.json['error_message'])
@mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses')
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
@mock.patch('sysinv.api.controllers.v1.storage_ceph._discover_and_validate_cinder_capabilities')
@mock.patch('sysinv.api.controllers.v1.storage_ceph._apply_backend_changes')
def test_post_ceph_with_valid_svc_all_svc_param_and_confirm(self, mock_apply, mock_validate, mock_img_conv, mock_mon_ip):
def test_post_ceph_with_valid_svc_all_svc_param_and_confirm(self, mock_apply, mock_validate, mock_mon_ip):
vals = {
'backend': constants.SB_TYPE_CEPH,
'services': (',').join([constants.SB_SVC_CINDER, constants.SB_SVC_GLANCE]),
@ -654,11 +645,10 @@ class StorageBackendTestCases(base.FunctionalTest):
self.get_json('/storage_backend/%s/' % response.json['uuid'])['backend']) # Result
@mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses')
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
@mock.patch.object(SBApiHelper, 'set_backend_data',
side_effect=set_backend_state_configured)
def test_post_ceph_and_confirm_modify_with_invalid_svc(self, mock_set_backend_data,
mock_img_conv, mock_mon_ip):
mock_mon_ip):
vals = {
'backend': constants.SB_TYPE_CEPH,
'capabilities': {'test_bparam3': 'foo'},
@ -680,14 +670,13 @@ class StorageBackendTestCases(base.FunctionalTest):
patch_response.json['error_message'])
@mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses')
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
@mock.patch('sysinv.api.controllers.v1.storage_ceph._discover_and_validate_cinder_capabilities')
@mock.patch('sysinv.api.controllers.v1.storage_ceph._apply_backend_changes')
@mock.patch.object(SBApiHelper, 'set_backend_data',
side_effect=set_backend_state_configured)
def test_post_ceph_and_confirm_modify_with_svc_missing_params(self, mock_set_backend_data,
mock_apply, mock_validate,
mock_img_conv, mock_mon_ip):
mock_mon_ip):
vals = {
'backend': constants.SB_TYPE_CEPH,
'capabilities': {'test_bparam3': 'foo'},
@ -709,13 +698,12 @@ class StorageBackendTestCases(base.FunctionalTest):
patch_response.json['error_message'])
@mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses')
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
@mock.patch('sysinv.api.controllers.v1.storage_ceph._discover_and_validate_cinder_capabilities')
@mock.patch('sysinv.api.controllers.v1.storage_ceph._apply_backend_changes')
@mock.patch.object(SBApiHelper, 'set_backend_data',
side_effect=set_backend_state_configured)
def test_post_ceph_and_confirm_modify_with_svc_missing_some_params(self, mock_set_backend_data, mock_apply,
mock_validate, mock_img_conv, mock_mon_ip):
mock_validate, mock_mon_ip):
vals = {
'backend': constants.SB_TYPE_CEPH,
'capabilities': {'test_bparam3': 'foo'},
@ -739,14 +727,13 @@ class StorageBackendTestCases(base.FunctionalTest):
patch_response.json['error_message'])
@mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses')
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
@mock.patch('sysinv.api.controllers.v1.storage_ceph._discover_and_validate_cinder_capabilities')
@mock.patch('sysinv.api.controllers.v1.storage_ceph._apply_backend_changes')
@mock.patch.object(SBApiHelper, 'set_backend_data',
side_effect=set_backend_state_configured)
def test_post_ceph_and_confirm_modify_with_svc_with_params(self, mock_set_backend_data,
mock_apply, mock_validate,
mock_img_conv, mock_mon_ip):
mock_mon_ip):
vals = {
'backend': constants.SB_TYPE_CEPH,
'capabilities': {'test_bparam3': 'foo'},
@ -774,8 +761,7 @@ class StorageBackendTestCases(base.FunctionalTest):
self.get_json('/storage_backend/%s/' % response.json['uuid'])['capabilities']) # Result
@mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses')
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
def test_post_ceph_and_list(self, mock_img_conv, mock_mon_ip):
def test_post_ceph_and_list(self, mock_mon_ip):
vals = {
'backend': constants.SB_TYPE_CEPH,
'capabilities': {'test_bparam3': 'foo'},
@ -1052,10 +1038,9 @@ class StorageLvmTestCases(base.FunctionalTest):
self.assertIn('WARNING : THIS OPERATION IS NOT REVERSIBLE AND CANNOT BE CANCELLED',
response.json['error_message'])
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._discover_and_validate_cinder_hiera_data')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._apply_backend_changes')
def test_post_and_confirm(self, mock_apply, mock_validate, mock_img_conv):
def test_post_and_confirm(self, mock_apply, mock_validate):
vals = {
'backend': constants.SB_TYPE_LVM,
'services': constants.SB_SVC_CINDER,
@ -1116,10 +1101,9 @@ class StorageLvmTestCases(base.FunctionalTest):
self.assertIn('Missing required cinder service parameter',
response.json['error_message'])
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._discover_and_validate_cinder_hiera_data')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._apply_backend_changes')
def test_post_with_valid_svc_all_svc_param_and_confirm(self, mock_apply, mock_validate, mock_img_conv):
def test_post_with_valid_svc_all_svc_param_and_confirm(self, mock_apply, mock_validate):
vals = {
'backend': constants.SB_TYPE_LVM,
'services': constants.SB_SVC_CINDER,
@ -1132,13 +1116,12 @@ class StorageLvmTestCases(base.FunctionalTest):
self.assertEqual(constants.SB_TYPE_LVM, # Expected
self.get_json('/storage_lvm/%s/' % response.json['uuid'])['backend']) # Result
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._discover_and_validate_cinder_hiera_data')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._apply_backend_changes')
@mock.patch.object(SBApiHelper, 'set_backend_data',
side_effect=set_backend_state_configured)
def test_post_and_confirm_modify_with_invalid_svc(self, mock_set_backend_data,
mock_apply, mock_validate, mock_img_conv):
mock_apply, mock_validate):
vals = {
'backend': constants.SB_TYPE_LVM,
'services': constants.SB_SVC_CINDER,
@ -1161,10 +1144,9 @@ class StorageLvmTestCases(base.FunctionalTest):
self.assertTrue(patch_response.json['error_message'])
self.assertIn('Service glance is not supported', patch_response.json['error_message'])
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._discover_and_validate_cinder_hiera_data')
@mock.patch('sysinv.api.controllers.v1.storage_lvm._apply_backend_changes')
def test_post_and_list(self, mock_apply, mock_validate, mock_img_conv):
def test_post_and_list(self, mock_apply, mock_validate):
vals = {
'backend': constants.SB_TYPE_LVM,
'services': constants.SB_SVC_CINDER,
@ -1212,8 +1194,7 @@ class StorageCephTestCases(base.FunctionalTest):
response.json['error_message'])
@mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses')
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
def test_post_and_confirm(self, mock_img_conv, mock_mon_ip):
def test_post_and_confirm(self, mock_mon_ip):
vals = {
'backend': constants.SB_TYPE_CEPH,
'capabilities': {'test_bparam3': 'foo'},
@ -1240,8 +1221,7 @@ class StorageCephTestCases(base.FunctionalTest):
response.json['error_message'])
@mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses')
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
def test_post_with_valid_svc_all_svc_param_and_confirm(self, mock_img_conv, mock_mon_ip):
def test_post_with_valid_svc_all_svc_param_and_confirm(self, mock_mon_ip):
vals = {
'backend': constants.SB_TYPE_CEPH,
'services': constants.SB_SVC_SWIFT,
@ -1255,10 +1235,9 @@ class StorageCephTestCases(base.FunctionalTest):
self.get_json('/storage_ceph/%s/' % response.json['uuid'])['backend']) # Result
@mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses')
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
@mock.patch.object(SBApiHelper, 'set_backend_data',
side_effect=set_backend_state_configured)
def test_post_and_confirm_modify_with_invalid_svc(self, mock_set_backend_data, mock_img_conv, mock_mon_ip):
def test_post_and_confirm_modify_with_invalid_svc(self, mock_set_backend_data, mock_mon_ip):
vals = {
'backend': constants.SB_TYPE_CEPH,
'capabilities': {'test_bparam3': 'foo'},
@ -1279,8 +1258,7 @@ class StorageCephTestCases(base.FunctionalTest):
self.assertIn('Service invalid_svc is not supported', patch_response.json['error_message'])
@mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses')
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
def test_post_and_confirm_modify_with_svc_with_params(self, mock_img_conv, mock_mon_ip):
def test_post_and_confirm_modify_with_svc_with_params(self, mock_mon_ip):
# Test skipped. Fix later.
self.skipTest("Skipping to prevent failure notification on Jenkins")
vals = {
@ -1306,8 +1284,7 @@ class StorageCephTestCases(base.FunctionalTest):
self.get_json('/storage_ceph/%s/' % response.json['uuid'])['capabilities']) # Result
@mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses')
@mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')
def test_post_and_list(self, mock_img_conv, mock_mon_ip):
def test_post_and_list(self, mock_mon_ip):
vals = {
'backend': constants.SB_TYPE_CEPH,
'capabilities': {'test_bparam3': 'foo'},

18
sysinv/sysinv/sysinv/sysinv/tests/api/test_storage_tier.py
View File

@ -639,9 +639,8 @@ class StorageTierDependentTCs(base.FunctionalTest):
'services': "%s,%s" % (constants.SB_SVC_CINDER, constants.SB_SVC_GLANCE),
'confirmed': True
}
with nested(mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses'),
mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')) as (
mock_ceph_mon, mock_conv):
with nested(mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses')) as (
mock_ceph_mon):
response = self.post_json('/storage_backend', values, expect_errors=False)
self.assertEqual(http_client.OK, response.status_int)
self.assertEqual('ceph', # Expected
@ -811,9 +810,8 @@ class StorageTierDependentTCs(base.FunctionalTest):
'capabilities': {'test_bparam3': 'foo'},
'confirmed': True
}
with nested(mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses'),
mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')) as (
mock_ceph_mon, mock_conv):
with nested(mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses')) as (
mock_ceph_mon):
response = self.post_json('/storage_ceph', values, expect_errors=True)
self.assertEqual(http_client.BAD_REQUEST, response.status_int)
self.assertEqual('application/json', response.content_type)
@ -830,9 +828,8 @@ class StorageTierDependentTCs(base.FunctionalTest):
'name': 'ceph-gold',
'confirmed': True
}
with nested(mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses'),
mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults')) as (
mock_ceph_mon, mock_conv):
with nested(mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses')) as (
mock_ceph_mon):
response = self.post_json('/storage_ceph', values, expect_errors=True)
self.assertEqual(http_client.BAD_REQUEST, response.status_int)
self.assertEqual('application/json', response.content_type)
@ -851,9 +848,8 @@ class StorageTierDependentTCs(base.FunctionalTest):
'confirmed': True
}
with nested(mock.patch.object(StorageBackendConfig, 'get_ceph_mon_ip_addresses'),
mock.patch.object(StorageBackendConfig, 'set_img_conversions_defaults'),
mock.patch.object(StorageBackendConfig, 'get_ceph_tier_size')) as (
mock_ceph_mon, mock_conv, mock_space):
mock_ceph_mon, mock_space):
mock_space.return_value = 0
response = self.post_json('/storage_ceph', values, expect_errors=True)

2
sysinv/sysinv/sysinv/sysinv/tests/db/sqlalchemy/test_migrations.py
View File

@ -1317,7 +1317,6 @@ class TestMigrations(BaseMigrationTestCase, WalkVersionsMixin):
storconfigs = db_utils.get_table(engine, 'i_storconfig')
storconfigs_col = {
'glance_backend': 'String', 'glance_gib': 'Integer',
'img_conversions_gib': 'String',
}
for col, coltype in storconfigs_col.items():
self.assertTrue(isinstance(storconfigs.c[col].type,
@ -1571,7 +1570,6 @@ class TestMigrations(BaseMigrationTestCase, WalkVersionsMixin):
'uuid': 'String',
'database_gib': 'Integer',
'cgcs_gib': 'Integer',
'img_conversions_gib': 'Integer',
'backup_gib': 'Integer',
'forisystemid': 'Integer',
}