source: cows_wps/trunk/cows_wps/controllers/jobs.py @ 7106

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/cows_wps/trunk/cows_wps/controllers/jobs.py@7106
Revision 7106, 6.6 KB checked in by astephen, 10 years ago (diff)

Got job cancellation working. Still needs to pick up responses propoerly

Line 
1import logging
2import re
3
4from pylons import request, response, session, tmpl_context as c
5from pylons.controllers.util import abort, redirect_to
6
7from cows_wps.renderer.ui_renderer import *
8from cows_wps.controllers import *
9from cows_wps.lib.ui.proc_config import *
10
11from cows_wps.model.managers import requestManager
12from cows_wps.process_handler.context.process_status import STATUS
13from cows_wps.process_handler.validate_arguments import parseDateTime
14
15log = logging.getLogger(__name__)
16
17
18def checkValidJobStatus(status):
19    allowed_status_codes = [code for code in STATUS.__dict__.keys() if code[0] != "_"]
20    status = status.split("|")
21
22    for st in status:
23        if st not in allowed_status_codes:
24            return False
25
26    return status
27   
28   
29def checkValidJobType(jtype):
30    allowed_job_types = ["1", "2"]
31    job_types = jtype.split("|")
32
33    for jtype in job_types:
34        if jtype not in allowed_job_types:
35            return False
36
37    return job_types
38
39
40def checkValidOrderBy(order_by):
41    allowed = ["job_id", "user_id", "job_status", "job_type", "sub_time"]
42    new_allowed = []
43
44    for i in allowed:
45        new_allowed.append("%s_rev" % i)
46
47    allowed.extend(new_allowed)
48
49    if order_by not in allowed:
50        return False
51
52    return order_by
53
54   
55def toDateTime(tm):
56    try:
57        return parseDateTime(tm)
58    except:
59        return False
60   
61
62class JobsController(BaseController):
63
64    job_item_order = {"job_id_match": 0, "user_id": 1, "job_status": 2,
65                      "job_type": 3, "sub_before": 4, "sub_after": 4,
66                      "job_id": 0, "sub_time": 4}
67
68    filter_types = {"job_id_match": "regex", 
69                    "job_desc_match": "regex",
70            "job_type": "contains",
71            "job_status": "contains",           
72            "sub_after": "time:after",
73            "sub_before": "time:before",
74            "user_id": "equality",
75            }
76
77    default_args = {"start": 0,
78                    "n_records": 20,
79            "job_desc_match": None,
80            "job_id_match": None,
81            "job_type": None,
82            "job_status": None,
83            "sub_before": None,
84            "sub_after": None,
85            "order_by": "sub_time_rev"}
86
87    arg_processers = {"start": int,
88                    "n_records": int,
89            "job_desc_match": str,
90            "job_id_match": str,
91            "job_type": checkValidJobType,
92            "job_status": checkValidJobStatus,
93            "sub_before": toDateTime,
94            "sub_after": toDateTime,
95            "order_by": checkValidOrderBy}
96
97
98    def index(self):
99        (args, bad_args) = self._parseArgs()
100        user_id = request.environ["REMOTE_USER"].split("/")[-1]
101        args["user_id"] = user_id
102
103#        return (str(args) + "----" + str(bad_args))
104        (filtered_jobs, total_matches) = apply(self._filterJobs, [], args)
105
106        renderer = UIPageRenderer()
107        return renderer.renderJobsPage(user_id, filtered_jobs, total_matches, args, bad_args)
108   
109   
110    def _parseArgs(self):
111        args = {}
112        bad_args = {}
113   
114        for (key, default) in self.default_args.items():
115            value = None
116
117            if request.params.has_key(key):
118                value = str(request.params.getone(key).strip())
119
120                # If arg_check is False then bad input
121                arg_check = apply(self.arg_processers[key], [value])
122
123                if value == "":
124                    value = default
125                elif arg_check == False:
126                    bad_args[key] = value
127                    value = default
128                else:
129                    value = arg_check
130            else:
131                value = default
132           
133            args[key] = value
134           
135        return (args, bad_args)
136   
137
138    def _orderJobs(self, jobs, order_by):
139        reverse = False
140
141        if order_by.find("_rev") > -1:
142            order_by = order_by.replace("_rev", "")
143            reverse = True
144
145        indx = self.job_item_order[order_by] 
146        tmp_jobs = [(job[indx], job[:]) for job in jobs]
147        tmp_jobs.sort()
148
149        if reverse:
150            tmp_jobs.reverse()
151         
152        ordered_jobs = [i[1] for i in tmp_jobs]
153        return ordered_jobs
154   
155   
156    def _filterJobs(self, user_id, start, n_records, job_desc_match, job_id_match,
157                    job_type, job_status, sub_before, sub_after, order_by):
158        # Get all jobs at start
159        requests = requestManager.getAllRequest()
160       
161        # Define jobs as tuple of (job_id, user, status, job_type, created)
162        # And convert all unicodes
163        jobs = [[str(i) for i in (r.id, r.user_id, r.job.status, r.job.type, r.job.created)] for r in requests]
164         
165        for filtr in ("job_id_match", "job_type", "job_status", "sub_before", "sub_after", "user_id"):
166            jobs = self._filterBy(jobs, filtr, filter_value = vars()[filtr])
167       
168        total_matches = len(jobs)       
169        ordered_jobs = self._orderJobs(jobs, order_by)[start:(start + n_records)]
170        return (ordered_jobs, total_matches)
171   
172   
173    def _filterBy(self, jobs, filtr, filter_value):
174        # Represent jobs as lists of properties
175        if filter_value == None:
176            return jobs
177       
178        indx = self.job_item_order[filtr]
179        test_param = None
180        filter_type = self.filter_types[filtr]
181        filtered_jobs = []
182
183        for job in jobs:
184       
185            item = job[indx]
186       
187            if filter_type == "regex":
188                if not test_param:
189                    test_param = re.compile(filter_value)
190       
191                if test_param.search(item):
192                    filtered_jobs.append(job)
193           
194            elif filter_type.find("time:") == 0:
195                if not test_param:
196                    test_param = filter_value
197
198                item = parseDateTime(item.replace(" ", "T").split(".")[0])
199       
200                when = filter_type.split(":")[1].strip()
201  #              raise (str(item) + "nnnnnn" + str(test_param))
202                if when == "after":
203                    if item > test_param:
204                        filtered_jobs.append(job)
205           
206                elif when == "before":
207                    if item < test_param:
208                        filtered_jobs.append(job)
209           
210            elif filter_type == "equality":
211#                raise (str(filter_value) + "...." + str(item))
212                if filter_value == item:
213                    filtered_jobs.append(job)
214           
215            elif filter_type == "contains":
216#                raise str(str(item) + str(filter_value))
217                if item in filter_value:
218                    filtered_jobs.append(job)
219
220        return filtered_jobs
221
Note: See TracBrowser for help on using the repository browser.