def getFromJobId(cls, jobId):
"""
create a JobFacade to access an existing job.
@param jobId: the job identifier
@type jobId: string
@return: the appropriate job facade
@rtype: JobFacade
"""
jobState = JobState(jobId)
jfargs = {'jobId': jobState.getID(),'programUrl':None,'workflowUrl':None}
if jobState.isWorkflow():
jfargs['workflowUrl'] = jobState.getName()
else:
jfargs['programUrl']= jobState.getName()
# this id is identical to the one in parameter,
# except it has been normalized (may have removed
# trailing index.xml from the id)
if jobState.isLocal():
return(LocalJobFacade(**jfargs))
else:
return(RemoteJobFacade(**jfargs))
class AsynchronJob:
"""
is instantiated in child process instantiate the object corresponding
to the execution manager defined in Config, and after the completion of the job
manage the results
"""
def __init__(self, commandLine, dirPath, serviceName, resultsMask , userEmail = None, email_notify = 'auto' , jobState = None , xmlEnv = None):
"""
@param commandLine: the command to be executed
@type commandLine: String
@param dirPath: the absolute path to directory where the job will be executed (normaly we are already in)
@type dirPath: String
@param serviceName: the name of the service
@type serviceName: string
@param resultsMask: the unix mask to retrieve the results of this job
@type resultsMask: a dictionary { paramName : [ string prompt , ( string class , string or None superclass ) , string mask ] }
@param userEmail: the user email adress
@type userEmail: string
@param email_notify: if the user must be or not notify of the results at the end of the Job.
the 3 authorized values for this argument are:
- 'true' to notify the results to the user
- 'false' to Not notify the results to the user
- 'auto' to notify the results based on the job elapsed time and the config EMAIL_DELAY
@type email_notify: string
@param jobState: the jobState link to this job
@type jobState: a L{JobState} instance
@param xmlEnv: the environement variable need by the program
@type xmlEnv: dictionnary
@call: by the main of this module which is call by L{AsynchronRunner}
"""
self._command = commandLine
self._dirPath = dirPath
self.serviceName = serviceName
self.father_pid = os.getppid()
self.father_done = False
if jobState is None:
self.jobState = JobState( self._dirPath )
else:
self.jobState = jobState
self.userEmail = userEmail
self.email_notify = email_notify
if self._dirPath[-1] == '/':
self._dirPath = self._dirPath[:-1]
self.jobKey = os.path.split( self._dirPath )[ 1 ]
atexit.register( self.childExit , "------------------- %s : %s -------------------" %( serviceName , self.jobKey ) )
t0 = time.time()
############################################
self._run( serviceName , xmlEnv )
#############################################
t1 = time.time()
self.results = {}
for paramName in resultsMask.keys():
resultsFiles = []
#type is a tuple ( klass , superKlass )
masks = resultsMask[ paramName ]
for mask in masks :
for File in glob.glob( mask ):
size = os.path.getsize( File )
if size != 0:
resultsFiles.append( ( str( File ) , size , None ) ) #we have not information about the output format
if resultsFiles:
self.results[ paramName ] = resultsFiles #a list of tuple (string file name , int size , string format or None )
self.jobState.setOutputDataFile( paramName , resultsFiles )
self.jobState.commit()
try:
zipFileName = self.zipResults()
except Exception :
msg = "an error occured during the zipping results :\n\n"
rc_log.critical( "%s/%s : %s" %( self.serviceName , self.jobKey , msg ) , exc_info = True)
zipFileName = None
if self.userEmail:
if self.email_notify == 'auto':
# we test email_delay() to see if it is >= to 0,
# as it seems that sometimes it is not >0.
if ( t1 - t0 ) >= _cfg.email_delay():
emailResults(_cfg,
self.userEmail,
registry ,
self.jobState.getID(),
self._dirPath ,
self.serviceName ,
self.jobKey ,
FileName = zipFileName )
elif self.email_notify == 'true':
emailResults( _cfg,
self.userEmail,
registry ,
self.jobState.getID(),
self._dirPath ,
self.serviceName ,
self.jobKey ,
FileName = zipFileName )
else:
pass
def childExit(self , message ):
print >> sys.stderr , message
#rc_log.log( 12 , "runnerChild %d ending, send a SIGCHLD to %d" %( os.getpid() , self.father_pid ) )
def _run(self , serviceName, xmlEnv ):
dispatcher = _cfg.getDispatcher()
execution_config = dispatcher.getExecutionConfig( self.jobState )
try:
exec_engine = executionLoader( execution_config = execution_config )
except MobyleError ,err :
msg = "unknown execution system : %s" %err
rc_log.critical("%s : %s" %( serviceName ,
msg
), exc_info = True
)
sm = StatusManager()
sm.setStatus( self._dirPath , Status( code = 5 , message = 'Mobyle internal server error' ) )
raise MobyleError, msg
except Exception , err:
rc_log.error( str(err ), exc_info=True)
raise err
