Source Code for Module Products.ZenUtils.ZenScriptBase

  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  __doc__="""ZenScriptBase 
 15  """ 
 16   
 17  from AccessControl.SecurityManagement import newSecurityManager 
 18  from AccessControl.SecurityManagement import noSecurityManager 
 19  from threading import Lock 
 20  from transaction import commit 
 21  from Utils import getObjByPath, zenPath, set_context 
 22  from CmdBase import CmdBase 
 23  from Products.Five import zcml 
 24   
 25  from Products.ZenRelations.ZenPropertyManager import setDescriptors 
 26  from Exceptions import ZentinelException 
 27   
 28  defaultCacheDir = zenPath('var') 
 29   
 30 -class DataRootError(Exception):pass 
 31   
 32 -class ZenScriptBase(CmdBase): 
 33   
 34 -    def __init__(self, noopts=0, app=None, connect=False): 
 35          import Products.ZenossStartup 
 36          zcml.load_site() 
 37          CmdBase.__init__(self, noopts) 
 38          self.dataroot = None 
 39          self.app = app 
 40          self.db = None 
 41          if connect: 
 42              self.connect() 
 43   
 44 -    def connect(self): 
 45          if not self.app: 
 46              from ZEO import ClientStorage 
 47              from ZODB import DB 
 48              addr = (self.options.host, self.options.port) 
 49              storage=ClientStorage.ClientStorage(addr,  
 50                              client=self.options.pcachename, 
 51                              var=self.options.pcachedir, 
 52                              cache_size=self.options.pcachesize*1024*1024) 
 53              self.db=DB(storage, cache_size=self.options.cachesize) 
 54              self.poollock = Lock() 
 55          self.getDataRoot() 
 56          self.login() 
 57          if getattr(self.dmd, 'propertyTransformers', None) is None: 
 58              self.dmd.propertyTransformers = {} 
 59              commit() 
 60          setDescriptors(self.dmd.propertyTransformers) 
 61   
 62   
 63 -    def login(self, name='admin', userfolder=None): 
 64          '''Logs in.''' 
 65          if userfolder is None: 
 66              userfolder = self.app.acl_users 
 67          user = userfolder.getUserById(name) 
 68          if user is None: return 
 69          if not hasattr(user, 'aq_base'): 
 70              user = user.__of__(userfolder) 
 71          newSecurityManager(None, user) 
 72   
 73   
 74 -    def logout(self): 
 75          '''Logs out.''' 
 76          noSecurityManager() 
 77   
 78   
 79 -    def getConnection(self): 
 80          """Return a wrapped app connection from the connection pool. 
 81          """ 
 82          if not self.db: 
 83              raise ZentinelException( 
 84                  "running inside zope can't open connections.") 
 85          try: 
 86              self.poollock.acquire() 
 87              connection=self.db.open() 
 88              root=connection.root() 
 89              app=root['Application'] 
 90              app = set_context(app) 
 91              app._p_jar.sync() 
 92              return app 
 93          finally: 
 94              self.poollock.release() 
 95   
 96   
 97 -    def closeAll(self): 
 98          """Close all connections in both free an inuse pools. 
 99          """ 
100          self.db.close() 
101   
102   
103 -    def opendb(self): 
104          if self.app: return  
105          self.connection=self.db.open() 
106          root=self.connection.root() 
107          app = root['Application'] 
108          self.app = set_context(app) 
109          self.app._p_jar.sync() 
110   
111   
112 -    def syncdb(self): 
113          self.connection.sync() 
114   
115   
116 -    def closedb(self): 
117          self.connection.close() 
118          #self.db.close() 
119          self.app = None 
120          self.dataroot = None 
121          self.dmd = None 
122   
123   
124 -    def getDataRoot(self): 
125          if not self.app: self.opendb() 
126          if not self.dataroot: 
127              self.dataroot = getObjByPath(self.app, self.options.dataroot) 
128              self.dmd = self.dataroot 
129   
130   
131 -    def getDmdObj(self, path): 
132          """return an object based on a path starting from the dmd""" 
133          return getObjByPath(self.app, self.options.dataroot+path) 
134   
135   
136 -    def findDevice(self, name): 
137          """return a device based on its FQDN""" 
138          devices = self.dataroot.getDmdRoot("Devices") 
139          return devices.findDevice(name) 
140       
141       
142 -    def buildOptions(self): 
143          """basic options setup sub classes can add more options here""" 
144          CmdBase.buildOptions(self) 
145          self.parser.add_option('--host', 
146                      dest="host",default="localhost", 
147                      help="hostname of zeo server") 
148          self.parser.add_option('--port', 
149                      dest="port",type="int", default=8100, 
150                      help="port of zeo server") 
151          self.parser.add_option('-R', '--dataroot', 
152                      dest="dataroot", 
153                      default="/zport/dmd", 
154                      help="root object for data load (i.e. /zport/dmd)") 
155          self.parser.add_option('--cachesize', 
156                      dest="cachesize",default=1000, type='int', 
157                      help="in memory cachesize default: 1000") 
158          self.parser.add_option('--pcachename', 
159                      dest="pcachename",default=None, 
160                      help="persistent cache file name default:None") 
161          self.parser.add_option('--pcachedir', 
162                      dest="pcachedir",default=defaultCacheDir, 
163                      help="persistent cache file directory") 
164          self.parser.add_option('--pcachesize', 
165                      dest="pcachesize",default=10, type='int', 
166                      help="persistent cache file size in MB") 
167