Package Products :: Package ZenModel :: Module IpService |
[hide private]
[frames] | no frames]

# Source Code for Module Products.ZenModel.IpService

      1  ###########################################################################
      2  #
      3  # This program is part of Zenoss Core, an open source monitoring platform.
      4  # Copyright (C) 2007, 2009 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  __doc__="""IpService
     15
     16  IpService is a function provided by computer (like a server).  it
     17  is defined by a protocol type (udp/tcp) and a port number.
     18
     19  """
     20
     21  from Globals import DTMLFile, InitializeClass
     22  from AccessControl import ClassSecurityInfo
     23  from Products.ZenModel.ZenossSecurity import *
     24
     25  from Products.ZenRelations.RelSchema import *
     26
     27  from Products.ZenModel.Service import Service
     28  from Products.ZenModel.IpServiceClass import IpServiceClass
     29  from Products.ZenUtils.IpUtil import isip
     30
     31 -def manage_addIpService(context, id, protocol, port, userCreated=None, REQUEST=None):
     32      """
     33      Make an IP service entry
     34      """
     35      s = IpService(id)
     36      s.protocol = protocol
     37      s.port = int(port)
     38      args = {'protocol':protocol, 'port':int(port)}
     39      # Indexing is subscribed to ObjectAddedEvent, which fires
     40      # on _setObject, so we want to set service class first.
     41      s.__of__(context).setServiceClass(args)
     42      context._setObject(id, s)
     43      s = context._getOb(id)
     44      if userCreated: s.setUserCreateFlag()
     45      if REQUEST is not None:
     46          REQUEST['RESPONSE'].redirect(context.absolute_url()
     47                                       +'/manage_main')
     48      return s
     49
     50  addIpService = DTMLFile('dtml/addIpService',globals())
     51
     52
     53 -def getIpServiceKey(protocol, port):
     54      return "%s_%05d" % (protocol, port)
     55
     56
     57 -class IpService(Service):
     58      """
     59      IpService object
     60      """
     61
     62      __pychecker__='no-override'
     63
     64      portal_type = meta_type = 'IpService'
     65
     66      protocols = ('tcp', 'udp')
     67
     68      ipaddresses = []
     69      discoveryAgent = ""
     70      port = 0
     71      protocol = ""
     72      manageIp = ""
     73
     74      collectors = ('zenstatus',)
     75
     76      _properties = (
     77          {'id':'port', 'type':'int', 'mode':'', 'setter': 'setPort',
     78           'description':"TCP port to check for this service."},
     79          {'id':'protocol', 'type':'string', 'mode':'', 'setter': 'setProtocol',
     80           'description':"Protocol (TCP or UPD) used by this service."},
     81          {'id':'ipaddresses', 'type':'lines', 'mode':'',
     82           'description':"IP addresses that this service is listening on."},
     83          {'id':'discoveryAgent', 'type':'string', 'mode':'',
     84           'description':"What process was used to discover this service."},
     85          {'id':'manageIp', 'type':'string', 'mode':'',
     86           'description':"The IP address to check for this service."},
     87          )
     88      _relations = Service._relations + (
     89          ("os", ToOne(ToManyCont,"Products.ZenModel.OperatingSystem","ipservices")),
     90          )
     91
     92      factory_type_information = (
     93          {
     94              'immediate_view' : 'ipServiceDetail',
     95              'actions'        :
     96              (
     97                  { 'id'            : 'status'
     98                  , 'name'          : 'Status'
     99                  , 'action'        : 'ipServiceDetail'
    100                  , 'permissions'   : (ZEN_VIEW, )
    101                  },
    102                  { 'id'            : 'events'
    103                  , 'name'          : 'Events'
    104                  , 'action'        : 'viewEvents'
    105                  , 'permissions'   : (ZEN_VIEW, )
    106                  },
    107                  { 'id'            : 'manage'
    108                  , 'name'          : 'Administration'
    109                  , 'action'        : 'ipServiceManage'
    110                  , 'permissions'   : ("Manage DMD",)
    111                  },
    112                  { 'id'            : 'viewHistory'
    113                  , 'name'          : 'Modifications'
    114                  , 'action'        : 'viewHistory'
    115                  , 'permissions'   : (ZEN_VIEW_MODIFICATIONS,)
    116                  },
    117              )
    118           },
    119          )
    120
    121      security = ClassSecurityInfo()
    122
    123
    124 -    def monitored(self):
    125          """
    126          Return monitored state of ipservice.
    127          If service only listens on 127.0.0.1 return false.
    128          """
    129          if self.cantMonitor(): return False
    130          return super(IpService, self).monitored()
    131
    132
    133 -    def cantMonitor(self):
    134          """
    135          Return true if IpService only listens on 127.0.0.1, or if it is a UDP
    136          service.
    137          """
    138          return self.protocol == 'udp' \
    139                  or ( len(self.ipaddresses) == 1
    140                       and "127.0.0.1" in self.ipaddresses )
    141
    142
    143
    144 -    def getInstDescription(self):
    145          """
    146          Return some text that describes this component.  Default is name.
    147          """
    148          return "%s-%d ips:%s" % (self.protocol, self.port,
    149                                   ", ".join(self.ipaddresses))
    150
    151
    152 -    def setServiceClass(self, kwargs):
    153          """
    154          Set the service class based on a dict describing the service.
    155          Dict keys are be protocol and port
    156          """
    157          protocol = kwargs['protocol']
    158          port = kwargs['port']
    159          name = getIpServiceKey(protocol, port)
    160          path = "/IpService/"
    161          srvs = self.dmd.getDmdRoot("Services")
    162          srvclass = srvs.createServiceClass(name=name, path=path,
    163                                 factory=IpServiceClass, port=port)
    164          self.serviceclass.addRelation(srvclass)
    165
    166
    167 -    def getSendString(self):
    168          return self.getAqProperty("sendString")
    169
    170
    171 -    def getExpectRegex(self):
    172          return self.getAqProperty("expectRegex")
    173
    174
    175 -    def getServiceClass(self):
    176          """
    177          Return a dict like one set by IpServiceMap for services.
    178          """
    179          svc = self.serviceclass()
    180          if svc:
    181              return {'protocol': self.protocol, 'port': self.port }
    182          return {}
    183
    184
    185 -    def primarySortKey(self):
    186          return "%s-%05d" % (self.protocol, self.port)
    187
    188 -    def getManageIp(self):
    189          """
    190          A service can listen on multiple interfaces on a device,
    191          and the interface it listens on may not be the same one
    192          that is the manageIp for the device.
    193
    194          @return: IP address to contact the service on
    195          @rtype: string
    196          """
    197          if self.manageIp:
    198              # List of IP address
    199              interfaces = self.getNonLoopbackIpAddresses()
    200              if self.manageIp in interfaces:
    201                 if self.manageIp in self.ipaddresses or \
    202                    '0.0.0.0' in self.ipaddresses:
    203                     return self.manageIp
    204              # Oops! Our management IP is no longer here
    205
    206          return self._getManageIp()
    207
    208 -    def _getManageIp(self):
    209          """
    210          Pick an IP out of available choices.
    211
    212          @return: IP address to contact the service on
    213          @rtype: string
    214          """
    215          manage_ip = Service.getManageIp(self)
    216          bare_ip = manage_ip.split('/',1)[0]
    217          if bare_ip in self.ipaddresses:
    218              return bare_ip
    219
    220          for ip in self.ipaddresses:
    221              if ip != '0.0.0.0' and ip != '127.0.0.1':
    222                  return ip
    223          return bare_ip
    224
    225 -    def setManageIp(self, manageIp):
    226          """
    227          Manually set the management IP address to check the
    228          service status.
    229
    230          @parameter manageIp: IP address to check the service health
    231          @type manageIp: string
    232          """
    233          if not manageIp:
    234              return
    235
    236          bare_ip = manageIp.split('/',1)[0]
    237          if not isip(bare_ip):
    238              return
    239
    240          ips = self.getIpAddresses()
    241          if '0.0.0.0' in self.ipaddresses and bare_ip in ips:
    242              self.manageIp = bare_ip
    243
    244          if bare_ip in self.ipaddresses:
    245              self.manageIp = bare_ip
    246
    247 -    def unsetManageIp(self):
    248          """
    249          Remove a prevously set management IP address to check the
    250          service status.
    251          """
    252          self.manageIp = ''
    253
    254 -    def getIpAddresses(self):
    255          """
    256          List the IP addresses to which we can contact the service.
    257
    258          @return: list of IP addresses
    259          @rtype: array of strings
    260          """
    261          ips = [ ip for ip in self.ipaddresses \
    262              if ip != '0.0.0.0' and ip != '127.0.0.1' ]
    263          if not ips:
    264              ips = Service.getNonLoopbackIpAddresses(self)
    265              ips = [ x.split('/',1)[0] for x in ips ]
    266          return ips
    267
    268
    269 -    def getProtocol(self):
    270          return self.protocol
    271
    272 -    def getPort(self):
    273          return self.port
    274
    275 -    def getKeyword(self):
    276          sc = self.serviceclass()
    277          if sc: return sc.name
    278
    279 -    def getDescription(self):
    280          sc = self.serviceclass()
    281          if sc: return sc.description
    282
    283 -    def ipServiceClassUrl(self):
    284          sc = self.serviceclass()
    285          if sc: return sc.getPrimaryUrlPath()
    286
    287
    288      security.declareProtected('Manage DMD', 'manage_editService')
    289 -    def manage_editService(self, id=None,
    290                          status=None, ipaddresses=None,
    291                          manageIp=None,
    292                          protocol=None, port=None,
    293                          description=None,
    294                          monitor=False, severity=5, sendString="",
    295                          expectRegex="", REQUEST=None):
    296          """
    297          Edit a Service from a web page.
    298          """
    299          if id:
    300              self.rename(id)
    301              if status: self.status = status
    302              self.ipaddresses = ipaddresses
    303              self.description = description
    304              self.protocol = protocol
    305              self._updateProperty('port', port)
    306
    307
    308              if protocol != self.protocol or port != self.port:
    309                  self.setServiceClass({'protocol':protocol, 'port':int(port)})
    310
    311          self.setManageIp(manageIp)
    312
    313          msg = []
    314          msg.append(self.setAqProperty("sendString", sendString, "string"))
    315          msg.append(self.setAqProperty("expectRegex", expectRegex, "string"))
    316          self.index_object()
    317
    318          return super(IpService, self).manage_editService(monitor, severity,
    319                                          msg=msg,REQUEST=REQUEST)
    320
    321
    322  InitializeClass(IpService)
    323