/*
    * Copyright (c) 2003 Peter Antman, Teknik i Media  <peter.antman@tim.se>
    *
    * $Id: FTPConnectionFactory.java,v 1.1.1.1 2004/05/19 12:26:42 pra Exp $
    *
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 2 of the License, or (at your option) any later version
   * 
   * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   * 
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  package org.backsource.adaptor.ftp;
  
  import EDU.oswego.cs.dl.util.concurrent.LinkedQueue;
  
  import javax.management.ObjectName;
  import javax.management.MBeanServer;
  import javax.management.MalformedObjectNameException;
  
  import org.backsource.jmx.ServiceMBeanSupport;
  import org.backsource.jmx.ObjectNameFactory;
  
  import org.backsource.utils.io.CachedStreamFactory;
  import org.backsource.utils.io.CachedStream;
  /***
   * First scetch of a J2ee/jdbc like ftp adaptor.
   *
   * <p>This factory is currently hardwired to use the {@link NetFTPConnection}.</p>
   <p>The typical usage scenarion is much like usage of JDBC. Either you have a preconfigured factory that you lookup through JDBC, or it is configured manually. It is however not serializable.</p>
   <pre> 
        FTPConnectionFactory  connectionFactory = new FTPConnectionFactory();
        connectionFactory.setHostName( "localhost" );
        connectionFactory.setUser( "pra@tim.se" );
        connectionFactory.setPassword( anonymous );
  
        FTPConnection ftp = null;
        try {
          // Transfer a file
          ftp.put("topfile.xml", new FileInputStream( new File(dir,"topfile.xml") ) );
          // Create subdir an populate
          ftp.mkdir("mysub");
          ftp.put("mysub/subfile1.xml", new FileInputStream( new File(dir,"subfile1.xml") ) );
  
          // Remove stuff
          ftp.deleteFile("topfile.xml");
          ftp.deleteFile("mysub/subfile1.xml");
          // delete dir
          ftp.deleteFile("mysub");
        } catch (FTPException e) {
           // throw some own exception
        } finally {
          if ( ftp != null) {
            ftp.close();
          } // end of if ()      
  
        } // end of finally
  
        connectionFactory.stop();
  </pre>         
        
   
   *
   * @author <a href="mailto:pra@tim.se">Peter Antman</a>
   * @version $Revision: 1.1.1.1 $
   * @jmx:mbean name="adaptor:service=ftp,name=serverName" extends="org.backsource.jmx.ServiceMBean"
   */
  
  public class FTPConnectionFactory extends ServiceMBeanSupport
     implements   org.backsource.adaptor.ftp.FTPConnectionFactoryMBean {
     public static final javax.management.ObjectName OBJECT_NAME = ObjectNameFactory.create("adaptor:service=ftp,name=serverName");
     public static final int DEFAULT_TIMEOUT = 60*1000;
     private String hostName;
     private String user;
     private String pwd;
     private int timeout = DEFAULT_TIMEOUT;
     protected ObjectName name = OBJECT_NAME;
     protected MBeanServer server;
     protected LinkedQueue connections = new LinkedQueue();
     protected CachedStreamFactory streamFactory;
     protected CachedStream stream;
     
     public FTPConnectionFactory (){
        
     }
     protected ObjectName getObjectName(MBeanServer server, ObjectName name)
        throws MalformedObjectNameException
     {
        this.server = server;
        if ( name != null) {
           this.name = name;
        } // end of if ()
       
       return this.name;
    }
    /***
     * Name of the ftp server.
     *
     * @jmx:managed-attribute
     */
    public void setHostName(String hostName) {
       this.hostName = hostName;
    }
 
    /***
     * Name of the ftp server.
     *
     * @jmx:managed-attribute
     */
    public String getHostName() {
       return hostName;
    }
 
    /***
     * Name of the user.
     *
     * @jmx:managed-attribute
     */
    public void setUser(String user) {
       this.user = user;
    }
 
    /***
     * Name of the user.
     *
     * @jmx:managed-attribute
     */
    public String getUser() {
       return user;
    }
    /***
     * Password.
     *
     * @jmx:managed-attribute
     */
    public void setPassword(String pwd) {
       this.pwd = pwd;
    }
 
    /***
     * Password.
     *
     * @jmx:managed-attribute
     */
    public String getPassword() {
       return pwd;
    }
    
    /***
     * Timeout.
     *
     * @jmx:managed-attribute
     */
    public void setTimeout(int timeout) {
       this.timeout = timeout;
    }
 
    /***
     * The a {@link org.backsource.utils.io.CachedStreamFactory} to use for stream handling; if not supplied the default one according the default configuration rules are used.
     */
    public void setCachedStreamFactory(CachedStreamFactory streamFactory) {
       this.streamFactory = streamFactory;
    }
 
    /***
     * Get the cached stream (not the factory).
     */
    public CachedStream getCachedStream() throws FTPException {
       try {
          synchronized(this) {
             if ( stream == null) {
                if ( streamFactory == null) {
                   streamFactory = CachedStreamFactory.newInstance();
                   
                } // end of if ()
                stream = streamFactory.getCachedStream();
             }
          }
          
       } catch (ClassNotFoundException e) {
          throw new FTPException("Could not construct a cached stream: " +e,e);
       } // end of try-catch
       return stream;
    }
 
    /***
     * Timeout.
     *
     * @jmx:managed-attribute
     */
    public int getTimeout() {
       return timeout;
    }
 
    public void stop() {
       log.debug("Stoping factory");
       NetFTPConnection ftp = null;
       while (!connections.isEmpty()) {
          try {      
             ftp = (NetFTPConnection)connections.take();
             if ( ftp != null) {
                ftp.internalClose();
             } // end of if ()
          } catch ( InterruptedException e) {
             log.warn("Pool interrupted while trying to empty");
          } // end of try-catch
       } // end of while ()
       log.debug("Factory stoped");
    }
    
    
    /***
     * Get a new FTPConnection, may have been cached/pooled.
     * <p>The connection MUST be close after usage, use it much like you would use a JDBC connection.
     */
    public FTPConnection getConnection() throws FTPException {
       NetFTPConnection ftp = null;
       if ( connections.isEmpty() ) {
          ftp =  new NetFTPConnection(this);
       } else {
          try {
             ftp = (NetFTPConnection)connections.take();
          } catch (InterruptedException e) {
             throw new FTPException("Could not get a connection from pool "+e,e);
          } // end of try-catch
 
       } // end of else
       if ( !ftp.isAlive()) {
          ftp.connect();
       } // end of if ()
       return ftp;
       
    }
 
    /***
     * Hook from the connection to return the connection to the pool.
     */
    protected void releaseConnection(FTPConnection ftp) {
       NetFTPConnection myFtp = ( NetFTPConnection)ftp;
       log.debug("Releasing connection: " +ftp);
       //if ( myFtp != null) {
          // Better safe than sorry!
       //  myFtp.internalClose();
 
       //} 
       // end of if ()
       try {
          connections.put(myFtp);
       } catch (InterruptedException e) {
          ;//Ignored
          //What the FUCK!
       } // end of try-catch
       log.debug("Released connection: " +ftp);
    }
 }// FTPConnectionFactory