*/
<<<<<<< HEAD:wro4j-core/src/main/java/ro/isdc/wro/model/resource/locator/support/DispatcherStreamLocator.java
/*
 * Copyright (c) 2008. All rights reserved.
 */
package ro.isdc.wro.model.resource.locator.support;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.Validate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import ro.isdc.wro.config.Context;
import ro.isdc.wro.http.support.RedirectedStreamServletResponseWrapper;
import ro.isdc.wro.model.resource.locator.ResourceLocator;
import ro.isdc.wro.util.WroUtil;


/**
 * A strategy which use ByteArray IO Streams and dispatch the request to a given location.
 *
 * @author Alex Objelean
 */
public final class DispatcherStreamLocator {
  private static final Logger LOG = LoggerFactory.getLogger(DispatcherStreamLocator.class);


  /**
   * @return {@link UriLocator} responsible for resolving external resources.
  private ResourceLocator newExternalResourceLocator(final String location) {
    return new UrlResourceLocator(location) {
      /**
       * No wildcard handling is required.
       */
      @Override
      protected boolean disableWildcards() {
        return true;
      };
    };
  }

  /**
   * When using JBoss Portal and it has some funny quirks...actually a portal application have several small web
   * application behind it. So when it intercepts a requests for portal then it start bombing the the application behind
   * the portal with multiple threads (web requests) that are combined with threads for wro4j.
   *
   * @return a valid stream for required location. This method will never return a null.
   * @throws IOException
   *           if the stream cannot be located at the specified location.
   */
  public InputStream getInputStream(final HttpServletRequest request, final HttpServletResponse response,
      final String location)
      throws IOException {
    Validate.notNull(request);
    Validate.notNull(response);
    // where to write the bytes of the stream
    final ByteArrayOutputStream os = new ByteArrayOutputStream();
    boolean warnOnEmptyStream = false;

    // preserve context, in case it is unset during dispatching
    final Context originalContext = Context.get();
    try {
      final RequestDispatcher dispatcher = request.getRequestDispatcher(location);
      if (dispatcher == null) {
        // happens when dynamic servlet context relative resources are included outside of the request cycle (inside
        // the thread responsible for refreshing resources)

        // Returns the part URL from the protocol name up to the query string and contextPath.
        final String servletContextPath = request.getRequestURL().toString().replace(request.getServletPath(), "");
        final String absolutePath = servletContextPath + location;
        return newExternalResourceLocator(absolutePath).getInputStream();
      }
      // Wrap request
      final ServletRequest servletRequest = getWrappedServletRequest(request, location);
      // Wrap response
      final ServletResponse servletResponse = new RedirectedStreamServletResponseWrapper(os, response);
      LOG.debug("dispatching request to location: " + location);
      // use dispatcher
      dispatcher.include(servletRequest, servletResponse);
      warnOnEmptyStream = true;
      // force flushing - the content will be written to
      // BytArrayOutputStream. Otherwise exactly 32K of data will be
      // written.
      servletResponse.getWriter().flush();
      os.close();
    } catch (final Exception e) {
      // Not only servletException can be thrown, also dispatch.include can throw NPE when the scheduler runs outside
      // of the request cycle, thus connection is unavailable. This is caused mostly when invalid resources are
      // included.
      LOG.debug("[FAIL] Error while dispatching the request for location {}", location);
      throw new IOException("Error while dispatching the request for location " + location);
    } finally {
      if (warnOnEmptyStream && os.size() == 0) {
        LOG.warn("Wrong or empty resource with location: {}", location);
      }
      // Put the context back
      if (!Context.isContextSet()) {
        Context.set(originalContext);
      }
    }
    return new ByteArrayInputStream(os.toByteArray());
  }

  /**
   * Build a wrapped servlet request which will be used for dispatching.
   */
  private ServletRequest getWrappedServletRequest(final HttpServletRequest request, final String location) {
    final HttpServletRequest wrappedRequest = new HttpServletRequestWrapper(request) {
      @Override
      public String getRequestURI() {
        return getContextPath() + location;
      }

      @Override
      public String getPathInfo() {
        return WroUtil.getPathInfoFromLocation(location);
      }

      @Override
      public String getServletPath() {
        return WroUtil.getServletPathFromLocation(location);
      }
    };
    return wrappedRequest;
  }
