Comments

• michi Members

  September 2011

  Hi,
  
  it's quite easy to make sahi kerberos capable.
  
  The following changes have to be done (have a look at the TODO's):
  
  [h]net.sf.sahi.request.HttpRequest[/h]

  public HttpRequest modifyForFetch() {
          if (logger.isLoggable(Level.FINEST)) {
              logger.finest("REQUEST HEADERS BEFORE MODIFICATION");
              logger.finest(new String(rawHeaders()));
          }
          removeHeader("Proxy-Connection");
          removeHeader("Accept-Encoding");
          addHeader("Accept-Encoding", "gzip");
          removeHeader("Keep-Alive");
          removeHeader("sahi-isxhr");
   
          // TODO:The following lines have to be removed
          // Not sure whether Authorization and Proxy-Authorization should be
          // removed.
          // removeHeader("Authorization");
          // removeHeader("Proxy-Authorization");
   
          // cookies().remove("sahisid");
          // setHeader("Cookie", rebuildCookies());
          resetRawHeaders();
          if (logger.isLoggable(Level.FINEST)) {
              logger.finest("REQUEST HEADERS AFTER MODIFICATION");
              logger.finest(firstLine());
              logger.finest("\n------------\n\nRequest Headers:\n" + headers());
          }
          return this;
  }
  

  
  [h]net.sf.sahi.request.RemoteRequestProcessor[/h]

  public HttpResponse processHttp(final HttpRequest requestFromBrowser,
              boolean modify) {
          try {
              ThreadLocalMap.put("session", requestFromBrowser.session());
   
              TrafficLogger.storeRequestHeader(requestFromBrowser.rawHeaders(),
                      "unmodified");
              TrafficLogger.storeRequestBody(requestFromBrowser.data(),
                      "unmodified");
              requestFromBrowser.modifyForFetch();
              TrafficLogger.storeRequestHeader(requestFromBrowser.rawHeaders(),
                      "modified");
              String urlStr = requestFromBrowser.url();
              final URL url = new URL(urlStr);
              if (logger.isLoggable(Level.FINE)) {
                  logger.fine(url.toString());
              }
   
              HttpURLConnection connection = (HttpURLConnection) url
                      .openConnection();
              connection.setDefaultUseCaches(true);
              connection.setUseCaches(true);
              HttpURLConnection.setFollowRedirects(false);
              if (logger.isLoggable(Level.FINEST)) {
                  logger.finest("requestFromBrowser.headers():");
                  logger.finest(requestFromBrowser.headers().toString());
              }
              setConnectionRequestHeaders(requestFromBrowser, connection);
   
              if (logger.isLoggable(Level.FINEST)) {
                  logger.finest("Request headers set on connection:");
                  logger.finest(getReqHeaders(connection));
              }
   
              HttpResponse response = null;
              int responseCode = -1;
              try {
                  connection.setRequestMethod(requestFromBrowser.method()
                          .toUpperCase());
                  if (requestFromBrowser.isPost() || requestFromBrowser.isPut()) {
                      if (logger.isLoggable(Level.FINEST)) {
                          logger.finest("In post requestFromBrowser.data() = "
                                  + requestFromBrowser.data());
                      }
                      connection.setDoOutput(true);
                      OutputStream outputStreamToHost = connection
                              .getOutputStream();
                      outputStreamToHost.write(requestFromBrowser.data());
                      outputStreamToHost.close();
                  }
                  InputStream inputStreamFromHost = null;
                  responseCode = connection.getResponseCode();
                  if (logger.isLoggable(Level.FINE)) {
                      logger.fine("responseCode  = " + responseCode);
                  }
                  if (responseCode < 400) {
                      inputStreamFromHost = connection.getInputStream();
                  } else {
                      if (logger.isLoggable(Level.FINE)) {
                          logger.fine("Fetching error stream");
                      }
                      inputStreamFromHost = connection.getErrorStream();
                  }
                  boolean isGZIP = "gzip".equals(connection.getContentEncoding());
                  if (logger.isLoggable(Level.FINER)) {
                      logger.finer("isGZIP=" + isGZIP
                              + "; connection.getContentEncoding()="
                              + connection.getContentEncoding());
                  }
                  if (isGZIP) {
                      if (logger.isLoggable(Level.FINE)) {
                          logger.fine("Using GZIPInputStream");
                      }
                      inputStreamFromHost = new GZIPInputStream(
                              inputStreamFromHost);
                  }
                  if (responseCode >= 500 && !requestFromBrowser.isAjax()) {
                      if (logger.isLoggable(Level.FINE)) {
                          logger.fine("Returning get5xxResponse");
                      }
                      response = getWrappedResponse(get5xxResponse(responseCode,
                              inputStreamFromHost));
                  // TODO:remove the 401 case, so that the browser can handle it
                  // } else if (responseCode == 401) {
                  // if (logger.isLoggable(Level.FINE)) {
                  // logger.fine("Returning process401");
                  // }
                  // response = process401(connection, inputStreamFromHost);
                  } else {
                      response = getResponse(inputStreamFromHost, connection);
                      TrafficLogger.storeResponseHeader(response.headers()
                              .toString().getBytes(), "unmodified");
                      TrafficLogger.storeResponseBody(response.data(),
                              "unmodified");
                  }
   
                  if (requestFromBrowser.isAjax() && responseCode > 300
                          && responseCode < 306) {
                      String redirectedTo = response
                              .getLastSetValueOfHeader("Location");
                      if (redirectedTo != null)
                          requestFromBrowser.session().addAjaxRedirect(
                                  redirectedTo);
   
                  }
   
                  if (isGZIP) {
                      response.removeHeader("Content-Encoding", "gzip");
                      if (response instanceof StreamingHttpResponse)
                          response.setContentLength(-1);
                  }
   
              } catch (IOException uhe) {
                  if (uhe instanceof SSLHandshakeException)
                      uhe.printStackTrace();
                  if (logger.isLoggable(Level.WARNING)
                          && !urlStr.contains("DesignerOutput")) {
                      logger.warning("Returning CannotConnectResponse for: "
                              + urlStr);
                      logger.fine(Utils.getStackTraceString(uhe));
                  }
                  response = getWrappedResponse(getCannotConnectResponse(uhe));
              }
              if (responseCode != 204 && responseCode != 304) {
                  String contentTypeHeader = response.contentTypeHeader();
                  boolean downloadContentType = isDownloadContentType(contentTypeHeader);
                  boolean attachment = response.isAttachment();
                  boolean downloadURL = isDownloadURL(urlStr);
                  if (logger.isLoggable(Level.FINER)) {
                      logger.finer("downloadURL = " + downloadURL);
                      logger.finer("response.isAttachment() = " + attachment);
                      logger.finer("contentTypeHeader = " + contentTypeHeader);
                      logger
                              .finer("downloadContentType = "
                                      + downloadContentType);
                      logger
                              .finer("Content-Disposition="
                                      + response
                                              .getLastSetValueOfHeader("Content-Disposition"));
                  }
                  if (responseCode == 200
                          && (downloadContentType || attachment || downloadURL)) {
                      if (logger.isLoggable(Level.INFO)) {
                          logger.info("Calling downloadFile");
                          logger.info(requestFromBrowser.url());
                          logger.info("downloadURL = " + downloadURL);
                          logger.info("response.isAttachment() = " + attachment);
                          logger.info("contentTypeHeader = " + contentTypeHeader);
                          logger.info("downloadContentType = "
                                  + downloadContentType);
                          logger
                                  .info("Content-Disposition="
                                          + response
                                                  .getLastSetValueOfHeader("Content-Disposition"));
                      }
                      downloadFile(requestFromBrowser, response);
                      return new NoContentResponse();
                  }
                  // TODO:add this if to make sure that the response wont be modified
                  if (responseCode != 401)
                      response = addFilters(requestFromBrowser, modify, response,
                              responseCode);
              }
              if (responseCode == 204) {
                  requestFromBrowser.session().set204(true);
              }
              // Can be used to induce a delay in playback for testing Sahi
              // Thread.sleep(10000);
              return response;
          } catch (Exception e) {
              if (logger.isLoggable(Level.WARNING)) {
                  logger.warning(Utils.getStackTraceString(e));
              }
              return null;
          }
  }