/**
    * Copyright 2005-2006 the original author or authors.
    *
    * Licensed under the Gnu General Pubic 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://www.opensource.org/licenses/gpl-license.php
    *
   * This program 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 General Public License for more details.
   */
  package org.figure8.join.services.scripting.ant.tasks;
  
  import org.figure8.join.services.remoting.AuthenticatedService;
  import org.figure8.join.services.security.InvalidLoginException;
  
  import com.caucho.hessian.client.HessianProxyFactory;
  
  import org.apache.tools.ant.Task;
  import org.apache.tools.ant.Project;
  import org.apache.tools.ant.BuildException;
  
  import java.rmi.RemoteException;
  /**
   * This is an abstract Ant task providing utility methods for accessing
   * Join remote service. This task provides 3 optional attributes : <br/>
   * <ul>
   * <li><b>url</b> : The url for connecting to Join remote service (in
   * case ot no url in context),</li>
   * <li><b>user</b> : The user for connecting to Join remote service (in
   * case of no security token in context),</li>
   * <li><b>password</b> : The password for connecting to Join remote service
   * (in case of no security token in context).</li>
   * </ul>
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.2 $
   */
  public abstract class RemoteServiceTask extends Task{
  
     // Static -------------------------------------------------------------------
  
     /** Constant representing the subcontext url whithin Join web site for accessing remote services. */
     public static final String REMOTE_URL_SUBCONTEXT = "/remoting/hessian/";
  
  
     // Attributes ---------------------------------------------------------------
  
     /** The url for connecting to Join remote service (in case ot no url in context) */
     private String url;
     /** The user for connecting to Join remote service (in case of no security token in context) */
     private String user;
     /** The password for connecting to Join remote service (in case of no security token in context) */
     private String password;
  
  
     // Public -------------------------------------------------------------------
  
     /** @return The url for connecting to Join remote service */
     public String getUrl(){
        return url;
     }
     /** @param url The url for connecting to Join remote service */
     public void setUrl(String url){
        this.url = url;
     }
     /** @return The user for connecting to Join remote service */
     public String getUser(){
        return user;
     }
     /** @param user The user for connecting to Join remote service */
     public void setUser(String user){
        this.user = user;
     }
     /** @return The password for connecting to Join remote service */
     public String getPassword(){
        return password;
     }
     /** @param password The password for connecting to Join remote service */
     public void setPassword(String password){
        this.password = password;
     }
  
  
     // Protected ----------------------------------------------------------------
  
     /**
      * Retrieve a remote {@link AuthenticatedService} using a connection url. The
      * connection url retrieval strategy is the following : first check if there's an
      * url into project user properties (join.url property), if not present check if
      * it is defined as a global system property, finally use the <b>url</b> attribute
      * of this Task.
      * @param name The name of the AuthenticatedService
      * @param serviceClass The class representing the service interface
      * @throws BuildException if remote service cannot be acquired (connection problem, etc...)
      * @return A handler onto remote service needing authentication
      */
    protected AuthenticatedService retrieveRemoteService(String name, Class serviceClass) throws BuildException{
       // Retrieve url from project properties, from system property or from task attributes.
       String connectionUrl = getProject().getUserProperty(JoinTask.URL_PROPERTY);
       if (connectionUrl == null) connectionUrl = System.getProperty(JoinTask.URL_PROPERTY);
       if (connectionUrl == null) connectionUrl = url;
       // Check we really have an url.
       if (connectionUrl == null || connectionUrl.length() == 0)
          throw new BuildException("No url found for connecting to remote " + name + " service", getLocation());
 
       // Retrieve the authenticated service.
       AuthenticatedService service = null;
       connectionUrl += (REMOTE_URL_SUBCONTEXT + name);
       try{
          // Connect and retrieve Hessian proxy.
          HessianProxyFactory proxyFactory = new HessianProxyFactory();
          log("Connecting to remote AuthenticatedService (" + name + ") using url: " + connectionUrl, Project.MSG_DEBUG);
          service = (AuthenticatedService)proxyFactory.create(serviceClass, connectionUrl);
       }
       catch (Exception e){
          // Log disgnostic messages and wrap into a BuildException.
          log("Exception while connecting to remote service using " + connectionUrl, Project.MSG_ERR);
          log("Exception detailed message is: " + e.getMessage(), Project.MSG_ERR);
          throw new BuildException("Exception while connecting to remote service", e, getLocation());
       }
       return service;
    }
 
    /**
     * Log to remote service if necessary before starting working with it. This method returns the
     * security token associated with session. It is retrieved with the following strategy :
     * <ul>
     * <li>first check if such a token is in project context (join.security.token user property).
     * It assumes the login has already been done,</li>
     * <li>if not present try getting user and password first from global system properties
     * (join.security.user and join.security.password) and login to the service,</li>
     * <li>get user and password from this task attributes and login to the service.</li>
     * </ul>
     * @param service The remote service to retrieve a security token for
     * @return The security token for the established session
     */
    protected String loginToRemoteService(AuthenticatedService service) throws InvalidLoginException, RemoteException{
       // First check if there's a secutiry token.
       String token = getProject().getUserProperty(JoinTask.SECURITY_TOKEN);
 
       if (token == null){
          // Else, try system property for getting user/password ....
          String connectionUser = System.getProperty(JoinTask.SECURITY_USER);
          String connectionPwd = System.getProperty(JoinTask.SECURITY_PASSWORD);
          // Else, try user/password specified by task.
          if (connectionUser == null){
             connectionUser = user;
             connectionPwd = password;
          }
          // Check we really have user/password pair.
          if (connectionUser == null || connectionPwd == null)
             throw new BuildException("No user or password for login to the remote AuthenticatedService", getLocation());
 
          // Login onto remote service.
          log("Login to remote ProcessControlService using user/password: " + connectionUser + "/" + connectionPwd, Project.MSG_DEBUG);
          token = service.login(connectionUser, connectionPwd);
       }
       log("Retrieve a security token: " + token, Project.MSG_DEBUG);
       return token;
    }
 
    /**
     * Release the connection onto remote authenticated service. The logout operation
     * is only called if the token is not first retrieved from context (context tokens
     * are permanent).
     * @param service The remote service to logout from
     * @param token The security token to use for logging out.
     */
    protected void releaseRemoteService(AuthenticatedService service, String token){
       // First check if there's a secutiry token in context.
       String ctxToken = getProject().getUserProperty(JoinTask.SECURITY_TOKEN);
 
       if (ctxToken == null || !ctxToken.equals(token)){
          log("Logout from remote AuthenticatedService using token: " + token, Project.MSG_DEBUG);
          try {service.logout(token);}
          catch (RemoteException re){
             // Log a non lethal disgnostic message.
             log("RemoteException while logout from remote AuthenticatedService: " + re.getMessage(), Project.MSG_WARN);
          }
       }
    }
 }