Ignore:
Timestamp:
25/06/10 14:29:20 (10 years ago)
Author:
astephen
Message:

fixing up jobs page and moving renderer code into renderer package

File:
1 edited

Legend:

Unmodified
Added
Removed
  • cows_wps/trunk/cows_wps/controllers/jobs.py

    r5968 r7095  
    1010from cows_wps.model.managers import requestManager 
    1111from cows_wps.process_handler.context.process_status import STATUS 
     12from cows_wps.process_handler.validate_arguments import parseDateTime 
    1213 
    1314log = logging.getLogger(__name__) 
    1415 
     16 
     17def checkValidJobStatus(status): 
     18    allowed_status_codes = [code for code in STATUS.__dict__.keys() if code[0] != "_"] 
     19    status = status.split("|") 
     20 
     21    for st in status: 
     22        if st not in allowed_status_codes: 
     23            return False 
     24 
     25    return status 
     26     
     27     
     28def checkValidJobType(jtype): 
     29    allowed_job_types = ["1", "2"] 
     30    job_types = jtype.split("|") 
     31 
     32    for jtype in job_types: 
     33        if jtype not in allowed_job_types: 
     34            return False 
     35 
     36    return job_types 
     37 
     38 
     39def checkValidOrderBy(order_by): 
     40    allowed = ["job_id", "user_id", "job_status", "job_type", "sub_time"] 
     41    new_allowed = [] 
     42 
     43    for i in allowed: 
     44        new_allowed.append("%s_rev" % i) 
     45 
     46    allowed.extend(new_allowed) 
     47 
     48    if order_by not in allowed: 
     49        return False 
     50 
     51    return order_by 
     52 
     53     
     54def toDateTime(tm): 
     55    try: 
     56        return parseDateTime(tm) 
     57    except: 
     58        return False 
     59    
     60 
    1561class JobsController(BaseController): 
    1662 
    17     def cancel(self): 
    18         """ 
    19         Cancel a job 
    20         """ 
    21         job_id = request.params.get("job_id", None) 
    22         if job_id == None: 
    23             return "Please provide an argument job_id=<Something>" 
    24  
    25         resp = "Nothing yet..." 
     63    job_item_order = {"job_id_match": 0, "user_id": 1, "job_status": 2, 
     64                      "job_type": 3, "sub_before": 4, "sub_after": 4, 
     65                      "job_id": 0, "sub_time": 4} 
     66 
     67    filter_types = {"job_id_match": "regex",  
     68                    "job_desc_match": "regex", 
     69            "job_type": "contains", 
     70            "job_status": "contains",             
     71            "sub_after": "time:after", 
     72            "sub_before": "time:before", 
     73            } 
     74    default_args = {"start": 0, 
     75                    "n_records": 20, 
     76            "job_desc_match": None, 
     77            "job_id_match": None, 
     78            "job_type": None, 
     79            "job_status": None, 
     80            "sub_before": None, 
     81            "sub_after": None, 
     82            "order_by": "sub_time"} 
     83    arg_processers = {"start": int, 
     84                    "n_records": int, 
     85            "job_desc_match": str, 
     86            "job_id_match": str, 
     87            "job_type": checkValidJobType, 
     88            "job_status": checkValidJobStatus, 
     89            "sub_before": toDateTime, 
     90            "sub_after": toDateTime, 
     91            "order_by": checkValidOrderBy} 
     92 
     93    def index(self): 
     94        (args, bad_args) = self._parseArgs() 
     95#        return str(args) 
     96        (filtered_jobs, total_matches) = apply(self._filterJobs, [], args) 
     97 
    2698        renderer = UIPageRenderer() 
    27         resp = renderer.render("Job cancellation page", 
    28                                [("Cancelling: %s" % job_id, resp)]) 
    29         return resp 
    30  
    31  
    32     def index(self): 
    33         """ 
    34         Reads jobs list and shows. 
    35         """ 
    36         requestManager.updateRunningRequests() 
    37  
    38         resp = '<table border="2"><tr><td>Job id</td><td>type</td><td>user</td><td>status</td></tr>\n' 
    39         for r in requestManager.getAllRequest(): 
    40             status = r.job.status 
    41             type = r.job.type 
    42             job_id = r.job.job_id 
    43             user = r.user_id 
    44             row = "<tr><td>%s</td><td>%s</td><td>%s</td><td>%s</td></tr>\n" % (job_id, type, user, status) 
    45             resp += row 
    46  
    47         resp += "</table>"  
    48         renderer = UIPageRenderer() 
    49         resp = renderer.render("Job list page", 
    50                                [("All jobs", resp)]) 
    51         return resp 
     99        return renderer.renderJobsPage(filtered_jobs, total_matches, args, bad_args) 
     100     
     101     
     102    def _parseArgs(self): 
     103        args = {} 
     104        bad_args = {} 
     105     
     106        for (key, default) in self.default_args.items(): 
     107            value = None 
     108            if request.params.has_key(key): 
     109                value = str(request.params.getone(key)) 
     110             
     111                # If arg_check is False then bad input 
     112                arg_check = apply(self.arg_processers[key], [value]) 
     113                if arg_check == False: 
     114                    bad_args[key] = value 
     115                    value = default 
     116                else: 
     117                    value = arg_check 
     118            else: 
     119                value = default 
     120             
     121            args[key] = value 
     122             
     123        return (args, bad_args) 
     124     
     125 
     126    def _orderJobs(self, jobs, order_by): 
     127        reverse = False 
     128 
     129        if order_by.find("_rev") > -1: 
     130            order_by = order_by.replace("_rev", "") 
     131            reverse = True 
     132 
     133        indx = self.job_item_order[order_by]  
     134        tmp_jobs = [(job[indx], job[:]) for job in jobs] 
     135        tmp_jobs.sort() 
     136 
     137        if reverse: 
     138            tmp_jobs.reverse() 
     139          
     140        ordered_jobs = [i[1] for i in tmp_jobs] 
     141        return ordered_jobs 
     142     
     143     
     144    def _filterJobs(self, start, n_records, job_desc_match, job_id_match, 
     145                    job_type, job_status, sub_before, sub_after, order_by): 
     146        # Get all jobs at start 
     147        requests = requestManager.getAllRequest() 
     148        
     149        # Define jobs as tuple of (job_id, user, status, job_type, created)  
     150        # And convert all unicodes 
     151        jobs = [[str(i) for i in (r.job_id, r.user_id, r.job.status, r.job.type, r.job.created)] for r in requests] 
     152          
     153        for filtr in ("job_id_match", "job_type", "job_status", "sub_before", "sub_after"): 
     154            jobs = self._filterBy(jobs, filtr, filter_value = vars()[filtr]) 
     155        
     156        total_matches = len(jobs)         
     157        ordered_jobs = self._orderJobs(jobs, order_by)[start:(start + n_records)] 
     158        return (ordered_jobs, total_matches) 
     159     
     160     
     161    def _filterBy(self, jobs, filtr, filter_value): 
     162        # Represent jobs as lists of properties 
     163        if filter_value == None: 
     164            return jobs 
     165         
     166        indx = self.job_item_order[filtr] 
     167        test_param = None 
     168        filter_type = self.filter_types[filtr] 
     169        filtered_jobs = [] 
     170 
     171        for job in jobs: 
     172         
     173            item = job[indx] 
     174         
     175            if filter_type == "regex": 
     176                if not test_param: 
     177                    test_param = re.compile(filter_value) 
     178         
     179                if test_param.search(item): 
     180                    filtered_jobs.append(job) 
     181             
     182            elif filter_type.find("time:") == 0: 
     183                if not test_param: 
     184                    test_param = filter_value 
     185         
     186                when = filter_type.split(":")[1].strip() 
     187         
     188                if when == "after": 
     189                    if item > test_param: 
     190                        filtered_jobs.append(job) 
     191             
     192                elif when == "before": 
     193                    if item < test_param: 
     194                        filtered_jobs.append(job) 
     195             
     196            elif filter_type == "equality": 
     197                if filter_value == item: 
     198                    filtered_jobs.append(job) 
     199             
     200            elif filter_type == "contains": 
     201#                raise str(str(item) + str(filter_value)) 
     202                if item in filter_value: 
     203                    filtered_jobs.append(job) 
     204 
     205        return filtered_jobs 
     206 
Note: See TracChangeset for help on using the changeset viewer.