package eteg.sinon.executor;
   
   import eteg.sinon.core.Action;
   import eteg.sinon.core.Catalog;
   import eteg.sinon.core.Collector;
   import eteg.sinon.core.CollectorConfiguration;
   import eteg.sinon.core.DataExtraction;
   import eteg.sinon.core.LoopStep;
   import eteg.sinon.core.Page;
  import eteg.sinon.core.PageConfiguration;
  import eteg.sinon.core.Parameter;
  import eteg.sinon.core.ParameterSet;
  import eteg.sinon.core.PositioningStep;
  import eteg.sinon.core.StartPage;
  import eteg.sinon.core.Step;
  import eteg.sinon.exception.EvaluationException;
  import eteg.sinon.exception.SinonException;
  import eteg.sinon.exception.StepAfterLoopLimitPositionException;
  import eteg.sinon.exception.StepException;
  import eteg.sinon.exception.StepWithBeforeException;
  import eteg.sinon.exception.StepWithFailIfFoundException;
  import eteg.sinon.exception.UnknownPageException;
  import eteg.sinon.listener.CatalogStateListener;
  import eteg.sinon.listener.ErrorListener;
  import eteg.sinon.listener.PageStateListener;
  import org.apache.commons.httpclient.Cookie;
  import org.apache.commons.httpclient.HttpClient;
  import org.apache.commons.httpclient.HttpMethod;
  import org.apache.commons.httpclient.URI;
  import org.apache.commons.httpclient.methods.GetMethod;
  import org.apache.commons.httpclient.methods.PostMethod;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.log4j.PropertyConfigurator;
  import org.apache.velocity.VelocityContext;
  import org.apache.velocity.app.VelocityEngine;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.FileReader;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.StringWriter;
  import java.io.UnsupportedEncodingException;
  import java.io.FileOutputStream;
  import java.io.BufferedOutputStream;
  import java.lang.reflect.Method;
  import java.net.MalformedURLException;
  import java.net.URLEncoder;
  import java.net.UnknownHostException;
  import java.text.DecimalFormat;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Properties;
  
  /***
   * Class that executes a {@link eteg.sinon.core.Collector} instance.
   *
   * @author <a href="mailto:thiagohp at users.sourceforge.net">Thiago H. de Paula
   *         Figueiredo </a>
   * @author Last modified by $Author: thiagohp $
   * @version $Revision: 1.7 $
   */
  public class CollectorExecutor {
  
      final private static String HTTP_PREFIX = "http://";
  
      final private static String HTTPS_PREFIX = "https://";
  
      final private static String VELOCITY_PROPERTIES_PATH =
              "/velocity.properties";
  
      final private static String COLLECTOR_PROPERTY = "collector";
  
      final private static PageState BEFORE_DOWNLOAD =
              PageState.BEFORE_DOWNLOAD;
  
      final private static PageState BEFORE_PROCESSING =
              PageState.BEFORE_PROCESSING;
  
      final private static PageState AFTER_PROCESSING =
              PageState.AFTER_PROCESSING;
  
      final private static PageState FINISHED =
              PageState.FINISHED;
  
      final private static String LOG4J_PROPERTIES_FILENAME = "log4j.properties";
  
      final private static String TEMPLATE_SUFFIX = "}";
  
      final private static String TEMPLATE_PREFIX = "${";
  
     /***
      * Suffix used in URLs that point to local files.
      */
     final private static String FILE_PROTOCOL = "file:/";
 
     /***
      * Current directory.
      */
     final private static File CURRENT_DIRECTORY = new File(".");
 
     /***
      * Codificação padrão utilizada para se fazer <i>URL enconding </i> de
      * parâmetros HTTP.
      */
     final private static String DEFAULT_URL_ENCODING = "ISO_8859_1";
 
     /***
      * Sinon log filename.
      */
     final public static String LOG_FILENAME = "sinon.log";
 
     /***
      * Velocity context.
      */
     private VelocityContext context;
 
     /***
      * Velocity engine.
      */
     private VelocityEngine engine;
 
     /***
      * Collector being executed.
      */
     private Collector collector;
 
     /***
      * Think time instance used by this execution.
      */
     private ThinkTime thinkTime;
 
     /***
      * HTTP headers.
      */
     private Properties httpHeaders;
 
     /***
      * List containing the names of all properties set.
      */
     private ArrayList propertyNames;
 
     /***
      * Hash table that maps multivalued properties (lists) to their
      * values list.
      */
     private HashMap multivaluedProperties;
 
     /***
      * Logger.
      */
     private Log log;
 
     /***
      * Catalog instance being executed now.
      */
     private Catalog currentCatalog;
 
     /***
      * Page instance being executed now.
      */
     private Page currentPage;
 
     /***
      * Data extraction instance being executed now.
      */
     private DataExtraction currentDataExtraction;
 
     /***
      * Execution step instance being executed now.
      */
     private Step currentStep;
 
     /***
      * Current action text.
      */
     private String currentText;
 
     /***
      * Current document bytes.
      */
     private byte[] currentBytes;
 
     /***
      * Current position inside the text of the current action.
      */
     private int currentPosition;
 
     /***
      * Position at which the desired information starts.
      */
     private int from;
 
     /***
      * Position at which the desired information ends.
      */
     private int to;
 
     /***
      * Number of downloaded pages..
      */
     private int pagesDownloaded;
 
     /***
      * Number of transferred bytes.
      */
     private int bytesDownloaded;
 
     /***
      * {@link ErrorListener} of the current action.
      */
     private ErrorListener currentErrorListener;
 
     /***
      * {@link PageStateListener} of the current action.
      */
     private PageStateListener currentPageStateListener;
 
     /***
      * <code>org.apache.commons.httpclient.HttpClient</code> instance.
      */
     private HttpClient httpClient;
 
     /***
      * Action queue.
      */
     private ArrayList actionQueue;
 
     /***
      * Current catalog state change listener.
      */
     private CatalogStateListener catalogStateListener;
 
     /***
      * Execution start Unix timestamp.
      */
     private long start;
 
     /***
      * Execution finish Unix timestamp.
      */
     private long finish;
 
     /***
      * Flag used to stop an execution.
      */
     private boolean mustStop = false;
 
     /***
      * Single constructor of this class.
      *
      * @param collector a {@link Collector} instance.
      * @throws IllegalArgumentException  if <code>collector</code> is
      * <code>null</code>.
      */
     public CollectorExecutor(Collector collector) {
 
         if (collector == null) {
 
             throw new IllegalArgumentException(
                     "Parameter collector can't be null");
 
         }
 
         this.collector = collector;
 
         propertyNames = new ArrayList();
         pagesDownloaded = 0;
         bytesDownloaded = 0;
         currentCatalog = null;
         currentPage = null;
         currentDataExtraction = null;
         currentStep = null;
         currentPosition = -1;
         currentText = null;
         actionQueue = new ArrayList();
 
         configureLogger();
 
     }
 
     /***
      * Executes all catalogs of this collector in sequence.
      *
      * @throws SinonException if some error ocurrs.
      */
     public void execute() throws SinonException {
         execute(collector.getCatalogs());
     }
 
     /***
      * Executes a list of catalogs of the coletor.
      *
      * @param catalogs a {@link Catalog} array..
      * @throws SinonException if some unhandled error ocurrs.
      * @todo i18n
      */
     public void execute(Catalog[] catalogs) throws SinonException {
 
         start = System.currentTimeMillis();
         finish = -1;
 
         if (log.isInfoEnabled()) {
             log.info("Starting execution of collector " + collector.getId());
         }
 
         try {
 
             Catalog[] currentCatalogs = collector.getCatalogs();
 
             for (int i = 0; i < catalogs.length; i++) {
 
                 boolean ok = false;
 
                 for (int j = 0; j < currentCatalogs.length; j++) {
 
                     if (catalogs[i] == null) {
 
                         throw new IllegalArgumentException(
                                 "No member of the catalogs vector can be null");
 
                     }
 
                     if (catalogs[i] == currentCatalogs[j]) {
 
                         ok = true;
                         break;
 
                     }
 
                 }
 
                 if (ok == false) {
 
                     throw new SinonException("Catalog "
                             + catalogs[i].getId()
                             + " does not belong to this collector.", this);
 
                 }
 
             }
 
             engine = new VelocityEngine();
             Properties props = new Properties();
 
             try {
 
                 props.load(this.getClass().getResourceAsStream(
                         VELOCITY_PROPERTIES_PATH));
             } catch (RuntimeException e1) {
                 throw new SinonException("velocity.properties não found.");
             }
 
             try {
 
                 engine.init(props);
 
             } catch (Exception e) {
 
                 final String message = "Error during Velocity initialization";
 
                 if (log.isFatalEnabled()) {
                     log.fatal(message, e);
                 }
 
                 throw new SinonException(message, e, this);
 
             }
 
             loadCatalogStateListener();
 
         } catch (Exception e) {
 
             if (log.isFatalEnabled()) {
 
                 log.fatal("Fatal error initializing collector "
                         + collector.getId(), e);
                 return;
 
             }
 
         }
 
         try {
 
             for (int i = 0; i < catalogs.length; i++) {
 
                 setup(catalogs[i]);
 
                 if (catalogStateListener != null) {
                     catalogStateListener.onStateChange(catalogs[i],
                             CatalogState.BEFORE_PROCESSING, this);
 
                 }
 
                 executeCatalog(catalogs[i]);
 
                 if (catalogStateListener != null) {
 
                     catalogStateListener.onStateChange(catalogs[i],
                             CatalogState.AFTER_PROCESSING, this);
 
                 }
 
             }
 
         } catch (SinonException e) {
 
             finish = System.currentTimeMillis();
 
             if (log.isFatalEnabled()) {
 
                 log.fatal("");
                 log.fatal("Execution state: ");
                 log.fatal(getExecutionInfo());
                 log.fatal("");
                 log.fatal("Properties values: ");
                 log.fatal(getPropertyInfo());
                 log.fatal("Fatal error: ", e);
 
             }
 
             throw e;
 
         }
 
         finish = System.currentTimeMillis();
 
         if (log.isInfoEnabled()) {
 
             log.info("Execution finished.");
             log.info("Information:");
             log.info(getExecutionInfo());
 
         }
 
     }
 
     /***
      * Adds all properties of a given <code>catalog</code> to the
      * Velocity context.
      *
      * @param catalog a {@link Catalog} instance.
      */
     private void addCatalogProperties(final Catalog catalog)
             throws SinonException {
 
         Properties properties = catalog.getProperties();
 
         Enumeration keys = properties.keys();
 
         while (keys.hasMoreElements()) {
 
             String name = (String) keys.nextElement();
             String value = properties.getProperty(name);
             setProperty(name, value);
 
         }
 
     }
 
     /***
      * Loads this collector's {@link CatalogStateListener} if it exists.
      *
      * @throws SinonException if some error ocurrs.
      */
     private void loadCatalogStateListener() throws SinonException {
 
         String className = collector.getCatalogStateListenerClassName();
 
         if (className != null) {
 
             Object instance = invokeGetInstanceMethod(className);
 
             try {
 
                 catalogStateListener = (CatalogStateListener) instance;
 
             } catch (ClassCastException e) {
 
                 final String message = "Object returned by static method " +
                         "getInstance() of class" + className
                         + " is not a  CatalogStateListener instance.";
 
                 throw new SinonException(message, e, this);
 
             }
 
         } else {
             catalogStateListener = null;
         }
 
     }
 
     /***
      * Sets up this {@link CollectorExecutor} for the execution of
      * <code>catalog</code>
      *
      * @param catalog a {@link Catalog} instance.
      * @throws SinonException if some error ocurrs.
      * @todo i18n
      */
     private void setup(Catalog catalog) throws SinonException {
 
         if (log.isDebugEnabled()) {
             log.debug("Initializing the context of this execution.");
         }
 
         context = new VelocityContext();
         context.put(COLLECTOR_PROPERTY, this);
 
         httpClient = new HttpClient();
         httpClient.setConnectionTimeout(
                 collector.getConfiguration().getTimeout());
         httpClient.setTimeout(collector.getConfiguration().getTimeout());
 
         context = new VelocityContext();
 
         configureThinkTime();
 
         httpHeaders = collector.getConfiguration().getHttpHeaders();
 
         propertyNames = new ArrayList();
         multivaluedProperties = new HashMap();
 
         addCatalogProperties(catalog);
 
     }
 
     /***
      * Retuns the {@link Collector} to be executed by this executor.
      *
      * @return a {@link Collector} instance.
      */
     public Collector getCollector() {
         return collector;
     }
 
     /***
      * Returns the {@link Catalog} being executed.
      * @return a {@link Catalog} instance.
      */
     public Catalog getCurrentCatalog() {
         return currentCatalog;
     }
 
     /***
      * Returns the {@link Page} being executed.
      * @return a {@link Page} instance.
      */
     public Page getCurrentPage() {
         return currentPage;
     }
 
     /***
      * Returns the {@link DataExtraction} being executed.
      * @return a {@link DataExtraction} instance.
      */
     public DataExtraction getCurrentDataExtraction() {
         return currentDataExtraction;
     }
 
     /***
      * Returns the {@link Step} being executed.
      * @return a {@link Step} instance.
      */
     public Step getCurrentStep() {
         return currentStep;
     }
 
     /***
      * Retorns a <code>String</code> array containing the name of all
      * properties set in this executor.
      *
      * @return a <code>String[]</code>.
      */
     public String[] getPropertyNames() {
 
         String[] propertyArray = new String[propertyNames.size()];
 
         propertyNames.toArray(propertyArray);
 
         return propertyArray;
 
     }
 
     /***
      * Retorns the last downloaded page text.
      *
      * @return a <code>String</code>.
      */
     public String getCurrentText() {
         return currentText;
     }
 
     /***
      * Retorns the last downloaded document as a byte array.
      *
      * @return a <code>byte[]</code>.
      */
     public byte[] getCurrentBytes() {
         return currentBytes;
     }
 
     /***
      * Retorns the current position in the current page.
      *
      * @return an <code>int</code>.
      */
     public int getCurrentPosition() {
         return currentPosition;
     }
 
     /***
      * Returns the number of pages already downloaded.
      *
      * @return an <code>int</code>.
      */
     public int getPagesDownloaded() {
         return pagesDownloaded;
     }
 
     /***
      * Return the number of bytes already downloaded.
      *
      * @return an <code>int</code>.
      */
     public int getBytesDownloaded() {
         return bytesDownloaded;
     }
 
     /***
      * Retorns the moment this executor started in Unix timestamp format.
      * Returns -1 if this executor has not started yet.
      *
      * @return a <code>long</code>.
      */
     public long getStartTime() {
         return start;
     }
 
     /***
      * Retorns the moment this executor finished in Unix timestamp format.
      * Returns -1 if this executor has not finished yet.
      *
      * @return a <code>long</code>.
      */
     public long getFinishTime() {
         return finish;
     }
 
     /***
      * Returns a <code>String</code> containing some execution information.
      *
      * @return a <code>String</code>.
      */
     public String getExecutionInfo() {
 
         StringBuffer buffer = new StringBuffer();
 
         buffer.append("Collector       : " + collector.getId());
         buffer.append("\n");
 
         buffer.append("Catalog         : ");
         if (currentCatalog == null) {
             buffer.append("none");
         } else {
             buffer.append(currentCatalog.getId());
         }
         buffer.append("\n");
 
         buffer.append("Page            : ");
         if (currentPage == null) {
             buffer.append("none");
         } else {
             buffer.append(currentPage.getId());
         }
         buffer.append("\n");
 
         buffer.append("Data extraction : ");
         if (currentDataExtraction == null) {
             buffer.append("none");
         } else {
             buffer.append(currentDataExtraction.getId());
         }
         buffer.append("\n");
 
         buffer.append("Step type       : ");
         if (currentStep == null) {
             buffer.append("none");
         } else {
             buffer.append(currentStep.getClass().getName());
         }
         buffer.append("\n");
 
         buffer.append("Page downloads  : ");
         buffer.append(getPagesDownloaded());
         buffer.append("\n");
 
         buffer.append("Bytes downloaded: ");
         buffer.append(getBytesDownloaded());
         buffer.append("\n");
 
         buffer.append("Start time      : ");
         buffer.append(new Date(getStartTime()));
         buffer.append("\n");
 
         buffer.append("Finish time     : ");
         buffer.append(new Date(getFinishTime()));
         buffer.append("\n");
 
         if (finish == -1) {
             finish = System.currentTimeMillis();
         }
 
         DecimalFormat decimalFormat = new DecimalFormat("0.00");
         String elapsed = decimalFormat.format((finish - start) / 1000.0);
 
         buffer.append("Elapsed time    : ");
         buffer.append(elapsed);
         buffer.append(" seconds");
         buffer.append("\n");
 
         return buffer.toString();
 
     }
 
     /***
      * Retorns a <code>String</code> containing name and value of all properties
      * set.
      *
      * @return a <code>String</code>.
      */
     public String getPropertyInfo() {
 
         StringBuffer buffer = new StringBuffer();
 
         String[] propertyNames = getPropertyNames();
 
         for (int i = 0; i < propertyNames.length; i++) {
 
             buffer.append("\t");
             buffer.append(propertyNames[i]);
             buffer.append(" = ");
 
             final Object propertyValue = getPropertyValue(propertyNames[i]);
 
             if (propertyValue instanceof List) {
                 buffer.append("list : ");
             }
 
             buffer.append(propertyValue);
             buffer.append("\n");
 
         }
 
         return buffer.toString();
 
     }
 
     /***
      * Returns the <i>logger</i> used by this executor.
      *
      * @return a <code>org.apache.commons.logging.Log</code> instance.
      */
     public Log getLog() {
         return log;
     }
 
     /***
      * Returns the value of the property which name is
      * <code>propertyName</code>. If this property is a simple value, a
      * <code>String</code> is returned. Otherwise, a <code>List</code>
      * containing <code>String</code>s is returned.
      *
      * @param propertyName a <code>String</code>.
      * @return the value of <code>propertyName</code>.
      * @throws IllegalArgumentException if <code>propertyName</code> is
      * <code>null</code>.
      */
     final public Object getPropertyValue(String propertyName) {
 
         if (propertyName == null) {
 
             throw new IllegalArgumentException(
                     "Parameter propertyName can't be null.");
 
         }
 
         if (multivaluedProperties.containsKey(propertyName)) {
 
             return context.get(propertyName);
 
         } else {
 
             String value = null;
             final String template =
                     TEMPLATE_PREFIX + propertyName + TEMPLATE_SUFFIX;
 
             try {
                 value = evaluate(template);
             } catch (EvaluationException e) {
 
                 if (log.isErrorEnabled()) {
                     log.error(e);
                 }
 
                 return null;
 
             }
 
             if (template.equals(value)) {
                 return null;
             } else {
                 return value;
             }
 
         }
 
     }
 
     /***
      * Evaluates the Velocity template contained in <code>template</code>.
      *
      * @param template a <code>String</code> contendo um Velocity template.
      */
     private String evaluate(String template) throws EvaluationException {
 
         StringWriter sw = new StringWriter();
 
         try {
 
             engine.evaluate(context, sw, template, template);
 
         } catch (Exception e) {
 
             final String message = "Problems evaluation template : "
                     + template;
 
             if (log.isFatalEnabled()) {
                 log.fatal(message);
             }
 
             throw new EvaluationException(e, this, template);
 
         }
 
         return sw.toString();
 
     }
 
     /***
      * Adds a value to a multivalued property (list). If the property does not
      * exists yet, it is created. To set simple properties, use
      * {@link #setProperty}.
      *
      * @param propertyId a <code>String</code> containing the property name.
      * @param value a <code>String</code> containing the value to be added.
      * @param allowDuplicates a <code>boolean</code> telling if duplicate values
      * can be added or not.
      * @throws SinonException if <code>propertyId</code> is not a multivalued
      * property.
      * @throws IllegalArgumentException if <code>propertyId</code> is
      * <code>null</code> or if <code>value</code> is <code>null</code>.
      * @todo this method cannot be public.
      */
     final public void addValueToProperty(String propertyId, String value,
                                          boolean allowDuplicates)
             throws SinonException {
 
         if (propertyId == null) {
 
             throw new IllegalArgumentException(
                     "Parameter propertyId can't be null");
 
         }
 
         if (value == null) {
 
             throw new IllegalArgumentException(
                     "Parameter value can't be null");
 
         }
 
         if (multivaluedProperties.containsKey(propertyId) == false) {
 
             if (propertyNames.contains(propertyId)) {
 
                 throw new SinonException("Attempt to add a value to a " +
                         "property that is not multivalued : "
                         + propertyId);
 
             }
 
             ArrayList values = new ArrayList();
             values.add(value);
 
             propertyNames.add(propertyId);
             multivaluedProperties.put(propertyId, values);
             context.put(propertyId, values);
 
             if (log.isDebugEnabled()) {
 
                 log.debug("Creating multivalued property " + propertyId
                         + " with value " + value);
 
             }
 
         } else {
 
             if (propertyNames.contains(propertyId) == false) {
                 propertyNames.add(propertyId);
             }
 
             List values = (List) multivaluedProperties.get(propertyId);
 
             if (allowDuplicates == false) {
 
                 if (values.contains(value)) {
 
                     log.debug("Attempt to add value to multivalued property " +
                             "that does not accept duplicate values: "
                             + propertyId + " value: "
                             + value);
 
                     return;
 
                 }
 
             }
 
             values.add(value);
 
             if (log.isDebugEnabled()) {
 
                 log.debug("Added value to property " + propertyId
                         + " : " + value);
 
             }
 
         }
 
     }
 
     /***
      * Sets a property. This method can only be used with simple properties.
      * To add a value to a multivalued property, use
      * {@link #addValueToProperty}.
      *
      * @param propertyId a <code>String</code> containing the property name.
      * @param value a <code>String</code> containing the property value.
      * @throws SinonException if <code>propertyId</code> for o nome de uma propriedade
      *             multivalorada.
      * @throws IllegalArgumentException
      *             se <code>propertyId</code> é <code>null</code> ou se
      *             <code>value</code> é <code>null</code>.
      */
     final public void setProperty(String propertyId, String value)
             throws SinonException {
 
         if (propertyId == null) {
 
             throw new IllegalArgumentException(
                     "Parameter propertyId cannot be null");
 
         }
 
         if (value == null) {
 
             throw new IllegalArgumentException(
                     "Parameter value cannot be null");
 
         }
 
         if (propertyNames.contains(propertyId) == false) {
 
             if (multivaluedProperties.containsKey(propertyId)) {
 
                 throw new SinonException("Attempt to set a value for a "
                         + "multivalued property: " + propertyId);
 
             }
 
             propertyNames.add(propertyId);
 
         }
 
         if (log.isDebugEnabled()) {
 
             log.debug("Setting property : " + propertyId + " = " + value
                     + " (previous value : " + context.get(propertyId) + ")");
 
         }
 
         context.put(propertyId, value);
 
     }
 
     /***
      * Executes a catalog.
      *
      * @param catalog a {@link Catalog} instance.
      * @throws SinonException if some error ocurrs.
      */
     private void executeCatalog(Catalog catalog) throws SinonException {
 
         currentCatalog = catalog;
         StartPage[] startPages = catalog.getStartPages();
         Page page;
 
         if (mustStop == false) {
 
             if (log.isInfoEnabled()) {
 
                 log.info("Starting processing of catalog "
                         + catalog.getId());
 
             }
 
             for (int i = 0; i < startPages.length; i++) {
 
                 page = catalog.getPage(startPages[i].getRefid());
 
                 if (page == null) {
 
                     final UnknownPageException exception =
                             new UnknownPageException(
                                     startPages[i].getRefid(), this);
 
                     throw exception;
 
                 }
 
                 // the Velocity context does not need to be restarted at the
                 // first time, as the method that calls this method already
                 // called setup
                 if (i > 0) {
                     setup(catalog);
                 }
 
                 setProperties(startPages[i].getProperties());
 
                 if (log.isInfoEnabled()) {
 
                     log.info("Starting download and processing of initial " +
                             "action " + page.getId() + " (" + (i + 1)
                             + " out of " + startPages.length + ")");
 
                 }
 
                 actionQueue.clear();
 
                 executePage(page);
 
                 while (actionQueue.isEmpty() == false) {
 
                     // removing the ActionContextPair at the top of the
                     // stack and executing it.
                     final int size = actionQueue.size();
                     ActionContextPair pair =
                             (ActionContextPair) actionQueue.get(size - 1);
 
                     actionQueue.remove(pair);
 
                     final Action action = pair.getAction();
 
                     Page thisPage = catalog.getPage(action.getPageId());
 
                     // note that the context being used in the execution
                     // was changed to the one popped from the top of the
                     // stack.
                     context = pair.getContext();
 
                     executePage(thisPage, action);
 
                 }
 
             }
 
         }
 
         if (log.isInfoEnabled()) {
 
             log.info("Finished execution of catalog " + catalog.getId());
             log.info("Execution information up to now:");
             log.info(getExecutionInfo());
 
         }
 
     }
 
     /***
      * Executes a action. If <code>action</code> is not <code>null</code>,
      * the action download will follow the <code>action</code>.
      * Otherwise, the action download will use the configurations of
      * <code>action</code>.
      *
      * @param page a {@link Page} instance.
      * @param action an {@link Action} instance.
      * @throws SinonException if some error ocurrs.
      */
     private void executePageAndItsActions(Page page, Action action)
             throws SinonException {
 
         executePage(page, action);
 
     }
 
     /***
      * Calls {@link #setProperty} for each property in
      * <code>properties</code>.
      *
      * @param properties a <code>java.util.Properties</code> instance.
      */
     private void setProperties(Properties properties) throws SinonException {
 
         Enumeration keys = properties.keys();
 
         while (keys.hasMoreElements()) {
 
             String key = (String) keys.nextElement();
             String value = properties.getProperty(key);
             setProperty(key, value);
 
         }
 
     }
 
     /***
      * Executes a action. The same as <code>executeCatalog(action, null)</code>.
      *
      * @param page a {@link Page} instance.
      * @throws SinonException if some error ocurrs.
      */
     private void executePage(Page page) throws SinonException {
         executePage(page, null);
     }
 
     /***
      * Executes a pages. If <code>action</code> is not <code>null</code>,
      * the action download will follow the <code>action</code>.
      * Otherwise, the action download will use the configurations of
      * <code>action</code>.
      *
      * @param page a {@link Page} instance.
      * @param page an {@link Action} instance.
      * @throws SinonException if some error ocurrs.
      */
     private void executePage(Page page, Action action) throws SinonException {
 
         // if nobody asked this CollectorExecutor to not execute anymore . . .
         if (mustStop == false) {
 
             currentPage = page;
 
             loadListeners(page);
 
             currentText = download(page, action);
 
             // if there was some problem during the action download, we notify
             // the action listener.
             if (currentText == null) {
 
                 notifyPageListener(FINISHED);
                 return;
 
             }
 
             final String filename =
                     page.getStorageConfiguration().getFilename();
 
             if (filename != null) {
                 writePageToFile(filename);
             }
 
             processPage(page);
 
             notifyPageListener(AFTER_PROCESSING);
 
             Action[] actions = page.getActions();
 
             for (int i = 0; i < actions.length; i++) {
                 executeActionContextPairs(actions[i]);
             }
 
             currentPage = page;
 
             notifyPageListener(FINISHED);
 
         }
 
     }
 
     /***
      * Writes {@link #currentText} to a file named <code>filename</code>.
      * If it already exists, it will be overwritten.
      *
      * @param filename a <code>String</code>.
      */
     private void writePageToFile(final String filename) throws SinonException {
 
         String pathname = evaluate(filename);
         File destination = new File(pathname);
 
         try {
 
             if (destination.isAbsolute() == false) {
                 destination = new File(CURRENT_DIRECTORY, pathname);
             }
 
             BufferedOutputStream outputStream =
                     new BufferedOutputStream(new FileOutputStream(destination));
 
             outputStream.write(currentBytes);
             outputStream.close();
 
         } catch (IOException e) {
 
             throw new SinonException("Error writing page "
                     + currentPage.getId()
                     + " to " + destination.getAbsolutePath(), e, this);
 
         }
 
     }
 
     /***
      * Loads the listeners of a given action.
      */
     private void loadListeners(Page page) throws SinonException {
 
         String className;
         Object instance;
 
         className = page.getErrorListenerClassName();
 
         if (className != null) {
 
             instance = invokeGetInstanceMethod(className);
 
             try {
 
                 currentErrorListener = (ErrorListener) instance;
 
             } catch (ClassCastException e) {
 
                 final String message = "The object returned by the static "
                         + "method getInstance() of class " + className
                         + " is not an ErrorListener instance.";
 
                 throw new SinonException(message, e, this);
 
             }
 
         } else {
             currentErrorListener = null;
         }
 
         className = currentPage.getPageStateListenerClassName();
 
         if (className != null) {
 
             instance = invokeGetInstanceMethod(className);
 
             try {
 
                 currentPageStateListener = (PageStateListener) instance;
 
             } catch (ClassCastException e) {
 
                 final String message = "The object returned by the static "
                         + "method getInstance() of class " + className
                         + " is not an PageStateListener instance.";
 
                 throw new SinonException(message, e, this);
 
             }
 
         } else {
             currentPageStateListener = null;
         }
 
 //		className = currentPage.getPromptListenerClassName();
 //
 //		if (className != null) {
 //
 //			instance = invokeGetInstanceMethod(className);
 //
 //			try {
 //
 //				currentPromptListener = (PromptListener) instance;
 //
 //			} catch (ClassCastException e) {
 //
 //				final String message = "O objeto retornado pelo método "
 //						+ "estático getInstance() da classe " + className
 //						+ " não é uma instância de PromptListener.";
 //
 //				throw new SinonException(message, e, this);
 //
 //			}
 //
 //		} else {
 //			currentPromptListener = null;
 //		}
 
     }
 
     /***
      * Invokes static method <code>getInstance</code> of the class whose
      * fully qualified name is <code>className</code>.
      *
      * @param className a <code>String</code>.
      * @return the object returned by static method <code>getInstance</code>
      * of the class whose fully qualified name is <code>className</code>.
      * @throws SinonException if some error ocurrs.
      */
     private Object invokeGetInstanceMethod(String className)
             throws SinonException {
 
         Object instance;
         Class someClass = null;
 
         try {
 
             someClass = Class.forName(className);
 
         } catch (ClassNotFoundException e) {
 
             final String message = "Class " + className
                     + " was not found.";
 
             throw new SinonException(message, e, this);
 
         }
 
         try {
 
             Method method = someClass.getMethod("getInstance", null);
             instance = method.invoke(null, null);
 
         } catch (Exception e) {
 
             final String message = "Could not create a " + className +
                     "instance. Check if it has a public static getInstance() " +
                     "method that returns one instance of this class.";
 
             throw new SinonException(message, e, this);
 
         }
 
         return instance;
 
     }
 
     /***
      * Notifies the current action {@link PageStateListener} that its
      * state changed to <code>newPageState</code>.
      *
      * @param newPageState a {@link PageState} instance.
      */
     private void notifyPageListener(PageState newPageState) {
 
         if (currentPageStateListener != null) {
 
             currentPageStateListener.onStateChange(currentPage, newPageState,
                     catalogStateListener, this);
 
         }
 
     }
 
     /***
      * Processes a action.
      *
      * @param page a {@link Page} instance.
      */
     private void processPage(Page page) throws SinonException {
 
         Step[] steps = page.getSteps();
         currentPosition = 0;
         from = -1;
         to = -1;
 
         for (int i = 0; i < steps.length; i++) {
 
             Step step = steps[i];
 
             try {
 
                 executeStep(step, Integer.MAX_VALUE);
 
             } catch (SinonException e) {
 
                 ErrorResponse response = notifyErrorListener(e);
 
                 if (response.isResumeNext()) {
                     continue;
                 } else if (response.isRetry()) {
                     executeStep(step, Integer.MAX_VALUE);
                 } else if (response.isStop()) {
                     throw e;
                 }
 
             }
 
         }
 
     }
 
     /***
      * Executes an extraction step (action, data extraction, loop, jump,
      * from or to).
      *
      * @param step a {@link Step} instance.
      * @param limitPosition a <code>int</code> containing a position that
      * this step cannot go further.
      * @throws StepException if some error ocurrs.
      */
     private void executeStep(Step step, int limitPosition)
             throws SinonException {
 
         currentStep = step;
 
         if (step.isPositioningStep()) {
 
             PositioningStep positioningStep = (PositioningStep) step;
             executePositioningStep(positioningStep, limitPosition);
 
         } else if (step.isDataExtraction()) {
 
             DataExtraction dataExtraction = (DataExtraction) step;
             executeDataExtraction(dataExtraction, limitPosition);
 
         } else if (step.isAction()) {
 
             log.fatal("This could not happen!!!");
             System.exit(1);
 
         } else if (step.isLoop()) {
 
             LoopStep loopStep = (LoopStep) step;
             executeLoop(loopStep, limitPosition);
 
         } else {
 
             throw new StepException("Unknown step type: " + step + " : "
                     + step.getClass(), this);
 
         }
 
     }
 
     /***
      * Executes a loop.
      *
      * @param loop a {@link LoopStep} instance.
      * @param limitPosition a <code>int</code> containing a position that
      * this step cannot go further.
      * @throws StepException if some error ocurrs.
      */
     private void executeLoop(LoopStep loop, int limitPosition)
             throws SinonException {
 
         int iterations = 0;
         int loopReferencePosition = getLoopReferencePosition(loop);
 
         if (limitPosition < loopReferencePosition) {
             loopReferencePosition = limitPosition;
         }
 
         while (evaluateLoopCondition(loop, loopReferencePosition)) {
 
             Step[] steps = loop.getSteps();
             int oldCurrentPosition = currentPosition;
 
             try {
 
                 for (int i = 0; i < steps.length; i++) {
 
                     if (oldCurrentPosition > currentPosition) {
                         break;
                     }
 
                     oldCurrentPosition = currentPosition;
                     executeStep(steps[i], loopReferencePosition);
 
                     if (oldCurrentPosition > currentPosition) {
                         break;
                     }
 
                 }
 
 // expected failure . . .
             } catch (StepAfterLoopLimitPositionException afterLimitPosition) {
 
                 if (log.isDebugEnabled()) {
                     log.debug("Iterations executed : " + iterations);
                 }
 
                 return;
 
             } catch (StepWithBeforeException beforeException) {
                 throw beforeException;
             } catch (SinonException sinonException) {
 
                 if (loop.getCondition().equals("notFails")) {
 
                     currentPosition = oldCurrentPosition;
 
                     if (log.isDebugEnabled()) {
 
                         log.debug("Expected failure in loop in action "
                                 + "identificador " + currentPage.getId());
 
                         if (currentStep.isPositioningStep()) {
 
                             PositioningStep positioningStep =
                                     (PositioningStep) currentStep;
 
                             log.debug("Reference : "
                                     + positioningStep.getReference());
 
                         }
 
                         log.debug("Iterations executed : " + iterations);
 
                     }
 
                     return;
 
                 } else {
                     throw sinonException;
                 }
 
             }
 
             iterations++;
 
             if (evaluateLoopCondition(loop, loopReferencePosition) == false) {
                 return;
             }
 
         }
 
     }
 
     /***
      * Retruns the reference position of the current loop.
      *
      * @param loop a {@link LoopStep} instance.
      * @throws StepException if some error ocurrs.
      */
     private int getLoopReferencePosition(LoopStep loop) throws SinonException {
 
         int loopReferencePosition;
 
         if (loop.getCondition().equals("before")) {
 
             loopReferencePosition = currentText.indexOf(
                     loop.getValue(), currentPosition);
 
             if (loopReferencePosition < 0) {
 
                 throw new SinonException("Loop reference not found : "
                         + loop.getValue());
 
             }
 
         } else {
             loopReferencePosition = Integer.MAX_VALUE;
         }
 
         return loopReferencePosition;
 
     }
 
     /***
      * Returns <code>true</code> if this loop must continue, <code>false</code>
      * otherwise.
      *
      * @param loop a {@link LoopStep} instance.
      * @return <code>true</code> if this loop must continue, <code>false</code>
      * otherwise.
      * @throws StepException if some error ocurrs.
      */
     private boolean evaluateLoopCondition(LoopStep loop,
                                           int loopReferencePosition) throws SinonException {
 
         if (loop.getCondition().equals("notFails")) {
 
             return (true);
 
         } else if (loop.getCondition().equals("before")) {
 
             return (currentPosition < loopReferencePosition);
 
         } else {
 
             throw new SinonException("Unknown loop stop condition : "
                     + loop.getCondition());
 
         }
 
     }
 
     /***
      * Enqueues one or more {@link ActionContextPair} to execute
      * this <code>action</code>.
      *
      * @param action an {@link Action} instance.
      * @throws SinonException if some error ocurrs.
      */
     private void executeActionContextPairs(Action action)
             throws SinonException {
 
         String condition = action.getCondition();
 
         // if we have a condition in this action . . .
         if (condition != null) {
 
             final boolean mustExecute = evaluateActionCondition(condition,
                     action.getPropertyId());
 
             if (mustExecute == false) {
                 return;
             }
 
         }
 
         Page page = currentCatalog.getPage(action.getPageId());
 
         if (page == null) {
 
             if (log.isFatalEnabled()) {
 
                 final String message = "Page " + action.getPageId()
                         + ", referenced in a " + currentPage.getId() +
                         " action, was not found.";
 
                 log.fatal(message);
 
                 throw new UnknownPageException(action.getPageId(), this);
 
             }
 
         }
 
         String foreach = action.getForeach();
 
         // if this action has a loop . . .
         if (foreach != null) {
 
             String index = action.getIndex();
             String variable = action.getVariable();
             List values = (List) getPropertyValue(foreach);
 
             if (values == null) {
 
                 throw new SinonException("Property " + foreach
                         + " does not exists or no value was added to it.");
 
             }
 
             final int size = values.size();
 
             // we are enqueuing actions to be executed, se we must
             // do this in reverse order in order to have them executed
             // in the right order.
             for (int i = size - 1; i >= 0; i--) {
 
                 String value = (String) values.get(i);
 
                 if (index != null) {
                     setProperty(index, String.valueOf(i + 1));
                 }
 
                 if (variable != null) {
                     setProperty(variable, value);
                 }
 
                 enqueueAction(action);
 
             }
 
         } else {
 
             page = currentCatalog.getPage(action.getPageId());
 
             if (page == null) {
 
                 if (log.isFatalEnabled()) {
 
                     final String message = "Page " + action.getPageId()
                             + ", referenced by a "
                             + currentPage.getId() + " action, was not found.";
 
                     log.fatal(message);
 
                     throw new UnknownPageException(action.getPageId(), this);
 
                 }
 
             }
 
             enqueueAction(action);
 
         }
 
     }
 
     /***
      * Enqueues an action.
      *
      * @param action an {@link Action} instance.
      */
     private void enqueueAction(Action action) {
 
         if (action == null) {
 
             throw new IllegalArgumentException(
                     "Parameter action can't be null");
 
         }
 
         final VelocityContext contextClone = (VelocityContext) context.clone();
 
         actionQueue.add(new ActionContextPair(action, contextClone));
 
     }
 
     /***
      * Evaluates if a given {@link Action} condition is true or not.
      *
      * @param condition a <code>String</code> containing the name of the
      * condition.
      * @param propertyId a <code>String</code> containing the name of
      * the variable used to evaluate the condition.
      * @return <code>true</code> if the condition is true,
      *         <code>false</code> otherwise.
      * @throws IllegalArgumentException if <code>propertyId</code> is
      * <code>null</code>.
      * @throws SinonException if some error ocurrs.
      */
     private boolean evaluateActionCondition(String condition, String propertyId)
             throws SinonException {
 
         String value = (String) getPropertyValue(propertyId);
 
         if (value == null) {
             throw new SinonException("The property " + propertyId + " does " +
                     "not exists.");
         }
 
         if (condition.equals("notEmpty")) {
 
             if (value.trim().length() == 0) {
                 return false;
             } else {
                 return true;
             }
 
         } else {
 
             throw new IllegalArgumentException("The condition " + condition
                     + " is not valid.");
 
         }
 
     }
 
     /***
      * Executes a data extraction. The action current position is changed.
      *
      * @param dataExtraction a {@link PositioningStep} instance.
      * @param limitPosition a <code>int</code> containing a position that
      * this step cannot go further.
      * @throws StepException if some error ocurrs.
      */
     private void executeDataExtraction(DataExtraction dataExtraction,
                                        int limitPosition)
             throws SinonException {
 
         currentDataExtraction = dataExtraction;
 
         if (dataExtraction.isResetPositionNeeded()) {
             currentPosition = 0;
         }
 
         Step[] steps = dataExtraction.getSteps();
         int oldCurrentPosition = currentPosition;
 
         try {
 
             for (int i = 0; i < steps.length; i++) {
                 executeStep(steps[i], limitPosition);
             }
 
         } catch (StepAfterLoopLimitPositionException e) {
 
             throw e;
 
         } catch (StepException e) {
 
             if (dataExtraction.isFailOnError()) {
                 throw e;
             } else {
 
                 currentPosition = oldCurrentPosition;
 
                 if (log.isDebugEnabled()) {
 
                     if (e instanceof StepWithFailIfFoundException
                             || e instanceof StepWithBeforeException) {
 
                         log.debug(e.getClass() + " : " + e.getMessage());
 
                     } else {
 
                         log.debug("Data extraction " + dataExtraction.getId()
                                 + " had an expected failure, so everything " +
                                 "OK.");
 
                     }
 
                     if (currentStep.isPositioningStep()) {
 
                         PositioningStep positioningStep = (PositioningStep) currentStep;
 
                         log.debug("Reference : "
                                 + positioningStep.getReference());
 
                     }
 
                 }
 
                 if (dataExtraction.isMultivalued()) {
                     addValueToProperty(dataExtraction.getId(),
                             dataExtraction.getValueOnError(), true);
                 } else {
                     setProperty(dataExtraction.getId(),
                             dataExtraction.getValueOnError());
                 }
 
                 return;
 
             }
 
         }
 
         String value = extractFromToData(dataExtraction);
 
         if (dataExtraction.isTrimValueNeeded()) {
             value = value.trim();
         }
 
         if (dataExtraction.isMultivalued() == false) {
             setProperty(dataExtraction.getId(), value);
         } else {
 
             addValueToProperty(dataExtraction.getId(), value,
                     dataExtraction.isAllowDuplicates());
 
         }
 
     }
 
     /***
      * Extracts a piece of data after <code>from</code> and <code>to</code>
      * steps were already done. The extracted string is returned.
      *
      * @param dataExtraction the {@link DataExtraction} being executed.
      * @throws SinonException if the <code>from</code> step was not
      * executed succesfully of if the <code>to</code> step was not
      * executed succesfully of if the <code>from</code> position is
      * higher than the <code>to</code> one.
      */
     private String extractFromToData(DataExtraction dataExtraction)
             throws SinonException {
 
         if (from < 0) {
 
             throw new SinonException("Initial position (from) of data " +
                     " extraction " + dataExtraction.getId()
                     + " was not found or was not set in action "
                     + currentPage.getId());
 
         }
 
         if (to < 0) {
 
             throw new SinonException("End position (to) of data " +
                     " extraction " + dataExtraction.getId()
                     + " was not found or was not set in action "
                     + currentPage.getId());
 
         }
 
         if (from > to) {
 
             throw new SinonException("Initial position (from) of data "
                     + "extraction " + dataExtraction.getId() + " is higher "
                     + "than the end positioin (to) in action " +
                     currentPage.getId());
 
         }
 
         String value = currentText.substring(from, to);
         return value;
 
     }
 
     /***
      * Executes a positioning step. The current position is changed.
      *
      * @param step a {@link PositioningStep} instance.
      * @param limitPosition a <code>int</code> containing a position that
      * this step cannot go further.
      * @throws StepException if the positioning step's reference was not found.
      */
     private void executePositioningStep(PositioningStep step, int limitPosition)
             throws StepException {
 
         currentStep = step;
 
         int oldCurrentPosition = currentPosition;
 
         final String originalReference = step.getReference();
         String reference = null;
 
         try {
             reference = evaluate(originalReference);
         } catch (EvaluationException e) {
 
             throw new StepException("Could not evaluate reference "
                     + originalReference + " : " + e.getClass() + " : "
                     + e.getMessage(), this);
 
         }
 
         int beforePosition = Integer.MAX_VALUE;
 
         String before = step.getBefore();
 
         if (before != null) {
 
             beforePosition = currentText.indexOf(before, currentPosition);
 
             if (beforePosition == -1) {
 
                 throw new StepWithBeforeException(
                         "Failure executing positioning step: the reference " +
                         "string " + before + ", used as maximum position, " +
                         "was not found.", this);
 
             }
 
         }
 
         if (step.getDirection() == PositioningStep.FORWARD) {
 
             currentPosition = currentText.indexOf(reference, currentPosition);
 
         } else {
 
             currentPosition = currentText.lastIndexOf(reference,
                     currentPosition);
 
         }
 
         if (step.isFailIfFound()) {
 
             if (currentPosition >= 0) {
 
                 throw new StepWithFailIfFoundException("Reference string "
                         + originalReference + " (" + reference
                         + "), that means an expected failure, was found" +
                         "and everything is OK.", this);
 
             } else {
 
                 currentPosition = oldCurrentPosition;
                 return;
 
             }
 
         }
 
         if (currentPosition > limitPosition) {
 
             throw new StepAfterLoopLimitPositionException("The positioning " +
                     "step with reference " + originalReference +
                     " (" + reference + ") went further the loop limit.", this);
 
         }
 
         if (currentPosition == -1) {
 
             currentPosition = oldCurrentPosition;
 
             throw new StepException("Failure during execution of positioning " +
                     "step: the reference string " + originalReference +
                     " (" + reference + ") "
                     + " was not found.", this);
 
         }
 
         if (currentPosition >= beforePosition) {
 
             throw new StepException("Failure during execution of positioning " +
                     "step: the reference string " + originalReference +
                     " (" + reference + ") "
                     + " was found after string " + before, this);
 
         }
 
         if (step.isFrom() || step.isJump()) {
             currentPosition += reference.length();
         }
 
         if (step.isFrom()) {
             from = currentPosition;
         }
 
         if (step.isTo()) {
             to = currentPosition;
         }
 
     }
 
     /***
      * Downloads a action and returns it in a <code>String</code>.
      * The configurations contained in <code>actioni</code>, if it is not
      * <code>null</code>, are used instead of the configurations contained in
      * <code>action</code>.
      *
      * @param page a {@link Page} instance.
      * @param action an {@link Action} instance.
      * @return a <code>String</code>.
      * @throws SinonException if some unhandled error ocurrs.
      *             se algum erro não tratado ocorrer.
      */
     private String download(Page page, Action action) throws SinonException {
 
         HttpMethod method;
         String url = null;
         PageConfiguration configuration = null;
         currentText = null;
         currentBytes = null;
 
         if (action != null) {
 
             url = action.getUrl();
 
             if (url != null) {
 
                 configuration = action.getConfiguration();
 
             } else {
 
                 url = page.getUrl();
                 configuration = page.getConfiguration();
 
             }
 
         } else {
 
             url = page.getUrl();
             configuration = page.getConfiguration();
 
         }
 
         url = url.trim();
 
         if (url == null || url.length() == 0) {
 
             throw new SinonException("No URL was given to action "
                     + page.getId() + " in catalog " + currentCatalog.getId());
 
         }
 
         url = evaluate(url);
 
         if (url.startsWith(FILE_PROTOCOL)) {
 
             String filename = url.substring(
                     FILE_PROTOCOL.length(), url.length());
 
             currentText = readFile(filename);
 
             return currentText;
 
         } else if (url.startsWith(HTTP_PREFIX) == false
                 && url.startsWith(HTTPS_PREFIX) == false) {
 
             throw new SinonException(
                     "Toda URL must begin with " + HTTP_PREFIX + ", " +
                     HTTPS_PREFIX + ", or " + FILE_PROTOCOL +
                     "(action: " + page + ", url : " + url + ")");
 
         }
 
         method = createHttpMethod(page, url, configuration);
 
         final boolean followRedirects = page.getFollowRedirects();
 
         setHttpHeaders(method);
 
         if (log.isDebugEnabled()) {
             logDebuggingMessages(page, url, method);
         }
 
         notifyPageListener(BEFORE_DOWNLOAD);
 
         int response = -1;
         int retries = collector.getConfiguration().getRetries();
         Exception exception = null;
         GetMethod redirMethod = null;
         String exceptionMessage = null;
         boolean ok = false;
 
         for (int i = 0; i < retries + 1; i++) {
 
             if (log.isDebugEnabled() && i > 0) {
 
                 log.debug("");
                 log.debug("Attempt " + i + " of " + retries);
 
             }
 
             // se esta não é a primeira vez que baixamos alguma coisa,
             // temos que observar o think time.
             if (pagesDownloaded > 0) {
                 waitForThinkTime();
             }
 
             long start = System.currentTimeMillis();
             long end;
 
             try {
 
                 response = httpClient.executeMethod(method);
                 boolean wasRedirected = false;
 
                 if (followRedirects && response >= 300 && response < 400) {
 
                     URI location = new URI(method.getURI(),
                             method.getResponseHeader("location").getValue());
 
                     if (log.isDebugEnabled()) {
                         log.debug("Redirecting to " + location.getURI());
                     }
 
                     redirMethod = new GetMethod(location.getURI());
                     response = httpClient.executeMethod(redirMethod);
                     wasRedirected = true;
 
                 }
 
                 if (wasRedirected) {
                     currentBytes = redirMethod.getResponseBody();
                 } else {
                     currentBytes = method.getResponseBody();
                 }
 
                 currentText = new String(currentBytes);
 
                 if (response == 200 && currentText == null) {
 
                     if (log.isDebugEnabled()) {
                         log.debug("Connection timeout expired.");
                     }
 
                     method.releaseConnection();
 
                     if (redirMethod != null) {
                         redirMethod.releaseConnection();
                     }
 
                     method = createHttpMethod(page, url, configuration);
 
                     continue;
 
                 }
 
             } catch (MalformedURLException e) {
 
                 exception = e;
                 exceptionMessage = "Invalid URL : " + url;
 
                 if (log.isDebugEnabled()) {
 
                     log.debug("HTTP response : " + response);
                     log.debug(exceptionMessage);
 
                 }
 
             } catch (UnknownHostException e) {
 
                 exception = e;
                 exceptionMessage = "URL not found : " + url;
 
                 if (log.isDebugEnabled()) {
 
                     log.debug("HTTP response : " + response);
                     log.debug(exceptionMessage);
 
                 }
 
                 method = recreateMethodObject(method, redirMethod, page, url,
                         configuration);
 
                 continue;
 
             } catch (IOException e) {
 
                 exceptionMessage = "Problems transferring action "
                         + page.getId() + " : " + e.getClass() + " : "
                         + e.getMessage();
 
                 if (log.isDebugEnabled()) {
 
                     log.debug("HTTP response : " + response);
                     log.debug(exceptionMessage);
 
                 }
 
                 exception = e;
 
                 method = recreateMethodObject(method, redirMethod, page, url,
                         configuration);
 
                 continue;
 
             }
 
             ok = true;
 
             end = System.currentTimeMillis();
 
             if (log.isDebugEnabled()) {
                 log.debug("Download elapsed time : " + (end - start) + " ms.");
             }
 
             break;
 
         }
 
         if (log.isDebugEnabled()) {
             log.debug("HTTP response : " + response);
         }
 
         if (response == -1 || response >= 400
                 || (followRedirects && response >= 300) || ok == false) {
 
             if (exceptionMessage == null && response == -1) {
                 exceptionMessage = "Connection timeout expired";
             } else {
                 exceptionMessage = "HTTP response : " + response;
             }
 
             final SinonException sinonException = new SinonException(
                     "Page " + page.getId()
                     + " could not be downloaded : "
                     + exceptionMessage, exception, this);
 
             ErrorResponse errorResponse = notifyErrorListener(sinonException);
 
             if (errorResponse.isStop()) {
                 throw sinonException;
             } else if (errorResponse.isResumeNext()) {
 
                 currentText = null;
                 return null;
 
             } else if (errorResponse.isRetry()) {
                 return download(page, action);
             }
 
         }
 
         if (currentText == null) {
 
             final String message = "Page " + page.getId()
                     + " could not be downloaded within timeout.";
 
             if (log.isErrorEnabled()) {
                 log.error(message);
             }
 
             throw new SinonException(message);
 
         }
 
         notifyPageListener(BEFORE_PROCESSING);
 
         bytesDownloaded += currentText.length();
         pagesDownloaded++;
 
         return currentText;
 
     }
 
     /***
      * Recreates a <code>Method</code> object.
      *
      * @param method
      * @param redirMethod
      * @param page
      * @param url
      * @param configuration
      * @return
      * @throws SinonException
      */
     private HttpMethod recreateMethodObject(HttpMethod method,
                                             GetMethod redirMethod,
                                             Page page,
                                             String url,
                                             PageConfiguration configuration)
             throws SinonException {
 
         method.releaseConnection();
 
         if (redirMethod != null) {
             redirMethod.releaseConnection();
         }
 
         method = createHttpMethod(page, url, configuration);
         return method;
 
     }
 
     /***
      * Halts the collector execution to simulate a think time.
      */
     private void waitForThinkTime() {
 
         try {
 
             final long millis = thinkTime.nextThinkTime();
             Thread.sleep(millis);
 
             if (log.isDebugEnabled()) {
                 log.debug("Think time interval: " + millis + " ms.");
             }
 
         } catch (InterruptedException e) {
 
             if (log.isWarnEnabled()) {
                 log.warn(e.getClass() + " : " + e.getMessage());
             }
 
         }
 
     }
 
     /***
      * Creates a <code>Method</code> instance to download a action.
      *
      * @param page a {@link Page} instance.
      * @param url a <code>String</code>.
      * @param configuration a {@link PageConfiguration} instance.
      * @return a <code>HttpMethod</code> instance.
      * @throws SinonException if some error ocurrs.
      */
     private HttpMethod createHttpMethod(Page page,
                                         String url,
                                         PageConfiguration configuration)
             throws SinonException {
 
         HttpMethod method;
         ParameterSet parameterSet;
 
         try {
 
             if (page.getMethod() == Page.POST_METHOD) {
                 method = new PostMethod(url);
             } else {
                 method = new GetMethod(url);
             }
 
         } catch (IllegalArgumentException e) {
             throw new SinonException("Invalid URL : " + url, e, this);
         }
 
         if (configuration != null) {
             parameterSet = configuration.getParameterSet();
         } else {
             parameterSet = null;
         }
 
         //NameValuePair[] parameters;
 
         if (parameterSet != null && parameterSet.getParameters().size() > 0) {
 
             String queryString = getQueryString(parameterSet);
 
             // parameters = getNameValuePairArray(parameterSet);
 
             if (page.getMethod() == Page.POST_METHOD) {
 
                 PostMethod postMethod = (PostMethod) method;
                 // postMethod.setRequestBody(parameters);
                 postMethod.setRequestBody(queryString);
 
             } else {
                 // method.setQueryString(parameters);
                 method.setQueryString(queryString);
             }
 
         }
 
         return method;
 
     }
 
     /***
      * Returns a query string representing <code>parameterSet</code>.
      *
      * @param parameterSet a {@link ParameterSet} instance.
      * @return a <code>String</code>.
      * @throws SinonException if some error ocurrs.
      */
     private String getQueryString(ParameterSet parameterSet)
             throws SinonException {
 
         StringBuffer buffer = new StringBuffer();
         Map parameters = parameterSet.getParameters();
         Iterator iterator = parameters.keySet().iterator();
 
         while (iterator.hasNext()) {
 
             String name = (String) iterator.next();
             Parameter parameter = (Parameter) parameters.get(name);
             String value = evaluate(parameter.getValue());
             String encoding = parameter.getEncoding();
 
             try {
 
                 buffer.append(URLEncoder.encode(name, encoding));
                 buffer.append("=");
                 buffer.append(URLEncoder.encode(value, encoding));
                 buffer.append("&");
 
             } catch (UnsupportedEncodingException e) {
 
                 throw new SinonException("Unsupported character set : "
                         + encoding, e, this);
 
             }
 
         }
 
         // deletes the last &, as it is not useful.
         buffer.deleteCharAt(buffer.length() - 1);
 
         return buffer.toString();
 
     }
 
     /***
      * Logs some debug messages about the {@link Page} about to be downloaded.
      *
      * @param page a {@link Page} instance.
      * @param url a <code>String</code>.
      * @param method a <code>HttpMethod</code> instance.
      */
     private void logDebuggingMessages(Page page,
                                       String url,
                                       HttpMethod method) {
 
         log.debug("");
         log.debug("Starting download of action " + page.getId());
         log.debug("URL : " + url);
 
         if (page.getMethod() == Page.POST_METHOD) {
 
             PostMethod postMethod = (PostMethod) method;
 
             try {
 
                 log.debug("Query string: "
                         + postMethod.getRequestBodyAsString());
 
             } catch (Exception e) {
                 log.debug(e);
             }
 
             log.debug("Using POST method to send parameters.");
 
         } else {
 
             log.debug("Query string: " + method.getQueryString());
             log.debug("Using GET method to send parameters.");
 
         }
 
         Cookie[] cookies = httpClient.getState().getCookies();
 
         if (cookies.length > 0) {
 
             log.debug("Cookies:");
 
             for (int i = 0; i < cookies.length; i++) {
 
                 log.debug("\t" + cookies[i].getName() + " : "
                         + cookies[i].getValue());
 
             }
 
         }
 
     }
 
     /***
      * Notifies the current action's {@link ErrorListener}, if it has one,
      * that some exception ocurred and asks what to do.
      *
      * @param exception a {@link SinonException} instance.
      * @return a {@link ErrorResponse} instance..
      */
     private ErrorResponse notifyErrorListener(SinonException exception) {
 
         if (currentErrorListener != null) {
             return currentErrorListener.onError(exception);
         } else {
             return ErrorResponse.STOP;
         }
 
     }
 
     /***
      * Reads a text file and returns int in a <code>String</code>.
      *
      * @param filename a <code>String</code> containing the file name.
      * @return uma <code>String</code> containing the file contents.
      * @throws SinonException if some error ocurrs.
      */
     final private String readFile(String filename) throws SinonException {
 
         StringBuffer buffer = null;
 
         try {
 
             FileReader fileReader = new FileReader(filename);
             BufferedReader reader = new BufferedReader(fileReader);
 
             buffer = new StringBuffer();
 
             String line = reader.readLine();
 
             while (line != null) {
 
                 buffer.append(line);
                 line = reader.readLine();
 
             }
 
         } catch (FileNotFoundException e) {
 
             throw new SinonException("File not found : " + filename, e, this);
 
         } catch (IOException e) {
 
             throw new SinonException("Error reading file " + filename,
                     e, this);
 
         }
 
         return buffer.toString();
 
     }
 
     /***
      * Configures the logger object and deletes the current directory's
      * <code>sinon.log</code> file if it already exists.
      */
     private void configureLogger() {
 
         File file = new File(LOG_FILENAME);
 
         if (file.exists()) {
             file.delete();
         }
 
         Properties props = new Properties();
 
         InputStream is = this.getClass().getResourceAsStream(
                 "/" + LOG4J_PROPERTIES_FILENAME);
 
         try {
             props.load(is);
             PropertyConfigurator.configure(props);
             log = LogFactory.getLog(CollectorExecutor.class);
             log.info("Loaded log4j properties");
         } catch (RuntimeException e1) {
             System.out.println("log4J.properties not found. " +
                     "The logger will use default settings.");
             e1.printStackTrace();
         } catch (IOException e2) {
             System.out.println("Error loading log4j.properties");
             e2.printStackTrace();
         }
 
 
     }
 
     /***
      * Configures the think time.
      */
     private void configureThinkTime() throws SinonException {
 
         final CollectorConfiguration configuration =
                 collector.getConfiguration();
 
         String className = configuration.getThinkTimeImplementationClassName();
 
         Class thinkTimeClass = null;
 
         try {
 
             thinkTimeClass = Class.forName(className);
 
         } catch (ClassNotFoundException e) {
 
             final String message = "Class " + className
                     + ", eteg.sinon.executor.ThinkTime implementation, "
                     + "was not found.";
 
             throw new SinonException(message, e, this);
 
         }
 
         try {
 
             thinkTime = (ThinkTime) thinkTimeClass.newInstance();
 
         } catch (InstantiationException e) {
 
             final String message = "Could not create instance of class " +
                     className + ". Check if it is concrete and if it has "
                     + "a public constructor with no parameters.";
 
             throw new SinonException(message, e, this);
 
         } catch (IllegalAccessException e) {
 
             final String message = "Could not create instance of class " +
                     className + ". Check if it is concrete and if it has "
                     + "a public constructor with no parameters.";
 
             throw new SinonException(message, e, this);
 
         }
 
         thinkTime.setConfiguration(configuration.getThinkTimeProperties());
 
     }
 
     /***
      * Sets the HTTP headers of <code>method</code> according to the
      * collector's configuration.
      *
      * @param method a <code>HttpMethod</code> instance.
      */
     private void setHttpHeaders(HttpMethod method) {
 
         Enumeration keys = httpHeaders.keys();
 
         while (keys.hasMoreElements()) {
 
             String name = (String) keys.nextElement();
             String value = httpHeaders.getProperty(name);
             method.setRequestHeader(name, value);
 
         }
 
     }
 
     /***
      * Stops the execution of this collector.
      */
     public void stop() {
 
         if (log != null && log.isInfoEnabled()) {
             log.info("Stopping collector execution.");
         }
 
         this.mustStop = true;
 
     }
 
     /***
      * Returns <code>true</code> if the execution of this collector
      * was stopped and <code>false</code> otherwise.
      * @return <code>true</code> if the execution of this collector
      * was stopped and <code>false</code> otherwise.
      */
     public boolean isStopped() {
         return this.mustStop;
     }
 
     /***
      * Prints the content of <code>someContext</code>
      * to a String and returns it.
      *
      * @param someContext a <code>VelocityContext</code>.
      */
     private static String printContext(VelocityContext someContext) {
 
         if (someContext == null) {
 
             throw new IllegalArgumentException(
                     "Parameter someContext can't be null");
 
         }
 
         StringBuffer buffer = new StringBuffer();
 
         Object[] keys = someContext.getKeys();
         final int length = keys.length;
 
         for (int i = 0; i < length; i++) {
 
             final Object key = keys[i];
             buffer.append(key.toString().trim());
             buffer.append("=");
             buffer.append(someContext.get((String) key).toString().trim());
             buffer.append("");
 
             if (i < length - 1) {
                 buffer.append(", ");
             }
 
         }
 
         return buffer.toString();
 
     }
 
     /***
      * (Action, Velocity context) pair.
      */
     private final static class ActionContextPair {
 
         /***
          * Action to be executed.
          */
         private Action action;
 
         /***
          * Context under which the action will be executed.
          */
         private VelocityContext context;
 
         /***
          * Single constructor.
          *
          * @param action an {@link Action} instance.
          * @param context a {@link VelocityContext} instance.
          */
         public ActionContextPair(Action action, VelocityContext context) {
 
             if (action == null) {
 
                 throw new IllegalArgumentException(
                         "Parameter action can't be null");
 
             }
 
             if (context == null) {
 
                 throw new IllegalArgumentException(
                         "Parameter context can't be null");
 
             }
 
             this.action = action;
             this.context = context;
 
         }
 
         /***
          * Returns the context.
          *
          * @return a {@link VelocityContext} instance.
          */
         public VelocityContext getContext() {
             return context;
         }
 
         /***
          * Returns the action.
          *
          * @return an {@link Action} instance.
          */
         public Action getAction() {
             return action;
         }
 
         /***
          * Returns the action pageId and the contents of the context.
          *
          * @return a <code>String</code>.
          */
         public String toString() {
 
             StringBuffer buffer = new StringBuffer();
 
             buffer.append("Stack: page ");
             buffer.append(action.getPageId());
             buffer.append(", context ");
             buffer.append(printContext(context));
             buffer.append("");
 
             return buffer.toString();
 
         }
 
     }
 
 }