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 or (at your 
  8  # option) any later version as published by 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      title = name 
179   
180 -    def monitored(self): 
181          """ 
182          Should this service be monitored or not. Use ServiceClass aq path.  
183          """ 
184          return self.getAqProperty("zMonitor") 
185   
186   
187 -    def alertOnRestart(self): 
188          """ 
189          Retrieve the zProperty zAlertOnRestart 
190          """ 
191          return self.getAqProperty("zAlertOnRestart") 
192   
193   
194 -    def getSeverities(self): 
195          """ 
196          Return a list of tuples with the possible severities 
197          """ 
198          return self.ZenEventManager.getSeverities() 
199   
200   
201 -    def getFailSeverity(self): 
202          """ 
203          Return the severity for this service when it fails. 
204          """ 
205          return self.getAqProperty("zFailSeverity") 
206   
207   
208 -    def getFailSeverityString(self): 
209          """ 
210          Return a string representation of zFailSeverity 
211          """ 
212          return self.ZenEventManager.severities[self.getAqProperty("zFailSeverity")] 
213   
214   
215 -    def getClassObject(self): 
216          """ 
217          Return the ProcessClass for this proc 
218          """ 
219          return self.osProcessClass() 
220   
221   
222      security.declareProtected('Manage DMD', 'manage_editOSProcess') 
223 -    def manage_editOSProcess(self, zMonitor=False, zAlertOnRestart=False, 
224                               zFailSeverity=3, msg=None,REQUEST=None): 
225          """ 
226          Edit a Service from a web page. 
227          """ 
228          if msg is None: msg=[] 
229          msg.append(self.setAqProperty("zMonitor", zMonitor, "boolean")) 
230          msg.append(self.setAqProperty("zAlertOnRestart",zAlertOnRestart,"int")) 
231          msg.append(self.setAqProperty("zFailSeverity",zFailSeverity,"int")) 
232          msg = [ m for m in msg if m ] 
233          self.index_object() 
234          if not msg: msg.append("No action needed") 
235          if REQUEST: 
236              messaging.IMessageSender(self).sendToBrowser( 
237                  'Process Edited', 
238                  ", ".join(msg) + ":" 
239              ) 
240              return self.callZenScreen(REQUEST) 
241   
242   
243 -    def getUserCommandTargets(self): 
244          ''' 
245          Called by Commandable.doCommand() to ascertain objects on which 
246          a UserCommand should be executed. 
247          ''' 
248          return [self]      
249   
250   
251 -    def getUserCommandEnvironment(self): 
252          """ 
253          Return the environment to be used when processing a UserCommand 
254          """ 
255          environ = Commandable.getUserCommandEnvironment(self) 
256          context = self.primaryAq() 
257          environ.update({'proc': context,  'process': context,}) 
258          return environ 
259   
260   
261 -    def getAqChainForUserCommands(self): 
262          """ 
263          Setup the aq chain as appropriate for the execution of a UserCommand 
264          """ 
265          chain = aq_chain(self.getClassObject().primaryAq()) 
266          chain.insert(0, self) 
267          return chain 
268   
269   
270 -    def getUrlForUserCommands(self): 
271          """ 
272          Return the url where UserCommands are viewed for this object 
273          """ 
274          return self.getPrimaryUrlPath() + '/osProcessManage' 
275   
276 -    def filterAutomaticCreation(self): 
277          # get the processes defined in Zenoss 
278          processes = self.getDmdRoot("Processes") 
279          pcs = list(processes.getSubOSProcessClassesGen()) 
280          pcs.sort(lambda a, b: cmp(a.sequence,b.sequence)) 
281   
282          for pc in pcs: 
283              fullname = (self.procName + ' ' + self.parameters).rstrip() 
284              if pc.match(fullname): 
285                  self.setOSProcessClass(pc.getPrimaryDmdId()) 
286                  self.id = om.procName 
287                  parameters = om.parameters.strip() 
288                  if parameters and not pc.ignoreParameters: 
289                      parameters = md5.md5(parameters).hexdigest() 
290                      self.id += ' ' + parameters 
291                  self.id = self.prepId(id) 
292                  return True 
293          return False 
294   
295   
296  InitializeClass(OSProcess) 
297