<!--

    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.

    This program and the accompanying materials are made available under the
    terms of the Eclipse Public License v. 2.0, which is available at
    http://www.eclipse.org/legal/epl-2.0.

    This Source Code may also be made available under the following Secondary
    Licenses when the conditions for such availability set forth in the
    Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
    version 2 with the GNU Classpath Exception, which is available at
    https://www.gnu.org/software/classpath/license.html.

    SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0

-->

<property name="report-method" value="report"/>
<property name="target-to-run" value="smoke-test"/>

<target name="pe">
    <echo message="So you are using Platform Edition"/>
    <property name="execution.mode" value="pe"/>
    <property name="pe" value="Platform Edition"/>
    <property file="${env.APS_HOME}/devtests/jdbc/config/pe-config.properties"/>
    <antcall target="print-props"/>
</target>

<target name="das">
    <echo message="So you are using Standard Edition"/>
    <property name="execution.mode" value="pe"/>
    <property file="${env.APS_HOME}/devtests/jdbc/config/das-config.properties"/>
    <antcall target="print-props"/>
</target>

<target name="ee" depends="ee-common">
    <echo message="So you are using Enterprise Edition"/>
    <property name="execution.mode" value="ee"/>
    <property name="ee" value="Enterprise Edition"/>
    <property name="ee-prefix" value="eeconfig/ee-"/>
    <property file="${env.APS_HOME}/devtests/jdbc/config/ee-config.properties"/>
    <setproxy proxyhost="webcache" proxyport="8080"/>
    <loadfile property="target-server-port" srcFile="${admin.domain.dir}/${admin.domain}/config/glassfish-acc.xml"/>
    <condition property="orbPortSet" value="true">
        <contains string="${target-server-port}" substring="33700"/>
    </condition>
    <condition property="cluster" value="true">
    <contains string="${install.type}" substring="cluster"/>
    </condition>
    <antcall target="change-orb-port"/>
    <antcall target="print-props"/>
</target>

<target name="change-orb-port" unless="orbPortSet">
    <echo message="changing orb port from the default [3700] to ${orb.port}"/>
    <replace file="${admin.domain.dir}/${admin.domain}/config/glassfish-acc.xml" token="3700" value="${orb.port}"/>
</target>

<target name="standalone" depends="ee">
    <property name="appserver.instance.name" value="${server.instance.name}"/>
</target>

<target name="print-props">
    <echo message="admin.user=${admin.user}"/>
    <echo message="admin.port=${admin.port}"/>
    <echo message="admin.domain=${admin.domain}"/>
    <echo message="appserver.instance.name=${appserver.instance.name}"/>
</target>

<!-- clean -->
<target name="clean-classes-common" depends="init-common">
        <delete dir="${build.classes.dir}" failonerror="false"/>
</target>

<target name="clean-jars-common" depends="init-common">
        <delete dir="${assemble.dir}" failonerror="false"/>
</target>

<target name="clean-common" depends="init-common">
    <antcall target="clean-classes-common"/>
    <antcall target="clean-jars-common"/>
</target>

<target name="cleanWS" depends="init-common">
    <echo message="cleaning all *.output, *.log and RepRunConf.txt files..."/>
    <delete dir="${env.APS_HOME}/build" failonerror="false"/>
    <delete failonerror="false">
        <fileset dir="${env.APS_HOME}"
            includes="**/*results*.*ml,
            **/*.output,
            **/*.log,
            **/RepRunConf.txt"/>
    </delete>
</target>

<target name="cleanAS" depends="init-common">
    <echo message="deleting domain[ ${admin.domain} ].."/>
    <antcall target="delete-domain-common"/>
    <echo message="creating domain[ ${admin.domain} ].."/>
    <antcall target="create-domain-common"/>
</target>

<!--  compile  -->
<target name="compile-common" depends="init-common">
        <antcall target="compile-common-as"/>
        <antcall target="compile-common-as80"/>
</target>

<target name="compile-common-as" depends="init-common" unless="AS80">
    <mkdir dir="${build.classes.dir}"/>
    <echo message="sqe-common.xml: Compiling test source files"/>
    <javac srcdir="${src}"
        source="1.4"
        destdir="${build.classes.dir}"
        classpath="${s1astest.classpath}"
        debug="on"
        failonerror="false"/>
</target>

<target name="compile-common-as80" depends="init-common" if="AS80">
    <mkdir dir="${build.classes.dir}"/>
    <echo message="sqe-common.xml: Compiling test source files with 8.0 PE"/>
    <javac srcdir="${src}"
        source="1.4"
        destdir="${build.classes.dir}"
        classpath="${s1as80test.classpath}"
        debug="on"
        failonerror="false"/>
</target>


<!-- war targets -->
<target name="webclient-war-common" if="hasWebclient" depends="init-common">
        <mkdir dir="${assemble.dir}"/>
        <antcall target="package-war-common">
                <!--param name="war.classes" value="${build.classes.dir}"/-->
                <param name="war.file" value="${assemble.dir}/${appname}-web.war"/>
        </antcall>
</target>

<target name="package-war-without-sun.xml" unless="sun-web.xml">
        <echo message="This war does not contain sun-web.xml"/>
        <echo message="my build classes dir is:${build.classes.dir}"/>
        <delete file="${war.file}"/>
        <mkdir dir="${build.classes.dir}/WEB-INF"/>
        <copy file="${web.xml}"
                tofile="${build.classes.dir}/WEB-INF/web.xml"/>
        <echo message="Creating war file ${war.file}"/>
        <!--jar jarfile="${war.file}" basedir="${war.classes}" update="true"-->
        <jar jarfile="${war.file}" basedir="${build.classes.dir}"
                update="true" includes ="${webclient.war.classes}">
                <fileset dir="${basedir}/web" casesensitive="yes">
                        <include name="*.html"/>
                        <include name="*.jsp"/>
                        <include name="*.gif"/>
                        <include name="*.do"/>
                        <exclude name="**/*.java"/>
                </fileset>
                <fileset dir="${build.classes.dir}" casesensitive="true">
                        <include name="WEB-INF/web.xml"/>
                </fileset>
        </jar>
        <echo message="created war file ${war.file}"/>
        <delete dir="${build.classes.dir}/WEB-INF" failonerror="false"/>
        <echo message="my webclient war classes are:${webclient.war.classes}"/>
</target>

<target name="package-war-common">
    <antcall target="package-war-with-sun.xml"/>
    <antcall target="package-war-without-sun.xml"/>
</target>

<target name="package-war-with-sun.xml" if="sun-web.xml">
        <echo message="my build classes dir is:${build.classes.dir}"/>
        <delete file="${war.file}"/>
        <mkdir dir="${build.classes.dir}/tmp"/>
        <mkdir dir="${build.classes.dir}/tmp/WEB-INF"/>
        <mkdir dir="${build.classes.dir}/tmp/WEB-INF/classes"/>
        <copy file="${sun-web.xml}"
                tofile="${build.classes.dir}/tmp/WEB-INF/sun-web.xml"
                failonerror="false"/>
        <copy file="${webservices.xml}"
                tofile="${build.classes.dir}/tmp/WEB-INF/webservices.xml"
                failonerror="false"/>
        <copy file="${mappingfile.location}/${mappingfile.name}"
                tofile="${build.classes.dir}/tmp/${mappingfile.name}"
                failonerror="false"/>
        <copy file="${wsdlfile.location}/${wsdlfile.name}"
                tofile="${build.classes.dir}/tmp/WEB-INF/wsdl/${wsdlfile.name}"
                failonerror="false"/>
        <copy file="${web.xml}"
                tofile="${build.classes.dir}/tmp/WEB-INF/web.xml"/>
        <copy todir="${build.classes.dir}/tmp/WEB-INF/classes">
                <fileset dir="${build.classes.dir}">
                        <include name="${war.classes}"/>
                </fileset>
        </copy>
        <echo message="Creating war file ${war.file}"/>
        <jar jarfile="${war.file}" update="true">
                <fileset dir="${build.classes.dir}/tmp" casesensitive="yes">
                        <include name="**/*class*"/>
                </fileset>
                <fileset dir="${basedir}/web" casesensitive="yes">
                        <include name="**/*.html"/>
                        <include name="**/*.jsp"/>
                        <include name="**/*.gif"/>
                        <include name="**/*.do"/>
                        <exclude name="**/*.java,**/*.xml,**/*.properties"/>
                </fileset>
                <fileset dir="${build.classes.dir}/tmp/" casesensitive="true">
                        <include name="WEB-INF/web.xml"/>
                        <include name="WEB-INF/sun-web.xml"/>
                        <include name="WEB-INF/webservices.xml"/>
                        <include name="WEB-INF/wsdl/${wsdlfile.name}"/>
                        <include name="${mappingfile.name}"/>
                </fileset>
        </jar>
        <echo message="created war file ${war.file}"/>
        <delete dir="${build.classes.dir}/tmp/WEB-INF" failonerror="false"/>
        <echo message="my webclient war classes are:${webclient.war.classes}"/>
