ops.deploy.props

<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="11.0"
         DefaultTargets="Run"
         xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <!--
        The following ItemGroup defines which steps are taken during the deploy process. The order of the items in the item group
        determines in which order the deploy steps are executed.

        Each deploy step can define the following items:
        - Properties                                     - The semi-colon separated set of properties that should be passed to the script.
                                                           Properties are written as 'key=value'.
        - Groups                                         - All the groups that a given step belongs to. The user can elect to only run deploy steps for a given group.
        - PreSteps                                       - A semi-colon separated list of all additional scripts and their targets that should be executed before
                                                           the selected deploy step.
        - PostSteps                                      - A semi-colon separated list of all additional scripts and their targets that should be executed after
                                                           the selected deploy step.

        The metadata to the script that is about to be executed is passed to each pre-step under the following properties:

        - StepDescription : The full description of the step to be executed.
        - StepId          : The ID of the step. In general the name of the property that references the step file.
        - StepName        : The name of the step.
        - StepPath        : The full path to the script file for the step.

        Additionally all the standard properties as seen below and the properties for the given deploy step are passed in.

        The following ItemGroup defines which steps are taken during the deploy process. The order of the items in the item group
        determines in which order the deploy steps are executed.

        The following deploy steps are by default provided through the given properties:
        $(DeployStepsBuildTargetsAssembly) - Builds Visual Studio projects that contain MsBuild Tasks. Separate from building the standard Visual Studio
                                             solutions so that it is possible to build MsBuild tasks that will be used in the build process.
        $(DeployStepsGenerateTargetsFile)  - Generates a targets file for use with an MsBuild tasks assembly.
        $(DeployStepsPrepareRestoreNuGet)  - Restores the NuGet packages as specified in the '$(DirWorkspace)\packages.config' file. Additionally
                                             also restores the NuGet packages as specified in the nBuildKit specific 'packages.config' files.
        $(DeployStepsPrepareVcsBranch)     - When building from a GIT repository on Jenkins ensures that the current checkout has the same branch
                                             name as the remote tracking branch.
        $(DeployStepsPrepareGetVersion)    - Gathers version information and stores it in a temporary file for use by the rest of the deploy process.
                                             Currently supported methods of gathering version information are using (in order):
                                             - The version defined by a custom MsBuild task which is defined in a file of which the path is stored
                                               in the 'VersionScriptPath' property. The task should output:
                                                 - VersionMajor
                                                 - VersionMinor
                                                 - VersionPatch
                                                 - VersionBuild
                                                 - VersionPreRelease
                                                 - VersionSemantic
                                                 - VersionSemanticFull
                                                 - VersionSemanticNuget
                                             - The version stored in an 'version.xml' file which contains an MsBuild property group with
                                               the properties:
                                                 - BuildNumber
                                                 - VersionMajor
                                                 - VersionMinor
                                                 - VersionPatch
                                                 - VersionBuild
                                                 - VersionPreRelease
                                             - The GitVersion tool (https://github.com/ParticularLabs/GitVersion)
                                             - The GitHubFlowVersion tool (https://github.com/JakeGinnivan/GitHubFlowVersion)
        $(DeployStepsPrepareTagVcs)        - Tags the current commit with the version number. Currently supported version control systems are TFS and GIT.
        $(DeployStepsPrepareGetIssueIds)   - Gets the issue IDs from the commits on the current branch and stores them in a temp file for later use.
        $(DeployStepsPushToTags)           - Pushes the tags to a remote git repository
        $(DeployStepsPushToNuget)          - Pushes one or more artifacts to a NuGet feed
        $(DeployStepsPushToDirectory)      - Pushes one or more artifacts to a directory
        $(DeployStepsPushToSymbolServer)   - Pushes one or more NuGet symbol packages to a local symbol server on a UNC path
        $(DeployStepsPushToGitHubRelease)  - Pushes zero or more files to a GitHub release
        $(DeployStepsPushToGitBranch)      - Pushes zero or more files to a Git branch. Any files that currently exist on that branch are removed
                                             and replaced by the specified files.
        $(DeployStepsPushToGitRepository)  - Pushes an archived local workspace to a Git repository.

        Additional deploy steps can be defined by providing the path to the MsBuild script that should be executed
        for that step, e.g. adding a deploy step that points to the 'c:\stuff\MyCoolScript.msbuild' will execute
        that script.

        Each script has the following properties passed to it:
        $(ShouldDisplayDebugLog)          - A flag indicating whether or not to display debug log information, usually at the start of the script execution.
        $(NBuildKitVersion)               - The full version of the nBuildKit library that is executing the build.
        $(DirNBuildKitMsBuild)            - The full path to the directory that contains the nBuildKit scripts.
        $(DirNBuildKitMsBuildShared)      - The full path to the directory that contains the shared nBuildkit scripts.
        $(DirNBuildKitMsBuildExtensions)  - The full path to the directory that contains the nBuildKit extension scripts.
        $(DirNBuildKitMsBuildTemplates)   - The full path to the directory that contains the nBuildKit templates.
    -->
    <ItemGroup>
        <!--
        <DeployStepsToExecute Include="$(DeployStepsBuildTargetsAssembly)">
            <Properties>
            </Properties>
            <Groups>
                Bootstrap;
            </Groups>
            <PreSteps>
            </PreSteps>
            <PostSteps>
            </PostSteps>
        </DeployStepsToExecute>
        <DeployStepsToExecute Include="$(DeployStepsGenerateTargetsFile)">
            <Properties>
            </Properties>
            <Groups>
                Bootstrap;
            </Groups>
            <PreSteps>
            </PreSteps>
            <PostSteps>
            </PostSteps>
        </DeployStepsToExecute>
        -->

        <DeployStepsToExecute Include="$(DeployStepsRestoreNuGet)">
            <Properties>
            </Properties>
            <Groups>
                NuGet;
                Prepare;
                Restore;
            </Groups>
            <PreSteps>
            </PreSteps>
            <PostSteps>
            </PostSteps>
        </DeployStepsToExecute>

        <!--
            The following steps need to be executed on the original branch (i.e. the branch we are interested in
            building.
        -->
        <DeployStepsToExecute Include="$(DeployStepsPrepareVcsBranch)">
            <Properties>
            </Properties>
            <Groups>
                Prepare;
            </Groups>
            <PreSteps>
            </PreSteps>
            <PostSteps>
            </PostSteps>
        </DeployStepsToExecute>
        <DeployStepsToExecute Include="$(DeployStepsPrepareGetIssueIds)">
            <Properties>
            </Properties>
            <Groups>
                Prepare;
            </Groups>
            <PreSteps>
            </PreSteps>
            <PostSteps>
            </PostSteps>
        </DeployStepsToExecute>

        <!--
            All steps from here on may be executed on a different branch than the orginal branch we we started the
            build on because we might have done some merging / restoring from a different repository.
        -->
        <DeployStepsToExecute Include="$(DeployStepsPrepareGetVersion)">
            <Properties>
            </Properties>
            <Groups>
                Prepare;
            </Groups>
            <PreSteps>
            </PreSteps>
            <PostSteps>
            </PostSteps>
        </DeployStepsToExecute>

        <DeployStepsToExecute Include="$(DeployStepsPrepareReleaseNotes)">
            <Properties>
            </Properties>
            <Groups>
                prepare;
                prepare.get;
                prepare.get.releasenotes;
            </Groups>
            <PreSteps>
            </PreSteps>
            <PostSteps>
            </PostSteps>
        </DeployStepsToExecute>
        <!--
        <DeployStepsToExecute Include="$(DeployStepsPrepareTagVcs)">
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform);
            </Properties>
            <Groups>
                Prepare;
                Tag;
            </Groups>
            <PreSteps>
            </PreSteps>
            <PostSteps>
            </PostSteps>
        </DeployStepsToExecute>
        -->
        <!--
        <DeployStepsToExecute Include="$(DeployStepsPushToTags)">
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform);
            </Properties>
            <Groups>
                Tag;
                Push;
            </Groups>
            <PreSteps>
            </PreSteps>
            <PostSteps>
            </PostSteps>
        </DeployStepsToExecute>
        -->
        <!--
        <DeployStepsToExecute Include="$(DeployStepsPushToDirectory)">
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform);
            </Properties>
            <Groups>
                Directory;
                Push;
            </Groups>
            <PreSteps>
            </PreSteps>
            <PostSteps>
            </PostSteps>
        </DeployStepsToExecute>
        <DeployStepsToExecute Include="$(DeployStepsPushToSymbolServer)">
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform);
            </Properties>
            <Groups>
                Push;
                SymbolServer;
            </Groups>
            <PreSteps>
            </PreSteps>
            <PostSteps>
            </PostSteps>
        </DeployStepsToExecute>
        -->
        <DeployStepsToExecute Include="$(DeployStepsPushToGitHubRelease)">
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform);
            </Properties>
            <Groups>
                GitHub;
                Push;
            </Groups>
            <PreSteps>
            </PreSteps>
            <PostSteps>
            </PostSteps>
        </DeployStepsToExecute>
        <!--
        <DeployStepsToExecute Include="$(DeployStepsPushToGitBranch)">
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform);
            </Properties>
            <Groups>
                Git;
                Push;
            </Groups>
            <PreSteps>
            </PreSteps>
            <PostSteps>
            </PostSteps>
        </DeployStepsToExecute>
        <DeployStepsToExecute Include="$(DeployStepsPushToGitRepository)">
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform);
            </Properties>
            <Groups>
                Git;
                Push;
            </Groups>
            <PreSteps>
            </PreSteps>
            <PostSteps>
            </PostSteps>
        </DeployStepsToExecute>
        -->

        <!--
            The last step is pushing to NuGet because we can't remove packages from NuGet
        -->
        <DeployStepsToExecute
            Condition=" '$(IsMasterBranch)' == 'true' "
            Include="$(DeployStepsPushToNuget)">
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform);
            </Properties>
            <Groups>
                deploy;
                deploy.package.nuget;
            </Groups>
            <PreSteps>
            </PreSteps>
            <PostSteps>
            </PostSteps>
        </DeployStepsToExecute>
    </ItemGroup>

    <!--
        Define the scripts that should be executed when any one of the deploy steps fails.

        Steps can be defined by providing the path to the MsBuild script that should be executed
        for that step, e.g. adding a deploy step that points to the 'c:\stuff\MyCoolScript.msbuild' will execute
        that script.

        Each script has the following properties passed to it:
        $(SharedPropertyFile)             - The full path to the settings.props file (i.e. this file).
        $(ShouldDisplayDebugLog)         - A flag indicating whether or not to display debug log information, usually at the start of the script execution.
        $(NBuildKitVersion)              - The full version of the nBuildKit library that is executing the build.
        $(DirNBuildKitMsBuild)           - The full path to the directory that contains the nBuildKit scripts.
        $(DirNBuildKitMsBuildShared)     - The full path to the directory that contains the shared nBuildkit scripts.
        $(DirNBuildKitMsBuildExtensions) - The full path to the directory that contains the nBuildKit extension scripts.
        $(DirNBuildKitMsBuildTemplates)  - The full path to the directory that contains the nBuildKit templates.

        Additionally any properties defined by the 'Properties' section are also pushed up.
    -->
    <ItemGroup>
        <!--
        <DeployFailureStepsToExecute Include="">
            <Properties>
            </Properties>
        </DeployFailureStepsToExecute>
        -->
    </ItemGroup>

    <!--
        The following item group stores metadata describing the custom deploy steps that are executed in the deploy process.
        By providing this metadata it is possible for pre- and post-step actions to more clearly determine which step
        they were attached to.
    -->
    <ItemGroup>
        <!--
        <AvailableStepMetadata Include="$([System.IO.Path]::GetFileName('$(DirWorkspace)\my.deploy.step.msbuild'))">
            <Description>
                The description for my cool deploy step
            </Description>
            <Id></Id>
            <Name>My deploy step</Name>
            <Path>$(DirWorkspace)\my.deploy.step.msbuild</Path>
        </AvailableStepMetadata>
        -->
    </ItemGroup>


    <!--
        **** PUSHTO - DIRECTORY / FILESERVER ****
    -->
    <!--
        The ItemGroup defining the files that should be pushed to a given deployment directory.

        The IncludedFiles and the ExcludedFiles are lists of files that
        should be included (or excluded) in the list of files to deploy. Each entry is separated by a semi-colon(;).

        The PushToDirectorySpecs, IncludedFiles and ExcludedFiles all allow the insertion of build templates,
        e.g. \\MyServer\${ProductNameInFilePath}\${VersionSemantic}
    -->
    <ItemGroup>
        <!--<PushToDirectorySpecs Include="\\MyServer\${ProductNameInFilePath}\${VersionSemantic}">
            <IncludedFiles>
                $(DirBuildDeploy)\myfile.zip
            </IncludedFiles>
            <ExcludedFiles>
            </ExcludedFiles>
        </PushToDirectorySpecs>-->
    </ItemGroup>


    <!--
        **** PUSHTO - NUGET ****
    -->
    <PropertyGroup>
        <!--
            The URL to which all NuGet packages should be pushed. By default it pushes to nuget.org.
            If the repository needs authentication then the API key should be defined via an environment variable:
            NuGetApiKey - The NuGet API key for the NuGet feed
        -->
        <!--<NuGetSourceUrl Condition=" '$(NuGetSourceUrl)' == '' ">UNDEFINED</NuGetSourceUrl>-->
    </PropertyGroup>
    <!--
        The ItemGroup defining which packages should be pushed up to the NuGet package source.
        Allows build templates, e.g. $(DirBuildDeploy)\${VersionSemantic}\*.nupkg.
    -->
    <ItemGroup>
        <!--
        <NuGetPackagesToPush
            Condition=" '$(DirBuildDeploy)' != '' "
            Include="$(DirBuildDeploy)\*.nupkg"
            Exclude="$(DirBuildDeploy)\*.symbols.nupkg" />
        -->
    </ItemGroup>


    <!--
        **** PUSHTO - SYMBOL SERVER ****
    -->
    <!--
        The ItemGroup defining which symbol packages should be pushed up to the symbol server.
        Allows build templates, e.g. $(DirBuildDeploy)\${VersionSemantic}\*.symbols.nupkg.
    -->
    <ItemGroup>
        <!--
        <SymbolPackagesToPush
            Condition=" '$(DirBuildDeploy)' != '' "
            Include="$(DirBuildDeploy)\*.symbols.nupkg" />
        -->
    </ItemGroup>


    <!--
        **** PUSHTO - GITHUB RELEASE ****
    -->
    <!--
        The ItemGroup defining the files that should be pushed to a GitHub release. All properties
        except for the Repository allow the use of build templates, e.g. $(DirBuildDeploy)\myarchive-${VersionSemantic}.zip
    -->
    <ItemGroup Condition=" '$(ShouldLoadPushToGitHubReleaseSpecs)' == 'true' ">
        <PushToGitHubReleaseSpecs Include="${VersionSemantic}">
            <Repository>$(GitHubRepositoryName)</Repository>
            <Description>${ReleaseNotes}</Description>
            <IncludedFiles>
            </IncludedFiles>
            <ExcludedFiles>
            </ExcludedFiles>
        </PushToGitHubReleaseSpecs>
    </ItemGroup>


    <!--
        **** PUSHTO - GIT BRANCH ****
    -->
    <!--
        The ItemGroup defining the files that should be pushed to a GIT branch. All properties
        allow the use of build templates, e.g. $(DirBuildDeploy)\myarchive-${VersionSemantic}.zip
    -->
    <ItemGroup>
        <!--
        <PushToGitBranchSpecs
            Condition=" '$(DirBuildDeploy)' != '' "
            Include="$(DirBuildDeploy)\myarchive-${VersionSemantic}.zip">
            <Repository>$(GitRemoteRepository)</Repository>
            <Branch>master</Branch>
            <ExtractZipFiles>true</ExtractZipFiles>
            <CommitMessage>New changes</CommitMessage>
        </PushToGitBranchSpecs>
        -->
    </ItemGroup>


    <!--
        **** PUSHTO - GIT REPOSITORY ****
    -->
    <!--
        The ItemGroup defining the zip files containing a git workspace that should be pushed to a GIT repository.
        All properties allow the use of build templates, e.g. $(DirBuildDeploy)\myarchive-${VersionSemantic}.zip
    -->
    <ItemGroup Condition=" '@(PushToGitRepositorySpecs)' == '' ">
        <!--
        <PushToGitRepositorySpecs
            Condition=" '$(DirBuildDeploy)' != '' "
            Include="$(DirBuildDeploy)\myarchive-${VersionSemantic}.zip">
            <Repository>$(GitRemoteRepository)</Repository>
        </PushToGitRepositorySpecs>
        -->
    </ItemGroup>






    <!--
        *****************************************
        *                                       *
        *   TOOLS-OPS SPECIFIC SETTINGS    *
        *                                       *
        *****************************************
    -->

    <PropertyGroup>
        <OpsConfigurationVersion>0.1</OpsConfigurationVersion>
    </PropertyGroup>
</Project>