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

# Source Code for Module Products.ZenModel.OSProcess

      1  ##############################################################################
      2  #
      3  # Copyright (C) Zenoss, Inc. 2007, all rights reserved.
      4  #
      5  # This content is made available according to terms specified in
      6  # License.zenoss under the directory where your Zenoss product is installed.
      7  #
      8  ##############################################################################
      9
     10
     11  from Globals import InitializeClass
     12  from AccessControl import ClassSecurityInfo
     13  from AccessControl import Permissions
     14  from Products.ZenModel.ZenossSecurity import *
     15
     16  from Commandable import Commandable
     17  from Products.ZenRelations.RelSchema import *
     18  from Products.ZenWidgets import messaging
     19  from Acquisition import aq_chain
     20
     21  from OSComponent import OSComponent
     22  from ZenPackable import ZenPackable
     23  from md5 import md5
     24
     25 -def manage_addOSProcess(context, newClassName, userCreated, REQUEST=None):
     26      """
     27      Make an os process from the ZMI
     28      """
     29      id = newClassName.split('/')[-1]
     30      osp = OSProcess(id)
     31      # Indexing is subscribed to ObjectAddedEvent, which fires
     32      # on _setObject, so we want to set process class first.
     33      osp.__of__(context).setOSProcessClass(newClassName)
     34      context._setObject(id, osp)
     35      osp = context._getOb(id)
     36      osp.procName = id
     37      if userCreated: osp.setUserCreateFlag()
     38      if REQUEST is not None:
     39          REQUEST['RESPONSE'].redirect(context.absolute_url()+'/manage_main')
     40      return osp
     41
     42
     43 -def createFromObjectMap(context, objectMap):
     44      om = objectMap
     45      device = context.device()
     46      processes = context.device().getDmdRoot("Processes")
     47      pcs = processes.getSubOSProcessClassesSorted()
     48      fullname = (om.procName + ' ' + om.parameters).rstrip()
     49      for pc in pcs:
     50          if pc.match(fullname):
     51              id = getProcessIdentifier(om.procName, None if pc.ignoreParameters else om.parameters)
     52              result = OSProcess(device.prepId(id))
     53              om.setOSProcessClass = pc.getPrimaryDmdId()
     54              return result
     55
     56
     57 -def getProcessIdentifier(name, parameters):
     58      """
     59      Get a process identifier string from the name and parameters of the process.
     60      """
     61      return ('%s %s' % (name, md5((parameters or '').strip()).hexdigest())).strip()
     62
     63
     64 -class OSProcess(OSComponent, Commandable, ZenPackable):
     65      """
     66      OSProcess object
     67      """
     68      portal_type = meta_type = 'OSProcess'
     69
     70      procName = ""
     71      parameters = ""
     72      _procKey = ""
     73
     74      collectors = ('zenprocess','zencommand')
     75
     76      _properties = OSComponent._properties + (
     77          {'id':'procName', 'type':'string', 'mode':'w'},
     78          {'id':'parameters', 'type':'string', 'mode':'w'},
     79          {'id':'zAlertOnRestarts', 'type':'boolean', 'mode':'w'},
     80          {'id':'zFailSeverity', 'type':'int', 'mode':'w'},
     81      )
     82
     83      _relations = OSComponent._relations + ZenPackable._relations + (
     84          ("os", ToOne(ToManyCont, "Products.ZenModel.OperatingSystem", "processes")),
     85          ("osProcessClass", ToOne(ToMany, "Products.ZenModel.OSProcessClass", "instances")),
     86          ('userCommands', ToManyCont(ToOne, 'Products.ZenModel.UserCommand', 'commandable')),
     87      )
     88
     89      factory_type_information = (
     90          {
     91              'immediate_view' : 'osProcessDetail',
     92              'actions'        :
     93              (
     94                  { 'id'            : 'status'
     95                  , 'name'          : 'Status'
     96                  , 'action'        : 'osProcessDetail'
     97                  , 'permissions'   : ( Permissions.view, )
     98                  },
     99                  { 'id'            : 'events'
    100                  , 'name'          : 'Events'
    101                  , 'action'        : 'viewEvents'
    102                  , 'permissions'   : (ZEN_VIEW, )
    103                  },
    104                  { 'id'            : 'perfConf'
    105                  , 'name'          : 'Template'
    106                  , 'action'        : 'objTemplates'
    107                  , 'permissions'   : ("Change Device", )
    108                  },
    109                  { 'id'            : 'manage'
    110                  , 'name'          : 'Administration'
    111                  , 'action'        : 'osProcessManage'
    112                  , 'permissions'   : ("Manage DMD",)
    113                  },
    114              )
    115           },
    116          )
    117
    118      security = ClassSecurityInfo()
    119
    120
    121 -    def getOSProcessConf(self):
    122          """
    123          Return information used to monitor this process.
    124          """
    125          ignoreParams = getattr(self.osProcessClass(), 'ignoreParameters', False)
    126          return (self.id, self.name(), ignoreParams,
    127                  self.alertOnRestart(), self.getFailSeverity())
    128
    129
    130 -    def setOSProcessClass(self, procKey):
    131          """
    132          Set the OSProcessClass based on procKey which is the proc + args.
    133          We set by matching regular expressions of each proces class.
    134          """
    135          klass = self.getDmdObj(procKey)
    136          klass.instances.addRelation(self)
    137
    138
    139 -    def getOSProcessClass(self):
    140          """
    141          Return the current procKey.
    142          """
    143          pClass = self.osProcessClass()
    144          if pClass:
    145              return pClass.getPrimaryDmdId()
    146
    147
    148 -    def getOSProcessClassLink(self):
    149          """
    150          Return an a link to the OSProcessClass.
    151          """
    152          proccl = self.osProcessClass()
    153          if proccl:
    154              if self.checkRemotePerm("View", proccl):
    155                  return "<a href='%s'>%s</a>" % (proccl.getPrimaryUrlPath(),
    156                                                  proccl.getOSProcessClassName())
    157              else:
    158                  return proccl.getOSProcessClassName()
    159          return ""
    160
    161
    162 -    def name(self):
    163          """
    164          Return a string that is the process name and, if ignoreParamaters
    165          is not True, then also the parameters.
    166          """
    167          ignoreParams = getattr(self.osProcessClass(), 'ignoreParameters', False)
    168          if not self.parameters or ignoreParams:
    169              return self.procName
    170          return self.procName + " " + self.parameters
    171
    172      title = name
    173
    174 -    def monitored(self):
    175          """
    176          Should this service be monitored or not. Use ServiceClass aq path.
    177          """
    178          return self.getAqProperty("zMonitor")
    179
    180
    181 -    def alertOnRestart(self):
    182          """
    183          Retrieve the zProperty zAlertOnRestart
    184          """
    185          return self.getAqProperty("zAlertOnRestart")
    186
    187
    188 -    def getSeverities(self):
    189          """
    190          Return a list of tuples with the possible severities
    191          """
    192          return self.ZenEventManager.getSeverities()
    193
    194
    195 -    def getFailSeverity(self):
    196          """
    197          Return the severity for this service when it fails.
    198          """
    199          return self.getAqProperty("zFailSeverity")
    200
    201
    202 -    def getFailSeverityString(self):
    203          """
    204          Return a string representation of zFailSeverity
    205          """
    206          return self.ZenEventManager.severities[self.getAqProperty("zFailSeverity")]
    207
    208
    209 -    def getClassObject(self):
    210          """
    211          Return the ProcessClass for this proc
    212          """
    213          return self.osProcessClass()
    214
    215
    216      security.declareProtected('Manage DMD', 'manage_editOSProcess')
    217 -    def manage_editOSProcess(self, zMonitor=False, zAlertOnRestart=False,
    218                               zFailSeverity=3, msg=None,REQUEST=None):
    219          """
    220          Edit a Service from a web page.
    221          """
    222          if msg is None: msg=[]
    223          msg.append(self.setAqProperty("zMonitor", zMonitor, "boolean"))
    224          msg.append(self.setAqProperty("zAlertOnRestart",zAlertOnRestart,"int"))
    225          msg.append(self.setAqProperty("zFailSeverity",zFailSeverity,"int"))
    226          msg = [ m for m in msg if m ]
    227          self.index_object()
    228          if not msg: msg.append("No action needed")
    229          if REQUEST:
    230              messaging.IMessageSender(self).sendToBrowser(
    231                  'Process Edited',
    232                  ", ".join(msg) + ":"
    233              )
    234              return self.callZenScreen(REQUEST)
    235
    236
    237 -    def getUserCommandTargets(self):
    238          '''
    239          Called by Commandable.doCommand() to ascertain objects on which
    240          a UserCommand should be executed.
    241          '''
    242          return [self]
    243
    244
    245 -    def getUserCommandEnvironment(self):
    246          """
    247          Return the environment to be used when processing a UserCommand
    248          """
    249          environ = Commandable.getUserCommandEnvironment(self)
    250          context = self.primaryAq()
    251          environ.update({'proc': context,  'process': context,})
    252          return environ
    253
    254
    255 -    def getAqChainForUserCommands(self):
    256          """
    257          Setup the aq chain as appropriate for the execution of a UserCommand
    258          """
    259          chain = aq_chain(self.getClassObject().primaryAq())
    260          chain.insert(0, self)
    261          return chain
    262
    263
    264 -    def getUrlForUserCommands(self):
    265          """
    266          Return the url where UserCommands are viewed for this object
    267          """
    268          return self.getPrimaryUrlPath() + '/osProcessManage'
    269
    270 -    def filterAutomaticCreation(self):
    271          # get the processes defined in Zenoss
    272          pcs = sorted(self.getDmdRoot("Processes").getSubOSProcessClassesGen(), key=lambda a: a.sequence)
    273
    274          fullname = (self.procName + ' ' + self.parameters).rstrip()
    275          for pc in pcs:
    276              if pc.match(fullname):
    277                  self.setOSProcessClass(pc.getPrimaryDmdId())
    278                  self.id = self.prepId(getProcessIdentifier(om.procName,
    279                                        None if pc.ignoreParameters else om.parameters))
    280                  return True
    281          return False
    282
    283
    284  InitializeClass(OSProcess)
    285