</target>

<!-- ===== package ejb jar ===== -->
<target name="package-ejbjar-common">
        <mkdir dir="${assemble.dir}"/>
    <delete file="${ejb.jar}" failonerror="false"/>
    <echo message="sqe-common.xml: Generating ejb-jar inside build directory"/>
    <mkdir dir="${build.classes.dir}/META-INF"/>
    <mkdir dir="${build.classes.dir}/META-INF/wsdl"/>
    <copy file="${ejb-jar.xml}" tofile="${build.classes.dir}/META-INF/ejb-jar.xml"/>
    <copy file="${sun-ejb-jar.xml}" tofile="${build.classes.dir}/META-INF/sun-ejb-jar.xml"/>

    <!-- optional files -->
    <copy file="${sun-cmp-mappings.xml}"
        tofile="${build.classes.dir}/META-INF/sun-cmp-mappings.xml"
                failonerror="false"/>
   <copy file="${dbschema}" todir="${build.classes.dir}" failonerror="false"/>
   <copy file="${mapping.xml}" todir="${build.classes.dir}/META-INF" failonerror="false"/>
   <copy file="${webservices.xml}" todir="${build.classes.dir}/META-INF" failonerror="false"/>
   <copy file="${webservices.wsdl}" todir="${build.classes.dir}/META-INF/wsdl" failonerror="false"/>

   <!-- make a jar  -->
   <jar jarfile="${ejb.jar}" basedir="${ejbjar.files}" update="true"
        includes ="${ejbjar.classes}">
        <metainf dir="${build.classes.dir}/META-INF">
            <include name="**/*.xml"/>
            <include name="**/*.wsdl"/>
        </metainf>
   </jar>

   <delete dir="${build.classes.dir}/META-INF" failonerror="false"/>
</target>
<!-- ========================================= -->

<!-- appclient package -->
<target name="package-appclientjar-common">
    <mkdir dir="${assemble.dir}"/>
    <delete file="${appclient.jar}" failonerror="false"/>
    <echo message="sqe-common.xml: Generating appclient-jar in build dir"/>
    <mkdir dir="${build.classes.dir}/META-INF"/>
    <copy file="${application-client.xml}"
                tofile="${build.classes.dir}/META-INF/application-client.xml"/>
    <copy file="${sun-application-client.xml}"
                tofile="${build.classes.dir}/META-INF/sun-application-client.xml"/>
    <jar jarfile="${appclient.jar}" basedir="${appclientjar.files}"
        update="true" includes ="${appclientjar.classes}"
        manifest="./client/MANIFEST.MF">
            <metainf dir="${build.classes.dir}/META-INF">
                <include name="application-client.xml"/>
                <include name="sun-application-client.xml"/>
                  </metainf>
        </jar>
        <delete dir="${build.classes.dir}/META-INF" failonerror="false"/>
</target>

<!--  ejb jar packager -->
<target name="ejb-jar-common" depends="init-common">
    <mkdir dir="${assemble.dir}"/>
    <antcall target="package-ejbjar-common">
        <param name="ejbjar.files" value="${build.classes.dir}"/>
        <param name="ejb.jar" value="${assemble.dir}/${appname}-ejb.jar"/>
    </antcall>
</target>

<!--  appclient jar create -->
<target name="appclient-jar-common" depends="init-common">
    <mkdir dir="${assemble.dir}"/>
    <antcall target="package-appclientjar-common">
        <param name="appclientjar.files"
            value="${build.classes.dir}"/>
        <param name="appclient.jar"
            value="${assemble.dir}/${appname}-client.jar"/>
    </antcall>
</target>

<!--  ear -->
<target name="build-ear-common" depends="fixFiles,ejb-jar-common,appclient-jar-common,webclient-war-common">
    <delete file="${assemble.dir}/${appname}.ear"/>
    <mkdir dir="${assemble.dir}"/>
    <mkdir dir="${build.classes.dir}/META-INF"/>
    <copy file="${sun-application.xml}"
        tofile="${build.classes.dir}/META-INF/sun-application.xml"
        failonerror="false"/>
    <ear earfile="${assemble.dir}/${appname}App.ear"
        appxml="${application.xml}">
        <fileset dir="${assemble.dir}">
            <include name="*.jar"/>
            <include name="*.war"/>
        </fileset>
        <fileset dir="${build.classes.dir}">
            <include name="META-INF/sun-application.xml"/>
        </fileset>
        <fileset dir="${env.APS_HOME}/lib" includes="reporter.jar"/>
    </ear>
</target>

<!--  ear (Without dependencies) -->
<target name="ear-common" depends="fixFiles,init-common">
    <delete file="${assemble.dir}/${appname}.ear"/>
    <mkdir dir="${assemble.dir}"/>
    <mkdir dir="${build.classes.dir}/META-INF"/>
    <copy file="${sun-application.xml}"
        tofile="${build.classes.dir}/META-INF/sun-application.xml"
        failonerror="false"/>
    <ear earfile="${assemble.dir}/${appname}App.ear"
        appxml="${application.xml}">
        <fileset dir="${assemble.dir}">
            <include name="*.jar"/>
            <include name="*.war"/>
        </fileset>
        <fileset dir="${build.classes.dir}">
            <include name="META-INF/sun-application.xml"/>
        </fileset>
        <fileset dir="${env.APS_HOME}/lib" includes="reporter.jar"/>
    </ear>
</target>

<!--  asadmin common target -->
<target name="asadmin-common">
  <echo message="Doing admin task ${admin.command}"/>
    <exec executable="${ASADMIN}" failonerror="false">
        <arg line="${admin.command} ${as.props} ${operand.props}" />
    </exec>
</target>

<!--  reconfig the AppServ  -->
<target name="reconfig-common" depends="init-common">
        <echo message="Reconfig has been deprecated. No Action will be taken by the Appserver !!"/>
</target>


<!--  create/delete user in file realm -->
<target name="create-user-common" depends="init-common">
    <echo message="Creating user:${user},pwd:${password} in gp:${groups}"/>
    <exec executable="${ASADMIN}" failonerror="false">
        <arg line="create-file-user"/>
        <arg line="${as.props}"/>
        <arg line="--groups ${groups}"/>
        <arg line="--userpassword ${password}"/>
        <arg line="--authrealmname ${authrealmname}"/>
        <arg line="--target ${appserver.instance.name}"/>
        <arg line="${user}"/>
    </exec>
</target>

<target name="delete-user-common" depends="init-common">
<echo message="Deleting user ${user} in file realm"/>
    <exec executable="${ASADMIN}" failonerror="false">
        <arg line="delete-file-user"/>
        <arg line="${as.props}"/>
        <arg line="--authrealmname ${authrealmname}"/>
        <arg line="--target ${appserver.instance.name}"/>
        <arg line="${user}"/>
    </exec>
</target>

<!--  create JDBC connection pool  -->
<target name="create-jdbc-connpool-common" depends="init-common">
    <exec executable="${ASADMIN}" failonerror="false">
        <arg line="create-jdbc-connection-pool"/>
        <arg line="--datasourceclassname ${db.class}"/>
        <arg line="--restype ${jdbc.resource.type}"/>
        <arg line="--target ${appserver.instance.name}"/>
        <arg line="${as.props}"/>
        <arg line="${jdbc.conpool.name}"/>
    </exec>
    <antcall target="set-pool-props"/>
