Subversion Repositories SmartDukaan

/******************************************************************************* 

 *  Copyright 2009 Amazon Services.

 *  Licensed under the Apache License, Version 2.0 (the "License"); 

 *  

 *  You may not use this file except in compliance with the License. 

 *  You may obtain a copy of the License at: http://aws.amazon.com/apache2.0

 *  This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 

 *  CONDITIONS OF ANY KIND, either express or implied. See the License for the 

 *  specific language governing permissions and limitations under the License.

 * ***************************************************************************** 

 *

 *  Marketplace Web Service Java Library

 *  API Version: 2009-01-01

 *  Generated: Tue Feb 17 13:31:26 PST 2009 

 * 

 */

package com.amazonaws.mws;

import java.lang.reflect.Method;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.Reader;

import java.io.StringReader;

import java.io.UnsupportedEncodingException;

import java.net.MalformedURLException;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URL;

import java.net.URLEncoder;

import java.security.DigestInputStream;

import java.security.DigestOutputStream;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.security.SignatureException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.TimeZone;

import java.util.TreeMap;

import java.util.Map.Entry;

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Future;

import java.util.concurrent.RejectedExecutionHandler;

import java.util.concurrent.ThreadFactory;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import javax.crypto.Mac;

import javax.crypto.spec.SecretKeySpec;

import javax.xml.bind.JAXBContext;

import javax.xml.bind.JAXBException;

import javax.xml.bind.Unmarshaller;

import javax.xml.transform.stream.StreamSource;

import org.apache.commons.codec.binary.Base64;

import org.apache.http.Header;

import org.apache.http.message.BasicHeader;

import org.apache.http.HttpStatus;

import org.apache.http.auth.AuthScope;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.params.BasicHttpParams;

import org.apache.http.client.entity.UrlEncodedFormEntity;

import org.apache.http.entity.InputStreamEntity;

import org.apache.http.protocol.HTTP;

import org.apache.http.NameValuePair;

import org.apache.http.HttpResponse;

import org.apache.http.message.BasicNameValuePair;

import org.apache.http.auth.UsernamePasswordCredentials;

import org.apache.http.impl.client.DefaultHttpClient;

import org.apache.http.params.CoreProtocolPNames;

import org.apache.http.params.HttpConnectionParams;

import org.apache.http.HttpHost;

import org.apache.http.conn.params.ConnRoutePNames;

import org.apache.http.impl.conn.PoolingClientConnectionManager;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.http.client.HttpClient;

import org.apache.http.client.CredentialsProvider;

import org.apache.http.impl.client.BasicCredentialsProvider;

import org.apache.http.protocol.HttpContext;

import org.apache.http.protocol.BasicHttpContext;

import org.apache.http.client.protocol.ClientContext;

import com.amazonaws.mws.model.CancelFeedSubmissionsRequest;

import com.amazonaws.mws.model.CancelFeedSubmissionsResponse;

import com.amazonaws.mws.model.CancelReportRequestsRequest;

import com.amazonaws.mws.model.CancelReportRequestsResponse;

import com.amazonaws.mws.model.ErrorResponse;

import com.amazonaws.mws.model.GetFeedSubmissionCountRequest;

import com.amazonaws.mws.model.GetFeedSubmissionCountResponse;

import com.amazonaws.mws.model.GetFeedSubmissionListByNextTokenRequest;

import com.amazonaws.mws.model.GetFeedSubmissionListByNextTokenResponse;

import com.amazonaws.mws.model.GetFeedSubmissionListRequest;

import com.amazonaws.mws.model.GetFeedSubmissionListResponse;

import com.amazonaws.mws.model.GetFeedSubmissionResultRequest;

import com.amazonaws.mws.model.GetFeedSubmissionResultResponse;

import com.amazonaws.mws.model.GetFeedSubmissionResultResult;

import com.amazonaws.mws.model.GetReportCountRequest;

import com.amazonaws.mws.model.GetReportCountResponse;

import com.amazonaws.mws.model.GetReportListByNextTokenRequest;

import com.amazonaws.mws.model.GetReportListByNextTokenResponse;

import com.amazonaws.mws.model.GetReportListRequest;

import com.amazonaws.mws.model.GetReportListResponse;

import com.amazonaws.mws.model.GetReportRequest;

import com.amazonaws.mws.model.GetReportRequestCountRequest;

import com.amazonaws.mws.model.GetReportRequestCountResponse;

import com.amazonaws.mws.model.GetReportRequestListByNextTokenRequest;

import com.amazonaws.mws.model.GetReportRequestListByNextTokenResponse;

import com.amazonaws.mws.model.GetReportRequestListRequest;

