def __init__( self , execution_config ):
"""
@param execution_config: the configuration of the Execution
@type execution_config: ExecutionConfig instance
"""
self._cfg = Config()
self.execution_config = execution_config
self.execution_config_alias = self._cfg.getAliasFromConfig( self.execution_config )
self.status_manager = StatusManager()
def executionLoader(jobID=None, alias=None, execution_config=None):
assert (
bool(jobID) + bool(alias) + bool(execution_config) == 1
), "please provide either a jobID, an alias or an execution_config"
from Mobyle.ConfigManager import Config
cfg = Config()
if not execution_config:
if jobID:
from Mobyle.JobState import normUri
from urlparse import urlparse
path = normUri(jobID)
protocol, host, path, a, b, c = urlparse(path)
if protocol == "http":
raise NotImplementedError, "trying to instanciate an Execution system from a remote Job"
if path[-9:] == "index.xml":
path = path[:-10]
adm = Admin(path)
alias = adm.getExecutionAlias()
if not alias:
msg = "cant determine the Execution system for %s " % (jobID)
u_log.error(msg)
raise MobyleError(msg)
try:
execution_config = cfg.getExecutionConfigFromAlias(alias)
except KeyError:
msg = "the ExecutionConfig alias %s doesn't match with any alias in Config" % alias
u_log.critical(msg)
raise MobyleError(msg)
klass_name = execution_config.execution_class_name
try:
module = __import__("Mobyle.Execution.%s" % klass_name)
except ImportError, err:
msg = "The Execution.%s module is missing" % klass_name
u_log.critical(msg)
raise MobyleError, msg
# COPYING.LIB document. #
# #
#############################################################
"""
Validator.py
This module is used to validate a Mobyle XML file (program or else?)
against the Relax NG schema and the schematron rules
- The Validator class
"""
from lxml import etree
import os
from subprocess import Popen, PIPE
from Mobyle.ConfigManager import Config
_cfg = Config()
from logging import getLogger
v_log = getLogger(__name__)
# defining paths for validation external stuff
mobschPath = os.path.join(_cfg.mobylehome(), "Schema", "mobyle.sch")
schprocPath = os.path.join(_cfg.mobylehome(), "Tools", "validation", "iso_svrl.xsl")
rbPath = os.path.join(_cfg.mobylehome(), "Tools", "validation", "remove_base.xsl")
jingPath = os.path.join(_cfg.mobylehome(), "Tools", "validation", "jing", "jing.jar")
SVRL_NS = "http://purl.oclc.org/dsdl/svrl"
svrl_validation_errors = etree.XPath("//svrl:failed-assert/svrl:text/text()", namespaces={"svrl": SVRL_NS})
# generating schematron validation xsl from its xsl generator
class ExecutionSystem(object):
"""
abstract class
manage the status by updating the file index.xml
"""
def __init__( self , execution_config ):
"""
@param execution_config: the configuration of the Execution
@type execution_config: ExecutionConfig instance
"""
self._cfg = Config()
self.execution_config = execution_config
self.execution_config_alias = self._cfg.getAliasFromConfig( self.execution_config )
self.status_manager = StatusManager()
def run( self , commandLine , dirPath , serviceName , jobState , xmlEnv = None):
"""
@param execution_config: the configuration of the Execution
@type execution_config: ExecutionConfig instance
@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 jobState:
@type jobState: a L{JobState} instance
"""
self.jobState = jobState
if dirPath[-1] == '/':
dirPath = dirPath[:-1]
jobKey = os.path.split( dirPath )[1]
if os.getcwd() != os.path.abspath( dirPath ):
msg = "the child process execute itself in a wrong directory"
self._logError( dirPath , serviceName ,jobKey,
userMsg = "Mobyle internal server error" ,
logMsg = msg )
raise MobyleError , msg
protectedCommandLine = ''
for c in commandLine:
protectedCommandLine += '\\'+ c
if xmlEnv is None:
xmlEnv = {}
dispatcher = self._cfg.getDispatcher()
queue = dispatcher.getQueue( jobState )
adm = Admin( dirPath )
adm.setQueue( queue )
adm.commit()
new_path = ''
binary_path = self._cfg.binary_path()
if binary_path :
new_path = ":".join( binary_path )
if xmlEnv.has_key( 'PATH' ) :
new_path = "%s:%s" %( xmlEnv[ 'PATH' ] , new_path )
if new_path :
xmlEnv[ 'PATH' ] = "%s:%s" %( new_path , os.environ[ 'PATH' ] )
else:
xmlEnv[ 'PATH' ] = os.environ[ 'PATH' ]
for var in os.environ.keys():
if var != 'PATH':
xmlEnv[ var ] = os.environ[ var ]
self._returncode = None
accounting = self._cfg.accounting()
if accounting:
beg_time = time.time()
###################################
mobyleStatus = self._run( commandLine , dirPath , serviceName , jobKey , jobState , queue , xmlEnv )
###################################
if accounting:
end_time = time.time()
elapsed_time = end_time - beg_time
a_log = getLogger( 'Mobyle.account' )
#%d trunc time to second
#%f for millisecond
a_log.info("%(serviceName)s/%(jobkey)s : %(exec_class)s/%(queue)s : %(beg_time)d-%(end_time)d %(ela_time)d : %(status)s" %{ 'serviceName':serviceName ,
'jobkey':jobKey,
'exec_class':self.execution_config.execution_class_name ,
'queue': queue,
'beg_time':beg_time ,
'end_time':end_time ,
'ela_time':elapsed_time ,
'status': mobyleStatus ,
}
)
self.status_manager.setStatus( dirPath , mobyleStatus )
def getStatus( self , number ):
"""
@param execution_config: a configuration object for this execution system
@type execution_config: an ExecutionConfig subclass instance
@param number:
@type number:
@return the status of the job
@rtype:
abstract method. this method must be implemented in child classes
"""
raise NotImplementedError, "Must be Implemented in child classes"
def kill( self , number ):
"""
kill the Job
@param execution_config: a configuration object for this execution system
@type execution_config: an ExecutionConfig subclass instance
@param number:
@type number:
abstract method. this method must be implemented in child classes
"""
raise NotImplementedError, "Must be Implemented in child classes"
def _logError( self , dirPath , serviceName , jobKey , userMsg = None , logMsg = None ):
if userMsg :
self.status_manager.setStatus( dirPath, Status( code = 5 , message = userMsg ) )
if logMsg :
_log.error( "%s/%s : %s" %( serviceName ,
jobKey ,
logMsg
)
)
MOBYLEHOME = os.environ['MOBYLEHOME']
if not MOBYLEHOME:
sys.exit('MOBYLEHOME must be defined in your environment')
if ( os.path.join( MOBYLEHOME , 'Src' ) ) not in sys.path:
sys.path.append( os.path.join( MOBYLEHOME , 'Src' ) )
import urllib, urllib2, cookielib #@UnresolvedImport
from Mobyle.ConfigManager import Config
from Workflow import Parser
if __name__ == "__main__":
cfg = Config()
url = cfg.cgi_url()+'/workflow.py'
# the cookie jar keeps the Mobyle session cookie in a warm place, so that
# all the HTTP requests connect to the same workspace
cj = cookielib.CookieJar()
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
mp = Parser()
def get_str(params):
data = urllib.urlencode(params)
req = urllib2.Request(url, data)
handle = opener.open(req)
str = handle.read()
return str.strip('\n')