</target>

<target name="set-pool-props" depends="init-common">

  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.User=${db.user}"/>
  </exec>


  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.Password=${db.pwd}"/>
  </exec>

  <antcall target="set-${db.type}-connpool-props"/>
</target>

<target name="set-derby-connpool-props">
    <exec executable="${ASADMIN}" failonerror="false">
      <arg line="set"/>
      <arg line="${as.props}"/>
      <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.User=${db.user}"/>
    </exec>
    <exec executable="${ASADMIN}" failonerror="false">
      <arg line="set"/>
      <arg line="${as.props}"/>
      <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.Password=${db.pwd}"/>
    </exec>
    <exec executable="${ASADMIN}" failonerror="false">
      <arg line="set"/>
      <arg line="${as.props}"/>
      <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.driverType=4"/>
    </exec>
    <exec executable="${ASADMIN}" failonerror="false">
      <arg line="set"/>
      <arg line="${as.props}"/>
      <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.portNumber=${db.port}"/>
    </exec>
    <exec executable="${ASADMIN}" failonerror="false">
      <arg line="set"/>
      <arg line="${as.props}"/>
      <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.dataBaseName=${db.name}"/>
    </exec>
    <exec executable="${ASADMIN}" failonerror="false">
      <arg line="set"/>
      <arg line="${as.props}"/>
      <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.retrieveMessagesFromServerOnGetMessage=true"/>
    </exec>
    <exec executable="${ASADMIN}" failonerror="false">
      <arg line="set"/>
      <arg line="${as.props}"/>
      <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.create=true"/>
    </exec>
    <exec executable="${ASADMIN}" failonerror="false">
      <arg line="set"/>
      <arg line="${as.props}"/>
      <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.serverName=${db.host}"/>
    </exec>
</target>

<target name="set-non-db2-type2-connpool-props">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.serverName=${db.host}"/>
  </exec>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.port=${db.port}"/>
  </exec>
</target>

<target name="set-sybase-connpool-props">
  <antcall target="set-datadirect-pool-props"/>
  <antcall target="set-sybasej-pool-props"/>
  <antcall target="set-sybase-connpool-props-common"/>
</target>

<target name="set-microsoft-connpool-props">
  <antcall target="set-datadirect-pool-props"/>
  <antcall target="set-microsoft-connpool-props-common"/>
</target>

<target name="set-sybase-connpool-props-common" unless="datadirect">
  <antcall target="set-non-db2-type2-connpool-props"/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.DatabaseName=${db.name}" />
  </exec>
</target>

<target name="set-oracle-connpool-props">
    <antcall target="set-datadirect-pool-props"/>
    <antcall target="set-oracle-connpool-props-common"/>
</target>

<target name="set-oracle-connpool-props-common" unless="datadirect">
  <antcall target="set-non-db2-type2-connpool-props"/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.serviceName=${db.name}"/>
  </exec>
  <!--- thin driver property requires this property name to be set. -->
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.url=${db.url}" />
  </exec>
  <!-- inet driver property added for enabling CLOB's in oracle Deepa
Singh 01/27/04 -->
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.streamstolob=true"/>
  </exec>
</target>

<target name="set-sybasej-pool-props" if="jconnect">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.portNumber=${db.port}"/>
  </exec>
</target>


<target name="set-datadirect-pool-props" if="datadirect">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.serverName=${db.host}"/>
  </exec>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.portNumber=${db.port}"/>
  </exec>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.user=${db.user}"/>
  </exec>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.password=${db.pwd}"/>
  </exec>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.SID=${db.name}"/>
  </exec>
</target>

<target name="set-pointbase-connpool-props">
  <antcall target="set-non-db2-type2-connpool-props"/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.DatabaseName=${db.url}"/>
  </exec>
</target>

<target name="set-db2-connpool-props">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.driverType=2"/>
  </exec>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.databaseName=${db.name}"/>
  </exec>
</target>

<target name="set-microsoft-connpool-props-common">
  <antcall target="set-non-db2-type2-connpool-props"/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.portNumber=${db.port}" />
  </exec>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="set"/>
    <arg line="${as.props}"/>
    <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.databaseName=${db.name}" />
  </exec>
</target>

<!--  create XA JDBC connection pool  -->
<target name="create-jdbc-xa-connpool-common" depends="init-common">
    <exec executable="${ASADMIN}" failonerror="false">
        <arg line="create-jdbc-connection-pool"/>
        <arg line="${as.props}"/>
        <arg line="--datasourceclassname ${db.xaclass}"/>
        <arg line="--restype ${jdbc.xaresource.type}"/>
        <arg line="--target ${appserver.instance.name}"/>
        <arg line="${jdbc.conpool.name}"/>
    </exec>
    <exec executable="${ASADMIN}" failonerror="false">
      <arg line="set"/>
      <arg line="${as.props}"/>
      <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.User=${db.user}"/>
    </exec>
    <exec executable="${ASADMIN}" failonerror="false">
      <arg line="set"/>
      <arg line="${as.props}"/>
      <arg line="domain.resources.jdbc-connection-pool.${jdbc.conpool.name}.property.Password=${db.pwd}"/>
    </exec>

    <antcall target="set-${db.type}-connpool-props"/>
</target>

<!--  delete JDBC connection-pool  -->
<target name="delete-jdbc-connpool-common" depends="init-common">
    <exec executable="${ASADMIN}" failonerror="false">
        <arg line="delete-jdbc-connection-pool"/>
        <arg line="${as.props}"/>
        <arg line="--cascade=true"/>
        <arg line="--target ${appserver.instance.name}"/>
        <arg line="${jdbc.conpool.name}"/>
    </exec>
    <echo message="cmd executed for ${appserver.instance.name}"/>
</target>

<!--  create/delete JDBC resource  -->
<target name="create-jdbc-resource-common" depends="init-common">
    <exec executable="${ASADMIN}" failonerror="false">
        <arg line="create-jdbc-resource"/>
        <arg line="${as.props}"/>
        <arg line="--connectionpoolid ${jdbc.conpool.name}"/>
        <arg line="--target ${appserver.instance.name}"/>
        <arg line="${jdbc.resource.name}"/>
    </exec>
    <echo message="cmd executed for ${appserver.instance.name}"/>
</target>

<target name="delete-jdbc-resource-common" depends="init-common">
    <exec executable="${ASADMIN}" failonerror="false">
        <arg line="delete-jdbc-resource"/>
        <arg line="${as.props}"/>
        <arg line="--target ${appserver.instance.name}"/>
        <arg line="${jdbc.resource.name}"/>
    </exec>
    <echo message="cmd executed for ${appserver.instance.name}"/>
</target>

<!--  deploy/undeploy JDBC resources  -->
<target name="deploy-jdbc-common" depends="init-common">
    <antcall target="create-jdbc-connpool-common" />
    <antcall target="create-jdbc-resource-common" />
    <!-- <antcall target="reconfig-common" /> -->
</target>

<target name="undeploy-jdbc-common" depends="init-common">
  <antcall target="delete-jdbc-resource-common" />
  <antcall target="delete-jdbc-connpool-common" />
</target>

<!--  create persistence resource  -->
<target name="create-persistence-resource-common" depends="init-common">
    <exec executable="${ASADMIN}" failonerror="false">
        <arg line="create-persistence-resource"/>
        <arg line="${as.props}"/>
        <arg line="--target ${appserver.instance.name}"/>
        <arg line="${pm.resource.name}"/>
    </exec>
    <antcall target="set-pmf-props"/>
    <echo message="cmd executed for ${appserver.instance.name}"/>
</target>

<target name="set-pmf-props">
    <exec executable="${ASADMIN}" failonerror="false">
        <arg line="set"/>
        <arg line="${as.props}"/>
        <arg line="domain.resources.persistence-manager-factory-resource.${pm.resource.name}.factory_class=${pm.factory.class}"/>
    </exec>
    <exec executable="${ASADMIN}" failonerror="false">
        <arg line="set"/>
        <arg line="${as.props}"/>
        <arg line="domain.resources.persistence-manager-factory-resource.${pm.resource.name}.jdbc_resource_jndi_name=${jdbc.resource.name}"/>
    </exec>
