dotnet-installer/src/SourceBuild/content/build.proj

<Project>
  <Import Project="Sdk.props" Sdk="Microsoft.NET.Sdk" />

  <UsingTask AssemblyFile="$(LeakDetectionTasksAssembly)" TaskName="CheckForPoison" />
  <UsingTask AssemblyFile="$(XPlatSourceBuildTasksAssembly)" TaskName="WriteUsageBurndownData" />
  <UsingTask AssemblyFile="$(XPlatSourceBuildTasksAssembly)" TaskName="ReplaceTextInFile" />
  <UsingTask AssemblyFile="$(XPlatSourceBuildTasksAssembly)" TaskName="CreateSdkSymbolsLayout" />

  <Import Project="Sdk.targets" Sdk="Microsoft.NET.Sdk" />

  <Target Name="Build" DependsOnTargets="PrepareOutput;InitBuild">
    <Message Text="Build Environment: $(Platform) $(Configuration) $(TargetOS) $(TargetRid)" />

    <MSBuild Projects="$(RepoProjectsDir)$(RootRepo).proj" Targets="Build" BuildInParallel="$(BuildInParallel)" StopOnFirstFailure="true" />
  </Target>

  <Target Name="PrepareOutput">
    <MakeDir Directories="$(OutputPath)" />
    <MakeDir Directories="$(LoggingDir)" />
    <MakeDir Directories="$(IntermediatePath)" />
    <MakeDir Directories="$(SourceBuiltBlobFeedDir)" />
    <MakeDir Directories="$(SourceBuiltPackagesPath)" />
    <MakeDir Directories="$(SourceBuiltAssetsDir)" />
    <MakeDir Directories="$(LocalBlobStorageRoot)" />
    <MakeDir Directories="$(MSBuildDebugPathTargetDir)" />
    <MakeDir Directories="$(RoslynDebugPathTargetDir)" />
    <MakeDir Directories="$(AspNetRazorBuildServerLogDir)" />
  </Target>

  <Target Name="InitBuild">
    <MSBuild Projects="$(ToolsDir)init-build.proj" />
  </Target>

  <Target Name="Clean">
    <RemoveDir Directories="$(BaseOutputPath)" />
  </Target>

  <!-- Copies the output assets of the builds to the output path. -->
  <Target Name="CopyBinariesToBinFolder"
          AfterTargets="Build"
          Inputs="$(MSBuildProjectFullPath)"
          Outputs="$(CompletedSemaphorePath)CopyBinariesToBinFolder.complete">
    <ItemGroup>
      <BinariesToCopy Include="$(SourceBuiltAssetsDir)*.*" Exclude="$(SourceBuiltAssetsDir)*.nupkg;$(SourceBuiltAssetsDir)*.requires_nupkg_signing" />
    </ItemGroup>

    <Copy SourceFiles="@(BinariesToCopy)"
          DestinationFolder="$(OutputPath)"
          Condition="'@(BinariesToCopy)'!=''" />

    <WriteLinesToFile File="$(CompletedSemaphorePath)CopyBinariesToBinFolder.complete" Overwrite="true" />
  </Target>

  <!-- After building, generate a prebuilt usage report. -->
  <Target Name="ReportPrebuiltUsage"
          AfterTargets="Build"
          Condition="'$(SkipReportPrebuiltUsage)' != 'true'">
    <MSBuild Projects="$(RepoProjectsDir)$(RootRepo).proj" Targets="WritePrebuiltUsageData;ReportPrebuiltUsage" />
  </Target>

  <Target Name="DiscoverSymbolsTarballs"
          AfterTargets="Build">
    <ItemGroup>
      <SymbolsTarball Include="$(OutputPath)Symbols.*.tar.gz" />
    </ItemGroup>
  </Target>

  <Target Name="ExtractSymbolsTarballs"
          AfterTargets="Build"
          DependsOnTargets="DiscoverSymbolsTarballs"
          Outputs="%(SymbolsTarball.Identity)">

    <PropertyGroup>
      <Filename>$([System.IO.Path]::GetFileName('%(SymbolsTarball.Identity)'))</Filename>
      <RepositoryName>$(Filename.Split('.')[1])</RepositoryName>
      <UnifiedSymbolsLayout>$(ArtifactsTmpDir)Symbols</UnifiedSymbolsLayout>
      <DestinationFolder>$(UnifiedSymbolsLayout)/$(RepositoryName)</DestinationFolder>
    </PropertyGroup>

    <MakeDir Directories="$(DestinationFolder)" />
    <Exec Command="tar -xzf %(SymbolsTarball.Identity) -C $(DestinationFolder)"
          WorkingDirectory="$(SymbolsRoot)" />

    <Delete Files="%(SymbolsTarball.Identity)" />
  </Target>

  <!-- After building, repackage symbols into a single tarball. -->
  <Target Name="RepackageSymbols"
          AfterTargets="Build"
          DependsOnTargets="
            DetermineMicrosoftSourceBuildIntermediateInstallerVersion;
            DiscoverSymbolsTarballs;
            ExtractSymbolsTarballs">
    <PropertyGroup>
      <UnifiedSymbolsTarball>$(OutputPath)dotnet-symbols-$(MicrosoftSourceBuildIntermediateInstallerVersion)-$(TargetRid).tar.gz</UnifiedSymbolsTarball>
    </PropertyGroup>

    <Exec Command="tar --numeric-owner -czf $(UnifiedSymbolsTarball) *"
          WorkingDirectory="$(UnifiedSymbolsLayout)" />

    <Message Importance="High" Text="Packaged all symbols in '$(UnifiedSymbolsTarball)'" />
  </Target>

  <!-- After building, create the sdk symbols tarball. -->
  <Target Name="CreateSdkSymbolsTarball"
          AfterTargets="Build"
          DependsOnTargets="RepackageSymbols">
    <ItemGroup>
      <SdkTarballItem Include="$(OutputPath)dotnet-sdk-*$(TarBallExtension)"
                      Exclude="$(OutputPath)dotnet-sdk-symbols-*$(TarBallExtension)" />
    </ItemGroup>

    <PropertyGroup>
      <SdkSymbolsLayout>$(ArtifactsTmpDir)SdkSymbols</SdkSymbolsLayout>
      <SdkSymbolsTarball>$(OutputPath)dotnet-sdk-symbols-$(MicrosoftSourceBuildIntermediateInstallerVersion)-$(TargetRid).tar.gz</SdkSymbolsTarball>
      <SdkLayout>$(ArtifactsTmpDir)Sdk</SdkLayout>
      <SdkTarball>%(SdkTarballItem.Identity)</SdkTarball>
    </PropertyGroup>

    <MakeDir Directories="$(SdkLayout)" />
    <Exec Command="tar -xzf $(SdkTarball) -C $(SdkLayout)"
          WorkingDirectory="$(OutputPath)" />

    <CreateSdkSymbolsLayout SdkLayoutPath="$(SdkLayout)"
                            AllSymbolsPath="$(UnifiedSymbolsLayout)"
                            SdkSymbolsLayoutPath="$(SdkSymbolsLayout)"
                            FailOnMissingPDBs="true" />

    <Exec Command="tar --numeric-owner -czf $(SdkSymbolsTarball) *"
          WorkingDirectory="$(SdkSymbolsLayout)" />

    <Message Importance="High" Text="Packaged sdk symbols in '$(SdkSymbolsTarball)'" />

    <RemoveDir Directories="$(UnifiedSymbolsLayout)" />
    <RemoveDir Directories="$(SdkSymbolsLayout)" />
    <RemoveDir Directories="$(SdkLayout)" />
  </Target>

  <!--
    Dev scenario: rewrite a prebuilt-report. This makes it easy to add data to an existing
    prebuilt report without performing another full build. This doesn't reevalutate which packages
    are prebuilts or search the projects: it uses the existing usage.xml file to generate report
    XMLs based on the info put in artifacts/.
  -->
  <Target Name="RewritePrebuiltUsageReport">
    <MSBuild Projects="$(RepoProjectsDir)$(RootRepo).proj" Targets="ReportPrebuiltUsage" />
  </Target>

  <Target Name="ReportPoisonUsage"
          AfterTargets="Build"
          Condition="'$(EnablePoison)' == 'true'"
          Inputs="$(MSBuildProjectFullPath)"
          Outputs="$(CompletedSemaphorePath)ReportPoisonUsage.complete" >
    <ItemGroup>
      <FinalCliTarball Include="$(SourceBuiltTarBallPath)**/*$(TarBallExtension)" />
    </ItemGroup>

    <Message Importance="High" Text="[$([System.DateTime]::Now.ToString('HH:mm:ss.ff'))] Checking @(FinalCliTarball) for poisoned files." />

    <ItemGroup>
      <NonShippingPackagesList Include="$(PackageListsDir)**/$(NonShippingPackagesListPrefix)*" />
    </ItemGroup>

    <CheckForPoison FilesToCheck="@(FinalCliTarball)"
                    HashCatalogFilePath="$(PoisonReportDataFile)"
                    MarkerFileName="$(PoisonMarkerFile)"
                    PoisonReportOutputFilePath="$(PoisonUsageReportFile)"
                    NonShippingPackagesListFiles="@(NonShippingPackagesList)" />

    <WriteLinesToFile File="$(CompletedSemaphorePath)ReportPoisonUsage.complete" Overwrite="true" />
    <Message Importance="High" Text="[$([System.DateTime]::Now.ToString('HH:mm:ss.ff'))] Done checking for poison." />
  </Target>

  <Target Name="GeneratePrebuiltBurndownData"
          Inputs="$(MSBuildProjectFullPath)"
          Outputs="$(CompletedSemaphorePath)GeneratePrebuiltBurndownData.complete" >
    <WriteUsageBurndownData RootDirectory="$(ProjectDir)"
                            PrebuiltBaselineFile="$(BaselineDataFile)"
                            OutputFilePath="$(PrebuiltBurndownDataFile)" />

    <WriteLinesToFile File="$(CompletedSemaphorePath)GeneratePrebuiltBurndownData.complete" Overwrite="true" />
  </Target>

  <Target Name="RunSmokeTest">
    <ItemGroup>
      <SdkTarballItem Include="$(SourceBuiltTarBallPath)**/dotnet-sdk*$(TarBallExtension)"
                      Exclude="$(SourceBuiltTarBallPath)**/dotnet-sdk-symbols*$(TarBallExtension)" />
      <SourceBuiltArtifactsItem Include="$(SourceBuiltTarBallPath)**/Private.SourceBuilt.Artifacts.*$(TarBallExtension)" />
    </ItemGroup>

    <PropertyGroup>
      <CustomTestEnvVars Condition="'$(EnablePoison)' == 'true'">SMOKE_TESTS_POISON_REPORT_PATH=$(PoisonUsageReportFile);</CustomTestEnvVars>
      <SdkTarballPath>%(SdkTarballItem.Identity)</SdkTarballPath>
      <SourceBuiltArtifactsPath>%(SourceBuiltArtifactsItem.Identity)</SourceBuiltArtifactsPath>
      <SmokeTestConsoleVerbosity Condition="'$(SmokeTestConsoleVerbosity)' == ''">normal</SmokeTestConsoleVerbosity>
    </PropertyGroup>

    <!-- Multiple loggers are specified so that results are captured in trx and pipelines can fail with AzDO pipeline warnings -->
    <Exec Command="$(DotnetToolCommand) test $(SmokeTestsDir) --logger:trx --logger:'console;verbosity=$(SmokeTestConsoleVerbosity)' -c $(Configuration)"
          EnvironmentVariables="
            SMOKE_TESTS_SDK_TARBALL_PATH=$(SdkTarballPath);
            SMOKE_TESTS_SOURCEBUILT_ARTIFACTS_PATH=$(SourceBuiltArtifactsPath);
            SMOKE_TESTS_TARGET_RID=$(TargetRid);
            SMOKE_TESTS_PORTABLE_RID=$(PortableRid);
            SMOKE_TESTS_CUSTOM_PACKAGES_PATH=$(CustomSourceBuiltPackagesPath);
            $(CustomTestEnvVars)" />
  </Target>

  <Target Name="CreateSmokeTestPrereqsTarball"
          AfterTargets="RunSmokeTest"
          Condition="'$(SkipSmokeTestPrereqsTarballCreation)' != 'true'"
          DependsOnTargets="
            CheckIfCreateSmokeTestPrereqsExistToPack;
            CreateSmokeTestPrereqsTarballIfPrereqsExist"/>

  <Target Name="CheckIfCreateSmokeTestPrereqsExistToPack">
    <PropertyGroup>
      <SmokeTestsArtifactsDir>$(SmokeTestsDir)bin/$(Configuration)/net8.0/</SmokeTestsArtifactsDir>
      <SmokeTestsPackagesDir>$(SmokeTestsArtifactsDir)packages/</SmokeTestsPackagesDir>
    </PropertyGroup>

    <ItemGroup>
      <SmokeTestsPrereqs Include="$(SmokeTestsPackagesDir)**/*.nupkg" />
    </ItemGroup>

    <Message Text="Found @(SmokeTestsPrereqs->Count()) prereqs in '$(SmokeTestsPackagesDir)'." Importance="High" />
  </Target>

  <Target Name="CreateSmokeTestPrereqsTarballIfPrereqsExist"
          DependsOnTargets="DetermineMicrosoftSourceBuildIntermediateInstallerVersion"
          Condition="'@(SmokeTestsPrereqs->Count())' != '0'">
    <PropertyGroup>
      <SmokeTestPrereqsTarballName>$(OutputPath)dotnet-smoke-test-prereqs.$(MicrosoftSourceBuildIntermediateInstallerVersion).$(TargetRid).tar.gz</SmokeTestPrereqsTarballName>
      <SmokeTestsPrereqPackagesDir>$(SmokeTestsArtifactsDir)prereq-packages/</SmokeTestsPrereqPackagesDir>
    </PropertyGroup>

    <Copy SourceFiles="@(SmokeTestsPrereqs)"
          DestinationFolder="$(SmokeTestsPrereqPackagesDir)" />

    <Exec Command="tar --numeric-owner -czf $(SmokeTestPrereqsTarballName) ."
          WorkingDirectory="$(SmokeTestsPrereqPackagesDir)"/>

    <Message Importance="High" Text="Packaged smoke-test prereqs in '$(SmokeTestPrereqsTarballName)'" />
  </Target>

  <UsingTask AssemblyFile="$(XPlatSourceBuildTasksAssembly)" TaskName="UploadToAzure" />

  <Target Name="PublishPrebuiltReportData">
    <Error Text="RelativeBlobPath must be set to a non-empty string." Condition="'$(RelativeBlobPath)' == ''" />
    <Error Text="ContainerName must be set to a non-empty string." Condition="'$(ContainerName)' == ''" />
    <Error Text="AzureAccountName must be set to a non-empty string." Condition="'$(AzureAccountName)' == ''" />
    <Error Text="AzureAccessToken must be set to a non-empty string." Condition="'$(AzureAccessToken)' == ''" />

    <ItemGroup>
      <ItemsToPublish Include="$(PackageReportDir)*.xml" />
      <ItemsToPublish Include="$(PackageReportDir)*.csv" />
      <ItemsToPublish>
        <RelativeBlobPath>$(RelativeBlobPath)/%(Filename)%(Extension)</RelativeBlobPath>
      </ItemsToPublish>
    </ItemGroup>

    <Message Text="Uploading files to '$(AzureAccountName)' blob storage at $(ContainerName)/$(RelativeBlobPath)" />

    <UploadToAzure AccountName="$(AzureAccountName)"
                   AccountKey="$(AzureAccessToken)"
                   ContainerName="$(ContainerName)"
                   Items="@(ItemsToPublish)"
                   Overwrite="true" />
  </Target>

  <Target Name="CreatePrebuiltsTarball"
          AfterTargets="Build"
          DependsOnTargets="
            CheckIfPrebuiltsExistToPack;
            CreatePrebuiltsTarballIfPrebuiltsExist"/>

  <Target Name="CheckIfPrebuiltsExistToPack">
    <!-- Directory existence doesn't mean there are files inside. Use a pattern to find files. -->
    <ItemGroup>
      <PrebuiltFile Include="$(ResultingPrebuiltPackagesDir)**" />
    </ItemGroup>

    <Message Text="Found @(PrebuiltFile->Count()) files in prebuilt packages dir." Importance="High" />
  </Target>

  <Target Name="CreatePrebuiltsTarballIfPrebuiltsExist"
          DependsOnTargets="DetermineMicrosoftSourceBuildIntermediateInstallerVersion"
          Condition="'@(PrebuiltFile->Count())' != '0'">
    <PropertyGroup>
      <TarballFilePath>$(OutputPath)$(SourceBuiltPrebuiltsTarballName).$(MicrosoftSourceBuildIntermediateInstallerVersion).$(TargetRid).tar.gz</TarballFilePath>
      <TarballWorkingDir>$(ResultingPrebuiltPackagesDir)</TarballWorkingDir>
    </PropertyGroup>

    <Exec Command="tar --numeric-owner -zcf $(TarballFilePath) -C $(TarballWorkingDir) ." />

    <Message Text="Tarball '$(TarballFilePath)' was successfully created from '$(TarballWorkingDir)'" Importance="High" />
  </Target>
</Project>