Tools/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 List<Section>  gensectList = new ArrayList<Section>();
  42     /**
  43      Call extern tool
  44
  45      @param     buffer  The buffer to put the result with alignment
  46      **/
  47     public void toBuffer (DataOutputStream buffer){
  48         ///
  49         /// call extern tool
  50         ///
  51         try {
  52             executeTool ();
  53         } catch (Exception e) {
  54             throw new BuildException("Call to executeTool failed!\n" + e.getMessage());
  55         }
  56
  57         ///
  58         /// check if file exist
  59         ///
  60         File outputFile = new File (this.outputFileName);
  61         if (!outputFile.exists()) {
  62             throw new BuildException("The file " + outputFile.getPath() + " does not exist!\n");
  63         }
  64
  65         ///
  66         /// Read output file and write it's cotains to buffer
  67         ///
  68         FileInputStream fs = null;
  69         DataInputStream in = null;
  70         try {
  71             fs  = new FileInputStream (outputFile);
  72             in  = new DataInputStream (fs);
  73
  74
  75             int fileLen = (int)outputFile.length();
  76             byte[] data  = new byte[fileLen];
  77             in.read(data);
  78             buffer.write(data, 0, fileLen);
  79
  80             ///
  81             /// 4 byte alignment
  82             ///
  83             while ((fileLen & 0x03) != 0) {
  84                 fileLen++;
  85                 buffer.writeByte(0);
  86             }
  87         } catch (Exception e) {
  88             EdkLog.log(e.getMessage());
  89             throw new BuildException("Tool call, toBuffer failed!\n");
  90         } finally {
  91             try {
  92                 if (in != null) {
  93                     in.close();
  94                 }
  95                 if (fs != null) {
  96                     fs.close();
  97                 }
  98                 outputFile.delete();
  99             } catch (Exception e) {
 100                 EdkLog.log("WARNING: Cannot close " + outputFile.getPath());
 101             }
 102         }
 103     }
 104
 105     ///
 106     /// execute external tool for genffsfile
 107     ///
 108     private void executeTool () {
 109         String command   = "";
 110         String argument  = "";
 111         command          = toolName;
 112
 113         //
 114         //  Get each section which under the compress {};
 115         //  And add it is contains to File;
 116         //
 117         Section sect;
 118         try{
 119             Iterator SectionIter = this.gensectList.iterator();
 120             while (SectionIter.hasNext()){
 121                 sect = (Section)SectionIter.next();
 122                 //
 123                 // Parse <genSection> element
 124                 //
 125                 File outputFile = File.createTempFile("temp", "sec1", new File(outputPath));
 126                 FileOutputStream bo = new FileOutputStream(outputFile);
 127                 DataOutputStream Do = new DataOutputStream (bo);
 128                 //
 129                 //  Call each section class's toBuffer function.
 130                 //
 131                 try {
 132                     sect.toBuffer(Do);
 133                 }
 134                 catch (BuildException e) {
 135                     EdkLog.log(e.getMessage());
 136                     throw new BuildException ("GenSection failed at Tool!");
 137                 } finally {
 138                     if (Do != null){
 139                         Do.close();
 140                     }
 141
 142                 }
 143                 this.tempInputFile.insFile(outputFile.getPath());
 144             }
 145         } catch (IOException e){
 146             throw new BuildException ("Gensection failed at tool!");
 147         }
 148
 149         try {
 150             Random ran = new Random(9999);
 151             this.outputFileName = "Temp" + ran.nextInt();
 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) {
            EdkLog.log(e.getMessage());
 168             throw new BuildException("Execution of externalTool task failed!\n");
 169         }
 170     }
 171
 172     /**
 173      Add method of ANT task/datatype for nested ToolArg type of element
 174
 175      @param     toolArg     The ToolArg object containing arguments for the tool
 176      **/
 177     public void addConfiguredToolArg (ToolArg toolArg) {
 178         toolArgList.insert(toolArg);
 179     }
 180
 181     /**
 182      Get method of ANT task/datatype for attribute "OutputPath"
 183
 184      @returns   The name of output path
 185      **/
 186     public String getOutputPath() {
 187         return outputPath;
 188     }
 189
 190     /**
 191      Set method of ANT task/datatype for attribute "OutputPath"
 192
 193      @param     outputPath  The name of output path
 194      **/
 195     public void setOutputPath(String outPutPath) {
 196         this.outputPath = outPutPath;
 197     }
 198
 199     /**
 200      Get method of ANT task/datatype for attribute "ToolName"
 201
 202      @returns   The name of the tool.
 203      **/
 204     public String getToolName() {
 205         return toolName;
 206     }
 207
 208     /**
 209      Set method of ANT task/datatype for attribute "ToolName"
 210
 211      @param     toolName    The name of the tool
 212      **/
 213     public void setToolName(String toolName) {
 214         this.toolName = toolName;
 215     }
 216
 217     /**
 218      Add method of ANT task/datatype for nested Input type of element
 219
 220      @param     file    The Input objec which represents a file
 221      **/
 222     public void addConfiguredInput(Input file) {
 223         inputFiles.insert(file);
 224     }
 225
 226 //    /**
 227 //      addTool
 228 //
 229 //      This function is to add instance of Tool to list.
 230 //
 231 //      @param tool             instance of Tool.
 232 //    **/
 233 //    public void addTool(Tool tool){
 234 //        this.toolList.add(tool);
 235 //    }
 236
 237     public void addGenSection(GenSectionTask genSect){
 238         this.gensectList.add(genSect);
 239     }
 240 }
 241
 242