<antcall target="create-pmf-resource-reference"/>
</target>

<target name="create-pmf-resource-reference" if="ee">
<exec executable="${ASADMIN}" failonerror="false">
        <arg line="create-resource-ref"/>
        <arg line="--user ${admin.user}"/>
        <arg line="--password ${admin.password}"/>
        <arg line="--host ${admin.host}"/>
        <arg line="--port ${admin.port}"/>
        <arg line="--target server"/>
        <arg line="${pm.resource.name}"/>
</exec>
<exec executable="${ASADMIN}" failonerror="false">
        <arg line="create-resource-ref"/>
        <arg line="--user ${admin.user}"/>
        <arg line="--password ${admin.password}"/>
        <arg line="--host ${admin.host}"/>
        <arg line="--port ${admin.port}"/>
        <arg line="--target server"/>
        <arg line="${jdbc.resource.name}"/>
</exec>
</target>

<!--  delete persistence resource  -->
<target name="delete-persistence-resource-common" depends="init-common">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="delete-persistence-resource"/>
    <arg line="${as.props}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${pm.resource.name}"/>
  </exec>
</target>

<!-- Create all tables -->
<target name="create-alltables" depends="init-common">
    <echo message="Create all tables...executing all create_xxx.sql files"/>
    <antcall target="execute-sql-common">
        <param name="sql.file.type" value="create"/>
    </antcall>
</target>

<!-- drop all tables as part of cleanup -->
<target name="drop-alltables" depends="init-common">
   <echo message="CleanDB:Finding all tables and drop tables..."/>
   <antcall target="execute-sql-common-output">
        <param name="sql.file.type" value="alltables"/>
   </antcall>
   <replace file="drop_alltables_${db.type}.sql" token="," value=" "/>
   <antcall target="execute-sql-common">
        <param name="sql.file.type" value="drop_alltables"/>
   </antcall>

</target>

<target name="execute-sql-common-output" depends="init-common" >
  <echo message="***** LD_LIBRARY_PATH=${env.LD_LIBRARY_PATH}  *****"/>
  <sql
    driver="${db.driver}"
    url="${db.url}"
    userid="${db.user}"
    password="${db.pwd}"
    onerror="continue"
    print="yes"
    showheaders="false"
    output="drop_${sql.file.type}_${db.type}.sql"
    classpath="${s1astest.classpath}">
    <fileset dir=".">
      <include name="**/${sql.file.type}_${db.type}.sql"/>
    </fileset>
  </sql>
</target>

<!-- drop all tables as part of cleanup -->
<target name="drop-sqe-alltables" depends="init-common">
   <echo message="Droping all tables...executing all drop_xxx.sql
files"/>
   <antcall target="execute-sql-common">
        <param name="sql.file.type" value="drop"/>
   </antcall>
</target>

<target name="execute-sql-common" depends="init-common" >
  <sql
    driver="${db.driver}"
    url="${db.url}"
    userid="${db.user}"
    password="${db.pwd}"
    src="${sql.file}"
    onerror="continue"
    print="yes"
    classpath="${s1astest.classpath}"/>
</target>

<target name="capture-schema-common" depends="init-common">
    <echo message="Make sure that driver classes are in CLASSPATH env variable"/>
    <exec executable="${CAPTURESCHEMA}" failonerror="false">
        <arg line="-dburl"/>
        <arg line="${db.url}"/>
        <arg line="-username"/>
        <arg line="${db.user}"/>
        <arg line="-password"/>
        <arg line="${db.pwd}"/>
        <arg line="-driver"/>
        <arg line="${db.class}"/>
        <arg line="${tables}"/>
        <arg line="-out"/>
        <arg line="${output.dbschema}"/>
    </exec>
</target>

<!--  create/delete javamail resources  -->
<target name="create-javamail-resource-common">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="create-javamail-resource"/>
    <arg line="--user ${admin.user}"/>
    <arg line="--password ${admin.password}"/>
    <arg line="--host ${admin.host}"/>
    <arg line="--port ${admin.port}"/>
    <arg line="--mailhost ${mailhost}"/>
    <arg line="--mailuser ${mailuser}"/>
    <arg line="--fromaddress ${fromaddress}"/>
    <arg line="--storeprotocol imap"/>
    <arg line="--storeprotocolclass com.sun.mail.imap.IMAPStore"/>
    <arg line="--transprotocol smtp"/>
    <arg line="--transprotocolclass com.sun.mail.smtp.SMTPTransport"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${javamail.resource.name}"/>
  </exec>
<echo message="javamail successfully create for ${appserver.instance.name}"/>
</target>

<target name="delete-javamail-resource-common">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="delete-javamail-resource"/>
    <arg line="${as.props}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${javamail.resource.name}"/>
  </exec>
</target>

<!--  create/remove JVM options (used for connectors)   -->
<target name="create-JVM-options" depends="init-common">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="create-jvm-options"/>
    <arg line="${as.props}"/>
    <arg line=":-Djdbc.drivers=${db.driver}"/>
  </exec>
</target>

<target name="remove-JVM-options" depends="init-common">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="delete-jvm-options"/>
    <arg line="${as.props}"/>
    <arg line=":-Djdbc.drivers=${db.driver}"/>
  </exec>
  <!-- <antcall target="reconfig-common"/> -->
</target>

<!--  set classpath-suffix            -->
<target name="set-classpath-suffix" depends="init-common">
   <antcall target="set-win-classpath-suffix"/>
   <antcall target="set-unix-classpath-suffix"/>
</target>

<target name="set-unix-classpath-suffix"
        depends="init-common" if="isUnix">
        <!-- Get classpath-suffix -->
        <exec executable="${ASADMIN}" failonerror="false"
          output="${classpathsuffix.file}">
          <arg line="get"/>
          <arg line="${as.props}"/>
          <arg line="${appserver.config.name}.java-config.classpath_suffix"/>
        </exec>

        <!-- load as property -->
        <loadproperties srcFile="${classpathsuffix.file}"/>

        <!-- set the classpath-suffix -->
        <exec executable="${ASADMIN}" failonerror="false">
          <arg line="set"/>
          <arg line="${as.props}"/>
          <arg line="&quot;${appserver.config.name}.java-config.classpath_suffix=${server-config.java-config.classpath-suffix}${path.separator}${env.APS_HOME}/${db.unixdriverpath}&quot;"/>
        </exec>
        <!-- <antcall target="reconfig-common"/> -->
</target>

<target name="set-win-classpath-suffix"
        depends="init-common" if="isWindows">

        <!-- Get classpath-suffix -->
        <exec executable="${ASADMIN}" failonerror="false"
          output="${classpathsuffix.file}">
          <arg line="get"/>
          <arg line="${as.props}"/>
          <arg line="${appserver.config.name}.java-config.classpath_suffix"/>
        </exec>
        <replace file="${classpathsuffix.file}" token=":SunAppServer" value=":/Sun/AppServer"/>

        <!-- load as property -->
        <loadproperties srcFile="${classpathsuffix.file}"/>

        <!-- set the classpath-suffix -->
        <exec executable="${ASADMIN}" failonerror="false">
          <arg line="set"/>
          <arg line="${as.props}"/>
          <arg line="&quot;${appserver.config.name}.java-config.classpath_suffix=${server-config.java-config.classpath-suffix}${classpathsuffix.file}${path.separator}${env.SPS_HOME}/${db.windriverpath}&quot;"/>
        </exec>
        <!-- <antcall target="reconfig-common"/> -->
</target>

<!--  create/delete Connector connection pool  -->
<target name="create-connector-connpool-common"
        depends="init-common, create-connector-connpool"/>

<target name="create-connector-connpool" depends="init-common">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="create-connector-connection-pool"/>
    <arg line="${as.props}"/>
    <arg line="--raname ${ra.name}"/>
    <arg line="--connectiondefinition ${connection.defname}"/>
    <arg line="--property ConnectionURL=${connector.url}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${connector.conpool.name}"/>
  </exec>
</target>

<target name="delete-connector-connpool-common" depends="init-common">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="delete-connector-connection-pool"/>
    <arg line="${as.props}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${connector.conpool.name}"/>
  </exec>
</target>

