CODEWITHSUNDEEP
functionpowershellmodulescope
mark
mark

Reputation: 62804

Is it possible to have a module function that modifies parameter values of the caller script?

Motivation

Reduce the maintenance of an Azure DevOps task that invokes a Powershell script with a lot of parameters ("a lot" could be 5).

The idea relies on the fact that Azure DevOps generates environment variables to reflect the build variables. So, I devised the following scheme:

  1. Prefix all non secret Azure DevOps variables with MyBuild.
  2. The task powershell script would call a function to check the script parameters against the MyBuild_ environment variables and would automatically assign the value of the MyBuild_xyz environment variable to the script parameter xyz if the latter has no value.

This way the task command line would only contain secret parameters (which are not reflected in the environment). Often, there are no secret parameters and so the command line remains empty. We find this scheme to reduce the maintenance of the tasks driven by a powershell script.

Example

param(
    $DBUser,
    [ValidateNotNullOrEmpty()]$DBPassword,
    $DBServer,
    $Configuration,
    $Solutions,
    $ClientDB = $env:Build_DefinitionName,
    $RawBuildVersion = $env:Build_BuildNumber,
    $BuildDefinition = $env:Build_DefinitionName,
    $Changeset = $env:Build_SourceVersion,
    $OutDir = $env:Build_BinariesDirectory,
    $TempDir,
    [Switch]$EnforceNoMetadataStoreChanges
)

$ErrorActionPreference = "Stop"

. $PSScriptRoot\AutomationBootstrap.ps1
$AutomationScripts = GetToolPackage DevOpsAutomation

. "$AutomationScripts\vNext\DefaultParameterValueBinding.ps1" $PSCommandPath -Required 'ClientDB' -Props @{
    OutDir = @{ DefaultValue = [io.path]::GetFullPath("$PSScriptRoot\..\..\bin") }
    TempDir = @{ DefaultValue = 'D:\_gctemp' }
    DBUser = @{ DefaultValue = 'SomeUser' }
}

The described parameter binding logic is implemented in the script DefaultParameterValueBinding.ps1 which is published in a NuGet package. The code installs the package and thus gets access to the script.

In the example above, some parameters default to predefined Azure Devops variables, like $RawBuildVersion = $env:Build_BuildNumber. Some are left uninitialized, like $DBServer, which means it would default to $env:MyBuild_DBServer.

We can get away without the special function to do the binding, but then the script author would have to write something like this:

$DBServer = $env:MyBuild_DBServer,
$Configuration = $env:MyBuild_Configuration,
$Solutions = $env:MyBuild_Solutions,

I wanted to avoid this, because of the possibility of an accidental name mismatch.

The Problem

The approach does not work when I package the logic of DefaultParameterValueBinding.ps1 into a module function. This is because of the module scope isolation - I just cannot modify the parameters of the caller script.

Is it still possible to do? Is it possible to achieve my goal in a more elegant way? Remember, I want to reduce the cost associated with maintaining the task command line in Azure DevOps.

Right now I am inclined to retreat back to this scheme:

$xyz = $(Resolve-ParameterValue 'xyz' x y z ...)

Where Resolve-ParameterValue would first check $env:MyBuild_xyz and if not found select the first not null value out of x,y,z,...

But if the Resolve-ParameterValue method comes from a module, then the script must assume the module has already been installed, because it has no way to install it before the parameters are evaluated. Or has it?

EDIT 1

Notice the command line used to invoke the DefaultParameterValueBinding.ps1 script does not contain the caller script parameters! It does include $PSCommandPath, which is used to obtain the PSBoundParameters collection.

Upvotes: 0

Views: 43

Answers (1)

Adam
Adam

Reputation: 4168

Yea, but it will require modifications to the calling script and the function. Pass the parameters by reference. Adam B. has a nice piece on passing parameters by reference in the following:

https://mcpmag.com/articles/2015/06/04/reference-variables-in-powershell.aspx

Net-net, the following is an example:

$age = 12;

function birthday {
  param([ref]$age)
  $age.value += 1
}

birthday -age ([ref]$age)

Write-Output $age

I've got an age of 12. I pass it into a function as a parameter. The function increments the value of $age by 1. You can do the same thing with a function in a module. You get my drift.

Upvotes: 1

Related Questions