def setUp(self):
super(ManagerTestCase, self).setUp()
self.service = manager.ConductorManager('test-host', 'test-topic')
self.service.dbapi = dbapi.get_instance()
self.context = context.get_admin_context()
self.dbapi = dbapi.get_instance()
self.system = utils.create_test_isystem()
self.load = utils.create_test_load()
def setUp(self):
super(AppOperatorTestCase, self).setUp()
# Set up objects for testing
self.app_operator = kube_app.AppOperator(dbapi.get_instance())
self.context = context.get_admin_context()
self.dbapi = dbapi.get_instance()
self.temp_dir = self.useFixture(fixtures.TempDir())
def setUp(self):
super(StorageTierDependentTCs, self).setUp()
self.mock_set_crushmap = self.set_crushmap_patcher.start()
self.service = manager.ConductorManager('test-host', 'test-topic')
self.service.dbapi = dbapi.get_instance()
self.context = context.get_admin_context()
self.dbapi = dbapi.get_instance()
self.system = dbutils.create_test_isystem()
self.load = dbutils.create_test_load()
self.host_index = -1
self.mon_index = -1
def setUp(self):
super(UpdateCephCluster, self).setUp()
self.service = manager.ConductorManager('test-host', 'test-topic')
self.service.dbapi = dbapi.get_instance()
self.context = context.get_admin_context()
self.dbapi = dbapi.get_instance()
self.system = utils.create_test_isystem()
self.load = utils.create_test_load()
self.host_index = -1
self.mock_upgrade_downgrade_kube_components = self.upgrade_downgrade_kube_components_patcher.start(
)
def setUp(self):
super(AppOperatorTestCase, self).setUp()
# Manager holds apps_metadata dict
self.service = manager.ConductorManager('test-host', 'test-topic')
# Set up objects for testing
self.helm_operator = helm.HelmOperator(dbapi.get_instance())
self.app_operator = kube_app.AppOperator(dbapi.get_instance(),
self.helm_operator,
self.service.apps_metadata)
self.context = context.get_admin_context()
self.dbapi = dbapi.get_instance()
self.temp_dir = self.useFixture(fixtures.TempDir())
class Route(base.SysinvObject):
# VERSION 1.0: Initial version
VERSION = '1.0'
dbapi = db_api.get_instance()
fields = {
'id': int,
'uuid': utils.uuid_or_none,
'forihostid': utils.int_or_none,
'interface_uuid': utils.uuid_or_none,
'interface_id': int,
'ifname': utils.str_or_none,
'family': utils.str_or_none,
'network': utils.ip_str_or_none(),
'prefix': utils.int_or_none,
'gateway': utils.ip_str_or_none(),
'metric': utils.int_or_none,
}
_foreign_fields = {
'interface_uuid': 'interface:uuid',
'interface_id': 'interface:id',
'ifname': 'interface:ifname',
'forihostid': 'interface:forihostid'
}
@base.remotable_classmethod
def get_by_uuid(cls, context, uuid):
return cls.dbapi.route_get(uuid)
def save_changes(self, context, updates):
self.dbapi.route_update(
self.uuid, # pylint: disable=no-member
updates)
class Address(base.SysinvObject):
# VERSION 1.0: Initial version
VERSION = '1.0'
dbapi = db_api.get_instance()
fields = {
'id': int,
'uuid': utils.uuid_or_none,
'forihostid': utils.int_or_none,
'interface_uuid': utils.uuid_or_none,
'pool_uuid': utils.uuid_or_none,
'networktype': utils.str_or_none,
'ifname': utils.str_or_none,
'family': utils.int_or_none,
'address': utils.ip_str_or_none(),
'prefix': utils.int_or_none,
'enable_dad': utils.bool_or_none,
'name': utils.str_or_none,
}
_foreign_fields = {
'interface_uuid': 'interface:uuid',
'pool_uuid': 'address_pool:uuid',
'ifname': 'interface:ifname',
'forihostid': 'interface:forihostid',
'networktype': 'interface:networktype'
}
@base.remotable_classmethod
def get_by_uuid(cls, context, uuid):
return cls.dbapi.address_get(uuid)
def save_changes(self, context, updates):
self.dbapi.address_update(self.uuid, updates)
class StorageTier(base.SysinvObject):
# VERSION 1.0: Initial version
VERSION = '1.0'
dbapi = db_api.get_instance()
fields = {
'id': int,
'uuid': utils.str_or_none,
'name': utils.str_or_none,
'type': utils.str_or_none,
'status': utils.str_or_none,
'capabilities': utils.dict_or_none,
'forbackendid': utils.int_or_none,
'backend_uuid': utils.str_or_none,
'forclusterid': utils.int_or_none,
'cluster_uuid': utils.str_or_none,
'stors': list,
}
_foreign_fields = {
'backend_uuid': get_backend_uuid,
'cluster_uuid': get_cluster_uuid,
'stors': get_stor_ids
}
@base.remotable_classmethod
def get_by_uuid(cls, context, uuid):
return cls.dbapi.storage_tier_get(uuid)
def save_changes(self, context, updates):
self.dbapi.storage_tier_update(
self.uuid, # pylint: disable=no-member
updates)
class CPU(base.SysinvObject):
dbapi = db_api.get_instance()
fields = {
'id': int,
'uuid': utils.str_or_none,
'forihostid': int,
'ihost_uuid': utils.str_or_none,
'forinodeid': utils.int_or_none,
'inode_uuid': utils.str_or_none,
'numa_node': utils.int_or_none,
'cpu': int,
'core': utils.int_or_none,
'thread': utils.int_or_none,
'cpu_family': utils.str_or_none,
'cpu_model': utils.str_or_none,
'allocated_function': utils.str_or_none,
# 'coprocessors': utils.dict_or_none,
'capabilities': utils.dict_or_none,
}
_foreign_fields = {
'ihost_uuid': 'host:uuid',
'inode_uuid': 'node:uuid',
'numa_node': 'node:numa_node'
}
@base.remotable_classmethod
def get_by_uuid(cls, context, uuid):
return cls.dbapi.icpu_get(uuid)
def save_changes(self, context, updates):
self.dbapi.icpu_update(self.uuid, updates)
class Partition(base.SysinvObject):
dbapi = db_api.get_instance()
fields = {
'id': int,
'uuid': utils.str_or_none,
'start_mib': utils.int_or_none,
'end_mib': utils.int_or_none,
'size_mib': utils.int_or_none,
'device_path': utils.str_or_none,
'device_node': utils.str_or_none,
'type_guid': utils.str_or_none,
'type_name': utils.str_or_none,
'idisk_id': utils.int_or_none,
'foripvid': utils.int_or_none,
'forihostid': utils.int_or_none,
'status': int,
'capabilities': utils.dict_or_none,
'idisk_uuid': utils.str_or_none,
'ipv_uuid': utils.str_or_none,
'ihost_uuid': utils.str_or_none,
}
_foreign_fields = {'ihost_uuid': 'host:uuid', 'ipv_uuid': 'pv:uuid'}
@base.remotable_classmethod
def get_by_uuid(cls, context, uuid):
return cls.dbapi.partition_get(uuid)
def save_changes(self, context, updates):
self.dbapi.partition_update(self.uuid, updates)
class CephMon(base.SysinvObject):
dbapi = db_api.get_instance()
fields = {
'id': int,
'uuid': utils.uuid_or_none,
'device_path': utils.str_or_none,
'ceph_mon_gib': utils.int_or_none,
'state': utils.str_or_none,
'task': utils.str_or_none,
'forihostid': utils.int_or_none,
'ihost_uuid': utils.str_or_none,
'hostname': utils.str_or_none,
}
_foreign_fields = {
'hostname': 'host:hostname',
'ihost_uuid': 'host:uuid'
}
@base.remotable_classmethod
def get_by_uuid(cls, context, uuid):
return cls.dbapi.ceph_mon_get(uuid)
def save_changes(self, context, updates):
self.dbapi.ceph_mon_update(self.uuid, updates)
def create_test_helm_overrides(**kw):
helm_overrides = get_test_helm_overrides(**kw)
# Let DB generate ID if it isn't specified explicitly
if 'id' not in kw:
del helm_overrides['id']
dbapi = db_api.get_instance()
return dbapi.helm_override_create(helm_overrides)
def create_test_user(**kw):
user = get_test_user(**kw)
# Let DB generate ID if it isn't specified explicitly
if 'id' not in kw:
del user['id']
dbapi = db_api.get_instance()
return dbapi.iuser_create(user)
def setUp(self):
super(PTPTestCase, self).setUp()
self.dbapi = dbapi.get_instance()
self.system = dbutils.create_test_isystem()
self.load = dbutils.create_test_load()
self.controller = dbutils.create_test_ihost(
id='1',
uuid=None,
forisystemid=self.system.id,
hostname='controller-0',
personality=constants.CONTROLLER,
subfunctions=constants.CONTROLLER,
invprovision=constants.PROVISIONED,
)
self.worker = dbutils.create_test_ihost(
id='2',
uuid=None,
forisystemid=self.system.id,
hostname='worker-0',
personality=constants.WORKER,
subfunctions=constants.WORKER,
mgmt_mac='01:02.03.04.05.C0',
mgmt_ip='192.168.24.12',
invprovision=constants.PROVISIONED,
administrative=constants.ADMIN_LOCKED)
self.dbapi.ptp_create({})
self.ptp = self.dbapi.ptp_get_one()
self.ptp_uuid = self.ptp.uuid
class KubeApp(base.SysinvObject):
# VERSION 1.0: Initial version
VERSION = '1.0'
dbapi = db_api.get_instance()
fields = {
'id': int,
'name': utils.str_or_none,
'app_version': utils.str_or_none,
'manifest_name': utils.str_or_none,
'manifest_file': utils.str_or_none,
'status': utils.str_or_none,
'progress': utils.str_or_none,
'active': utils.bool_or_none,
'recovery_attempts': utils.int_or_zero,
}
@base.remotable_classmethod
def get_by_name(cls, context, name):
return cls.dbapi.kube_app_get(name)
@base.remotable_classmethod
def get_inactive_app_by_name_version(cls, context, name, version):
return cls.dbapi.kube_app_get_inactive_by_name_version(name, version)
def save_changes(self, context, updates):
self.dbapi.kube_app_update(
self.id, # pylint: disable=no-member
updates)
class InterfaceNetwork(base.SysinvObject):
VERSION = '1.0'
dbapi = db_api.get_instance()
fields = {
'id': int,
'uuid': utils.uuid_or_none,
'forihostid': utils.int_or_none,
'interface_id': utils.int_or_none,
'interface_uuid': utils.uuid_or_none,
'ifname': utils.str_or_none,
'network_id': utils.int_or_none,
'network_uuid': utils.uuid_or_none,
'network_name': utils.str_or_none,
'network_type': utils.str_or_none
}
_foreign_fields = {
'forihostid': 'interface:forihostid',
'interface_id': 'interface:id',
'interface_uuid': 'interface:uuid',
'ifname': 'interface:ifname',
'network_uuid': 'network:uuid',
'network_id': 'network:id',
'network_name': 'network:name',
'network_type': 'network:type'
}
@base.remotable_classmethod
def get_by_uuid(cls, context, uuid):
return cls.dbapi.interface_network_get(uuid)
class StorageCeph(storage_backend.StorageBackend):
dbapi = db_api.get_instance()
fields = dict(
{
'cinder_pool_gib': utils.int_or_none,
'glance_pool_gib': utils.int_or_none,
'ephemeral_pool_gib': utils.int_or_none,
'object_pool_gib': utils.int_or_none,
'kube_pool_gib': utils.int_or_none,
'object_gateway': utils.bool_or_none,
'tier_id': utils.int_or_none,
'tier_name': utils.str_or_none,
'tier_uuid': utils.str_or_none,
}, **storage_backend.StorageBackend.fields)
_foreign_fields = dict(
{
'tier_name': 'tier:name',
'tier_uuid': 'tier:uuid',
}, **storage_backend.StorageBackend._foreign_fields)
@base.remotable_classmethod
def get_by_uuid(cls, context, uuid):
return cls.dbapi.storage_ceph_get(uuid)
def save_changes(self, context, updates):
self.dbapi.storage_ceph_update(self.uuid, updates)
def create_test_ptp(**kw):
ptp = get_test_ptp(**kw)
# Let DB generate ID if it isn't specified explicitly
if 'id' not in kw:
del ptp['id']
dbapi = db_api.get_instance()
return dbapi.ptp_create(ptp)
class NTP(base.SysinvObject):
dbapi = db_api.get_instance()
fields = {
'id': int,
'uuid': utils.str_or_none,
'enabled': utils.bool_or_none,
'ntpservers': utils.str_or_none,
'forisystemid': utils.int_or_none,
'isystem_uuid': utils.str_or_none,
}
_foreign_fields = {
'isystem_uuid': 'system:uuid'
}
@base.remotable_classmethod
def get_by_uuid(cls, context, uuid):
return cls.dbapi.intp_get(uuid)
def save_changes(self, context, updates):
self.dbapi.intp_update(self.uuid, # pylint: disable=no-member
updates)
def create_test_drbd(**kw):
drbd = get_test_drbd(**kw)
# Let DB generate ID if it isn't specified explicitly
if 'id' not in kw:
del drbd['id']
dbapi = db_api.get_instance()
return dbapi.drbdconfig_create(drbd)
def setUp(self):
super(TestACL, self).setUp()
self.environ = {'fake.cache': utils.FakeMemcache()}
self.fake_node = db_utils.get_test_ihost()
self.dbapi = db_api.get_instance()
self.node_path = '/ihosts/%s' % self.fake_node['uuid']
def create_test_remotelogging(**kw):
dns = get_test_remotelogging(**kw)
# Let DB generate ID if it isn't specified explicitly
if 'id' not in kw:
del dns['id']
dbapi = db_api.get_instance()
return dbapi.remotelogging_create(dns)
class LLDPTLV(base.SysinvObject):
dbapi = db_api.get_instance()
fields = {
'id': int,
'agent_id': utils.int_or_none,
'agent_uuid': utils.str_or_none,
'neighbour_id': utils.int_or_none,
'neighbour_uuid': utils.str_or_none,
'type': utils.str_or_none,
'value': utils.str_or_none
}
_foreign_fields = {
'agent_uuid': 'lldp_agent:uuid',
'neighbour_uuid': 'lldp_neighbour:uuid',
}
@base.remotable_classmethod
def get_by_id(cls, context, id):
return cls.dbapi.lldp_tlv_get_by_id(id)
def save_changes(self, context, updates):
self.dbapi.lldp_tlv_update(self.id, updates)
class DataNetwork(base.SysinvObject):
VERSION = '1.0'
dbapi = db_api.get_instance()
fields = {'id': int,
'uuid': utils.uuid_or_none,
'network_type': utils.str_or_none,
'name': utils.str_or_none,
'description': utils.str_or_none,
'mtu': utils.int_or_none,
'multicast_group': utils.str_or_none,
'port_num': utils.int_or_none,
'ttl': utils.int_or_none,
'mode': utils.str_or_none,
}
_optional_fields = {'port_num',
'multicast_group',
'ttl',
'mode'}
@base.remotable_classmethod
def get_by_uuid(cls, context, uuid):
return cls.dbapi.datanetwork_get(uuid)
def save_changes(self, context, updates):
self.dbapi.datanetwork_update(self.uuid, updates)
class System(base.SysinvObject):
dbapi = db_api.get_instance()
fields = {
'id': int,
'uuid': utils.str_or_none,
'name': utils.str_or_none,
'system_type': utils.str_or_none,
'system_mode': utils.str_or_none,
'description': utils.str_or_none,
'capabilities': utils.dict_or_none,
'contact': utils.str_or_none,
'location': utils.str_or_none,
'latitude': utils.str_or_none,
'longitude': utils.str_or_none,
'services': utils.int_or_none,
'software_version': utils.str_or_none,
'timezone': utils.str_or_none,
'security_profile': utils.str_or_none,
'region_name': utils.str_or_none,
'service_project_name': utils.str_or_none,
'distributed_cloud_role': utils.str_or_none,
'security_feature': utils.str_or_none,
}
@base.remotable_classmethod
def get_by_uuid(cls, context, uuid):
return cls.dbapi.isystem_get(uuid)
def save_changes(self, context, updates):
self.dbapi.isystem_update(
self.uuid, # pylint: disable=no-member
updates)
def create_test_interface(**kw):
"""Create test interface entry in DB and return Interface DB object.
Function to be used to create test Interface objects in the database.
:param kw: kwargs with overriding values for interface's attributes.
:returns: Test Interface DB object.
"""
interface = get_test_interface(**kw)
datanetworks_list = interface.get('datanetworks') or []
# Let DB generate ID if it isn't specified explicitly
if 'id' not in kw:
del interface['id']
if 'datanetworks' in interface:
del interface['datanetworks']
dbapi = db_api.get_instance()
forihostid = kw.get('forihostid')
interface_obj = dbapi.iinterface_create(forihostid, interface)
# assign the interface to the datanetwork
for datanetwork in datanetworks_list:
if not datanetwork:
continue
dn = dbapi.datanetwork_get(datanetwork)
values = {'interface_id': interface_obj.id, 'datanetwork_id': dn.id}
dbapi.interface_datanetwork_create(values)
return interface_obj
class FPGADevice(base.SysinvObject):
dbapi = db_api.get_instance()
fields = {
'id': int,
'uuid': utils.str_or_none,
'host_id': utils.int_or_none,
'host_uuid': utils.str_or_none,
'pci_id': utils.int_or_none,
'pciaddr': utils.str_or_none,
'bmc_build_version': utils.str_or_none,
'bmc_fw_version': utils.str_or_none,
'root_key': utils.str_or_none,
'revoked_key_ids': utils.str_or_none,
'boot_page': utils.str_or_none,
'bitstream_id': utils.str_or_none,
}
_foreign_fields = {'host_uuid': 'host:uuid'}
@base.remotable_classmethod
def get_by_uuid(cls, context, uuid):
return cls.dbapi.fpga_device_get(uuid)
def save_changes(self, context, updates):
self.dbapi.fpga_device_update(
self.uuid, # pylint: disable=no-member
updates)
class TrapDest(base.SysinvObject):
dbapi = db_api.get_instance()
fields = {
'id': int,
'uuid': utils.str_or_none,
'ip_address': utils.str_or_none,
'community': utils.str_or_none,
'port': utils.int_or_none,
'type': utils.str_or_none,
'transport': utils.str_or_none,
}
@base.remotable_classmethod
def get_by_uuid(cls, context, uuid):
return cls.dbapi.itrapdest_get(uuid)
@base.remotable_classmethod
def get_by_ip(cls, context, ip):
return cls.dbapi.itrapdest_get_by_ip(ip)
def save_changes(self, context, updates):
self.dbapi.itrapdest_update(
self.uuid, # pylint: disable=no-member
updates)
class InterfaceBase(base.SysinvObject):
dbapi = db_api.get_instance()
fields = {
'id': int,
'uuid': utils.str_or_none,
'forihostid': utils.int_or_none,
'iftype': utils.str_or_none,
'ifname': utils.str_or_none,
'networktype': utils.str_or_none,
'ifcapabilities': utils.dict_or_none,
'farend': utils.dict_or_none,
'uses': utils.list_of_strings_or_none,
'used_by': utils.list_of_strings_or_none,
'sriov_numvfs': utils.int_or_none
}
_foreign_fields = {
'uses': _get_interface_name_list,
'used_by': _get_interface_name_list,
}
@base.remotable_classmethod
def get_by_uuid(cls, context, uuid):
return cls.dbapi.interface_get(uuid)
class LLDPNeighbour(base.SysinvObject):
dbapi = db_api.get_instance()
fields = {'id': int,
'uuid': utils.str_or_none,
'msap': utils.str_or_none,
'host_id': utils.int_or_none,
'host_uuid': utils.str_or_none,
'port_id': utils.int_or_none,
'port_uuid': utils.str_or_none,
'port_name': utils.str_or_none,
'port_namedisplay': utils.str_or_none}
_foreign_fields = {
'host_uuid': 'host:uuid',
'port_uuid': 'port:uuid',
'port_name': 'port:name',
'port_namedisplay': 'port:namedisplay',
}
for tlv in constants.LLDP_TLV_VALID_LIST:
fields.update({tlv: utils.str_or_none})
_foreign_fields.update({tlv: get_lldp_tlvs})
@base.remotable_classmethod
def get_by_uuid(cls, context, uuid):
return cls.dbapi.lldp_neighbour_get(uuid)
def save_changes(self, context, updates):
self.dbapi.lldp_neighbour_update(self.uuid, # pylint: disable=no-member
updates)
