JetWebFile.java

Go to the documentation of this file.

package cedar.jetweb.util;
import org.apache.commons.io.FileUtils;
import java.util.Vector;
import java.io.*;

import cedar.jetweb.*;



public class JetWebFile extends File{

    private boolean zipped_ = false;
    private boolean archived_ = false;
    private boolean jobIn_ = false;
    private boolean jobOut_ = false;
    private String dir_ = "";
    private String fileName_ = "";
    private String extension_ = "";
    private static String archiveDir_ = JetWebConfig.storeDirName;
    private static String inputDir_ = JetWebConfig.jobInDirName;
    private static String outputDir_ = JetWebConfig.jobOutDirName;
    private static boolean pathsChecked_ = false;

    private boolean isXML_ = false;
    private boolean isAida_ = false;
    private boolean isOut_ = false;

    public static String XML = ".xml";
    private static String GZ_ = ".gz";
    public  static String AIDA = ".aida";
    public static String AIDML = ".aidml";
    public static String OUT = ".out";

    private static Integer xmlLength_ = XML.length();
    private static Integer outLength_ = OUT.length();
    private static Integer aidaLength_ =  AIDA.length();
    private static Integer gzLength_ =  GZ_.length();
    private static Integer aidmlLength_ = AIDML.length();


    public JetWebFile(String fName){

    super(findFileName(fName));
    parseFileName(this.getAbsolutePath());
    }

    public JetWebFile(String fName, String extension){
    super(findFileName(fName + extension));
    parseFileName(this.getAbsolutePath());
    }

    public String toString(){

    return fileName_;
    }

    public JetWebFile Zip()
    throws JetWebException{
    
    if(zipped_) return this;

    if(!this.exists()){
        throw new JetWebException("JetWebFile.Zip()", 
                      "Error, file " + 
                      this + extension_ + 
                      "does not exist for zipping");
    }

    execCommand("gzip -f");
    zipped_ = true;

    JetWebFile newFile = null;

    if(isAida()){//then we must re-name the file from .aidml.gz to .aida
        reName(dir_ + fileName_ + AIDML + GZ_,
           dir_ + fileName_ + AIDA);
        extension_ = AIDA;
        newFile = new JetWebFile(dir_ + fileName_ + AIDA);
    }else{
        newFile = new JetWebFile(dir_ + fileName_ + extension_ + GZ_);
    }
    
    return newFile;
    }

    public JetWebFile UnZip()
    throws JetWebException{

    if(!zipped_) return this;
    
    if(!this.exists()){
        throw new JetWebException("JetWebFile.UnZip()", 
                      "Error, file " + 
                      this + extension_ + GZ_ +  
                      "does not exist for unzipping");
    }

    JetWebFile newFile = null;

    if(isAida()){
        execCommand("gunzip -f -S '" + AIDA + "'");
        //we now need to tag on the .aidml extension
        reName(dir_ + fileName_, dir_ + fileName_ + AIDML);
        extension_ = AIDML;
        newFile = new JetWebFile(dir_ + fileName_ + AIDML);
    }else{
        execCommand("gunzip -f");
        newFile = new JetWebFile(dir_ + fileName_ + extension_);
    }
    zipped_ = false;
    return newFile;
    }

    public boolean isZipped(){
    return zipped_;
    }

    public JetWebFile Archive()
    throws JetWebException{

    if(archived_) return this;
    if(!this.exists()){
        throw new JetWebException("JetWebFile.Archive()", 
                      "Error, file " + 
                      this + extension_ + 
                      "does not exist for archiving");
    }

    archived_ = true;

    return moveTo(archiveDir_);
    }

    public JetWebFile UnArchive()
    throws JetWebException{

    if(!archived_) return this;
    if(!this.exists()){
        throw new JetWebException("JetWebFile.UnArchive()", 
                      "Error, file " + 
                      this + extension_ + 
                      "does not exist in the archive directory"
                      );
    }

    archived_ = false;

    return moveTo(outputDir_);
    }

    public boolean isArchived(){
    return archived_;
    }

    public String extension(){
    return extension_;
    }

    public String directory(){
    return dir_;
    }

    public boolean isAida(){
    return(isAida_);
    }

    public boolean isXML(){
    return(isXML_);
    }

    public boolean isOut(){
    return(isOut_);
    }

