d82543aa92946ef453d3c9324a34997f07ca974f
[proteocache.git] / server / compbio / statistic / CassandraRequester.java
1 package compbio.statistic;
2
3 import java.text.ParseException;
4 import java.text.SimpleDateFormat;
5 import java.util.ArrayList;
6 import java.util.Calendar;
7 import java.util.Date;
8 import java.util.Iterator;
9 import java.util.List;
10 import java.util.Map;
11
12 import compbio.cassandra.ProteinBean;
13 import compbio.cassandra.CassandraNativeConnector;
14 import compbio.cassandra.CassandraReader;
15 import compbio.cassandra.DataBase;
16 import compbio.cassandra.Pair;
17 import compbio.cassandra.StructureJobLog;
18
19 public class CassandraRequester {
20         private CassandraReader db = new CassandraReader();
21         private ArrayList<DataBase> query;
22         private static long currentDate = 0;
23         private static long earlestDate = 0;
24         private final static SimpleDateFormat formatYYMMDD = new SimpleDateFormat("yyyy/MM/dd");
25         private final static SimpleDateFormat formatDDMMYY = new SimpleDateFormat("dd/MM/yyyy");
26
27         /*
28          * query: execution time for the period from date1 till date2
29          */
30         public List<DataBase> extractExecutionTime(String date1, String date2) {
31                 if (null == date1) {
32                         date1 = "1970/1/1";
33                 }
34                 if (null == date2) {
35                         date1 = "2100/1/1";
36                 }
37                 if (!isThisDateValid(date1,formatYYMMDD) || !isThisDateValid(date2,formatYYMMDD)) {
38                         System.out.println("CassandraRequester.extractExecutionTime: wrong format for date1 " + date1 + "or date2 " + date2);
39                         return null;
40                 }
41                 SetDateRange();
42                 int nbins = 5;
43                 long dateStart = DateParsing(date1, formatYYMMDD);
44                 long dateEnd = DateParsing(date2, formatYYMMDD);
45                 if (dateEnd < earlestDate || dateStart > currentDate || dateStart > dateEnd)
46                         return null;
47                 if (dateStart < earlestDate)
48                         dateStart = earlestDate;
49                 if (dateEnd > currentDate)
50                         dateStart = currentDate;
51
52                 Calendar start = Calendar.getInstance();
53                 start.setTime(new Date(dateStart));
54                 Calendar end = Calendar.getInstance();
55                 end.setTime(new Date(dateEnd));
56                 query = new ArrayList<DataBase>();
57                 List<Integer> totalTime = new ArrayList<Integer>();
58                 for (int i = 0; i < nbins; i++)
59                         totalTime.add(i, 0);
60                 List<Pair<String, String>> res = db.ReadProteinDataTable();
61                 List<Pair<Date, Long>> numres = new ArrayList<Pair<Date, Long>>();
62
63                 for (Pair<String, String> entry : res) {
64                         SimpleDateFormat dateformatter = new SimpleDateFormat("yyyy/MM/dd");
65                         try {
66                                 Date jobstartdate = dateformatter.parse(entry.getElement0());
67                                 long date = jobstartdate.getTime();
68                                 if (dateStart <= date && date <= dateEnd) {
69                                         SimpleDateFormat datetimeformatter = new SimpleDateFormat("yyyy/MM/dd:H:m:s");
70                                         Date jobstarttime = datetimeformatter.parse(entry.getElement0());
71                                         Date jobendtime = datetimeformatter.parse(entry.getElement1());
72                                         long diff = (jobendtime.getTime() - jobstarttime.getTime()) / 1000;
73                                         Pair<Date, Long> pair = new Pair<Date, Long>(jobstartdate, Long.valueOf(diff));
74                                         numres.add(pair);
75                                 }
76                         } catch (ParseException e) {
77                                 e.printStackTrace();
78                         }
79                 }
80
81                 for (Date date = start.getTime(); !start.after(end); start.add(Calendar.DATE, 1), date = start.getTime()) {
82                         List<Integer> timeResult = new ArrayList<Integer>();
83                         for (int i = 0; i < nbins; i++)
84                                 timeResult.add(i, 0);
85                         for (Pair<Date, Long> p : numres) {
86                                 if (date.equals(p.getElement0())) {
87                                         long lenResult = p.getElement1().longValue();
88                                         if (lenResult <= 30)
89                                                 timeResult.set(0, timeResult.get(0) + 1);
90                                         else if (lenResult > 30 && lenResult <= 60)
91                                                 timeResult.set(1, timeResult.get(1) + 1);
92                                         else if (lenResult > 60 && lenResult <= 120)
93                                                 timeResult.set(2, timeResult.get(2) + 1);
94                                         else if (lenResult > 120 && lenResult <= 600)
95                                                 timeResult.set(3, timeResult.get(3) + 1);
96                                         else {
97                                                 timeResult.set(4, timeResult.get(4) + 1);
98                                         }
99                                 }
100                         }
101                         for (int i = 0; i < nbins; i++)
102                                 totalTime.set(i, totalTime.get(i) + timeResult.get(i));
103                         DataBase db = new DataBase();
104                         db.setTimeRez(timeResult);
105                         db.setDate(DateFormat(date.getTime()));
106                         query.add(db);
107                 }
108
109                 DataBase db = new DataBase();
110                 db.setTimeTotalExec(totalTime);
111                 query.add(db);
112                 return query;
113         }
114         
115         /*
116          * query: total number of jobs  for the period from date1 till date2
117          */
118         public List<DataBase> countJobs(String date1, String date2) {
119                 if (null == date1) {
120                         date1 = "1970/1/1";
121                 }
122                 if (null == date2) {
123                         date1 = "2100/1/1";
124                 }
125                 if (!isThisDateValid(date1, formatYYMMDD) || !isThisDateValid(date2, formatYYMMDD)) {
126                         System.out.println("CassandraRequester.countJobs: wrong format for date1 " + date1 + "or date2 " + date2);
127                         return null;
128                 }
129                 SetDateRange();
130                 long dateStart = DateParsing(date1, formatYYMMDD);
131                 long dateEnd = DateParsing(date2, formatYYMMDD);
132                 if (dateEnd < earlestDate || dateStart > currentDate || dateStart > dateEnd)
133                         return null;
134                 if (dateStart < earlestDate)
135                         dateStart = earlestDate;
136                 if (dateEnd > currentDate)
137                         dateStart = currentDate;
138
139                 Calendar start = Calendar.getInstance();
140                 start.setTime(new Date(dateStart));
141                 Calendar end = Calendar.getInstance();
142                 end.setTime(new Date(dateEnd));
143                 query = new ArrayList<DataBase>();
144                 for (Date date = start.getTime(); !start.after(end); start.add(Calendar.DATE, 1), date = start.getTime()) {
145                         List<Long> res = db.ReadDateTable(date.getTime());
146                         if (res == null)
147                                 continue;
148                         DataBase bean = new DataBase();
149                         bean.setTotal((int)(long)res.get(0));
150                         bean.setTotalOK((int)(long)res.get(1));
151                         bean.setTotalStopped((int)(long)res.get(2));
152                         bean.setTotalError((int)(long)res.get(3));
153                         bean.setTotalTimeOut((int)(long)res.get(4));
154                         bean.setDate(DateFormat(date.getTime()));
155                         query.add(bean);
156                 }
157                 return query;
158         }
159
160         /*
161          * query: jobs and sequence at date
162          */
163         public List<DataBase> readJobByDay (String date) {
164                 if (null == date) {
165                         return null;
166                 }
167                 if (!isThisDateValid(date, formatDDMMYY)) {
168                         System.out.println("CassandraRequester.readJobByDay: Wrong date format for " + date);
169                         return null;
170                 }
171                 SetDateRange();
172                 long day = DateParsing(date, formatDDMMYY);
173                 if (day < earlestDate || day > currentDate)
174                         return null;    
175                 List<Pair<String, String>>      res = db.ReadProteinData(day);
176                 if (res == null)
177                         return null;
178                 query = new ArrayList<DataBase>();
179                 for (Pair<String, String> entry : res) {                
180                         DataBase bean = new DataBase();
181                         bean.setDate(date);
182                         bean.setId(entry.getElement0());
183                         bean.setProt(entry.getElement1());
184                         query.add(bean);
185                 }
186                 return query;
187         }
188
189
190         /* 
191          * query: protein sequence
192          * */
193         public List<ProteinBean> readProteins(String protIn, String flag) {
194                 List<ProteinBean> result;
195                 if (flag.equals("whole")) 
196                         result = db.ReadWholeSequence(protIn);
197                  else 
198                          result = db.ReadPartOfSequence(protIn);
199                 if (result == null)
200                         return null;
201                 
202                 if (flag.equals("part")) {
203                         for (ProteinBean entry : result) {
204                                 entry.setSubProt(CreateSubprot(entry.getSequence(), protIn));
205                         }
206                 }                                       
207                 return result;
208         }
209         
210
211         /* 
212          * query protein sequences with number of jobs
213          */
214         public List<DataBase> readProteinByCounter(int minimalcounter) {
215                 query = new ArrayList<DataBase>();
216                 Map<String, Integer> map = db.ReadProteinSequenceByCounter();
217                 for (Map.Entry<String, Integer> entry : map.entrySet()) {
218                         if (entry.getValue() > minimalcounter && entry.getKey().length() > 0) {
219                                 DataBase bean = new DataBase();
220                                 bean.setTotalId(entry.getValue());
221                                 bean.setProt(entry.getKey());
222                                 query.add(bean);
223                         }
224                 }
225                 return query;
226         }
227         
228         /* 
229          * query ip with number of jobs
230          */
231         public List<DataBase> readIpByCounter(Integer minimalcounter) {
232                 query = new ArrayList<DataBase>();
233                 Map<String, Integer> map = db.ReadIpByCounter();
234                 if (minimalcounter == null)
235                         minimalcounter = 0;
236                 if (map == null)
237                         return null;
238                 for (Map.Entry<String, Integer> entry : map.entrySet()) {
239                         if (entry.getValue() > minimalcounter) {
240                                 DataBase bean = new DataBase();
241                                 bean.setTotalId(entry.getValue());
242                                 bean.setIp(entry.getKey());
243                                 query.add(bean);
244                         }
245                 }
246                 return query;
247         }
248         /*
249          * query jobs log info
250          */
251         public DataBase readJobLog(String jobid) {
252                 if (jobid == null)
253                         return null;
254                 StructureJobLog res = db.ReadJobLog(jobid);
255                 if (res == null)
256                         return null;
257                 DataBase query = new DataBase();
258                 query.setLogInfo(res);
259                 return query;
260         }
261         
262         
263         /*
264          * query jobs by ipStructureJobLog
265          */
266         public List<DataBase> readIp(String ip) {
267                 if (ip == null)
268                         return null;
269                 List<Pair<String, String>> res = db.ReadIpWithJobs(ip);
270                 if (res == null) 
271                         return null;
272                 query = new ArrayList<DataBase>();
273                 for (Pair<String, String> entry : res) {
274                         DataBase bean = new DataBase();
275                         bean.setIp(ip);
276                         bean.setId(entry.getElement0());
277                         bean.setProt(entry.getElement1());
278                         query.add(bean);
279                 }
280                 return query;
281         }
282         
283         /*
284          * create list of parts of protein sequence;
285          */
286         private static List<String> CreateSubprot (String protein, String subprot) {
287                 List<String> sub = new ArrayList<String>();
288                 String subStr = protein;
289                 while (subStr.length() > 0 && subStr.contains(subprot)) {
290                         String first = subStr.substring(0, subStr.indexOf(subprot));
291                         if (first.length() > 0)
292                                 sub.add(first);
293                         sub.add(subprot);
294                         subStr = subStr.substring(subStr.indexOf(subprot) + subprot.length(), subStr.length());
295                 }
296                 if (subStr.length() > 0)
297                         sub.add(subStr);
298                 return sub;
299         }
300         /*
301          * convert String date into long date (miliseconds since the epoch start)
302          */
303         private static long DateParsing(String datInput, SimpleDateFormat formatter) {
304                 if (datInput == null) {
305                         return 0;
306                 }
307                 long dateWorkSt = 0;
308                 
309                 try {
310                         dateWorkSt = formatter.parse(datInput).getTime();
311                 } catch (ParseException e) {
312                         e.printStackTrace();
313                 }
314                 return dateWorkSt;
315         }
316
317         // convert long to date in string format
318         private static String DateFormat(long inDate) {
319                 SimpleDateFormat datformat = new SimpleDateFormat("dd/MM/yyyy");
320                 return datformat.format(new Date(inDate));
321         }
322
323         /*
324          * set earlest date and current dates. earlestDate is static and should be
325          * set at the 1st call currentDate should be re-calculated every time
326          */
327         private static void SetDateRange() {
328                 Calendar cal = Calendar.getInstance();
329                 currentDate = DateParsing(cal.get(Calendar.YEAR) + "/" + (cal.get(Calendar.MONTH) + 1) + "/" + cal.get(Calendar.DAY_OF_MONTH), formatYYMMDD);
330                 if (0 == earlestDate) {
331                         CassandraRequester cr = new CassandraRequester();
332                         earlestDate = cr.earliestDate();
333                 }
334         }
335
336         public boolean isThisDateValid(String dateToValidate, SimpleDateFormat sdf) {
337                 if (dateToValidate == null || dateToValidate.equals("")) {
338                         return false;
339                 }
340                 try {
341                         // if not valid, this will throw ParseException
342                         sdf.setLenient(false);
343                         Date date = sdf.parse(dateToValidate);
344                 } catch (ParseException e) {
345                         e.printStackTrace();
346                         return false;
347                 }
348                 return true;
349         }
350
351         /*
352          * find the earliest date in the database
353          */
354         public long earliestDate() {
355                 earlestDate = CassandraNativeConnector.getEarliestDateInDB();
356                 return earlestDate;
357         }
358         
359 }