<!--  create/delete Connector resource  -->
<target name="create-connector-resource-common" depends="init-common">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="create-connector-resource"/>
    <arg line="${as.props}"/>
    <arg line="--poolname ${connector.conpool.name}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${connector.jndi.name}"/>
  </exec>
</target>

<target name="delete-connector-resource-common" depends="init-common">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="delete-connector-resource"/>
    <arg line="${as.props}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${connector.jndi.name}"/>
  </exec>
</target>

<!-- create/delete JMS Queues      -->
<target name="create-jms-queue-common" depends="init-common">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="create-jms-resource"/>
    <arg line="${as.props}"/>
    <arg line="--restype ${jms.resource.type}"/>
    <arg line="--property ${queue.property.name}=${queue.property.value}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${jms.resource.name}"/>
  </exec>
  <echo message="cmd executed for ${appserver.instance.name}"/>
</target>

<target name="delete-jms-queue-common" depends="init-common">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="delete-jms-resource"/>
    <arg line="${as.props}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${jms.resource.name}"/>
  </exec>
</target>

<!-- create/delete JMS Connection -->
<target name="create-jms-connection-common" depends="init-common">
  <echo message="Creating JMS con. factory with name ${jms.factory.name}"/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="create-jms-resource"/>
    <arg line="--restype ${jms.factory.type}"/>
    <arg line="${as.props}"/>
    <arg line="${imq.client.id}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${jms.factory.name}"/>
  </exec>
  <echo message="cmd executed for ${appserver.instance.name}"/>
</target>

<target name="delete-jms-connection-common" depends="init-common">
  <echo message="Delete JMS con. factory with name ${jms.factory.name}"/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="delete-jms-resource"/>
    <arg line="${as.props}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${jms.factory.name}"/>
  </exec>
  <echo message="cmd executed for ${appserver.instance.name}"/>
</target>

<!-- create/delete JMS Destination Resource      -->

<target name="create-jms-resource-common" depends="init-common, check-jms-type,
create-jms-resource-queue-common, create-jms-resource-topic-common">
</target>
<target name="check-jms-type">
    <condition property="queue" value="true">
        <contains string="${dest.type}" substring="queue" casesensitive="false"/>
    </condition>
    <condition property="topic" value="true">
        <contains string="${dest.type}" substring="topic" casesensitive="false"/>
    </condition>
</target>

<target name="create-jms-resource-queue-common" if="queue">
  <echo message="Creating JMS resource with name
${jms.resource.name}"/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="create-jmsdest"/>
    <arg line="--desttype ${dest.type}"/>
    <arg line="${as.props}"/>
    <arg line="--property maxNumActiveConsumers=${activeconsumer.maxnum}"/>
    <arg line="${dest.name}"/>
  </exec>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="create-jms-resource"/>
    <arg line="--restype ${jms.resource.type}"/>
    <arg line="--property imqDestinationName=${dest.name}"/>
    <arg line="${as.props}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${jms.resource.name}"/>
  </exec>
</target>


<target name="create-jms-resource-topic-common" if="topic">
  <echo message="Creating JMS resource with name
${jms.resource.name}"/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="create-jmsdest"/>
    <arg line="--desttype ${dest.type}"/>
    <arg line="${as.props}"/>
    <arg line="${dest.name}"/>
  </exec>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="create-jms-resource"/>
    <arg line="--restype ${jms.resource.type}"/>
    <arg line="--property imqDestinationName=${dest.name}"/>
    <arg line="${as.props}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${jms.resource.name}"/>
  </exec>
</target>

<target name="delete-jms-resource-common" depends="init-common">
  <echo message="Delete JMS resource with name ${jms.resource.name}"/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="delete-jms-resource"/>
    <arg line="${as.props}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${jms.resource.name}"/>
  </exec>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="delete-jmsdest"/>
    <arg line="${as.props}"/>
    <arg line="--desttype ${dest.type} ${dest.name}"/>
  </exec>
</target>

<!--  deploy/undeploy JMS resources  -->
<target name="deploy-jms-common" depends="init-common">
  <antcall target="create-jms-connection-common" />
  <antcall target="create-jms-resource-common" />
  <antcall target="create-jms-queue-common" />
  <!-- <antcall target="reconfig-common" /> -->
</target>

<target name="undeploy-jms-common" depends="init-common">
  <antcall target="delete-jms-connection-common" />
  <antcall target="delete-jms-resource-common" />
  <antcall target="delete-jms-queue-common" />
  <!-- <antcall target="reconfig-common" /> -->
</target>

<!--  deploy the applications in AppServ  -->
<target name="deploy-common" depends="init-common">
    <antcall target="deploy-common-${execution.mode}"/>
</target>

<target name="deploy-common-pe" depends="init-common">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="deploy"/>
    <arg line="${as.props}"/>
    <arg line="--name ${appname}App"/>
    <arg line="--retrieve ${assemble.dir}"/>
    <arg line="${assemble.dir}/${appname}App.ear"/>
  </exec>
</target>

<target name="deploy-common-ee" depends="init-common">
    <echo message="So you are using Enterprise Version eh ?"/>
<property name="deployed.app" value="${assemble.dir}/${appname}App.ear"/>

  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="deploy"/>
    <arg line="--user ${admin.user}"/>
    <arg line="--password ${admin.password}"/>
    <arg line="--host ${admin.host}"/>
    <arg line="--port ${admin.port}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="--type ${apptype}"/>
    <arg line="--retrieve ${assemble.dir}"/>
<!-- deployed.app defaults to ${assemble.dir}/${appname}App.ear defined in properties.xml-->
    <arg line="${deployed.app}"/>
  </exec>
  <echo message="Deployment on target server ${appserver.instance.name}
successful"/>

</target>


<!-- start cmp deploy/undeploy targets -->
    <!--  deploy the applications in java2DB for createtable  -->
        <target name="deploy-common-createtable" depends="init-common">
          <echo message="using java2DB targets"/>
          <exec executable="${ASADMIN}" failonerror="false">
            <arg line="deploy"/>
            <arg line="${as.props}"/>
            <arg line="--name ${appname}App"/>
            <arg line="--retrieve ${assemble.dir}"/>
            <arg line="--target ${appserver.instance.name}"/>
            <arg line="--dbvendorname ${db.type}"/>
            <arg line="--createtables=true"/>
            <arg line="--uniquetablenames=true"/>
            <arg line="${assemble.dir}/${appname}App.ear"/>
          </exec>
        </target>

    <!--  deploy the applications in java2DB for dropandcreatetable  -->
        <target name="deploy-common-dropcreatetable" depends="init-common">
          <echo message="using java2DB targets"/>
          <exec executable="${ASADMIN}" failonerror="false">
            <arg line="deploy"/>
            <arg line="${as.props}"/>
            <arg line="--name ${appname}App"/>
            <arg line="--retrieve ${assemble.dir}"/>
            <arg line="--dbvendorname ${db.type}"/>
            <arg line="--dropandcreatetables=true"/>
            <arg line="--uniquetablenames=true"/>
            <arg line="--target ${appserver.instance.name}"/>
            <arg line="${assemble.dir}/${appname}App.ear"/>
          </exec>
        </target>

    <!--  undeploy the applications in java2DB for droptable  -->
        <target name="undeploy-common-droptable" depends="init-common">
          <echo message="using java2DB targets"/>
          <echo message="Undeploying ${appname}."/>
          <exec executable="${ASADMIN}">
            <arg line="undeploy"/>
            <arg line="--user ${admin.user}"/>
            <arg line="--password ${admin.password}"/>
            <arg line="--host ${admin.host}"/>
            <arg line="--port ${admin.port}"/>
            <arg line="--droptables=true"/>
            <arg line="--target ${appserver.instance.name}"/>
            <arg line="${appname}App"/>
          </exec>
        </target>
<!-- end cmp targets -->

<target name="deploy-jsp-common" depends="init-common">
  <echo message="Deploying ${deploy.file}."/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="deploy"/>
    <arg line="${as.props}"/>
    <arg line="--precompiledjsp true"/>
    <arg line="--upload true"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="--retrieve ${assemble.dir}"/>
  </exec>
</target>