import com.amazonaws.mws.model.GetReportRequestListResponse;

import com.amazonaws.mws.model.GetReportResponse;

import com.amazonaws.mws.model.GetReportResult;

import com.amazonaws.mws.model.GetReportScheduleCountRequest;

import com.amazonaws.mws.model.GetReportScheduleCountResponse;

import com.amazonaws.mws.model.GetReportScheduleListByNextTokenRequest;

import com.amazonaws.mws.model.GetReportScheduleListByNextTokenResponse;

import com.amazonaws.mws.model.GetReportScheduleListRequest;

import com.amazonaws.mws.model.GetReportScheduleListResponse;

import com.amazonaws.mws.model.IdList;

import com.amazonaws.mws.model.ManageReportScheduleRequest;

import com.amazonaws.mws.model.ManageReportScheduleResponse;

import com.amazonaws.mws.model.RequestReportRequest;

import com.amazonaws.mws.model.RequestReportResponse;

import com.amazonaws.mws.model.ResponseMetadata;

import com.amazonaws.mws.model.ResponseHeaderMetadata;

import com.amazonaws.mws.model.StatusList;

import com.amazonaws.mws.model.SubmitFeedRequest;

import com.amazonaws.mws.model.SubmitFeedResponse;

import com.amazonaws.mws.model.TypeList;

import com.amazonaws.mws.model.UpdateReportAcknowledgementsRequest;

import com.amazonaws.mws.model.UpdateReportAcknowledgementsResponse;

/**

 * The Amazon Marketplace Web Service contain APIs for inventory and order management.

 * 

 *

 *

 * MarketplaceWebServiceClient is implementation of MarketplaceWebService based on the

 * Apache <a href="http://jakarta.apache.org/commons/httpclient/">HttpClient</a>.

 *

 */

public  class MarketplaceWebServiceClient implements MarketplaceWebService {

    private final Log log = LogFactory.getLog(MarketplaceWebServiceClient.class);

    private String awsAccessKeyId = null;

    private String awsSecretAccessKey = null;

    private MarketplaceWebServiceConfig config = null;

    private HttpClient httpClient = null;

    private CredentialsProvider credentialsProvider = new BasicCredentialsProvider();

    private HttpContext httpContext= null;

    private ExecutorService asyncExecutor;

    private List<Header> defaultHeaders = new ArrayList<Header>();

    private static JAXBContext  jaxbContext;

    private static ThreadLocal<Unmarshaller> unmarshaller;

    private static Pattern ERROR_PATTERN_ONE = Pattern.compile(".*\\<RequestId>(.*)\\</RequestId>.*\\<Error>" +

            "\\<Code>(.*)\\</Code>\\<Message>(.*)\\</Message>\\</Error>.*(\\<Error>)?.*",

            Pattern.MULTILINE | Pattern.DOTALL);

    private static Pattern ERROR_PATTERN_TWO = Pattern.compile(".*\\<Error>\\<Code>(.*)\\</Code>\\<Message>(.*)" +

            "\\</Message>\\</Error>.*(\\<Error>)?.*\\<RequestID>(.*)\\</RequestID>.*",

            Pattern.MULTILINE | Pattern.DOTALL);

    private static String DEFAULT_ENCODING = "UTF-8";

    /** Initialize JAXBContext and  Unmarshaller **/

    static {

        try {

            jaxbContext = JAXBContext.newInstance("com.amazonaws.mws.model", MarketplaceWebService.class.getClassLoader());

        } catch (JAXBException ex) {

            throw new ExceptionInInitializerError(ex);

        }

        unmarshaller = new ThreadLocal<Unmarshaller>() {

            @Override

            protected synchronized Unmarshaller initialValue() {

                try {

                    return jaxbContext.createUnmarshaller();

                } catch(JAXBException e) {

                    throw new ExceptionInInitializerError(e);

                }

            }

        };

    }

    /**

     * Constructs MarketplaceWebServiceClient with AWS Access Key ID and AWS Secret Key

     *

     * @param awsAccessKeyId

     *          AWS Access Key ID

     * @param awsSecretAccessKey

     *          AWS Secret Access Key

     */

    public  MarketplaceWebServiceClient(

        	String awsAccessKeyId,

    		String awsSecretAccessKey,

    		String applicationName,

    		String applicationVersion) {

        this(	awsAccessKeyId, awsSecretAccessKey, 

        		applicationName, applicationVersion,

        		new MarketplaceWebServiceConfig());

    }

    /**

     * Constructs MarketplaceWebServiceClient with AWS Access Key ID, AWS Secret Key

     * and max number of threads to spawn for async operations

     *

     * @param awsAccessKeyId

     *          AWS Access Key ID

     * @param awsSecretAccessKey

     *          AWS Secret Access Key

     * @param maxAsyncThreads

     *          Max number of threads to spawn for async operation.

     */

