def create_device(self, node, connected_nodes):
device = self.dmd.Devices.findDeviceByIdExact(node)
if device:
device.deleteDevice()
site = node.split("-", 1)[0]
gateways = ["{}-gw-a".format(site), "{}-gw-b".format(site)]
is_host = "host" in node
dc = self.dmd.Devices.createOrganizer("/Test/Layer2/Site-{}/{}".format(
site, "Host" if is_host else "Switch"))
dc.setZenProperty("zL2PotentialRootCause", False if is_host else True)
dc.setZenProperty("zL2Gateways", gateways)
device = dc.createInstance(node)
device.setPerformanceMonitor("localhost")
device.manageIp = self.ip(node)
from Products.ZenModel.IpInterface import IpInterface
mgmt_if_id = "mgmt"
device.os.interfaces._setObject(mgmt_if_id, IpInterface(mgmt_if_id))
mgmt_if = device.os.interfaces._getOb(mgmt_if_id)
mgmt_if.macaddress = self.mac_pair(node, None)[0]
mgmt_if.setIpAddresses(["{}/16".format(self.ip(node))])
mgmt_if.index_object()
notify(IndexingEvent(mgmt_if))
for connected_node in connected_nodes:
connecting_if_id = "to-{}".format(connected_node)
device.os.interfaces._setObject(connecting_if_id,
IpInterface(connecting_if_id))
local_mac, client_mac = self.mac_pair(node, connected_node)
connecting_if = device.os.interfaces._getOb(connecting_if_id)
connecting_if.macaddress = local_mac
if not is_host:
connecting_if.clientmacs = [client_mac]
connecting_if.setIpAddresses(["{}/16".format(self.ip(node))])
notify(IndexingEvent(connecting_if))
notify(IndexingEvent(device))
device.index_object()
return device
def testGetManageIpMultipleInterfaces(self):
"""
What should happen if multiple interfaces are available for a
service? What if you want to select an alternate one?
"""
# No interfaces defined
self.assertEquals(self.dev.getManageIp(), '')
self.assertEquals(self.ipsvc.getManageIp(), '')
# Have one IP address
tmpo = IpInterface('test')
self.dev.os.interfaces._setObject('test', tmpo)
self.iface = self.dev.getDeviceComponents()[1]
self.iface.addIpAddress('1.2.3.4')
self.dev.setManageIp('1.2.3.4/24')
self.ipsvc.ipaddresses = ['0.0.0.0']
self.assertEquals(self.dev.getManageIp(), '1.2.3.4/24')
self.assertEquals(self.ipsvc.getManageIp(), '1.2.3.4')
# Have two IP addresses
tmpo = IpInterface('test1')
self.dev.os.interfaces._setObject('test1', tmpo)
self.iface1 = self.dev.getDeviceComponents()[2]
self.iface1.addIpAddress('2.3.4.5')
self.dev.setManageIp('2.3.4.5/24')
self.assertEquals(self.dev.getManageIp(), '2.3.4.5/24')
self.assertEquals(self.ipsvc.getManageIp(), '2.3.4.5')
self.ipsvc.setManageIp('1.2.3.4/24')
self.assertEquals(self.ipsvc.getManageIp(), '1.2.3.4')
self.ipsvc.unsetManageIp()
self.assertEquals(self.ipsvc.getManageIp(), '2.3.4.5')
# Restrict the service to only one IP address
# Happens when a service restarts with new configuration
self.ipsvc.setManageIp('2.3.4.5/24')
self.assertEquals(self.ipsvc.getManageIp(), '2.3.4.5')
self.ipsvc.ipaddresses = ['1.2.3.4']
self.assertEquals(self.ipsvc.getManageIp(), '1.2.3.4')
# Remove an IP address from an interface
self.ipsvc.ipaddresses = ['0.0.0.0']
self.ipsvc.setManageIp('1.2.3.4/24')
self.assertEquals(self.ipsvc.getManageIp(), '1.2.3.4')
self.iface.setIpAddresses(['10.20.30.40/8'])
self.assertEquals(self.ipsvc.getManageIp(), '2.3.4.5')
def add_linux_interface_mac(device, interface_name, macaddress):
eth_if = IpInterface(interface_name)
device.os.interfaces._setObject(eth_if.id, eth_if)
eth_if = device.os.interfaces._getOb(eth_if.id)
eth_if.macaddress = macaddress
eth_if.index_object()
device.index_object()
def testSetManageIp(self):
tmpo = IpInterface('test')
self.dev.os.interfaces._setObject('test', tmpo)
self.iface = self.dev.getDeviceComponents()[1]
self.iface.addIpAddress('1.2.3.4')
# Explicitly set the manageIp at the device level
self.dev.setManageIp('1.2.3.4/24')
self.assertEquals(self.dev.getManageIp(), '1.2.3.4/24')
self.assertEquals(self.ipsvc.getManageIp(), '1.2.3.4')
self.dev.setManageIp('2.3.4.5/24')
self.assertEquals(self.ipsvc.getManageIp(), '2.3.4.5')
# Explicitly set the manageIp at the service level
self.ipsvc.ipaddresses = ['0.0.0.0']
self.ipsvc.setManageIp('1.2.3.4/24')
self.assertEquals(self.dev.getManageIp(), '2.3.4.5/24')
self.assertEquals(self.ipsvc.getManageIp(), '1.2.3.4')
# Unset the manageIp
self.ipsvc.unsetManageIp()
self.assertEquals(self.ipsvc.getManageIp(), '2.3.4.5')
# Set the manageIp with garbage
self.ipsvc.setManageIp('HelloWorld')
self.assertEquals(self.ipsvc.getManageIp(), '2.3.4.5')
def testSetManageIp(self):
testIp = '1.2.3.4'
self.dev.setManageIp(testIp)
self.assertEqual(self.dev.getManageIp(), testIp)
ip = self.dev.getNetworkRoot().findIp(testIp)
self.assert_(ip is not None)
self.dev.setManageIp(testIp)
# Need a network interface to register an IP in catalog
from Products.ZenModel.IpInterface import IpInterface
tmpIface = IpInterface('testNIC')
self.dev.os.interfaces._setObject('testNIC', tmpIface)
self.iface1 = self.dev.getDeviceComponents()[0]
self.iface1.addIpAddress('1.2.3.4')
# What about duplicates?
d = self.dmd.Devices.createInstance('localhost')
d.setManageIp()
self.assertTrue(d.getManageIp() in ('127.0.0.1', '::1'))
# Mask out the warning
log = logging.getLogger()
curLogLevel = log.getEffectiveLevel()
log.setLevel(logging.ERROR)
d.setManageIp(testIp)
log.setLevel(curLogLevel)
self.assertTrue(d.getManageIp() in ('127.0.0.1', '::1'))
def afterSetUp(self):
super(TestIpInterface, self).afterSetUp()
tmpo = IpInterface('test')
self.dev = self.dmd.Devices.createInstance('testdev')
self.dev.os.interfaces._setObject('test', tmpo)
self.iface = self.dev.getDeviceComponents()[0]
self.iface.interfaceName = 'test'
self.iface.macaddress = '00:00:00:00:00:00'
def afterSetUp(self):
super(TestIpAddress, self).afterSetUp()
self.dev = self.dmd.Devices.createInstance("testdev")
tmpIface = IpInterface('test')
self.dev.os.interfaces._setObject('test',tmpIface)
self.iface = self.dev.getDeviceComponents()[0]
self.iface.addIpAddress('1.2.3.4')
self.addr = self.iface.getIpAddressObj()
def add_interface(dev, macaddress='', clientmacs=[], vlans=None):
''' Add new interface to device '''
eth_id = random_id()
eth = IpInterface(eth_id, eth_id)
eth.macaddress = macaddress
eth.clientmacs = clientmacs
if vlans:
eth.vlans = vlans
dev.os.interfaces._setObject('unused_id_param', eth)
def test_Platform_Physical(self):
linux_dc = self.dmd.Devices.createOrganizer('/Server/Linux')
linux_server = linux_dc.createInstance('test-linux-host1')
from Products.ZenModel.IpInterface import IpInterface
linux_iface = add_contained(linux_server.os, 'interfaces',
IpInterface('eth0'))
linux_iface.macaddress = '00:0c:29:fe:ab:bc'
linux_iface.index_object()
from Products.ZenModel.HardDisk import HardDisk
linux_disk = add_contained(linux_server.hw, 'harddisks',
HardDisk('sda3'))
host1 = self.endpoint().getObjByPath('hosts/host1')
host1.address = '192.168.66.71'
pif1 = self.endpoint().getObjByPath('hosts/host1/pifs/pif1')
pif1.pif_device = linux_iface.id
pif1.macaddress = linux_iface.macaddress
pif1.index_object()
pbd1 = self.endpoint().getObjByPath('hosts/host1/pbds/pbd1')
pbd1.dc_device = '/dev/{}'.format(linux_disk.id)
host1_impacts, host1_impacted_by = impacts_for(host1)
pbd1_impacts, pbd1_impacted_by = impacts_for(pbd1)
pif1_impacts, pif1_impacted_by = impacts_for(pif1)
server_impacts, server_impacted_by = impacts_for(linux_server)
iface_impacts, iface_impacted_by = impacts_for(linux_iface)
disk_impacts, disk_impacted_by = impacts_for(linux_disk)
# Physical Server -> Host
self.assertTrue(linux_server.id in host1_impacted_by,
'missing impact: {} -> {}'.format(linux_server, host1))
self.assertTrue(host1.id in server_impacts,
'missing impact: {} <- {}'.format(host1, linux_server))
# Physical Server IpInterface -> PIF
self.assertTrue(linux_iface.id in pif1_impacted_by,
'missing impact: {} -> {}'.format(linux_iface, pif1))
self.assertTrue(pif1.id in iface_impacts,
'missing impact: {} <- {}'.format(pif1, linux_iface))
# Physical Server HardDisk -> PBD
self.assertTrue(linux_disk.id in pbd1_impacted_by,
'missing impact: {} -> {}'.format(linux_disk, pbd1))
self.assertTrue(pbd1.id in disk_impacts,
'missing impact: {} <- {}'.format(pbd1, linux_disk))
def test_Platform_Virtual(self):
linux_dc = self.dmd.Devices.createOrganizer('/Server/Linux')
linux_server = linux_dc.createInstance('test-linux-guest1')
from Products.ZenModel.IpInterface import IpInterface
linux_iface = add_contained(linux_server.os, 'interfaces',
IpInterface('eth0'))
linux_iface.macaddress = '00:0c:29:fe:ab:bc'
linux_iface.index_object()
from Products.ZenModel.HardDisk import HardDisk
linux_disk = add_contained(linux_server.hw, 'harddisks',
HardDisk('xvda'))
vm1 = self.endpoint().getObjByPath('vms/vm1')
vif1 = self.endpoint().getObjByPath('vms/vm1/vifs/vif1')
vif1.vif_device = linux_iface.id
vif1.macaddress = linux_iface.macaddress
vif1.index_object()
vbd1 = self.endpoint().getObjByPath('vms/vm1/vbds/vbd1')
vbd1.vbd_device = linux_disk.id
vm1_impacts, vm1_impacted_by = impacts_for(vm1)
vbd1_impacts, vbd1_impacted_by = impacts_for(vbd1)
vif1_impacts, vif1_impacted_by = impacts_for(vif1)
server_impacts, server_impacted_by = impacts_for(linux_server)
iface_impacts, iface_impacted_by = impacts_for(linux_iface)
disk_impacts, disk_impacted_by = impacts_for(linux_disk)
# VM -> Guest Device
self.assertTrue(vm1.id in server_impacted_by,
'missing impact: {} -> {}'.format(vm1, linux_server))
self.assertTrue(linux_server.id in vm1_impacts,
'missing impact: {} <- {}'.format(linux_server, vm1))
# PIF -> Guest IpInterface
self.assertTrue(vif1.id in iface_impacted_by,
'missing impact: {} -> {}'.format(vif1, linux_iface))
self.assertTrue(linux_iface.id in vif1_impacts,
'missing impact: {} <- {}'.format(linux_iface, vif1))
# PBD -> Guest HardDisk
self.assertTrue(vbd1.id in disk_impacted_by,
'missing impact: {} -> {}'.format(vbd1, linux_disk))
self.assertTrue(linux_disk.id in vbd1_impacts,
'missing impact: {} <- {}'.format(linux_disk, vbd1))
def afterSetUp(self):
super(TestIpRouteEntry, self).afterSetUp()
self.dev = self.dmd.Devices.createInstance('testdev')
tmpo = IpInterface('iface0')
self.dev.os.interfaces._setObject('iface0', tmpo)
self.iface0 = self.dev.os.interfaces._getOb('iface0')
self.iface0.setIpAddresses('1.2.3.4/24')
self.iface0.ifindex = 0
self.iface0.interfaceName = 'iface0'
tmpo = IpInterface('iface1')
self.dev.os.interfaces._setObject('iface1', tmpo)
self.iface1 = self.dev.os.interfaces._getOb('iface1')
self.iface1.setIpAddresses('2.3.4.5/24')
self.iface1.ifindex = 1
self.iface1.interfaceName = 'iface1'
tmpo = IpRouteEntry('rEntry')
self.dev.os.routes._setObject('rEntry', tmpo)
self.rEntry = self.dev.os.routes()[0]
def testGetIpAddresses(self):
# No interfaces defined
self.assertEquals(self.ipsvc.getNonLoopbackIpAddresses(), [])
# Have one IP address
tmpo = IpInterface('test')
self.dev.os.interfaces._setObject('test', tmpo)
self.iface = self.dev.getDeviceComponents()[1]
self.iface.addIpAddress('1.2.3.4')
self.dev.setManageIp('1.2.3.4/24')
self.assertEquals(self.ipsvc.getNonLoopbackIpAddresses(), ['1.2.3.4'])
# Have two IP addresses
tmpo = IpInterface('test1')
self.dev.os.interfaces._setObject('test1', tmpo)
self.iface1 = self.dev.getDeviceComponents()[2]
self.iface1.addIpAddress('2.3.4.5')
self.assertEquals(self.ipsvc.getNonLoopbackIpAddresses(),
['1.2.3.4', '2.3.4.5'])
self.assertEquals(
self.ipsvc.getNonLoopbackIpAddresses(showNetMask=True),
['1.2.3.4/24', '2.3.4.5/24'])
def testSetNextHopIp(self):
tempdev = self.dmd.Devices.createInstance('testdev2')
tmpo = IpInterface('test2')
tempdev.os.interfaces._setObject('test2', tmpo)
iface2 = tempdev.os.interfaces()[0]
iface2.setIpAddresses('3.4.5.6/24')
self.rEntry.setNextHopIp('3.4.5.6')
self.assert_(self.rEntry.getNextHopIp() == '3.4.5.6')
self.assertEqual(
self.rEntry.getNextHopIpLink(),
"<a href='/zport/dmd/Networks/3.4.5.0/ipaddresses/3.4.5.6'>3.4.5.6</a>"
)
self.assertEqual(self.rEntry.getNextHopDevice(), tempdev)
self.assertEqual(
self.rEntry.getNextHopDeviceLink(),
"<a href='/zport/dmd/Devices/devices/testdev2/'>testdev2</a>")
def testManage_createDeviceWithIpFromInterface(self):
# create device with ip that is on Interface of another device
testIp = '1.2.3.4'
dev1 = manage_createDevice(self.dmd,
'myfirstdevice',
'/',
manageIp='1.2.3.5')
# Need a network interface on that device
from Products.ZenModel.IpInterface import IpInterface
tmpIface = IpInterface('testNIC')
dev1.os.interfaces._setObject('testNIC', tmpIface)
iface = dev1.getDeviceComponents()[0]
iface.addIpAddress(testIp)
ip = dev1.getNetworkRoot().findIp(testIp)
self.assert_(ip is not None)
dev2 = manage_createDevice(self.dmd,
'myseconddevice',
'/',
manageIp=testIp)
self.assertNotEqual(dev1.manageIp, dev2.manageIp)
self.assert_(dev2 is not None)