<!--  deploy/undeploy module files -->
<!--
    Note: Set "modulefile" param to following values:
        * <archive_name>.<jar|war|rar> ( for deploy-module-common)
        * <archive_name> (for undeploy-module-common)
        * <archive_name> (for runclient-module-common)
-->
<target name="deploy-module-common" depends="init-common">
  <echo message="Deploying ${deployed.module}"/>
<property name="additional.options" value=""/>
<property name="deployed.module" value="${assemble.dir}/${modulefile}"/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="deploy"/>
    <arg line="${as.props}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${additional.options}"/>
    <arg line="--retrieve ${assemble.dir}"/>
    <arg line="${deployed.module}"/>
  </exec>
</target>

<!-- deploy for web module  with retrieve option -->
<target name="deploy-web-module-common" depends="init-common">
  <echo message="Deploying ${deployed.module}"/>
  <property name="additional.options" value=""/>
  <property name="deployed.module" value="${assemble.dir}/${modulefile}"/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="deploy"/>
    <arg line="${as.props}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${additional.options}"/>
    <arg line="${deployed.module}"/>
  </exec>
</target>


<target name="undeploy-module-common" depends="init-common">
  <echo message="Undeploying ${deployed.module}"/>
<property name="additional.options" value=""/>
<property name="deployed.module" value="${assemble.dir}/${modulefile}"/>
  <echo message="Deploying ${module}."/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="undeploy"/>
    <arg line="${as.props}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${deployed.module.name}"/>
  </exec>
</target>

<target name="runclient-module-common" depends="init-common">
    <exec executable="${APPCLIENT}" failonerror="false" timeout="1500000">
    <arg line="-client" />
    <arg line="${assemble.dir}/${modulefile}Client.jar"/>
    <arg line="-name" />
    <arg line="${modulefile}Client"/>
    <arg line="-textauth"/>
    <arg line="-user j2ee"/>
    <arg line="-password j2ee"/>
    <arg line="-xml ${admin.domain.dir}/${admin.domain}/config/glassfish-acc.xml"/>
    <arg line="${additional-params}"/>
  </exec>
<!-- confirming report generation... -->
  <antcall target="checkReporting-common">
      <param name="test.name" value="${appname}"/>
      <param name="test.description" value="${test.description}"/>
  </antcall>
</target>


<!--  deploy/undeploy RAR files -->
<target name="deploy-rar-common" depends="init-common">
  <echo message="Deploying ${rarfile}."/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="deploy"/>
    <arg line="${as.props}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${rarfile}"/>
  </exec>
</target>

<target name="undeploy-rar-common" depends="init-common">
  <echo message="Undeploying ${undeployrar}..."/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="undeploy"/>
    <arg line="${as.props}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${undeployrar}"/>
  </exec>
</target>

<!-- setup RAR config values for all instances in a cluster -->
<target name="create-cluster-rarconfig" depends="init-common">
 <echo message="Setting up config values for cluster ..."/>
   <exec executable="${ASADMIN}" failonerror="false">
   <arg line="create-resource-adapter-config"/>
   <arg line="${as.props}"/>
   <arg line="--target ${appserver.instance.name}"/>
   <arg line="--property ${rarconfig.properties}"/>
   <arg line="${rarname}"/>
   </exec>
</target>

<!-- delete RAR config values for all instances in a cluster -->
<target name="delete-cluster-rarconfig" depends="init-common">
 <echo message="Deleting config values for cluster ..."/>
   <exec executable="${ASADMIN}" failonerror="false">
   <arg line="delete-resource-adapter-config"/>
   <arg line="${as.props}"/>
   <arg line="--target ${appserver.instance.name}"/>
   <arg line="${rarname}"/>
   </exec>
</target>


<!-- setup RAR config values for specific instance of server in a cluster -->
<target name="setup-instance-rarconfig" depends="init-common">
 <echo message="Setting up config values for instance ..."/>
   <exec executable="${ASADMIN}" failonerror="false">
   <arg line="create-system-properties"/>
   <arg line="${as.props}"/>
   <arg line="--target ${appserver.instance.name}"/>
   <arg line="--property ${rarconfig.properties}"/>
   </exec>
</target>

<!--  undeploy the applications in AppServ  -->
<target name="undeploy-common" depends="init-common">
    <echo message="Undeploying ${appname}App on server ${appserver.instance.name} ..."/>
    <exec executable="${ASADMIN}" failonerror="false">
        <arg line="undeploy"/>
        <arg line="${as.props}"/>
        <arg line="--target ${appserver.instance.name}"/>
        <arg line="${appname}App"/>
    </exec>
    <echo message="cmd executed for ${appserver.instance.name}"/>
</target>

<!--  run appclient in AppServ  -->
<target name="runclient-common" depends="init-common">
  <echo message="Executing appclient at ${basedir}"/>
  <exec executable="${APPCLIENT}" failonerror="false" timeout="1500000">
    <arg line="-client" />
    <arg line="${assemble.dir}/${appname}AppClient.jar"/>
    <arg line="-name" />
    <arg line="${appname}Client"/>
    <arg line="-textauth"/>
    <arg line="-user j2ee"/>
    <arg line="-password j2ee"/>
    <arg line="-xml ${admin.domain.dir}/${admin.domain}/config/glassfish-acc.xml"/>
    <arg line="${appclient.application.args}"/>
  </exec>
  <!-- confirming report generation... -->
  <antcall target="checkReporting-common">
      <param name="test.name" value="${appname}"/>
      <param name="test.description" value="${test.description}"/>
  </antcall>
</target>

<!--  run web client in AppServ  -->
<target name="runwebclient-common" depends="init-common">
  <echo message="Executing Web Test from ${basedir}"/>
  <java
    fork="on"
    timeout="120000"
    classpath="${env.APS_HOME}/lib/webtest.jar:${s1astest.classpath}"
    classname="com.sun.ejte.ccl.webrunner.webtest.WebTest">
    <arg value="script.txt"/>
    <arg value="${http.host}"/>
    <arg value="${http.port}"/>
    <arg value="${env.APS_HOME}/${execution.mode}/test_results.xml"/>
    <arg value="${testsuite.id}"/>
  </java>
</target>

<!--  start Pointbase servers -->
<target name="startPB" depends="init-common">
  <echo message="Starting Pointbase servers"/>
  <property name="jvm.args"
      value="-Ddatabase.home=${db.root}/databases
          -Dpointbase.ini=${db.root}/tools/serveroption/pointbase.ini"/>
  <parallel>
    <java classname="com.pointbase.net.netServer"
      classpath="${db.classpath}" failonerror="true" fork="true">
      <jvmarg line="${jvm.args}"/>
      <arg line="/port:9092"/>
    </java>
    <java classname="com.pointbase.net.netServer"
      classpath="${db.classpath}" failonerror="true" fork="true">
      <jvmarg line="${jvm.args}"/>
      <arg line="/port:9093"/>
    </java>

    <!-- ports 9094 and 9095 are being used by the Tomcat group -->
    <java classname="com.pointbase.net.netServer"
      classpath="${db.classpath}" failonerror="true" fork="true">
      <jvmarg line="${jvm.args}"/>
      <arg line="/port:9094"/>
    </java>
    <java classname="com.pointbase.net.netServer"
      classpath="${db.classpath}" failonerror="true" fork="true">
      <jvmarg line="${jvm.args}"/>
      <arg line="/port:9095"/>
    </java>
    <!-- <antcall target="create-db-common"/> -->
  </parallel>
</target>

<!--  create Pointbase Databases -->
<target name="create-db-common" depends="init-common">
  <echo message="Creating Pointbase Databases"/>
  <sleep seconds="10"/>
  <parallel>
    <java classname="com.pointbase.tools.toolsCommander"
      classpath="${db.classpath}" failonerror="false">
      <arg line="${db.driver}"/>
      <arg line="jdbc:pointbase:server://${db.host}:9093/sqe-samples,new"/>
      <arg line="${db.user}"/>
      <arg line="${db.pwd}"/>
    </java>
    <java classname="com.pointbase.tools.toolsCommander"
      classpath="${db.classpath}" failonerror="false">
      <arg line="${db.driver}"/>
      <arg line="jdbc:pointbase:server://${db.host}:9094/ActivityDB,new"/>
      <arg line="PBPUBLIC"/>
      <arg line="PBPUBLIC"/>
    </java>
    <java classname="com.pointbase.tools.toolsCommander"
      classpath="${db.classpath}" failonerror="false">
      <arg line="${db.driver}"/>
      <arg line="jdbc:pointbase:server://${db.host}:9095/app_centric_test_servlet2_4_workflow,new"/>
      <arg line="PUBLIC"/>
      <arg line="PUBLIC"/>
    </java>
  </parallel>
