def relMap(self):
"""Create a relationship map.
"""
relmap = RelationshipMap()
relmap.relname = self.relname
relmap.compname = self.compname
return relmap
def relMap(self):
"""Create a relationship map.
"""
relmap = RelationshipMap()
relmap.relname = self.relname
relmap.compname = self.compname
return relmap
def process(self, device, results, log):
log.info("Processing %s for device %s", self.name(), device.id)
getdata, tabledata = results
maps = []
ocpRelMap = RelationshipMap(
relname='raritanOCPs',
compname=self.compname,
modname='ZenPacks.community.Raritan.RaritanOCP')
for snmpindex, row in tabledata.get(
'overCurrentProtectorConfigurationTable', {}).items():
ocpData = {}
snmpindex = snmpindex.strip('.')
log.info('snmpindex:{}'.format(snmpindex))
log.info('row:{}'.format(row))
title = row.get('overCurrentProtectorLabel')
name = row.get('overCurrentProtectorName')
if name:
title = '{} ({})'.format(title, name)
ocpData['id'] = self.prepId(title)
ocpData['title'] = title
ocpData['snmpindex'] = snmpindex
ocpSensors = tabledata.get(
'overCurrentProtectorSensorConfigurationTable', {})
log.debug('sensors:{}'.format(ocpSensors))
for sensor, sensorNum in self.sensorType.items():
sensorIndex = '{}.{}'.format(snmpindex, sensorNum)
ocpSensor = ocpSensors[sensorIndex]
ocpData['{}_units'.format(
sensor)] = ocpSensor['overCurrentProtectorSensorUnits']
ocpData['{}_digits'.format(sensor)] = ocpSensor[
'overCurrentProtectorSensorDecimalDigits']
log.debug('sensorData:{}'.format(ocpData))
ocpRelMap.append(
ObjectMap(
compname=self.compname,
modname='ZenPacks.community.Raritan.RaritanOCP',
data=ocpData,
))
maps.append(ocpRelMap)
maps.extend([
ocpRelMap,
])
return maps
def processTblTrays(self, tblTrays, log):
mapTrays = RelationshipMap(
modname='ZenPacks.TwoNMS.PrinterMIB.PrinterTray',
relname='printermibtray')
# iterate each tray and translate the mibs
for trayId, trayData in tblTrays.iteritems():
# create an input Tray object
trayObj = self.objectMap(trayData)
trayObj.id = self.prepId(trayId)
# translate prtInputTypeTC
try:
if (self.PrtInputTypeTC[str(trayObj.prtInputTypeTC)] != None):
trayObj.prtInputType = self.PrtInputTypeTC[str(
trayObj.prtInputTypeTC)]
except AttributeError:
log.warn("Tray does not support the prtInputTypeTC oid")
trayObj.prtInputType = self.PrtInputTypeTC['na']
#continue
# translate PrtCapacityUnitTC
try:
if (self.PrtCapacityUnitTC[str(trayObj.prtCapacityUnitTC)] !=
None):
trayObj.prtCapacityUnit = self.PrtCapacityUnitTC[str(
trayObj.prtCapacityUnitTC)]
except AttributeError:
log.warn("Tray does not support the PrtCapacityUnitTC oid")
trayObj.prtCapacityUnit = self.PrtCapacityUnitTC['na']
#continue
# add a percentage value of the usage
try:
trayObj.usagepct = self.calculateUsagePct(
trayObj.prtInputCurrentLevel, trayObj.prtInputMaxCapacity,
log)
except:
mapTemp.usagepct = 'na'
# assign object to the relationsipMap
trayObj.modname = "ZenPacks.TwoNMS.PrinterMIB.PrinterTray"
trayObj.supplyId = trayObj.id
trayObj.snmpindex = trayObj.id
log.debug("New input tray found: %s", trayObj)
mapTrays.append(trayObj)
return mapTrays
def getAppsRelMaps(self, apps):
obj_maps = []
rel_maps = []
for data in apps:
app_id = prepId(data['name'])
obj_maps.append(
ObjectMap(data=dict(
id=app_id,
title=data['name'],
cfName=data['name'],
cfVersion=data['version'],
cfState=data['state'],
cfMetaCreated=data['meta']['created'],
cfMetaVersion=data['meta']['version'],
setCFURIs=data['uris'],
setCFServices=data['services'],
cfStagingModel=data['staging']['model'],
cfStagingStack=data['staging']['stack'],
modeled_instances=len(data['instances']),
modeled_runningInstances=data['runningInstances'],
modeled_resourcesMemory=data['resources']['memory'] *
1048576,
modeled_resourcesDisk=data['resources']['disk'] * 1048576,
modeled_resourcesFDS=data['resources']['fds'])))
rel_maps.extend(
self.getAppInstancesRelMaps(app_id, data['instances'],
'cfApps/{0}'.format(app_id)))
return [
RelationshipMap(relname='cfApps',
modname='ZenPacks.zenoss.CloudFoundry.App',
objmaps=obj_maps)
] + rel_maps
def getProvisionedServicesRelMaps(self, services):
obj_maps = []
for data in services:
obj_maps.append(
ObjectMap(data=dict(
id=prepId(data['name']),
title=data['name'],
cfName=data['name'],
cfVersion=data['version'],
cfVendor=data['vendor'],
cfType=data['type'],
cfTier=data['tier'],
cfMetaCreated=data['meta']['created'],
cfMetaUpdated=data['meta']['updated'],
cfMetaVersion=data['meta']['version'],
setCFMetaTags=data['meta']['tags'],
setCFProperties=data['properties'],
)))
return [
RelationshipMap(
relname='cfProvisionedServices',
modname='ZenPacks.zenoss.CloudFoundry.ProvisionedService',
objmaps=obj_maps)
]
def getSystemServicesRelMaps(self, services):
obj_maps = []
for type, type_data in services.items():
for name, name_data in type_data.items():
for version, data in name_data.items():
obj_maps.append(
ObjectMap(data=dict(
id=prepId(data['id']),
title=name,
cfId=data['id'],
cfName=name,
cfVersion=data['version'],
cfDescription=data['description'],
cfVendor=data['vendor'],
cfType=type,
setCFTiers=data['tiers'],
)))
return [
RelationshipMap(
relname='cfSystemServices',
modname='ZenPacks.zenoss.CloudFoundry.SystemService',
objmaps=obj_maps)
]
def getFrameworksRelMaps(self, frameworks):
rel_maps = []
obj_maps = []
for name, data in frameworks.items():
framework_id = prepId(name)
obj_maps.append(
ObjectMap(data=dict(
id=framework_id,
title=name,
cfName=name,
setCFDetection=data['detection'],
)))
rel_maps.extend(
self.getRuntimesRelMaps(
data['runtimes'], 'cfFrameworks/{0}'.format(framework_id)))
rel_maps.extend(
self.getAppServersRelMaps(
data['appservers'],
'cfFrameworks/{0}'.format(framework_id)))
return [
RelationshipMap(relname='cfFrameworks',
modname='ZenPacks.zenoss.CloudFoundry.Framework',
objmaps=obj_maps)
] + rel_maps
def getAppInstancesRelMaps(self, appId, instances, compname):
obj_maps = []
for data in instances:
instance_id = prepId(str(data['index']))
stats = data['stats']['stats']
obj_maps.append(
ObjectMap(data=dict(
id='{0}_{1}'.format(appId, instance_id),
title=instance_id,
cfIndex=data['index'],
cfState=data['state'],
cfSince=data['since'],
cfHost=stats['host'],
cfPort=stats['port'],
cfCores=stats['cores'],
modeled_quotaMemory=stats['mem_quota'],
modeled_quotaDisk=stats['disk_quota'],
modeled_usageCPU=stats['usage']['cpu'],
modeled_usageMemory=stats['usage']['mem'] * 1024,
modeled_usageDisk=stats['usage']['disk'] * 1024,
)))
return [
RelationshipMap(compname=compname,
relname='cfAppInstances',
modname='ZenPacks.zenoss.CloudFoundry.AppInstance',
objmaps=obj_maps)
]
def getSpareDisksRelMaps(self, spares, compname):
obj_maps = []
for name, data in spares.iteritems():
spare_id = prepId(name)
obj_maps.append(ObjectMap(data=dict(
id = spare_id,
sparedisk_name = name,
node = data['node'],
disk_uid = data['disk_uid'],
raid_state = data['raid_state'],
raid_type = data['raid_type'],
bay = data['bay'],
byte_per_sector = data['byte_per_sector'],
disk_type = data['disk_type'],
rpm = data['rpm'],
model = data['model'],
serialnr = data['serialnr'],
firmware = data['firmware'],
poweron_hours = data['poweron_hours'],
grown_defect_list_count = data['grown_defect_list_count'],
total_bytes = data['total_bytes'],
)))
return [RelationshipMap(
compname = compname,
relname = 'spare_disks',
modname = 'ZenPacks.CS.NetApp.SevenMode.SpareDisk',
objmaps = obj_maps)]
def get_zones_rel_maps(self, zones_response):
zone_maps = []
for zone in zones_response.get('zone', []):
zone_id = self.prepId('zone%s' % zone['id'])
zone_maps.append(
ObjectMap(data=dict(
id=zone_id,
title=zone.get('name', zone_id),
cloudstack_id=zone['id'],
allocation_state=zone.get('allocationstate', ''),
guest_cidr_address=zone.get('guestcidraddress', ''),
dhcp_provider=zone.get('dhcpprovider', ''),
dns1=zone.get('dns1', ''),
dns2=zone.get('dns2', ''),
internal_dns1=zone.get('internaldns1', ''),
internal_dns2=zone.get('internaldns2', ''),
network_type=zone.get('networktype', ''),
security_groups_enabled=zone.get('securitygroupsenabled',
''),
vlan=zone.get('vlan', ''),
zone_token=zone.get('zonetoken', ''),
)))
yield RelationshipMap(relname='zones',
modname='ZenPacks.zenoss.CloudStack.Zone',
objmaps=zone_maps)
def getRedisDbRelMap(self, device, dbData, log):
rel_maps = []
log.info('In getRedisDbRelMap - dbData is %s \n' % (dbData))
for k, v in dbData.iteritems():
compname = 'redisPorts/%s' % (k)
object_maps = []
for k1, v1 in v.iteritems():
db_number = int(k1[-1])
db_avg_ttl = v1.get('avg_ttl', None)
db_keys = v1.get('keys', None)
object_maps.append(
ObjectMap(
data={
'id': k + '_' + self.prepId(k1),
'title': k + '_' + self.prepId(k1),
'db_number': db_number,
'db_avg_ttl': db_avg_ttl,
'db_keys': db_keys,
}))
rel_maps.append(
RelationshipMap(
compname=compname,
relname='redisDbs',
modname='ZenPacks.community.zplib.Redis.RedisDb',
objmaps=object_maps))
return rel_maps
def volumes_rm(region_id, volumes):
'''
Return volumes RelationshipMap given region_id and a VolumeInfo
ResultSet.
'''
volume_data = []
for volume in volumes:
if volume.attach_data.instance_id:
instance_id = prepId(volume.attach_data.instance_id)
else:
instance_id = None
volume_data.append({
'id': prepId(volume.id),
'title': name_or(volume.tags, volume.id),
'volume_type': volume.type,
'create_time': volume.create_time,
'size': volume.size / (1024**3),
'iops': volume.iops,
'status': volume.status,
'attach_data_status': volume.attach_data.status,
'attach_data_devicepath': volume.attach_data.device,
'setInstanceId': instance_id,
'setZoneId': volume.zone,
})
return RelationshipMap(compname='regions/%s' % region_id,
relname='volumes',
modname=MODULE_NAME['EC2Volume'],
objmaps=volume_data)
def instances_rm(region_id, reservations):
'''
Return instances RelationshipMap given region_id and an InstanceInfo
ResultSet.
'''
instance_data = []
for instance in chain.from_iterable(r.instances for r in reservations):
zone_id = prepId(instance.placement) if instance.placement else None
subnet_id = prepId(instance.subnet_id) if instance.subnet_id else None
instance_data.append({
'id': prepId(instance.id),
'title': name_or(instance.tags, instance.id),
'instance_id': instance.id,
'public_dns_name': instance.public_dns_name,
'private_ip_address': instance.private_ip_address,
'image_id': instance.image_id,
'instance_type': instance.instance_type,
'launch_time': instance.launch_time,
'state': instance.state,
'platform': getattr(instance, 'platform', ''),
'detailed_monitoring': instance.monitored,
'setZoneId': zone_id,
'setVPCSubnetId': subnet_id,
})
return RelationshipMap(compname='regions/%s' % region_id,
relname='instances',
modname=MODULE_NAME['EC2Instance'],
objmaps=instance_data)
def vpc_subnets_rm(region_id, subnets):
'''
Return vpc_subnets RelationshipMap given region_id and a SubnetInfo
ResultSet.
'''
vpc_subnet_data = []
for subnet in subnets:
vpc_subnet_data.append({
'id':
prepId(subnet.id),
'title':
name_or(subnet.tags, subnet.id),
'available_ip_address_count':
subnet.available_ip_address_count,
'cidr_block':
subnet.cidr_block,
'defaultForAz':
to_boolean(subnet.defaultForAz),
'mapPublicIpOnLaunch':
to_boolean(subnet.mapPublicIpOnLaunch),
'state':
subnet.state,
'setVPCId':
subnet.vpc_id,
'setZoneId':
subnet.availability_zone,
})
return RelationshipMap(compname='regions/%s' % region_id,
relname='vpc_subnets',
modname=MODULE_NAME['EC2VPCSubnet'],
objmaps=vpc_subnet_data)
def _node_manager_oms(self, data, device):
"""
Build Node Manager object maps.
"""
node_mgr_oms = []
# Find live node managers names in the jmx output.
live_node_mgrs = []
for bean in data['beans']:
if bean['name'] == 'Hadoop:service=ResourceManager,name=RMNMInfo':
live_node_mgrs = bean.setdefault('LiveNodeManagers', [])
break
if live_node_mgrs:
live_node_mgrs = json.loads(live_node_mgrs)
# Build Node Manager oms given the data found in jmx.
comp = self._dict_components['HadoopNodeManager']
for node_mgr in live_node_mgrs:
node_mgr_address = prep_ip(device, node_mgr['NodeHTTPAddress'])
node_mgr_oms.append(
ObjectMap({
'id':
prepId(device.id + NAME_SPLITTER + node_mgr_address),
'title':
node_mgr_address,
'node_type':
comp[0]
}))
return RelationshipMap(relname=comp[1],
modname=MODULE_NAME['HadoopNodeManager'],
objmaps=node_mgr_oms)
def get_inputs(self, results, log):
input_maps = []
getdata, tabledata = results
for snmpindex, row in tabledata.get('upsPhaseInputTable', {}).items():
inputData = {}
snmpindex = snmpindex.strip('.')
log.debug('snmpindex:{}'.format(snmpindex))
log.debug('row:{}'.format(row))
inputIndex = row.get('upsPhaseInputTableIndex')
name = row.get('upsPhaseInputName')
inputData['id'] = self.prepId('Input_{}'.format(inputIndex))
inputData['title'] = self.prepId(name)
inputData['snmpindex'] = snmpindex
inputData['index'] = row.get('upsPhaseInputTableIndex')
inputData['numPhases'] = row.get('upsPhaseNumInputPhases')
inputData['orientation'] = self.voltageOrMap[int(
row.get('upsPhaseInputVoltageOrientation'))]
inputData['inputType'] = self.typeMap[int(
row.get('upsPhaseInputType'))]
input_maps.append(inputData)
inputRelMap = RelationshipMap(
relname='powerNetInputs',
modname='ZenPacks.community.PowerNet.PowerNetInput',
compname=self.compname,
objmaps=input_maps,
)
log.debug('get_inputs: {}'.format(inputRelMap))
return inputRelMap
def getQueueRelMap(self, queues_string, compname):
object_maps = []
for queue_string in queues_string.split('\n'):
if not queue_string.strip():
continue
name, durable, auto_delete, arguments = \
re.split(r'\s+', queue_string)
if re.search(r'true', durable, re.I):
durable = True
else:
durable = False
if re.search(r'true', auto_delete, re.I):
auto_delete = True
else:
auto_delete = False
object_maps.append(
ObjectMap(
data={
'id': prepId(name),
'title': name,
'durable': durable,
'auto_delete': auto_delete,
'arguments': arguments,
}))
return RelationshipMap(
compname=compname,
relname='rabbitmq_queues',
modname='ZenPacks.zenoss.RabbitMQ.RabbitMQQueue',
objmaps=object_maps)
def process(self, device, results, log):
"""
Must return one of :
- None, changes nothing. Good in error cases.
- A RelationshipMap, for the device to component information
- An ObjectMap, for the device device information
- A list of RelationshipMaps and ObjectMaps, both
"""
log.debug('Process results: {}'.format(results))
bamboo_data = results.get('bamboo', '')
rm = []
if bamboo_data:
bamboo_maps = []
om_bamboo = ObjectMap()
bamboo_name = 'Bamboo {}'.format(bamboo_data['version'])
om_bamboo.id = self.prepId(bamboo_name)
om_bamboo.title = bamboo_name
bamboo_maps.append(om_bamboo)
rm.append(RelationshipMap(relname='bambooServers',
modname='ZenPacks.community.Bamboo.BambooServer',
compname='',
objmaps=bamboo_maps))
log.debug('{}: process maps:{}'.format(device.id, rm))
return rm
def get_pods_rel_maps(self, pods_response):
pod_maps = {}
for pod in pods_response.get('pod', []):
zone_id = self.prepId('zone%s' % pod['zoneid'])
pod_id = self.prepId('pod%s' % pod['id'])
compname = 'zones/%s' % zone_id
pod_maps.setdefault(compname, [])
pod_maps[compname].append(
ObjectMap(data=dict(
id=pod_id,
title=pod.get('name', pod_id),
cloudstack_id=pod['id'],
allocation_state=pod.get('allocationstate', ''),
start_ip=pod.get('startip', ''),
end_ip=pod.get('endip', ''),
netmask=pod.get('netmask', ''),
gateway=pod.get('gateway', ''),
)))
for compname, obj_maps in pod_maps.items():
yield RelationshipMap(compname=compname,
relname='pods',
modname='ZenPacks.zenoss.CloudStack.Pod',
objmaps=obj_maps)
def add_maps(self, res, ds):
"""
Check for added/removed tables and return a RelationshipMap if
any changes took place. Otherwise return empty list.
"""
try:
res = json.loads(res)
except ValueError:
log.error(
'Error parsing collected data for {} monitoring template'.
format(ds.template))
res = []
if not res:
return []
tables_update = set(table['name'] for table in res.get('table'))
self.added = list(tables_update.difference(set(ds.table_ids)))
self.removed = list(set(ds.table_ids).difference(tables_update))
if self.added or self.removed:
tables_oms = []
for table in tables_update:
tables_oms.append(
ObjectMap({
'id': prepId(table),
'title': table
}))
return [
RelationshipMap(relname='hbase_tables',
modname=MODULE_NAME['HBaseTable'],
objmaps=tables_oms)
]
return []
def olsonInterface(self, manageIp, macaddr):
om = ObjectMap({},
compname="os",
modname="Products.ZenModel.IpInterface")
om.id = self.prepId("eth0")
om.title = om.id
om.interfaceName = om.id
om.description = "Manually Kludged"
om.type = "manual"
om.speed = 10000000
om.mtu = 1500
om.ifindex = "1"
om.adminStatus = 1
om.operStatus = 1
om.monitor = False
om.setIpAddresses = [
manageIp,
]
om.macaddress = macaddr
# om.lockFromDeletion()
# om.lockFromUpdates()
return RelationshipMap(relname="interfaces",
compname="os",
modname="Products.ZenModel.IpInterface",
objmaps=[
om,
])
def get_clusters_rel_maps(self, clusters_response):
cluster_maps = {}
for cluster in clusters_response.get('cluster', []):
zone_id = self.prepId('zone%s' % cluster['zoneid'])
pod_id = self.prepId('pod%s' % cluster['podid'])
cluster_id = self.prepId('cluster%s' % cluster['id'])
compname = 'zones/%s/pods/%s' % (zone_id, pod_id)
cluster_maps.setdefault(compname, [])
cluster_maps[compname].append(
ObjectMap(data=dict(
id=cluster_id,
title=cluster.get('name', cluster_id),
cloudstack_id=cluster['id'],
allocation_state=cluster.get('allocationstate', ''),
cluster_type=cluster.get('clustertype', ''),
hypervisor_type=cluster.get('hypervisortype', ''),
managed_state=cluster.get('managedstate', ''),
)))
for compname, obj_maps in cluster_maps.items():
yield RelationshipMap(compname=compname,
relname='clusters',
modname='ZenPacks.zenoss.CloudStack.Cluster',
objmaps=obj_maps)
def process(self, device, results, log):
log.info(
'Modeler %s processing data for device %s',
self.name(), device.id
)
maps = collections.OrderedDict([
('hbase_tables', [])
])
try:
data = json.loads(results)
except ValueError:
log.error('HBaseTableCollector: Error parsing collected data')
return
# List of tables
tables_oms = []
if data: # Check if there are any tables.
for table in data["table"]:
tables_oms.append(self._table_om(table))
maps['hbase_tables'].append(RelationshipMap(
relname='hbase_tables',
modname=MODULE_NAME['HBaseTable'],
objmaps=tables_oms))
log.info(
'Modeler %s finished processing data for device %s',
self.name(), device.id
)
return list(chain.from_iterable(maps.itervalues()))
def model_connectors(self, results, log):
log.debug('model_connectors data: {}'.format(results))
rings = {}
for entry in results:
ring = entry['ring']
if ring not in rings:
rings[ring] = []
rings[ring].append(entry)
rm = []
for ring, connectors in rings.items():
compname = 'scalitySupervisors/Supervisor/scalityRings/{}'.format(
ring)
connector_maps = []
for connector in connectors:
volume_id = connector['id']
om_connector = ObjectMap()
om_connector.id = self.prepId(volume_id)
om_connector.title = connector['name']
om_connector.connector_id = volume_id
om_connector.protocol = connector['protocol']
om_connector.detached = connector['detached']
om_connector.address = connector['address']
om_connector.ring = connector['ring']
connector_maps.append(om_connector)
rm.append(
RelationshipMap(
compname=compname,
relname='scalityConnectors',
modname='ZenPacks.community.Scality.ScalityConnector',
objmaps=connector_maps))
return rm
def get_oss_rel_maps(self, es_response):
oss = getattr(self.device, 'zESOssNodes', None)
ossList = oss.split(",")
rm = []
fs_dict = es_response.get('host', {})
nw_data = self.filter_server(fs_dict, 'oss')
i = 0
for key, val in nw_data.items():
log.debug("XXX KEY: %s and VALUE: %r", key, val)
if val.get('id') is None:
val['id'] = str(key)
if val.get('title') is None:
val['title'] = str(key)
try:
val['management_address'] = ossList[i]
except IndexError:
val['management_address'] = 'null'
# Create Object Map
om = self.objectMap()
om.updateFromDict(val)
# Update Object Map to RelationShip Map
rm.append(om)
i += 1
return RelationshipMap(
relname=EXMODEL['objectStorageServers']['relname'],
modname=EXMODEL['objectStorageServers']['modname'],
objmaps=rm)
def process(self, device, results, log):
log.info("Modeler %s processing data for device %s", self.name(),
device.id)
rm = self.relMap()
for service in results.get('Win32_Service', ()):
om = self.objectMap()
om.id = self.prepId(service.Name)
om.serviceName = service.Name
om.caption = service.Caption
om.setServiceClass = {
'name': service.Name,
'description': service.Caption
}
om.pathName = service.PathName
om.serviceType = service.ServiceType
om.startMode = service.StartMode
om.startName = service.StartName
om.description = service.Description
rm.append(om)
maps = []
maps.append(
RelationshipMap(relname="winrmservices", compname='os',
objmaps=[]))
maps.append(rm)
return maps
def _validate_datamap(device,
datamap,
relname=None,
compname=None,
modname=None,
parentId=None):
if isinstance(datamap, RelationshipMap):
log.debug('_validate_datamap: got valid RelationshipMap')
elif relname:
log.debug('_validate_datamap: build relationship_map using relname')
datamap = RelationshipMap(relname=relname,
compname=compname,
modname=modname,
objmaps=datamap,
parentId=parentId)
elif isinstance(datamap, IncrementalDataMap):
log.debug('_validate_datamap: got valid IncrementalDataMap')
elif isinstance(datamap, ObjectMap):
log.debug('_validate_datamap: got valid ObjectMap')
datamap = IncrementalDataMap(device, datamap)
else:
log.debug('_validate_datamap: build object_map')
datamap = ObjectMap(datamap, compname=compname, modname=modname)
datamap = IncrementalDataMap(device, datamap)
return datamap
def process(self, device, results, log):
log.debug(' Start of process - results is %s \n' % (results))
maps = []
datastores = []
for datastore in results:
datastoreDict = {}
datastoreDict['id'] = self.prepId(datastore.summary.name)
datastoreDict['title'] = datastore.summary.name
datastoreDict['type'] = datastore.summary.type
datastoreDict['capacity'] = long(datastore.summary.capacity)
if not int(datastore.summary.accessible) == 1:
log.warning('Datastore %s of device %s is not accessible' %
(datastoreDict['id'], device.id))
continue
datastores.append(ObjectMap(data=datastoreDict))
log.debug(' datastoreDict is %s \n' % (datastoreDict))
log.debug('VM Datastore is %s \n' % (datastoreDict['id']))
maps.append(
RelationshipMap(
relname='esxiDatastore',
modname=
'ZenPacks.community.VMwareESXiMonitorPython.ESXiDatastore',
objmaps=datastores))
return maps
def model_nodes(self, results, log):
log.debug('model_nodes data: {}'.format(results))
rings = {}
for entry in results:
ring_name = entry['ring']
if ring_name not in rings:
rings[ring_name] = []
rings[ring_name].append(entry)
rm = []
for ring, nodes in rings.items():
compname = 'scalitySupervisors/Supervisor/scalityRings/{}'.format(
ring)
node_maps = []
for node in nodes:
om_node = ObjectMap()
node_name = node['name']
om_node.id = self.prepId('{}_{}'.format(ring, node_name))
om_node.title = node_name
om_node.ring = ring
# TODO: not safe
om_node.admin_endpoint = '{}:{}'.format(
node['admin_address'], node['admin_port'])
om_node.chord_endpoint = '{}:{}'.format(
node['chord_address'], node['chord_port'])
om_node.server_endpoint = node['server']
node_maps.append(om_node)
rm.append(
RelationshipMap(
compname=compname,
relname='scalityNodes',
modname='ZenPacks.community.Scality.ScalityNode',
objmaps=node_maps))
return rm
def model_servers(self, servers, log):
log.debug('model_servers data: {}'.format(servers))
server_maps = []
for server in servers:
server_name = server['name']
server_ip = server['management_ip_address']
om_server = ObjectMap()
# TODO: Use something else than IP address to ID the server
om_server.id = self.prepId(server_ip)
om_server.title = server_name
om_server.server_type = server['server_type']
om_server.ip_address = server_ip
om_server.zone = server['zone']
# TODO: check usage of id in datasource
om_server.server_id = server['id']
# TODO: BUG since 8.x : TypeError: string indices must be integers
rings = server['rings']
if rings and isinstance(rings[0], dict):
# Supervisor 7.4.6.1
om_server.rings = ', '.join(
sorted([r['name'] for r in server['rings']]))
else:
# Supervisor 8.3.0.5
om_server.rings = ', '.join(sorted(server['rings']))
om_server.roles = ', '.join(sorted(server['roles']))
om_server.disks = ', '.join(server['disks'])
server_maps.append(om_server)
return RelationshipMap(
compname='scalitySupervisors/Supervisor',
relname='scalityServers',
modname='ZenPacks.community.Scality.ScalityServer',
objmaps=server_maps)
def test_updateRelationship(self):
"""Test relationship creation."""
rm = RelationshipMap(
compname="os",
relname="interfaces",
modname="Products.ZenModel.IpInterface",
objmaps=[
ObjectMap({"id": "eth0"}),
ObjectMap({"id": "eth1"}),
])
changed = self.service.remote_applyDataMaps(self.device.id, [rm])
self.assertTrue(
changed,
"device.os.interfaces not changed by first RelationshipMap")
self.assertEqual(
2, self.device.os.interfaces.countObjects(),
"wrong number of interfaces created by first RelationshipMap")
changed = self.service.remote_applyDataMaps(self.device.id, [rm])
self.assertFalse(
changed,
"device.os.interfaces changed by second RelationshipMap")
rm.maps = rm.maps[:1]
changed = self.service.remote_applyDataMaps(self.device.id, [rm])
self.assertTrue(
changed,
"device.os.interfaces not changed by trimmed RelationshipMap")
self.assertEquals(
1, self.device.os.interfaces.countObjects(),
"wrong number of interfaces after trimmed RelationshipMap")
rm.maps = []
changed = self.service.remote_applyDataMaps(self.device.id, [rm])
self.assertTrue(
changed,
"device.os.interfaces not changed by empty RelationshipMap")
self.assertEquals(
0, self.device.os.interfaces.countObjects(),
"wrong number of interfaces after empty RelationshipMap")
def processTblTrays(self, tblTrays, log):
mapTrays = RelationshipMap(modname='ZenPacks.TwoNMS.PrinterMIB.PrinterTray', relname='printermibtray')
# iterate each tray and translate the mibs
for trayId, trayData in tblTrays.iteritems():
# create an input Tray object
trayObj = self.objectMap(trayData)
trayObj.id = self.prepId(trayId)
# translate prtInputTypeTC
try:
if (self.PrtInputTypeTC[str(trayObj.prtInputTypeTC)] != None):
trayObj.prtInputType = self.PrtInputTypeTC[str(trayObj.prtInputTypeTC)]
except AttributeError:
log.warn("Tray does not support the prtInputTypeTC oid")
trayObj.prtInputType = self.PrtInputTypeTC['na']
#continue
# translate PrtCapacityUnitTC
try:
if (self.PrtCapacityUnitTC[str(trayObj.prtCapacityUnitTC)] != None):
trayObj.prtCapacityUnit = self.PrtCapacityUnitTC[str(trayObj.prtCapacityUnitTC)]
except AttributeError:
log.warn("Tray does not support the PrtCapacityUnitTC oid")
trayObj.prtCapacityUnit = self.PrtCapacityUnitTC['na']
#continue
# add a percentage value of the usage
try:
trayObj.usagepct = self.calculateUsagePct(trayObj.prtInputCurrentLevel, trayObj.prtInputMaxCapacity, log)
except:
mapTemp.usagepct = 'na'
# assign object to the relationsipMap
trayObj.modname = "ZenPacks.TwoNMS.PrinterMIB.PrinterTray"
trayObj.supplyId = trayObj.id
trayObj.snmpindex = trayObj.id
log.debug("New input tray found: %s", trayObj)
mapTrays.append(trayObj)
return mapTrays
def process(self, device, results, log):
maps = []
top_rm = RelationshipMap(relname='testTopComponents')
maps.append(top_rm)
for i in range(device.zTestCalcPerfTopComponentsPerDevice):
top_rm.append(
ObjectMap(data={
'id': 'top{}'.format(i),
},
modname='ZenPacks.test.CalcPerfScale.TestTopComponent'))
bottom_rm = RelationshipMap(
compname='testTopComponents/top{}'.format(i),
relname='testBottomComponents')
for j in range(device.zTestCalcPerfBottomComponentsPerTopComponent):
bottom_rm.append(
ObjectMap(data={
'id': 'top{}-bottom{}'.format(i, j),
},
modname='ZenPacks.test.CalcPerfScale.TestBottomComponent'))
maps.append(bottom_rm)
return maps
def process(self, device, results, log):
log.info(
"Modeler %s processing data for device %s",
self.name(),
device.id
)
maps = list()
pools = dict()
get_regex = r'^(?P<ds>\S+)\t(?P<key>\S+)\t(?P<value>\S+)\t\S+$'
for line in results.splitlines():
get_match = re.match(get_regex, line)
if get_match:
ds = get_match.group('ds')
pool = ds.split('/')[0]
key = get_match.group('key')
value = get_match.group('value')
if pool not in pools:
pools[pool] = dict()
if ds not in pools[pool]:
pools[pool][ds] = dict()
if value.endswith('%') or re.match(r'^\d+\.\d{2}x$', value):
value = value[:-1]
elif value == '-':
value = None
elif key == 'type':
pools[pool][ds]['zDsType'] = value
continue
pools[pool][ds][key] = value
booleans = [
'atime',
'defer_destroy',
'mounted',
'nbmand',
'overlay',
'relatime',
'setuid',
'utf8only',
'vscan',
'zoned',
]
floats = [
'compressratio',
'refcompressratio',
]
ints = [
'available',
'copies',
'filesystem_count',
'filesystem_limit',
'logicalreferenced',
'logicalused',
'quota',
'recordsize',
'referenced',
'refquota',
'refreservation',
'reservation',
'snapshot_count',
'snapshot_limit',
'used',
'usedbychildren',
'usedbydataset',
'usedbyrefreservation',
'usedbysnapshots',
'userrefs',
'volblocksize',
'volsize',
'written',
]
times = [
'creation',
]
prefixes = {
'filesystem': 'fs',
'volume': 'vol',
'snapshot': 'snap'
}
suffixes = {
'filesystem': '',
'volume': 'Vol',
'snapshot': 'Snap'
}
time_format = '%Y-%m-%d %H:%M:%S'
rm = RelationshipMap(
relname='zfsdatasets',
modname='ZenPacks.daviswr.ZFS.ZFSDataset'
)
ignore_names_regex = getattr(device, 'zZFSDatasetIgnoreNames', '')
if ignore_names_regex:
log.info('zZFSDatasetIgnoreNames set to %s', ignore_names_regex)
ignore_types = getattr(device, 'zZFSDatasetIgnoreTypes', list())
if ignore_types:
log.info('zZFSDatasetIgnoreTypes set to %s', str(ignore_types))
ignore_pools_regex = getattr(device, 'zZPoolIgnoreNames', '')
if ignore_pools_regex:
log.info('zZPoolIgnoreNames set to %s', ignore_pools_regex)
# Dataset components
for pool in pools:
if ignore_pools_regex and re.match(ignore_pools_regex, pool):
log.debug('Skipping pool %s due to zZPoolIgnoreNames', pool)
continue
rm = RelationshipMap(
compname='zpools/pool_{0}'.format(pool),
relname='zfsDatasets',
modname='ZenPacks.daviswr.ZFS.ZFSDataset'
)
datasets = pools[pool]
for ds in datasets:
if ignore_names_regex and re.match(ignore_names_regex, ds):
log.debug(
'Skipping dataset %s due to zZFSDatasetIgnoreNames',
ds
)
continue
elif ignore_types \
and datasets[ds].get('zDsType', '') in ignore_types:
log.debug(
'Skipping dataset %s due to zZFSDatasetIgnoreTypes',
ds
)
continue
comp = dict()
for key in datasets[ds]:
if key in booleans:
comp[key] = True \
if ('on' == datasets[ds][key]
or 'yes' == datasets[ds][key]) \
else False
elif key in floats:
comp[key] = float(datasets[ds][key])
elif key in ints:
comp[key] = int(datasets[ds][key])
elif key in times:
comp[key] = time.strftime(
time_format,
time.localtime(int(datasets[ds][key]))
)
else:
comp[key] = datasets[ds][key]
prefix = prefixes.get(comp.get('zDsType'), '')
suffix = suffixes.get(comp.get('zDsType'), 'Dataset')
# Pool name should already be part of the dataset name,
# making it unique
comp['id'] = self.prepId('{0}_{1}'.format(prefix, ds))
comp['title'] = ds
log.debug('Found ZFS %s: %s', comp.get('type', ''), comp['id'])
mod = 'ZenPacks.daviswr.ZFS.ZFS{0}'.format(suffix)
rm.append(ObjectMap(
modname=mod,
data=comp
))
maps.append(rm)
log.debug(
'ZFS RelMap:\n%s',
str(maps)
)
return maps
def test_subclass_catalogs(self):
rm = RelationshipMap(
modname="ZenPacks.test.ClassProxies.MyComponent",
relname="myComponents")
rm.extend([
ObjectMap(
modname="ZenPacks.test.ClassProxies.MyComponent",
data={
"id": "myComponent-1",
"idx_device": "myComponent-1",
"idx_global": "myComponent-1"}),
ObjectMap(
modname="ZenPacks.test.ClassProxies.MyComponent",
data={
"id": "myComponent-2",
"idx_device": "myComponent-2",
"idx_global": "myComponent-2"}),
ObjectMap(
modname="ZenPacks.test.ClassProxies.MyComponentSub1",
data={
"id": "myComponent1-1",
"idx_device": "myComponent1-1",
"idx_global": "myComponent1-1",
"idx_device_sub1": "myComponent1-1",
"idx_global_sub1": "myComponent1-1"}),
ObjectMap(
modname="ZenPacks.test.ClassProxies.MyComponentSub1",
data={
"id": "myComponent1-2",
"idx_device": "myComponent1-2",
"idx_global": "myComponent1-2",
"idx_device_sub1": "myComponent1-2",
"idx_global_sub1": "myComponent1-2"}),
ObjectMap(
modname="ZenPacks.test.ClassProxies.MyComponentSub2",
data={
"id": "myComponent2-1",
"idx_device": "myComponent2-1",
"idx_global": "myComponent2-1",
"idx_device_sub2": "myComponent2-1",
"idx_global_sub2": "myComponent2-1"}),
ObjectMap(
modname="ZenPacks.test.ClassProxies.MyComponentSub2",
data={
"id": "myComponent2-2",
"idx_device": "myComponent2-2",
"idx_global": "myComponent2-2",
"idx_device_sub2": "myComponent2-2",
"idx_global_sub2": "myComponent2-2"})])
# Describe what all of the catalogs should look like.
component_ids = [
"myComponent-1", "myComponent1-1", "myComponent2-1",
"myComponent-2", "myComponent1-2", "myComponent2-2",
]
device_expected = {
"MyComponent": {"idx_device": component_ids},
"MyComponentSub1": {"idx_device_sub1": ["myComponent1-1", "myComponent1-2"]},
"MyComponentSub2": {"idx_device_sub2": ["myComponent2-1", "myComponent2-2"]}}
from ZenPacks.test.ClassProxies.MyComponent import MyComponent
from ZenPacks.test.ClassProxies.MyComponentSub1 import MyComponentSub1
from ZenPacks.test.ClassProxies.MyComponentSub2 import MyComponentSub2
global_expected = {
MyComponent: {"idx_global": component_ids * 2},
MyComponentSub1: {"idx_global_sub1": ["myComponent1-1", "myComponent1-2"] * 2},
MyComponentSub2: {"idx_global_sub2": ["myComponent2-1", "myComponent2-2"] * 2}}
def verify_all_catalogs():
for device in devices:
for catalog_name, indexes in device_expected.items():
for index_name, expected_values in indexes.items():
self.assertItemsEqual(
expected_values,
[getattr(x, index_name) for x in device.search(catalog_name)])
for class_, indexes in global_expected.items():
for index_name, expected_values in indexes.items():
self.assertItemsEqual(
expected_values,
[getattr(x, index_name) for x in class_.class_search(self.dmd)])
# Create devices and components
devices = [
create_device(
self.dmd,
zPythonClass="ZenPacks.test.ClassProxies.MyDevice",
device_id="test-device{}".format(x),
datamaps=[rm])
for x in (1, 2)]
# Verify that all catalogs are correct after initial modeling.
verify_all_catalogs()
# Delete catalogs.
self.dmd.Devices._delObject("ZenPacks_test_ClassProxies_MyComponentSearch")
self.dmd.Devices._delObject("ZenPacks_test_ClassProxies_MyComponentSub1Search")
self.dmd.Devices._delObject("ZenPacks_test_ClassProxies_MyComponentSub2Search")
for device in devices:
device._delObject("ComponentBaseSearch")
device._delObject("MyComponentSearch")
device._delObject("MyComponentSub1Search")
device._delObject("MyComponentSub2Search")
# Index single component of one of the subclasses.
devices[0].myComponents._getOb("myComponent1-1").index_object()
# All components of superclasseses should now be indexed in
# device and global catalogs.
self.assertItemsEqual(
component_ids,
[x.id for x in devices[0].search("MyComponent")])
self.assertItemsEqual(
component_ids * 2,
[x.id for x in MyComponent.class_search(self.dmd)])
# All components of the same class should be indexed in device
# and global catalogs.
self.assertItemsEqual(
["myComponent1-1", "myComponent1-2"],
[x.id for x in devices[0].search("MyComponentSub1")])
self.assertItemsEqual(
["myComponent1-1", "myComponent1-2"] * 2,
[x.id for x in MyComponentSub1.class_search(self.dmd)])
# All components of classes not in the inheritence hierarchy
# should not yet be indexed in device or global catalogs.
self.assertItemsEqual(
[],
[x.id for x in devices[0].search("MyComponentSub2")])
self.assertItemsEqual(
[],
[x.id for x in MyComponentSub2.class_search(self.dmd)])
# Index remaining unique device/subclass combinations.
devices[0].myComponents._getOb("myComponent2-1").index_object()
devices[1].myComponents._getOb("myComponent1-1").index_object()
devices[1].myComponents._getOb("myComponent2-1").index_object()
# Now all catalogs should be complete.
verify_all_catalogs()
break
if not found:
log.error("Unable to find a matching objectmap to extend: %s" % om_dict)
continue
objmaps[key].append(
ObjectMap(compname=compname, modname=modname, classname=classname, data=om_dict)
)
added_count = len(objmaps[key]) - starting_count
if added_count > 0:
log.info(" Added %d new objectmaps to %s" % (added_count, key))
# Apply the objmaps in the right order.
componentsMap = RelationshipMap(relname="components")
for i in (
"tenants",
"regions",
"flavors",
"images",
"servers",
"zones",
"hosts",
"hypervisors",
"services",
"networks",
"subnets",
"routers",
"ports",
"agents",
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 process(self, device, results, log):
log.info('Modeler %s processing data for device %s',
self.name(), device.id)
getdata, tabledata = results
sensor_count = sum([getdata[x] for x in getdata if 'Count' in x])
maps = []
# device-specific data
manufacturer = 'Geist Manufacturing, Inc.'
os_name = '%s %s' % (getdata['productTitle'], getdata['productVersion'])
maps.append(ObjectMap(data={
'sensor_count': sensor_count,
'title': getdata['productFriendlyName'],
'productUrl': getdata['productUrl'],
'setHWProductKey': MultiArgs(getdata['productHardware'], manufacturer),
'setOSProductKey': MultiArgs(os_name, manufacturer),
}))
# Components: climate sensors
rm = RelationshipMap(
relname='geistClimateSensors',
modname='ZenPacks.crosse.Geist.Monitor.GeistClimateSensor',
)
for snmpindex, row in tabledata.get('climateTable', {}).items():
serial = row.get('climateSerial')
if not serial:
log.warn('Skipping climate sensor with no serial')
continue
log.debug('Modeling climate sensor %s', serial)
values = {k: row[k] for k in row}
values['id'] = self.prepId(serial)
values['title'] = values['climateName']
values['snmpindex'] = snmpindex.strip('.')
rm.append(ObjectMap(
modname='ZenPacks.crosse.Geist.Monitor.GeistClimateSensor',
data=values
))
maps.append(rm)
# Components: temperature sensors
rm = RelationshipMap(
relname='geistTemperatureSensors',
modname='ZenPacks.crosse.Geist.Monitor.GeistTemperatureSensor',
)
for snmpindex, row in tabledata.get('tempSensorTable', {}).items():
serial = row.get('tempSensorSerial')
if not serial:
log.warn('Skipping temperature sensor with no serial')
continue
log.debug('Modeling temperature sensor %s', serial)
values = {k: row[k] for k in row}
values['id'] = self.prepId(serial)
values['title'] = values['tempSensorName']
values['snmpindex'] = snmpindex.strip('.')
rm.append(ObjectMap(
modname='ZenPacks.crosse.Geist.Monitor.GeistTemperatureSensor',
data=values
))
maps.append(rm)
# Components: airflow sensors
rm = RelationshipMap(
relname='geistAirflowSensors',
modname='ZenPacks.crosse.Geist.Monitor.GeistAirflowSensor',
)
for snmpindex, row in tabledata.get('airFlowSensorTable', {}).items():
serial = row.get('airFlowSensorSerial')
if not serial:
log.warn('Skipping airflow sensor with no serial')
continue
log.debug('Modeling airflow sensor %s', serial)
values = {k: row[k] for k in row}
values['id'] = self.prepId(serial)
values['title'] = values['airFlowSensorName']
values['snmpindex'] = snmpindex.strip('.')
rm.append(ObjectMap(
modname='ZenPacks.crosse.Geist.Monitor.GeistAirflowSensor',
data=values
))
maps.append(rm)
return maps
def process(self, device, results, log):
log.info('processing %s for device %s', self.name(), device.id)
maps = list()
""" Example output through 10.12
caching:ReservedVolumeSpace = 25000000000
caching:LogClientIdentity = yes
caching:CacheLimit = 70000000000
caching:ServerRoot = "/Library/Server"
caching:ServerGUID = "02FE97F2-41F3-4CEE-9899-27976DB91A1A"
caching:DataPath = "/Library/Server/Caching/Data"
caching:LocalSubnetsOnly = yes
caching:Port = 0
caching:CacheLimit = 70000000000
caching:StartupStatus = "OK"
caching:RegistrationStatus = 1
caching:CacheFree = 52754638336
caching:PersonalCacheUsed = 0
caching:TotalBytesDropped = 0
caching:CacheStatus = "OK"
caching:TotalBytesStoredFromOrigin = 419351941
caching:state = "RUNNING"
caching:Port = 49232
caching:Peers:_array_index:0:address = "aaa.bbb.ccc.ddd"
caching:Peers:_array_index:0:port = 49094
caching:Peers:_array_index:0:details:capabilities:ur = yes
caching:Peers:_array_index:0:details:capabilities:sc = yes
caching:Peers:_array_index:0:details:capabilities:pc = no
caching:Peers:_array_index:0:details:capabilities:im = no
caching:Peers:_array_index:0:details:capabilities:ns = yes
caching:Peers:_array_index:0:details:capabilities:query-parameters = yes # noqa
caching:Peers:_array_index:0:details:cache-size = 900000000000
caching:Peers:_array_index:0:details:ac-power = yes
caching:Peers:_array_index:0:details:is-portable = no
caching:Peers:_array_index:0:details:local-network:_array_index:0:speed = 1000 # noqa
caching:Peers:_array_index:0:details:local-network:_array_index:0:wired = yes # noqa
caching:Peers:_array_index:0:healthy = yes
caching:Peers:_array_index:0:version = "161"
caching:Peers:_array_index:0:friendly = yes
caching:Peers:_array_index:0:guid = "9B9CDED4-F70C-4910-B7D4-11D1530AD34D" # noqa
caching:TotalBytesStoredFromPeers = 0
caching:RestrictedMedia = no
caching:CacheDetails:_array_index:0:BytesUsed = 0
caching:CacheDetails:_array_index:0:LocalizedType = "Mac Software"
caching:CacheDetails:_array_index:0:MediaType = "Mac Software"
caching:CacheDetails:_array_index:0:Language = "en"
caching:CacheDetails:_array_index:1:BytesUsed = 419351941
caching:CacheDetails:_array_index:1:LocalizedType = "iOS Software"
caching:CacheDetails:_array_index:1:MediaType = "iOS Software"
caching:CacheDetails:_array_index:1:Language = "en"
...
caching:PersonalCacheLimit = 70000000000
caching:CacheUsed = 419351941
caching:TotalBytesStored = 419351941
caching:TotalBytesImported = 0
caching:PersonalCacheFree = 52754638336
caching:Active = yes
caching:TotalBytesReturned = 476014159
"""
# Parse results
service = dict()
caches = dict()
peers = dict()
lines = results.splitlines()
# Legacy output
if not results.startswith('{'):
output = dict(line.split(' = ') for line in lines)
for key in output:
if key.startswith('caching:CacheDetails:'):
short = key.replace(
'caching:CacheDetails:_array_index:',
''
)
idx = int(short.split(':')[0])
k = short.split(':')[1]
v = output.get(key).replace('"', '')
if idx not in caches:
caches[idx] = dict()
caches[idx].update({k: v})
elif key.startswith('caching:Peers:'):
short = key.replace('caching:Peers:_array_index:', '')
short = short.replace('details:', '')
if ('capabilities' not in key
and 'local-network' not in key):
idx = int(short.split(':')[0])
k = short.split(':')[1]
v = output.get(key).replace('"', '')
if idx not in peers:
peers[idx] = dict()
peers[idx].update({k: v})
else:
k = key.split(':')[1]
service.update({k: output.get(key).replace('"', '')})
# JSON output
else:
for line in lines:
output = json.loads(line)
service.update(output.get('result', dict()))
# Mimic structure of legacy output
keys = service.get('CacheDetails', dict()).keys()
for idx in range(0, len(keys)):
value = service.get('CacheDetails', dict()).get(keys[idx])
caches[idx] = {
'MediaType': keys[idx],
'BytesUsed': value,
}
if len(keys) - 1 == idx:
break
# Settings output has an element named "Parents" as well
if output.get('name', 'status') != 'settings':
peer_count = 0
for peer in service.get('Peers', list()):
peers[peer_count] = peer
peer_count += 1
for peer in service.get('Parents', list()):
peer['is-parent'] = True
peers[peer_count] = peer
peer_count += 1
for idx in peers:
for attr in ('ac-power', 'cache-size', 'is-portable'):
if attr in peers[idx]['details']:
peers[idx][attr] = peers[idx]['details'][attr]
# Caching Service
booleans = [
'Active',
'AllowPersonalCaching',
'LocalSubnetsOnly',
'LogClientIdentity',
'RestrictedMedia',
]
for attr in booleans:
if attr in service and type(service[attr]) is not bool:
service[attr] = True if 'yes' == service[attr] else False
integers = [
'CacheFree',
'CacheLimit',
'CacheUsed',
'Port',
'ReservedVolumeSpace',
]
for attr in integers:
if attr in service and type(service[attr]) is not int:
service[attr] = int(service[attr])
# More realistic Cache Limit value if configured to "unlimited"
if service.get('CacheLimit', 0) == 0:
service['CacheLimit'] = service.get('CacheLimit', 0)
service['CacheLimit'] += service.get('CacheUsed', 0)
service['CacheLimit'] += service.get('CacheFree', 0)
service['id'] = self.prepId('CachingService')
service['title'] = service.get('DataPath', 'Content Caching')
# Escape spaces in DataPath for zencommand later
if 'DataPath' in service:
service['DataPath'] = service['DataPath'].replace(' ', r'\ ')
# Not listening, service likely not running
if 'Port' in service and service.get('Port') == 0:
del service['Port']
log.debug('Caching Service\n%s', service)
rm = RelationshipMap(
relname='contentCachingService',
modname='ZenPacks.daviswr.OSX.Server.Caching.ContentCachingService'
)
rm.append(ObjectMap(
modname='ZenPacks.daviswr.OSX.Server.Caching.ContentCachingService', # noqa
data=service
))
maps.append(rm)
# Individual Cache components
rm = RelationshipMap(
compname='contentCachingService/CachingService',
relname='contentCaches',
modname='ZenPacks.daviswr.OSX.Server.Caching.ContentCache'
)
for idx in caches:
cache = caches.get(idx)
if 'BytesUsed' in cache:
cache['BytesUsed'] = int(cache['BytesUsed'])
cache['title'] = self.prepId(cache.get('MediaType', ''))
cache['id'] = self.prepId(cache['title'])
log.debug('Individual Cache: %s', cache)
rm.append(ObjectMap(
modname='ZenPacks.daviswr.OSX.Server.Caching.ContentCache',
data=cache
))
maps.append(rm)
# Peer Server components
rm = RelationshipMap(
compname='contentCachingService/CachingService',
relname='contentCachePeers',
modname='ZenPacks.daviswr.OSX.Server.Caching.ContentCachePeer'
)
peer_integers = [
'cache-size',
'port',
]
peer_booleans = [
'ac-power',
'friendly',
'healthy',
'is-portable',
]
for idx in peers:
peer = peers.get(idx)
for attr in peer_integers:
if attr in peer and type(peer[attr]) is not int:
peer[attr] = int(peer[attr])
for attr in peer_booleans:
if attr in peer and type(peer[attr]) is not bool:
peer[attr] = True if 'yes' == peer[attr] else False
peer['title'] = peer.get('address', peer.get('guid', ''))
id_str = 'cachepeer_{0}'.format(
peer.get('address', peer.get('guid', ''))
)
peer['id'] = self.prepId(id_str)
log.debug('Peer Caching Server: %s', peer)
rm.append(ObjectMap(
modname='ZenPacks.daviswr.OSX.Server.Caching.ContentCachePeer',
data=peer
))
maps.append(rm)
return maps
def process(self, device, results, log):
log.info(
"Modeler %s processing data for device %s",
self.name(),
device.id
)
maps = list()
pools = dict()
last_parent = None
last_pool = None
last_root = None
last_tree = None
last_type = None
last_vdev = None
zpool_status = False
get_regex = r'^(?P<pool>\S+)\t(?P<key>\S+)\t(?P<value>\S+)\t\S+$'
zdb_header_regex = r'(?P<key>\S+)\:$'
zdb_kv_regex = r'\ {4}\s*(?P<key>\S+)\:\s?(?P<value>\S+)'
status_pool_regex = r'^\s+pool: (?P<dev>\S+)$'
status_logs_regex = r'^\s+logs$'
status_cache_regex = r'^\s+cache$'
status_spare_regex = r'^\s+spares$'
status_dev_regex = r'(?P<dev>\S+)\s+\S+(?:\s+\d+){3}$'
for line in results.splitlines():
get_match = re.match(get_regex, line)
zdb_pool_match = re.match(r'^' + zdb_header_regex, line)
zdb_tree_match = re.match(r'^ ' + zdb_header_regex, line)
zdb_root_match = re.match(r'^ ' + zdb_header_regex, line)
zdb_vdev_match = re.match(r'^ ' + zdb_header_regex, line) # noqa
zdb_kv_match = re.match(zdb_kv_regex, line)
status_pool_match = re.match(status_pool_regex, line) \
or re.match(r'^\t' + status_dev_regex, line)
status_logs_match = re.match(status_logs_regex, line)
status_cache_match = re.match(status_cache_regex, line)
status_spare_match = re.match(status_spare_regex, line)
status_root_match = re.match(r'^\t ' + status_dev_regex, line)
status_child_match = re.match(r'^\t ' + status_dev_regex, line)
if get_match:
pool = get_match.group('pool')
key = get_match.group('key')
value = get_match.group('value')
if pool not in pools:
pools[pool] = dict()
if value.endswith('%') or re.match(r'^\d+\.\d{2}x$', value):
value = value[:-1]
elif value == '-':
value = None
pools[pool][key] = value
elif zdb_pool_match:
if not zpool_status:
pool = zdb_pool_match.group('key')
if pool not in pools:
pools[pool] = dict()
last_pool = pools[pool]
last_pool['type'] = 'pool'
last_parent = last_pool
elif zdb_tree_match:
key = zdb_tree_match.group('key')
if 'tree' in key:
last_pool[key] = dict()
last_tree = last_pool[key]
last_parent = last_tree
elif zdb_root_match:
key = zdb_root_match.group('key')
last_tree[key] = dict()
last_root = last_tree[key]
last_parent = last_root
elif zdb_vdev_match:
key = zdb_vdev_match.group('key')
last_root[key] = dict()
last_vdev = last_root[key]
last_parent = last_vdev
elif zdb_kv_match:
key = zdb_kv_match.group('key')
value = zdb_kv_match.group('value').replace("'", "")
# Attributes right under vdev_tree are pool-wide
# and should already be in `zpool get` output
if 'vdev_tree' in last_pool \
and last_pool['vdev_tree'] == last_parent:
continue
# ZenModeler does not like these in the RelMap
elif key in ['hostid', 'hostname']:
continue
elif 'name' == key:
last_parent['title'] = value
continue
elif 'pool_guid' == key:
last_parent['guid'] = value
continue
# Spare devices will be modeled based on 'zpool status' output
elif 'type' == key and 'spare' == value:
continue
last_parent[key] = value
# disk type
if key == 'path':
last_parent['title'] = value.split('/')[-1]
# mirror type
elif key == 'id' and 'type' in last_parent:
last_parent['title'] = '{0}-{1}'.format(
last_parent['type'],
value
)
# raidz type
elif key == 'nparity' \
and 'id' in last_parent \
and 'type' in last_parent:
last_parent['type'] += value
last_parent['title'] = '{0}-{1}'.format(
last_parent['type'],
last_parent['id']
)
# 'zpool status' is only to find cache devices
# since they're strangely absent from zdb
elif status_pool_match:
zpool_status = True
pool = status_pool_match.group('dev')
if pool not in pools:
pools[pool] = dict()
if 'vdev_tree' not in pools[pool]:
pools[pool]['vdev_tree'] = dict()
last_pool = pools[pool]
last_pool['type'] = 'pool'
last_type = last_pool['type']
last_tree = pools[pool]['vdev_tree']
last_parent = last_tree
elif status_logs_match:
last_type = 'logs'
elif status_cache_match:
last_type = 'cache'
elif status_spare_match:
last_type = 'spare'
# Emulate structure in zdb output for log devices
# Each device is a root vdev,
# rather than a child vdev in a logs/cache root
elif status_root_match:
if 'cache' == last_type or 'spare' == last_type:
dev = status_root_match.group('dev')
key = '{0}_{1}'.format(last_type, dev)
if key not in last_tree:
last_tree[key] = dict()
last_root = last_tree[key]
last_root['title'] = dev
for boolean in ['cache', 'log', 'spare']:
last_root['is_{0}'.format(boolean)] = '0'
last_root['is_{0}'.format(last_type)] = '1'
elif status_child_match:
last_type = 'child'
booleans = [
'autoexpand',
'autoreplace',
'delegation',
'listsnapshots',
'readonly',
]
dev_booleans = [
'is_cache',
'is_log',
'is_spare',
'whole_disk',
]
ints = [
'allocated',
'ashift',
'asize',
'capacity',
'create_txg',
'dedupditto',
'free',
'freeing',
'leaked',
'metaslab_array',
'metaslab_shift',
'size',
'txg',
'DTL',
]
floats = [
'dedupratio',
'fragmentation',
]
# Basic Linux block device name
# sda1
disk_id_basic_regex = r'^([a-z]{3,})\d+$'
# Linux /dev/disk/by-id
# ata-WDC_WD2000F9YZ-09N20L0_WD-WCC1P0356812-part1
# Linux /dev/disk/by-path
# pci-0000:00:11.0-scsi-2:0:0:0-part1
# Illumos block device name
# c8t5000CCA03C41D2FDd0s0
disk_id_regex = r'^(.*)(?:-part\d+|s\d+)$'
pool_rm = RelationshipMap(
relname='zpools',
modname='ZenPacks.daviswr.ZFS.ZPool'
)
root_rm_list = list()
child_rm_list = list()
ignore_names_regex = getattr(device, 'zZPoolIgnoreNames', '')
if ignore_names_regex:
log.info('zZPoolIgnoreNames set to %s', ignore_names_regex)
# Pool components
for pool in pools:
if ignore_names_regex and re.match(ignore_names_regex, pool):
log.debug(
'Skipping pool %s due to zZPoolIgnoreNames',
pool
)
continue
comp = dict()
for key in pools[pool]:
if key in booleans:
comp[key] = True if ('on' == pools[pool][key]) else False
elif key in ints:
comp[key] = int(pools[pool][key])
elif key in floats:
comp[key] = float(pools[pool][key])
elif not key == 'vdev_tree' \
and not key == 'name':
comp[key] = pools[pool][key]
# Can't use the GUID since it's not available in iostat
comp['id'] = self.prepId('pool_{0}'.format(pool))
log.debug('Found ZPool: %s', comp['id'])
pool_rm.append(ObjectMap(
modname='ZenPacks.daviswr.ZFS.ZPool',
data=comp
))
# Root vDev components
roots = pools[pool].get('vdev_tree', None)
if roots is not None:
log.debug('ZPool %s has children', comp['id'])
root_rm = RelationshipMap(
compname='zpools/pool_{0}'.format(pool),
relname='zrootVDevs',
modname='ZenPacks.daviswr.ZFS.ZRootVDev'
)
for key in roots.keys():
if not key.startswith('children') \
and not key.startswith('cache_') \
and not key.startswith('spare_'):
del roots[key]
for root in roots:
comp = dict()
children = list()
for key in roots[root]:
if key in dev_booleans:
comp[key] = True \
if '1' == roots[root][key] \
else False
elif key in ints:
comp[key] = int(roots[root][key])
elif key == 'type':
comp['VDevType'] = roots[root][key]
elif key.startswith('children[') \
or key.startswith('cache_') \
or key.startswith('spare_'):
children.append(roots[root][key])
elif not key == 'name':
comp[key] = roots[root][key]
comp['pool'] = pool
if comp.get('whole_disk') and comp.get('title'):
match = re.match(disk_id_regex, comp['title']) \
or re.match(disk_id_basic_regex, comp['title'])
if match:
comp['title'] = match.groups()[0]
id_str = '{0}_{1}'.format(
pool,
comp.get('title', '').replace('-', '_')
)
comp['id'] = self.prepId(id_str)
if comp.get('is_cache'):
modname = 'CacheDev'
elif comp.get('is_log'):
modname = 'LogDev'
elif comp.get('is_spare'):
modname = 'SpareDev'
else:
modname = 'RootVDev'
log.debug('Found %s: %s', modname, comp['id'])
root_rm.append(ObjectMap(
modname='ZenPacks.daviswr.ZFS.Z{0}'.format(modname),
data=comp
))
# Store Dev components
if len(children) > 0:
log.debug('Root vDev %s has children', comp['id'])
child_rm = RelationshipMap(
compname='zpools/pool_{0}/zrootVDevs/{1}'.format(
pool,
id_str
),
relname='zstoreDevs',
modname='ZenPacks.daviswr.ZFS.ZStoreDev'
)
for child in children:
comp = dict()
for key in child:
if key in dev_booleans:
comp[key] = True \
if '1' == child[key] \
else False
elif key in ints:
comp[key] = int(child[key])
elif key == 'type':
comp['VDevType'] = child[key]
elif not key == 'name':
comp[key] = child[key]
comp['pool'] = pool
if comp.get('whole_disk') and comp.get('title'):
match = re.match(
disk_id_regex,
comp['title']
) \
or re.match(
disk_id_basic_regex,
comp['title']
)
if match:
comp['title'] = match.groups()[0]
id_str = '{0}_{1}'.format(
pool,
comp.get('title', '').replace('-', '_')
)
comp['id'] = self.prepId(id_str)
log.debug('Found child vDev: %s', comp['id'])
child_rm.append(ObjectMap(
modname='ZenPacks.daviswr.ZFS.ZStoreDev',
data=comp
))
child_rm_list.append(child_rm)
root_rm_list.append(root_rm)
maps.append(pool_rm)
maps += root_rm_list
maps += child_rm_list
log.debug(
'ZPool RelMap:\n%s',
str(maps)
)
return maps
def processTblSupplies(self, tblSupplies, tblColors, log):
# initialize seperate maps for toners and other supplies
# use RelationshipMap() because I want to specify the relationship since there's only 1 modeler
# for more components
mapSupplies = RelationshipMap(modname='ZenPacks.TwoNMS.PrinterMIB.PrinterSupply', relname='printermibsupply')
mapToners = RelationshipMap(modname='ZenPacks.TwoNMS.PrinterMIB.PrinterToner', relname='printermibtoner')
# simplify the tblColors map to make the code easier to read
colors = {}
for cId, cInfo in tblColors.iteritems():
colors[str(cId)] = cInfo['prtMarkerColorantValue'].split("\x00")[0]
log.debug("colors table = %s", colors)
# go over each supply and classifiy as toner (ink cartridge) or other supply
for supplyId, supplyData in tblSupplies.iteritems():
# create a temp map first because we don't know yet what kind of supply we have
mapTemp = self.objectMap(supplyData)
mapTemp.id = self.prepId(supplyId)
isToner = False
# check if it's a toner or other supply, color toners have prtMarkerSuppliesColorantIndex > 0
# translate the color id
try:
if mapTemp.prtMarkerSuppliesColorantIndex > 0:
isToner = True
# overwrite the index with the color value
if (colors[str(mapTemp.prtMarkerSuppliesColorantIndex)] != None):
mapTemp.prtMarkerSuppliesColorantValue = colors[str(mapTemp.prtMarkerSuppliesColorantIndex)]
mapTemp.rgbColorCode = self.rgbColorCodes[mapTemp.prtMarkerSuppliesColorantValue.lower()]
else:
mapTemp.prtMarkerSuppliesColorantValue = self.PrtConsoleColorTC['na']
except (AttributeError, KeyError):
log.warn("AttributeErorr or KeyError occurred - Supply does not support the prtMarkerSuppliesColorantIndex oid")
mapTemp.prtMarkerSuppliesColorantValue = self.PrtConsoleColorTC['na']
mapTemp.rgbColorCode = self.rgbColorCodes['na']
#continue
except:
log.warn("Unknown error occurred")
mapTemp.prtMarkerSuppliesColorantValue = self.PrtConsoleColorTC['na']
mapTemp.rgbColorCode = self.rgbColorCodes['na']
#continue
# translate the supply unit type id
try:
if (self.PrtMarkerSuppliesSupplyUnitTC[str(mapTemp.prtMarkerSuppliesSupplyUnitTC)] != None):
mapTemp.prtMarkerSuppliesSupplyUnit = self.PrtMarkerSuppliesSupplyUnitTC[str(mapTemp.prtMarkerSuppliesSupplyUnitTC)]
except AttributeError:
log.warn("Supply does not support the prtMarkerSuppliesSupplyUnitTC oid")
mapTemp.prtMarkerSuppliesSupplyUnit = self.PrtMarkerSuppliesSupplyUnitTC['na']
#continue
# translate the supply type id
try:
if (self.PrtMarkerSuppliesTypeTC[str(mapTemp.prtMarkerSuppliesTypeTC)] != None):
mapTemp.prtMarkerSuppliesType = self.PrtMarkerSuppliesTypeTC[str(mapTemp.prtMarkerSuppliesTypeTC)]
except AttributeError:
log.warn("Supply does not support the prtMarkerSuppliesTypeTC oid")
mapTemp.prtMarkerSuppliesType = self.PrtMarkerSuppliesTypeTC['na']
#continue
# add a percentage value of the usage
try:
mapTemp.usagepct = self.calculateUsagePct(mapTemp.prtMarkerSuppliesLevel, mapTemp.prtMarkerSuppliesMaxCapacity, log)
except:
mapTemp.usagepct = 'na'
# add the temp map to the toner or supply map
if (isToner == True):
mapTemp.modname = "ZenPacks.TwoNMS.PrinterMIB.PrinterToner"
mapTemp.supplyId = mapTemp.id
mapTemp.snmpindex = mapTemp.id
log.debug("New toner found: %s", mapTemp)
mapToners.append(mapTemp)
else:
mapTemp.modname = "ZenPacks.TwoNMS.PrinterMIB.PrinterSupply"
mapTemp.supplyId = mapTemp.id
mapTemp.snmpindex = mapTemp.id
log.debug("New supply found: %s", mapTemp)
mapSupplies.append(mapTemp)
return mapSupplies, mapToners