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

# Source Code for Module Products.ZenModel.OSProcess

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