src/eu/cepl/network/SimpleHTTP.java

   1 package eu.cepl.network;
   2
   3 /*
   4  * TODO:
   5  * - I have to figure out how to switch on logging for HTTP protocol
   6  * - Location:
   7  * - Cookies!
   8  */
   9 import java.io.BufferedInputStream;
  10 import java.io.BufferedOutputStream;
  11 import java.io.ByteArrayInputStream;
  12 import java.io.IOException;
  13 import java.io.InputStreamReader;
  14 import java.io.UnsupportedEncodingException;
  15 import java.net.MalformedURLException;
  16 import java.net.URL;
  17 import java.net.URLConnection;
  18 import java.net.URLEncoder;
  19 import java.util.HashMap;
  20 import java.util.Map;
  21 import java.util.Map.Entry;
  22
  23 public class SimpleHTTP {
  24
  25         private URL url = null;
  26         private BufferedInputStream inBS = null;
  27         private BufferedOutputStream outBS = null;
  28         // private ConsoleHandler hand = new ConsoleHandler();
  29         private URLConnection conn = null;
  30         private URLConnection connection;
  31
  32         final static int BUFMAX = 1024;
  33
  34         // private static Logger logger =
  35         // Logger.getLogger(SimpleHTTP.class.getName());
  36         /**
  37      *
  38      *
  39      */
  40         public SimpleHTTP() {
  41                 // logger.addHandler(hand);
  42                 // hand.setFormatter(new ReallySimpleFormatter());
  43                 //
  44                 // if (new Boolean(System.getProperty("debugging"))) {
  45                 // hand.setLevel(Level.FINE);
  46                 // logger.setLevel(Level.FINE);
  47                 // } else {
  48                 // hand.setLevel(Level.INFO);
  49                 // logger.setLevel(Level.INFO);
  50                 // }
  51         }
  52
  53         /**
  54          *
  55          * @param inURL
  56          */
  57         public SimpleHTTP(URL inURL) {
  58                 init(inURL);
  59         }
  60
  61         /**
  62          *
  63          * @param strURL
  64          * @throws MalformedURLException
  65          */
  66         public SimpleHTTP(String strURL) throws MalformedURLException {
  67                 init(new URL(strURL));
  68         }
  69
  70         /**
  71          *
  72          * @param initURL
  73          */
  74         private void init(URL initURL) {
  75                 url = initURL;
  76         }
  77
  78         /**
  79          *
  80          * @return
  81          */
  82         public URL getUrl() {
  83                 return url;
  84         }
  85
  86         /**
  87          *
  88          * @param headers
  89          * @return
  90          * @throws IOException
  91          */
  92         private URLConnection getConnection(Map<String, String> headers)
  93                         throws IOException {
  94                 if (headers == null) {
  95                         headers = new HashMap<String, String>();
  96                 }
  97                 if (conn == null) {
  98                         conn = url.openConnection();
  99                         for (Entry<String, String> e : headers.entrySet()) {
 100                                 conn.addRequestProperty(e.getKey(), e.getValue());
 101                         }
 102                 }
 103                 return conn;
 104         }
 105
 106         /**
 107          *
 108          * @param headers
 109          * @return
 110          * @throws IOException
 111          */
 112         public BufferedOutputStream getWriter(Map<String, String> headers)
 113                         throws IOException {
 114                 try {
 115                         connection = getConnection(headers);
 116                         connection.setDoOutput(true);
 117                         outBS = new BufferedOutputStream(connection.getOutputStream());
 118                 } catch (UnsupportedEncodingException e) {
 119                         // Cannot happen, UTF-8 is correct.
 120                 } catch (IOException e) {
 121                         throw new IOException("Cannot read from the HTTP command results.",
 122                                         e);
 123                 }
 124                 return outBS;
 125         }
 126
 127         /**
 128          * Provides BufferedInputStream pointing to the URL.
 129          *
 130          * @param headers
 131          * @return
 132          * @throws IOException
 133          */
 134         public BufferedInputStream getInputStream(Map<String, String> headers)
 135                         throws IOException {
 136                 try {
 137                         connection = getConnection(headers);
 138                         inBS = new BufferedInputStream(connection.getInputStream());
 139                 } catch (IOException e) {
 140                         System.err.println("Cannot create BufferedInputStream for URL "
 141                                         + url.toString());
 142                         e.printStackTrace();
 143                         throw e;
 144                 }
 145                 return inBS;
 146         }
 147
 148         /**
 149          * reads whole stream into string
 150          *
 151          * @param in
 152          *            incoming byte stream
 153          * @return String in UTF-8 encoding
 154          * @throws IOException
 155          */
 156         String suck(BufferedInputStream in) throws IOException {
 157                 StringBuffer inBuf = new StringBuffer();
 158                 InputStreamReader inR = null;
 159                 int count = 0;
 160
 161                 try {
 162                         inR = new InputStreamReader(in, "UTF-8");
 163                 } catch (UnsupportedEncodingException e) {
 164                         // Cannot happen, UTF-8 is always supported
 165                 }
 166                 char[] cbuf = new char[BUFMAX];
 167
 168                 while ((count = inR.read(cbuf)) != -1) {
 169                         inBuf.append(cbuf, 0, count);
 170                 }
 171
 172                 return inBuf.toString();
 173         }
 174
 175         /**
 176          *
 177          * @param headers
 178          * @return
 179          * @throws IOException
 180          */
 181         public String get(Map<String, String> headers) throws IOException {
 182                 BufferedInputStream inCh;
 183
 184                 if (headers == null) {
 185                         headers = new HashMap<String, String>();
 186                 }
 187
 188                 try {
 189                         inCh = getInputStream(headers);
 190                 } catch (IOException e) {
 191                         throw new IOException("Cannot create Reader for URL "
 192                                         + url.toString(), e);
 193                 }
 194
 195                 return suck(inCh);
 196         }
 197
 198         /**
 199          *
 200          * @return
 201          * @throws IOException
 202          */
 203         public String get() throws IOException {
 204                 return get(null);
 205         }
 206
 207         /**
 208          *
 209          * @param inStream
 210          * @param headers
 211          * @param mime String with MIME type of data in {@literal inStream}
 212          * @return BufferedInputStream with the data returned from the server
 213          * @throws IOException
 214          */
 215         @SuppressWarnings("unused")
 216         public BufferedInputStream post(BufferedInputStream inStream,
 217                         Map<String, String> headers, String mime) throws IOException {
 218
 219                 BufferedOutputStream outCh;
 220                 BufferedInputStream inCh;
 221                 long inLen = 0;
 222                 int c = 0;
 223                 byte[] inBuf = new byte[BUFMAX];
 224                 String mimeType = "";
 225
 226                 if (mime == null) {
 227                         mimeType = "application/octet-stream";
 228                 } else {
 229                         mimeType = mime;
 230                 }
 231
 232                 if (headers == null) {
 233                         headers = new HashMap<String, String>();
 234                 }
 235
 236                 if (inLen > 0) {
 237                         headers.put("Content-Type", mimeType);
 238                         headers.put("Content-Length", Long.toString(inLen));
 239                 }
 240
 241                 try {
 242                         outCh = getWriter(headers);
 243                         while ((c = inStream.read(inBuf)) != -1) {
 244                                 outCh.write(inBuf);
 245                         }
 246                         outCh.flush();
 247                         outCh.close();
 248                 } catch (IOException e) {
 249                         throw new IOException("Cannot POST to URL " + url.toString(), e);
 250                 }
 251
 252                 try {
 253                         inCh = getInputStream(null);
 254                 } catch (IOException e) {
 255                         throw new IOException("Cannot create Reader for URL "
 256                                         + url.toString(), e);
 257                 }
 258
 259                 return inCh;
 260         }
 261
 262         /**
 263          * The main POST method for the object, expected to be used most. Both
 264          * accepts data as String and returnes back String as a result.
 265          *
 266          * @param data
 267          *            String with data to be sent in the body of POST
 268          * @param headers
 269          *            Map with pairs of String ... name of the header and the value
 270          *            of the header.
 271          * @return String with the result of the calling POST
 272          * @throws IOException
 273          */
 274         public String post(String data, Map<String, String> headers)
 275                         throws IOException {
 276
 277                 return suck(post(new BufferedInputStream(new ByteArrayInputStream(
 278                                                 data.getBytes("UTF-8"))), headers,
 279                                 "application/x-www-form-urlencoded"));
 280         }
 281
 282         /**
 283          *
 284          * @param inDict
 285          * @param headers
 286          * @return
 287          * @throws IOException
 288          */
 289         public String post(Map<String, String> inDict, Map<String, String> headers)
 290                         throws IOException {
 291                 String strData = "";
 292
 293                 for (Entry<String, String> e : inDict.entrySet()) {
 294                         try {
 295                                 strData += URLEncoder.encode(e.getKey(), "UTF-8") + "="
 296                                                 + URLEncoder.encode(e.getValue(), "UTF-8") + "&";
 297                         } catch (UnsupportedEncodingException e1) {
 298                                 // Never happens, UTF-8 is always supported
 299                         }
 300                 }
 301                 if (strData.charAt(strData.length() - 1) == '&') {
 302                         strData = strData.substring(0, strData.length() - 1);
 303                 }
 304                 return post(strData, headers);
 305         }
 306
 307         /**
 308          *
 309          * @param inData
 310          * @return
 311          * @throws IOException
 312          */
 313         public String post(String inData) throws IOException {
 314                 return post(inData, null);
 315         }
 316
 317         /**
 318          *
 319          * @param inDict
 320          * @return
 321          * @throws IOException
 322          */
 323         public String post(Map<String, String> inDict) throws IOException {
 324                 return post(inDict, null);
 325         }
 326 }