def install(self, dmd):
ZenPackBase.install(self, dmd)
#
# To create an organizer when the ZenPack is installed, uncomment the next few lines
#
dc = dmd.Devices.createOrganizer('/Example/TestClass')
dc.setZenProperty('zCollectorPlugins',
('zenoss.snmp.NewDeviceMap',
'zenoss.snmp.DeviceMap',
'zenoss.snmp.InterfaceMap',
'zenoss.snmp.RouteMap',
'community.snmp.ExampleSNMP',
'community.snmp.ExampleHostResourcesSNMP',
'community.cmd.ExampleCMD',))
# If we want to use a Command modeler plugin, then cmd userid and password need to be setup
dc.setZenProperty('zCommandUsername', 'mollie')
dc.setZenProperty('zCommandPassword', 'fiddle')
#
# Ensure that properties for this organizer class will be of device object class ExampleDevice
#
dc.setZenProperty('zPythonClass', 'ZenPacks.community.MenuExamples.ExampleDevice')
#
#Create an instance of this device class, checking first whether such a an instance exists
if dc.devices._getOb('ExampleDevice1', None): return
myInst = dc.createInstance('ExampleDevice1')
myInst.setPerformanceMonitor('localhost')
def install(self, dmd):
if yaml_installed():
ZenPackBase.install(self, dmd)
self.check_permissions()
self.create_symlink()
else:
sys.exit(1)
def install(self, dmd):
ZenPackBase.install(self, dmd)
#
# To create an organizer when the ZenPack is installed, uncomment the next few lines
#
dc = dmd.Devices.createOrganizer('/Example/TestClass')
dc.setZenProperty('zCollectorPlugins', (
'zenoss.snmp.NewDeviceMap',
'zenoss.snmp.DeviceMap',
'zenoss.snmp.InterfaceMap',
'zenoss.snmp.RouteMap',
'community.snmp.ExampleSNMP',
'community.snmp.ExampleHostResourcesSNMP',
'community.cmd.ExampleCMD',
))
# If we want to use a Command modeler plugin, then cmd userid and password need to be setup
dc.setZenProperty('zCommandUsername', 'mollie')
dc.setZenProperty('zCommandPassword', 'fiddle')
#
# Ensure that properties for this organizer class will be of device object class ExampleDevice
#
dc.setZenProperty('zPythonClass',
'ZenPacks.skills1st.MenuExamples.ExampleDevice')
#
#Create an instance of this device class, checking first whether such a an instance exists
if dc.devices._getOb('ExampleDevice1', None): return
myInst = dc.createInstance('ExampleDevice1')
myInst.setPerformanceMonitor('localhost')
def testConfigMap(self):
tag = 'myZenpack'
fileDict = {
"service.json": {
'servicePath': '/',
'serviceDefinition': {
'Name': "Svc",
'Id': 'svc',
'ConfigFiles': {
'/opt/zenoss/etc/service.conf': {},
'/opt/zenoss/etc/other.conf': {}
}
}
},
}
configMap = {
'/opt/zenoss/etc/service.conf': "foobar",
'/opt/zenoss/etc/other.conf': "boofar"
}
context = _MockServiceMigrationContext()
client = _MockControlPlaneClient(services=_services)
with setControlPlaneClient(client), setCurrentService(
'zope'), setServiceMigrationContext(context):
z = ZenPack('id')
z._loadServiceDefinition = createMockLoadServiceDefinitions(
fileDict)
z.installServicesFromFiles(fileDict.keys(), [configMap], tag)
self.assertEquals(len(fileDict), len(context.added))
for i, j in ((i[0], json.loads(i[1])) for i in context.added):
for key, val in configMap.iteritems():
self.assertEquals(j['ConfigFiles'][key]['Content'], val)
def install(self, dmd):
ZenPackBase.install(self, dmd)
#
# To create an organizer when the ZenPack is installed, uncomment the next few lines
#
dc = dmd.Devices.createOrganizer("/Example/TestClass")
dc.setZenProperty(
"zCollectorPlugins",
(
"zenoss.snmp.NewDeviceMap",
"zenoss.snmp.DeviceMap",
"zenoss.snmp.InterfaceMap",
"zenoss.snmp.RouteMap",
"community.snmp.ExampleSNMP",
"community.snmp.ExampleHostResourcesSNMP",
"community.cmd.ExampleCMD",
),
)
# If we want to use a Command modeler plugin, then cmd userid and password need to be setup
dc.setZenProperty("zCommandUsername", "mollie")
dc.setZenProperty("zCommandPassword", "fiddle")
#
# Ensure that properties for this organizer class will be of device object class ExampleDevice
#
dc.setZenProperty("zPythonClass", "ZenPacks.skills1st.MenuExamples.ExampleDevice")
#
# Create an instance of this device class, checking first whether sucha an instance exists
if dc.devices._getOb("ExampleDevice1", None):
return
myInst = dc.createInstance("ExampleDevice1")
myInst.setPerformanceMonitor("localhost")
def testNormalizeServiceLogConfigs(self):
sampleLogConfig = {
'filters': ['supervisord'],
'path': '/opt/zenoss/log/Z2.log',
'type': 'pythondaemon'
}
auditLogConfig = {
'filters': ['supervisord'],
'path': '/opt/zenoss/log/audit.log',
'type': 'zenossaudit'
}
tests = ({}, {
'LogConfigs': []
}, {
'LogConfigs': [auditLogConfig]
}, {
'LogConfigs': [sampleLogConfig]
}, {
'LogConfigs': [sampleLogConfig, auditLogConfig]
}, {
'LogConfigs': [auditLogConfig, sampleLogConfig]
})
for service in tests:
inputLength = len(service.get('LogConfigs', []))
if auditLogConfig in service.get('LogConfigs', []):
LogConfigs = ZenPack.normalizeService(service, {},
'')['LogConfigs']
self.assertEquals(len(LogConfigs), inputLength)
else:
LogConfigs = ZenPack.normalizeService(service, {},
'')['LogConfigs']
self.assertEquals(len(LogConfigs), inputLength + 1)
self.assertIn(auditLogConfig, LogConfigs)
def remove(self, dmd, leaveObjects=False):
if not leaveObjects:
# When a ZenPack is removed the remove method will be called with
# leaveObjects set to False. This means that you likely want to
# make sure that leaveObjects is set to false before executing
# your custom removal code.
pass
ZenPackBase.remove(self, dmd, leaveObjects=leaveObjects)
def remove(self, app, leaveObjects=False):
#self.saveComponents(app)
removeAllComponents(app, self.definitions)
ZenPackBase.remove(self, app, leaveObjects)
d = self.definitions[0]
zenpackname = "%s.%s" % (d.zenpackroot, d.zenpackbase)
removeRels(app, zenpackname)
removeRelations(self.definitions)
self.updateRelations(app)
def install(self, app):
for c in self.constructs: c.buildZenPackFiles()
ZenPackBase.install(self, app)
self.updateRelations(app)
if self.shouldLoad() is True:
log.info("loading components")
try: self.loadComponents(app)
except: log.warn("problem loading components")
else: log.info("not loading components")
def remove(self, app, leaveObjects=False):
if not leaveObjects:
Device._relations = tuple(
[x for x in Device._relations if x[0] != 'openvz_containers'])
self.rebuildRelations(app.zport.dmd)
self.remove_modeler_plugins(app.zport.dmd)
ZenPackBase.remove(self, app, leaveObjects=leaveObjects)
def install(self, dmd):
ZenPackBase.install(self, dmd)
torque = dmd.Devices.createOrganizer('/Server/SSH/Linux/Torque')
# add our modeler
collectors = torque.getProperty('zCollectorPlugins') or []
torque.setZenProperty('zCollectorPlugins',
collectors+['CERIT_SC.cmd.pbsnodes'])
for device in self.dmd.Devices.getSubDevices():
ddevice.buildRelations()
def remove(self, dmd, leaveObjects=False):
if not leaveObjects:
# Delete all instances of devices in /Storage/IBMV7000 - completely - including history and events
#
for dev in dmd.Devices.Storage.IBMV7000.getSubDevices():
dev.deleteDevice(deleteStatus=True, deleteHistory=True, deletePerf=True)
# Next line delete all subclasses too
dmd.Devices.manage_deleteOrganizer('/Storage/IBMV7000')
ZenPackBase.remove(self, dmd, leaveObjects=leaveObjects)
def remove(self, app, leaveObjects=False):
''''''
if self.shouldSave() is True:
log.info("saving components")
try: self.saveComponents(app)
except: log.warn("problem saving components")
else: log.info("not saving components")
ZenPackBase.remove(self, app, leaveObjects)
removeAllComponents(app, self.definitions)
d = self.definitions[0]
zenpackname = "%s.%s" % (d.zenpackroot, d.zenpackbase)
removeRels(app, zenpackname)
removeRelations(self.definitions)
self.updateRelations(app)
def remove(self, app, leaveObjects=False):
if not leaveObjects:
self.removeZProperties(self.dmd.getPhysicalRoot())
if self.dmd.Devices.Server.Windows.hasProperty('zWinEventlog'):
self.dmd.Devices.Server.Windows.deleteZenProperty(
'zWinEventlog')
if self.dmd.Devices.Server.Windows.hasProperty(
'zWmiMonitorIgnore'):
self.dmd.Devices.Server.Windows.deleteZenProperty(
'zWmiMonitorIgnore')
if self.dmd.Devices.Discovered.hasProperty('zWmiMonitorIgnore'):
self.dmd.Devices.Discovered.deleteZenProperty(
'zWmiMonitorIgnore')
_removePluginsFromDiscovered(self.dmd)
ZenPackBase.remove(self, app, leaveObjects)
def remove(self, dmd, leaveObjects=False):
if not leaveObjects:
# Delete all instances of devices in /Storage/IBMV7000 - completely - including history and events
#
for dev in dmd.Devices.Storage.IBMV7000.getSubDevices():
dev.deleteDevice(deleteStatus=True,
deleteHistory=True,
deletePerf=True)
# Next line delete all subclasses too
dmd.Devices.manage_deleteOrganizer('/Storage/IBMV7000')
ZenPackBase.remove(self, dmd, leaveObjects=leaveObjects)
def install(self, app):
self._removePreviousZenPacks(self.dmd)
ZenPackBase.install(self, app)
_addPluginsToDiscovered(self.dmd)
self.createZProperties(self.dmd.getPhysicalRoot())
if not self.dmd.Devices.Discovered.hasProperty('zWmiMonitorIgnore'):
self.dmd.Devices.Discovered.setZenProperty('zWmiMonitorIgnore',
False)
if not self.dmd.Devices.Server.Windows.hasProperty(
'zWmiMonitorIgnore'):
self.dmd.Devices.Server.Windows.setZenProperty(
'zWmiMonitorIgnore', False)
if not self.dmd.Devices.Server.Windows.hasProperty('zWinEventlog'):
self.dmd.Devices.Server.Windows.setZenProperty(
'zWinEventlog', True)
def testRemoveNoCurrentServiceId(self):
moduleName = "Zenpacks.zenoss.Test"
services = _services + [_MockService('me', 'hub1', [moduleName])]
client = _MockControlPlaneClient(services=services)
with setControlPlaneClient(client):
ZenPack("id").removeServices(moduleName)
self.assertEquals(client.deleted, [])
def testInstallFromFiles(self):
tag = 'myZenpack'
E_KEY = 'expectedParentId' # for this test only - associates path with service
P_KEY = 'servicePath' # key defining path at which to install service
D_KEY = 'serviceDefinition' # key defining service to be installed
I_KEY = 'Id' # key defining ID
N_KEY = 'Name' # key defining Name
# Mock the filesystem - maps path->json file contents
fileDict = dict(
a={
P_KEY: '/',
D_KEY: {
E_KEY: 'zenoss',
I_KEY: 'a',
N_KEY: 'A'
}
},
b={
P_KEY: '/hub',
D_KEY: {
E_KEY: 'hub1',
I_KEY: 'b',
N_KEY: 'B'
}
},
c={
P_KEY: '/hub',
D_KEY: {
E_KEY: 'hub1',
I_KEY: 'c',
N_KEY: 'C'
}
},
)
context = _MockServiceMigrationContext()
client = _MockControlPlaneClient(services=_services)
with setControlPlaneClient(client), setCurrentService(
'zope'), setServiceMigrationContext(context):
z = ZenPack('id')
z._loadServiceDefinition = createMockLoadServiceDefinitions(
fileDict)
z.installServicesFromFiles(fileDict.keys(),
[{}] * len(fileDict.keys()), tag)
self.assertEquals(len(fileDict), len(context.added))
for i, j in ((i[0], json.loads(i[1])) for i in context.added):
self.assertEquals(i, j[E_KEY])
def testAddNoCurrentServiceId(self):
context = _MockServiceMigrationContext()
client = _MockControlPlaneClient(services=_services)
service = json.dumps(_MockService('id'), cls=_MockServiceEncoder)
with setControlPlaneClient(client), setServiceMigrationContext(
context):
ZenPack("id").installServiceDefinitions(service, "/hub")
self.assertEquals(context.added, [])
def testNormalizeServiceImage(self):
try:
image = 'foobar'
os.environ['SERVICED_SERVICE_IMAGE'] = image
tests = (({'ImageID': ''}, image), ({'ImageID': 'xxx'}, 'xxx'))
for service, expected in tests:
actual = ZenPack.normalizeService(service, {}, '')['ImageID']
self.assertEquals(actual, expected)
finally:
del os.environ['SERVICED_SERVICE_IMAGE']
def remove(self, dmd, leaveObjects=False):
if not leaveObjects:
# When a ZenPack is removed the remove method will be called with
# leaveObjects set to False. This means that you likely want to
# make sure that leaveObjects is set to false before executing
# your custom removal code.
#
# Delete all instances of devices in /Example/TestClass - completely - including history and events
#
for dev in dmd.Devices.Example.TestClass.getSubDevices():
dev.deleteDevice(deleteStatus=True, deleteHistory=True, deletePerf=True)
#
# Now delete the device class organizer hierarchy we created
#
# Next line delete all subclasses too
#
dmd.Devices.manage_deleteOrganizer("/Devices/Example")
ZenPackBase.remove(self, dmd, leaveObjects=leaveObjects)
def install(self, packName):
zp = None
# We wrap our try in a try to abort our tansaction, but make sure we
# unpause applyDataMap functionality
try:
try:
# hide uncatalog error messages since they do not do any harm
log = logging.getLogger('Zope.ZCatalog')
oldLevel = log.getEffectiveLevel()
log.setLevel(HIGHER_THAN_CRITICAL)
zp = self.dmd.ZenPackManager.packs._getOb(packName)
self.log.info('Upgrading %s', packName)
self.dmd.startPauseADM()
zp.upgrade(self.app)
except AttributeError:
try:
module = __import__('Products.' + packName, globals(), {}, [''])
zp = module.ZenPack(packName)
except (ImportError, AttributeError) as ex:
self.log.debug(
"Unable to find custom ZenPack (%s), defaulting to generic ZenPack", ex
)
zp = ZenPack(packName)
self.dmd.ZenPackManager.packs._setObject(packName, zp)
zp = self.dmd.ZenPackManager.packs._getOb(packName)
zp.install(self.app)
finally:
log.setLevel(oldLevel)
if zp:
for required in zp.requires:
try:
self.dmd.ZenPackManager.packs._getOb(required)
except Exception:
self.log.error(
"Pack %s requires pack %s: not installing",
packName, required
)
return
except Exception:
transaction.abort()
finally:
self.dmd.stopPauseADM()
def testStopServices(self):
tag = 'MyZenPack'
services = _services + [
_MockService('alpha', 'zenoss', [tag]),
_MockService('beta', 'hub1', [tag]),
]
expected = ['alpha', 'beta']
client = _MockControlPlaneClient(services=services)
with setControlPlaneClient(client), setCurrentService('zope'):
ZenPack("id").doServiceAction(tag, 'stop')
self.assertEquals(sorted(client.stopped), sorted(expected))
def testAddSingleService(self):
client = _MockControlPlaneClient(services=_services)
service = _MockService('id', 'pid')
service.poolId = 'not_default'
service = json.dumps(service, cls=_MockServiceEncoder)
with setControlPlaneClient(client), setCurrentService('zope'):
ZenPack("id").installServiceDefinitions(service, "/hub")
self.assertEquals(len(client.added), 1)
parent, added = client.added[0][0], json.loads(client.added[0][1])
self.assertEquals(added['Id'], 'id')
self.assertEquals(parent, 'hub1')
def testRemoveServices(self):
tag = 'MyZenPack'
services = _services + [
_MockService('alpha', 'zenoss', [tag]),
_MockService('beta', 'hub1', [tag]),
]
expected = ['alpha', 'beta']
client = _MockControlPlaneClient(services=services)
with setControlPlaneClient(client), setCurrentService('zope'):
ZenPack("id").removeServices(tag)
self.assertEquals(sorted(client.deleted), sorted(expected))
def remove(self, dmd, leaveObjects=False):
if not leaveObjects:
# When a ZenPack is removed the remove method will be called with
# leaveObjects set to False. This means that you likely want to
# make sure that leaveObjects is set to false before executing
# your custom removal code.
#
# Delete all instances of devices in /Example/TestClass - completely - including history and events
#
for dev in dmd.Devices.Example.TestClass.getSubDevices():
dev.deleteDevice(deleteStatus=True,
deleteHistory=True,
deletePerf=True)
#
# Now delete the device class organizer hierarchy we created
#
# Next line delete all subclasses too
#
dmd.Devices.manage_deleteOrganizer('/Devices/Example')
ZenPackBase.remove(self, dmd, leaveObjects=leaveObjects)
def install(self, packName):
zp = None
try:
# hide uncatalog error messages since they do not do any harm
log = logging.getLogger('Zope.ZCatalog')
oldLevel = log.getEffectiveLevel()
log.setLevel(HIGHER_THAN_CRITICAL)
zp = self.dmd.ZenPackManager.packs._getOb(packName)
self.log.info('Upgrading %s' % packName)
zp.upgrade(self.app)
except AttributeError:
try:
module = __import__('Products.' + packName, globals(), {}, [''])
zp = module.ZenPack(packName)
except (ImportError, AttributeError), ex:
self.log.debug("Unable to find custom ZenPack (%s), "
"defaulting to generic ZenPack",
ex)
zp = ZenPack(packName)
self.dmd.ZenPackManager.packs._setObject(packName, zp)
zp = self.dmd.ZenPackManager.packs._getOb(packName)
zp.install(self.app)
def install(self, packName):
zp = None
# We wrap our try in a try to abort our tansaction, but make sure we
# unpause applyDataMap functionality
try:
try:
# hide uncatalog error messages since they do not do any harm
log = logging.getLogger('Zope.ZCatalog')
oldLevel = log.getEffectiveLevel()
log.setLevel(HIGHER_THAN_CRITICAL)
zp = self.dmd.ZenPackManager.packs._getOb(packName)
self.log.info('Upgrading %s', packName)
self.dmd.startPauseADM()
zp.upgrade(self.app)
except AttributeError:
try:
module = __import__('Products.' + packName, globals(), {}, [''])
zp = module.ZenPack(packName)
except (ImportError, AttributeError), ex:
self.log.debug(
"Unable to find custom ZenPack (%s), defaulting to generic ZenPack", ex
)
zp = ZenPack(packName)
self.dmd.ZenPackManager.packs._setObject(packName, zp)
zp = self.dmd.ZenPackManager.packs._getOb(packName)
zp.install(self.app)
finally:
log.setLevel(oldLevel)
if zp:
for required in zp.requires:
try:
self.dmd.ZenPackManager.packs._getOb(required)
except:
self.log.error(
"Pack %s requires pack %s: not installing",
packName, required
)
return
def install(self, packName):
zp = None
try:
# hide uncatalog error messages since they do not do any harm
log = logging.getLogger('Zope.ZCatalog')
oldLevel = log.getEffectiveLevel()
log.setLevel(HIGHER_THAN_CRITICAL)
zp = self.dmd.ZenPackManager.packs._getOb(packName)
self.log.info('Upgrading %s' % packName)
zp.upgrade(self.app)
except AttributeError:
try:
module = __import__('Products.' + packName, globals(), {},
[''])
zp = module.ZenPack(packName)
except (ImportError, AttributeError), ex:
self.log.debug(
"Unable to find custom ZenPack (%s), "
"defaulting to generic ZenPack", ex)
zp = ZenPack(packName)
self.dmd.ZenPackManager.packs._setObject(packName, zp)
zp = self.dmd.ZenPackManager.packs._getOb(packName)
zp.install(self.app)
def testNestedInstall(self):
client = _MockControlPlaneClient(services=_services)
services = [
json.dumps(_MockService(i), cls=_MockServiceEncoder)
for i in ('svc1', 'root', 'svc2')
]
paths = ['/=ROOT', '/', '/=ROOT']
with setControlPlaneClient(client), setCurrentService('zope'):
ZenPack("id").installServiceDefinitions(services, paths)
# Confirm that parent is installed before children
self.assertEquals(len(client.added), len(paths))
for i, v in enumerate(('root', 'svc', 'svc')):
svc = json.loads(client.added[i][1])
self.assertIn(v, svc['Id'])
def testNestedInstall(self):
context = _MockServiceMigrationContext()
client = _MockControlPlaneClient(services=_services)
services = [
json.dumps(_MockService(i), cls=_MockServiceEncoder)
for i in ('svc1', 'root', 'svc2')
]
paths = ['/=ROOT', '/', '/=ROOT']
with setControlPlaneClient(client), setCurrentService(
'zope'), setServiceMigrationContext(context):
ZenPack("id").installServiceDefinitions(services, paths)
root = json.loads(context.added[0][1])
self.assertEquals(root["Name"], "ROOT")
self.assertIn("SVC1", [s["Name"] for s in root["Services"]])
self.assertIn("SVC2", [s["Name"] for s in root["Services"]])
def testAddMultipleServices(self):
client = _MockControlPlaneClient(services=_services)
services = [
json.dumps(_MockService(i), cls=_MockServiceEncoder)
for i in ('id1', 'id2')
]
paths = ['/', '/hub']
with setControlPlaneClient(client), setCurrentService('zope'):
ZenPack("id").installServiceDefinitions(services, paths)
self.assertEquals(len(client.added), 2)
added = [(i[0], json.loads(i[1])) for i in client.added]
self.assertEquals(added[0][1]['Id'], 'id1')
self.assertEquals(added[0][0], 'zenoss')
self.assertEquals(added[1][1]['Id'], 'id2')
self.assertEquals(added[1][0], 'hub1')
def testNormalizeServiceConfig(self):
service = {
'ConfigFiles': {
'missing': {},
'empty': {
'Content': ''
},
'present': {
'Content': 'present Content'
}
}
}
configMap = {'missing': 'missing Content', 'empty': 'empty Content'}
expected = dict(present=service['ConfigFiles']['present']['Content'],
**configMap)
configFiles = ZenPack.normalizeService(service, configMap,
'')['ConfigFiles']
for key, value in configFiles.iteritems():
self.assertEquals(expected[key], value['Content'])
def testNestedRemove(self):
tag = 'zp'
_services = [
_MockService('zenoss', '', []),
_MockService('zope', 'zenoss', ['daemon']),
_MockService('svc1', 'root', [tag]),
_MockService('root', 'zenoss', [tag]),
_MockService('svc2', 'root', [tag]),
]
client = _MockControlPlaneClient(services=_services)
with setControlPlaneClient(client), setCurrentService('zope'):
ZenPack("id").removeServices(tag)
expected = ['root', 'svc1', 'svc2']
self.assertEquals(sorted(client.deleted), sorted(expected))
# Confirm child services deleted before parent
self.assertLess(client.deleted.index('svc1'),
client.deleted.index('root'))
self.assertLess(client.deleted.index('svc2'),
client.deleted.index('root'))
def testAddMultipleServicesRelative(self):
context = _MockServiceMigrationContext()
client = _MockControlPlaneClient(services=_services)
services = [
json.dumps(dict(Name=n, Tags=[t])) for n, t in zip(
["a", "b", "c", "d", "e"], ["1", "2", "3", "4", "5"])
]
paths = ["/hub/..", "/=ZOPE", "/=ZOPE/=b", "/=ZOPE/=b/=c", "/hub/../1"]
with setControlPlaneClient(client), setCurrentService(
'zope'), setServiceMigrationContext(context):
ZenPack("id").installServiceDefinitions(services, paths)
self.assertEquals(
[json.loads(a[1]) for a in context.added],
[{
"Services": [{
"Services": [],
"Name": "e",
"Tags": ["5"]
}],
"Name": "a",
"Tags": ["1"]
}, {
"Services": [{
"Services": [{
"Services": [],
"Name": "d",
"Tags": ["4"]
}],
"Name":
"c",
"Tags": ["3"]
}],
"Name":
"b",
"Tags": ["2"]
}])
def remove(self, app, leaveObjects=False):
# disable globally, for all device classes and devices:
self.disable_modeler_plugins(app.zport.dmd, self.modeler_plugins, self.devices_or_classes_to_modify_iterator(app) )
ZenPackBase.remove(self, app, leaveObjects=leaveObjects)
def install(self, app):
Base.install(self, app)
self.migrate()
def remove(self, app, leaveObjects=False):
if hasattr(app.zport.dmd, 'productName'):
del app.zport.dmd.productName
ZenPackBase.remove(self, app, leaveObjects)
def upgrade(self, app):
Base.upgrade(self, app)
self.migrate()
def install(self, app):
ZenPackBase.install(self, app)
for d in self.dmd.Devices.getSubDevices():
d.buildRelations()
def install(self, dmd):
ZenPackBase.install(self, dmd)
self.symlinkScript()
for d in self.dmd.Devices.getSubDevices():
d.buildRelations()
def install(self, app):
ZenPackBase.install(self, app)
self.install_modeler_plugins(app.zport.dmd)
self.rebuildRelations(app.zport.dmd)
def remove(self, dmd, leaveObjects=False):
if not leaveObjects:
pass
self.remove_symlink()
ZenPackBase.remove(self, dmd, leaveObjects=leaveObjects)
def transactional_actions():
# Instantiate ZenPack
entryMap = pkg_resources.get_entry_map(dist, ZENPACK_ENTRY_POINT)
if not entryMap or len(entryMap) > 1:
raise ZenPackException(
'A ZenPack egg must contain exactly one'
' zenoss.zenpacks entry point. This egg appears to contain'
' %s such entry points.' % len(entryMap))
packName, packEntry = entryMap.items()[0]
runExternalZenpack = True
#if zenpack with same name exists we can't load both modules
#installing new egg zenpack will be done in a sub process
existing = dmd.ZenPackManager.packs._getOb(packName, None)
if existing:
log.info("Previous ZenPack exists with same name %s" % packName)
if filesOnly or not existing:
#running files only or zenpack by same name doesn't already exists
# so no need to install the zenpack in an external process
runExternalZenpack = False
module = packEntry.load()
if hasattr(module, 'ZenPack'):
zenPack = module.ZenPack(packName)
else:
zenPack = ZenPack(packName)
zenPack.eggPack = True
CopyMetaDataToZenPackObject(dist, zenPack)
if filesOnly:
for loader in (ZPL.ZPLDaemons(), ZPL.ZPLBin(),
ZPL.ZPLLibExec()):
loader.load(zenPack, None)
if fromUI and not zenPack.installableFromUI:
raise ZenPackException(
"This ZenPack cannot be installed through the UI.")
if not filesOnly:
# Look for an installed ZenPack to be upgraded. In this case
# upgraded means that it is removed before the new one is installed
# but that its objects are not removed and the packables are
# copied to the new instance.
existing = dmd.ZenPackManager.packs._getOb(packName, None)
if not existing and zenPack.prevZenPackName:
existing = dmd.ZenPackManager.packs._getOb(
zenPack.prevZenPackName, None)
deferFileDeletion = False
packables = []
upgradingFrom = None
if existing:
upgradingFrom = existing.version
for p in existing.packables():
packables.append(p)
existing.packables.removeRelation(p)
if existing.isEggPack():
forceNoFileDeletion = existing.eggPath() == dist.location
RemoveZenPack(dmd,
existing.id,
skipDepsCheck=True,
leaveObjects=True,
forceNoFileDeletion=forceNoFileDeletion,
uninstallEgg=False)
else:
# Don't delete files, might still be needed for
# migrate scripts to be run below.
deferFileDeletion = True
oldzenpack.RemoveZenPack(dmd,
existing.id,
skipDepsCheck=True,
leaveObjects=True,
deleteFiles=False)
if runExternalZenpack or forceRunExternal:
log.info("installing zenpack %s; launching process" % packName)
cmd = [binPath('zenpack')]
if link:
cmd += ["--link"]
cmd += ["--install", eggPath]
if upgradingFrom:
cmd += ['--previousversion', upgradingFrom]
if fromUI:
cmd += ["--fromui"]
cmdStr = " ".join(cmd)
log.debug("launching sub process command: %s" % cmdStr)
p = subprocess.Popen(cmdStr, shell=True)
out, err = p.communicate()
p.wait()
if p.returncode:
raise ZenPackException(
'Error installing the egg (%s): %s' %
(p.returncode, err))
dmd._p_jar.sync()
else:
dmd.ZenPackManager.packs._setObject(packName, zenPack)
zenPack = dmd.ZenPackManager.packs._getOb(packName)
#hack because ZenPack.install is overridden by a lot of zenpacks
#so we can't change the signature of install to take the
#previousVerison
zenPack.prevZenPackVersion = previousVersion
zenPack.install(dmd)
zenPack.prevZenPackVersion = None
try:
zenPack = dmd.ZenPackManager.packs._getOb(packName)
for p in packables:
pId = p.getPrimaryId()
try:
# make sure packable still exists; could be deleted by a
# migrate
getObjByPath(dmd, pId)
log.debug("adding packable relation for id %s", pId)
zenPack.packables.addRelation(p)
except (KeyError, zExceptions.NotFound):
log.debug('did not find packable %s', pId)
except AttributeError, e:
# If this happens in the child process or during the non-upgrade
# flow, reraise the exception
if not runExternalZenpack:
raise
# This specific error will occur when the version of the ZenPack
# being installed subclasses Products.ZenModel.ZenPack, but the
# previous version of the ZenPack did not.
if str(e) == "'ZenPack' object has no attribute '__of__'":
zenPack = ZenPack(packName)
else:
# This is the signature error of class-loading issues
# during zenpack upgrade. The final state should be okay,
# except that modified packables may be lost.
message = "There has been an error during the post-" + \
"installation steps for the zenpack %s. In " + \
"most cases, no further action is required. If " + \
"issues persist, please reinstall this zenpack."
message = message % packName
log.warning(message)
raise NonCriticalInstallError(message)
cleanupSkins(dmd)
return zenPack, deferFileDeletion, existing
def transactional_actions():
# Instantiate ZenPack
entryMap = pkg_resources.get_entry_map(dist, ZENPACK_ENTRY_POINT)
if not entryMap or len(entryMap) > 1:
raise ZenPackException('A ZenPack egg must contain exactly one'
' zenoss.zenpacks entry point. This egg appears to contain'
' %s such entry points.' % len(entryMap))
packName, packEntry = entryMap.items()[0]
runExternalZenpack = True
#if zenpack with same name exists we can't load both modules
#installing new egg zenpack will be done in a sub process
existing = dmd.ZenPackManager.packs._getOb(packName, None)
if existing:
log.info("Previous ZenPack exists with same name %s" % packName)
if filesOnly or not existing:
#running files only or zenpack by same name doesn't already exists
# so no need to install the zenpack in an external process
runExternalZenpack = False
module = packEntry.load()
if hasattr(module, 'ZenPack'):
zenPack = module.ZenPack(packName)
else:
zenPack = ZenPack(packName)
zenPack.eggPack = True
CopyMetaDataToZenPackObject(dist, zenPack)
if filesOnly:
for loader in (ZPL.ZPLDaemons(), ZPL.ZPLBin(), ZPL.ZPLLibExec()):
loader.load(zenPack, None)
if fromUI and not zenPack.installableFromUI:
raise ZenPackException("This ZenPack cannot be installed through the UI.")
if not filesOnly:
# Look for an installed ZenPack to be upgraded. In this case
# upgraded means that it is removed before the new one is installed
# but that its objects are not removed and the packables are
# copied to the new instance.
existing = dmd.ZenPackManager.packs._getOb(packName, None)
if not existing and zenPack.prevZenPackName:
existing = dmd.ZenPackManager.packs._getOb(
zenPack.prevZenPackName, None)
deferFileDeletion = False
packables = []
upgradingFrom = None
if existing:
upgradingFrom = existing.version
for p in existing.packables():
packables.append(p)
existing.packables.removeRelation(p)
if existing.isEggPack():
forceNoFileDeletion = existing.eggPath() == dist.location
RemoveZenPack(dmd, existing.id,
skipDepsCheck=True, leaveObjects=True,
forceNoFileDeletion=forceNoFileDeletion,
uninstallEgg=False)
else:
# Don't delete files, might still be needed for
# migrate scripts to be run below.
deferFileDeletion = True
oldzenpack.RemoveZenPack(dmd, existing.id,
skipDepsCheck=True, leaveObjects=True,
deleteFiles=False)
if runExternalZenpack or forceRunExternal:
log.info("installing zenpack %s; launching process" % packName)
cmd = [binPath('zenpack')]
if link:
cmd += ["--link"]
cmd += ["--install", eggPath]
if upgradingFrom:
cmd += ['--previousversion', upgradingFrom]
if fromUI:
cmd += ["--fromui"]
if serviceId:
cmd += ['--service-id', serviceId]
cmdStr = " ".join(cmd)
log.debug("launching sub process command: %s" % cmdStr)
p = subprocess.Popen(cmdStr,
shell=True)
out, err = p.communicate()
p.wait()
if p.returncode:
raise ZenPackException('Error installing the egg (%s): %s' %
(p.returncode, err))
dmd._p_jar.sync()
else:
dmd.ZenPackManager.packs._setObject(packName, zenPack)
zenPack = dmd.ZenPackManager.packs._getOb(packName)
#hack because ZenPack.install is overridden by a lot of zenpacks
#so we can't change the signature of install to take the
#previousVerison
zenPack.prevZenPackVersion = previousVersion
zenPack.install(dmd)
zenPack.prevZenPackVersion = None
try:
zenPack = dmd.ZenPackManager.packs._getOb(packName)
for p in packables:
pId = p.getPrimaryId()
try:
# make sure packable still exists; could be deleted by a
# migrate
getObjByPath(dmd, pId)
log.debug("adding packable relation for id %s", pId)
zenPack.packables.addRelation(p)
except (KeyError, zExceptions.NotFound):
log.debug('did not find packable %s',pId)
except AttributeError, e:
# If this happens in the child process or during the non-upgrade
# flow, reraise the exception
if not runExternalZenpack:
raise
# This specific error will occur when the version of the ZenPack
# being installed subclasses Products.ZenModel.ZenPack, but the
# previous version of the ZenPack did not.
if str(e) == "'ZenPack' object has no attribute '__of__'":
zenPack = ZenPack(packName)
else:
# This is the signature error of class-loading issues
# during zenpack upgrade. The final state should be okay,
# except that modified packables may be lost.
message = "There has been an error during the post-" + \
"installation steps for the zenpack %s. In " + \
"most cases, no further action is required. If " + \
"issues persist, please reinstall this zenpack."
message = message % packName
log.warning( message )
raise NonCriticalInstallError( message )
cleanupSkins(dmd)
return zenPack, deferFileDeletion, existing
def install(self, dmd):
# create the required device class
dc = dmd.Devices.createOrganizer('/Storage/IBMV7000')
ZenPackBase.install(self, dmd)
def remove(self, app, leaveObjects=False):
if not leaveObjects:
_removePluginsFromDiscovered(self.dmd)
ZenPackBase.remove(self, app, leaveObjects)
def install(self, app):
for c in self.constructs:
c.buildZenPackFiles()
ZenPackBase.install(self, app)
self.updateRelations(app)
def install(self, app):
self._removePreviousZenPacks(self.dmd)
ZenPackBase.install(self, app)
_addPluginsToDiscovered(self.dmd)
def install(self, app):
# productName is used in the UpdateCheck call to dev.zenoss.org to
# identify what product is checking version.
app.zport.dmd.productName = 'trebortechlayout'
ZenPackBase.install(self, app)
app = self.dmd.getPhysicalRoot()
def testNormalizeServiceTags(self):
tag = 'foobar'
tests = ({}, {"Tags": ['some', 'tags']})
for service in tests:
tags = ZenPack.normalizeService(service, {}, tag)['Tags']
self.assertIn(tag, tags)
def install(self, dmd):
# create the required device class
dc = dmd.Devices.createOrganizer('/Storage/IBMV7000')
ZenPackBase.install(self, dmd)
def remove(self, app, leaveObjects=False):
ZenPackBase.remove(self, app, leaveObjects)
Device._relations = tuple([x for x in Device._relations if x[0] not in ('httpComponents')])
for d in self.dmd.Devices.getSubDevices():
d.buildRelations()
def install(self, app):
# productName is used in the UpdateCheck call to dev.zenoss.org to
# identify what product is checking version.
app.zport.dmd.productName = 'trebortechlayout'
ZenPackBase.install(self, app)
app = self.dmd.getPhysicalRoot()
def remove(self, dmd, leaveObjects=False):
ZenPackBase.remove(self, dmd, leaveObjects=leaveObjects)
Device._relations = tuple([x for x in Device._relations if x[0] not in ('torqueNodes')])
for device in self.dmd.Devices.getSubDevices():
device.buildRelations()
def remove(self, dmd, leaveObjects=False):
self.removeScriptSymlink()
ZenPackBase.remove(self, dmd, leaveObjects=leaveObjects)
Device._relations = tuple([x for x in Device._relations if x[0] not in ('javaApps')])
for d in self.dmd.Devices.getSubDevices():
d.buildRelations()
def remove(self, app, leaveObjects=False):
if hasattr(app.zport.dmd, 'productName'):
del app.zport.dmd.productName
ZenPackBase.remove(self, app, leaveObjects)
def upgrade(self, app):
ZenPackBase.upgrade(self, app)
self.rebuildRelations(app.zport.dmd)
def install(self, app):
ZenPackBase.install(self, app)
# enable globally, for all device classes and devices:
self.enable_modeler_plugins( app.zport.dmd, self.modeler_plugins, self.devices_or_classes_to_modify_iterator(app) )