    public MarketplaceWebServiceClient(

    		String awsAccessKeyId, 

    		String awsSecretAccessKey,

    		String applicationName,

    		String applicationVersion, 

    		int maxAsyncThreads) {

        this(	awsAccessKeyId, awsSecretAccessKey, 

        		applicationName, applicationVersion,

        		new MarketplaceWebServiceConfig().withMaxAsyncThreads(maxAsyncThreads));

    }

    /**

     * Constructs MarketplaceWebServiceClient with AWS Access Key ID, AWS Secret Key

     * and MarketplaceWebServiceConfig. Use MarketplaceWebServiceConfig to pass additional

     * configuration that affects how service is being called.

     *

     * @param awsAccessKeyId

     *          AWS Access Key ID

     * @param awsSecretAccessKey

     *          AWS Secret Access Key

     * @param config

     *          Additional configuration options

     */

    @SuppressWarnings("serial")

	public  MarketplaceWebServiceClient(

    		String awsAccessKeyId,

    		String awsSecretAccessKey,

    		String applicationName,

    		String applicationVersion,

            MarketplaceWebServiceConfig config) {

        this.awsAccessKeyId = awsAccessKeyId;

        this.awsSecretAccessKey = awsSecretAccessKey;

        this.config = config;

        this.httpClient = configureHttpClient(applicationName, applicationVersion);

        this.asyncExecutor = new ThreadPoolExecutor(config.getMaxAsyncThreads(),

                config.getMaxAsyncThreads(), 60L, TimeUnit.SECONDS,

                new ArrayBlockingQueue<Runnable>(config.getMaxAsyncQueueSize()) {

                    @Override

                    public boolean offer(Runnable task) {

                        log.debug("Maximum number of concurrent threads reached, queuing task...");

                        return super.offer(task);

                    }

                },

                new ThreadFactory() {

                    private final AtomicInteger threadNumber = new AtomicInteger(1);

                    public Thread newThread(Runnable task) {

                        Thread thread = new Thread(task, "MarketplaceWebServiceClient-Thread-" +

                                threadNumber.getAndIncrement());

                        thread.setDaemon(true);

                        if (thread.getPriority() != Thread.NORM_PRIORITY) {

                            thread.setPriority(Thread.NORM_PRIORITY);

                        }

                        log.debug("ThreadFactory created new thread: " + thread.getName());

                        return thread;

                    }

                },

                new RejectedExecutionHandler() {

                    public void rejectedExecution(Runnable task, ThreadPoolExecutor executor) {

                        log.debug("Maximum number of concurrent threads reached, and queue is full. " +

                                "Running task in the calling thread..." + Thread.currentThread().getName());

                        if (!executor.isShutdown()) {

                            task.run();

                        }

                    }

                });

    }

    // Public API ------------------------------------------------------------//

    /**

     * Get Report 

     *

     * The GetReport operation returns the contents of a report. Reports can potentially be

     * very large (>100MB) which is why we only return one report at a time, and in a

     * streaming fashion.

     * 

     * @param request

     *          GetReportRequest request

     * @return

     *          GetReport Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetReportResponse getReport(GetReportRequest request) throws MarketplaceWebServiceException {

        return invoke(GetReportResponse.class, convertGetReport(request), request);

    }

    /**

     * Non-blocking Get Report 

     * <p/>

     * Returns <code>future</code> pointer to GetReportResponse

     * <p/>

     * If response is ready, call to <code>future.get()</code> 

     * will return GetReportResponse. 

     * <p/>

     * If response is not ready, call to <code>future.get()</code> will block the 

     * calling thread until response is returned. 

     * <p/>

     * Note, <code>future.get()</code> will throw wrapped runtime exception. 

     * <p/>

     * If service error has occured, MarketplaceWebServiceException can be extracted with

     * <code>exception.getCause()</code>

     * <p/>

     * Usage example for parallel processing:

     * <pre>

     *

     *  List<Future<GetReportResponse>> responses = new ArrayList<Future<GetReportResponse>>();

     *  for (GetReportRequest request : requests) {

     *      responses.add(client.getReportAsync(request));

     *  }

     *  for (Future<GetReportResponse> future : responses) {

     *      while (!future.isDone()) {

     *          Thread.yield();

     *      }

     *      try {

     *          GetReportResponse response = future.get();

     *      // use response

     *      } catch (Exception e) {

     *          if (e instanceof MarketplaceWebServiceException) {

     *              MarketplaceWebServiceException exception = MarketplaceWebServiceException.class.cast(e);

     *          // handle MarketplaceWebServiceException

     *          } else {

     *          // handle other exceptions

     *          }

     *      }

     *  }

     * </pre>

     *

     * @param request

     *          GetReportRequest request

     * @return Future<GetReportResponse> future pointer to GetReportResponse

     * 

     */

