Source Code for Module arcjobtool.plugins.Plugins

  1  """ 
  2  Plugin support module 
  3  """ 
  4   
  5  import os, sys, arc 
  6   
  7 -class PluginBase(object): 
  8      """ 
  9      Base class for ArcGui plugins. 
 10      """ 
 11       
 12 -    def __init__(self): 
 13          self.__filename = "noname.lpi" 
 14          self.onInit() 
 15       
 16 -    def onInit(self): 
 17          pass 
 18    
 19 -    def onDestroy(self): 
 20          pass 
 21       
 22 -    def onEdit(self): 
 23          pass 
 24       
 25 -    def onSetup(self): 
 26          pass 
 27       
 28 -    def onClean(self): 
 29          pass 
 30       
 31 -    def onSave(self, workDir): 
 32          pass 
 33       
 34 -    def onLoad(self, workDir): 
 35          pass 
 36               
 37 -    def onGetId(self): 
 38          return "PluginBase" 
 39       
 40 -    def onGetVersion(self): 
 41          return (0,0,0) 
 42           
 43 -    def onGetShortName(self): 
 44          return "Base plugin" 
 45           
 46 -    def onGetDescription(self): 
 47          return "Base plugin should not be used directly." 
 48       
 49 -    def onNeedSave(self): 
 50          return False 
 51       
 52 -    def onGetTask(self): 
 53          return None 
 54       
 55 -    def getFilename(self): 
 56          return self.__filename 
 57       
 58 -    def setFilename(self, filename): 
 59          self.__filename = filename 
 60           
 61 -    def setWorkDir(self, workDir): 
 62          self.__workDir = workDir 
 63           
 64 -    def getWorkDir(self): 
 65          return self.__workDir 
 66       
 67      id = property(onGetId) 
 68      version = property(onGetVersion) 
 69      filename = property(getFilename, setFilename) 
 70      shortname = property(onGetShortName) 
 71      description = property(onGetDescription) 
 72      workDir = property(getWorkDir, setWorkDir) 
 73      task = property(onGetTask) 
 74           
 75  instance = None 
 76   
 77 -class PluginManager(object): # subclassing from object for 2.2, unnecessary after that 
 78      """ 
 79      Class for managing plugins in ArcGui. 
 80      """ 
 81 -    def __new__(cls): 
 82          """ 
 83          Overloaded new method to make sure we only have one instance 
 84          of a plugin manager. 
 85          """ 
 86           
 87          global instance 
 88           
 89          if instance is not None: 
 90              return instance 
 91       
 92          instance = object.__new__(cls) 
 93          return instance 
 94       
 95 -    def logMsg(self, level, msg): 
 96          if self.__logger!=None: 
 97              self.__logger.msg(level, msg) 
 98           
 99 -    def logInfoMsg(self, msg): 
100          if self.__logger!=None: 
101              self.logMsg(arc.INFO, msg) 
102       
103 -    def logDebugMsg(self, msg): 
104          if self.__logger!=None: 
105              self.logMsg(arc.DEBUG, msg) 
106   
107 -    def logErrorMsg(self, msg): 
108          if self.__logger!=None: 
109              self.logMsg(arc.ERROR, msg)     
110       
111 -    def __init__(self): 
112          """ 
113          Plugin manager constructor. 
114           
115          Loads plugins from plugin directory. Creates a dictionary of 
116          subclasses. 
117          """ 
118           
119          self.__logger = arc.Logger(arc.Logger_getRootLogger(), "PluginManager") 
120           
121          self.logInfoMsg("Init plugin manager...") 
122           
123          # Initialise instance variables 
124           
125          self.__pluginPath = "" 
126          self.__pluginClassDict = {} 
127           
128          # Figure out plugin directory 
129           
130          if os.environ.has_key("ARCJOBTOOL_LIB"): 
131              self.__pluginPath = os.path.join(os.environ["ARCJOBTOOL_LIB"], "arcjobtool/plugins") 
132          else: 
133              self.__pluginPath = "./plugins" 
134   
135          self.logInfoMsg("Finding plugins...") 
136           
137          # Find and load plugins 
138               
139          dirList = os.listdir(self.__pluginPath) 
140           
141          for dirItem in dirList: 
142              fullPath = os.path.join(self.__pluginPath, dirItem) 
143              if os.path.isfile(fullPath): 
144                  if os.path.splitext(fullPath)[1] == ".py": 
145                      if dirItem!="Plugins.py": 
146                          self.__loadPlugin(dirItem.split(".py")[0]) 
147           
148          # Store loaded subclasses in a dictionary 
149                           
150          for pluginClass in PluginBase.__subclasses__(): 
151              self.__pluginClassDict[pluginClass.__name__] = pluginClass 
152               
153                       
154 -    def __loadPlugin(self, plugin): 
155          """ 
156          Load plugin from plugin dir. 
157          """ 
158          self.logInfoMsg("Importing: "+plugin) 
159          __import__("arcjobtool.plugins."+plugin) 
160   
161 -    def getPlugins(self): 
162          return PluginBase.__subclasses__() 
163           
164 -    def pluginFromId(self, pluginId): 
165          """ 
166          Return plugin instance from string pluginId. 
167          """ 
168          if self.__pluginClassDict.has_key(pluginId): 
169              return self.__pluginClassDict[pluginId]() 
170          else: 
171              return None 
172           
173 -    def pluginFromWorkDir(self, workDir): 
174          """ 
175          Return plugin instance based on definition dir. 
176          """ 
177          pluginIdFilename = os.path.join(workDir, "plugin.id") 
178          if os.path.exists(pluginIdFilename): 
179              pluginIdFile = open(pluginIdFilename, "r") 
180              pluginId = pluginIdFile.read().strip() 
181              pluginIdFile.close() 
182               
183              return self.pluginFromId(pluginId) 
184          else: 
185              return None 
186           
187      plugins = property(getPlugins) 
188