    public String fullPath(){

    String fp = dir_ + fileName_ + extension_;
    if(zipped_ && !isAida_) fp = fp + GZ_;

    return fp;
    }
    private static String findFileName(String fName){
    
    checkPaths();

    File tmp = new File(fName);
    if(tmp.exists()){
        return fName;
    }
        
    Vector<String> parts = decompose(fName);

    boolean triedZipped = parts.get(2).equals(AIDA) || 
        parts.get(3).equals(GZ_);
    boolean triedArchive = parts.get(0).equals(archiveDir_);
    boolean triedInput = parts.get(0).equals(inputDir_);
    boolean isAida = parts.get(2).equals(AIDA) ||
        parts.get(2).equals(AIDML);

    if( !(triedArchive && triedZipped) ){
        if(isAida){
        fName = archiveDir_ + parts.get(1) + AIDA;
        }else{
        fName = archiveDir_ + parts.get(1) + parts.get(2) + GZ_;
        }

        tmp = new File(fName);
        if(tmp.exists())return fName;
    }

    if( !(triedArchive && !triedZipped) ){
        if(isAida){
        fName = archiveDir_ + parts.get(1) + AIDML;
        }else{
        fName = archiveDir_ + parts.get(1) + parts.get(2);
        }

        tmp = new File(fName);
        if(tmp.exists()) return fName;
    }

    if( !(triedInput && triedZipped)){
        if(isAida){
        fName = inputDir_ + parts.get(1) + AIDA;
        }else{
        fName = inputDir_ + parts.get(1) + parts.get(2) + GZ_;
        }

        tmp = new File(fName);
        if(tmp.exists()) return fName;
        }
    
    if( !(triedInput && !triedZipped)){
        if(isAida){
        fName = inputDir_ + parts.get(1) + AIDML;
        }else{
        fName = inputDir_ + parts.get(1) + parts.get(2);
        }

        tmp = new File(fName);
        if(tmp.exists()) return fName;
    }

    fName = outputDir_ + parts.get(1) + parts.get(2);
    
    return fName;
    }
    private static Vector<String> decompose(String fName){
    Vector<String> vec = new Vector(4);

    int lastSlash = fName .lastIndexOf("/");
    if(lastSlash != -1){
        String dir = fName.substring(0, lastSlash);
        if(!dir.endsWith("/")) dir = dir + "/";
        vec.add(dir);
        fName = fName.substring(lastSlash+1);
    }else{
        vec.add("");
    }
    boolean zipped = false;
    boolean aida;
    String gz = "";
    String ext = "";
    if(fName.endsWith(GZ_)){
        fName = fName.substring(0, fName.length() - gzLength_);
        gz = GZ_;
    }

    if(fName.endsWith(AIDA)){
        fName = fName.substring(0, fName.length() - aidaLength_);
        ext = AIDA;
    }

    if(fName.endsWith(AIDML)){
        fName = fName.substring(0, fName.length() - aidmlLength_);
        ext = AIDML;
    }

    if(fName.endsWith(XML)){
        fName = fName.substring(0, fName.length() - xmlLength_);
        ext = XML;
    }
    
    if(fName.endsWith(OUT)){
        fName = fName.substring(0, fName.length() - outLength_);
        ext = OUT;
    }

    vec.add(fName);
    vec.add(ext);
    vec.add(gz);
    return vec;
    }

    private void parseFileName(String fName){
    
    Vector<String> parts = decompose(fName);
    dir_ = parts.get(0);
    fileName_ = parts.get(1);
    String ext = parts.get(2);

    if(parts.get(3).equals(GZ_) ||
       ext.equals(AIDA)){
        zipped_ = true;
    }else{
        zipped_ = false;
    }

    if(ext.equals(AIDA)){
        extension_ = AIDA;
        isAida_ = true;
    }else if(ext.equals(AIDML)){
        extension_ = AIDML;
        isAida_ = true;
    }else if(ext.equals(XML)){
        extension_ = XML;
        isXML_ = true;
    }else if(ext.equals(OUT)){
        extension_ = OUT;
        isOut_ = true;
    }

    if(dir_.equals(archiveDir_)){
        archived_ = true;
    }else if(dir_.equals(inputDir_)){
        jobIn_ = true;
    }else if(dir_.equals(outputDir_)){
        jobOut_ = true;
    }

    return; 
    }

    private static void checkPaths(){
      
    if(pathsChecked_) return;
    pathsChecked_ = true;

    if(!archiveDir_.endsWith("/")) archiveDir_ = archiveDir_ + "/";
    if(!inputDir_.endsWith("/")) inputDir_ = inputDir_ + "/";
    if(!outputDir_.endsWith("/")) outputDir_ = outputDir_ + "/";

    return;
    }
    private JetWebFile moveTo(String dir)
    throws JetWebException{

    if(!dir.endsWith("/")) dir = dir + "/";
    JetWebFile newFile = null;
    try{
        File fileDir = new File(dir);
        FileUtils.copyFileToDirectory(this, fileDir);
        
        String fName = fileName_ + extension_;
        if(!isAida() && isZipped()){
        fName = fName + GZ_;
        }

        newFile = new JetWebFile(dir + fName);
        File oldFile  = new File(dir_ + fName);
        
        //this.renameTo(newFile);
        FileUtils.forceDelete(oldFile);
    }catch (IOException err){
        throw new JetWebException(err);
    }
    return newFile;
    }
    private void reName(String oldName, String newName)
    throws JetWebException{

    File newFile = new File(newName);
    File oldFile = new File(oldName);
    try{
        FileUtils.copyFile(oldFile, newFile);
        FileUtils.forceDelete(oldFile);
    }catch(IOException err){
        throw new JetWebException(err);
    }
    //this.renameTo(newFile);
    //oldFile.delete();
    return;
    }
    private void execCommand(String cmd)
    throws JetWebException{

    try{
        Process prc = 
        Runtime.getRuntime().exec
        (cmd + " " + dir_ + fileName_ + extension_);
        try {
        prc.waitFor();
        } catch (InterruptedException e) {
        System.out.println("JetWebFile: Problem waiting for file " + 
                   dir_ + fileName_ + 
                   " with command " + cmd);
        }
    }catch (IOException e1) {
        throw new JetWebException
        (e1, "JetWebFile: Could not execute command " + 
         cmd +"on file " + dir_ + fileName_);
    }
    
    return;
    }
}

Generated Wed Jan 17 09:14:27 GMT 2007