    public Future<GetReportResponse> getReportAsync(final GetReportRequest request) {

        Future<GetReportResponse> response = asyncExecutor.submit(new Callable<GetReportResponse>() {

            public GetReportResponse call() throws MarketplaceWebServiceException {

                return getReport(request);

            }

            });

        return response;

    }

    /**

     * Get Report Schedule Count 

     *

     * returns the number of report schedules

     * 

     * @param request

     *          GetReportScheduleCountRequest request

     * @return

     *          GetReportScheduleCount Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetReportScheduleCountResponse getReportScheduleCount(GetReportScheduleCountRequest request) throws MarketplaceWebServiceException {

        return invoke(GetReportScheduleCountResponse.class, convertGetReportScheduleCount(request));

    }

    /**

     * Non-blocking Get Report Schedule Count 

     * <p/>

     * Returns <code>future</code> pointer to GetReportScheduleCountResponse

     * <p/>

     * If response is ready, call to <code>future.get()</code> 

     * will return GetReportScheduleCountResponse. 

     * <p/>

     * If response is not ready, call to <code>future.get()</code> will block the 

     * calling thread until response is returned. 

     * <p/>

     * Note, <code>future.get()</code> will throw wrapped runtime exception. 

     * <p/>

     * If service error has occured, MarketplaceWebServiceException can be extracted with

     * <code>exception.getCause()</code>

     * <p/>

     * Usage example for parallel processing:

     * <pre>

     *

     *  List<Future<GetReportScheduleCountResponse>> responses = new ArrayList<Future<GetReportScheduleCountResponse>>();

     *  for (GetReportScheduleCountRequest request : requests) {

     *      responses.add(client.getReportScheduleCountAsync(request));

     *  }

     *  for (Future<GetReportScheduleCountResponse> future : responses) {

     *      while (!future.isDone()) {

     *          Thread.yield();

     *      }

     *      try {

     *          GetReportScheduleCountResponse response = future.get();

     *      // use response

     *      } catch (Exception e) {

     *          if (e instanceof MarketplaceWebServiceException) {

     *              MarketplaceWebServiceException exception = MarketplaceWebServiceException.class.cast(e);

     *          // handle MarketplaceWebServiceException

     *          } else {

     *          // handle other exceptions

     *          }

     *      }

     *  }

     * </pre>

     *

     * @param request

     *          GetReportScheduleCountRequest request

     * @return Future<GetReportScheduleCountResponse> future pointer to GetReportScheduleCountResponse

     * 

     */

    public Future<GetReportScheduleCountResponse> getReportScheduleCountAsync(final GetReportScheduleCountRequest request) {

        Future<GetReportScheduleCountResponse> response = asyncExecutor.submit(new Callable<GetReportScheduleCountResponse>() {

            public GetReportScheduleCountResponse call() throws MarketplaceWebServiceException {

                return getReportScheduleCount(request);

            }

            });

        return response;

    }

    /**

     * Get Report Request List By Next Token 

     *

     * retrieve the next batch of list items and if there are more items to retrieve

     * 

     * @param request

     *          GetReportRequestListByNextTokenRequest request

     * @return

     *          GetReportRequestListByNextToken Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetReportRequestListByNextTokenResponse getReportRequestListByNextToken(GetReportRequestListByNextTokenRequest request) throws MarketplaceWebServiceException {

        return invoke(GetReportRequestListByNextTokenResponse.class, convertGetReportRequestListByNextToken(request));

    }

    /**

     * Non-blocking Get Report Request List By Next Token 

     * <p/>

     * Returns <code>future</code> pointer to GetReportRequestListByNextTokenResponse

     * <p/>

     * If response is ready, call to <code>future.get()</code> 

     * will return GetReportRequestListByNextTokenResponse. 

     * <p/>

     * If response is not ready, call to <code>future.get()</code> will block the 

     * calling thread until response is returned. 

     * <p/>

     * Note, <code>future.get()</code> will throw wrapped runtime exception. 

     * <p/>

     * If service error has occured, MarketplaceWebServiceException can be extracted with

     * <code>exception.getCause()</code>

     * <p/>

     * Usage example for parallel processing:

     * <pre>

     *

     *  List<Future<GetReportRequestListByNextTokenResponse>> responses = new ArrayList<Future<GetReportRequestListByNextTokenResponse>>();

     *  for (GetReportRequestListByNextTokenRequest request : requests) {

     *      responses.add(client.getReportRequestListByNextTokenAsync(request));

     *  }

     *  for (Future<GetReportRequestListByNextTokenResponse> future : responses) {

     *      while (!future.isDone()) {

     *          Thread.yield();

     *      }

     *      try {

     *          GetReportRequestListByNextTokenResponse response = future.get();

     *      // use response

     *      } catch (Exception e) {

     *          if (e instanceof MarketplaceWebServiceException) {

     *              MarketplaceWebServiceException exception = MarketplaceWebServiceException.class.cast(e);

     *          // handle MarketplaceWebServiceException

     *          } else {

     *          // handle other exceptions

     *          }

     *      }

     *  }

     * </pre>

     *

     * @param request

     *          GetReportRequestListByNextTokenRequest request

     * @return Future<GetReportRequestListByNextTokenResponse> future pointer to GetReportRequestListByNextTokenResponse

     * 

     */

