buildframework/helium/tools/compile/sbs/sbs.ant.xml
changeset 587 85df38eb4012
parent 217 0f5e3a7fb6af
child 588 c7c26511138f
child 618 df88fead2976
equal deleted inserted replaced
217:0f5e3a7fb6af 587:85df38eb4012
    22 -->
    22 -->
    23 <!--* @package compile -->
    23 <!--* @package compile -->
    24 <project name="compile.sbs" xmlns:hlm="http://www.nokia.com/helium">
    24 <project name="compile.sbs" xmlns:hlm="http://www.nokia.com/helium">
    25     <description>
    25     <description>
    26     Executes compilation of a System Model of System Definition file using Symbian SBS (Raptor) tools. 
    26     Executes compilation of a System Model of System Definition file using Symbian SBS (Raptor) tools. 
    27 
       
    28     Should not be called directly but through compile-main by setting ${build.system.sbs} property.
       
    29 
       
    30     Example:
       
    31 
       
    32     hlm -Dsysdef.configurations.list=ALL -Dbuild.system=sbs compile-main
       
    33     hlm "-Dsysdef.configurations.list=REALLYCLEAN,ALL" -Dbuild.system=sbs compile-main
       
    34     </description>
    27     </description>
    35 
    28 
    36     <!-- Executes compilation  of a System Model of System Definition file using Symbian SBS (Raptor) tools. 
    29 
    37 
    30 
    38     Should not be called directly but through compile-main by setting ${build.system.sbs} property.
    31     <!--
    39 
    32         Executes compilation  of a System Model of System Definition file using Symbian SBS (Raptor) tools. 
    40     Example: 
    33         Should not be called directly but through compile-main by setting ${build.system.sbs} property.
    41 
       
    42     hlm -Dsysdef.configurations.list=ALL -Dbuild.system=sbs compile-main
       
    43     hlm "-Dsysdef.configurations.list=REALLYCLEAN,ALL" -Dbuild.system=sbs compile-main
       
    44 
       
    45     -->
    34     -->
    46 
    35 
       
    36     <!--* @property sbs.build.ctc
       
    37      This property enables Raptor compilation using ctc. 
       
    38      @type boolean
       
    39      @scope public
       
    40      -->
       
    41     
    47     <!-- skip sbs layer filtering (true) for new schema and false for schema 1.4.0
    42     <!-- skip sbs layer filtering (true) for new schema and false for schema 1.4.0
    48     @type boolean
    43     @type boolean
    49     -->
    44     -->
    50     <property name="skip.sbs.layer.generation" value="false" />
    45     <property name="skip.sbs.layer.generation" value="false" />
    51     
    46     
    89             </or>
    84             </or>
    90             <then>
    85             <then>
    91                 <echo message="Copying helium filter plugin to sbs home" />
    86                 <echo message="Copying helium filter plugin to sbs home" />
    92                 <copy file="${helium.dir}/tools/common/python/scripts/filter_metadatalog.py" todir="${env.SBS_HOME}/python/plugins/" failonerror="true" />
    87                 <copy file="${helium.dir}/tools/common/python/scripts/filter_metadatalog.py" todir="${env.SBS_HOME}/python/plugins/" failonerror="true" />
    93                 <copy file="${helium.dir}/tools/common/python/scripts/sbsscanlogmetadata.py" todir="${env.SBS_HOME}/python/plugins/" failonerror="true" />
    88                 <copy file="${helium.dir}/tools/common/python/scripts/sbsscanlogmetadata.py" todir="${env.SBS_HOME}/python/plugins/" failonerror="true" />
    94                 <echo message="sbs.patternset: ${sbs.patternset}" />
       
    95                 <hlm:generate-layers />
       
    96                 <var name="sbs.internal.inputs.list" value="" unset="true"/>
    89                 <var name="sbs.internal.inputs.list" value="" unset="true"/>
    97                 <if>
    90                 <if>
    98                     <istrue value="${schema.new}" />
    91                     <istrue value="${schema.new}" />
    99                     <then>
    92                     <then>
   100                         <var name="sbs.internal.inputs.list" value="${sbs.inputs.list}"/>
    93                         <hlm:downgradeSysdef epocroot="${build.drive}/" srcfile="${canonical.sysdef.file}" 
       
    94                             destfile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml"/>
       
    95                         <var name="sbs.patternset" unset="true"/>
       
    96                         <if>
       
    97                             <isreference refid="sysdef.filters.${sysdef.configuration}" />
       
    98                             <then>
       
    99                                 <property name="sbs.patternset" value="sysdef.filters.${sysdef.configuration}" />
       
   100                                 <echo message="sbs.patternset: ${sbs.patternset}" />
       
   101                             </then>
       
   102                             <else>
       
   103                                 <echo message="The sysdef.${sysdef.configuration} patternset is not defined." />
       
   104                             </else>
       
   105                         </if>
   101                     </then>
   106                     </then>
   102                     <else>
   107                     <else>
   103                         <var name="sbs.internal.inputs.list" value="" unset="true"/>
   108                         <hlm:generate-layers />
   104                         <hlm:getsbsinputs config="sbs.${sysdef.configuration}" outputProperty="sbs.internal.inputs.list"/>
       
   105                     </else>
   109                     </else>
   106                 </if>
   110                 </if>
       
   111                 <var name="sbs.internal.inputs.list" value="" unset="true"/>
       
   112                 <hlm:getsbsinputs config="sbs.${sysdef.configuration}" outputProperty="sbs.internal.inputs.list"/>
   107                 <for list="${sbs.internal.inputs.list}" delimiter="," param="sbs.input">
   113                 <for list="${sbs.internal.inputs.list}" delimiter="," param="sbs.input">
   108                     <sequential>
   114                     <sequential>
   109                         <echo message="building raptor input: @{sbs.input}" />
   115                         <echo message="building raptor input: @{sbs.input}" />
   110                         <hlm:getVariableValue name="--logfile" property="sbs.log.file">
   116                         <var name="sbs.log.file" unset="true" />
   111                             <hlm:sbsinput refid="@{sbs.input}" />
   117                         <property name="sbs.log.file" location="${compile.log.dir}/${build.id}_${sysdef.configuration}_@{sbs.input}_compile.log" />
   112                         </hlm:getVariableValue>
       
   113                         <!-- run arm license checking / setting arm version only for arm config -->
   118                         <!-- run arm license checking / setting arm version only for arm config -->
   114                         <hlm:getVariableValue name="-c" property="compilevalue.var" failOnerror="false">
   119                         <hlm:getVariableValue name="-c" property="compilevalue.var" failOnerror="false">
   115                             <hlm:sbsinput refid="@{sbs.input}" />
   120                             <hlm:sbsinput refid="@{sbs.input}" />
   116                         </hlm:getVariableValue>
   121                         </hlm:getVariableValue>
   117                         <echo message="config parameter -c : ${compilevalue.var}" />
   122                         <echo message="config parameter -c : ${compilevalue.var}" />
   122                             </and>
   127                             </and>
   123                             <then>
   128                             <then>
   124                                 <runtarget target="set-arm-version"/>
   129                                 <runtarget target="set-arm-version"/>
   125                             </then>
   130                             </then>
   126                         </if>
   131                         </if>
   127                         <var name="sbs.clean.log" value="${sbs.log.file}.clean.log"/>
       
   128                         <var name="sbs.what.log" value="${sbs.log.file}.whatlog.log"/>
       
   129                         <!-- Generate the filtered layers -->
   132                         <!-- Generate the filtered layers -->
   130                         <if>
   133                         <if>
   131                             <isset property="run.coverity"/>
   134                             <isset property="run.coverity"/>
   132                             <then>
   135                             <then>
   133                                 <hlm:coveritybuild  sbsinput="@{sbs.input}" 
   136                                 <hlm:coveritybuild  sbsinput="@{sbs.input}" 
   135                                                     layerpatternsetref="${sbs.patternset}" 
   138                                                     layerpatternsetref="${sbs.patternset}" 
   136                                                     workingdir="${build.drive}/" 
   139                                                     workingdir="${build.drive}/" 
   137                                                     execute="true"
   140                                                     execute="true"
   138                                                     failonerror="false"
   141                                                     failonerror="false"
   139                                                     outputlog="${sbs.log.file}" 
   142                                                     outputlog="${sbs.log.file}" 
   140                                                     cleanlog = "${sbs.clean.log}"
   143                                                     erroroutput="${sbs.log.file}.sbs_error.log">
   141                                                     whatlog = "${sbs.what.log}"
       
   142                                                     erroroutput="${sbs.log.file}.sbs_error.log"
       
   143                                                     statslog="${sbs.log.file}.info.xml">
       
   144                                     <hlm:coverityoptions refid="coverity.build.options"/>
   144                                     <hlm:coverityoptions refid="coverity.build.options"/>
   145                                 </hlm:coveritybuild>
   145                                 </hlm:coveritybuild>
   146                             </then>
   146                             </then>
   147                             <elseif>
   147                             <elseif>
   148                                 <istrue value="${sbs.build.ctc}"/>
   148                                 <istrue value="${sbs.build.ctc}"/>
   151                                                     sysdefFile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml" 
   151                                                     sysdefFile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml" 
   152                                                     layerPatternSetRef="${sbs.patternset}" 
   152                                                     layerPatternSetRef="${sbs.patternset}" 
   153                                                     errorOutput="${sbs.log.file}.sbs_error.log" 
   153                                                     errorOutput="${sbs.log.file}.sbs_error.log" 
   154                                                     workingDir="${build.drive}/" 
   154                                                     workingDir="${build.drive}/" 
   155                                                     failOnError="false" 
   155                                                     failOnError="false" 
   156                                                     outputLog="${sbs.log.file}" 
   156                                                     outputLog="${sbs.log.file}" />                                
   157                                                     cleanLog = "${sbs.clean.log}"
       
   158                                                     whatlog = "${sbs.what.log}"
       
   159                                                     statsLog="${sbs.log.file}.info.xml" />                                
       
   160                                 </then>
   157                                 </then>
   161                             </elseif>
   158                             </elseif>
   162                             <else>
   159                             <else>
   163                                 <hlm:sbstask sbsinput="@{sbs.input}" 
   160                                 <hlm:sbstask sbsinput="@{sbs.input}" 
   164                                                 sysdefFile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml" 
   161                                                 sysdefFile="${build.drive}/output/build/canonical_system_definition_${sysdef.configuration}.xml" 
   165                                                 layerPatternSetRef="${sbs.patternset}" 
   162                                                 layerPatternSetRef="${sbs.patternset}" 
   166                                                 errorOutput="${sbs.log.file}.sbs_error.log" 
   163                                                 errorOutput="${sbs.log.file}.sbs_error.log" 
   167                                                 workingDir="${build.drive}/" 
   164                                                 workingDir="${build.drive}/" 
   168                                                 failOnError="false" 
   165                                                 failOnError="false" 
   169                                                 outputLog="${sbs.log.file}" 
   166                                                 outputLog="${sbs.log.file}" />
   170                                                 cleanLog = "${sbs.clean.log}"
       
   171                                                 whatlog = "${sbs.what.log}"
       
   172                                                 statsLog="${sbs.log.file}.info.xml" />
       
   173                             </else>
   167                             </else>
   174                         </if>
   168                         </if>
   175                         <hlm:assertFileExists file="${sbs.log.file}"/>
   169                         <hlm:assertFileExists file="${sbs.log.file}"/>
   176                         <hlm:assertFileExists file="${sbs.clean.log}"/>
       
   177                         <hlm:assertFileExists file="${sbs.what.log}"/>
       
   178                         <hlm:assertFileExists file="${sbs.log.file}.sbs_error.log"/>
   170                         <hlm:assertFileExists file="${sbs.log.file}.sbs_error.log"/>
   179                         <hlm:assertFileExists file="${sbs.log.file}.info.xml"/>
       
   180                         <!-- run arm license checking / setting arm version only for arm config --> 
   171                         <!-- run arm license checking / setting arm version only for arm config --> 
   181                         <echo message="sbs.log.file: ${sbs.log.file}" />
   172                         <echo message="sbs.log.file: ${sbs.log.file}" />
   182                         <hlm:sbsProcessOutputMacro sbs.log.file="${sbs.log.file}"
   173                         <hlm:sbsProcessOutputMacro sbs.log.file="${sbs.log.file}"
   183                             sbs.clean.log.file="${sbs.clean.log}" sbs.what.log.file="${sbs.what.log}" 
       
   184                             sbs.stats.file="${sbs.log.file}.info.xml"
       
   185                             sbs.ant.output.file="${sbs.log.file}" sbs.error.output.file="${sbs.log.file}.sbs_error.log"/>
   174                             sbs.ant.output.file="${sbs.log.file}" sbs.error.output.file="${sbs.log.file}.sbs_error.log"/>
   186                     </sequential>
   175                     </sequential>
   187                 </for>
   176                 </for>
   188             </then>
   177             </then>
   189         </if>
   178         </if>
   190     </target>
   179     </target>
   191     
   180     
   192     
   181     
   193     <macrodef name="sbsProcessOutputMacro" uri="http://www.nokia.com/helium">
   182     <macrodef name="sbsProcessOutputMacro" uri="http://www.nokia.com/helium">
   194         <attribute name="sbs.clean.log.file" />
       
   195         <attribute name="sbs.what.log.file" />
       
   196         <attribute name="sbs.log.file" />
   183         <attribute name="sbs.log.file" />
   197         <attribute name="sbs.stats.file" />
       
   198         <attribute name="sbs.error.output.file" />
   184         <attribute name="sbs.error.output.file" />
   199         <attribute name="sbs.ant.output.file" />
   185         <attribute name="sbs.ant.output.file" />
   200         <sequential>
   186         <sequential>
   201             <var name="sbs.scan2.template" value="scan2_orm.html.ftl" />
   187             <var name="sbs.scan2.template" value="scan2_orm.html.ftl" />
   202             <var name="base.sbs.log" value="" unset="true"/>
   188             <var name="base.sbs.log" value="" unset="true"/>
   212             <hlm:signalMacro logfile="@{sbs.error.output.file}" 
   198             <hlm:signalMacro logfile="@{sbs.error.output.file}" 
   213                 signal.input="raptorErrorSignalInput" phase="compile"/>
   199                 signal.input="raptorErrorSignalInput" phase="compile"/>
   214             <!-- update the resultes to database -->
   200             <!-- update the resultes to database -->
   215             <echo message="Metadata enabled, storing build status in database" />
   201             <echo message="Metadata enabled, storing build status in database" />
   216             <echo message="sbs log file :@{sbs.log.file}" />
   202             <echo message="sbs log file :@{sbs.log.file}" />
   217             <echo message="sbs.clean.log.file :@{sbs.clean.log.file}" />
       
   218             <echo message="sbs.what.log.file :@{sbs.what.log.file}" />
       
   219             <trycatch property="hlm-sbs.parser.thrown">
   203             <trycatch property="hlm-sbs.parser.thrown">
   220                 <try>
   204                 <try>
   221                     <hlm:metadatarecord  database="${metadata.dbfile}">
   205                     <hlm:metadatarecord  database="${metadata.dbfile}">
   222                         <hlm:sbsmetadatainput whatLogFile="@{sbs.what.log.file}" cleanLogFile="@{sbs.clean.log.file}">
   206                         <hlm:sbsmetadatainput>
   223                             <fileset casesensitive="false" file="@{sbs.log.file}"/>
   207                             <fileset casesensitive="false" file="@{sbs.log.file}"/>
   224                             <metadatafilterset refid="filterset.sbs" />
   208                             <metadatafilterset refid="filterset.sbs" />
   225                         </hlm:sbsmetadatainput>
   209                         </hlm:sbsmetadatainput>
   226                     </hlm:metadatarecord>
   210                     </hlm:metadatarecord>
   227                 </try>
   211                 </try>
   239                                     <metadatafilterset refid="filterset.sbs" />
   223                                     <metadatafilterset refid="filterset.sbs" />
   240                                 </hlm:textmetadatainput>
   224                                 </hlm:textmetadatainput>
   241                             </hlm:metadatarecord>
   225                             </hlm:metadatarecord>
   242                         </then>
   226                         </then>
   243                         <else>
   227                         <else>
   244                             <fail message="failed during raptor log parsing: might be due to invalid xml output from raptor" />
   228                             <loadfile property="sbs.error.output" srcfile="@{sbs.error.output.file}" failonerror="false"/>
       
   229                             <fail message="failed during raptor log parsing: might be due to invalid xml output from raptor ${hlm-sbs.parser.thrown}. ${sbs.error.output}" />
   245                         </else>
   230                         </else>
   246                     </if>
   231                     </if>
   247                 </catch>
   232                 </catch>
   248             </trycatch>
   233             </trycatch>
   249             <fmpp sourceFile="${helium.dir}/tools/common/templates/log/${sbs.scan2.template}"
   234             <fmpp sourceFile="${helium.dir}/tools/common/templates/log/${sbs.scan2.template}"
   251                 <freemarkerLinks expandProperties="yes">
   236                 <freemarkerLinks expandProperties="yes">
   252                     macro: ${helium.dir}/tools/common/templates/macro
   237                     macro: ${helium.dir}/tools/common/templates/macro
   253                 </freemarkerLinks>
   238                 </freemarkerLinks>
   254                 <data expandProperties="yes">
   239                 <data expandProperties="yes">
   255                     dbPath: ${metadata.dbfile}
   240                     dbPath: ${metadata.dbfile}
   256                     doc: xml(@{sbs.stats.file})
   241                     logfilename: @{sbs.log.file}
   257                     whatLogPath: @{sbs.what.log.file}
       
   258                     ant: antProperties()
   242                     ant: antProperties()
   259                 </data>
   243                 </data>
   260             </fmpp>
   244             </fmpp>
   261             <echo message="generating signal" />
   245             <echo message="generating signal" />
   262             <hlm:assertFileExists file="${build.log.dir}/${base.sbs.log}.scan2.html"/>
   246             <hlm:assertFileExists file="${build.log.dir}/${base.sbs.log}.scan2.html"/>