src/jalview/ws/rest/HttpResultSet.java

   1 package jalview.ws.rest;
   2
   3 import jalview.bin.Cache;
   4 import jalview.io.FileParse;
   5 import jalview.io.packed.DataProvider;
   6 import jalview.io.packed.ParsePackedSet;
   7 import jalview.io.packed.SimpleDataProvider;
   8 import jalview.io.packed.DataProvider.JvDataType;
   9 import jalview.ws.io.mime.JalviewMimeContentHandler;
  10
  11 import java.io.BufferedReader;
  12 import java.io.IOException;
  13 import java.io.InputStreamReader;
  14 import java.io.UnsupportedEncodingException;
  15 import java.util.ArrayList;
  16 import java.util.List;
  17
  18 import org.apache.http.HttpEntity;
  19 import org.apache.http.HttpResponse;
  20 import org.apache.http.client.methods.HttpRequestBase;
  21 import org.apache.http.entity.mime.MultipartEntity;
  22 import org.apache.james.mime4j.MimeException;
  23 import org.apache.james.mime4j.parser.ContentHandler;
  24 import org.apache.james.mime4j.parser.MimeStreamParser;
  25
  26 /**
  27  * data source instantiated from the response of an httpclient request.
  28  *
  29  * @author JimP
  30  *
  31  */
  32
  33 public class HttpResultSet extends FileParse
  34 {
  35
  36   private HttpRequestBase cachedRequest;
  37
  38   /**
  39    * when set, indicates that en can be recreated by repeating the HttpRequest
  40    * in cachedRequest
  41    */
  42   boolean repeatable = false;
  43
  44   /**
  45    * response that is to be parsed as jalview input data
  46    */
  47   private HttpEntity en = null;
  48
  49   /**
  50    * (sub)job that produced this result set.
  51    */
  52   private RestJob restJob;
  53
  54   public HttpResultSet(RestJob rj, HttpResponse con, HttpRequestBase req)
  55           throws IOException
  56   {
  57     super();
  58     setDataName(rj.getJobId() + " Part " + rj.getJobnum());
  59     restJob = rj;
  60     cachedRequest = req;
  61     initDataSource(con);
  62   }
  63
  64   /**
  65    * construct a set of dataproviders to parse a result set from this service
  66    *
  67    * @param resSet
  68    * @return
  69    */
  70   public List<DataProvider> createResultDataProviders()
  71   {
  72     List<DataProvider> dp = new ArrayList<DataProvider>();
  73     for (JvDataType type : restJob.rsd.getResultDataTypes())
  74     {
  75       dp.add(new SimpleDataProvider(type, this, null));
  76     }
  77     return dp;
  78   }
  79
  80   public Object[] parseResultSet() throws Exception, Error
  81   {
  82     List<DataProvider> dp = new ArrayList<DataProvider>();
  83     Object[] results = null;
  84
  85     if (en == null)
  86     {
  87       throw new Error(
  88               "Implementation Error: need to have an HttpResponse to process.");
  89     }
  90     jalview.io.packed.JalviewDataset ds = restJob.newJalviewDataset();
  91     // Decide how we deal with content.
  92     if (en instanceof MultipartEntity)
  93     {
  94       // Multipart messages should be properly typed, so we parse them as we go.
  95       MultipartEntity mpe = (MultipartEntity) en;
  96       // multipart
  97       JalviewMimeContentHandler handler = new JalviewMimeContentHandler(ds);
  98       MimeStreamParser parser = new MimeStreamParser();
  99       parser.setContentHandler(handler);
 100       try
 101       {
 102         parser.parse(mpe.getContent());
 103       } catch (MimeException me)
 104       {
 105         error = true;
 106         errormessage = "Couldn't parse message from web service.";
 107         Cache.log.warn("Failed to parse MIME multipart content", me);
 108         en.consumeContent();
 109       }
 110       return new ParsePackedSet().getAlignment(ds,
 111               handler.getJalviewDataProviders());
 112     }
 113     else
 114     {
 115       // Need to use hints from rest service description.
 116       dp = createResultDataProviders();
 117       ParsePackedSet pps = new ParsePackedSet();
 118       return pps.getAlignment(ds, dp);
 119     }
 120   }
 121
 122   private void initDataSource(HttpResponse con) throws IOException
 123   {
 124     en = con.getEntity();
 125     repeatable = en.isRepeatable();
 126
 127     if (!(en instanceof MultipartEntity))
 128     {
 129       // assume content is simple text stream that can be read from
 130       String enc = (en.getContentEncoding() == null) ? null : en
 131               .getContentEncoding().getValue();
 132       if (en.getContentType() != null)
 133       {
 134         Cache.log.debug("Result Type: " + en.getContentType().toString());
 135       }
 136       else
 137       {
 138         Cache.log.debug("No Result Type Specified.");
 139       }
 140       if (enc == null || enc.length() < 1)
 141       {
 142         Cache.log.debug("Assuming 'Default' Result Encoding.");
 143       }
 144       else
 145       {
 146         Cache.log.debug("Result Encoded as : " + enc);
 147       }
 148       // attempt to identify file and construct an appropriate DataSource
 149       // identifier for it.
 150       // try to parse
 151       // Mime-Multipart or single content type will be expected.
 152       // if (enc.equals(org.apache.http.client.utils.)))
 153       InputStreamReader br = null;
 154       try
 155       {
 156         br = (enc != null) ? new InputStreamReader(en.getContent(), enc)
 157                 : new InputStreamReader(en.getContent());
 158       } catch (UnsupportedEncodingException e)
 159       {
 160         Cache.log.error("Can't handle encoding '" + enc
 161                 + "' for response from webservice.", e);
 162         en.consumeContent();
 163         error = true;
 164         errormessage = "Can't handle encoding for response from webservice";
 165         return;
 166       }
 167       if (br != null)
 168       {
 169         dataIn = new BufferedReader(br);
 170         error = false;
 171       }
 172     }
 173   }
 174
 175   @Override
 176   protected void finalize() throws Throwable
 177   {
 178     dataIn = null;
 179     cachedRequest = null;
 180     try
 181     {
 182       if (en != null)
 183       {
 184         en.consumeContent();
 185       }
 186     } catch (Exception e)
 187     {
 188     } catch (Error ex)
 189     {
 190     }
 191     super.finalize();
 192   }
 193
 194 }