nant.build

<?xml version="1.0" encoding="utf-8"?>
<project name="NServiceBus" default="build" xmlns="http://nant.sf.net/release/0.85/nant.xsd">
	<property name="solution.dir" value="src"/>
	<property name="trunk.dir" value="."/>
	<property name="company.name" value="NServiceBus"/>
	<property name="bin.dir" value="bin" />
	<property name="lib.dir" value="lib" />
	<property name="tools.dir" value="tools" />
	<property name="build.base" value="build"/>
	<property name="project.version" value="3.0.0" />
	<property name="file.version" value="${project.version}.0000" dynamic="true"/>
	<property name="release.dir" value="${trunk.dir}\release"/>
	<property name="binaries.dir" value="${trunk.dir}\binaries"/>
	<property name="output.dir" value="${build.base}\output"/>
	<property name="test.dir" value="${build.base}\test"/>
	<property name="artifacts.dir" value="artifacts"/>
	<property name="merge.dir" value="${build.base}/merge"/>
	<property name="main.build.dir" value="${build.base}\nservicebus"/>
	<property name="core.build.dir" value="${build.base}\nservicebus.core"/>
	<property name="host.build.dir" value="${build.base}\host"/>
	<property name="container.build.dir" value="${build.base}\containers"/>
	<property name="container.output.dir" value="${output.dir}\containers"/>
	<property name="Is64BitOperatingSystem" value="false" />
	<property name="Is64BitProcess" value="false" />
	<property name="IsWow64Process" value="false" />
	<property name="architecture" value="x86" dynamic="true" />
	<property name="build.dir.absolutepath" value="${path::get-full-path(build.base)}" />
	<property name="include.dependencies" value="true" dynamic="true" />
	<property name="include_azure" value="false" dynamic="true" />
	<property name="servicehosting.version" value="" dynamic="true" />
	<property name="project.config" value="release" />
	<property name="targetframework" value="net-4.0" dynamic="true" />
	<property name="msbuild" value="${framework::get-framework-directory(framework::get-target-framework())}\msbuild.exe" dynamic="true" />
	<property name="msbuild.targetframework" value="/p:TargetFrameworkVersion=v3.5 /ToolsVersion:3.5" dynamic="true" />
	<property name="ilmerge.targetframework" value="" dynamic="true" />
	<property name="nunit.targetframework" value="" dynamic="true" />
	
	<if test="${targetframework == 'net-4.0'}">
		<property name="nunit.targetframework" value="/framework=4.0"/>
	</if>


	<target name="DetectOperatingSystemArchitecture" depends="DetectIfWow64Process,DetectIf64BitProcess">
		<description>
			This will detect whether the current Operating System is running as a 32-bit or 64-bit Operating System regardless of whether this is a 32-bit or 64-bit process.
		</description>
		<property name="Is64BitOperatingSystem" value="${IsWow64Process or Is64BitProcess}" />

		<if test="${Is64BitOperatingSystem}">
			<property name="architecture" value="x64" />
		</if>
	</target>

	<script language="C#" prefix="MyWin32Calls">
		<code>
			<![CDATA[
            [System.Runtime.InteropServices.DllImport("kernel32.dll")]
            public static extern bool IsWow64Process(System.IntPtr hProcess, out bool lpSystemInfo);

            [Function("IsWow64Process")]
            public bool IsWow64Process()
            {
                bool retVal = false;
               
                IsWow64Process(System.Diagnostics.Process.GetCurrentProcess().Handle, out retVal);
               
                return retVal;
            }
    ]]>
		</code>
		<references>
			<include name="System.dll" />
		</references>
	</script>

	<target name="DetectIfWow64Process">
		<description>
			Detects whether we are currently in a WoW64 process or not.
		</description>

		<property name="IsWow64Process" value="${MyWin32Calls::IsWow64Process()}" />
		<echo message="Setting the [IsWow64Process] property to ${IsWow64Process}." />
	</target>

	<target name="DetectIf64BitProcess">
		<description>
			Detects whether we are currently in a 32-bit or 64-bit process (not necessarily what the OS is running). Note that as of the time of this writing, this will ALWAYS return false because NAnt is compiled to run in 32-bit mode only.
		</description>

		<!-- This can return x86, x64, AMD64, or IA64 as of the time of this writing. This works for a 32-bit process in a 64-bit OS because the OS makes the 64-bitness transparent to the process in this environment variable. -->
		<property name="Is64BitProcess" value="${environment::get-variable('PROCESSOR_ARCHITECTURE')!='x86'}" />
		<echo message="Setting the [Is64BitProcess] property to ${Is64BitProcess}." />
	</target>
	<readregistry  property="servicehosting.version" key="SOFTWARE\Microsoft\Microsoft SDKs\ServiceHosting\v1.0\FullVersion" hive="LocalMachine" failonerror="false"/>


	<target name="build" depends="build_src,test,compile_tools,compile_msmqutils,prepare_binaries,compile_samples"/>
	<target name="build_src" depends="clean, init, commonassemblyinfo, compile_main,compile_core,compile_containers,compile_hosts,compile_hosts32"/>

	<target name="init" depends="DetectOperatingSystemArchitecture" description="Initializes build properties">
		<tstamp>
			<formatter property="datetime.buildtime" pattern="yyyy-MM-dd, HH:mm:ss" />
		</tstamp>
		<echo message="Creating build dir: ${build.base}"/>
		<delete dir="${build.base}"/>
		<mkdir dir="${build.base}"/>
		<echo message="Current Directory: ${project::get-base-directory()}"/>


		<echo message="${architecture}" />
		<copy todir="${lib.dir}\sqlite" overwrite="true">
			<fileset basedir="${lib.dir}\sqlite\${architecture}">
				<include name="*.*" />
			</fileset>
		</copy>

		<if test="${targetframework == 'net-4.0'}">
		    <property name="netfx.installroot" value="" dynamic="true" />
			<readregistry 	property="netfx.installroot" key="SOFTWARE\Microsoft\.NETFramework\InstallRoot" hive="LocalMachine" />
			<echo message="Netfx in:  ${netfx.installroot}" />

			<property name="netfx.current" value="${netfx.installroot}v4.0.30319"/>
			<property name="msbuild" value="${netfx.current}\msbuild.exe"/>
			<echo message=".Net 4.0 build requested - ${msbuild}" />

			<property name="ilmerge.targetframework" value="/targetplatform:v4,${netfx.current}" />
			<property name="msbuild.targetframework" value="/p:TargetFrameworkVersion=v4.0 /ToolsVersion:4.0"/>
		</if>
	</target>

	<target name="clean" description="delete build artifacts">
		<delete dir="${build.base}" failonerror="false" />
	</target>

	<target name="commonassemblyinfo" depends="init">
		<property name="assembly.version" value="${project.version}.0" />
		
		<if test="${property::exists('build.number')}">
			<property name="file.version" value="${project.version}.${build.number}"/>
		</if>

		<echo message="##teamcity[buildNumber '${file.version}']" />
		<delete file="${solution.dir}/CommonAssemblyInfo.cs" failonerror="false"/>
		<asminfo output="${solution.dir}/CommonAssemblyInfo.cs" language="CSharp">
			<imports>
				<import namespace="System" />
				<import namespace="System.Reflection" />
				<import namespace="System.Runtime.InteropServices" />
				<import namespace="System.Security" />
			</imports>
			<attributes>
				<attribute type="AssemblyVersionAttribute" value="${assembly.version}" />
				<attribute type="AssemblyFileVersionAttribute" value="${file.version}" />
				<attribute type="AssemblyCopyrightAttribute" value="Copyright © ${company.name} 2007-${datetime::get-year(datetime::now())}" />
				<attribute type="AssemblyProductAttribute" value="${project::get-name()}" />
				<attribute type="AssemblyCompanyAttribute" value="${company.name}" />
				<attribute type="AssemblyConfigurationAttribute" value="${project.config}" />
				<attribute type="AssemblyInformationalVersionAttribute" value="${file.version}" />
				<!-- TODO : Figure out how to handle non trusted callers i .net 4.0 -->
				<if test="${targetframework != 'net-4.0'}">
					<attribute type="AllowPartiallyTrustedCallersAttribute" asis="true" />
				</if>
				<attribute type="ComVisibleAttribute" value="false" />
			</attributes>
			<references>
				<include name="System.dll" />
			</references>
		</asminfo>
	</target>

	<target name="compile_main" depends="init">
		<!-- NServiceBus -->
		<foreach 	item="String"
						in="core"
						delim=","
						property="pathToBuild">
			<exec 	program="${msbuild}"
						  commandline="/p:Configuration=${project.config} /p:OutDir=${build.dir.absolutepath}\nservicebus\ ${msbuild.targetframework}"
						  workingdir="${solution.dir}\${pathToBuild}" />
		</foreach>

		<property name="nservicebus.assemblies" value="${main.build.dir}\NServiceBus.dll" dynamic="true" />
		<foreach item="File" property="filename">
			<in>
				<items>
					<include name="${main.build.dir}\NServiceBus.*.dll" />
				</items>
			</in>
			<do>
				<property name="nservicebus.assemblies" value="${nservicebus.assemblies} ${filename}"/>
			</do>
		</foreach>
		<!-- Create the merged NServiceBus.dll-->
		<mkdir dir="${output.dir}" />
		<exec program="${lib.dir}\ilmerge.exe"
					commandline="/out:${output.dir}\NServiceBus.dll ${nservicebus.assemblies} /target:library /keyfile:NServiceBus.snk /xmldocs /log:build\output.txt ${ilmerge.targetframework}"
					workingdir="." />

	</target>
	<target name="compile_core" depends="compile_main">
		<!-- NServiceBus.Core -->
		<foreach 	item="String"
						in="utils,ObjectBuilder,messageInterfaces,impl\messageInterfaces,config,logging,impl\ObjectBuilder.Common,installation,unicastTransport,messagemutator,encryption,faults,unitofwork,httpHeaders,masterNode,impl\installation,impl\unicast\NServiceBus.Unicast.Msmq,unicast,headers,impersonation,impl\unicast\queuing,impl\unicast\transport,impl\unicast\NServiceBus.Unicast.Subscriptions.Msmq,impl\unicast\NServiceBus.Unicast.Subscriptions.InMemory,impl\faults,impl\encryption,impl\Serializers,databus,impl\Sagas,grid,impl\SagaPersisters\InMemory,impl\unitofwork,impl\SagaPersisters\NHibernateSagaPersister,impl\unicast\NServiceBus.Unicast.Subscriptions.NHibernate,impl\unicast\NServiceBus.Unicast.Subscriptions.Azure.TableStorage,integration,impl\databus,distributor,gateway"
						delim=","
						property="pathToBuild">
			<exec 	program="${msbuild}"
						  commandline="/p:Configuration=${project.config} /p:OutDir=${build.dir.absolutepath}\nservicebus.core\ ${msbuild.targetframework}"
						  workingdir="${solution.dir}\${pathToBuild}" />
		</foreach>
		<!-- Create list of all "core" assemblies -->
		<property name="nservicebus.coreassemblies" value="${core.build.dir}\NServiceBus.Objectbuilder.dll" dynamic="true" />
		<foreach item="File" property="filename">
			<in>
				<items>
					<include name="${core.build.dir}\NServiceBus.**.dll" />
					<exclude name="${core.build.dir}\**Tests.dll" />
					<!-- NServiceBus.Objectbuilder.dll needs to be first in the list to be the "primary assembly so it's added explicitly-->"
					<exclude name="${core.build.dir}\NServiceBus.Objectbuilder.dll" />
				</items>
			</in>
			<do>
				<property name="nservicebus.coreassemblies" value="${nservicebus.coreassemblies} ${filename}"/>
			</do>
		</foreach>
		<!-- Create list of all depending assemblies that will be merged into NServiceBus.Core.dll -->
		<property name="nservicebus.merged_dependencies" value="" dynamic="true" />
		<if test="${include.dependencies != 'false'}">
			<foreach item="File" property="filename">
				<in>
					<items>
						<include name="${core.build.dir}\antlr3*.dll" />
						<include name="${core.build.dir}\common.logging.dll"/>
						<include name="${lib.dir}\common.logging.log4net.dll"/>
						<include name="${core.build.dir}\Interop.MSMQ.dll" />
						<include name="${core.build.dir}\AutoFac.dll"/>
						<include name="${core.build.dir}\NHibernate*.dll" />
						<include name="${core.build.dir}\FluentNHibernate.dll" />
						<include name="${core.build.dir}\Iesi.Collections.dll" />
						<include name="${core.build.dir}\LinFu*.dll" />
						<exclude name="${core.build.dir}\**Tests.dll" />
					</items>
				</in>
				<do>
					<property name="nservicebus.merged_dependencies" value="${nservicebus.merged_dependencies} ${filename}"/>
				</do>
			</foreach>
		</if>

		<echo message="Creating the merged NServiceBus.Core.dll, Dependencies included:" />
		<echo message="${nservicebus.merged_dependencies}" />

		<!-- Create the merged NServiceBus.Core.dll-->
		<exec program="${lib.dir}\ilmerge.exe"
					commandline="/out:${output.dir}\NServiceBus.Core.dll ${nservicebus.coreassemblies} ${nservicebus.merged_dependencies} /target:library /keyfile:NServiceBus.snk /xmldocs /internalize:ilmerge.exclude /log:build\output_core.txt ${ilmerge.targetframework}"
					workingdir="." />

	</target>


	<target name="compile_containers">
		<!-- Containers -->
		<exec 	program="${msbuild}"
					commandline="/p:Configuration=${project.config} /p:OutDir=${build.dir.absolutepath}\containers\ ${msbuild.targetframework}"
					workingdir="${solution.dir}\impl\ObjectBuilder" />

		<!-- Copy the container assemblies to the output directory -->
		<copy todir="${container.output.dir}">
			<fileset basedir="${container.build.dir}">
				<include name="NServiceBus.ObjectBuilder.Autofac.dll" />
				<include name="NServiceBus.ObjectBuilder.CastleWindsor.dll" />
				<include name="NServiceBus.ObjectBuilder.StructureMap.dll" />
				<include name="NServiceBus.ObjectBuilder.Unity.dll" />
				<include name="NServiceBus.ObjectBuilder.Ninject.dll" />
			</fileset>
		</copy>
	</target>

	<target name="compile_hosts">
		<property name="hosting.build.dir" value="${build.base}\hosting" />

		<!-- Compile all hosts -->
		<exec 	program="${msbuild}"
					commandline="/p:Configuration=${project.config} /p:OutDir=${build.dir.absolutepath}\hosting\ ${msbuild.targetframework}"
						workingdir="${solution.dir}\hosting" />

		<!-- Merge the windowshost and it's dependencies -->
		<mkdir 	dir="${output.dir}\host" />
		<exec 	program="${lib.dir}\ilmerge.exe"
					commandline="/keyfile:NServiceBus.snk /out:${output.dir}\host\NServiceBus.Host.exe ${hosting.build.dir}\NServiceBus.Hosting.Windows.exe ${hosting.build.dir}\NServiceBus.Hosting.dll ${hosting.build.dir}\Microsoft.Practices.ServiceLocation.dll ${hosting.build.dir}\Magnum.dll ${hosting.build.dir}\Topshelf.dll /internalize:ilmerge.exclude /target:exe /xmldocs /log:build\output_windowshost.txt ${ilmerge.targetframework}"
					workingdir="." />
	</target>

	<target name="compile_hosts32">
		<property name="hosting.build.dir32" value="${build.base}\hosting32" />

		<!-- Cleanup remnants of previous host compilation -->
		<exec 	program="${msbuild}"
					commandline="/p:Configuration=${project.config} /p:OutDir=${build.dir.absolutepath}\hosting32\ ${msbuild.targetframework} /t:Clean"
					workingdir="${solution.dir}\hosting" />
					
		<!-- Compile all hosts for 32-bit execution -->
		<exec 	program="${msbuild}"
					commandline="/p:Configuration=${project.config} /p:PlatformTarget=x86 /p:OutDir=${build.dir.absolutepath}\hosting32\ ${msbuild.targetframework}"
					workingdir="${solution.dir}\hosting" />

		<!-- Merge the windowshost and it's dependecies -->
		<mkdir 	dir="${output.dir}\host" />
		<exec 	program="${lib.dir}\ilmerge.exe"
					commandline="/keyfile:NServiceBus.snk /out:${output.dir}\host\NServiceBus.Host32.exe ${hosting.build.dir32}\NServiceBus.Hosting.Windows.exe ${hosting.build.dir32}\NServiceBus.Hosting.dll ${hosting.build.dir32}\Microsoft.Practices.ServiceLocation.dll ${hosting.build.dir32}\Magnum.dll ${hosting.build.dir32}\Topshelf.dll /internalize:ilmerge.exclude /target:exe /xmldocs /log:build\output_windowshost32.txt ${ilmerge.targetframework}"
					workingdir="." />
	</target>

	<target name="test">
		<mkdir dir="${build.base}\test-reports" />

		<!-- run the core tests-->
		<property name="nservicebus.testassemblies" value="" dynamic="true" />
		<foreach item="File" property="filename">
			<in>
				<items>
					<include name="${core.build.dir}\*Tests.dll" />
					<include name="${build.dir.absolutepath}\containers\*Tests.dll" />
					<exclude name="${core.build.dir}\*FileShare.Tests.dll" />
                                        <exclude name="${core.build.dir}\*Gateway.Tests.dll" />
					<exclude if="${servicehosting.version == '' or include_azure == 'false'} " name="${core.build.dir}\*Azure.Tests.dll" />
				</items>
			</in>
			<do>
				<property name="nservicebus.testassemblies" value="${nservicebus.testassemblies} ${filename}"/>
			</do>
		</foreach>
	
		
		<echo message="${nservicebus.testassemblies}" />
		
		<exec program="nunit-console.exe" basedir="tools\nunit" workingdir="${core.build.dir}">
			<arg line="${nservicebus.testassemblies}" />
			<arg value="${nunit.targetframework}" />
		</exec>
	</target>

	<target name="compile_tools">

		<!-- Testing -->
		<exec 	program="${msbuild}"
					commandline="/p:Configuration=${project.config} /p:OutDir=${build.dir.absolutepath}\testing\ ${msbuild.targetframework}"
					workingdir="${solution.dir}\testing" />
		
		<exec program="nunit-console.exe" basedir="tools\nunit" workingdir="${build.dir.absolutepath}\testing\">
			<arg line="NServiceBus.Testing.Tests.dll" />
			<arg value="${nunit.targetframework}" />
		</exec>
		<mkdir 	dir="${output.dir}\testing" />
		<exec 	program="${lib.dir}\ilmerge.exe"
					commandline="/out:${output.dir}\testing\NServiceBus.Testing.dll ${build.base}\testing\NServiceBus.Testing.dll ${build.base}\testing\Rhino.Mocks.dll /target:library /xmldocs /internalize:ilmerge.exclude /keyfile:NServiceBus.snk /log:build\output_testing.txt ${ilmerge.targetframework}"
					workingdir="." />

		<!-- timeout -->
		<exec 	program="${msbuild}"
					commandline="/p:Configuration=${project.config} /p:OutDir=${build.dir.absolutepath}\timeout\ ${msbuild.targetframework}"
					workingdir="${solution.dir}\timeout" />


		<!-- proxy -->
		<exec 	program="${msbuild}"
					commandline="/p:Configuration=${project.config} /p:OutDir=${build.dir.absolutepath}\proxy\ ${msbuild.targetframework}"
					workingdir="${solution.dir}\proxy" />


		<!-- Misc -->
		<foreach 	item="String"
						in="tools\management\Grid,tools\management\Errors\ReturnToSourceQueue"
						delim=","
						property="pathToBuild">
			<exec 	program="${msbuild}"
						  commandline="/p:Configuration=${project.config} /p:OutDir=${build.dir.absolutepath}\tools\ ${msbuild.targetframework}"
						  workingdir="${solution.dir}\${pathToBuild}" />
		</foreach>

		<!-- ilmerge dependent assemblies into XsdGenerator -->
		<exec program="${lib.dir}\ilmerge.exe"
		commandline="/out:..\XsdGenerator.exe XsdGenerator.exe NServiceBus.Serializers.XML.dll NServiceBus.Utils.Reflection.dll /target:exe /log:output_xsdgenerator.txt ${ilmerge.targetframework}"
		workingdir="${core.build.dir}" />

		<!-- copy the xsdgenerator to the tools directory -->
		<copy todir="${build.base}\tools\">
			<fileset basedir="${build.base}\">
				<include name="XsdGenerator.exe" />
			</fileset>
		</copy>
	</target>

	<target name="compile_samples" depends="prepare_binaries">
		<foreach 	item="String"
						in="AsyncPages,FullDuplex,PubSub,Manufacturing,GenericHost,Versioning,WcfIntegration,Starbucks,SendOnlyEndpoint,DataBus"
						delim=","
						property="pathToBuild">
			<echo message="${pathToBuild}" />
			<exec	program="${msbuild}"
					commandline="/p:Configuration=${project.config} ${msbuild.targetframework}"
					workingdir="${trunk.dir}\samples\${pathToBuild}" />
		</foreach>
		<if test="${servicehosting.version != '' and include_azure == 'true'}">
			<exec	program="${msbuild}" 
					commandline="/p:Configuration=${project.config} ${msbuild.targetframework}"
					workingdir="${trunk.dir}\samples\AzureService" />
		</if>
                <!-- exclude the WebServiceBridge sample until we can figure out why it fails on the CI server when building 4.0 -->
		<if test="${targetframework != 'net-4.0'}">
			<exec	program="${msbuild}" 
					commandline="/p:Configuration=${project.config} ${msbuild.targetframework}"
					workingdir="${trunk.dir}\samples\WebServiceBridge" />
		</if>

	</target>
	
	<target name="compile_msmqutils" depends="commonassemblyinfo">
		<exec 	program="${msbuild}"
					commandline="/p:Configuration=${project.config} /p:OutDir=${build.dir.absolutepath}\tools\MsmqUtils\ ${msbuild.targetframework}"
					workingdir="${solution.dir}\utils" />

	</target>
	
	<target name="BuildMsmqUtils" depends="compile_msmqutils">
		<!-- copy the runner to the tools directory -->
		<copy todir="tools\msmqutils">
			<fileset basedir="${build.dir.absolutepath}\tools\MsmqUtils">
				<include name="*.*" />
			</fileset>
		</copy>

	</target>

	<target name="prepare_binaries">
		<delete dir="${binaries.dir}" failonerror="false"></delete>
		<mkdir dir="${binaries.dir}" />
		<copy todir="${binaries.dir}">
			<fileset basedir="${output.dir}">
				<include name="NServiceBus*.*" />
			</fileset>
		</copy>
		<copy todir="${binaries.dir}">
			<fileset basedir="${output.dir}\host">
				<include name="*.*" />
			</fileset>
		</copy>
		<copy todir="${binaries.dir}">
			<fileset basedir="${output.dir}\testing">
				<include name="*.*" />
			</fileset>
		</copy>
		<copy todir="${binaries.dir}" flatten="true">
			<fileset basedir=".">
				<include name="${lib.dir}\log4net.dll" />
				<include name="${tools.dir}\nunit\nunit.framework.dll" />
			</fileset>
		</copy>
		<copy todir="${binaries.dir}">
			<fileset basedir="${lib.dir}\sqlite\x86">
				<include name="*.dll" />
			</fileset>
		</copy>
		<copy todir="${binaries.dir}\x64">
			<fileset basedir="${lib.dir}\sqlite\x64">
				<include name="*.dll" />
			</fileset>
		</copy>

		<!-- Prepare Containers -->
		<mkdir dir="${binaries.dir}\containers\autofac" />
		<copy todir="${binaries.dir}\containers\autofac">
			<fileset basedir="${lib.dir}\containers\autofac">
				<include name="Autofac*.*" />
			</fileset>
		</copy>
		<copy todir="${binaries.dir}\containers\autofac">
			<fileset basedir="${container.build.dir}">
				<include name="NServiceBus.ObjectBuilder.Autofac.dll" />
			</fileset>
		</copy>

		<mkdir dir="${binaries.dir}\containers\castle" />
		<copy todir="${binaries.dir}\containers\castle">
			<fileset basedir="${lib.dir}\containers\castle">
				<include name="Castle*.*" />
			</fileset>
		</copy>
		<copy todir="${binaries.dir}\containers\castle">
			<fileset basedir="${container.build.dir}">
				<include name="NServiceBus.ObjectBuilder.CastleWindsor.dll" />
			</fileset>
		</copy>

		<mkdir dir="${binaries.dir}\containers\structuremap" />
		<copy todir="${binaries.dir}\containers\structuremap">
			<fileset basedir="${lib.dir}\containers\structuremap">
				<include name="StructureMap*.*" />
			</fileset>
		</copy>
		<copy todir="${binaries.dir}\containers\structuremap">
			<fileset basedir="${container.build.dir}">
				<include name="NServiceBus.ObjectBuilder.StructureMap.dll" />
			</fileset>
		</copy>

		<mkdir dir="${binaries.dir}\containers\spring" />
		<copy todir="${binaries.dir}\containers\spring">
			<fileset basedir="${container.build.dir}">
				<include name="NServiceBus.ObjectBuilder.Spring.dll" />
				<include name="Spring.Core.dll" />
				<include name="antlr.runtime.dll" />
				<include name="Common.Logging.dll" />
			</fileset>
		</copy>

		<mkdir dir="${binaries.dir}\containers\unity" />
		<copy todir="${binaries.dir}\containers\unity">
			<fileset basedir="${lib.dir}\containers\unity">
				<include name="Microsoft.Practices.ObjectBuilder2.dll" />
				<include name="Microsoft.Practices.Unity.dll" />
			</fileset>
		</copy>
		<copy todir="${binaries.dir}\containers\unity">
			<fileset basedir="${container.build.dir}">
				<include name="NServiceBus.ObjectBuilder.Unity.dll" />
			</fileset>
		</copy>
		
		<mkdir dir="${binaries.dir}\containers\ninject" />
		<copy todir="${binaries.dir}\containers\ninject">
			<fileset basedir="${lib.dir}\containers\ninject">
				<include name="**\Ninject*.dll" />
			</fileset>
		</copy>
		<copy todir="${binaries.dir}\containers\ninject">
			<fileset basedir="${container.build.dir}">
				<include name="NServiceBus.ObjectBuilder.Ninject.dll" />
			</fileset>
		</copy>

	</target>

	<target name="package" depends="build">
		<delete dir="${release.dir}" failonerror="false"></delete>
		<mkdir dir="${release.dir}" />

		<copy todir="${release.dir}">
			<fileset basedir="${trunk.dir}">
				<include name="binaries\**" />
			</fileset>
		</copy>

		<copy todir="${release.dir}">
			<fileset basedir="${trunk.dir}">
				<include name="*.txt" />
			</fileset>
		</copy>

		<!-- Prepare Tools -->
		<copy todir="${release.dir}">
			<fileset basedir="${build.base}">
				<include name="tools\**" />

				<exclude name="**.xml" />
				<exclude name="**.pdb" />
			</fileset>
		</copy>

		<!-- Prepare Tools -->
		<copy todir="${release.dir}\processes">
			<fileset basedir="${build.base}">
				<include name="timeout\**" />
				<include name="proxy\**" />
				<include name="distributor\**" />
				<include name="gateway\**" />

				<exclude name="**.xml" />
				<exclude name="**.pdb" />
			</fileset>
		</copy>

		<copy todir="${release.dir}">
			<fileset basedir="${trunk.dir}">
				<include name="docs\**" />
			</fileset>
		</copy>

		<copy todir="${release.dir}">
			<fileset basedir="${trunk.dir}">
				<include name="RunMeFirst.bat" />
				<include name="samples\**" />
				<exclude name="**/obj/**" />
				<exclude name="**/bin/**" />
				<exclude name="**/_ReSharper*/**" />
				<exclude name="**.cache" />
			</fileset>
		</copy>

		<if test="${include.dependencies != 'true'}">
			<copy todir="${release.dir}\dependencies" flatten="true">
				<fileset basedir="${trunk.dir}" >
					<include name="${core.build.dir}\antlr*.dll" />
					<include name="${core.build.dir}\common.logging.dll"/>
					<include name="${lib.dir}\common.logging.log4net.dll"/>
					<include name="${core.build.dir}\Interop.MSMQ.dll" />
					<include name="${core.build.dir}\AutoFac.dll"/>
					<include name="${core.build.dir}\Spring.Core.dll" />
					<include name="${core.build.dir}\NHibernate*.dll" />
					<include name="${core.build.dir}\FluentNHibernate.dll" />
					<include name="${core.build.dir}\Iesi.Collections.dll" />
					<include name="${core.build.dir}\LinFu*.dll" />
					<exclude name="${core.build.dir}\**Tests.dll" />
				</fileset>
			</copy>
		</if>

		<delete dir="${artifacts.dir}" failonerror="false"/>
		<mkdir dir="${artifacts.dir}" />

		<zip zipfile="${artifacts.dir}\NServiceBus.${file.version}.zip" includeemptydirs="false" >
			<fileset basedir="${release.dir}">
				<include name="**"/>
			</fileset>

		</zip>

		<delete dir="${release.dir}" failonerror="false"/>

	</target>
</project>