Package Products :: Package ZenUtils :: Module ZCmdBase |
[hide private]
[frames] | no frames]

# Source Code for Module Products.ZenUtils.ZCmdBase

      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__="""ZenDaemon
     15
     16  $Id: ZC.py,v 1.9 2004/02/16 17:19:31 edahl Exp $"""
     17
     18  __version__ = "$Revision: 1.9 $"[11:-2]
     19
     20  from threading import Lock
     21
     22  from AccessControl.SecurityManagement import newSecurityManager
     23  from AccessControl.SecurityManagement import noSecurityManager
     24  from Products.Five import zcml
     25
     26  from Utils import getObjByPath, zenPath
     27
     28  from Exceptions import ZentinelException
     29  from ZenDaemon import ZenDaemon
     30
     31  from Products.ZenRelations.ZenPropertyManager import setDescriptors
     32
     33  import os
     34  defaultCacheDir = zenPath('var')
     35
     36 -class DataRootError(Exception):pass
     37
     38 -def login(context, name='admin', userfolder=None):
     39      '''Logs in.'''
     40      if userfolder is None:
     41          userfolder = context.getPhysicalRoot().acl_users
     42      user = userfolder.getUserById(name)
     43      if user is None: return
     44      if not hasattr(user, 'aq_base'):
     45          user = user.__of__(userfolder)
     46      newSecurityManager(None, user)
     47      return user
     48
     49 -class ZCmdBase(ZenDaemon):
     50
     51 -    def __init__(self, noopts=0, app=None, keeproot=False):
     52          import Products.ZenossStartup
     53          zcml.load_site()
     54          ZenDaemon.__init__(self, noopts, keeproot)
     55          self.dataroot = None
     56          self.app = app
     57          self.db = None
     58          if not app:
     59              try:
     60                  self.zeoConnect()
     61              except ValueError:
     62                  cache = os.path.join(self.options.pcachedir,
     63                                       '%s.zec' % self.options.pcachename)
     64                  if os.path.exists(cache):
     65                      self.log.warning("Deleting corrupted cache %s" % cache)
     66                      os.unlink(cache)
     67                      self.zeoConnect()
     68                  else:
     69                      raise
     70          self.poollock = Lock()
     71          self.getDataRoot()
     72          self.login()
     73          setDescriptors(self.dmd.propertyTransformers)
     74
     75 -    def zeoConnect(self):
     76          from ZEO.ClientStorage import ClientStorage
     77          storage=ClientStorage((self.options.host, self.options.port),
     78                                client=self.options.pcachename,
     79                                var=self.options.pcachedir,
     80                                cache_size=self.options.pcachesize*1024*1024)
     81          from ZODB import DB
     82          self.db = DB(storage, cache_size=self.options.cachesize)
     83
     84
     85 -    def login(self, name='admin', userfolder=None):
     86          '''Logs in.'''
     87          login(self.dmd, name, userfolder)
     88
     89
     90 -    def logout(self):
     91          '''Logs out.'''
     92          noSecurityManager()
     93
     94
     95 -    def getConnection(self):
     96          """Return a wrapped app connection from the connection pool.
     97          """
     98          if not self.db:
     99              raise ZentinelException(
    100                  "running inside zope can't open connections.")
    101          try:
    102              self.poollock.acquire()
    103              connection=self.db.open()
    104              root=connection.root()
    105              app=root['Application']
    106              app = self.getContext(app)
    107              app._p_jar.sync()
    108              return app
    109          finally:
    110              self.poollock.release()
    111
    112
    113 -    def closeAll(self):
    114          """Close all connections in both free an inuse pools.
    115          """
    116          self.db.close()
    117
    118
    119 -    def opendb(self):
    120          if self.app: return
    121          self.connection=self.db.open()
    122          root=self.connection.root()
    123          app=root['Application']
    124          self.app = self.getContext(app)
    125
    126
    127 -    def syncdb(self):
    128          self.connection.sync()
    129
    130
    131 -    def closedb(self):
    132          self.connection.close()
    133          #self.db.close()
    134          self.app = None
    135          self.dataroot = None
    136          self.dmd = None
    137
    138
    139 -    def getDataRoot(self):
    140          if not self.app: self.opendb()
    141          if not self.dataroot:
    142              self.dataroot = getObjByPath(self.app, self.options.dataroot)
    143              self.dmd = self.dataroot
    144
    145
    146 -    def getContext(self, app):
    147          from ZPublisher.HTTPRequest import HTTPRequest
    148          from ZPublisher.HTTPResponse import HTTPResponse
    149          from ZPublisher.BaseRequest import RequestContainer
    150          resp = HTTPResponse(stdout=None)
    151          env = {
    152              'SERVER_NAME':'localhost',
    153              'SERVER_PORT':'8080',
    154              'REQUEST_METHOD':'GET'
    155              }
    156          req = HTTPRequest(None, env, resp)
    157          return app.__of__(RequestContainer(REQUEST = req))
    158
    159
    160 -    def getDmdObj(self, path):
    161          """return an object based on a path starting from the dmd"""
    162          return getObjByPath(self.app, self.options.dataroot+path)
    163
    164
    165 -    def findDevice(self, name):
    166          """return a device based on its FQDN"""
    167          devices = self.dataroot.getDmdRoot("Devices")
    168          return devices.findDevice(name)
    169
    170 -    def sigTerm(self, signum=None, frame=None):
    171          pass
    172
    173 -    def buildOptions(self):
    174          """basic options setup sub classes can add more options here"""
    175          ZenDaemon.buildOptions(self)
    176          self.parser.add_option('--host',
    177                      dest="host",default="localhost",
    178                      help="hostname of zeo server")
    179          self.parser.add_option('--port',
    180                      dest="port",type="int", default=8100,
    181                      help="port of zeo server")
    182          self.parser.add_option('-R', '--dataroot',
    183                      dest="dataroot",
    184                      default="/zport/dmd",
    185                      help="root object for data load (i.e. /zport/dmd)")
    186          self.parser.add_option('--cachesize',
    187                      dest="cachesize",default=1000, type='int',
    188                      help="in memory cachesize default: 1000")
    189          self.parser.add_option('--pcachename',
    190                      dest="pcachename",default=None,
    191                      help="persistent cache file name default:None")
    192          self.parser.add_option('--pcachedir',
    193                      dest="pcachedir",default=defaultCacheDir,
    194                      help="persistent cache file directory")
    195          self.parser.add_option('--pcachesize',
    196                      dest="pcachesize",default=10, type='int',
    197                      help="persistent cache file size in MB")
    198