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.Collections;
   8 import java.util.Date;
   9 import java.util.Iterator;
  10 import java.util.List;
  11
  12 import compbio.cassandra.CassandraNativeConnector;
  13 import compbio.cassandra.DataBase;
  14
  15 public class CassandraRequester {
  16         private CassandraNativeConnector DBInstance = new CassandraNativeConnector();
  17         private ArrayList<DataBase> query;
  18         private static long currentDate = 0;
  19         private static long earlestDate = 0;
  20
  21
  22         /*
  23          * query: execution time for the period from date1 till date2
  24          * */
  25         public List<DataBase> extractExecutionTime(String date1, String date2) {
  26                 if (!isThisDateValid(date1) || !isThisDateValid(date2)) {
  27                         System.out.println("Wrong date: point 3");
  28                         return null;
  29                 }
  30                 SetDateRange();
  31                 int nbins = 5;
  32                 long dateStart = DateParsing(date1);
  33                 long dateEnd = DateParsing(date2);
  34                 if ((dateStart < earlestDate && dateEnd < earlestDate) || (dateStart > currentDate && dateEnd > currentDate) || dateStart > dateEnd)
  35                         return null;
  36                 if (dateStart < earlestDate)
  37                         dateStart = earlestDate;
  38                 if (dateEnd > currentDate)
  39                         dateStart = currentDate;
  40
  41                 System.out.println("CassandraRequester.extractExecutionTime: earlestDate = " + earlestDate + ", currentDate = " + currentDate);
  42
  43                 Calendar start = Calendar.getInstance();
  44                 start.setTime(new Date(dateStart));
  45                 Calendar end = Calendar.getInstance();
  46                 end.setTime(new Date(dateEnd));
  47                 query = new ArrayList<DataBase>();
  48                 List<Integer> totalTime = new ArrayList<Integer>();
  49                 for (int i = 0; i < nbins; i++)
  50                         totalTime.add(i, 0);
  51                 /*
  52                 for (Date date = start.getTime(); !start.after(end); start.add(Calendar.DATE, 1), date = start.getTime()) {
  53                         List<Integer> timeResult = new ArrayList<Integer>();
  54                         SliceQuery<Long, String, String> result = HFactory.createSliceQuery(DBInstance.GetKeyspace(), LongSerializer.get(),
  55                                         StringSerializer.get(), StringSerializer.get());
  56                         result.setColumnFamily("ProteinData");
  57                         result.setKey(date.getTime());
  58                         result.setRange(null, null, false, Integer.MAX_VALUE);
  59                         QueryResult<ColumnSlice<String, String>> columnSlice = result.execute();
  60                         List<HColumn<String, String>> col = columnSlice.get().getColumns();
  61                         if (!col.isEmpty()) {
  62                                 Iterator<HColumn<String, String>> itCol = col.iterator();
  63                                 for (int i = 0; i < nbins; i++)
  64                                         timeResult.add(i, 0);
  65                                 // split all jobs into nbins bins
  66                                 while (itCol.hasNext()) {
  67                                         String id = itCol.next().getName();
  68                                         long lenResult = CountID(id);
  69                                         if (lenResult <= 30)
  70                                                 timeResult.set(0, timeResult.get(0) + 1);
  71                                         else if (lenResult > 30 && lenResult <= 60)
  72                                                 timeResult.set(1, timeResult.get(1) + 1);
  73                                         else if (lenResult > 60 && lenResult <= 120)
  74                                                 timeResult.set(2, timeResult.get(2) + 1);
  75                                         else if (lenResult > 120 && lenResult <= 600)
  76                                                 timeResult.set(3, timeResult.get(3) + 1);
  77                                         else {
  78                                                 timeResult.set(4, timeResult.get(4) + 1);
  79                                         }
  80                                 }
  81                                 for (int i = 0; i < nbins; i++)
  82                                         totalTime.set(i, totalTime.get(i) + timeResult.get(i));
  83                                 DataBase db = new DataBase();
  84                                 db.setTimeRez(timeResult);
  85                                 db.setDate(DateFormat(date.getTime()));
  86                                 query.add(db);
  87                         }
  88                 }
  89                 */
  90                 DataBase db = new DataBase();
  91                 db.setTimeTotalExec(totalTime);
  92                 query.add(db);
  93                 System.out.println("StatisticsProt.readLength: total number of dates = " + query.size());
  94                 return query;
  95         }
  96
  97         /*
  98          * convert String date into long date (miliseconds since the epoch start)
  99          */
 100         private static long DateParsing(String datInput) {
 101                 if (datInput == null) {
 102                         return 0;
 103                 }
 104                 long dateWorkSt = 0;
 105                 SimpleDateFormat formatter = new SimpleDateFormat("yyyy/MM/dd");
 106                 try {
 107                         dateWorkSt = formatter.parse(datInput).getTime();
 108                 } catch (ParseException e) {
 109                         e.printStackTrace();
 110                 }
 111                 return dateWorkSt;
 112         }
 113
 114         /*
 115          * convert String date:time into long date:time (miliseconds since the epoch start)
 116          */
 117         private static long TimeConvert(String datInput) {
 118                 long dateWorkSt = 0;
 119                 if (datInput == null) {
 120                         return dateWorkSt;
 121                 }
 122                 SimpleDateFormat formatter = new SimpleDateFormat("yyyy/MM/dd:hh:mm:ss");
 123                 try {
 124                         dateWorkSt = formatter.parse(datInput).getTime();
 125                 } catch (ParseException e) {
 126                         e.printStackTrace();
 127                 }
 128                 return dateWorkSt;
 129         }
 130
 131         // convert long to date in string format
 132         private static String DateFormat(long inDate) {
 133                 SimpleDateFormat datformat = new SimpleDateFormat("dd/MM/yyyy");
 134                 String dateString = datformat.format(new Date(inDate));
 135                 return dateString;
 136         }
 137
 138         /*
 139          * convert ???
 140          */
 141         public static String DateFormatYYMMDD(long indate) {
 142                 SimpleDateFormat datformat = new SimpleDateFormat("yyyy/MM/dd");
 143                 String dateString = datformat.format(new Date(indate));
 144                 return dateString;
 145         }
 146
 147         /*
 148          * ???
 149          */
 150         public long CountID(String id) {
 151                 /*
 152                 SliceQuery<String, String, String> sliceQuery = HFactory.createSliceQuery(DBInstance.GetKeyspace(), StringSerializer.get(),
 153                                 StringSerializer.get(), StringSerializer.get());
 154                 sliceQuery.setColumnFamily("ProteinLog").setKey(id).setRange("", "", false, 100);
 155                 QueryResult<ColumnSlice<String, String>> result = sliceQuery.execute();
 156                 String datBegin = result.get().getColumnByName("DataBegin").getValue();
 157                 String datEnd = result.get().getColumnByName("DataEnd").getValue();
 158
 159                 long datBeginLong = TimeConvert(datBegin);
 160                 long datEndLong = TimeConvert(datEnd);
 161                 return (datEndLong - datBeginLong) / 1000;
 162                 */
 163                 return 0;
 164         }
 165
 166         /*
 167          * set earlest date and current dates.
 168          * earlestDate is static and should be set at the 1st call
 169          * currentDate should be re-calculated every time
 170          */
 171         private static void SetDateRange() {
 172                 if (0 == earlestDate) {
 173                         StatisticsProt sp = new StatisticsProt();
 174                         earlestDate = sp.earliestDate();
 175                         System.out.println("Set earlest Date = " + earlestDate);
 176                 }
 177                 Calendar cal = Calendar.getInstance();
 178                 currentDate = DateParsing(cal.get(Calendar.YEAR) + "/" + (cal.get(Calendar.MONTH) + 1) + "/" + cal.get(Calendar.DAY_OF_MONTH));
 179         }
 180
 181         public boolean isThisDateValid(String dateToValidate) {
 182                 if (dateToValidate == null || dateToValidate.equals("")) {
 183                         System.out.println("Undefined date");
 184                         return false;
 185                 }
 186                 SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
 187                 try {
 188                         // if not valid, this will throw ParseException
 189                         sdf.setLenient(false);
 190                         Date date = sdf.parse(dateToValidate);
 191                 } catch (ParseException e) {
 192                         e.printStackTrace();
 193                         return false;
 194                 }
 195                 return true;
 196         }
 197
 198         /*
 199          * find the earliest date in the database
 200          */
 201         public long earliestDate() {
 202                 /*
 203                 ArrayList<Long> dateSort = new ArrayList<Long>();
 204                 int row_count = 10000;
 205                 RangeSlicesQuery<Long, String, String> result = HFactory.createRangeSlicesQuery(DBInstance.GetKeyspace(), LongSerializer.get(),
 206                                 StringSerializer.get(), StringSerializer.get());
 207                 result.setColumnFamily("ProteinData");
 208                 result.setRange(null, null, false, Integer.MAX_VALUE);
 209                 result.setRowCount(row_count);
 210                 Long last_key = null;
 211                 while (true) {
 212                         result.setKeys(last_key, null);
 213                         QueryResult<OrderedRows<Long, String, String>> columnSlice = result.execute();
 214                         OrderedRows<Long, String, String> rows = columnSlice.get();
 215                         Iterator<Row<Long, String, String>> rowsIterator = rows.iterator();
 216                         while (rowsIterator.hasNext()) {
 217                                 Row<Long, String, String> row = rowsIterator.next();
 218                                 last_key = row.getKey();
 219                                 dateSort.add(last_key);
 220                         }
 221                         if (rows.getCount() < row_count)
 222                                 break;
 223                 }
 224                 Collections.sort(dateSort);
 225                 return dateSort.get(0);
 226                 */
 227                 return 0;
 228         }
 229 }