    public Future<GetReportRequestListByNextTokenResponse> getReportRequestListByNextTokenAsync(final GetReportRequestListByNextTokenRequest request) {

        Future<GetReportRequestListByNextTokenResponse> response = asyncExecutor.submit(new Callable<GetReportRequestListByNextTokenResponse>() {

            public GetReportRequestListByNextTokenResponse call() throws MarketplaceWebServiceException {

                return getReportRequestListByNextToken(request);

            }

            });

        return response;

    }

    /**

     * Update Report Acknowledgements 

     *

     * The UpdateReportAcknowledgements operation updates the acknowledged status of one or more reports.

     * 

     * @param request

     *          UpdateReportAcknowledgementsRequest request

     * @return

     *          UpdateReportAcknowledgements Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public UpdateReportAcknowledgementsResponse updateReportAcknowledgements(UpdateReportAcknowledgementsRequest request) throws MarketplaceWebServiceException {

        return invoke(UpdateReportAcknowledgementsResponse.class, convertUpdateReportAcknowledgements(request));

    }

    /**

     * Non-blocking Update Report Acknowledgements 

     * <p/>

     * Returns <code>future</code> pointer to UpdateReportAcknowledgementsResponse

     * <p/>

     * If response is ready, call to <code>future.get()</code> 

     * will return UpdateReportAcknowledgementsResponse. 

     * <p/>

     * If response is not ready, call to <code>future.get()</code> will block the 

     * calling thread until response is returned. 

     * <p/>

     * Note, <code>future.get()</code> will throw wrapped runtime exception. 

     * <p/>

     * If service error has occured, MarketplaceWebServiceException can be extracted with

     * <code>exception.getCause()</code>

     * <p/>

     * Usage example for parallel processing:

     * <pre>

     *

     *  List<Future<UpdateReportAcknowledgementsResponse>> responses = new ArrayList<Future<UpdateReportAcknowledgementsResponse>>();

     *  for (UpdateReportAcknowledgementsRequest request : requests) {

     *      responses.add(client.updateReportAcknowledgementsAsync(request));

     *  }

     *  for (Future<UpdateReportAcknowledgementsResponse> future : responses) {

     *      while (!future.isDone()) {

     *          Thread.yield();

     *      }

     *      try {

     *          UpdateReportAcknowledgementsResponse response = future.get();

     *      // use response

     *      } catch (Exception e) {

     *          if (e instanceof MarketplaceWebServiceException) {

     *              MarketplaceWebServiceException exception = MarketplaceWebServiceException.class.cast(e);

     *          // handle MarketplaceWebServiceException

     *          } else {

     *          // handle other exceptions

     *          }

     *      }

     *  }

     * </pre>

     *

     * @param request

     *          UpdateReportAcknowledgementsRequest request

     * @return Future<UpdateReportAcknowledgementsResponse> future pointer to UpdateReportAcknowledgementsResponse

     * 

     */

    public Future<UpdateReportAcknowledgementsResponse> updateReportAcknowledgementsAsync(final UpdateReportAcknowledgementsRequest request) {

        Future<UpdateReportAcknowledgementsResponse> response = asyncExecutor.submit(new Callable<UpdateReportAcknowledgementsResponse>() {

            public UpdateReportAcknowledgementsResponse call() throws MarketplaceWebServiceException {

                return updateReportAcknowledgements(request);

            }

            });

        return response;

    }

