def setUp(cls):
zope.component.testing.setUp(cls)
zope.component.provideAdapter(DefaultTraversable, (None, ))
zcml.load_config('testing-noevent.zcml', Products.ZenTestCase)
# Silly trickery here.
# We create a single TestCase, and share the environment that it creates
# across all our ZPLLayeredTestCase (which we have inheriting
# from unittest.TestCase instead)
if not cls.tc or cls.reset:
cls.tc = InitializerTestCase("test_nothing")
if isinstance(cls.tc_attributes, dict):
for k, v in cls.tc_attributes.iteritems():
setattr(cls.tc, k, v)
cls.tc.setUp()
cls.tc.dmd.REQUEST = None
if cls.yaml_doc:
cls.load_yaml()
try:
from Products.ZenTestCase.BaseTestCase import (
init_model_catalog_for_tests)
init_model_catalog_for_tests()
except ImportError:
pass
cls.mapper = ApplyDataMap()
def afterSetUp(self):
super(TestXen, self).afterSetUp()
self.adm = ApplyDataMap()
self.plugin = Xen()
self.device = self.dmd.Devices.createInstance('testDevice')
self.device.guestDevices = []
log.setLevel(logging.ERROR)
def setApplyDataMapToProxyComponent(self, datamap):
mapper = ApplyDataMap()
component = DeviceProxyComponent.component_for_proxy_device(self)
if not component:
LOG.error(
"Unable to apply datamap to proxy component for %s (component not found)"
% self)
else:
mapper._applyDataMap(component, datamap)
def afterSetUp(self):
"""Preparation invoked before each test is run."""
super(applyDataMapTests, self).afterSetUp()
self.service = ApplyDataMap()
self.deviceclass = self.dmd.Devices.createOrganizer("/Test")
self.device = self.deviceclass.createInstance("test-device")
self.device.setPerformanceMonitor("localhost")
self.device.setManageIp("192.0.2.77")
self.device.index_object()
transaction.commit()
def remote_applyDataMaps(self, device, datamaps):
device = self.getPerformanceMonitor().findDevice(device)
applicator = ApplyDataMap(self)
changed = False
for datamap in datamaps:
if applicator._applyDataMap(device, datamap):
changed = True
return changed
def setApplyDataMapToOpenStackInfrastructureHost(self, datamap):
mapper = ApplyDataMap()
component = DeviceProxyComponent.component_for_proxy_device(self)
if not component:
log.error(
"Unable to apply datamap to proxy component for %s (component not found)"
% self)
else:
mapper._applyDataMap(component, datamap)
def setUp(self):
super(TestModelOSIPAdmin, self).setUp()
self.applyDataMap = ApplyDataMap()._applyDataMap
if not self.device:
json_filename = os.path.dirname(
__file__) + "/data/model/osi_p_admin.json"
self.createDevice('testmodelOSIPAdmin',
json_filename=json_filename)
def create_device(dmd, device_id, data):
device = dmd.Devices.findDeviceByIdExact(device_id)
if not device:
deviceclass = dmd.Devices.createOrganizer(data.get("deviceClass", "/"))
deviceclass.setZenProperty("zPythonClass",
data.get("zPythonClass", ""))
device = deviceclass.createInstance(device_id)
adm = ApplyDataMap()._applyDataMap
map(lambda x: adm(device, x), data.get("dataMaps", []))
return device
def create_device(dmd, zPythonClass, device_id, datamaps):
device = dmd.Devices.findDeviceByIdExact(device_id)
if not device:
deviceclass = dmd.Devices.createOrganizer("/Server/SSH/Linux")
deviceclass.setZenProperty("zPythonClass", zPythonClass)
device = deviceclass.createInstance(device_id)
adm = ApplyDataMap()._applyDataMap
[adm(device, datamap) for datamap in datamaps]
return device
def remote_applyDataMaps(self, device, datamaps):
"""Patching command datasource to add partial remodeling"""
from Products.DataCollector.ApplyDataMap import ApplyDataMap
device = self.getPerformanceMonitor().findDevice(device)
applicator = ApplyDataMap(self)
changed = False
for datamap in datamaps:
if applicator._applyDataMap(device, datamap):
changed = True
return changed
def afterSetUp(self):
super(TestModeler, self).afterSetUp()
self.d = self.dmd.Devices.createInstance('zenoss.RabbitMQ.testDevice')
self.applyDataMap = ApplyDataMap()._applyDataMap
# Required to prevent erroring out when trying to define viewlets in
# ../browser/configure.zcml.
import zope.viewlet
zcml.load_config('meta.zcml', zope.viewlet)
import ZenPacks.zenoss.RabbitMQ
zcml.load_config('configure.zcml', ZenPacks.zenoss.RabbitMQ)
def remote_applyDataMaps(self, device, datamaps):
device_obj = self.getPerformanceMonitor().findDevice(device)
if device_obj is None:
log.warn("Device '%s' no longer exists. Discarding pending datamaps." % device)
return False
applicator = ApplyDataMap(self)
changed = False
for datamap in datamaps:
if applicator._applyDataMap(device_obj, datamap):
changed = True
return changed
def afterSetUp(self):
super(HBaseModelerPluginsTestCase, self).afterSetUp()
dc = self.dmd.Devices.createOrganizer('/Server')
self.d = dc.createInstance('hbase.testDevice')
self.d.dmd._p_jar = MockJar()
self.applyDataMap = ApplyDataMap()._applyDataMap
# Mock clear events function.
from Products.ZenModel.Device import Device
mock = lambda *args, **kwargs: None
Device.getClearEvents = mock
Device.setClearEvents = mock
def xmlrpc_applyDataMap(self,
devName,
datamap,
relname="",
compname="",
modname=""):
"""Apply a datamap passed as a list of dicts through XML-RPC.
"""
dev = self.dmd.findDevice(devName)
adm = ApplyDataMap()
adm.applyDataMap(dev,
datamap,
relname=relname,
compname=compname,
modname=modname)
def create_device(dmd, zPythonClass, device_id, datamaps):
deviceclass = dmd.Devices.createOrganizer("/Test")
deviceclass.setZenProperty("zPythonClass", zPythonClass)
device = deviceclass.createInstance(device_id)
device.setPerformanceMonitor("localhost")
device.setManageIp("127.1.2.3")
device.index_object()
notify(IndexingEvent(device))
adm = ApplyDataMap()._applyDataMap
[adm(device, datamap) for datamap in datamaps]
for component in device.getDeviceComponentsNoIndexGen():
component.index_object()
notify(IndexingEvent(component))
return device
def remote_applyDataMaps(self,
device,
maps,
devclass=None,
setLastCollection=False):
from Products.DataCollector.ApplyDataMap import ApplyDataMap
device = self.getPerformanceMonitor().findDeviceByIdExact(device)
adm = ApplyDataMap(self)
adm.setDeviceClass(device, devclass)
changed = False
#with pausedAndOptimizedIndexing():
for map in maps:
# make a copy because ApplyDataMap will modify the data map.
datamap = copy.deepcopy(map)
preadmdata = self.pre_adm_check(datamap, device)
start_time = time.time()
if adm._applyDataMap(device, datamap, commit=False):
changed = True
end_time = time.time() - start_time
changesubject = "device" if changed else "nothing"
if hasattr(datamap, "relname"):
log.debug(
"Time in _applyDataMap for Device %s with relmap %s objects: %.2f, %s changed.",
device.getId(), datamap.relname, end_time, changesubject)
elif hasattr(datamap, "modname"):
log.debug(
"Time in _applyDataMap for Device %s with objectmap, size of %d attrs: %.2f, %s changed.",
device.getId(), len(datamap.items()), end_time,
changesubject)
else:
log.debug(
"Time in _applyDataMap for Device %s: %.2f . Could not find if relmap or objmap, %s changed.",
device.getId(), end_time, changesubject)
self.post_adm_process(datamap, device, preadmdata)
if setLastCollection:
device.setSnmpLastCollection()
return changed
def remote_applyDataMaps(self, device, maps, devclass=None, setLastCollection=False):
from Products.DataCollector.ApplyDataMap import ApplyDataMap
device = self.getPerformanceMonitor().findDevice(device)
adm = ApplyDataMap(self)
adm.setDeviceClass(device, devclass)
def inner(map):
def action():
return bool(adm._applyDataMap(device, map))
return self._do_with_retries(action)
changed = False
for map in maps:
result = inner(map)
changed = changed or result
if setLastCollection:
self._setSnmpLastCollection(device)
return changed
def afterSetUp(self):
super(TestModel, self).afterSetUp()
dc = self.dmd.Devices.createOrganizer('/CloudStack')
dc.setZenProperty('zPythonClass', 'ZenPacks.zenoss.CloudStack.Cloud')
self.d = dc.createInstance('zenoss.CloudStack.testDevice')
if not ZVersion.VERSION.startswith('3.'):
self.d.dmd._p_jar = MockJar()
self.applyDataMap = ApplyDataMap()._applyDataMap
# Required to prevent erroring out when trying to define viewlets in
# ../browser/configure.zcml.
import zope.viewlet
zcml.load_config('meta.zcml', zope.viewlet)
import ZenPacks.zenoss.CloudStack
zcml.load_config('configure.zcml', ZenPacks.zenoss.CloudStack)
def afterSetUp(self):
# needed if this is run directly on the commandline,
# since otherwise it will be __main__, and ZPL's afterSetup
# will get confused.
self.__module__ = 'ZenPacks.zenoss.OpenStackInfrastructure.tests.test_impact'
super(TestEventMappings, self).afterSetUp()
# Quiet down some noisy logging.
# logging.getLogger('zen.OpenStackDeviceProxyComponent').setLevel(logging.ERROR)
self._loadEventsData()
self.adm = ApplyDataMap()
self.queue = ConsolidatingObjectMapQueue()
self.clock = 1000.0
def _now():
return self.clock
self.queue.now = _now
def remote_applyDataMaps(self,
device,
maps,
devclass=None,
setLastCollection=False):
from Products.DataCollector.ApplyDataMap import ApplyDataMap
device = self.getPerformanceMonitor().findDevice(device)
adm = ApplyDataMap(self)
adm.setDeviceClass(device, devclass)
def inner(map):
def action():
start_time = time.time()
completed = bool(adm._applyDataMap(device, map))
end_time = time.time() - start_time
if hasattr(map, "relname"):
log.debug(
"Time in _applyDataMap for Device %s with relmap %s objects: %.2f",
device.getId(), map.relname, end_time)
elif hasattr(map, "modname"):
log.debug(
"Time in _applyDataMap for Device %s with objectmap, size of %d attrs: %.2f",
device.getId(), len(map.items()), end_time)
else:
log.debug(
"Time in _applyDataMap for Device %s: %.2f . Could not find if relmap or objmap",
device.getId(), end_time)
return completed
return self._do_with_retries(action)
changed = False
for map in maps:
result = inner(map)
changed = changed or result
if setLastCollection:
self._setSnmpLastCollection(device)
return changed
def afterSetUp(self):
super(TestModel, self).afterSetUp()
# BaseTestCast.afterSetUp already hides transaction.commit. So we also
# need to hide transaction.abort.
self._transaction_abort = Transaction.abort
Transaction.abort = lambda *x: None
self.d = self.dmd.Devices.createInstance('zenoss.RabbitMQ.testDevice')
if not ZVersion.VERSION.startswith('3.'):
self.d.dmd._p_jar = MockJar()
self.applyDataMap = ApplyDataMap()._applyDataMap
# Required to prevent erroring out when trying to define viewlets in
# ../browser/configure.zcml.
import zope.viewlet
zcml.load_config('meta.zcml', zope.viewlet)
import ZenPacks.zenoss.RabbitMQ
zcml.load_config('configure.zcml', ZenPacks.zenoss.RabbitMQ)
def afterSetUp(self):
super(TestModel, self).afterSetUp()
dc = self.dmd.Devices.createOrganizer('/Devices/OpenStack')
dc.setZenProperty('zPythonClass', 'ZenPacks.zenoss.OpenStack.Endpoint')
dc.setZenProperty('zOpenStackAuthUrl', '')
dc.setZenProperty('zOpenstackComputeApiVersion', [])
dc.setZenProperty('zOpenStackProjectId', [])
dc.setZenProperty('zOpenStackInsecure', [])
dc.setZenProperty('zOpenStackRegionName', 'RegionOne')
self.d = dc.createInstance('zenoss.OpenStack.testDevice')
self.d.setPerformanceMonitor('localhost')
self.d.index_object()
notify(IndexingEvent(self.d))
self.applyDataMap = ApplyDataMap()._applyDataMap
zcml.load_config('configure.zcml', ZenPacks.zenoss.OpenStack)
self._loadModelData()
def run(self):
with open('model.yaml', 'r') as f:
self.model_config = yaml.load(f)
self.connect()
objmaps = []
for modname, obj_attrs in self.get_model_template("Global"):
objmaps.append(ObjectMap(modname=modname, data=obj_attrs))
for controller_num in range(1, self.options.controllers + 1):
for modname, obj_attrs in self.get_model_template("Controller"):
self.talesEvalAttrs(obj_attrs,
num=controller_num,
device_name=self.options.device)
objmaps.append(ObjectMap(modname=modname, data=obj_attrs))
for compute_num in range(1, self.options.computes + 1):
for modname, obj_attrs in self.get_model_template("Compute"):
self.talesEvalAttrs(obj_attrs,
num=compute_num,
device_name=self.options.device)
objmaps.append(ObjectMap(modname=modname, data=obj_attrs))
for tenant_num in range(3, self.options.tenants + 3):
for modname, obj_attrs in self.get_model_template("Tenant"):
self.talesEvalAttrs(obj_attrs,
num=tenant_num,
device_name=self.options.device)
objmaps.append(ObjectMap(modname=modname, data=obj_attrs))
compute_nums = range(1, self.options.computes + 1)
tenant_nums = range(3, self.options.tenants + 3)
for instance_num in range(1, self.options.instances + 1):
for modname, obj_attrs in self.get_model_template("Instance"):
tenant_num = tenant_nums[instance_num % self.options.tenants]
compute_num = compute_nums[instance_num %
self.options.computes]
self.talesEvalAttrs(obj_attrs,
num=instance_num,
device_name=self.options.device,
tenant_num=tenant_num,
compute_num=compute_num)
objmaps.append(ObjectMap(modname=modname, data=obj_attrs))
device = self.dmd.Devices.OpenStack.Infrastructure.findDevice(
self.options.device)
if not device:
print "Creating OpenStackInfrastructure device %s" % self.options.device
device = self.dmd.Devices.OpenStack.Infrastructure.createInstance(
self.options.device)
device.setPerformanceMonitor('localhost')
for controller_num in range(1, self.options.controllers + 1):
device_name = "%s_controller%d" % (self.options.device,
controller_num)
d = self.dmd.Devices.Server.SSH.Linux.NovaHost.findDevice(
device_name)
if not d:
print "Creating controller device %s" % device_name
d = self.dmd.Devices.Server.SSH.Linux.NovaHost.createInstance(
device_name)
d.setZenProperty('zIpServiceMapMaxPort', 32767)
for compute_num in range(1, self.options.computes + 1):
device_name = "%s_compute%d" % (self.options.device, compute_num)
d = self.dmd.Devices.Server.SSH.Linux.NovaHost.findDevice(
device_name)
if not d:
print "Creating compute device %s" % device_name
d = self.dmd.Devices.Server.SSH.Linux.NovaHost.createInstance(
device_name)
d.setZenProperty('zIpServiceMapMaxPort', 32767)
relmap = RelationshipMap(relname='components')
for objmap in objmaps:
relmap.append(objmap)
endpoint_om = ObjectMap(
modname='ZenPacks.zenoss.OpenStackInfrastructure.Endpoint',
data=dict(set_maintain_proxydevices=True))
print "Applying datamaps (1/2) (%d objects)" % len(objmaps)
adm = ApplyDataMap()
adm._applyDataMap(device, relmap)
adm._applyDataMap(device, endpoint_om)
print "Gathering network information"
l3_agent_ids = [
x.id for x in device.getDeviceComponents(
type="OpenStackInfrastructureNeutronAgent")
if x.type == 'L3 agent'
]
dhcp_agent_ids = [
x.id for x in device.getDeviceComponents(
type="OpenStackInfrastructureNeutronAgent")
if x.type == 'DHCP agent'
]
all_network_ids = [
x.id for x in device.getDeviceComponents(
type="OpenStackInfrastructureNetwork")
]
all_router_ids = [
x.id for x in device.getDeviceComponents(
type="OpenStackInfrastructureRouter")
]
all_subnet_ids = [
x.id for x in device.getDeviceComponents(
type="OpenStackInfrastructureSubnet")
]
instance_network_ids = [
x.id for x in device.getDeviceComponents(
type="OpenStackInfrastructureNetwork")
if x.ports() and len([y for y in x.ports() if y.instance()])
]
instance_subnet_ids = [
y.id for y in set(
chain.from_iterable([
x.subnets() for x in device.getDeviceComponents(
type="OpenStackInfrastructureNetwork") if x.ports()
and len([y for y in x.ports() if y.instance()])
]))
]
objmaps = []
print "Adding L3 Agent Relationships"
for agent_id in l3_agent_ids:
objmaps.append(
ObjectMap(
modname=
"ZenPacks.zenoss.OpenStackInfrastructure.NeutronAgent",
compname="components/%s" % agent_id,
data=dict(id=agent_id,
set_networks=all_network_ids,
set_routers=all_router_ids,
set_subnets=all_subnet_ids)))
print "Adding DHCP agent Relationships"
for agent_id in dhcp_agent_ids:
objmaps.append(
ObjectMap(
modname=
"ZenPacks.zenoss.OpenStackInfrastructure.NeutronAgent",
compname="components/%s" % agent_id,
data=dict(id=agent_id,
set_networks=instance_network_ids,
set_subnets=instance_subnet_ids)))
print "Adding instance <-> hypervisor relationship"
hypervisor_instances = defaultdict(list)
for instance_num in range(1, self.options.instances + 1):
instance_id = "server-%d" % instance_num
compute_num = compute_nums[instance_num % self.options.computes]
hypervisor_id = "hypervisor-compute%d.1" % compute_num
hypervisor_instances[hypervisor_id].append(instance_id)
for hypervisor_id, instance_ids in hypervisor_instances.iteritems():
objmaps.append(
ObjectMap(modname=
"ZenPacks.zenoss.OpenStackInfrastructure.Hypervisor",
compname="components/%s" % hypervisor_id,
data=dict(id=hypervisor_id,
set_instances=instance_ids)))
print "Applying datamaps (2/2) (%d objects)" % len(objmaps)
adm = ApplyDataMap()
for objmap in objmaps:
adm._applyDataMap(device, objmap)
print "Committing model changes."
transaction.commit()
def afterSetUp(self):
super(ApplyDataMapTest, self).afterSetUp()
self.adm = ApplyDataMap()
def afterSetUp(self):
super(TestCpuMap, self).afterSetUp()
self.adm = ApplyDataMap()
self.cmap = CpuMap()
self.device = self.dmd.Devices.createInstance('testDevice')
def afterSetUp(self):
super(TestModel, self).afterSetUp()
# Workaround for IMP-389:
# When Impact 5.2.1-5.2.3 (at least) are installed, setProdState
# is patched to re-index the object in the global catalog specifically
# on the productionState column, but at least on older verions of RM,
# the sandboxed version of global_catalog does not index that column,
# which causes setProdState to fail. Add the index for now, to
# work around this.
if (hasattr(self.dmd.global_catalog, 'indexes') and 'productionState'
not in self.dmd.global_catalog.indexes()):
from Products.ZenUtils.Search import makeCaseSensitiveFieldIndex
self.dmd.global_catalog.addIndex(
'productionState',
makeCaseSensitiveFieldIndex('productionState'))
self.dmd.global_catalog.addColumn('productionState')
# Patch to remove DNS dependencies
def getHostByName(name):
return MOCK_DNS.get(name)
def resolve_names(names):
result = {}
for name in names:
result[name] = MOCK_DNS.get(name)
return defer.maybeDeferred(lambda: result)
self._real_resolve_names = hostmap.resolve_names
hostmap.resolve_names = resolve_names
self._real_getHostByName = Device.getHostByName
Device.getHostByName = getHostByName
dc = self.dmd.Devices.createOrganizer(
'/Devices/OpenStack/Infrastructure')
dc.setZenProperty('zPythonClass',
'ZenPacks.zenoss.OpenStackInfrastructure.Endpoint')
dc.setZenProperty('zOpenStackHostDeviceClass',
'/Server/SSH/Linux/NovaHost')
dc.setZenProperty('zOpenStackRegionName', 'RegionOne')
dc.setZenProperty('zOpenStackAuthUrl', 'http://1.2.3.4:5000/v2.0')
dc.setZenProperty('zOpenStackNovaApiHosts', [])
dc.setZenProperty('zOpenStackExtraHosts', [])
dc.setZenProperty('zOpenStackHostMapToId', [])
dc.setZenProperty('zOpenStackHostMapSame', [])
dc.setZenProperty('zOpenStackHostLocalDomain', '')
dc.setZenProperty('zOpenStackExtraApiEndpoints', [])
self.d = dc.createInstance('zenoss.OpenStackInfrastructure.testDevice')
self.d.setPerformanceMonitor('localhost')
self.d.index_object()
notify(IndexingEvent(self.d))
self.applyDataMap = ApplyDataMap()._applyDataMap
# Required to prevent erroring out when trying to define viewlets in
# ../browser/configure.zcml.
import zope.viewlet
zcml.load_config('meta.zcml', zope.viewlet)
import ZenPacks.zenoss.OpenStackInfrastructure
zcml.load_config('configure.zcml',
ZenPacks.zenoss.OpenStackInfrastructure)
self._loadBadHosts()
self._loadZenossData()
def afterSetUp(self):
super(TestInterfaceAliasMap, self).afterSetUp()
self.adm = ApplyDataMap()
self.iamap = InterfaceAliasMap()
self.device = self.dmd.Devices.createInstance('testDevice')
