Source code: com/flexstor/common/io/xfile/FlexXFile.java

   /*
    * FlexXFile.java
    *
    * Copyright $Date: 2003/08/11 02:22:38 $ FLEXSTOR.net Inc.
    *
    * This work is licensed for use and distribution under license terms found at
    * http://www.flexstor.org/license.html
    *
    */
  
  package com.flexstor.common.io.xfile;
  
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.BufferedReader;
  import java.io.BufferedWriter;
  import java.io.IOException;
  import java.lang.reflect.Constructor;
  
  import com.flexstor.common.io.xfile.webnfs.WebNfsFile;
  import com.flexstor.common.settings.Settings;
  import com.flexstor.common.util.FlexDbServerHost;
  import com.flexstor.common.util.StringUtil;
  import com.flexstor.common.util.UrlAnalyzer;
  /**
  * This subclass of XFile overwrites some methods which otherwise will fail if:
  * 
  *     - The protocol used is a NFS URL and the path specified is mounted from another server
  *     OR
  *     - The path contains some escape codes and special characters that must be preserved.
  * 
  * Inside these overwriten methods we first determine if the path is a NFS URL; if it is, use
  * the super class method; if that fails and the file is local to the JVM server we create a 
  * new XFile instance (not FlexXFile) with a local path as argument where all special characters
  * have been replaced.
  *
  * David C. 03/01/00
  */
  public class FlexXFile
  
  {
     private FlexXFileI iFile;
     private String sProtocol = "";
  
  
     public FlexXFile(FlexXFile file, String str)
     {
        String sDir = file.getAbsolutePath();
        String sFileSeparator = file.getFileSeparator();//sDir
        
        if ( !sDir.endsWith(sFileSeparator) )
           sDir += sFileSeparator;
  
        sProtocol = UrlAnalyzer.getRemoteFileProtocol(sDir);
        String sProtocolPackage;   
        // If this class is instantiated within the FLEXdbServer, use the appserver's 
        // remoteFileProtocol.package value; otherwise use the client's value. If the 
        // protocol is UNC then use the unc protocol package
        if ( sProtocol == null )
        {
           sProtocol = "UNC";
           sProtocolPackage = "com.flexstor.common.io.xfile.unc";
        }
        else if ( FlexDbServerHost.isLocalHost() )
           sProtocolPackage = Settings.getString(Settings.APP_SERVER_REMOTE_FILE_PROTOCOL_PACKAGE);
        else
           sProtocolPackage = Settings.getString(Settings.CLIENT_REMOTE_FILE_PROTOCOL_PACKAGE);
                 
        try
        {
           Class ifileClass = Class.forName(sProtocolPackage + "." + FlexXFile.toProper(sProtocol) + "File");
           Class[] FlexArgs = new Class[] {java.lang.String.class};
           Constructor ifileConstructor = ifileClass.getConstructor( FlexArgs );
           Object[] theArgs = new Object[] { sDir + str };
           iFile = (FlexXFileI) ifileConstructor.newInstance( theArgs );
        }
        catch (java.lang.ClassNotFoundException cnfe)
        {
           cnfe.printStackTrace();
        }
        catch (java.lang.NoSuchMethodException nsme)
        {
           nsme.printStackTrace();
        }
        catch (java.lang.IllegalAccessException iae)
        {
           iae.printStackTrace();
        }
        catch (java.lang.InstantiationException ie)
        {
           ie.printStackTrace();
        }
        catch (java.lang.reflect.InvocationTargetException ite)
        {
           ite.printStackTrace();
        }
     }
  
  
    public FlexXFile(String str)
    {
       sProtocol = UrlAnalyzer.getRemoteFileProtocol(str);
       String sProtocolPackage;   
       // If this class is instantiated within the FLEXdbServer, use the appserver's 
       // remoteFileProtocol.package value; otherwise use the client's value. If the 
       // protocol is UNC then use the unc protocol package
       if ( sProtocol == null )
       {
          sProtocol = "UNC";
          sProtocolPackage = "com.flexstor.common.io.xfile.unc";
       }
       else if ( FlexDbServerHost.isLocalHost() )
          sProtocolPackage = Settings.getString(Settings.APP_SERVER_REMOTE_FILE_PROTOCOL_PACKAGE);
       else
          sProtocolPackage = Settings.getString(Settings.CLIENT_REMOTE_FILE_PROTOCOL_PACKAGE);
 
       try
       {
          Class ifileClass = Class.forName(sProtocolPackage + "." + FlexXFile.toProper(sProtocol) + "File");
          Class[] FlexArgs = new Class[] {java.lang.String.class};
          Constructor ifileConstructor = ifileClass.getConstructor( FlexArgs );
          Object[] theArgs = new Object[] { str };
          iFile = (FlexXFileI) ifileConstructor.newInstance( theArgs );
       }
       catch (java.lang.ClassNotFoundException cnfe)
       {
          cnfe.printStackTrace();
       }
       catch (java.lang.NoSuchMethodException nsme)
       {
          nsme.printStackTrace();
       }
       catch (java.lang.IllegalAccessException iae)
       {
          iae.printStackTrace();
       }
       catch (java.lang.InstantiationException ie)
       {
          ie.printStackTrace();
       }
       catch (java.lang.reflect.InvocationTargetException ite)
       {
          ite.printStackTrace();
       }
    }
    
    public String[] extendedList()
    {
         return iFile.extendedList();
    }
    
    public String[] extendedList(XFilenameFilter filter)
    {
         return iFile.extendedList(filter.getFilter(sProtocol));
    }
 
    
    public FlexXFileI getXFile()
    {
         return iFile;
    }
    
    public BufferedInputStream getBufferedInputStream() throws IOException
    {
         return iFile.getBufferedInputStream();
    }
    
    public BufferedInputStream getBufferedInputStream(int bufferSize) throws IOException
    {
         return iFile.getBufferedInputStream(bufferSize);
    }
    
    public BufferedOutputStream getBufferedOutputStream(int bufferSize) throws IOException
    {
         return iFile.getBufferedOutputStream(bufferSize);
    }
    
    public BufferedReader getBufferedReader(int bufferSize) throws IOException
    {
     
         return iFile.getBufferedReader(bufferSize);
    
    }
    
    public BufferedWriter getBufferedWriter(int bufferSize) throws IOException
    {
         return iFile.getBufferedWriter(bufferSize);
    }
    
    public BufferedOutputStream getBufferedOutputStream() throws IOException
    {
         return iFile.getBufferedOutputStream();
    }
    
    public BufferedReader getBufferedReader() throws IOException
    {
         return iFile.getBufferedReader();
    }
    
    public BufferedWriter getBufferedWriter() throws IOException
    {
         return iFile.getBufferedWriter();
    }
    
    public WebNfsFile getWebNFSFile()
    {
             return (WebNfsFile) iFile;
    }
    
    public String getPath()
    {
       return iFile.getPath(); 
    }
    
    public String getFileSystemName()
    {
     return iFile.getFileSystemName();
    }
    
    public String[] list(XFilenameFilter filter)
    {
       return iFile.list(filter.getFilter(sProtocol));
    }
    
    public String[] list()
    {
      return iFile.list();
    }
 
    public boolean mkdir()
    {
       return iFile.mkdir();
 
    }
 
    public boolean mkdirs()
    {
        return iFile.mkdirs();
    }
 
    public String getName()
    {
        return iFile.getName();
    }
 
    public String getParent()
    {
          return iFile.getParent();
    }
 
    public boolean exists()
    {
          return iFile.exists();
    }
 
    public boolean canRead()
    {
       return iFile.canRead();
    }
 
    public boolean canWrite()
    {
          return iFile.canWrite();
    }
 
    public boolean isDirectory()
    {
        return iFile.isDirectory();
    }
    
    public boolean isFile()
    {
        return iFile.isFile();
    }
 
    public boolean isAbsolute()
    {
        return iFile.isAbsolute();
    }
    
    public long lastModified()
    {
          return iFile.lastModified();
    }
    
    public long length()
    {
          return iFile.length();
    }
 
    public boolean delete()
    {
        return iFile.delete();
    }
    
    public boolean renameTo( FlexXFile xFile )
    {
         return iFile.renameTo(xFile.getXFile());
    }
    
    public String getServer()
    {
       return iFile.getServer();
    }
    
    /**
    * Returns the local path; if this is a NFS URL, it will return the path, without the
    * nfs://sServer portion.
    */
    public String getLocalPath()
    {
       return iFile.getLocalPath();
    }
    
    /**
    * Returns true if the files resides in this server; false otherwise
    */
    public boolean isLocalPath()
    {
       return iFile.isLocalPath();
    }
 
    public String getLocalParent()
    {
       return iFile.getLocalParent();
    }
 
    /**
    * Returns the path of this file as a UNC (Universal Naming Convension)
    * e.g. \\SERVER_NAME\location\filename
    */
    public String getUNCPath()
    {
       return iFile.getUNCPath();
    }
 
    /**
    * Returns the path of this file as a UNC (Universal Naming Convension), excluding the
    * server name.
    * e.g. \location\filename
    */
    public String getLocalUNCPath()
    {
       return iFile.getLocalUNCPath();
    }
 
    public String getAbsolutePath()
    {
         return iFile.getAbsolutePath();
    }
 
    public static String getFileSeparator(String sFile)
    {
       return WebNfsFile.getFileSeparator(sFile);
    }
 
    /**
     * Takes the protocol and capitalizes its first letter
     * WebNfs is a special case which will be handled separate from the others
     * since we need to capitalize both the 'W' and the 'N' and because the 
     * protocol could be either webnfs or nfs.
     * 
     * @param s The String to capitalize
     * @return The String with its first letter capitalized
     */
    public static String toProper( String sProtocol )
    {
       if ( sProtocol.equalsIgnoreCase("webnfs") || sProtocol.equalsIgnoreCase("nfs") )
          return "WebNfs";
       else
          return StringUtil.toProper(sProtocol);
    }
 
    public String getFileSeparator()
    {
       return iFile.getFileSeparator();   
    }
    
    public String toString()
    {
       return iFile.toString();
    }
    
 }