    /**

     * Submit Feed 

     *

     * Uploads a file for processing together with the necessary

     * metadata to process the file, such as which type of feed it is.

     * PurgeAndReplace if true means that your existing e.g. inventory is

     * wiped out and replace with the contents of this feed - use with

     * caution (the default is false).

     * 

     * @param request

     *          SubmitFeedRequest request

     * @return

     *          SubmitFeed Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public SubmitFeedResponse submitFeed(SubmitFeedRequest request) throws MarketplaceWebServiceException {

        return invoke(SubmitFeedResponse.class, convertSubmitFeed(request), request);

    }

    /**

     * Non-blocking Submit Feed 

     * <p/>

     * Returns <code>future</code> pointer to SubmitFeedResponse

     * <p/>

     * If response is ready, call to <code>future.get()</code> 

     * will return SubmitFeedResponse. 

     * <p/>

     * If response is not ready, call to <code>future.get()</code> will block the 

     * calling thread until response is returned. 

     * <p/>

     * Note, <code>future.get()</code> will throw wrapped runtime exception. 

     * <p/>

     * If service error has occured, MarketplaceWebServiceException can be extracted with

     * <code>exception.getCause()</code>

     * <p/>

     * Usage example for parallel processing:

     * <pre>

     *

     *  List<Future<SubmitFeedResponse>> responses = new ArrayList<Future<SubmitFeedResponse>>();

     *  for (SubmitFeedRequest request : requests) {

     *      responses.add(client.submitFeedAsync(request));

     *  }

     *  for (Future<SubmitFeedResponse> future : responses) {

     *      while (!future.isDone()) {

     *          Thread.yield();

     *      }

     *      try {

     *          SubmitFeedResponse response = future.get();

     *      // use response

     *      } catch (Exception e) {

     *          if (e instanceof MarketplaceWebServiceException) {

     *              MarketplaceWebServiceException exception = MarketplaceWebServiceException.class.cast(e);

     *          // handle MarketplaceWebServiceException

     *          } else {

     *          // handle other exceptions

     *          }

     *      }

     *  }

     * </pre>

     *

     * @param request

     *          SubmitFeedRequest request

     * @return Future<SubmitFeedResponse> future pointer to SubmitFeedResponse

     * 

     */

    public Future<SubmitFeedResponse> submitFeedAsync(final SubmitFeedRequest request) {

        Future<SubmitFeedResponse> response = asyncExecutor.submit(new Callable<SubmitFeedResponse>() {

            public SubmitFeedResponse call() throws MarketplaceWebServiceException {

                return submitFeed(request);

            }

            });

        return response;

    }

    /**

     * Submit Feed From File

     *

     * Uploads a file from disk for processing together with the necessary

     * metadata to process the file, such as which type of feed it is.

     * PurgeAndReplace if true means that your existing e.g. inventory is

     * wiped out and replace with the contents of this feed - use with

     * caution (the default is false).

     * 

     * This function assumes the Content MD5 value is unset in the request, and will

     * set it before making the Submit Feed request. The Feed Content must be stored

     * on disk, as the assumption is that the content is accessed through

     * a FileInputStream.

     * 

     * @param request

     *          SubmitFeedRequest request without the contentMd5 field set.

     * @return

     *          SubmitFeed Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public SubmitFeedResponse submitFeedFromFile( SubmitFeedRequest request )

      throws MarketplaceWebServiceException {

        try {

            String contentMd5 = computeContentMD5HeaderValue( (FileInputStream)request.getFeedContent() );

            request.setContentMD5( contentMd5 );

        }

        catch( Throwable t ) {

            throw new MarketplaceWebServiceException( t );

        }

        return submitFeed( request );

    }

    /**

     * Non-blocking Submit Feed From File 

     * <p/>

     * Returns <code>future</code> pointer to SubmitFeedResponse

     * <p/>

     * If response is ready, call to <code>future.get()</code> 

     * will return SubmitFeedResponse. 

     * <p/>

     * If response is not ready, call to <code>future.get()</code> will block the 

     * calling thread until response is returned. 

     * <p/>

     * Note, <code>future.get()</code> will throw wrapped runtime exception. 

     * <p/>

     * If service error has occured, MarketplaceWebServiceException can be extracted with

     * <code>exception.getCause()</code>

     * <p/>

     * Usage example for parallel processing:

     * <pre>

     *

     *  List<Future<SubmitFeedResponse>> responses = new ArrayList<Future<SubmitFeedResponse>>();

     *  for (SubmitFeedRequest request : requests) {

     *      responses.add(client.submitFeedFromFileAsync(request));

     *  }

     *  for (Future<SubmitFeedResponse> future : responses) {

     *      while (!future.isDone()) {

     *          Thread.yield();

     *      }

     *      try {

     *          SubmitFeedResponse response = future.get();

     *      // use response

     *      } catch (Exception e) {

     *          if (e instanceof MarketplaceWebServiceException) {

     *              MarketplaceWebServiceException exception = MarketplaceWebServiceException.class.cast(e);

     *          // handle MarketplaceWebServiceException

     *          } else {

     *          // handle other exceptions

     *          }

     *      }

     *  }

     * </pre>

     *

     * @param request

     *          SubmitFeedRequest request

     * @return Future<SubmitFeedResponse> future pointer to SubmitFeedResponse

     * 

     */

