GBSManager.py

Go to the documentation of this file.

import os
import re
import sys

from GBSConfig import GetConfigValue
from GBSLogger import Log, logger 
from GBSObject import GBSObject
from GBSModelRegistry import GetModelRegistry
from schema_migrator import migrate

class GBSManager(GBSObject) :

    """Top level object from which to create, list and destroy Tasks.

    This class inherits from GBSObject and adds the following user callable methods
      
    """

    ######  GBSObject inherited responsibilities   ###### 
      

    # Note that for this top level object: parent = None, model = 'default' and model_args = {}
    def __init__(self,name,parent,model,model_args):
        self.__schemaVersion      = 0    # Incremented each time the schema changes (See schema_migrator.py)
        self.__taskManagers       = {}   # Volatile: Hash name -> Task
        self.__taskManagersModels = {}   # Volatile: Hash name -> Task models
        
        GBSObject.__init__(self,name,parent,model)

        self.MakeChildDirectory()
        self.__ReloadChildren()

        # Migrate schema
        migrate(self)
        
        # Perform any house-keeping chores.
        self.__HouseKeeping()
        
    def _DoMemberIO(self,ioh):
        self.__schemaVersion = ioh("+Schema Version","i",self.__schemaVersion)
        GBSObject._DoMemberIO(self,ioh)

    def WriteFamily(self):
        self.Write()
        for task_name,task in self.__taskManagers.iteritems():task.WriteFamily()

    def GetType(self):          return "GBSManager"

    def __repr__(self) :
        return GBSObject.__repr__(self) + "\n"\
               + "Schema version " + str(self.__schemaVersion) + "\n"\
               + "Managing " + str(len(self.__taskManagers)) + " Tasks"

    
    ######  User Callable Methods (Getters then Setters)  ###### 

    def GetTask(self,name) :

        """Retrieve existing Task e.g. task = manager.GetTask("Fred")"""
        
        if not self.__taskManagers.has_key(name):
            print "Sorry, there is no Task named " + str(name)
            return None
        else : return self.__taskManagers[name]

    def ListModels(self):

        """List all available models"""

        print "The following models are available:-\n"
        reg = GetModelRegistry().GetRegistry()
        for m_name,m in reg.iteritems():
            print "Model: " + m_name
            print "*"*(len(m_name)+7) + "\n"
            print "Title:" + m.GetTitle() + "\nDescription:"
            print m.GetDescription()

    def ListTasks(self):

        """List all existing Tasks"""
        
        print "The following tasks are setup up:-\n"
        first = 1
        for task_name,task in self.__taskManagers.iteritems():
            if first:
                print task.AsString("Heading") + "\n"
                first = 0
            print task.AsString("Brief")

    def GetSchemaVersion(self):

        """Return current schema version number."""

        return self.__schemaVersion

    def AddTask(self,task_name,model_name="default"):

        """Create a new Task called task_name using model model_name e.g. task = manager.AddTask("Joe","default")"""
        
        #  Check that the name is legal and not already in use.
        if re.search(r"[^a-zA-Z0-9_\-]",task_name):
            print "Sorry, '" + str(task_name) + "' is an illegal task name (characters other than alphanumeric, '_' and '-')"
            return
        if self.__taskManagers.has_key(task_name):
            print "Sorry, there already is a Task named " + str(task_name)
            return None

        #  Check the model is valid
        model_name_valid = 0
        reg = GetModelRegistry().GetRegistry()
        for m_name,m in reg.iteritems():
            if model_name == m_name: model_name_valid = 1
        if not model_name_valid:
            print "Sorry %s is not a valid model, the following are available:-" % model_name
            for m_name,m in reg.iteritems():
                print "  " + m_name.ljust(15) + m.GetTitle()
            return None        
        tm = GetModelRegistry().CreateObject(model_name,"Task",task_name,self)
        self.__taskManagers[task_name]       = tm
        self.__taskManagersModels[task_name] = model_name
        return tm
            
    ######  Private Methods (not user callable)  ######

    def __HouseKeeping(self):
        """Perform start up house-keeping chores."""

        chores = GetConfigValue("HouseKeepingCommands")
        if ( chores ):
            print "Manager performing start of job house-keeping:-"
            for chore in chores.split(' ;'):
                print "  %s " % chore
                exit_code = os.system(chore)
                if exit_code: print "   - command failed with exit code %d" % exit_code
            
    def __ReloadChildren(self):

        """Reload child Tasks from disk.

        Loop over all *.state files, read their model name and then recreate."""

        import os, re

        child_dir         = self.GetStoreLocation("child_dir")
        child_state_files = os.listdir(child_dir)
        for child_state_file in child_state_files:

            #  Only look at *.state files
            child_state_file_spec = child_dir + "/" + child_state_file
            if not os.path.isfile(child_state_file_spec): continue
            mo = re.search(r"^(.*)\.state$",child_state_file)
            if not mo: continue
            child_name = mo.group(1)

            #  Have to sneak a look at the child's state file to get the model.
            #  This is the one case where the parent's model may not be the same
            #  as the child's; Manager is always the "default" model
            child_model = ""
            f = open(child_state_file_spec)
            for line in f:
                mo = re.search(r"Model Name:\s*(\S+)",line)
                if mo: child_model = mo.group(1)
            f.close()
            
            if not child_model:
                Log(self,logger.ERROR,"GBSManager: Cannot find model for Task in " + str(child_state_file_spec))
                continue
            self.AddTask(child_name,child_model)

    def _SetSchemaVersion(self,ver):

        """Set current schema version number."""

        self.__schemaVersion = ver
        self.Write()

---