class WinSQLInstance(OSComponent): ''' Model class for MSSQL Instance. ''' meta_type = portal_type = 'WinDBInstance' instancename = None backupdevices = None roles = None _properties = OSComponent._properties + ( {'id': 'instancename', 'type': 'string'}, ) _relations = OSComponent._relations + ( ("os", ToOne(ToManyCont, "ZenPacks.zenoss.Microsoft.Windows.OperatingSystem", "winsqlinstances")), ("backups", ToManyCont(ToOne, "ZenPacks.zenoss.Microsoft.Windows.WinSQLBackup", "winsqlinstance")), ("jobs", ToManyCont(ToOne, "ZenPacks.zenoss.Microsoft.Windows.WinSQLJob", "winsqlinstance")), ("databases", ToManyCont(ToOne, "ZenPacks.zenoss.Microsoft.Windows.WinSQLDatabase", "winsqlinstance")), ) def getRRDTemplateName(self): return 'WinDBInstance'
class Endpoint(Device): meta_type = portal_type = 'OpenStackEndpoint' _relations = Device._relations + ( ( 'flavors', ToManyCont( ToOne, 'ZenPacks.zenoss.OpenStack.Flavor.Flavor', 'endpoint', ), ), ( 'images', ToManyCont( ToOne, 'ZenPacks.zenoss.OpenStack.Image.Image', 'endpoint', ), ), ( 'servers', ToManyCont( ToOne, 'ZenPacks.zenoss.OpenStack.Server.Server', 'endpoint', ), ), )
class RabbitMQVHost(RabbitMQComponent): meta_type = portal_type = "RabbitMQVHost" _relations = RabbitMQComponent._relations + ( ( 'rabbitmq_node', ToOne( ToManyCont, 'ZenPacks.zenoss.RabbitMQ.RabbitMQNode.RabbitMQNode', 'rabbitmq_vhosts', ), ), ( 'rabbitmq_exchanges', ToManyCont( ToOne, 'ZenPacks.zenoss.RabbitMQ.RabbitMQExchange.RabbitMQExchange', 'rabbitmq_vhost', ), ), ( 'rabbitmq_queues', ToManyCont( ToOne, 'ZenPacks.zenoss.RabbitMQ.RabbitMQQueue.RabbitMQQueue', 'rabbitmq_vhost', ), ), ) def device(self): return self.rabbitmq_node().device()
class IBM3584DeviceHW(DeviceHW): # Define new relationships _relations = DeviceHW._relations + ( ("changerdevices", ToManyCont(ToOne, "ZenPacks.community.IBM3584Mon.IBM3584ChangerDevice", "hw")), ("frames", ToManyCont(ToOne, "ZenPacks.community.IBM3584Mon.IBM3584Frame", "hw")), ("accessdevices", ToManyCont(ToOne, "ZenPacks.community.IBM3584Mon.IBM3584AccessDevice", "hw")), )
class A10Device(Device): """ A10 device subclass. In this case the reason for creating a subclass of device is to add a new type of relation. We want many "A10ServiceGroup" and "A10VirtualServer" components to be associated with each of these devices. If you set the zPythonClass of a device class to ZenPacks.community.A10Device, any devices created or moved into that device class will become this class and be able to contain A10ServiceGroups and A10VirtualServers. """ meta_type = portal_type = 'A10Device' memoryUsed = 0 _properties = Device._properties + ({ 'id': 'memoryUsed', 'type': 'int', 'mode': '' }, ) # This is where we extend the standard relationships of a device to add # the "a10Servers", "a10ServiceGroups" and "a10VirtualServers" relationships that must be filled with components # of our custom "A10Server", "A10ServiceGroup" and "A10VirtualServer" classes. _relations = Device._relations + ( ( 'a10VirtualServers', ToManyCont( ToOne, 'ZenPacks.community.A10.A10VirtualServer', 'a10Device', ), ), ( 'a10ServiceGroups', ToManyCont( ToOne, 'ZenPacks.community.A10.A10ServiceGroup', 'a10Device', ), ), ( 'a10Servers', ToManyCont( ToOne, 'ZenPacks.community.A10.A10Server', 'a10Device', ), ), ) factory_type_information = deepcopy(Device.factory_type_information) def __init__(self, *args, **kw): Device.__init__(self, *args, **kw) self.buildRelations()
class upsDevice(Device): "upsCS1x1 Device" meta_type = portal_type = 'upsDevice' _relations = Device._relations + ( ('upsBattery', ToManyCont(ToOne, 'ZenPacks.community.upsCS1x1.upsBattery', 'upsDevBattery',),), ('upsInput', ToManyCont(ToOne, 'ZenPacks.community.upsCS1x1.upsInput', 'upsDevInput',),), ('upsOutput', ToManyCont(ToOne, 'ZenPacks.community.upsCS1x1.upsOutput', 'upsDevOutput',),), ('upsBypass', ToManyCont(ToOne, 'ZenPacks.community.upsCS1x1.upsBypass', 'upsDevBypass',),), )
class EC2Region(AWSComponent): ''' Model class for EC2Region. ''' meta_type = portal_type = 'EC2Region' _instance_device_ids = None _properties = AWSComponent._properties _relations = AWSComponent._relations + ( ('account', ToOne(ToManyCont, MODULE_NAME['EC2Account'], 'regions')), ('zones', ToManyCont(ToOne, MODULE_NAME['EC2Zone'], 'region')), ('instances', ToManyCont(ToOne, MODULE_NAME['EC2Instance'], 'region')), ('volumes', ToManyCont(ToOne, MODULE_NAME['EC2Volume'], 'region')), ('vpcs', ToManyCont(ToOne, MODULE_NAME['EC2VPC'], 'region')), ('vpc_subnets', ToManyCont(ToOne, MODULE_NAME['EC2VPCSubnet'], 'region')), ) def getDimension(self): return '' def getRegionId(self): return self.id @transact def discover_guests(self): ''' Attempt to discover and link instance guest devices. ''' map(operator.methodcaller('discover_guest'), self.instances()) # First discovery. Initialize our instance device ids storage. if self._instance_device_ids is None: self._instance_device_ids = set(self.instances.objectIds()) return instance_device_ids = set(self.instances.objectIds()) terminated_device_ids = self._instance_device_ids.difference( instance_device_ids) # Delete guest devices for terminated instances. for device_id in terminated_device_ids: guest_device = self.findDeviceByIdExact(device_id) if guest_device: LOG.info('Deleting device %s after instance %s was terminated', guest_device.titleOrId(), guest_device.id) guest_device.deleteDevice() # Store instance device ids for next run. self._instance_device_ids = instance_device_ids
class Zone(BaseComponent): meta_type = portal_type = "CloudStackZone" guest_cidr_address = None dhcp_provider = None dns1 = None dns2 = None internal_dns1 = None internal_dns2 = None network_type = None security_groups_enabled = None vlan = None zone_token = None _properties = BaseComponent._properties + ( {'id': 'guest_cidr_address', 'type': 'string', 'mode': ''}, {'id': 'dhcp_provider', 'type': 'string', 'mode': ''}, {'id': 'dns1', 'type': 'string', 'mode': ''}, {'id': 'dns2', 'type': 'string', 'mode': ''}, {'id': 'internal_dns1', 'type': 'string', 'mode': ''}, {'id': 'internal_dns2', 'type': 'string', 'mode': ''}, {'id': 'network_type', 'type': 'string', 'mode': ''}, {'id': 'security_groups_enabled', 'type': 'boolean', 'mode': ''}, {'id': 'vlan', 'type': 'string', 'mode': ''}, {'id': 'zone_token', 'type': 'string', 'mode': ''}, ) _relations = BaseComponent._relations + ( ('cloud', ToOne(ToManyCont, 'ZenPacks.zenoss.CloudStack.Cloud.Cloud', 'zones') ), ('pods', ToManyCont(ToOne, 'ZenPacks.zenoss.CloudStack.Pod.Pod', 'zone') ), ('vms', ToManyCont(ToOne, 'ZenPacks.zenoss.CloudStack.VirtualMachine.VirtualMachine', 'zone') ), ) def device(self): return self.cloud() def getRRDTemplates(self): templates = super(Zone, self).getRRDTemplates() if not self.isRootAdmin(): return [] return templates
class Endpoint(Device): meta_type = portal_type = 'OpenStackEndpoint' _relations = Device._relations + ( ( 'flavors', ToManyCont( ToOne, 'ZenPacks.zenoss.OpenStack.Flavor.Flavor', 'endpoint', ), ), ( 'images', ToManyCont( ToOne, 'ZenPacks.zenoss.OpenStack.Image.Image', 'endpoint', ), ), ( 'servers', ToManyCont( ToOne, 'ZenPacks.zenoss.OpenStack.Server.Server', 'endpoint', ), ), ) def getIconPath(self): return '/++resource++openstack/img/openstack.png' def getStatus(self, statusclass="/Status/*", **kwargs): # This is identical the behavior provided by ZPL- once this zenpack # is converted to ZPL, this method can be removed. if not self.monitorDevice(): return None zep = Zuul.getFacade("zep", self.dmd) try: event_filter = zep.createEventFilter( tags=[self.getUUID()], element_sub_identifier=[""], severity=[SEVERITY_CRITICAL], status=[STATUS_NEW, STATUS_ACKNOWLEDGED], event_class=filter(None, [statusclass])) result = zep.getEventSummaries(0, filter=event_filter, limit=0) except Exception: return None return int(result['total'])
class System(Device): meta_type = portal_type = "oVirtSystem" _relations = Device._relations + ( ('datacenters', ToManyCont(ToOne, 'ZenPacks.zenoss.oVirt.DataCenter.DataCenter', 'system')), ('storagedomains', ToManyCont(ToOne, 'ZenPacks.zenoss.oVirt.StorageDomain.StorageDomain', 'system')), ) def getIconPath(self): return icon_for(self, 'system')
class Framework(DeviceComponent, ManagedEntity): meta_type = portal_type = 'CloudFoundryFramework' cfName = '' cfDetection = PersistentList() _properties = ManagedEntity._properties + ( { 'id': 'cfName', 'type': 'string', 'mode': '' }, { 'id': 'cfDetection', 'type': 'string', 'mode': '' }, ) _relations = ManagedEntity._relations + ( ('cfEndpoint', ToOne(ToManyCont, 'ZenPacks.zenoss.CloudFoundry.Endpoint.Endpoint', 'cfFrameworks')), ('cfRuntimes', ToManyCont(ToOne, 'ZenPacks.zenoss.CloudFoundry.Runtime.Runtime', 'cfFramework')), ('cfAppServers', ToManyCont(ToOne, 'ZenPacks.zenoss.CloudFoundry.AppServer.AppServer', 'cfFramework')), ) # Meta-data: Zope object views and actions factory_type_information = ({ 'actions': ({ 'id': 'perfConf', 'name': 'Template', 'action': 'objTemplates', 'permissions': (ZEN_CHANGE_DEVICE, ), }, ), }, ) def device(self): return self.cfEndpoint() def getCFDetection(self): return self.cfDetection def setCFDetection(self, detection): self.cfDetection = PersistentList(detection)
class OperatingSystem(BaseOS): _relations = BaseOS._relations + ( ("winrmservices", ToManyCont(ToOne, "ZenPacks.zenoss.Microsoft.Windows.WinService", "os")), ("winrmiis", ToManyCont(ToOne, "ZenPacks.zenoss.Microsoft.Windows.WinIIS", "os")), ("winsqlinstances", ToManyCont(ToOne, "ZenPacks.zenoss.Microsoft.Windows.WinSQLInstance", "os")), ("clusterservices", ToManyCont(ToOne, "ZenPacks.zenoss.Microsoft.Windows.ClusterService", "os")), )
class Cluster(BaseComponent): meta_type = portal_type = "CloudStackCluster" cluster_type = None hypervisor_type = None managed_state = None _properties = BaseComponent._properties + ( { 'id': 'cluster_type', 'type': 'string', 'mode': '' }, { 'id': 'hypervisor_type', 'type': 'string', 'mode': '' }, { 'id': 'managed_state', 'type': 'string', 'mode': '' }, ) _relations = BaseComponent._relations + ( ('pod', ToOne(ToManyCont, 'ZenPacks.zenoss.CloudStack.Pod.Pod', 'clusters')), ('hosts', ToManyCont(ToOne, 'ZenPacks.zenoss.CloudStack.Host.Host', 'cluster')), ) def device(self): return self.pod().device()
class RaidGroup(DeviceComponent, ManagedEntity): meta_type = portal_type = 'NetAppRaidGroup' rg_name = None _properties = ManagedEntity._properties + ({ 'id': 'rg_name', 'type': 'string' }, ) _relations = ManagedEntity._relations + ( ('plex', ToOne(ToManyCont, 'ZenPacks.CS.NetApp.SevenMode.Plex', 'raid_groups')), ('disks', ToManyCont(ToOne, 'ZenPacks.CS.NetApp.SevenMode.Disk', 'raid_group')), ) factory_type_information = ({ 'actions': ({ 'id': 'perfConf', 'name': 'Template', 'action': 'objTemplates', 'permissions': (ZEN_CHANGE_DEVICE, ), }, ), }, ) def device(self): return self.plex().aggregate().netapp_device() def getRRDTemplateName(self): return 'NetApp7Mode_RaidGroup'
class Enclosure(DeviceComponent, ManagedEntity): meta_type = portal_type = 'NetBotzEnclosure' # Fields inherited from DeviceComponent and ManagedEntity # id, title, snmpindex enclosure_status = None error_status = None parent_id = None docked_id = None _properties = ManagedEntity._properties + ( { 'id': 'enclosure_status', 'type': 'string' }, { 'id': 'error_status', 'type': 'string' }, { 'id': 'parent_id', 'type': 'string' }, { 'id': 'docked_id', 'type': 'string' }, ) _relations = ManagedEntity._relations + ( ('sensor_device', ToOne( ToManyCont, 'ZenPacks.training.NetBotz.NetBotzDevice', 'enclosures', )), ('temperature_sensors', ToManyCont( ToOne, 'ZenPacks.training.NetBotz.TemperatureSensor', 'enclosure', )), ) factory_type_information = ({ 'actions': ({ 'id': 'perfConf', 'name': 'Template', 'action': 'objTemplates', 'permissions': (ZEN_CHANGE_DEVICE, ), }, ), }, ) def device(self): return self.sensor_device() def getRRDTemplateName(self): return 'Enclosure'
class NetAppDevice(Device): """NetApp Device""" meta_type = portal_type = 'NetAppDevice' _relations = Device._relations + ( ('aggregates', ToManyCont(ToOne, 'ZenPacks.CS.NetApp.SevenMode.Aggregate', 'netapp_device')), )
class ExampleDevice(Device): """ Example device subclass. In this case the reason for creating a subclass of device is to add a new type of relation. We want many "ExampleComponent" components to be associated with each of these devices. If you set the zPythonClass of a device class to ZenPacks.NAMESPACE.PACKNAME.ExampleDevice, any devices created or moved into that device class will become this class and be able to contain ExampleComponents. """ meta_type = portal_type = 'ExampleDevice' # This is where we extend the standard relationships of a device to add # our "exampleComponents" relationship that must be filled with components # of our custom "ExampleComponent" class. _relations = Device._relations + ( ('exampleComponents', ToManyCont(ToOne, 'ZenPacks.skills1st.MenuExamples.ExampleComponent', 'exampleDevice', ), ), ) # The menus for this particular device class will have all the standard menus # for a Device and then add on this new menu. The "action" field specifies # the page template (.pt) file that defines the menu. factory_type_information = deepcopy(Device.factory_type_information) factory_type_information[0]['actions'] += ( { 'id' : 'ExampleDevice' , 'name' : 'My Example Menu 2 (Example Devices only)' , 'action' : 'myExampleMenuTwo' , 'permissions' : ( Permissions.view,) }, ) # This function called by mydropDownMenu1.pt # The parameter "comments" must match the name parameter on the # input line and these both need to match the object attribute you are changing # The name of the function must match with the pt file dialog_buttons section, with # the name field for the OK input eg. # <input tal:attributes="type string:submit; # value string:OK" # name="createComment:method" /> def createComment(self, comments='', REQUEST=''): """ Set comments attribute for a device """ self.comments = comments if REQUEST: messaging.IMessageSender(self).sendToBrowser( 'Device comment set', 'Device comment created as %s ' % comments ) return self.callZenScreen(REQUEST)
class xupsDevice(Device): meta_type = portal_type = 'xupsDevice' _relations = Device._relations + ( ( 'xupsBattery', ToManyCont( ToOne, 'ZenPacks.community.xUPS.xupsBattery', 'xupsDevBattery', ), ), ( 'xupsInput', ToManyCont( ToOne, 'ZenPacks.community.xUPS.xupsInput', 'xupsDevInput', ), ), ( 'xupsOutput', ToManyCont( ToOne, 'ZenPacks.community.xUPS.xupsOutput', 'xupsDevOutput', ), ), ( 'xupsBypass', ToManyCont( ToOne, 'ZenPacks.community.xUPS.xupsBypass', 'xupsDevBypass', ), ), ( 'xupsContactSense', ToManyCont( ToOne, 'ZenPacks.community.xUPS.xupsContactSense', 'xupsDevContactSense', ), ), )
class Cloud(Device): meta_type = portal_type = "CloudStackCloud" _relations = Device._relations + ( ('zones', ToManyCont(ToOne, 'ZenPacks.zenoss.CloudStack.Zone.Zone', 'cloud') ), )
class MySQLServer(MySQLComponent): meta_type = portal_type = 'MySQLServer' size = None data_size = None index_size = None percent_full_table_scans = None slave_status = None master_status = None version = None deadlock_info = None _properties = MySQLComponent._properties + ( { 'id': 'size', 'type': 'string' }, { 'id': 'data_size', 'type': 'string' }, { 'id': 'index_size', 'type': 'string' }, { 'id': 'percent_full_table_scans', 'type': 'string' }, { 'id': 'slave_status', 'type': 'string' }, { 'id': 'master_status', 'type': 'string' }, { 'id': 'version', 'type': 'string' }, ) _relations = MySQLComponent._relations + ( ('mysql_host', ToOne(ToManyCont, 'Products.ZenModel.Device.Device', 'mysql_servers')), ('databases', ToManyCont(ToOne, MODULE_NAME['MySQLDatabase'], 'server')), ) def remove(self, object_id=None): if object_id: self.databases._delObject(object_id) def device(self): return self.mysql_host()
class ClusterService(OSComponent): ''' Model class for Cluster Service. ''' meta_type = portal_type = 'MSClusterService' ownernode = None description = None coregroup = False priority = 0 state = None _properties = OSComponent._properties + ( { 'id': 'ownernode', 'type': 'string' }, { 'id': 'description', 'type': 'string' }, { 'id': 'coregroup', 'type': 'boolean' }, { 'id': 'priority', 'type': 'integer' }, { 'id': 'state', 'type': 'string' }, ) _relations = OSComponent._relations + ( ('os', ToOne(ToManyCont, 'ZenPacks.zenoss.Microsoft.Windows.OperatingSystem', 'clusterservices')), ('clusterresources', ToManyCont(ToOne, 'ZenPacks.zenoss.Microsoft.Windows.ClusterResource', 'clusterservice')), ) def ownernodeurl(self): deviceRoot = self.dmd.getDmdRoot("Devices") try: clusterhostip = getHostByName(self.ownernode) device = deviceRoot.findDeviceByIdOrIp(clusterhostip) return device.getPrimaryUrlPath() except (gaierror): log.warning('Unable to resolve hostname {0}'.format( self.ownernode)) return def getRRDTemplateName(self): return 'ClusterService'
def add_relationships(cls): """Add our relationships to cls._relations.""" our_relnames = set(DEVICE_RELATIONS) existing_relnames = {x[0] for x in cls._relations} new_reltuples = tuple( (relname, ToManyCont(ToOne, DEVICE_RELATIONS[relname], 'switch')) for relname in our_relnames.difference(existing_relnames)) if new_reltuples: cls._relations += new_reltuples
class TrueNASDevice(Device): # temp_sensor_count = None _properties = Device._properties + ( # {'id': 'temp_sensor_count', 'type': 'int'}, ) _relations = Device._relations + ( ('TrueNAS_Pools', ToManyCont( ToOne, 'ZenPacks.iXsystems.TrueNAS.TrueNASPool', 'TrueNAS_Device', )), ('TrueNAS_Datasets', ToManyCont( ToOne, 'ZenPacks.iXsystems.TrueNAS.TrueNASDataset', 'TrueNAS_Device', )), )
class SubComponent(IpService): _relations = ( ("superComponent", ToOne(ToManyCont, 'Products.ZenModel.IpService.IpService', 'subcomponents')), ("subcomponents", ToManyCont( ToOne, "Products.ZenModel.tests.testDeviceComponent.SubSubComponent", "superComponent")), )
class HPEVADeviceOS(OperatingSystem): # Define new relationships _relations = Software._relations + ( ("interfaces", ToManyCont(ToOne, "Products.ZenModel.IpInterface", "os")), ("routes", ToManyCont(ToOne, "Products.ZenModel.IpRouteEntry", "os")), ("ipservices", ToManyCont(ToOne, "Products.ZenModel.IpService", "os")), ("winservices", ToManyCont(ToOne, "Products.ZenModel.WinService", "os")), ("processes", ToManyCont(ToOne, "Products.ZenModel.OSProcess", "os")), ("filesystems", ToManyCont(ToOne, "Products.ZenModel.FileSystem", "os")), ("software", ToManyCont(ToOne, "Products.ZenModel.Software", "os")), ("storagepools", ToManyCont(ToOne, "ZenPacks.community.HPEVAMon.HPEVAStoragePool", "os")), ("virtualdisks", ToManyCont(ToOne, "ZenPacks.community.HPEVAMon.HPEVAStorageVolume", "os")), ("drgroups", ToManyCont(ToOne, "ZenPacks.community.HPEVAMon.HPEVAConsistencySet", "os")), ) factory_type_information = ( { 'id' : 'Device', 'meta_type' : 'Device', 'description' : """Base class for all devices""", 'icon' : 'Device_icon.gif', 'product' : 'ZenModel', 'factory' : 'manage_addDevice', 'immediate_view' : 'hpevaDeviceOsDetail', 'actions' : () }, ) def __init__(self): id = "os" Software.__init__(self, id) self._delObject("os") # OperatingSystem is a software
class KyoceraPrinterDevice(Device): meta_type = portal_type = 'KyoceraPrinterDevice' _relations = Device._relations + (( 'printer_elements', ToManyCont( ToOne, 'ZenPacks.andinod.KyoceraPrinter.TonerContainer', 'toner_container', ), ), ) _relations += (( 'printer_covers', ToManyCont( ToOne, 'ZenPacks.andinod.KyoceraPrinter.PrinterCover', 'cover_printer', ), ), )
class StorageDomain(BaseComponent): meta_type = portal_type = "oVirtStorageDomain" storagedomain_type = None storage_type = None storage_format = None status = None _properties = BaseComponent._properties + ( {'id': 'storagedomain_type', 'type': 'string', 'mode': 'w'}, {'id': 'storage_type', 'type': 'string', 'mode': 'w'}, {'id': 'storage_format', 'type': 'string', 'mode': 'w'}, {'id': 'status', 'type': 'string', 'mode': 'w'}, ) _relations = BaseComponent._relations + ( ('system', ToOne(ToManyCont, 'ZenPacks.zenoss.oVirt.System.System', 'storagedomains') ), ('disks', ToManyCont(ToOne, 'ZenPacks.zenoss.oVirt.VmDisk.VmDisk', 'storagedomains') ), ('datacenters', ToMany(ToMany, 'ZenPacks.zenoss.oVirt.DataCenter.DataCenter', 'storagedomains') ), ) def device(self): return self.system() def setDatacenterId(self, ids): new_ids = set(ids) current_ids = set(x.id for x in self.datacenters()) for id_ in new_ids.symmetric_difference(current_ids): datacenter = self.device().datacenters._getOb(id_) if datacenter: if id_ in new_ids: self.datacenters.addRelation(datacenter) else: self.datacenters.removeRelation(datacenter) notify(IndexingEvent(datacenter, 'path', False)) def getDatacenterId(self): return sorted([x.id for x in self.datacenters()]) def getIconPath(self): return icon_for(self.device(), 'storage-domain')
class InfobloxDevice(Device): bind_zone_count = None _properties = Device._properties + ({ 'id': 'bind_zone_count', 'type': 'int' }, ) _relations = Device._relations + ( ('bind_zones', ToManyCont( ToOne, 'ZenPacks.community.Infoblox.InfobloxDNS', 'bind_zone', )), ('dhcp_networks', ToManyCont( ToOne, 'ZenPacks.community.Infoblox.InfobloxDHCP', 'dhcp_network', )), )
class Database(DeviceComponent, ManagedEntity, CollectedOrModeledMixin): meta_type = portal_type = 'PostgreSQLDatabase' dbName = None dbOid = None # We do more frequent collection of these values, but it's good to have an # immediate value to use as soon as the device is added. modeled_dbSize = None _properties = ManagedEntity._properties + ( { 'id': 'dbName', 'type': 'string', 'mode': '' }, { 'id': 'dbOid', 'type': 'int', 'mode': '' }, { 'id': 'modeled_dbSize', 'type': 'int', 'mode': '' }, ) _relations = ManagedEntity._relations + ( ('server', ToOne(ToManyCont, 'Products.ZenModel.Device.Device', 'pgDatabases')), ('tables', ToManyCont(ToOne, 'ZenPacks.zenoss.PostgreSQL.Table.Table', 'database')), ) # Meta-data: Zope object views and actions factory_type_information = ({ 'actions': ({ 'id': 'perfConf', 'name': 'Template', 'action': 'objTemplates', 'permissions': (ZEN_CHANGE_DEVICE, ), }, ), }, ) # Query for events by id instead of name. event_key = "ComponentId" def device(self): return self.server()
class HBaseRegionServer(HBaseComponent): meta_type = portal_type = 'HBaseRegionServer' start_code = None is_alive = None region_name = None handler_count = None memstore_upper_limit = None memstore_lower_limit = None logflush_interval = None _properties = HBaseComponent._properties + ( { 'id': 'start_code', 'type': 'string' }, { 'id': 'is_alive', 'type': 'string' }, { 'id': 'region_name', 'type': 'string' }, { 'id': 'handler_count', 'type': 'string' }, { 'id': 'memstore_upper_limit', 'type': 'string' }, { 'id': 'memstore_lower_limit', 'type': 'string' }, { 'id': 'logflush_interval', 'type': 'string' }, ) _relations = HBaseComponent._relations + ( ('hbase_host', ToOne(ToManyCont, 'Products.ZenModel.Device.Device', 'hbase_servers')), ('regions', ToManyCont(ToOne, MODULE_NAME['HBaseHRegion'], 'server')), ) def device(self): return self.hbase_host()