    public Future<SubmitFeedResponse> submitFeedFromFileAsync(final SubmitFeedRequest request) {

        Future<SubmitFeedResponse> response = asyncExecutor.submit(new Callable<SubmitFeedResponse>() {

            public SubmitFeedResponse call() throws MarketplaceWebServiceException { 

                return submitFeedFromFile( request );

            }

            });

        return response;

    }

    /**

     * Get Report Count 

     *

     * returns a count of reports matching your criteria;

     * by default, the number of reports generated in the last 90 days,

     * regardless of acknowledgment status

     * 

     * @param request

     *          GetReportCountRequest request

     * @return

     *          GetReportCount Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetReportCountResponse getReportCount(GetReportCountRequest request) throws MarketplaceWebServiceException {

        return invoke(GetReportCountResponse.class, convertGetReportCount(request));

    }

    /**

     * Non-blocking Get Report Count 

     * <p/>

     * Returns <code>future</code> pointer to GetReportCountResponse

     * <p/>

     * If response is ready, call to <code>future.get()</code> 

     * will return GetReportCountResponse. 

     * <p/>

     * If response is not ready, call to <code>future.get()</code> will block the 

     * calling thread until response is returned. 

     * <p/>

     * Note, <code>future.get()</code> will throw wrapped runtime exception. 

     * <p/>

     * If service error has occured, MarketplaceWebServiceException can be extracted with

     * <code>exception.getCause()</code>

     * <p/>

     * Usage example for parallel processing:

     * <pre>

     *

     *  List<Future<GetReportCountResponse>> responses = new ArrayList<Future<GetReportCountResponse>>();

     *  for (GetReportCountRequest request : requests) {

     *      responses.add(client.getReportCountAsync(request));

     *  }

     *  for (Future<GetReportCountResponse> future : responses) {

     *      while (!future.isDone()) {

     *          Thread.yield();

     *      }

     *      try {

     *          GetReportCountResponse response = future.get();

     *      // use response

     *      } catch (Exception e) {

     *          if (e instanceof MarketplaceWebServiceException) {

     *              MarketplaceWebServiceException exception = MarketplaceWebServiceException.class.cast(e);

     *          // handle MarketplaceWebServiceException

     *          } else {

     *          // handle other exceptions

     *          }

     *      }

     *  }

     * </pre>

     *

     * @param request

     *          GetReportCountRequest request

     * @return Future<GetReportCountResponse> future pointer to GetReportCountResponse

     * 

     */

    public Future<GetReportCountResponse> getReportCountAsync(final GetReportCountRequest request) {

        Future<GetReportCountResponse> response = asyncExecutor.submit(new Callable<GetReportCountResponse>() {

            public GetReportCountResponse call() throws MarketplaceWebServiceException {

                return getReportCount(request);

            }

            });

        return response;

    }

    /**

     * Get Feed Submission List By Next Token 

     *

     * retrieve the next batch of list items and if there are more items to retrieve

     * 

     * @param request

     *          GetFeedSubmissionListByNextTokenRequest request

     * @return

     *          GetFeedSubmissionListByNextToken Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public GetFeedSubmissionListByNextTokenResponse getFeedSubmissionListByNextToken(GetFeedSubmissionListByNextTokenRequest request) throws MarketplaceWebServiceException {

        return invoke(GetFeedSubmissionListByNextTokenResponse.class, convertGetFeedSubmissionListByNextToken(request));

    }

    /**

     * Non-blocking Get Feed Submission List By Next Token 

     * <p/>

     * Returns <code>future</code> pointer to GetFeedSubmissionListByNextTokenResponse

     * <p/>

     * If response is ready, call to <code>future.get()</code> 

     * will return GetFeedSubmissionListByNextTokenResponse. 

     * <p/>

     * If response is not ready, call to <code>future.get()</code> will block the 

     * calling thread until response is returned. 

     * <p/>

     * Note, <code>future.get()</code> will throw wrapped runtime exception. 

     * <p/>

     * If service error has occured, MarketplaceWebServiceException can be extracted with

     * <code>exception.getCause()</code>

     * <p/>

     * Usage example for parallel processing:

     * <pre>

     *

     *  List<Future<GetFeedSubmissionListByNextTokenResponse>> responses = new ArrayList<Future<GetFeedSubmissionListByNextTokenResponse>>();

     *  for (GetFeedSubmissionListByNextTokenRequest request : requests) {

     *      responses.add(client.getFeedSubmissionListByNextTokenAsync(request));

     *  }

     *  for (Future<GetFeedSubmissionListByNextTokenResponse> future : responses) {

     *      while (!future.isDone()) {

     *          Thread.yield();

     *      }

     *      try {

     *          GetFeedSubmissionListByNextTokenResponse response = future.get();

     *      // use response

     *      } catch (Exception e) {

     *          if (e instanceof MarketplaceWebServiceException) {

     *              MarketplaceWebServiceException exception = MarketplaceWebServiceException.class.cast(e);

     *          // handle MarketplaceWebServiceException

     *          } else {

     *          // handle other exceptions

     *          }

     *      }

     *  }

     * </pre>

     *

     * @param request

     *          GetFeedSubmissionListByNextTokenRequest request

     * @return Future<GetFeedSubmissionListByNextTokenResponse> future pointer to GetFeedSubmissionListByNextTokenResponse

     * 

     */

