/*

  * Copyright (C) The Apache Software Foundation. All rights reserved.

  *

  * This software is published under the terms of the Apache Software License

  * version 1.1, a copy of which has been included with this distribution in

  * the LICENSE file.

  * 

  * $Id: ProducerTask.java 155459 2005-02-26 13:24:44Z dirkv $

  */

 package org.apache.commons.messenger.task;

 import java.io.BufferedReader;

 import java.io.File;

 import java.io.FileReader;

 import java.io.IOException;

 import java.io.Reader;

 import java.util.Iterator;

 import java.util.Vector;

 import javax.jms.Destination;

 import javax.jms.JMSException;

 import javax.jms.TextMessage;

 import org.apache.commons.messenger.Messenger;

 import org.apache.commons.messenger.MessengerManager;

 import org.apache.tools.ant.BuildException;

 import org.apache.tools.ant.DirectoryScanner;

 import org.apache.tools.ant.Task;

 import org.apache.tools.ant.types.FileSet;

 /** 

  * <p><code>ProducerTask</code> is an Ant task which will 

  * publish all of the given text files as a JMS Text Message

  * using a given JMS Connection (Messenger) and a Destination

  *

  * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>

  * @version $Revision: 155459 $

  */

 public class ProducerTask extends Task {

     private Vector filesets = new Vector();

     private Messenger messenger;

     private String messengerName;

     private Destination destination;

     private String subject;

     private MessengerManager messengerManager;   

     private File file; 

     /** Holds value of property sleep. */

     private long sleep;

     // Properties

     //-------------------------------------------------------------------------

     /**

      * Adds a set of files (nested fileset attribute).

      */

     public void addFileset(FileSet set) {

         filesets.addElement(set);

     }

     public Messenger getMessenger() throws JMSException {

         if ( messenger == null ) {

             messenger = getMessengerManager().getMessenger( getMessengerName() );

         }

         return messenger;

     }

     /** Sets the Messenger to be used */

     public void setMessenger(Messenger messenger) {

         this.messenger = messenger;

     }

     /** Getter for property messengerName.

      * @return Value of property messengerName.

      */

     public String getMessengerName() {

         return messengerName;

     }

     /** Setter for property messengerName.

      * @param messengerName New value of property messengerName.

      */

     public void setMessengerName(String messengerName) {

         this.messengerName = messengerName;

     }

     /** Getter for property destination.

      * @return Value of property destination.

      */

     public Destination getDestination() throws JMSException {

         if ( destination == null ) {

             destination = getMessenger().getDestination( getSubject() );

         }

         return destination;

     }

     /** Setter for property destination.

      * @param destination New value of property destination.

      */

     public void setDestination(Destination destination) {

         this.destination = destination;

     }

     /** Getter for property subject.

      * @return Value of property subject.

      */

     public String getSubject() {

         return subject;

     }

     /** Setter for property subject.

      * @param subject New value of property subject.

      */

     public void setSubject(String subject) {

         this.subject = subject;

     }

     /** Getter for property messengerManager.

      * @return Value of property messengerManager.

      */

     public MessengerManager getMessengerManager() {

         return messengerManager;

     }

     /** Setter for property messengerManager.

      * @param messengerManager New value of property messengerManager.

      */

     public void setMessengerManager(MessengerManager messengerManager) {

         this.messengerManager = messengerManager;

     }

     /** 

      * Sets the URI of the Messenger.xml configuration document to use

      * to configure the messengers to use for this task.

      */

     public void setConfiguration(String uri) throws JMSException {

         setMessengerManager( MessengerManager.load( uri ) );

     }

     /** Getter for property sleep, which defines the number of milliseconds to 

      * sleep for before each send.

      * @return Value of property sleep.

      */

     public long getSleep() {

         return sleep;

     }

     /** Setter for property sleep, which defines the number of milliseconds to 

      * sleep for before each send.

      * @param sleep New value of property sleep.

      */

     public void setSleep(long sleep) {

         this.sleep = sleep;

     }

     /**

      * Returns the single file to be sent instead of a FileSet

      * @return File

      */

     public File getFile() {

         return file;

     }

     /**

      * Allows a single file to be sent via the Ant Task

      * @param file The file to set

      */

     public void setFile(File file) {

         this.file = file;

     }

     // Task interface

     //-------------------------------------------------------------------------

     /**

      * Performs the copy operation.

      */

     public void execute() throws BuildException {

         try {

             if (filesets.size() == 0) {

                 throw new BuildException("Specify at least one source fileset.", location);

             }

             Messenger messenger = getMessenger();

             if ( messenger == null ) {

                 throw new BuildException("Must specify a valid Messenger", location );

             }

             Destination destination = getDestination();

             if ( destination == null ) {

                 throw new BuildException("Must specify a valid JMS Destination", location );

             }

             if ( sleep > 0 ) {

                 log( "Will sleep for: " + sleep + " (ms) between message sends" );

             }

             // deal with the filesets

             boolean first = true;

             if (file != null ) {

                 sendFile(file, messenger, destination);

             }

             else {

                 for (Iterator iter = filesets.iterator(); iter.hasNext(); ) {

                     FileSet fs = (FileSet) iter.next();

                     DirectoryScanner ds = fs.getDirectoryScanner(project);                

                     ds.scan();

                     File dir = ds.getBasedir();

                     String[] files = ds.getIncludedFiles();

                     for (int i = 0; i < files.length; i++) {

                         if ( first ) {

                             first = false;

                         }

                         else {

                             sleep();

                         }

                         sendFile( new File( dir, files[i]), messenger, destination );

                     }

                 }

             }

         }

         catch (IOException e) {

             throw new BuildException(e, location);

         }

         catch (JMSException e) {

             throw new BuildException(e, location);

         }

         finally {        

             try {

                 // close the JMS connection to release any background threads        

                 messenger.close();

             }

             catch (Exception e) {

                 // ignore close exceptions

             }

         }

     }

     /**

      * Sends the contents of the given file to the given Destination 

      * using the given Messenger instance

      */

     protected void sendFile(File file, Messenger messenger, Destination destination) throws IOException, JMSException {

         log( "Sending message to: " + destination + " from file: " + file );

         String text = readText(

             new BufferedReader( new FileReader( file ) )

         );

         TextMessage message = messenger.createTextMessage( text );

         messenger.send( destination, message );

     }

     /** 

      * Reads the given text stream into a single string 

      */

     protected String readText(Reader in) throws IOException {

         // read all the text into memory

         StringBuffer buffer = new StringBuffer();

         BufferedReader reader = new BufferedReader( in );

         for ( String line; (line = reader.readLine()) != null; ) {

             buffer.append( line );

             buffer.append( '\n' );

         }

         reader.close();

         return buffer.toString();

     }

     /**

      * Sleeps for a configurable amount of time between each message send 

      */

     protected void sleep() {

         if ( sleep > 0 ) {

             try {

                 Thread.sleep(sleep);

             }

             catch (InterruptedException e) {

                 // ignore interuptions

             }

         }

     }

 }