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