Tools/Java/Source/FrameworkTasks/org/tianocore/framework/tasks/Tool.java

   1 /** @file
   2 This file is to define nested element which is meant for specifying a tool
   3
   4 Copyright (c) 2006, Intel Corporation
   5 All rights reserved. This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14 package org.tianocore.framework.tasks;
  15
  16 import java.io.DataInputStream;
  17 import java.io.DataOutputStream;
  18 import java.io.File;
  19 import java.io.FileInputStream;
  20 import java.io.FileOutputStream;
  21 import java.io.IOException;
  22 import java.util.ArrayList;
  23 import java.util.Iterator;
  24 import java.util.List;
  25 import java.util.Random;
  26
  27 import org.apache.tools.ant.BuildException;
  28 import org.tianocore.common.logger.EdkLog;
  29
  30 /**
  31  Class Tool is to define an external tool to be used for genffsfile
  32  **/
  33 public class Tool implements EfiDefine, Section {
  34
  35     private String toolName     = "";
  36     private ToolArg toolArgList = new ToolArg();
  37     private Input inputFiles = new Input();
  38     private Input tempInputFile = new Input();
  39     private String outputPath;
  40     private String outputFileName ;
  41     private static Random ran = new Random(9999);
  42     private List<Section>  gensectList = new ArrayList<Section>();
  43     /**
  44      Call extern tool
  45
  46      @param     buffer  The buffer to put the result with alignment
  47      **/
  48     public void toBuffer (DataOutputStream buffer){
  49         ///
  50         /// call extern tool
  51         ///
  52         try {
  53             executeTool ();
  54         } catch (Exception e) {
  55             throw new BuildException("Call to executeTool failed!\n" + e.getMessage());
  56         }
  57
  58         ///
  59         /// check if file exist
  60         ///
  61         File outputFile = new File (this.outputFileName);
  62         if (!outputFile.exists()) {
  63             throw new BuildException("The file " + outputFile.getPath() + " does not exist!\n");
  64         }
  65
  66         ///
  67         /// Read output file and write it's cotains to buffer
  68         ///
  69         FileInputStream fs = null;
  70         DataInputStream in = null;
  71         try {
  72             fs  = new FileInputStream (outputFile);
  73             in  = new DataInputStream (fs);
  74
  75
  76             int fileLen = (int)outputFile.length();
  77             byte[] data  = new byte[fileLen];
  78             in.read(data);
  79             buffer.write(data, 0, fileLen);
  80
  81             ///
  82             /// 4 byte alignment
  83             ///
  84             while ((fileLen & 0x03) != 0) {
  85                 fileLen++;
  86                 buffer.writeByte(0);
  87             }
  88         } catch (Exception e) {
  89             EdkLog.log(e.getMessage());
  90             throw new BuildException("Tool call, toBuffer failed!\n");
  91         } finally {
  92             try {
  93                 if (in != null) {
  94                     in.close();
  95                 }
  96                 if (fs != null) {
  97                     fs.close();
  98                 }
  99                 outputFile.delete();
 100             } catch (Exception e) {
 101                 EdkLog.log("WARNING: Cannot close " + outputFile.getPath());
 102             }
 103         }
 104     }
 105
 106     ///
 107     /// execute external tool for genffsfile
 108     ///
 109     private void executeTool () {
 110         String command   = "";
 111         String argument  = "";
 112         command          = toolName;
 113
 114         //
 115         //  Get each section which under the compress {};
 116         //  And add it is contains to File;
 117         //
 118         Section sect;
 119         try{
 120             Iterator SectionIter = this.gensectList.iterator();
 121             while (SectionIter.hasNext()){
 122                 sect = (Section)SectionIter.next();
 123                 //
 124                 // Parse <genSection> element
 125                 //
 126                 File outputFile = File.createTempFile("temp", "sec1", new File(outputPath));
 127                 FileOutputStream bo = new FileOutputStream(outputFile);
 128                 DataOutputStream Do = new DataOutputStream (bo);
 129                 //
 130                 //  Call each section class's toBuffer function.
 131                 //
 132                 try {
 133                     sect.toBuffer(Do);
 134                 }
 135                 catch (BuildException e) {
 136                     EdkLog.log(e.getMessage());
 137                     throw new BuildException ("GenSection failed at Tool!");
 138                 } finally {
 139                     if (Do != null){
 140                         Do.close();
 141                     }
 142
 143                 }
 144                 this.tempInputFile.insFile(outputFile.getPath());
 145             }
 146         } catch (IOException e){
 147             throw new BuildException ("Gensection failed at tool!");
 148         }
 149
 150         try {
 151             this.outputFileName = "Temp" + getRand();
 152             argument   = toolArgList + inputFiles.toStringWithSinglepPrefix(" -i ")
 153                          + tempInputFile.toString(" ")+ " -o " + outputFileName;
 154             EdkLog.log(this, EdkLog.EDK_VERBOSE, command + " " + argument);
 155             ///
 156             /// execute command line
 157             ///
 158             Process process = Runtime.getRuntime().exec(command + " " + argument);
 159             process.waitFor();
 160             Iterator tempFile = tempInputFile.getNameList().iterator();
 161             while (tempFile.hasNext()){
 162                 File file = new File((String)tempFile.next());
 163                 if (file.exists()) {
 164                     file.delete();
 165                 }
 166             }
 167         } catch (Exception e) {
 168             EdkLog.log(e.getMessage());
 169             throw new BuildException("Execution of externalTool task failed!\n");
 170         }
 171     }
 172
 173     /**
 174      Add method of ANT task/datatype for nested ToolArg type of element
 175
 176      @param     toolArg     The ToolArg object containing arguments for the tool
 177      **/
 178     public void addConfiguredToolArg (ToolArg toolArg) {
 179         toolArgList.insert(toolArg);
 180     }
 181
 182     /**
 183      Get method of ANT task/datatype for attribute "OutputPath"
 184
 185      @returns   The name of output path
 186      **/
 187     public String getOutputPath() {
 188         return outputPath;
 189     }
 190
 191     /**
 192      Set method of ANT task/datatype for attribute "OutputPath"
 193
 194      @param     outputPath  The name of output path
 195      **/
 196     public void setOutputPath(String outPutPath) {
 197         this.outputPath = outPutPath;
 198     }
 199
 200     /**
 201      Get method of ANT task/datatype for attribute "ToolName"
 202
 203      @returns   The name of the tool.
 204      **/
 205     public String getToolName() {
 206         return toolName;
 207     }
 208
 209     /**
 210      Set method of ANT task/datatype for attribute "ToolName"
 211
 212      @param     toolName    The name of the tool
 213      **/
 214     public void setToolName(String toolName) {
 215         this.toolName = toolName;
 216     }
 217
 218     /**
 219      Add method of ANT task/datatype for nested Input type of element
 220
 221      @param     file    The Input objec which represents a file
 222      **/
 223     public void addConfiguredInput(Input file) {
 224         inputFiles.insert(file);
 225     }
 226
 227 //    /**
 228 //      addTool
 229 //
 230 //      This function is to add instance of Tool to list.
 231 //
 232 //      @param tool             instance of Tool.
 233 //    **/
 234 //    public void addTool(Tool tool){
 235 //        this.toolList.add(tool);
 236 //    }
 237
 238     public void addGenSection(GenSectionTask genSect){
 239         this.gensectList.add(genSect);
 240     }
 241
 242     /**
 243      Get random number.
 244
 245      @returns   The random integer.
 246      **/
 247     public synchronized int getRand() {
 248         return ran.nextInt();
 249     }
 250 }
 251
 252