</target>

<target name="copyDrivers" depends="init-common">
  <echo message="db.driver.dir=${db.driver.dir}"/>
  <echo message="db.driver=${db.driver}"/>
  <echo message="db.file=${db.file}"/>
  <!-- Copy Pointbase Drivers -->
  <copy todir="${admin.domain.dir}/${admin.domain}/lib/ext"
    overwrite="true" failonerror="false">
    <fileset dir="${env.S1AS_HOME}/pointbase/lib" includes="**/*.jar"/>
  </copy>

  <property file="${db.file}"/>
  <antcall target="create-JVM-options"/>
  <antcall target="restart-server-instance-common"/>
</target>

<!-- Database Targets  -->
<target name="oracle">
  <echo message="So you are using oracle..!"/>
  <property file="${env.APS_HOME}/devtests/jdbc/config/oracle.properties"/>
</target>

<target name="oracledd">
    <echo message="So you are using oracle datadirect driver..!"/>
    <property file="${env.APS_HOME}/devtests/jdbc/config/oracle_datadirect.properties"/>
</target>

<!-- this target cleans up oracle schema, drops all tables under a user
and creates a new one
Added 8/21/2003 Deepa+Sailaja
-->
<target name="oracle-inituser" depends="init-common">
  <property file="${env.APS_HOME}/devtests/jdbc/config/oracle.properties"/>
  <sql driver="${db.driver}" url="${db.url}"
    userid="system" password="sysdba"
    onerror="continue"
    classpath="${env.S1AS_HOME}/lib/jdbcdrivers/smoracle.jar">
    drop user ${db.user} cascade;
    create user ${db.user} identified by ${db.pwd};
    grant connect,resource,dba to ${db.user};
  </sql>
</target>

<target name="reconfig" depends="init-common">
    <echo>
        Reconfig has been deprecated.
        No Action will be taken by the Appserver !!"/>
    </echo>
</target>


<!-- ****** Start run.xml targets ************************************************ -->

    <target name="startCleanAS">
        <echo message="run.xml:stopping AppServer Domain..."/>
        <antcall target="stop-domain"/>
        <echo message="run.xml:re-creating AppServer Domains..."/>
        <antcall target="cleanAS"/>
        <echo message="run.xml:starting AppServer Domain..."/>
        <antcall target="start-domain"/>
    </target>

    <target name="stopPB" depends="init-common" if="isUnix">
        <java classname="com.pointbase.tools.toolsCommander"
            classpath="${db.classpath}" failonerror="false">
            <arg line="${db.driver}"/>
            <arg line="jdbc:pointbase:server://${admin.host}:9092/sqe-samples"/>
            <arg line="exit.sql"/>
            <arg line="dbuser"/>
            <arg line="dbpassword"/>
        </java>
    </target>


<!-- ======= restart server instance targets ======= -->
    <target name="restart-server-instance-common" depends="init-common">
            <antcall target="restart-server-instance-common-${execution.mode}"/>
    </target>

    <target name="restart-server-instance-common-ee" depends="init-common">
        <antcall target="restart-standalone-instance"/>
        <antcall target="restart-cluster"/>
   </target>

<target name="restart-standalone-instance" unless="cluster">
  <echo message="Restarting remote server instance,until this gets fixed"/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="stop-instance"/>
    <arg line="--user ${admin.user}"/>
    <arg line="--password ${admin.password}"/>
    <arg line="--host ${admin.host}"/>
    <arg line="--port ${admin.port}"/>
    <arg line="${appserver.instance.name}"/>
  </exec>

  <sleep seconds="30"/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="start-instance"/>
    <arg line="--user ${admin.user}"/>
    <arg line="--password ${admin.password}"/>
    <arg line="--host ${admin.host}"/>
    <arg line="--port ${admin.port}"/>
    <arg line="${appserver.instance.name}"/>
  </exec>

</target>


<target name ="restart-cluster" if="cluster">
  <echo message="Restarting cluster,until this gets fixed"/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="stop-cluster"/>
    <arg line="--user ${admin.user}"/>
    <arg line="--password ${admin.password}"/>
    <arg line="--host ${admin.host}"/>
    <arg line="--port ${admin.port}"/>
    <arg line="${cluster.name}"/>
  </exec>

  <sleep seconds="30"/>
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="start-cluster"/>
    <arg line="--user ${admin.user}"/>
    <arg line="--password ${admin.password}"/>
    <arg line="--host ${admin.host}"/>
    <arg line="--port ${admin.port}"/>
    <arg line="${cluster.name}"/>
  </exec>
</target>

<target name="restart-server-instance-common-pe" depends="init-common">
  <echo message="Restarting the AppServer instance..."/>
  <antcall target="stop-domain"/>
  <sleep seconds="10"/>
  <antcall target="start-domain"/>
</target>

<target name="start-domain" depends="ping-appserver-version">
  <antcall target="start-domain-pe"/>
  <antcall target="start-domain-ee"/>
</target>

<target name="start-domain-pe" depends="init-common" unless="isEE">
  <echo message="start-domain is running on Platform Edition..."/>
  <antcall target="start-domain-win"/>
  <antcall target="start-domain-unix"/>
  <waitfor maxwait="5" maxwaitunit="minute" checkevery="500">
    <http url="http://${admin.host}:${admin.port}/asadmin"/>
  </waitfor>
</target>

   <target name="start-domain-ee" depends="init-common" if="isEE">
        <echo message="start-domain is running on Standard/Enterprise Edition..."/>
      <antcall target="start-domain-win"/>
      <antcall target="start-domain-unix"/>
      <echo message="Waiting for 90 secs to make sure server properly started..."/>
      <sleep seconds="90"/>
    </target>


    <target name="start-domain-win" depends="init-common" if="isWindows">
        <echo message="run.xml:starting domain on windows..."/>
        <exec executable="start" failonerror="false">
          <arg line="${ASADMIN}"/>
          <arg line="start-domain"/>
          <arg line="--user ${admin.user}"/>
          <arg line="--password ${admin.password}"/>
          <arg line="${admin.domain}"/>
        </exec>
    </target>

    <target name="start-domain-unix" depends="init-common" if="isUnix">
      <echo message="run.xml:starting domain on a unix OS..."/>
      <exec executable="${ASADMIN}" failonerror="false">
        <arg line="start-domain"/>
          <arg line="--user ${admin.user}"/>
          <arg line="--password ${admin.password}"/>
        <arg line="${admin.domain}"/>
      </exec>
    </target>

    <target name="stop-domain" depends="init-common">
      <echo message="run.xml:stopping domain..."/>
      <exec executable="${ASADMIN}" failonerror="false">
        <arg line="stop-domain"/>
        <arg line="${admin.domain}"/>
      </exec>
   </target>

<!-- ======= delete/create  nodeagent targets ======= -->
    <target name="delete-domain-common" depends="init-common">
      <exec executable="${ASADMIN}" failonerror="false">
        <arg line="delete-domain"/>
        <arg line="--domaindir ${admin.domain.dir}"/>
        <arg line="${admin.domain}"/>
      </exec>
    </target>

    <target name="create-domain-common" depends="init-common">
      <exec executable="${ASADMIN}" failonerror="false">
        <arg line="create-domain"/>
        <arg line="--domaindir ${admin.domain.dir}"/>
        <arg line="--adminport ${admin.port}"/>
        <arg line="--instanceport ${http.port}"/>
        <arg line="--adminuser ${admin.user}"/>
        <arg line="--adminpassword ${admin.password}"/>
        <arg line="--domainproperties orb.listener.port=${orb.port}" />
        <arg line="${admin.domain}"/>
      </exec>
    </target>

<!-- ****** End run.xml targets ************************************************ -->