=======
/*
 * Copyright (c) 2008. All rights reserved.
 */
package ro.isdc.wro.model.resource.locator;

import java.io.IOException;
import java.io.InputStream;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.Validate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * The purpose of this locator is to dispatch the request to a given context relative location (doesn't have to include
 * the context path).
 * 

 * Initial implementation used a request dispatcher, but since it doesn't behave correctly when the request are issued
 * outside of request cycle (cache reload scheduler), another approach is preferred. The new approach is to compute
 * absolute url of the request it as a separate connection using {@link UrlUriLocator}.
 * 
 * @author Alex Objelean
 */
public class DispatcherStreamLocator {
  private static final Logger LOG = LoggerFactory.getLogger(DispatcherStreamLocator.class);
  /**
   * Used to locate external resources. No wildcard handling is required.
   */
  private UriLocator externalUriLocator = newExternalUriLocator();
  
  /**
   * @param location
   *          a context relative location to retrieve stream for. This 
   * @return a valid stream for required location. This method will never return a null.
   * @throws IOException
   *           if the stream cannot be located at the specified location.
   */
  public InputStream getInputStream(final HttpServletRequest request, final HttpServletResponse response,
    final String location)
    throws IOException {
    Validate.notNull(request);
    Validate.notNull(response);

    final String absolutePath = computeServletContextPath(request) + location;
    LOG.debug("Locating resource: {}", absolutePath);
    return externalUriLocator.locate(absolutePath);
  }

  /**
   * @return the part URL from the protocol name up to the query string and contextPath.
   */
  private String computeServletContextPath(final HttpServletRequest request) {
    return request.getRequestURL().toString().replace(request.getServletPath(), "");
  }
  
  /**
   * @return {@link UriLocator} used to retrieve stream for absolute location .
   */
  protected UriLocator newExternalUriLocator() {
    return new UrlUriLocator().setEnableWildcards(false);
  }
>>>>>>> df25c6a22fcdd50e8da5dfe4cc2476fc6706ce0f:wro4j-core/src/main/java/ro/isdc/wro/model/resource/locator/DispatcherStreamLocator.java
}

/*
 * Copyright (c) 2008. All rights reserved.
 */
package ro.isdc.wro.model.resource.locator;

import java.io.IOException;
import java.io.InputStream;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.Validate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import ro.isdc.wro.model.resource.locator.ResourceLocator;


/**
 * The purpose of this locator is to dispatch the request to a given context relative location (doesn't have to include
 * the context path).
 * 

 * Initial implementation used a request dispatcher, but since it doesn't behave correctly when the request are issued
 * outside of request cycle (cache reload scheduler), another approach is preferred. The new approach is to compute
 * absolute url of the request it as a separate connection using {@link UrlUriLocator}.
 * 
 * @author Alex Objelean
 */
public class DispatcherStreamLocator {
  private static final Logger LOG = LoggerFactory.getLogger(DispatcherStreamLocator.class);
  /**
   * Used to locate external resources. No wildcard handling is required.
   */
  private ResourceLocator externalUriLocator = newExternalResourceLocator();
  
  /**
   * @param location
   *          a context relative location to retrieve stream for. This 
   * @return a valid stream for required location. This method will never return a null.
   * @throws IOException
   *           if the stream cannot be located at the specified location.
   */
  public InputStream getInputStream(final HttpServletRequest request, final HttpServletResponse response,
    final String location)
    throws IOException {
    Validate.notNull(request);
    Validate.notNull(response);

    final String absolutePath = computeServletContextPath(request) + location;
    LOG.debug("Locating resource: {}", absolutePath);
    return externalUriLocator.locate(absolutePath);
  }

  /**
   * @return the part URL from the protocol name up to the query string and contextPath.
   */
  private String computeServletContextPath(final HttpServletRequest request) {
    return request.getRequestURL().toString().replace(request.getServletPath(), "");
  }
  
  /**
   * @return {@link ResourceLocator} used to retrieve stream for absolute location .
   */
  protected ResourceLocator newExternalResourceLocator() {
    return new UrlResourceLocator().setEnableWildcards(false);
  }
}