Source Code for Module ZenModel.Link

  1  ########################################################################### 
  2  # 
  3  # This program is part of Zenoss Core, an open source monitoring platform. 
  4  # Copyright (C) 2007, Zenoss Inc. 
  5  # 
  6  # This program is free software; you can redistribute it and/or modify it 
  7  # under the terms of the GNU General Public License version 2 as published by 
  8  # the Free Software Foundation. 
  9  # 
 10  # For complete information please visit: http://www.zenoss.com/oss/ 
 11  # 
 12  ########################################################################### 
 13   
 14   
 15  from Globals import InitializeClass 
 16  from Products.ZenModel.ZenModelRM import ZenModelRM 
 17  from Products.ZenRelations.RelSchema import * 
 18  from AccessControl import ClassSecurityInfo, Permissions 
 19   
 20   
 21 -class ILink(object): 
 22      """ Defines the interface for Link-like objects, which 
 23          represent a connection between two devices or components  
 24      """ 
 25   
 26      link_type = '' 
 27      OSI_layer = ''  
 28      entry_type = '' 
 29   
 30 -    def getStatus(self): 
 31          """ Returns the event status, determined by: 
 32                  Pingdown on Device owning either endpoint 
 33                  Most severe event on either endpoint 
 34          """ 
 35          raise NotImplementedError 
 36   
 37 -    def setEndpoints(self, pointa, pointb): 
 38          """ Sets the two endpoints of a link-like object """ 
 39          raise NotImplementedError 
 40   
 41 -    def getEndpointNames(self): 
 42          """ Returns unique endpoint names (see Linkable.getEndpointName)""" 
 43          raise NotImplementedError 
 44   
 45 -    def getOtherEndpoint(self, endpoint): 
 46          """ Returns the link endpoint that is not the one given """ 
 47          raise NotImplementedError 
 48   
 49 -    def getDataForJSON(self): 
 50          """ Returns data ready for serialization. 
 51              Format: 
 52                  [ id link as string  
 53                  , endpoint a name  
 54                  , endpoint b name  
 55                  , self.OSI_layer  
 56                  , self.link_type  
 57                  , self.entry_type 
 58                  , self.id 
 59                  ] 
 60          """ 
 61          raise NotImplementedError 
 62   
 63 -    def getGeomapData(self): 
 64          """ Return the addresses of the endpoints 
 65              aggregated for the generation of the context 
 66          """ 
 67          raise NotImplementedError 
 68   
 69   
 70   
 71 -class Link(ZenModelRM, ILink): 
 72      """ A link between two Linkable objects, 
 73          which can have a status and a type. 
 74          Implements ILink interface. 
 75      """ 
 76   
 77      link_type = '' 
 78      OSI_layer = "1" 
 79      entry_type = 'manual' 
 80   
 81      default_catalog = 'linkSearch' 
 82   
 83      _properties = ZenModelRM._properties + ( 
 84          {'id':'link_type','type':'string','mode':'w'}, 
 85          {'id':'OSI_layer', 'type':'string', 'mode':'w'}, 
 86          {'id':'entry_type', 'type':'string', 'mode':'w'}, 
 87      ) 
 88   
 89      _relations = ( 
 90          ("endpoints",  
 91              ToMany(ToMany, "Products.ZenModel.Linkable", "links")), 
 92          ("linkManager",  
 93              ToOne(ToManyCont, "Products.ZenModel.LinkManager", "links")), 
 94      ) 
 95       
 96      factory_type_information = ( 
 97          { 'immediate_view' : 'editLink', 
 98            'factory'        : 'manage_addLink', 
 99            'actions'        : 
100            ( 
101             { 'id'            : 'editLink' 
102               , 'name'          : 'Edit' 
103               , 'action'        : 'editLink' 
104               , 'permissions'   : ( "Manage DMD", ) 
105               }, 
106             ) 
107            }, 
108          ) 
109   
110 -    def __init__(self, id): 
111          self.id = id 
112          ZenModelRM.__init__(self, id) 
113          self.buildRelations() 
114   
115 -    def manage_afterAdd(self, item, container): 
116          self.index_object() 
117   
118 -    def manage_beforeDelete(self, item, container): 
119          self.unindex_object() 
120   
121 -    def setEndpoints(self, pointa, pointb): 
122          self.endpoints._setObject(pointa.id, pointa) 
123          self.endpoints._setObject(pointb.id, pointb) 
124   
125 -    def getEndpointNames(self): 
126          return [x.getEndpointName() for x in self.endpoints()] 
127   
128 -    def getOtherEndpoint(self, endpoint): 
129          """ Return the link endpoint that is not the one given """ 
130          eps = self.endpoints() 
131          if eps[0]==endpoint:  
132              return eps[1] 
133          return eps[0] 
134   
135 -    def getDataForJSON(self): 
136          """ returns data ready for serialization 
137          """ 
138          id = '<a class="tablevalues" href="%s">%s</a>' % ( 
139                              self.absolute_url_path(), self.getId()) 
140          pointa, pointb = self.getEndpointNames() 
141          link_type = self.link_type 
142          entry_type = self.entry_type 
143          OSI_layer = self.OSI_layer 
144          return [id, pointa, pointb, OSI_layer, link_type, entry_type, 
145                  self.getId()] 
146   
147 -    def getStatus(self): 
148          """ Status of link is determined by: 
149                  Pingdown on Device owning either endpoint 
150                  Most severe event on either endpoint 
151          """ 
152          eps = self.endpoints() 
153          if max([ep.device().getPingStatus() for ep in eps]) > 0: 
154              return 5 
155          zem = self.dmd.ZenEventManager 
156          return max(map(zem.getMaxSeverity, eps)) 
157   
158 -    def getGeomapData(self, context, full=False): 
159          """ Return the addresses of the endpoints 
160              aggregated for the generation of the context 
161          """ 
162          generation = len(context.getPrimaryPath()) 
163          def getancestoraddress(endpoint): 
164              loc = endpoint.device().location() 
165              path = loc.getPrimaryPath() 
166              path = '/'.join(path[:generation]) 
167              ancestor = self.dmd.getObjByPath(path) 
168              if full: 
169                  return ancestor.getGeomapData() 
170              else: 
171                  return ancestor.address 
172          result = map(getancestoraddress, self.endpoints()) 
173          if result[0]==result[1]: return None 
174          result.sort() 
175          return tuple(result) 
176   
177   
178   
179  InitializeClass(Link) 
180