<!-- Confirm Report Generation -->
<target name="checkReporting-common">
    <available file="RepRunConf.txt" type="file" property="isReported"/>
    <antcall target="confirmReportPresent-common"/>
    <antcall target="confirmMissingReport-common"/>
</target>

<target name="confirmReportPresent-common" if="isReported">
    <echo message="file RepRunConf.txt is present." level="verbose"/>
    <echo message="Test seems to be reported fine"/>
    <echo message="deleting RepRunConf.txt..." level="verbose"/>
    <delete>
        <fileset dir="." includes="**/RepRunConf.txt"/>
    </delete>
</target>

<target name="confirmMissingReport-common" unless="isReported">
    <echo message="file RepRunConf.txt is missing!!!" level="verbose"/>
    <echo message="Test does not seem to have been reported"/>
    <echo message="Adding status 'did not run' into report..."/>
    <java classname="com.sun.ejte.ccl.reporter.ReporterClient">
        <classpath>
            <pathelement location="${env.APS_HOME}/lib/reporter.jar"/>
            <pathelement location="."/>
        </classpath>
        <arg value="${test.name}"/>
        <arg value="${test.description}"/>
        <arg value="${basedir}"/>
        <arg value="${env.APS_HOME}/devtests/jdbc/config/basic_test_resultsValid.xml"/>
    </java>
    <echo message="deleting RepRunConf.txt..." level="verbose"/>
    <delete>
        <fileset dir="." includes="**/RepRunConf.txt"/>
    </delete>
</target>

<target name="convert-dnrlist">
  <replace file="did_not_runs_list.xml" token="pass" value="did_not_run"/>
  <replace file="did_not_runs_list.xml" token="fail" value="did_not_run"/>
  <delete file="did_not_runs_listValid.xml"/>
  <delete file="did_not_runs_list"/>
</target>

<target name="run-loose-reporter" depends="init-common">
  <!--
  Caution:
  the test description should be passed as 'one' word with no spaces
  testname_and_status parameter can be overloaded by specifying multiple
  test names and their status in the order: testname teststatus
  thus, passing space seperated argument makes more sense here.
  -->
  <property name="testdesc" value="default"/>
  <property name="testname_and_status" value="defaultname did_not_run"/>
  <java
    classname="com.sun.ejte.ccl.reporter.LooseReporterClient"
    classpath="${env.APS_HOME}/lib/reporter.jar">
    <arg line="${testdesc}"/>
    <arg line="${testname_and_status}"/>
  </java>
</target>
<!-- End Report Targets -->

<target name="list-components-common" depends="init-common">
    <exec executable="${ASADMIN}"
        outputproperty="components-list" failonerror="false">

        <arg line="list-components"/>
        <arg line="${as.props}"/>
    </exec>
</target>

<target name="show-component-status-common" depends="init-common">
    <exec executable="${ASADMIN}" outputproperty="component-status"
        failonerror="false">
        <arg line="show-component-status"/>
        <arg line="${as.props}"/>
        <arg line="${component-name}"/>
    </exec>
</target>

<target name="version-common" depends="init-common">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="version"/>
    <arg line="--verbose"/>
    <arg line="${as.props}"/>
  </exec>
</target>

<target name="enable-common" depends="init-common">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="enable"/>
    <arg line="${as.props}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${component.name}"/>
  </exec>
</target>

<target name="disable-common" depends="init-common">
  <exec executable="${ASADMIN}" failonerror="false">
    <arg line="disable"/>
    <arg line="${as.props}"/>
    <arg line="--target ${appserver.instance.name}"/>
    <arg line="${component.name}"/>
  </exec>
</target>

<!-- usage  -->
<target name="usage-common">
  <echo>
    ant clean           Remove all classes files
    ant build           Build the application
    ant deploy          Deploy the ear files to S1AS
    ant run                    Run the application
    ant undeploy        Undeploy the ear files from S1AS
    ant usage           Display this message
  </echo>
</target>

<!-- webservices -->
<target name="import-wsdl" depends="init-common">
    <mkdir dir="${build.classes.dir}"/>
    <exec executable="${WSCOMPILE}">
<!--
        <arg line="-classpath ${s1astest.classpath}"/>
-->
        <arg line="-classpath ${build.classes.dir}"/>
        <arg line="-import"/>
        <arg line="-f:norpcstructures"/>
        <arg line="-keep"/>
        <arg line="-d "/>
        <arg path="${build.classes.dir}"/>
        <!--
        <arg line="-s "/>
        <arg path="${basedir}/gensource"/>
        -->
        <arg line="-mapping ${build.classes.dir}/${mapping.file}"/>
        <arg line="${config-wsdl.file}"/>
    </exec>
</target>


<!-- get the appserver edition -->
<target name="ping-appserver-version" depends="init-common">
        <available file="${admin.domain.dir}/${admin.domain}/config/cert8.db" type="file" property="isEE"/>
</target>

<target name="setupTimer" depends="init-common" if="ee">
        <exec executable="${ASADMIN}" failonerror="false">
        <arg line="create-resource-ref"/>
            <arg line="--user ${admin.user}"/>
        <arg line="--password ${admin.password}"/>
        <arg line="--host ${admin.host}"/>
        <arg line="--port ${admin.port}"/>
        <arg line="--target ${appserver.instance.name}"/>
        <arg line="${jdbc.resource.name}"/>
</exec>
<exec executable="${ASADMIN}" failonerror="false">
        <arg line="set"/>
        <arg line="--user ${admin.user}"/>
        <arg line="--password ${admin.password}"/>
        <arg line="--host ${admin.host}"/>
        <arg line="--port ${admin.port}"/>
    <arg line="${appserver.instance.name}-config.ejb-container.ejb-timer-service.timer-datasource=${jdbc.resource.name}"/>
</exec>
<echo message="creating timer table from ${env.S1AS_HOME}/lib/install/ejbtimer_${db.type}"/>
    <sql
    driver="${db.driver}"
    url="${db.url}"
    userid="${db.user}"
    password="${db.pwd}"
    onerror="continue"
    print="yes"
    classpath="${s1astest.classpath}">
    <fileset dir="${env.S1AS_HOME}/lib/install/databases">
      <include name="**/ejbtimer_${db.type}.sql"/>
    </fileset>
    </sql>
</target>

<target name="get-version-common" depends="init-common">
    <exec executable="${ASADMIN}" failonerror="false" outputproperty="appserver.version">
        <arg line="version"/>
        <arg line="--verbose"/>
    </exec>
    <condition property="platform" value="true">
        <contains string="${appserver.version}" substring="Platform" casesensitive="false"/>
    </condition>
    <condition property="enterprise" value="true">
        <contains string="${appserver.version}" substring="Enterprise" casesensitive="false"/>
    </condition>
    <antcall target="platform-common"/>
    <antcall target="enterprise-common"/>
</target>

<target name="platform-common" if="platform">
    <echo message="This is Platform Version***"/>
</target>

<target name="enterprise-common" if="enterprise">
    <echo message="This is Enterprise Version***"/>
</target>


<target name="asadmin-common-ignore-fail">
  <echo message="Doing admin task ${admin.command} (ignore failures)"
      level="verbose"/>
  <echo message="Operand ${operand.props}"  level="verbose"/>
  <echo message="asadmin ${admin.command} ${as.props} ${operand.props}"/>
    <exec executable="${ASADMIN}" failonerror="false">
        <arg line="${admin.command} ${as.props} ${operand.props}" />
    </exec>
</target>

<target name="asadmin-batch-common">
  <echo message="Doing admin batch task ${admin.command} --file"
      level="verbose"/>
  <exec executable="${ASADMIN}" failonerror="true">
     <env key="AS_ADMIN_PORT" value="${admin.port}"/>
     <env key="AS_ADMIN_USER" value="${admin.user}"/>
     <env key="AS_ADMIN_PASSWORD" value="${admin.password}"/>
     <env key="AS_ADMIN_HOST" value="${admin.host}"/>
     <env key="AS_ADMIN_INSTANCE" value="${appserver.instance.name}"/>
     <arg line="--target ${appserver.instance.name}
                multimode --file ${asadmin.file}" />
  </exec>
</target>