workflow.py

#
# Copyright (C) 2012 INRA
# 
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#

import inspect
import os
import re
import sys
import uuid
import pkgutil
import tempfile
import pickle
import time
import threading
from ConfigParser import ConfigParser, NoOptionError
import types
import logging
from inspect import getcallargs

import jflow
import jflow.utils as utils
from jflow.workflows_manager import WorkflowsManager, JFlowConfigReader
from jflow.parameter import Parameter, date, MiltipleAppendAction

from weaver.script import ABSTRACTIONS
from weaver.script import DATASETS
from weaver.script import FUNCTIONS
from weaver.script import NESTS
from weaver.script import OPTIONS
from weaver.script import STACKS
from weaver.nest import Nest
from weaver.options import Options
from cctools.makeflow import MakeflowLog
from cctools.makeflow.log import Node


class Workflow(threading.Thread):
    """
    """

    PROPERTIES_FILE_NAME = "workflow.properties"
    MAKEFLOW_LOG_FILE_NAME = "Makeflow.makeflowlog"
    DUMP_FILE_NAME = "workflow.dump"
    WORKING = ".working"
    STATUS_STARTED = "started"
    STATUS_COMPLETED = "completed"
    STATUS_FAILED = "failed"
    STATUS_ABORTED = "aborted"

    def __init__(self, args={}, id=None, function= "process", parameters_section="parameters"):
        """ 
        """
        # define as a thread
        threading.Thread.__init__(self)
        self.jflow_config_reader = JFlowConfigReader()
        self.manager = WorkflowsManager()
        self.components = []
        self.makes = {}
        self.globals = {}
        self.options = Options()
        self.status = self.STATUS_STARTED
        self.start_time = None
        self.end_time = None
        self.function = function
        self.parameters_section = parameters_section
        self.comp_pckg = self._import_components()
        self.engine_arguments = ''
        self.component_nameids = {}
        # try to parse engine arguments
        try:
            type, options = self.jflow_config_reader.get_batch()
            if type: self.engine_arguments += ' -T ' + type
            if options : self.engine_arguments += ' -B "' + options + '"'
        except: self.engine_arguments = None
        try:
            # Add config information
            self.name, self.description, self.parameters = self._get_from_config()
        except:
            raise IOError(self.__class__.__name__ + " workflow property file not found or invalid.")
        
        self.id = id
        self.args = self._extend_and_format_args(self.parameters, args)
        self.metadata = self.args["metadata"]
        if self.id is not None:
            self.directory = self.manager.get_workflow_directory(self.name, self.id)
            if not os.path.isdir(self.directory):
                os.makedirs(self.directory, 0751)
            self._serialize()
    
    def init_component_nameids(self):
        workflow_command_lines = inspect.getsourcelines(getattr(self, self.function))[0]
        for i in range(0, len(workflow_command_lines)):
            line = workflow_command_lines[i]
            if line.find("self.add_component") != -1 and not re.search('^\s*\#', line) :
                while re.search('\\\s*$', line) or re.search(',\s*$', line): # While line ends with backslash
                    # Concatenate next line
                    i += 1
                    next_line = workflow_command_lines[i]
                    if re.search('^\s*\#', next_line) :
                        nex_line = "\\"
                    if re.search('\\\s*$', line):
                        line = re.search('(.+)\\\s*$', line).groups()[0] + next_line
                    elif re.search(',\s*$', line):
                        line = re.search('(.+),\s*$', line).groups()[0] + next_line
                component_prefix = "default"
                component_name = line.strip().split("self.add_component")[1][1:-1].split(",")[0][1:-1]
                arguments = re.search("self.add_component\s*\((.+)\)", line).groups()[0]
                named_prefix = re.search("component_prefix\s*=\s*([^,]+)", arguments)
                # Component prefix is in named argument
                if named_prefix:
                    component_prefix = named_prefix.groups()[0].strip().strip('"')
                # Component prefix is missing or in unamed argument
                else :
                    without_named_args = re.sub( ",?\s*\S+\s*=\s*\S+", "" , arguments) # Discard named arguments
                    fields = without_named_args.strip(",").split(",")
                    # Group brackets arguments
                    args_split_clean = []
                    current_idx = 0
                    current_arg = ""
                    while current_idx < len(fields) :
                        current_arg = current_arg + fields[current_idx] + ','
                        open_brackets = current_arg.count("[")
                        close_brackets = current_arg.count("]")
                        if open_brackets == close_brackets:
                            args_split_clean.append( current_arg[:-1] )
                            current_arg = ""
                        current_idx += 1
                    # Find component prefix
                    if len(args_split_clean) >= 4:
                        component_prefix = args_split_clean[3].strip().strip('"')
                if self._component_is_duplicated(component_name+"."+component_prefix):
                    raise ValueError("Component " + component_name + " with prefix " + 
                                     component_prefix + " already exist in this pipeline!")
                self.component_nameids[component_name+"."+component_prefix] = None
    
    @staticmethod
    def config_parser(arg_lines):
        for arg_line in arg_lines:
            for arg in arg_line.split():
                if not arg.strip():
                    continue
                yield arg
    
    def __setstate__(self, state):
        self.__dict__ = state.copy()
        threading.Thread.__init__(self, name=self.name)
        
    def __getstate__(self):
        """
        Threading uses Lock Object, do not consider these objects when serializing a workflow
        """
        odict = self.__dict__.copy()
        del odict['_Thread__started']
        del odict['_Thread__block']
        del odict['_Thread__stderr']
        return odict
    
    def get_parameters_per_groups(self):
        parameters, parameters_order = {}, []
        for param in self.parameters:
            if param.group not in parameters_order: parameters_order.append(param.group)
            if parameters.has_key(param.group):
                parameters[param.group].append(param)
            else:
                parameters[param.group] = [param]
        return [parameters, parameters_order]
    
    def get_exec_path(self, software):
        return self.jflow_config_reader.get_exec(software)
    
    def add_component(self, component_name, args=[], kwargs={}, component_prefix="default"):
        # first build and check if this component is OK
        if self.comp_pckg.has_key(component_name):
            my_pckge = __import__(self.comp_pckg[component_name], globals(), locals(), [component_name], -1)
            # build the object and define required field
            cmpt_object = getattr(my_pckge, component_name)()
            cmpt_object.output_directory = self.get_component_output_directory(component_name, component_prefix)
            cmpt_object.prefix = component_prefix
            if kwargs: cmpt_object.define_parameters(**kwargs)
            else: cmpt_object.define_parameters(*args)
            # add the component
            self.components.append(cmpt_object)
            # if this one require a dynamic pipeline, execute the first part
            if cmpt_object.is_dynamic:
                self._execute_weaver()
            return cmpt_object
        else:
            raise ImportError(component_name + " component cannot be loaded, available components are: {0}".format(", ".join(self.comp_pckg.keys())))
    
    def pre_process(self):
        pass
    
    def process(self):
        """ 
        Run the workflow, has to be implemented by subclasses
        """
        raise NotImplementedError
    
    def post_process(self):
        pass
    
    def get_temporary_file(self, suffix=".txt"):
        # first check if tmp directory exists
        if not os.path.isdir(self.jflow_config_reader.get_tmp_directory()):
            os.makedirs(self.jflow_config_reader.get_tmp_directory(), 0751)
        tempfile_name = os.path.basename(tempfile.NamedTemporaryFile(suffix=suffix).name)
        return os.path.join(self.jflow_config_reader.get_tmp_directory(), tempfile_name)

    def get_component_output_directory(self, component_name, component_prefix):
        return os.path.join(self.directory, component_name + "_" + component_prefix)
    
    def get_components_nameid(self):
        return self.component_nameids.keys()
    
    def run(self):
        """
        Only require for Threading
        """
        # first init the component list within the workflow
        self.init_component_nameids()
        self.start_time = time.time()
        self.status = self.STATUS_STARTED
        self.end_time = None  
        # serialize the workflow before pre processing
        self._serialize()
        self.pre_process()
        # serialize the workflow before running
        self._serialize()
        try: 
            getattr(self, self.function)()
        except SystemExit, e: 
            self.status = self.STATUS_FAILED
            self.end_time = time.time()
            self._serialize()
            raise
        if len(self.components) > 0:
            self._execute_weaver()
        self._serialize()
        self.post_process()
        if self.status == self.STATUS_STARTED: self.status = self.STATUS_COMPLETED        
        self.end_time = time.time()
        self._serialize()
    
    def _extend_and_format_args(self, parameters, args):
        extended_args = {}
        for param in parameters:
            try: args[param.name] = args[param.name].encode('ascii','ignore')
            except: pass
            # if this parameter has been modified by the user
            if args.has_key(param.name):
                if param.action == MiltipleAppendAction:
                    extended_args[param.name] = []
                    for arg in args[param.name]:
                        sub_hash = {}
                        for sub_param in param.sub_parameters:
                            # find the value
                            value = None
                            for values in arg:
                                if values[0] == sub_param.flag: value = values[1]
                            if value == None: value = sub_param.default
                            sub_hash[sub_param.name] = value
                        extended_args[param.name].append(sub_hash)
                # if it's an append parameter, the result should be a list
                elif param.action == "append":
                    if args[param.name]:
                        try: value = args[param.name].split(",") 
                        except: value = args[param.name]
                    else: value = []
                    extended_args[param.name] = value
                # if it's a date
                elif param.type == date:
                    if isinstance(args[param.name], str):
                        extended_args[param.name] = date(args[param.name])
                    else:
                        extended_args[param.name] = args[param.name]
                # if it's a boolean
                elif param.type == types.BooleanType:
                    extended_args[param.name] = args[param.name] in [True, 1, 'true', '1', 't', 'y', 'yes']
                elif param.type.__name__ == "MultipleParameters":
                    extended_args[param.name] = {}
                    for sub_param in param.sub_parameters:
                        # find the value
                        value = None
                        for values in args[param.name]:
                            if values[0] == sub_param.flag: value = values[1]
                        if value == None: value = sub_param.default
                        extended_args[param.name][sub_param.name] = value
                else:
                    extended_args[param.name] = args[param.name]
            # otherwise use the default
            else:
                if param.type.__name__ == "MultipleParameters":
                    extended_args[param.name] = {}
                    for sub_param in param.sub_parameters:
                        extended_args[param.name][sub_param.name] = sub_param.default
                else:
                    extended_args[param.name] = param.default
        return extended_args
    
    def _get_from_config(self):
        reader = ConfigParser()
        reader.read(self._get_property_path())
        parameters, param_order = [], []
        try:
            params, sub_order, excludes, hash_params = {}, {}, [], {}
            # first grab all parameters name
            for param in reader.items(self.parameters_section):
                cvalue = reader.get(self.parameters_section, param[0])
                cparam = param[0].split(".")[0]
                ckey = ".".join(param[0].split(".")[1:])
                if len(ckey.split(".")) > 1:
                    if sub_order.has_key(cparam):
                        if ckey.split(".")[0] not in sub_order[cparam]: sub_order[cparam].append(ckey.split(".")[0])
                    else:
                        sub_order[cparam] =[ckey.split(".")[0]]
                if not params.has_key(cparam):
                    params[cparam] = {ckey: cvalue}
                else:
                    params[cparam][ckey] = cvalue
                if cparam not in param_order: param_order.append(cparam)
            
            for param_name in param_order:
                sub_params, current_params, sub_objs, sub_excludes, hash_sub_params = {}, {}, [], [], {}
                for param in params[param_name]:
                    sub_params_values = param.split(".")
                    if len(sub_params_values) == 2:
                        # TODO: handle exclusive for sub parameter
                        key = None
                        if sub_params_values[1] == "name": 
                            key = "display_name"
                        else:
                            key = sub_params_values[1]
                        if key == "exclude":
                            found = False
                            for exclude_group in sub_excludes:
                                if sub_params_values[0] in exclude_group:
                                    exclude_group.append(params[param_name][param])
                                    found = True
                                elif params[param_name][param] in exclude_group:
                                    exclude_group.append(sub_params_values[0])
                                    found = True
                            if not found: sub_excludes.append([sub_params_values[0], params[param_name][param]])
                        else:
                            if not sub_params.has_key(sub_params_values[0]):
                                sub_params[sub_params_values[0]] = {key: params[param_name][param]}
                                sub_params[sub_params_values[0]]["name"] = sub_params_values[0]
                            else:
                                sub_params[sub_params_values[0]][key] = params[param_name][param]
                    else:
                        if param == "name": current_params["display_name"] = params[param_name][param]
                        elif param == "exclude":
                            found = False
                            for exclude_group in excludes:
                                if param_name in exclude_group:
                                    exclude_group.append(params[param_name][param])
                                    found = True
                                elif params[param_name][param] in exclude_group:
                                    exclude_group.append(param_name)
                                    found = True
                            if not found: excludes.append([param_name, params[param_name][param]])
                        else: current_params[param] = params[param_name][param]
                current_params["name"] = param_name
                if sub_order.has_key(param_name):
                    for sub_param in sub_order[param_name]:
                        sub = Parameter(**sub_params[sub_param])
                        hash_sub_params[sub.name] = sub
                        sub_objs.append(sub)
                    # overwrite the group to exclude some parameters
                    for i, exclude_group in enumerate(sub_excludes):
                        group_name = "exclude-"+str(i)
                        for sparam in set(exclude_group):
                            hash_sub_params[sparam].group = group_name
                current_params["sub_parameters"] = sub_objs
                oparam = Parameter(**current_params)
                parameters.append(oparam)
                hash_params[oparam.name] = oparam
            # overwrite the group to exclude some parameters
            for i, exclude_group in enumerate(excludes):
                group_name = "exclude-"+str(i)
                for param in set(exclude_group):
                    hash_params[param].group = group_name
        except:
            pass
        # finally add the metadata parameter
        metadata = Parameter(name="metadata", flag="--metadata", help="Which metadata should be linked to this workflow", 
                             action="append", display_name="Metadata")
        parameters.append(metadata)
        return [reader.get("global", "name"),
                reader.get("global", "description"),
                parameters]
    
    def _update_status_from_log(self):
        # first update the status from weaver folders
        # TODO update self.end_time
        try:
            working_directory = os.path.join(self.directory, self.WORKING)
            make_states = []
            for wdir in os.listdir(working_directory):
                log_path = os.path.join(working_directory, wdir, self.MAKEFLOW_LOG_FILE_NAME)
                log = MakeflowLog(log_path)
                log.parse()
                make_states.append(log.state)
            if self.STATUS_ABORTED in make_states:
                self.status = self.STATUS_ABORTED
            elif self.STATUS_FAILED in make_states:
                self.status = self.STATUS_FAILED
            elif self.status != self.STATUS_COMPLETED:
                self.status = self.STATUS_STARTED
        except: pass
        self._serialize()

    def get_status(self):
        self._update_status_from_log()
        return self.status
    
    def get_resource(self, resource):
        return self.jflow_config_reader.get_resource(resource)
    
    def get_component_status(self, component_nameid):
        status = {"time": 0.0,
                  "tasks": 0,
                  "waiting": 0,
                  "running": 0,
                  "failed":0,
                  "aborted": 0,
                  "completed": 0}
        try:
            log = MakeflowLog(self.component_nameids[component_nameid])
            log.parse()
            symbols = set(n.symbol for n in log.nodes if n.symbol)
            if not symbols: return None
            for n in log.nodes:
                if not n.symbol: continue
                if n.symbol == component_nameid:
                    status["tasks"] += 1
                    status["time"]  += n.elapsed_time
                    if n.state == Node.WAITING:
                        status["waiting"] += 1
                    elif n.state == Node.RUNNING:
                        status["running"] += 1
                    elif n.state == Node.FAILED:
                        status["failed"] += 1
                    elif n.state == Node.ABORTED:
                        status["aborted"] += 1
                    elif n.state == Node.COMPLETED:
                        status["completed"] += 1
        except: pass
        return status        
    
    def makeflow_pretty_print_node(self, dag, node):
        sys.stdout.write('{0:>10} {1} {2}\n'.format('NODE', node.id, node.symbol))
        
        for output_file in sorted(node.output_files):
            sys.stdout.write('{0:>10} {1:>10} {2}\n'.format('', 'OUTPUT', output_file))
    
        for input_file in sorted(node.input_files):
            sys.stdout.write('{0:>10} {1:>10} {2}\n'.format('', 'INPUT', input_file))
            
        sys.stdout.write('{0:>10} {1:>10} {2}\n'.format('', 'COMMAND', node.command))

    def _execute_weaver(self, engine_wrapper=None):
        # Add nest path and path to script to Python module path to allow
        # for importing modules outside of $PYTHONPATH
        make_directory, new_make = self._get_current_make()
        current_working_directory = os.path.join(os.path.join(self.directory, self.WORKING), make_directory)
        sys.path.insert(0, os.path.abspath(os.path.dirname(current_working_directory)))

        # Load built-ins
        self._import('abstraction', ABSTRACTIONS)
        self._import('dataset', DATASETS)
        self._import('function', FUNCTIONS)
        self._import('nest', NESTS)
        self._import('options', OPTIONS)
        self._import('stack', STACKS)
                
        # Execute nest
        with Nest(current_working_directory, wrapper=engine_wrapper, path=self.jflow_config_reader.get_makeflow_path()) as nest:
            with self.options:
                if new_make:
                    try:
                        for component in self.components:
                            nest.symbol = component.get_nameid()
                            nest.batch = component.batch_options
                            self.component_nameids[component.get_nameid()] = os.path.join(current_working_directory, self.MAKEFLOW_LOG_FILE_NAME)
                            component.execute()
                        # create the DAG
                        nest.compile()
                    except Exception as e:
                        self.status = self.STATUS_FAILED
                        self.end_time = time.time()
                        self._serialize()
                        raise
                self.components = []
                # Once a weaver script is compiled, serialize the workflow
                self._serialize()
                try:
                    nest.execute(self.engine_arguments, exit_on_failure=True)
                except:
                    self.status = self.STATUS_FAILED
                    self.end_time = time.time()
                    self._serialize()
                    raise

    def _get_current_make(self):
        current_component, make_directory, new_make = [], None, False
        for component in self.components:
            current_component.append(component.get_nameid())
        for make in self.makes:
            if set(current_component) == set(self.makes[make]):
                make_directory = make
        # If the components in the queue have already been compiled
        if make_directory is None:
            make_directory = uuid.uuid4().hex[:10]
            self.makes[make_directory] = current_component
            new_make = True
        return [make_directory, new_make]
    
    def _serialize(self):
        self.dump_path = os.path.join(self.directory, self.DUMP_FILE_NAME)
        workflow_dump = open(self.dump_path, "wb")
        pickle.dump(self, workflow_dump)
        workflow_dump.close()

    def _component_is_duplicated(self, component_nameid):
        if component_nameid in self.component_nameids.keys():
            return True
        return False

    def _get_property_path(self):
        """ 
        Return(type:string):  the path to the workflow properties file, None if does not exist
        """
        property_file = os.path.join(os.path.dirname(inspect.getfile(self.__class__)), self.PROPERTIES_FILE_NAME)
        return property_file if os.path.isfile(property_file) else None

    def _import_components(self):
        pckge = {}
        # then import pipeline packages
        pipeline_dir = os.path.dirname(inspect.getfile(self.__class__))
        for importer, modname, ispkg in pkgutil.iter_modules([os.path.join(pipeline_dir, "components")], "workflows." + 
                                                             os.path.basename(pipeline_dir) + ".components."):
            try:
                m = __import__(modname)
                for class_name, obj in inspect.getmembers(sys.modules[modname], inspect.isclass):
                    if issubclass(obj, jflow.component.Component) and obj.__name__ != jflow.component.Component.__name__:
                        pckge[class_name] = modname
            except Exception as e:
                logging.getLogger("Workflow._import_components").debug("Component <{0}> cannot be loaded: {1}".format(modname, e))
        # finally import workflows shared packages
        workflows_dir = os.path.dirname(os.path.dirname(inspect.getfile(self.__class__)))
        for importer, modname, ispkg in pkgutil.iter_modules([os.path.join(workflows_dir, "components")], "workflows.components."):
            try:
                m = __import__(modname)
                for class_name, obj in inspect.getmembers(sys.modules[modname], inspect.isclass):
                    if issubclass(obj, jflow.component.Component) and obj.__name__ != jflow.component.Component.__name__:
                        pckge[class_name] = modname
            except Exception as e:
                logging.getLogger("Workflow._import_components").debug("Component <{0}> cannot be loaded: {1}".format(modname, e))
        return pckge

    def _import(self, module, symbols):
        """ Import ``symbols`` from ``module`` into global namespace. """
        # Import module
        m = 'weaver.{0}'.format(module)
        m = __import__(m, self.globals, self.globals, symbols, -1)

        # Import symbols from module into global namespace, which we store as
        # an attribute for later use (i.e. during compile)
        for symbol in symbols:
            self.globals[symbol] = getattr(m, symbol)