    public Future<GetFeedSubmissionListByNextTokenResponse> getFeedSubmissionListByNextTokenAsync(final GetFeedSubmissionListByNextTokenRequest request) {

        Future<GetFeedSubmissionListByNextTokenResponse> response = asyncExecutor.submit(new Callable<GetFeedSubmissionListByNextTokenResponse>() {

            public GetFeedSubmissionListByNextTokenResponse call() throws MarketplaceWebServiceException {

                return getFeedSubmissionListByNextToken(request);

            }

            });

        return response;

    }

    /**

     * Cancel Feed Submissions 

     *

     * cancels feed submissions - by default all of the submissions of the

     * last 30 days that have not started processing

     * 

     * @param request

     *          CancelFeedSubmissionsRequest request

     * @return

     *          CancelFeedSubmissions Response from the service

     *

     * @throws MarketplaceWebServiceException

     */

    public CancelFeedSubmissionsResponse cancelFeedSubmissions(CancelFeedSubmissionsRequest request) throws MarketplaceWebServiceException {

        return invoke(CancelFeedSubmissionsResponse.class, convertCancelFeedSubmissions(request));

    }

    /**

     * Non-blocking Cancel Feed Submissions 

     * <p/>

     * Returns <code>future</code> pointer to CancelFeedSubmissionsResponse

     * <p/>

     * If response is ready, call to <code>future.get()</code> 

     * will return CancelFeedSubmissionsResponse. 

     * <p/>

     * If response is not ready, call to <code>future.get()</code> will block the 

     * calling thread until response is returned. 

     * <p/>

     * Note, <code>future.get()</code> will throw wrapped runtime exception. 

     * <p/>

     * If service error has occured, MarketplaceWebServiceException can be extracted with

     * <code>exception.getCause()</code>

     * <p/>

     * Usage example for parallel processing:

     * <pre>

     *

     *  List<Future<CancelFeedSubmissionsResponse>> responses = new ArrayList<Future<CancelFeedSubmissionsResponse>>();

     *  for (CancelFeedSubmissionsRequest request : requests) {

     *      responses.add(client.cancelFeedSubmissionsAsync(request));

     *  }

     *  for (Future<CancelFeedSubmissionsResponse> future : responses) {

     *      while (!future.isDone()) {

     *          Thread.yield();

     *      }

     *      try {

     *          CancelFeedSubmissionsResponse response = future.get();

     *      // use response

     *      } catch (Exception e) {

     *          if (e instanceof MarketplaceWebServiceException) {

     *              MarketplaceWebServiceException exception = MarketplaceWebServiceException.class.cast(e);

     *          // handle MarketplaceWebServiceException

     *          } else {

     *          // handle other exceptions

     *          }

     *      }

     *  }

     * </pre>

     *

     * @param request

     *          CancelFeedSubmissionsRequest request

     * @return Future<CancelFeedSubmissionsResponse> future pointer to CancelFeedSubmissionsResponse

     * 

     */

    public Future<CancelFeedSubmissionsResponse> cancelFeedSubmissionsAsync(final CancelFeedSubmissionsRequest request) {

        Future<CancelFeedSubmissionsResponse> response = asyncExecutor.submit(new Callable<CancelFeedSubmissionsResponse>() {

            public CancelFeedSubmissionsResponse call() throws MarketplaceWebServiceException {

                return cancelFeedSubmissions(request);

            }

            });

        return response;

    }

    /**

     * Request Report 

     *

     * requests the generation of a report

     * 

     * @param request

     *          RequestReportRequest request

     * @return

     *          RequestReport Response from the service

     *