From d0ac4624f76ce5a9de6cdb7da32f455c3561b4c4 Mon Sep 17 00:00:00 2001 From: "Yuting Chen[MSFT]" Date: Mon, 18 Jul 2016 15:28:35 -0700 Subject: [PATCH 1/5] Add new module for runbooks --- AzureAutomationRunbook | 1 + 1 file changed, 1 insertion(+) create mode 100644 AzureAutomationRunbook diff --git a/AzureAutomationRunbook b/AzureAutomationRunbook new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/AzureAutomationRunbook @@ -0,0 +1 @@ + From 537b30e81e52b8004a4df0cab0ad8d5802e9cbf1 Mon Sep 17 00:00:00 2001 From: "Yuting Chen[MSFT]" Date: Mon, 18 Jul 2016 15:28:53 -0700 Subject: [PATCH 2/5] Delete AzureAutomationRunbook --- AzureAutomationRunbook | 1 - 1 file changed, 1 deletion(-) delete mode 100644 AzureAutomationRunbook diff --git a/AzureAutomationRunbook b/AzureAutomationRunbook deleted file mode 100644 index 8b13789..0000000 --- a/AzureAutomationRunbook +++ /dev/null @@ -1 +0,0 @@ - From f649469112846191687ffdcda245b0a517ee84db Mon Sep 17 00:00:00 2001 From: Yuting Chen Date: Mon, 18 Jul 2016 16:37:06 -0700 Subject: [PATCH 3/5] Add AzureAutomationRunbook module --- .../AzureAutomationRunbook.Resource.psd1 | Bin 0 -> 3632 bytes .../AzureAutomationRunbook.psd1 | Bin 0 -> 3124 bytes .../AzureAutomationRunbook.psm1 | 839 ++++++++++++++++++ .../Orchestrator.GraphRunbook.Model.dll | Bin 0 -> 58664 bytes 4 files changed, 839 insertions(+) create mode 100644 AzureAutomationRunbook/AzureAutomationRunbook.Resource.psd1 create mode 100644 AzureAutomationRunbook/AzureAutomationRunbook.psd1 create mode 100644 AzureAutomationRunbook/AzureAutomationRunbook.psm1 create mode 100644 AzureAutomationRunbook/Orchestrator.GraphRunbook.Model.dll diff --git a/AzureAutomationRunbook/AzureAutomationRunbook.Resource.psd1 b/AzureAutomationRunbook/AzureAutomationRunbook.Resource.psd1 new file mode 100644 index 0000000000000000000000000000000000000000..add82b1402ad060f511d204a32039a0d9007d1e9 GIT binary patch literal 3632 zcmds)-A@xi6vgkeiT}eSKA?#bc{OPwiWm|=0HvwF$BU}xR`KIeN_8e-|%?~tWyn{%Si z(;OcY8zsJuc<$L(EFH5$k!f#_=S|`&@v&9&@fhnPjD+;qqc#PDU2+r-uk3_xs@9l# z?RZ?e;QZD$7FjFbBX;fECv3=)Yg~KYZos^-k67!1+&Os8`Q;Qp6Y$-|#}HIo*5m@!^V==(l=jFGGLk=HPE-~v3dt_(J+X&7gcM&PG@QU#=GT2p0IlUN^pR@VPDt328}cqzTl0UZ#P zTV167ANj~sU-47Q`VHm`e1z(${OQ=?$|Kz`gw@CDwKY&YtEa4VHFkbHbwYMh z5Usz%%E`i-CdI1wq@TfOT_Mz&(&m&2xp*8iEzJGEtr%0&ZkQO6mvIJ^3*Wb?qUN6F ziMSLLGoHF1wmE&T_*+#h#`sX(z8_i-(d%Y)Z)!(m`2UN+hvoDST9!jUGPOCm>T^DK zGG+O?Q%mnvVU84D6|47?(!XoP>6L0$I>T~ttjZui$L5I|=CwWNW4&DSy_eHuX|SeR p(B)8_pu@*>wtBnC-&RAno6~6>-A&aj#2WtJsK0@4@P4kC{{jgLM;| zne}a-wZ5G&AJ~O8?8wO2fvby!GZ z-MN)Q|emrA8 zb1NxQvMD^;NnGqQ#+=zrxjN#kA{khi*fyuyU^-{L%D)^I6}&r~oZPG6s85|p@G#&{ z>=w&DQa9KT`iybpFcetMBKyOV{}+)DRo@lI1RVqS_WtDH?_j%2yt>TfxoS)tQ+-H! zNdE8ovsfhLm)Mw)1H~_Mx-Zc>o>;5miM7tEbLknQCv`DNsr4dnMO123s_=Uog}?vO zTXP82SA<7+{d*WmcbblkVq1;6XVjw1DexBFEMi}5j`OJa6z5g{ zBhY&GwAoQMl;ts=sh=kFiEFqlxt8tG={_-!b*K`2AGu|w9e+0AoT@hAR9s{AO8-{X zs}>F)RR`1T_Y8hWEh-B1q7?=UfPcHh>{KJxNX=sU1aH@;$~y+c;dCi6XFIk2znrAQpP zEJ{WgQs<3$RkLQf91GzJNS+?9V~2JHvO?Ms$Nz?~ld=gW}Wxk-APTvcCn>`YtN|3nnLS1N&g# zUEdy}KcKGNsm`jc8gZ9T$pd~h+amAkBh&ZTI~Icgoyb%F3_Zd6xbc e7w0i1M1Q(Y;&1S{vc%E5_pHB@V&4C9O#KUgaQJNi literal 0 HcmV?d00001 diff --git a/AzureAutomationRunbook/AzureAutomationRunbook.psm1 b/AzureAutomationRunbook/AzureAutomationRunbook.psm1 new file mode 100644 index 0000000..05bfb7b --- /dev/null +++ b/AzureAutomationRunbook/AzureAutomationRunbook.psm1 @@ -0,0 +1,839 @@ + +######################################################################################### +# +# Copyright (c) Microsoft Corporation. All rights reserved. +# +# AzureGraphRunbook Module +# +######################################################################################### + +Microsoft.PowerShell.Core\Set-StrictMode -Version Latest + +Microsoft.PowerShell.Utility\Import-LocalizedData LocalizedData -filename AzureAutomationRunbook.Resource.psd1 + +#region *-Runbook cmdlets +function Publish-Runbook +{ + <# + .ExternalHelp AzureGraphRunbook.psm1-help.xml + #> + [CmdletBinding(SupportsShouldProcess=$true, + PositionalBinding=$false)] + Param + ( + [Parameter(Mandatory=$true, + Position=0, + ValueFromPipelineByPropertyName=$true)] + [ValidateNotNullOrEmpty()] + [string] + $Path, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [string] + $NuGetApiKey, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [string] + $Repository, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [string] + $Description, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [Version] + $Version, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [string] + $Author, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [Guid] + $Guid, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [String] + $CompanyName, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [string] + $Copyright, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [string[]] + $Tags, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [Uri] + $ProjectUri, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [Uri] + $LicenseUri, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [Uri] + $IconUri, + + [Parameter()] + [string] + $ReleaseNotes + ) + + Process + { + <# + Publishes the specified graph runbook to the target repository. + + Following operations are performed by the Publish-AzureGraphRunbook cmdlet: + - Checks for the existence of .graphrunbook file and folder name should be + - Validates the .graphrunbook file contents. + - Creates or Updates the PowerShell module manifest file using specified metadata parameters. + - Validates the existence of specified repository name. + - NuGetApiKey is required for a web-based repository. + - Graph runbook folder will be published to the specified repository + #> + + $ev = $null + $repo = PowerShellGet\Get-PSRepository -Name $Repository -ErrorVariable ev + if($ev) + { + return + } + + $GraphRunbookBase = Validate-AzureGraphRunbookFolder -Path $Path -CallerPSCmdlet $PSCmdlet + + if($GraphRunbookBase) + { + if($Repository) + { + $null = $PSBoundParameters.Remove('Repository') + } + + if($NuGetApiKey) + { + $null = $PSBoundParameters.Remove('NuGetApiKey') + } + + + $GraphRunbookName = Split-Path -Path $GraphRunbookBase -Leaf + $ModulePathWithVersion = $false + + # if the Leaf of the $resolvedPath is a version, use its parent folder name as the module name + $ModuleVersion = New-Object System.Version + if([System.Version]::TryParse($GraphRunbookName, ([ref]$ModuleVersion))) + { + $GraphRunbookName = Microsoft.PowerShell.Management\Split-Path -Path (Microsoft.PowerShell.Management\Split-Path $GraphRunbookBase -Parent) -Leaf + $modulePathWithVersion = $true + } + + $GraphRunbookFileName = "$GraphRunbookName.graphrunbook" + $ManifestFileName = "$GraphRunbookName.psd1" + + $GraphRunbookFilePath = Join-Path -Path $GraphRunbookBase -ChildPath $GraphRunbookFileName + $ManifestFilePath = Join-Path -Path $GraphRunbookBase -ChildPath $ManifestFileName + + $ev = $null + + if((Microsoft.PowerShell.Management\Test-Path -Path $ManifestFilePath -PathType Leaf) -and + (Microsoft.PowerShell.Core\Test-ModuleManifest -Path $ManifestFilePath -ErrorAction SilentlyContinue)) + { + Update-AzureGraphRunbookManifest @PSBoundParameters -ErrorVariable ev + } + else + { + if(-not $Description) + { + $message = $LocalizedData.DescriptionParameterIsRequired -f ($GraphRunbookBase) + ThrowError -ExceptionName 'System.ArgumentException' ` + -ExceptionMessage $message ` + -ErrorId 'DescriptionParameterIsRequired' ` + -CallerPSCmdlet $PSCmdlet ` + -ErrorCategory InvalidArgument ` + -ExceptionObject $GraphRunbookBase + return + } + if($modulePathWithVersion) + { + $PSBoundParameters['Version'] = $ModuleVersion + } + New-AzureGraphRunbookManifest @PSBoundParameters -ErrorVariable ev + } + + #if($ev) + #{ + # return + #} + } + + $publishParameters = @{Path = $Path} + if($Repository) + { + $publishParameters['Repository'] = $Repository + } + + if($NuGetApiKey) + { + $publishParameters['NuGetApiKey'] = $NuGetApiKey + } + + if(Validate-AzureGraphRunbookFolder -Path $Path -ValidateManifest -CallerPSCmdlet $PSCmdlet) + { + $test = $publishParameters + PowerShellGet\Publish-Module @publishParameters ` + -Verbose:$VerbosePreference ` + -Debug:$DebugPreference ` + -WarningAction $WarningPreference ` + -ErrorAction $ErrorActionPreference + } + } +} + +function Find-Runbook +{ + <# + .ExternalHelp AzureGraphRunbook.psm1-help.xml + #> + [CmdletBinding()] + [outputtype("PSCustomObject[]")] + Param + ( + [Parameter(ValueFromPipelineByPropertyName=$true, + Position=0)] + [ValidateNotNullOrEmpty()] + [string[]] + $Name, + + [Parameter()] + [ValidateNotNull()] + [Version] + $MinimumVersion, + + [Parameter()] + [ValidateNotNull()] + [Version] + $MaximumVersion, + + [Parameter()] + [ValidateNotNull()] + [Version] + $RequiredVersion, + + [Parameter()] + [switch] + $AllVersions, + + [Parameter()] + [ValidateNotNull()] + [string] + $Filter, + + [Parameter()] + [ValidateNotNull()] + [string[]] + $Tag, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [string[]] + $Repository + ) + + Begin + { + } + + Process + { + if(-not $Tag) + { + $Tag = @() + } + + $Tag += 'Runbook' + $PSBoundParameters['Tag'] = $Tag + + PowerShellGet\Find-Module @PSBoundParameters | Where-Object {($_.Tags -contains 'Runbook')} + } +} + +function Save-Runbook +{ + <# + .ExternalHelp AzureGraphRunbook.psm1-help.xml + #> + [CmdletBinding(DefaultParameterSetName='NameAndPathParameterSet', + SupportsShouldProcess=$true)] + Param + ( + [Parameter(Mandatory=$true, + ValueFromPipelineByPropertyName=$true, + Position=0, + ParameterSetName='NameAndPathParameterSet')] + [ValidateNotNullOrEmpty()] + [string[]] + $Name, + + [Parameter(Mandatory=$true, + ValueFromPipeline=$true, + ValueFromPipelineByPropertyName=$true, + Position=0, + ParameterSetName='InputOjectAndPathParameterSet')] + [ValidateNotNull()] + [PSCustomObject[]] + $InputObject, + + [Parameter(ValueFromPipelineByPropertyName=$true, + ParameterSetName='NameAndPathParameterSet')] + [ValidateNotNull()] + [Version] + $MinimumVersion, + + [Parameter(ValueFromPipelineByPropertyName=$true, + ParameterSetName='NameAndPathParameterSet')] + [ValidateNotNull()] + [Version] + $MaximumVersion, + + [Parameter(ValueFromPipelineByPropertyName=$true, + ParameterSetName='NameAndPathParameterSet')] + [ValidateNotNull()] + [Version] + $RequiredVersion, + + [Parameter(ValueFromPipelineByPropertyName=$true, + ParameterSetName='NameAndPathParameterSet')] + [ValidateNotNullOrEmpty()] + [string[]] + $Repository, + + [Parameter(Mandatory=$true, ParameterSetName='NameAndPathParameterSet')] + [Parameter(Mandatory=$true, ParameterSetName='InputOjectAndPathParameterSet')] + [string] + $Path, + + [Parameter()] + [switch] + $Force + ) + + Process + { + $Null = $PSBoundParameters.Remove("Path") + $RunbookToSave= Find-Runbook @PSBoundParameters + $PSBoundParameters['Path'] = $Path + PowerShellGet\Save-Module @PSBoundParameters + } +} + +#endregion *-AzureGraphRunbook cmdlets + + +function Validate-AzureGraphRunbook +{ + [CmdletBinding()] + Param + ( + [Parameter(Mandatory=$true)] + [ValidateNotNullOrEmpty()] + [string] + $RunbookFilePath + ) + + Process + { + if(-not (Microsoft.PowerShell.Management\Test-Path -Path $RunbookFilePath -PathType Leaf)) + { + $message = $LocalizedData.PathNotFound -f ($RunbookFilePath) + ThrowError -ExceptionName 'System.ArgumentException' ` + -ExceptionMessage $message ` + -ErrorId 'TemplateFilePathNotFound' ` + -CallerPSCmdlet $PSCmdlet ` + -ErrorCategory InvalidArgument ` + -ExceptionObject $RunbookFilePath + return + } + + $SerializedRunbook = Microsoft.PowerShell.Management\Get-Content -Path $RunbookFilePath -Force + $RunbookContainer = $null + try + { + $RunbookContainer = [Orchestrator.GraphRunbook.Model.Serialization.RunbookSerializer]::DeserializeRunbookContainer($SerializedRunbook) + $GraphRunbook = [Orchestrator.GraphRunbook.Model.Serialization.RunbookSerializer]::GetRunbook($RunbookContainer) + } + catch + { + $message = $LocalizedData.InvalidGraphRunbookFile -f ($RunbookFilePath, "$_") + ThrowError -ExceptionName 'System.ArgumentException' ` + -ExceptionMessage $message ` + -ErrorId 'InvalidGraphRunbookFile' ` + -CallerPSCmdlet $PSCmdlet ` + -ErrorCategory InvalidArgument ` + -ExceptionObject $RunbookFilePath + return + } + + $Tags = @() + + if($RunbookContainer -and $RunbookContainer.RunbookType) + { + $Tags += "$($RunbookContainer.RunbookType)" + } + else + { + # Default runbook type is Graph Runbook Workflow + $Tags += 'GraphicalPSWFRunbook','Workflow' + } + if(-not ($Tags -Contains "Runbook")) + { + $Tags += 'Runbook' + } + if(-not ($Tags -Contains "AzureAutomation")) + { + $Tags += 'AzureAutomation' + } + + return $Tags + } +} + +function Validate-AzureGraphRunbookFolder +{ + [CmdletBinding()] + Param + ( + [Parameter(Mandatory=$true)] + [ValidateNotNullOrEmpty()] + [string] + $Path, + + [Parameter()] + [switch] + $ValidateManifest, + + [Parameter(Mandatory=$true)] + [ValidateNotNullOrEmpty()] + [System.Management.Automation.PSCmdlet] + $CallerPSCmdlet + ) + + Process + { + $GraphRunbookPath =Resolve-PathHelper -Path $Path -CallerPSCmdlet $PSCmdlet | Microsoft.PowerShell.Utility\Select-Object -First 1 + + if(-not $GraphRunbookPath -or -not (Microsoft.PowerShell.Management\Test-Path -Path $GraphRunbookPath -PathType Container)) + { + if(-not $GraphRunbookPath -or -not (Microsoft.PowerShell.Management\Test-Path -LiteralPath $GraphRunbookPath -PathType Container)) + { + $message = $LocalizedData.PathNotFound -f ($Path) + ThrowError -ExceptionName 'System.ArgumentException' ` + -ExceptionMessage $message ` + -ErrorId 'GraphRunbookPathNotFound' ` + -CallerPSCmdlet $CallerPSCmdlet ` + -ErrorCategory InvalidArgument ` + -ExceptionObject $Path + + return + } + } + + $GraphRunbookName = Microsoft.PowerShell.Management\Split-Path -Path $GraphRunbookPath -Leaf + $ModulePathWithVersion = $false + + # if the Leaf of the $resolvedPath is a version, use its parent folder name as the module name + $ModuleVersion = New-Object System.Version + if([System.Version]::TryParse($GraphRunbookName, ([ref]$ModuleVersion))) + { + $GraphRunbookName = Microsoft.PowerShell.Management\Split-Path -Path (Microsoft.PowerShell.Management\Split-Path $GraphRunbookPath -Parent) -Leaf + $modulePathWithVersion = $true + } + + $GraphRunbookFilePath = Join-Path -Path $GraphRunbookPath -ChildPath "$GraphRunbookName.graphrunbook" + + if(-not (Microsoft.PowerShell.Management\Test-Path -Path $GraphRunbookFilePath -PathType Leaf)) + { + $message = $LocalizedData.GraphRunbookFileIsMissing -f ($GraphRunbookFilePath, $Path) + ThrowError -ExceptionName 'System.ArgumentException' ` + -ExceptionMessage $message ` + -ErrorId 'GraphRunbookFileIsMissing' ` + -CallerPSCmdlet $CallerPSCmdlet ` + -ErrorCategory InvalidArgument ` + -ExceptionObject $GraphRunbookFilePath + return + } + + return $GraphRunbookPath + } +} + +function New-AzureGraphRunbookManifest +{ + <# + .ExternalHelp AzureGraphRunbook.psm1-help.xml + #> + [CmdletBinding(SupportsShouldProcess=$true, + PositionalBinding=$false)] + Param + ( + [Parameter(Mandatory=$true, + Position=0, + ValueFromPipelineByPropertyName=$true)] + [ValidateNotNullOrEmpty()] + [string] + $Path, + + [Parameter(Mandatory=$true)] + [ValidateNotNullOrEmpty()] + [string] + $Description, + + [Parameter(Mandatory=$true)] + [ValidateNotNullOrEmpty()] + [Version] + $Version, + + [Parameter(Mandatory=$true)] + [ValidateNotNullOrEmpty()] + [string] + $Author, + + [ValidateNotNullOrEmpty()] + [Guid] + $Guid, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [String] + $CompanyName, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [string] + $Copyright, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [string[]] + $Tags, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [Uri] + $ProjectUri, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [Uri] + $LicenseUri, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [Uri] + $IconUri, + + [Parameter()] + [string] + $ReleaseNotes + ) + + Process + { + if($Version) + { + $PSBoundParameters['ModuleVersion'] = $Version + $null = $PSBoundParameters.Remove('Version') + } + + $ModuleBasePath = Validate-AzureGraphRunbookFolder -Path $Path -CallerPSCmdlet $PSCmdlet + + if(-not $ModuleBasePath) + { + return + } + + $GraphRunbookName = Split-Path -Path $ModuleBasePath -Leaf + + # if the Leaf of the $resolvedPath is a version, use its parent folder name as the module name + $ModuleVersion = New-Object System.Version + if([System.Version]::TryParse($GraphRunbookName, ([ref]$ModuleVersion))) + { + $GraphRunbookName = Microsoft.PowerShell.Management\Split-Path -Path (Microsoft.PowerShell.Management\Split-Path $ModuleBasePath -Parent) -Leaf + $modulePathWithVersion = $true + } + + $GraphRunbookFileName = "$GraphRunbookName.graphrunbook" + $ManifestFileName = "$GraphRunbookName.psd1" + + $GraphRunbookFilePath = Join-Path -Path $ModuleBasePath -ChildPath $GraphRunbookFileName + $ManifestFilePath = Join-Path -Path $ModuleBasePath -ChildPath $ManifestFileName + + $PSBoundParameters['FileList'] = @($ManifestFileName, $GraphRunbookFileName) + $PSBoundParameters['Path'] = $ManifestFilePath + + $RunbookTags = Validate-AzureGraphRunbook -RunbookFilePath $GraphRunbookFilePath + + if(-not $RunbookTags) + { + return + } + + $Tags += @('AzureAutomation', 'Runbook') + $Tags += $RunbookTags + + $PSBoundParameters['Tags'] = $Tags | Select-Object -Unique + + Microsoft.PowerShell.Core\New-ModuleManifest @PSBoundParameters + } +} + +function Update-AzureGraphRunbookManifest +{ + <# + .ExternalHelp AzureGraphRunbook.psm1-help.xml + #> + [CmdletBinding(SupportsShouldProcess=$true, + PositionalBinding=$false)] + Param + ( + [Parameter(Mandatory=$true, + Position=0, + ValueFromPipelineByPropertyName=$true)] + [ValidateNotNullOrEmpty()] + [string] + $Path, + + [ValidateNotNullOrEmpty()] + [Guid] + $Guid, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [string] + $Author, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [String] + $CompanyName, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [string] + $Copyright, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [Version] + $Version, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [string] + $Description, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [string[]] + $Tags, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [Uri] + $ProjectUri, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [Uri] + $LicenseUri, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [Uri] + $IconUri, + + [Parameter()] + [string] + $ReleaseNotes + ) + + Process + { + if($Version) + { + $PSBoundParameters['ModuleVersion'] = $Version + $null = $PSBoundParameters.Remove('Version') + } + + $ModuleBasePath = Validate-AzureGraphRunbookFolder -Path $Path -ValidateManifest -CallerPSCmdlet $PSCmdlet + + if(-not $ModuleBasePath) + { + return + } + + $GraphRunbookName = Split-Path -Path $ModuleBasePath -Leaf + $ModulePathWithVersion = $false + + # if the Leaf of the $resolvedPath is a version, use its parent folder name as the module name + $ModuleVersion = New-Object System.Version + if([System.Version]::TryParse($GraphRunbookName, ([ref]$ModuleVersion))) + { + $GraphRunbookName = Microsoft.PowerShell.Management\Split-Path -Path (Microsoft.PowerShell.Management\Split-Path $ModuleBasePath -Parent) -Leaf + $modulePathWithVersion = $true + } + + $GraphRunbookFileName = "$GraphRunbookName.graphrunbook" + $ManifestFileName = "$GraphRunbookName.psd1" + + $GraphRunbookFilePath = Join-Path -Path $ModuleBasePath -ChildPath $GraphRunbookFileName + $ManifestFilePath = Join-Path -Path $ModuleBasePath -ChildPath $ManifestFileName + + $PSBoundParameters['FileList'] = @($ManifestFileName, $GraphRunbookFileName) + $PSBoundParameters['Path'] = $ManifestFilePath + + if(-not $Tags) + { + $moduleInfo = Microsoft.PowerShell.Core\Test-ModuleManifest -Path $ManifestFilePath + + # Remove the existing graph runbook resource tags, so that updated resource tags will be added later + if($moduleInfo -and $moduleInfo.Tags) + { + $Tags = $moduleInfo.Tags | Where-Object { + ($_ -ne 'GraphPowerShell') -and + ($_ -ne 'GraphPowerShellWorkflow') + } + } + } + else + { + $Tags += @('AzureAutomation') + } + + $RunbookTags = Validate-AzureGraphRunbook -RunbookFilePath $GraphRunbookFilePath + + if(-not $RunbookTags) + { + return + } + + $Tags += $RunbookTags + $PSBoundParameters['Tags'] = $Tags | Select-Object -Unique + $PSBoundParameters['Path'] = $ManifestFilePath + $test = $PSBoundParameters + PowerShellGet\Update-ModuleManifest @PSBoundParameters + } +} + +#region Common functions + +# Utility to throw an errorrecord +function ThrowError +{ + param + ( + [parameter(Mandatory = $true)] + [ValidateNotNullOrEmpty()] + [System.Management.Automation.PSCmdlet] + $CallerPSCmdlet, + + [parameter(Mandatory = $true)] + [ValidateNotNullOrEmpty()] + [System.String] + $ExceptionName, + + [parameter(Mandatory = $true)] + [ValidateNotNullOrEmpty()] + [System.String] + $ExceptionMessage, + + [System.Object] + $ExceptionObject, + + [parameter(Mandatory = $true)] + [ValidateNotNullOrEmpty()] + [System.String] + $ErrorId, + + [parameter(Mandatory = $true)] + [ValidateNotNull()] + [System.Management.Automation.ErrorCategory] + $ErrorCategory + ) + + $exception = New-Object $ExceptionName $ExceptionMessage; + $errorRecord = New-Object System.Management.Automation.ErrorRecord $exception, $ErrorId, $ErrorCategory, $ExceptionObject + $CallerPSCmdlet.ThrowTerminatingError($errorRecord) +} + +# Utility to support resolve full path +function Resolve-PathHelper +{ + param + ( + [Parameter()] + [ValidateNotNullOrEmpty()] + [string[]] + $path, + + [Parameter()] + [switch] + $isLiteralPath, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [System.Management.Automation.PSCmdlet] + $callerPSCmdlet + ) + + $resolvedPaths =@() + + foreach($currentPath in $path) + { + try + { + if($isLiteralPath) + { + $currentResolvedPaths = Microsoft.PowerShell.Management\Resolve-Path -LiteralPath $currentPath -ErrorAction Stop + } + else + { + $currentResolvedPaths = Microsoft.PowerShell.Management\Resolve-Path -Path $currentPath -ErrorAction Stop + } + } + catch + { + $errorMessage = ($LocalizedData.PathNotFound -f $currentPath) + ThrowError -ExceptionName "System.InvalidOperationException" ` + -ExceptionMessage $errorMessage ` + -ErrorId "PathNotFound" ` + -CallerPSCmdlet $callerPSCmdlet ` + -ErrorCategory InvalidOperation + } + + foreach($currentResolvedPath in $currentResolvedPaths) + { + $resolvedPaths += $currentResolvedPath.ProviderPath + } + } + + $resolvedPaths +} + +#endregion + +Export-ModuleMember -Function 'Publish-Runbook', + 'Find-Runbook', + 'Save-Runbook' diff --git a/AzureAutomationRunbook/Orchestrator.GraphRunbook.Model.dll b/AzureAutomationRunbook/Orchestrator.GraphRunbook.Model.dll new file mode 100644 index 0000000000000000000000000000000000000000..12c350e04fa3f812f575876ea41e18f41eafc85e GIT binary patch literal 58664 zcmeFad3;nw);C`F_TE{@Mo2;e&E6~torEnAkdOojJ0t{AkTgjHEg>DdJAsI3g2<=? zxPZ8!6A;`6cOAuX!3|f&ATGEe3=WDLprYdX`<_#`yKffM=Y5{%^ZVm{1NU^DrB0oy zI(4dU-EHbQR||s>!ieLy--LJ!zw|ej;qQY+uw%PF9xEQU?d|cHGG%X%vL)Vtqt@?R z>~}A7RJvaq)fAUjzZu#;2?&sZ;{L526G){fn;klsy%B}w@ zdTialzIlD(V=w&2*}oan0>lALfK z^8ij|P->)By3xt#?b1}pC6ldDewbVv=pxN@c9$0R&@6-#$l^GG;w&M8Oc+$(4N}yZ z0u59dXDTI7ywRCPDKu07qr>cUlHir$(z}9*(lhm?573H*AIM^50;SwUoUp2_4pmLn zt8!_o;9pXeOh6R|yH3@R4plAHs~V=MvWHa31XN*6=~RvEP}LQBRd90dc{q)6AgUVzSd zBs7b>VoDn#a>j>pasmVlCaH=OAizl_ffFELTuFjVpcU3q3H2xy@!gDS`R|KV!07Z4 z7X#7cL=-*)8)`d;)N-Pm>a3!C;laLyuz$1}?6$Up-B|-MjPvtJ8cH$Hq^+C)0i#V4 zH~|6%k0fvc1Pmfc-~W_1-tyxnYAMN;ZY2O+1rx_{wnx^QSIViE_;@gY#9OuxT$*p%C6B6>&sC){7I+ zg#jZ8oB#m>M-n&z0tSvGaAK`Cu~A_dJ8(}5${*2>$$6M6J2KpNpAZTS7;#dAOhmeV z3rlyLyh0jcO)17f+llCt&5?9^8ckd{7D zj~OE%EN5gn(kbPr2*?q^Jit$5Zdb&gxJ-i&CE5*8lISvtxzJ^T4wBp(ku>;XQA_7< z0D}fQVVd1(g?pu}$AqKU&B+E|G+5irU8LYPvlFJ;11J`&X|9sNH&!c#%eh-u&PV!k z{v9eOGs@WsMQAzD1MDu`?#VcX0pptDLzPn8%9 zFVGoIePHm7(+qFhKF9QSd&xXZ)#3KBBdu$nWn3!ShXmWS4|S`-SIEWGP|Kf=XkJNO zXYdt)39pc`b&?DO>PqyM(OFC^n)5Le&}m?Nz>T75kw9$K`5mZOBrF6mFdni_l@9=WbcE`h27+%oKwt)d-P}lWEIc6X zVz>?s-A4W`cN$TezX4g9;hTvJ12pP=9a3Wq9my7SNWG;)>XRK(k90`wZ|tbFrVgpE zcS!xRLuwyWM|xLvNZrvPb$^G{D04@83tLmelYJ^0Uw8UiipIz3s~6JYljp7^f=G+; zEhiC~KuEuZ9D`@=GU_z=1o=iXeld&3tIqDoX*W0>_=z%G0vS?~Z#D_*{mCFOv}x}p z-ry?-Gt;83Jda8<_~rmj@tqCm!!WgD1xu7JOffrqK%@UM80*BiBLfmK&yyW7Uf{YV+(1UOuZwNpEHbJ_Px{DD; zjOGNzw*a(3QI;faF>M*(>%1;(zct-6P+A0u%Fd-likci%C`{N%(Po&XPcr_i`iEN%+}@X z7@Kv2H)lWMoKax-iFndM1tuDk6HNn0#v9{Jq{l-gn|+J$6K!FIR@N1x+AO}spjw@M zVGpZ~H+4BX(G+irht)Yx$+L5LIa)f@Y{+5Kv^E zQ zj3u9E9>Av!Fn1&hY8Wakz*br?%-8L7j%v<%i^DJ@u`g(Xv4;E-V~tp#iHFxIst zUx%f)jMiZpEn{_9x0Vte*1ZLTt1HhG+sxe^EpVqW)`QwTjP<034`aPrQgvAG77UXx zuMf3E80$;D62|&bKZG%7ONI{X-_lKo4WM2LOAc&t=&(U8N(5`95uLUk0k3P6C7Jq5 z=Hg-MPqc{IF6@@k)?{6iS)Kjh@lGro25z%-X`5?#I9H4ymh*K4a?dWW*3p*7b9|NuRNif{3#h3~!_eNa4GdhM_-vu8|2IPDHZl$K)K0 zADT3<`jL|cCqTd&MG`mx0(?ReIDr^JF%z9C5;3mT1o3O-unrW@9 zCDSxpCZROAT6|y%Xi*mbH>i|v0@9XFiZh6^G7U)sV>&6nCR2m?>Ok>LCbn!PUkRn{ zfqKx*&gFp6+ZAoy4|=Fem0Pd(=U@c@PLIk^TTPl!DGtv4Za0 zm6m`)pvC%vMLR&~2LsQ)Db!{cPe#{rh%bgl-rs5@64RZC#slrmzIEVreL#DN&EoE|I^QB|29 zClaS1O>Kk4FM3q;yFTP8%8~GueqvA2%CyE7VD!gU}dY&{`u?Zz4>R>VlVk?tyDq}@n6MGU4A2I_{34X1t((xWSmLb450*GZkV!Nh%(V4d2 z`I0Ie;Ng(GC`$l4uV&w6U|X-?V4HJ-Yl-(5Y(F{5r_ zwYPGzr=iTZ)KfEh;qc+^p_N02W#{D%@wi6h^=e;OT}{xt%o8fT)Dxs|8;^tjW)u|B z|8GBRyy~hiwqCbotY_<_`z!Ar^Ys0PwmtB~ao@|goXAa@emcAF=w6d*PxXtB`LX|7 z%m3*z{zI!O4D zs^ZM^+Gd=?3YLg6u>?Y;!Y!8Jx2?JvtReso6;lEzCjaVpr__vfiO5_wGxr~*N zXj?@c*#%D(=d{lDKWWvSP~VMAu1DpnQQfL`Rv}P{-mOJi*Q^LxgE$aZM9~!Js6lnd zp*ezLIUqGl>xT7$767f98_ta~sgG75X8?Hu;#?>y4=E~QVd~BrF2{=|Y^#vEl@u-n z{QX{d5~`K9A^vtmPeLorbKzHVUR7BQ+(p(_)-&`r(CsR$i^qN<}Sjs%$`vg6h7c zrfpYx#3B}_kt3VB7NUdNiCO&bHxTZ&|}ptr^y#B>+QLZvPYKxvlJou%ZI*`YxEH1{&LGt%olnG{&!tE;XG zb)&=W2%x^z9;$^WOUc#C&|P6#cRQ-l`4FVm!c^;p^kN6MSRhMDp5}`*lV_2)#!Gf* zDQP--pmK?4ncGn>r|>Lg>NF^KS6BO%!{5*@sIbTHMT=kPA7dQQlwn+#+6PQr_eGQ zf6+MVX_1lZ%FU)p8CPJc0cnS$7uNCl*jahAKhmY_EI1#-9$JMEKU+YXT`HoN$a~j% zO_*JRvssZ2{6rLZ& zTw_@b?hTwiWhKdgjbM|F=o=ZX>_mEAOCLB`??vv|^Ro5L*Lc96_*hSnaG?!|Bn!*dxnF}#W40}TJg(A@Kr9%hlo za8yrc&+El>G=o`O-1EGiW^pUSCwfx3Z!r9V;jc_j?M3v>fOhdnue*Ag#lM*HIm4vh z#2wFYK47ev-Dh+kv#9Rlgyy^YT!Hi(eTd$xZ%p4lCO_T^EQ@z{L)c&H9~^K973AT3ui&n7aNcQ5no zB8PeVnP;#vWjMWKg z`GNCw#j1g@E(Wr*E0#uzf_1W?0apzOBi>l%bt4`un+u)^=e6~WT?8Is4UAn2ECJ`3 zmooM@V9CHPV=WJ{mhNILW6x{Ym5lAzu)i{PP{Y^+e>;NzmJn0{dea%>Z@dRT(Gd55>$5@JqBnOH;jP(STBwXSR#&VgLE#6^l1Y^U* ze;Av=*l_qa^}~F|Mv4=RH8D0yd@F>A6B|r7m`q}NcdA1E zvK3eiu$f9D^4(*8(rkjS&Sc3?%+#K<#4N=C-q2p8rCiKsY$9WG!~({a_a@$4;bv?n zW9NuU#tt%euJABs>O+$A#bRB)^Mn_sxUH8XMl83k2fW65HQ-K$FEVAMjkssqUIzTY z_A_9Po#0;>zRhrXR66wB97P%)W0)762g+s9sE@cihUl-wT#59joVLeahxEMI2LWZd z*T<5KyNwNI^JB4Bi}J?Zu`ep+jV}TA5QiZdqHm2`ua-C74XB9c;yNzn{P>gL>Mgu2 zo+Mw7e-Wj3PUvo+a(e>iCXiKA6NoG8F6~^LKy{InPnesONF`<^l4M1q)IjN5nDSc8 z9B89bdWijr=No#6gNXsaV~Hz4Kc2V-@Q1{8hIsK=(mQ}%I=>If*3_PcY%w9NvoTvN zPD=x9OzUlo7t{M~#4R9KcfHD}i2J&31bnUQdNH%HQ~G+utcRU<*@#P}6P;ut?XxbU zyQ#c!3!oxC$sq2p47+rrG}X>5+fyv=b0co&|MtXe zvrL1Y5cYRVSp+jZW;r{8#q70svHup5eBZK6haCft);09EC+2(bB3P=mjMqPs*WX$X zti?gtnv`N-CUG!~t%TL_J&1SIMwVGcDq~I7$<`)dJvAQLX%ho9UKzC5M6SjoJMChW zhLN3iQKVsHXOx(tVPt2Nn5|)CXSA5FVPq$*HtBB@CSt9q=v2DZaao~?{rwQ9+-s| zuY$Ck!hZDt#*W%ZGDGAr)?|Ijb_&=i$>Y+o^UHsGVt#>ScTp79QV(oa7&|2#qE6T75X*TI+x)i!w-LYFI&3Jg{L>r;W5^iZL4R?5KKR z6Eq%a$r95w-V*S##MzPuTNGuma7!M0fh%N7%qPef!OYQv6_@a`q#TVdu_}zM6xrfh zsl_@udW@1Q?$I!JbP=%U89QntokPSS4I`aH#HX6%^61IHw3di@F#24D&X4GCPs}sX zWqh_Iv9F^8I$m7QDdbTCej#NYn>QVhBatU4VxcR&#PjoleFZC zfy_HDnme}bxWwto2NoI5^qw@s1d|2rs*7}3qq%x9PCsaXWRGJ-!TQprL$8tuO~;kIC{7QT8L> z+hOc|wN9MUY#ABzkMVXR(UBrcJdmAq$__=|?!8($CXRt(j;CDWA&m*yc@<64Xed* zna@Te=Th;#4QoWa#-lNInMl=mKgC}Ltf$7K z5w}(h(0JB_dSJO4kJgcY5u-GW){%b^MN$%0*Ne-=)G)SETp{LYlH_N96$>QKN`CfN zv4k<{XY0fT;e7oJ>&2a6EXQ!Q_*TnzLBbeiqxf0FE=ec?mdFc}qc(~*o5WxZBRe;V z;TlGEZW3cPjAFrcVj^Qr*7d00bz-K*qZqPT%++}JB#bg_77H~VMU?Bs`5NzWu(oJ~i_$`Tv9!Xok`&PrUl6Dw&h*Ql`YlB|T!eLo{gE)TDZG zr?{W7CUI`k6NbCQ&l*+->~1_3P5GL{hNNcgH!I)4moq=rrCd<@t)4J++@+;E>bTf_W})o9ob#@1-qbBx`jVW$|o zU&Cz4q-BqWIT-su!zM8HwT3Nc%*xB!jn-|9b@mjVDgkzeu|&iD;uvE`Z8R4@AWkyYWW6di(eQxyQS#V(9u(Lx zpngDGuM`i7IL0=Mk5U!mBO-^fYsAr1yYW$RwTAtc8fSb=?9s5Kv^e7~ae%Qs;_9@) z#>a&thjd;eZcZC!d_t6I*x%E}0lPuNUI6x__*TOXr%g9LCFsFD%J+R*xpB8RjcY0L z{I5kkE0Q!`R=@SuXT?PlOS!h+$5!m_(QQbA{Kaj2PIO~zt<}-hXWS$DGS+0x=^6w! zSmPCSz0mlg7_RZkx~>5>R^wH5EfX(^i5l<1uJypm7~3p*r$1)3Ax@uNeO&KG3kL^nJ$H#bnx26`O@G{XJugSi;ywadG-b#(iS9 zhOL9n{UVO9G@(5q`KFktVGlv)TcTRS-U9ZvXx6Zw(!VsmBLq>SPt6kkT|7b)SidMFB(Sed03cnzb>r{iopA~h}Ez%@cu2jNQ_7S5z)OB z)-R0JizC7n#!^fli;;}UorR;Kh_TJ$;f&*kPeoN&vR-^DmW8pE*wtOm*ijp;i9Q#X zNS^iOjCx>~Ydl&ZeIc&ac>BToLfokFXub5M*sAe90`E(4x5lG6^(*n9#-lm)EAdap z( zCw*w4>yU~VgpC(P3~2`s#}b{ODn_>BwwITBBrIh42vo(4FeQ}MYmm9lVHppgD$eJ$ zUk9bUlw8ep3H9`Am@c87-pq6f^>nFCQuI*Lf4>EOpWCrERougt$X2Dap;g=dd7V=K zv#d=*z0I$Ku8Muk)u;C}(sNVq`I;P)BL6Q&0JQ zd0C2HUZ(Z6lQIjqblFp0PS-H3XV}E>T85Dl73};+T4@`nC6uK|&G&<@iapFd!0G>l z(~9_t(?5kNs*v1h2Wgg2pDPt~JmJLLNjMi(#7L%0bi~CO#5qiFU*APcC#Y&Nl2XHT z2^)0jMbLI;NhvQ&k-0AAysb4*SsR!x;U?@Zb`&$OV;O>~xP{aDXm%$5XglcoVKTm~e%_f_-``_S~)bwd07QJ!t$!6adZ+R zaHJqd3a%uK#gT$*2orH#bqbD&xGqqJJ$_t65%X|V;3&ft-zpqd9P@Bg;3z{$(V`pV z9mwB9G~!6Xm0&xLSez)Q;BI~^j(IpLaL~@S6-Nbjv2VbRbP9Hf@5EunF%L%tjxv!8 zJQwL)q=$+XI3|kW&^;XTBSbTfIPAXe#9_rzf!)^oaom6-PK<)wD9DW#593I|T?8+o zcH42JU}y3*99A3^ILgE`g3hU5X1I^xy9^IAJjU=O!_y2Eh2(7v;~Ay`UZ(Wmbbr9! zraZu9q5!Z(lrXd*Zws#MzT5LX<6KZy;%Y5XdJEd2^de1Hi-DT5xl& z^&UV&-(8lMA+y^ugln1)dW+=>K|2A5m0S7-ly{X~eLuDwQ=aepndPLi54+$qmACqy zw46pR)vTx|`~GYp7-hWzdF$axr~9T`$?`tdouDieHwsg~$<}MI4_pRrX73iu!y>I; zmGxoKyPwy3Bh#-z3;%_4-C}(Lxv0PD`|Si}RlirQ&x_UlyePN4_XpN&^`q1wwmh;^ zB*BL3&3B3K!MzL5iFiSYat0Kepnd2(m1OeN-sxA^3OHS$);h1Zm8k2|x7cQ?8=Nho zL3!Va7K65b*zOXConIPLg{}X)wmdaI{X0mOXC&AuZ;HKvH8en54$`aop9PqoUTiO5 zO9<8rf+;3~heeaRzJHnBioMQP6)SF=Z2@fL^ctjNg;V*v(JICS=i83 z6zPDYI6YZhfOIMH7O-YF!zPAX89u}CFhfP5(t9v0VCZJp$gqiFGsCS6cQbs3;UR`X zB@GHg2g4o=$1*HnSi#WEu#sUC!)AtC89u}CFhd19DX@xR0mI!44>1%*;yM@>Fmy9) zVz`yzGYk(iR7@<-a4f?DhHi#U47W0ThT$QGhZzbp*N$NULpQ@FhRqDOGThDZ8HR@$ zDi*EfuVz80Yf*#CWc!XiYStFFsxwM$gr8=Zia^#ifEE- zWZ2B`<>-y-iz6X%XC+wH#6ML z@DM|h&hiY$GOS>@o8cjbjtr6+%dmoBBg1BfyCvOGsV=aL?M0Fm3>|$a-N>++;ckY9 z7>d4JF2iOgrFSzt#8C8SF2k`5D;PEoAbK;y-3$*g6a!hF;aG+h47;00nb(@HGT&i- z(R>)M1xT?xY&l^0!D6xwvW~INu+~^7*{W^zwu@{VY};%P+CDKoVSCkf%x186v*+0- z+t0D9SkW2q&xo~~3HPs9L=@I1F<3u!LMjd`f_PvFSW6{>k_1X;P?ACE0!j)fsi35T z(hU?^d-VdPH&$kS5G@CQGYBiQY;baL*Ih2|P8fpq;83j0^1vMl?kKuT01{_Gq7V|} zAyEQ}$+${B6)UdkSZ&RK^lV6%LwX*rSkK4Gssg#($h8P7s|Mt}5Rb#GLe55kCz~t_ z0H3#b08LguU?+xoR-*hq_gVwxjkj$B)TbY_9S23iI6I{!^l)0j$2cvaF^bCS&hX8s zJ__!m)=`q8i90xY2a+qbzG0Tz8j%frO7)!Ziy1h(8>_5VivhMe= z{L}5);r-ZmAt~XKPNZ`~r_n04%tV5ni2GV6D)%ksUTh?~h$G25V;RzAoLCF#;mz2&m*vSpr3BzxYDu0ScW#P&8nob)enpG?{Y$@h}JLHepLKLB3euSXpDLVM-0-j82Pv< zfnhvGKRw+}FaZ%j!I6k`5~2X^X2d@gF`x@zD*ma63SB|(&aemWwo-+IVPDWxM1daQ z4ggdU33>qzM%++vme>dB97GG1V}*iP&>!g$Vj#Hrh!`rz4HYq9Fw$cYKUAy^bHN?Q zun757L-V+*EO8@Dk|1 z4N%2dL=)0G09A22-5D)GOcm$D*8o0* zaul2gZ$$bLl%t48aZOdl{npnby$fe9s(6gyQ{rY&o(5FKZgC6J&j6~p`}%KyFX5V| zg7f69NWTIb74a&dinHk*Nbdzy#lK)9?y6?lMGLxHrP4Dvo)&tUc3nS1L~xT)2IzbrLq^$q`Zz?WJ zJ_qcqdA8RyI|^>}!(*!!#g6FV!1y1E(L6zX zX8PLnqbb+C(Cjr|U~Vusns=G^o4+zASch2WS#PtxW&PB8!g|`O+HAH2TUT38Tc)kb zW^5E3&kzD(1!hXzKQEtLA`1QC-eWWUB6x=XaL05nLR!=0GcS5tqb-H+z#v)DejV;m zD8{bHB+(ObU=nt$#vl@mK`a@AC@_ZO2+0Z_`&_CTi}kGbIyLU+*T&zj(O*DjeQA0Nzugr_>I zs=8W~6lhOP{-Jd73QuKS(7mwQQ||RF7bP=%0e-U1Qzaj2{38XTM9R&<)0st{K&9VX zOAqFWumL6I?&>;Eh=rGqgl(H%7p$!dwq=Jh{yukx8*i2O1o5OF^wkA@%lI+ILXV%G zzpQizJ?+%~86mwYUri034n$RcN7ET)^osB_EIp&?uKpcGXOz(?DtF`AMe3(E?HQ^5 znIuZ^oT(3ug35$iw+s&@iV}J@)?HK8ir5jYWQxyMOJ$2tB9sLV6Y2@?g)C80xWrSr zwASavBfONOgTh67dqkUJ8Ar2ql$~rZ_rgudnMl=Ak2V5AR&nhLeKl3=$}}vft~G(6 zyQZDL6)&p|Hpqu8&m>al4tPpx@K7ubjd~9~zFLtT_HaT)q!SA8)M$`tVMh-e8#YO{ zOp&MB-5`_URum;#UBZ;M{f#QqbF`&A)Iv2DC6nrE*j*!(DR{`22J~`|zjTSGy1IBp zt=|)%w_CJR*@h4@m^5%(hK-RG>(BtrZc#GF=U=)A58bx4u%n)0SNMbe6Vvbr^_lu6 zY?)}+09^k+%!k);h(FUt`baB6@A3%zQFzRn;rG>2RPqGGA9gIB2FDPu2~v}nRQ;jq zQte@89@u0Oo)oSOda7E{$9Ze;hLcd)XbpO>K0*k|f-))Ks|lgxl$yC`%)-SMuc-9M zfUk+OyU5`*JBUZPx#oW~Wkn><;5(uBvk3We6)~M3-PW+ILSJ>YjMagx2_DqWTPcdr z6!3Jnzo8;W6xY-(!@9ks_<}k-VUN0D_)_qzMeLGTSzRrtIU$Xx485`?E8HGDr?tYg zhK)49Voz`Z4-ZPnNfDh`P)Q9Wm=PwDL};QtTOeNOFgE8blAshph84yWb{k`K+U zs4(ZyXO7Mslm!J zJT;Vhf&upWGm!OVkcm2F`R%i`GZPIRwyQleqO2XSy>51);zf%nn$>$~u~odn8$?IS zl?=0q$}0!)JAx6R>N6^7t(q#{zQ7Pw7MLGa+paF{vr<2VyC5J3M_m9*bsbTcENshT z{|v7s3l?FqFCuG8iOat3cyZhDnzxlza18bys%6-e4vEr#+Sy1M+uD@hR#UsSibw?7 z^V*itfkf*@X(!OOeA)EUM|pZ?t95wDfr;5po95h{ks7azA{}YqL_WcGd6>nENKsE` zD+?B23Z|L13iEP6CP)`AJB5Tbw2b!EE}%IY%Z3I@m(<{OLK0(gKuquiC%OYm3Ta6X z%WBpp2Fj)=+ z2_?SBjW@)}IuKzxFNfUKEKRM(9#-VhiG@YNY|0q!HqJm4xq!wCT`HFfeVTaTr8x`o zYwbewTxiPH>n+mH#E2V|3Qf_8J-kF~H&D|aD7!!E-kFXUDEdbxHs z=7%!1=Y$-u9jCI@R1+B%RBUVP_q>Fp!wyQw89c4j6C^R+ITC7gM(1m1Y<{SW_MDCj zY$r#y$)Sst2m)0*0qQxq6BTMQ?%Ot`{ML9oEv?yNiZ>9%83=+GVjk~dxg$rC1KFl#G}pN&+F-P~@0_eFBmz z31~UmGi1L>u?e0aX$Uq@&0V|}I3h}AKLusP7t$9gc7UCGa!H!jh*tENex3ZO@ zexcfFZB$YNx)u#MOPdyJqfq1i7xZcGhzk|VWoR_5*dmwVb&sy{A=aPl>ofb!f6Zsw`b!7C@+bV{zv3f*(m&ex zMx@`{`$dHJ$38Kw1Ahq9TK6TCozV|k_i^idt$E!46i340mdq8AMLnVIrhstRTcmAO z3EC*8*9&rPoL1wa1ubu>zjzn06<^OF131$x&oW=VCnQ(o!RV?EjK@nNwM{S*EbuSJ z77EQIY&UI3VG9^b@iIS7xI9%v#pI#cg6&xM86>K!TjikbuQDI&gl(-@Jo$87OjXqx z3m`49h4$q_yLp%+WxMF=!xaw=ZrT{uHt-gsLt6J5bx~^y$!LR|iy{db4F&Qkai-iw1;+YBl4oK&hJOBwiXL*QQ=L?;TY#DcL`n0 z)2FpcX~PdQFSn!Dt)RjbSqH6uB8 zd5tKlBBu+Y8tW7tFEsy#re?itJ6?D#&RWn0a-keqeTQuftJ7q{cvuBD0W9wzjEAXY zC(F6@vp_IJU4+0E5s~RgBoFFC_hNa$gOzD%${CRkv>G{nd9Q$O3}_U}B(yY~6un9B z$*p2{ke7_krwc^+=5e#F-Cbh@(~7Y7T1 z(6X=&^Id4(fqPfgRR-HLu=c^uOG8JD+6KRO@sbYmV9{8G6<|l@jQ8UDxqLlvdzExT z;g>fO;9~umq|V4F^9HLu?X`xynJ&J!tGBj{j4;}?VF@lQ-~uATdA*kwz-SKIR>Sli z$ugnNTNS}H1w~%>;u=J7Z)E^+cwyb*#WYVw#3T)ULt74kwp~Z9j+XN4%LRc?zh>d0 z^$Jb}BI*!X>3SLWR?xeUuKVfwEHoRnHX%HF&@4XPKZo9r&Fg&Z;>k5jc9|D<5`a7t*3Aa&ed^k)vpuI#(j6=anU_;)v(a#$J8soHGy0g@O4Ld`AQVjH1N3y zX+l2&Vvg0-nbsatJT;4PWvjTR-s|_(@R>T1r%4+y70s^2wdC*uk)|m0AUC?-OLLw~ zVpvtl)7P+Q=yauIJbO5XTfLVq3riHMK1>zfs_D?)=BjSH7R(m;XWTE4P3Ugl#zQC* zjH4=r;-z-}OnEx!mEn|wPAqg{!`drGS(xW3nz!A2Aia4)o@<8sgm#UKe9LgXSh{z3 zg2u*3RlC9A@lW&B%tj<^&1^rwpbxog+|>;MFNRWGZ7p^s0#jvd)Qu6(BD~feJEYoH zwl-!c?oPx40k_JaDumHWL!(glhhikLwK1dFK=ts|piOBIZSQH$;5GJgXq&bxEe z0@^%>3%nTbVT82eO{HipO63T;Oo>WzxbRlCHatiZ9gp+81q%w@m>sJMYJ4>f%Y1d{ zwBQn76?XSMi;+DW>s~rr6O(W^lN`N11Ud|tU~Z1cs^qKbbUC8bL;HE*UJ0GQ1hV9P z3bK15Z30<*K8C9_!|nCc4GP+24s8JYA;EVfaG_J(=c84qa#OuES_-AgCeaF=<5`$h zydp@qDB(V*kSRo!o9=DyWSHcxcS}YnHX|5J#p$G@4(=+h3iPYfTxP$-EDeK*yML(mg0e z(xLYZ4{`r%pKua$I?6|1Q~K|Hze)6K|3xNh-L@ZZ5}EDg&ioA}fm;5be6~pp|Gf_{ z{Z4s(elK4*vUF`9uR^UV40zjXzw_`M<~%%`MDN0whj=m&@LW7)_!geksvLPqpSK^tiRp2`CL{T+zdTy(6rT zUO2Bjb;zMBY@HKqYC_}ggp{bx3GqtjgvQI2M11`wp>rs0Wm-bxx=`ZkP-3^ab3&>b z8*6e1uni6oYj!9~LgOZrlL<}{3!>EsqSfG(2?(o7tR}b)p961Prhu+jrk9S~?rF_;rlxRe7?q*JpZiZp0x zn20Y~3YBzCBwZ7!T~s?t(n#gF>~UQv@|IdI&YDlGVFY{_K=L zufd@Bp)ezUD7V3GuJUfA;~Sqq8c+&0%Abc>RXW4544n)|Fmy?w?M5@@qq29$hI^#h zs`ZUEOu9eZAJ35{=Bx$PR?lwSF!EaOe;w>R0^H>nO6kpb}+aiIrd zsX`Y?!QIp;>8d%MGVHcPSAsRc3j0`XtX4t%gsnOhah*dU*Etk6i%EH?+93-%8i^#5 zA;PB`p_W`YPl*lHw-&w)ar}ox2}#I6_^0?!cx^&0bta7>bQ@97VWHNjg_DfNQ2?Jv z7)_wSB+!=yc)mB*XeAmzfx#+btwK#`GA0zG=h14#M!;C3IU}LOX3n5NoiH_4^GryU zz%3I>Vq>F(bY~((Los_U^PvrVyMRrd6J{z2B{9@;vtv8Q&sE}^(#el!bDz(qc9TSI zH<^UZv(YY^FuZ&=HK0VzGKQh6(7Qj_Py~LUll$%m_SvRr)CVo`LqbzDYNE!*NGVMN zst8kHu!biz;mckMAhiN#n{ScX=gaZe10IP2$VD1&Y;2~v$k<4a(&2MlDgf|Vr3Kma z?4E*ukNkY~C+a1O|I%&w$g2)sG2*3+H`T{IyBrx6bH{9c{#sAB%eOppR#NBBA31Ah zeD=Lj`*UCTs-nl@%5)-u z`X-IO_vKTYFZEsj()SZ){O9_4RsT-;Tk*kfmkt=1FyWr(JOfWXXEn{gD+-2ESKx7I zg`C4cF4p8k7+1{(3zCD7q+cT8w{e$hP$>+jrzFHF6f62D-O#h3cSDS_D+Zed3OO6} z8LZT%q==`6I15D)QlV+2&MmPZj3ksKlvsrUfh4~1WzE}>OFFy!JtWDsCPHJaR1Da) z7MbA4gO5QA1NwMxY(~1#qGX_>;Z+$FMAQT;g{@uqRgHFxOp^uO=weQ-#;IjaEpvvT z3o#wsk2#JqHQuk9kgM^2W{yZi-KpC8$}=Z_EIx=6I)@K`#J9}ns}5vgzru$bN*ZXB zr)rkQ99QS9#{Q;7`--m+Bk?@?RBxr<7w|0#X3fB+0&Rq1Gp>7KLH3C3?2!faK5rGS zUE*_ro~jvsZ$0*ZXkSloJWfw1e=Lb_JWOpnRXXKVG)BT`q+??f3Z!oy!`E@hA2HFR zH@W*QGAf|`zBD0k<0(icG@i7Y(WdF?=>`j09ZBeD{Dmt!mN@uB8(|uv!E8lnNfdF3 z_&^Rgu*D+ja;3my-=dyVB3Y^sH#W~fG# z4E?usmH~_glT2}gN23p{*6gQ8l;1OK+E9!yRFzsd3IEYr874GJY=#M+o=<4%5lcgv z2ODx3Xv|uzu@(bFHI)goW6<=C_aroBCNyOuZpJAFHCB!5CgAD_V$l{AP!l%06j&Zh zg8;!VoUd^oP?VZs;sKapN<^JZC_SNRDC^BbXeB31n4iv77>yC9BxC@lC(LK#M<+Cm zHeoH^Q~&|M5=EqCO)D-7UxXW^UC0`ZuTTzEL|JT7n5A7Yq21L4%Hs%g9FXm=h~5($ z7W(nsQtYZp718h6yBs;L?4gdxxOCw5 z90y<3qc6!~>%AUdlEstLia0AQ^z6O-WmNDNU~p$mTWEzhu^zCbAHgl|j@ z&&tUfo;!S47G7N48*ifcgZ(>qgU1nVLKY&u8N@LU@C+Yzb}8vsOIPoprRFgehXAgLe5Y z95>TcR#aN_!zVtmGQ-XGL3t1?jQ_np6BWlr9R!lJ^Q;>?2FoV?5-1w}cT zBZ>=hGjodzMvTjLs9T8lgI;4|}&~Xp5zo@!; zDlTXXex}gl;pgQ^;`0d4?J3i-|GWUd)9^Ny=`8xB@%XQ_fWzA^fVZTFe$UbrkxDtc zY6Scg;ZUHJ_G8E6jGy)jXlHH_b`I#TH?0Y=$4dLBw0BUAU)n#Todo%Jzwu|9m|zp_ zxzcXk;tn(&U>O(cE&mO{jsw~NZ+l2a-pC$94R##Ddn@2ig~m$g_3<9;B9!4^X+QR9 zX>V6=%@XkF-88Zma<7l_dLgT~`MC|x1lWbQ&+ z<-o3N?4~$6Xyq(W3s|2+moEUSyskidGxW}!D%6ht?!-HP^kqtqp`CTQ+Tq9b3+$WY zuYG^s3!PqY9gvgS7c(x~h)Qt4V(MwVHV5jo2%Pr%&g37`&RXsRYH4Z<@>c4Dkk1gt z*IoX{`l1?dUsALy3su-xqkTBNe@{feEM#k_o~39nYFF}k57&-H9qvx&c9d5?s9)&1 z2krLjy&v--`=z{!5h|;#cb>^NM_}SrpqZ{1QJ>LutOi(cru?q3S97=iKR_*Tzx*ya zUWoPo{{Am)0Vhqgsw!No&q_Dj2CSX9_WKycqBgHSD+VN+swmk}E}PjjFxH@^nS^VK z**?&$7?st-RmIpm#+C2tqN8+j*$j$kHf~cJg{y}ypD}6og*k@%>IW76mi@$z{XgVg z``cC47n)ahUhP_Ke9pDn@b_keid~RI`ZUXiJ5%2|YuH~e9LxQ&!4(rWOu>1XYdKqF zm~AvCscor$94t>&&uR$Be=PSGO)P*+a8kuHo1{7~&do4$$GQ>@ezTdgy<} zvKUtsSr(OOoH~8Rtn7ZSJ`(L#Q|PV5t+bA!(qcz(>9moBuJJ=Mb6q2bWfm2WACcY1 z)l1eWy~7%5CvvXUN>6ikj5(^nq-$BucE7YzF-?XnTyUpH`N(mmHc^70Gs zst!nx5ed?O=c*Te*gQvVUw>J1; zr`)xt_bop*cIBr>{=VYafb{n_Z+T5!`q48n1G+YxSh0R<;kLeO)9nYYJ8R*RUkfh1;OkRsn#X+AQnF{m9fd7>-(Q?r`oV+F)#=^tIJjm{ z;)3QEK7DlP{dtb>9{JCtBR{*|Z;JkQ+ zIp2QqoMF8Rk5+D5t=P~aCRYZUG$YoSY)raq&bv)7fA@UWBXd7|tM0|uKDz5U<9+Ny z8NG}tuH?p~UPFF(ch>k?`QKnGPxzZG7BQEv&~kFN)t}|72_1w zB-g|c?o!w0YXvM{zPzIXaGTGWH3waZWN#m1w96h+X|U?u1p^Z9q6qi=q&p}5{iQ--Y-~HL?^p?1P4$q6KN{R`Lde-sc)W9_#%ufH$#{8#0DXx9~ z*R$?OJ(70&BaOe_R{zc?-W67au`dwD-i(AX#XhLv-gg>S-o6uy6rtGLw3@5oej@?a#hp|2%Bi<$QbmzHRQucZ~n3GI>na=?QPV_{Enm-uOV@nRQRT_gW`&QvCMn z)LVBim|Awl$5Uq(kxi?@oRG!i9f*=Gmcl|8%zRh03UnC9bBfD?hsAqUjG$ zShiqA`hEZSeskiihzvsbDw)w4Xs(T{pd=s?#H*YLdD zp{~sAVT;_ELn?>4G8Yb8xF|EPDraGKWtD4a-iRTs0^qChpT6?O!^vkWFAvYkO-|l5 zm0-8kKa5ZH_mxVHGe6aeAN@MOfj1+Ed9x!IZ6O>}VxJSP;N5CW&U5ClUw zLg1J`7Xr_qJJ@FAa=g3!&eCf>8m0W|o^L+q^F=434}Aabn*CyCY}~%>`?@$kS(iIv z;DN$DhQHQ*o_p=Lcl~?uFY5a{GNu(4&+l4to9CJe?rORI z)}~tx=l(qDNLrR@=Zp!1*ZtUVpqt|d(@*`ErX>C7H$ED5$4ymV#Lu5zT(Z7@TINqJ z|FD%V7_#Y5^7Fes3k>~q&hf*aCqI|+qWPgwue;a$`yWMDY`Sf&YqjYK#JlY>-r3!` zebacgmffbYTnl)CX1872_lk{Q52{j9lMR^MvQuf@s3Y3Kb6<9*YoH8ay(1xPmd_V- z=w6vbd(KOIe%u1it1_2sL~eEt_A7I95X^EkG>6dtKjZ8lEv+8(&z+a*s(L!(rV58+ z+>Q06)nmH8?R)LjlbjtFGDx^o8PWq&~16~rI(FJZV8-gdVKM$^*bK)4t_5+>ep+7{r_D* zxa`9u*W4f8SikU>S6^N*K6}Qleu*ECb-nKIALs1(;_zvsn{!5Ay?5&f^JVj*R@a{=pkAHo5{)k&2UOsO}ms{7r z8h=%J{xdsm3k>^15$rrfuyb6UC^94}%5O%K3$Kj*O&7g7j3l%w&gf(`;>2OCE5U5j z&PzHgMiVQ>@;6LVX~p)-zU*oH`(An7;TtMO-I?vXJ^zUVnXc5ZP?Bnl?qi3lYR2>BdozzrdgF=OPwtG_X4p}F=&>s&&-wbg zaa&G)bNs6#Yr7B0f2{nb6Q#W_8?b$K`o@26vSfVy?`c1*+xp6D_EOh3uJT_u z;DTj0r~QzAqV(;>ul4+GUdG;S>z?fQU_)hj(YBd;PanJO?D7w9R*Q=UFZlMod*580 zQ}gro>k>cy-22I0+Xg-L(!jV_&xRY{Keg@0guXV^|wA`wo|X+OlGE%Dk6{ zCNKDKV@An_%%|=dQk4ExT<0_~|HGl@_W0KgFWSDkEOy=WWwD9VMqku_;uinDZ>nE; z=8M|f=3F~x)u#2$T_+mO`Tq6W7Tbe6hJBeixXVjN{lgQ!^*xZkc=hR753bKm_H>KA z^24};Rp0vlHU7>0U5+(8Z+v+FPlG<{e&ww@?LQ^<8+*^krw`wC$@qU-DkgX;#!kC` z+!xcne5k(RfPIKs0VZK@1H#IVzTXpF4o)gg*Sgji)!=hX74J6VR;2Az#Ni7Jp^2fE|e(q|ELKBm} zO6K*2%%AC5@Ee;fc^GfP@T8OYI}{&N`R>l()=G*UeCK-&Y2t-YDVuNBi7^v|S%go8 z)iB>SiUUZDQ(*mGKC0hjRtI`L=t=z(^&1cdxdm9j1^EHdgZd3S+~fxiHvhSH|F5d| zgqeBW29Jg$F&WzVgOg6=vF5q#>-?7o!m0??iQc&cA3np820N;;w- z&JbW3M6sRos#y#-Q|;v1~4 ztA$-f(rBsM8P_8%-?0tLX%+=`O|!}Iu;v9`zM_FUh03*S6CMuO2d(J=NjpAoV@v1g zV|})Ih}SSHH0?B=UJQS%fTARCahjFgA}e;P7XzV`x*d>tTAl<8`8Z(diu+ec0*xBx zZ4^R4ZmHq}quleC+**$d&$?fLxpgFtiup&Tm_W;D@QU{~6H6eS49Z&Hw$U43(BT|a z?_98YXZ~6B{@q6Sr|M03T!g{u4c2oM01EAIa~P-xT;0lYcwCKoWZ7 zlcgvnr{`a~p}T&Hn8*CTrt1H#)*Zapgt4KGhN!YaBlA!5-G(|n)KwtGJT6WKcDTg3 zowZ(Jl{|e!sdw#6D|Mjls&vF^@gts66FScebrYz^X&`}l&)rw=bS;WOK26kyVWYR) zQOUobV4B#XO4CpmG7l5e{MrsN6}=XAztS#T8pb{m^`^aZxb{gro>U`*vW5y7pX> zW7PFL(Mx?_JnC{NJWbh`Qxn+*Fx)6jTgA`X(IQuHUU5BtBU3uPz35#w`6SCluu`?j ziIIrK73aLhT_=4x8ItPK(jpbhmdDcH{5^K5SNgg{WCN>Kd9jUnNQ$e;Q~MO+jJh28 z6(WcIP`>LWUq{tj?lQJo)Fjaa5t%{7xeN8eDyQhD%Zl3IPu;c9`!4XP6}>hEu4lON)9GGg|C zuKglXW1+%uPe{*bpuYPq9JM@5oyV1`z%*T+AHqa_kOhmW!U+)X%W8L9Z?fZBH5ho!o~!e^ND40EpK-! zvxqE9mTin#`|kit#9cy~!wU)oLT#?@JE3zCXnM;P*5a{sYHiW0De68_mwTl7D6=bk z8f#vBnYsp#bjyu3sMRp3&fLN^z0Zfwz4)1YJ}#c`zP~b2M;!vSJnMr5fURT_rl#*5 ztQzeeYr?%X9fl)qK(8la|Itg_rmx1N7I7=|iGX1Lh$GiKgXWi^WSDPD9;P5!yZ|JW z>Bq;20YgGb!Cj{h2k!lUj41rRX>nrM8UYkPUNtHV=Xm231RS)-!x9}va45v_gXRK1 zpRgdveSSS?vA8nLsz~Q4wS*>Ln_uaeb_(*!IXPB9HTGbvazwA>Wui|6I_pp zlVl%u>p_2B;=q@eh*tZa=A%**4O7tF8+b|Cw<7T0Z#r(zdiBWbL2Ik=I;T)^${PZ- zoZfpoj(M$LxK7|1EsU(}Tqb{_iY_6bW10}7U!5 zvNGdow7N3m5tZ*|2Jcrp)%=7HT`EdnwU}vIss6DIQeE4cG)CI`tk~pvlLT_(h5)XC zX1@c+4f(pf+kP$Tg7ZN#zot_xHI~8`m5Xn6N$#nV0L`H+akW7-`KC$C_ zePD1gae=$oz_9}(IJkw^0u>9QKGnWf=nCX27{;e>s1I%YL=~w={H0mU&zT}vb2qmRkVtl`(Fm^d z9GEML%uk`Z+vk%(s76>j-a>7*6U4LoQr?2BKEO+;(75Wh>~$ys_gE1=RjLH@5oPxU zDZAHqeS`VHtU6K|P*IOZ{v}Mv2?0h|+X-!@<~jd{zg5SqpWLQSVGqOqLOvD};Nuh! zH5Y;NTkv!9@e6`+LtzUcZWDe}b8aEH2wXr|5C#`875YhXQLs0gRzvSa=8y{uGnCn7 zwcUh9|FM7eyY`lYN@zX%r zQ{N5dH!0-%9Ursf=cMzAMGvS)q=IvOxyJ% zvoDuX8PrJ7%Q_xEZDoUeF(|LY6cEVF7h~9UBd_2HP_`A*a!#K!v6l`HyIbc`O+A|v zL;aXk2zLIgt}zqV`6pPWwEQ@4_q(FoFINrnKMUWyn~Xnh5uFvkjTR+;v%e}<_7V1s z1v+F#aAWvQSgg6j;#!mDE%UUS^kIhFRguzbI@xKbQ&^SND=TDefNw4=E-ynSJYVWy zK0%H--WeulRYuo&8p^m2agNgl2p;D_5(_V~F>%su@}LH+-Gc`X|!>U0Fubow4OQ6N#+Md1d1xpa&+)N zeQ8HbO~j!!;Y|>IYY9srH9*@-Rd}@hSy`~PA2DTnUkcA38>Q9fR)s>2-R!HJ7GYVl zWPqv$KrysTQRBo+84+2>(;P-Rt3@vjeJFl;nQ;8u$iKbZP+lYI1MA){OXaHwL)EMLc}|pi>daeRJOus;3W_0&0MRscDuE6hACw0a#dp@W_k8zg6vK87Cc$2-M}=O1DtPtMi~pJk?C#eHxp{=Zd}3}@J{EUVVxTr+vg>_Mz%1nFe%~74db_E zLtbKCYU)du;dP1LwBK^4)8!&Ix)z-vahX40uqc@P!z0!8n4)UAqk)W%NFJ!)gbu)$t0Qv_{ zphW|b2)LZAlB^u4`1hR!aQcGt78L(MkL(!ii~)XQKE6Y+yLtp}AlPXDYJlp|HVAgo zf7qWMrcsWN?oZC|0w5kAym&e^L@a=a0uT?5wLKnGkR}3>N0);_$oT*4atGjT<^aC| z24JkguXgi*JKo^2az3n9uV$*M^5d^0B*#s9!h2Ewe!+Di)C%E9~U#_zg{1nCUt##bKV-Xry5p*hm8xiVYkcT-#bD zOG#iIf1MuN^~nf+Vbb8#!ypL^H;itK;+wQ2wI(KIE5prHXtkpkUg5KS`e4qx82cr~ zFlGSdZHiot-db!rma+n2ydP~B3VTy=V!Gr-x3hxHJ*laWJv|wA6ryQ!cjX!VHXd!& z*;XjWPJF!SPPw=s9PdG){OxTiqt(rs!kxW4A94H^ti=lVfF-m`_eV!>+QA=)cPDA9 zUas@gVMuX5%}4LKd;z;yayP5viBUsJaH5WrwyMI#dg<0gR|9N61>1d(#|<@hb~ddV zH;C~()n3DpWYhqXjN(vBi2kR6>${}zJ1yafPBR$^!2qL=*hi|?88jHEoJ0Qa3K{Ql zdyIt!V?d*OJ;j)qb$5;>J>U1+P184v7HB1Mnf+VT<+Bx?0cIl?{*%=*=0cRjCR5y< zOP^{(ZI{Dc)FC8st?C2$i1@|wn1a0}FFYe8NpJXWhYCC)^D?#}t_7MO)35@J=TLy3FpINaJbX8d##doUCVp@tl;j z+{i1L%Q?DCU_2=7r32$-^PcSXPZnm@yPCN+>`?wd*Cw~b8HGoY(49IaoT~)o9Xk|- zb8~sf1>gOh^iheB!JSDIQ_@h4zS`6x_vPNQ@wb=eoJ%Dz;N47ywJAtq6#z-Bc-+pR zqJk<2u_(At@c3gsP(g@Uz+DVb2afU^cQjEY#O|3x6`5L=oa^gV>fnut)pyRv zcb9HiDRUV&HBOtnaIKKA;51kv)nrA3(O#gUjHc~)ISr-$_2gV4k;y00(A{t(1 z7YSk?s6>jjZGlAme|2Oz|OgRs<8-N=S0(GQAI{PmO{{6wZ zK`NVkNM#Q)Nr-3w5dk2=eqyr-K>V1DLdal$$Y#})6~9wi88uB_v+utP^*6Yz8n|HU z2bVoqtaz|^>MyzMshMDPyou(qI7x&Ps(4ab3cW+=$Bd2*SnV71iR`aCI(BD((icq@ ztu~_@vn%d3ud*I7Pi|K)*=p%va;hU`iFTi9-tAbwMilDWAtiMoaoCXjo8k6Va=|zz zZDp5bX~LGmI^SmBRbg*^N$S;j52XhhD1{;f(ui;Wo{l$UxM3b2@fR;FFq1lm%$g{*`5Z zi3}oiWz5rNi<|3pK5#u|0#6=M9oJN+9E?zc5V9(h%+u`&1Nia@eobAkGrN|({a41t zoUlfXT;dooO$Lk9&N|e59!D9Sg`Ij5d2Z8O-hFN>OCfjjgR_r`t%F-OqCFEUPxSd> zbNc}Dsq<@^^~&3jvwpi&AskwwB?f~ncvs>*gKmgn&ctyq+#BQPA!6UC=hb4R-)zZK z9b~I4&K`;>$&^lQeRJl5%2?nwM?%_Z3!wM83!m~R+-oB~l$YuieW6}i!LaQ4ST(12 zDLqYBCapi{G<1Ie>i0WlRCe*|j4sb7ojoJMTm42Coo5*@Sxs#R+%8wVZJLRuJQPhC}pm{WbdhvnBoHx*9N*{EN46xUS}4 z^S=}Q{}QOu&?DDeTCRS!tUr2L8)0>~$AZS~NdCa3{Rkj8W?!UT;iERA zHB7N)7LBIi&~|eSs&yP|ZnC2g&5+qvT_EDdD6q7LE!@pBE+J_4BE#y1ub6zqzXIP- z$w6s3)BCha9m<^_fv~@R+d?j4Esa}KO9|^j&tyB>eY;v+Gxm>eY_6u?Om20qH}*Ev zOeZzK>HUv@iVD0_EODKi zL&U7+Zv2=Hl0|*{Ayv~4A83@OR8|lBiVHorb5ab*xqW^J!_TxXZtrph`iLsJqSy|n zH&=hcg)toW*k~su7q-u$I4yE{C?e9Mt=t}rzN~XP>917=J_R;sebg!I@bjB<@t%dU zYIZ-QzaiTMl_#`Kokh_kdGeL~8UOol?$=vVkfmnvo{)-!gRAy}OJ^Tm? zppv3|pb@Jf`7*4=KhrI&;4KYgB~0mQR^3-$ihx{u#3FjUpjJX~NX zC@d$$Ed#pkBgK{5zde8L?j?pZm)Trj;&hx1x%WBB5IH8bKnfk%Tz5U8Si(o0Q z=q{ztwQa(v_pd3XjtWZe_3Mb2u*43^JYc$twWY}-Vmf--CL6-7hHI6LY3bb>a2j2} zV&cM^h@jO6u4jm(_cIF0C}8)!dC;6=Ch2VULyJ*l-MJ@HgCkue$iD8woc0EXs(R#P z#a2qTswoQ0!Us|z#f7@mU+^+XrL^8or z#iHW1uO7_w5}%gc>&lk%P3+MW7p0`kzL>+OYN^>Qebet6dBvuUy>(%D(N4=z21af+ zz{&UdaPmd|v#sEFk?ePv&CenkA3%Amcz~HPyq`1;;Mbzp$Q;G0b5SRYCH!e?ByJ_j zpbI20iR8^fW^HR5S-xr~fS5RO0w^vF(E}jf0Ei9%QH)0Nd(#(;vH}RdCqDm)Hw(sfi+{wub!p=dY=n}fq#TNys|BdvHL8f4@Sa;JnN& z3iAL9(;k+hD^agnDY}W6Mk)$k7w1tAE$A!1l=LyITQ!xgbXi+{NOs*KLUuDq<;(!N zRc^>ItZ1JBeM{t>!g@)TdNaqM9!ae%`xL{OEDk?TEcS?!!tNpXsaNro9N94JtBj2s z%wH#{G2ac`aTW1Ny9&~9etZxjmJU+Z6^8O2frP(DDdy66c zk_E*g-6@RHy#+~pUk%Df8T=l*3brOp%gIfVE^xxK5fC6^^{{dwmMg0H( literal 0 HcmV?d00001 From 79bdd8d09b2185a03d87d7cb934e72bd10c4bf70 Mon Sep 17 00:00:00 2001 From: Yuting Chen Date: Fri, 22 Jul 2016 14:00:42 -0700 Subject: [PATCH 4/5] Add tests and update the scripts --- .../AzureAutomationRunbook.Resource.psd1 | Bin 3632 -> 3560 bytes .../AzureAutomationRunbook.psm1 | 237 ++-- .../Tests/PSGetTestUtils.psm1 | 1221 +++++++++++++++++ .../Tests/Pester.PublishRunbook.Tests.ps1 | 176 +++ .../AzureAutomationTutorial.graphrunbook | 1 + .../AzureAutomationTutorial.psd1 | 124 ++ .../Find-EmptyResourceGroups.graphrunbook | 1 + .../Find-EmptyResourceGroups.psd1 | 124 ++ .../Hello-WorldGraphical.graphrunbook | 1 + .../Invalid-GraphicalRB.graphrunbook | 1 + .../StartAzureRMVM.graphrunbook | 1 + .../StartAzureRMVM/StartAzureRMVM.psd1 | 123 ++ .../1.0/StopAzureRMVM.graphrunbook | 1 + .../StopAzureRMVM/1.0/StopAzureRMVM.psd1 | 123 ++ .../1.1/StopAzureRMVM.graphrunbook | 1 + .../StopAzureRMVM/1.1/StopAzureRMVM.psd1 | 123 ++ .../1.2/StopAzureRMVM.graphrunbook | 1 + .../StopAzureRMVM/1.2/StopAzureRMVM.psd1 | 123 ++ .../1.3/StopAzureRMVM.graphrunbook | 1 + .../StopAzureRMVM/1.3/StopAzureRMVM.psd1 | Bin 0 -> 6800 bytes .../TestInvalidRunbookFolder.txt | 0 AzureAutomationRunbook/Tests/uiproxy.ps1 | 262 ++++ 22 files changed, 2559 insertions(+), 86 deletions(-) create mode 100644 AzureAutomationRunbook/Tests/PSGetTestUtils.psm1 create mode 100644 AzureAutomationRunbook/Tests/Pester.PublishRunbook.Tests.ps1 create mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.graphrunbook create mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.psd1 create mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.graphrunbook create mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.psd1 create mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/Hello-WorldGraphical.graphrunbook create mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/Invalid-GraphicalRB/Invalid-GraphicalRB.graphrunbook create mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.graphrunbook create mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.psd1 create mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.graphrunbook create mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.psd1 create mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.graphrunbook create mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.psd1 create mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.graphrunbook create mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.psd1 create mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.graphrunbook create mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.psd1 create mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/TestInvalidRunbookFolder/TestInvalidRunbookFolder.txt create mode 100644 AzureAutomationRunbook/Tests/uiproxy.ps1 diff --git a/AzureAutomationRunbook/AzureAutomationRunbook.Resource.psd1 b/AzureAutomationRunbook/AzureAutomationRunbook.Resource.psd1 index add82b1402ad060f511d204a32039a0d9007d1e9..82171790291b5bc062f143c4592cbf3144f69efe 100644 GIT binary patch delta 26 icmdlW^Fn%q2g~LJ7CFYrIc!>+53n{cZjNBT!3F?;DG3?? delta 41 wcmaDMy+LM!2g~FYELxL!n58C{uzUitH75J8No}6M+Q2wjg-v6#0{aOz05o9@ssI20 diff --git a/AzureAutomationRunbook/AzureAutomationRunbook.psm1 b/AzureAutomationRunbook/AzureAutomationRunbook.psm1 index 05bfb7b..bbb74aa 100644 --- a/AzureAutomationRunbook/AzureAutomationRunbook.psm1 +++ b/AzureAutomationRunbook/AzureAutomationRunbook.psm1 @@ -10,6 +10,7 @@ Microsoft.PowerShell.Core\Set-StrictMode -Version Latest Microsoft.PowerShell.Utility\Import-LocalizedData LocalizedData -filename AzureAutomationRunbook.Resource.psd1 +$script:TempPath = ([System.IO.DirectoryInfo]$env:TEMP).FullName #region *-Runbook cmdlets function Publish-Runbook @@ -99,7 +100,7 @@ function Publish-Runbook Publishes the specified graph runbook to the target repository. Following operations are performed by the Publish-AzureGraphRunbook cmdlet: - - Checks for the existence of .graphrunbook file and folder name should be + - Checks for the existence of .graphrunbook file; if path is directory, folder name should be . - Validates the .graphrunbook file contents. - Creates or Updates the PowerShell module manifest file using specified metadata parameters. - Validates the existence of specified repository name. @@ -114,71 +115,137 @@ function Publish-Runbook return } - $GraphRunbookBase = Validate-AzureGraphRunbookFolder -Path $Path -CallerPSCmdlet $PSCmdlet - - if($GraphRunbookBase) + $tempFolderPath = Microsoft.PowerShell.Management\Join-Path -Path $script:TempPath ` + -ChildPath "$(Microsoft.PowerShell.Utility\Get-Random)" + #If the graphrunbook is not within any folder, we will copy it to a temp module location along with the manifest to publish + if($Path.EndsWith(".graphrunbook")) { - if($Repository) + if(Microsoft.PowerShell.Management\Test-Path $Path) { - $null = $PSBoundParameters.Remove('Repository') + $GraphRunbookBase = Microsoft.PowerShell.Management\Split-Path -Path $Path -Parent + $GraphRunbookFullName = Microsoft.PowerShell.Management\Split-Path -Path $Path -Leaf + $GraphRunbookName = [System.IO.Path]::GetFileNameWithoutExtension($GraphRunbookFullName) + $ManifestFileName = "$GraphRunbookName.psd1" + $ManifestFilePath = Join-Path -Path $GraphRunbookBase -ChildPath $ManifestFileName + + $tempModulePath = Microsoft.PowerShell.Management\Join-Path -Path $tempFolderPath -ChildPath $GraphRunbookName + #Create a new directory and copy .psd1 over + $null = Microsoft.PowerShell.Management\New-Item -Path $tempModulePath -ItemType Directory -Force -ErrorAction SilentlyContinue -WarningAction SilentlyContinue -Confirm:$false -WhatIf:$false + Microsoft.PowerShell.Management\Copy-Item -Path $Path -Destination $tempModulePath -Force -Recurse -Confirm:$false -WhatIf:$false + + $PSBoundParameters['Path'] = "$tempModulePath\$ManifestFileName" + if((Microsoft.PowerShell.Management\Test-Path -Path $ManifestFilePath -PathType Leaf) -and + (Microsoft.PowerShell.Core\Test-ModuleManifest -Path $ManifestFilePath -ErrorAction SilentlyContinue)) + { + Microsoft.PowerShell.Management\Copy-Item -Path $ManifestFilePath -Destination $tempModulePath -Force -Recurse -Confirm:$false -WhatIf:$false + + Update-AzureGraphRunbookManifest @PSBoundParameters -ErrorVariable ev + } + else + { + if(-not $Description) + { + $message = $LocalizedData.DescriptionParameterIsRequired -f ($GraphRunbookBase) + ThrowError -ExceptionName 'System.ArgumentException' ` + -ExceptionMessage $message ` + -ErrorId 'DescriptionParameterIsRequired' ` + -CallerPSCmdlet $PSCmdlet ` + -ErrorCategory InvalidArgument ` + -ExceptionObject $GraphRunbookBase + return + } + if($Repository) + { + $null = $PSBoundParameters.Remove('Repository') + } + + if($NuGetApiKey) + { + $null = $PSBoundParameters.Remove('NuGetApiKey') + } + New-AzureGraphRunbookManifest @PSBoundParameters -ErrorVariable ev + } + $Path = $tempModulePath } - - if($NuGetApiKey) + else { - $null = $PSBoundParameters.Remove('NuGetApiKey') + $message = $LocalizedData.PathNotFound -f ($Path) + ThrowError -ExceptionName 'System.ArgumentException' ` + -ExceptionMessage $message ` + -ErrorId 'GraphRunbookPathNotFound' ` + -CallerPSCmdlet $CallerPSCmdlet ` + -ErrorCategory InvalidArgument ` + -ExceptionObject $Path + return } - - - $GraphRunbookName = Split-Path -Path $GraphRunbookBase -Leaf - $ModulePathWithVersion = $false + } + else + { + $GraphRunbookBase = Validate-AzureGraphRunbookFolder -Path $Path -CallerPSCmdlet $PSCmdlet - # if the Leaf of the $resolvedPath is a version, use its parent folder name as the module name - $ModuleVersion = New-Object System.Version - if([System.Version]::TryParse($GraphRunbookName, ([ref]$ModuleVersion))) + if($GraphRunbookBase) { - $GraphRunbookName = Microsoft.PowerShell.Management\Split-Path -Path (Microsoft.PowerShell.Management\Split-Path $GraphRunbookBase -Parent) -Leaf - $modulePathWithVersion = $true - } + if($Repository) + { + $null = $PSBoundParameters.Remove('Repository') + } - $GraphRunbookFileName = "$GraphRunbookName.graphrunbook" - $ManifestFileName = "$GraphRunbookName.psd1" + if($NuGetApiKey) + { + $null = $PSBoundParameters.Remove('NuGetApiKey') + } - $GraphRunbookFilePath = Join-Path -Path $GraphRunbookBase -ChildPath $GraphRunbookFileName - $ManifestFilePath = Join-Path -Path $GraphRunbookBase -ChildPath $ManifestFileName + $GraphRunbookName = Microsoft.PowerShell.Management\Split-Path -Path $GraphRunbookBase -Leaf + $ModulePathWithVersion = $false - $ev = $null + # if the Leaf of the $resolvedPath is a version, use its parent folder name as the module name + $ModuleVersion = New-Object System.Version + if([System.Version]::TryParse($GraphRunbookName, ([ref]$ModuleVersion))) + { + $GraphRunbookName = Microsoft.PowerShell.Management\Split-Path -Path (Microsoft.PowerShell.Management\Split-Path $GraphRunbookBase -Parent) -Leaf + $modulePathWithVersion = $true + } - if((Microsoft.PowerShell.Management\Test-Path -Path $ManifestFilePath -PathType Leaf) -and - (Microsoft.PowerShell.Core\Test-ModuleManifest -Path $ManifestFilePath -ErrorAction SilentlyContinue)) - { - Update-AzureGraphRunbookManifest @PSBoundParameters -ErrorVariable ev - } - else - { - if(-not $Description) - { - $message = $LocalizedData.DescriptionParameterIsRequired -f ($GraphRunbookBase) - ThrowError -ExceptionName 'System.ArgumentException' ` - -ExceptionMessage $message ` - -ErrorId 'DescriptionParameterIsRequired' ` - -CallerPSCmdlet $PSCmdlet ` - -ErrorCategory InvalidArgument ` - -ExceptionObject $GraphRunbookBase - return + $GraphRunbookFileName = "$GraphRunbookName.graphrunbook" + $ManifestFileName = "$GraphRunbookName.psd1" + + $GraphRunbookFilePath = Join-Path -Path $GraphRunbookBase -ChildPath $GraphRunbookFileName + $ManifestFilePath = Join-Path -Path $GraphRunbookBase -ChildPath $ManifestFileName + + $PSBoundParameters['Path'] = $ManifestFilePath + + $ev = $null + if((Microsoft.PowerShell.Management\Test-Path -Path $ManifestFilePath -PathType Leaf) -and + (Microsoft.PowerShell.Core\Test-ModuleManifest -Path $ManifestFilePath -ErrorAction SilentlyContinue)) + { + Update-AzureGraphRunbookManifest @PSBoundParameters -ErrorVariable ev } - if($modulePathWithVersion) + else { - $PSBoundParameters['Version'] = $ModuleVersion + if(-not $Description) + { + $message = $LocalizedData.DescriptionParameterIsRequired -f ($GraphRunbookBase) + ThrowError -ExceptionName 'System.ArgumentException' ` + -ExceptionMessage $message ` + -ErrorId 'DescriptionParameterIsRequired' ` + -CallerPSCmdlet $PSCmdlet ` + -ErrorCategory InvalidArgument ` + -ExceptionObject $GraphRunbookBase + return + } + if($modulePathWithVersion) + { + $PSBoundParameters['Version'] = $ModuleVersion + } + New-AzureGraphRunbookManifest @PSBoundParameters -ErrorVariable ev } - New-AzureGraphRunbookManifest @PSBoundParameters -ErrorVariable ev - } - #if($ev) - #{ - # return - #} + if($ev) + { + return + } + } } - $publishParameters = @{Path = $Path} if($Repository) { @@ -192,13 +259,17 @@ function Publish-Runbook if(Validate-AzureGraphRunbookFolder -Path $Path -ValidateManifest -CallerPSCmdlet $PSCmdlet) { - $test = $publishParameters PowerShellGet\Publish-Module @publishParameters ` -Verbose:$VerbosePreference ` -Debug:$DebugPreference ` -WarningAction $WarningPreference ` -ErrorAction $ErrorActionPreference } + #Remove temp module path + if(Test-Path $tempFolderPath) + { + Microsoft.PowerShell.Management\Remove-Item $tempFolderPath -Force -Recurse -ErrorAction SilentlyContinue -WarningAction SilentlyContinue -Confirm:$false -WhatIf:$false + } } } @@ -334,8 +405,28 @@ function Save-Runbook { $Null = $PSBoundParameters.Remove("Path") $RunbookToSave= Find-Runbook @PSBoundParameters - $PSBoundParameters['Path'] = $Path - PowerShellGet\Save-Module @PSBoundParameters + # Save the runbook to temp location + $tempModulePath = Microsoft.PowerShell.Management\Join-Path -Path $script:TempPath ` + -ChildPath "$(Microsoft.PowerShell.Utility\Get-Random)" + $null = Microsoft.PowerShell.Management\New-Item -Path $tempModulePath -ItemType Directory -Force -ErrorAction SilentlyContinue -WarningAction SilentlyContinue -Confirm:$false -WhatIf:$false + $PSBoundParameters['Path'] = $tempModulePath + try{ + PowerShellGet\Save-Module @PSBoundParameters + #Only copy .graphrunbook to the destination folder + if(Microsoft.PowerShell.Management\Test-Path $tempModulePath) + { + $runbooks= Get-ChildItem –Path "$tempModulePath\*.graphrunbook" -Recurse -Force + foreach($runbook in $runbooks) + { + Microsoft.PowerShell.Management\Copy-Item -Path $runbook.FullName -Destination $Path -Force -Recurse -Confirm:$false -WhatIf:$false + } + } + } + #Remove the temp folder + finally + { + Microsoft.PowerShell.Management\Remove-Item -Path $tempModulePath -Force -Recurse -ErrorAction SilentlyContinue -WarningAction SilentlyContinue -Confirm:$false -WhatIf:$false + } } } @@ -557,23 +648,10 @@ function New-AzureGraphRunbookManifest $null = $PSBoundParameters.Remove('Version') } - $ModuleBasePath = Validate-AzureGraphRunbookFolder -Path $Path -CallerPSCmdlet $PSCmdlet - - if(-not $ModuleBasePath) - { - return - } + $ModuleBasePath = Split-Path $Path -Parent + $ModuleFullName = Split-Path $Path -Leaf + $GraphRunbookName = [System.IO.Path]::GetFileNameWithoutExtension($ModuleFullName) - $GraphRunbookName = Split-Path -Path $ModuleBasePath -Leaf - - # if the Leaf of the $resolvedPath is a version, use its parent folder name as the module name - $ModuleVersion = New-Object System.Version - if([System.Version]::TryParse($GraphRunbookName, ([ref]$ModuleVersion))) - { - $GraphRunbookName = Microsoft.PowerShell.Management\Split-Path -Path (Microsoft.PowerShell.Management\Split-Path $ModuleBasePath -Parent) -Leaf - $modulePathWithVersion = $true - } - $GraphRunbookFileName = "$GraphRunbookName.graphrunbook" $ManifestFileName = "$GraphRunbookName.psd1" @@ -677,24 +755,10 @@ function Update-AzureGraphRunbookManifest $null = $PSBoundParameters.Remove('Version') } - $ModuleBasePath = Validate-AzureGraphRunbookFolder -Path $Path -ValidateManifest -CallerPSCmdlet $PSCmdlet + $ModuleBasePath = Split-Path $Path -Parent + $ModuleFullName = Split-Path $Path -Leaf + $GraphRunbookName = [System.IO.Path]::GetFileNameWithoutExtension($ModuleFullName) - if(-not $ModuleBasePath) - { - return - } - - $GraphRunbookName = Split-Path -Path $ModuleBasePath -Leaf - $ModulePathWithVersion = $false - - # if the Leaf of the $resolvedPath is a version, use its parent folder name as the module name - $ModuleVersion = New-Object System.Version - if([System.Version]::TryParse($GraphRunbookName, ([ref]$ModuleVersion))) - { - $GraphRunbookName = Microsoft.PowerShell.Management\Split-Path -Path (Microsoft.PowerShell.Management\Split-Path $ModuleBasePath -Parent) -Leaf - $modulePathWithVersion = $true - } - $GraphRunbookFileName = "$GraphRunbookName.graphrunbook" $ManifestFileName = "$GraphRunbookName.psd1" @@ -729,6 +793,7 @@ function Update-AzureGraphRunbookManifest return } + $Tags += $RunbookTags $PSBoundParameters['Tags'] = $Tags | Select-Object -Unique $PSBoundParameters['Path'] = $ManifestFilePath diff --git a/AzureAutomationRunbook/Tests/PSGetTestUtils.psm1 b/AzureAutomationRunbook/Tests/PSGetTestUtils.psm1 new file mode 100644 index 0000000..6083127 --- /dev/null +++ b/AzureAutomationRunbook/Tests/PSGetTestUtils.psm1 @@ -0,0 +1,1221 @@ +. "$PSScriptRoot\uiproxy.ps1" + +$script:PSGetProgramDataPath ="$env:ProgramData\Microsoft\Windows\PowerShell\PowerShellGet" +$script:PSGetLocalAppDataPath="$env:LOCALAPPDATA\Microsoft\Windows\PowerShell\PowerShellGet" +$script:moduleSourcesFilePath="$script:PSGetLocalAppDataPath\PSRepositories.xml" +$script:NuGetBinaryProgramDataPath="$env:ProgramFiles\PackageManagement\ProviderAssemblies" +$script:NuGetClient = $null +$script:NuGetExeName = 'NuGet.exe' +$script:NuGetProvider = $null +$script:NuGetProviderName = 'NuGet' +$script:NuGetProviderVersion = [Version]'2.8.5.201' +$script:MyDocumentsModulesPath = Join-Path -Path ([Environment]::GetFolderPath("MyDocuments")) -ChildPath "WindowsPowerShell\Modules" +$script:ProgramFilesModulesPath = Microsoft.PowerShell.Management\Join-Path -Path $env:ProgramFiles -ChildPath "WindowsPowerShell\Modules" +$script:EnvironmentVariableTarget = @{ Process = 0; User = 1; Machine = 2 } +$script:ProgramDataExePath = Microsoft.PowerShell.Management\Join-Path -Path $script:PSGetProgramDataPath -ChildPath $script:NuGetExeName +$script:ApplocalDataExePath = Microsoft.PowerShell.Management\Join-Path -Path $script:PSGetLocalAppDataPath -ChildPath $script:NuGetExeName + +# PowerShellGetFormatVersion will be incremented when we change the .nupkg format structure. +# PowerShellGetFormatVersion is in the form of Major.Minor. +# Minor is incremented for the backward compatible format change. +# Major is incremented for the breaking change. +$script:CurrentPSGetFormatVersion = "1.0" +$script:PSGetFormatVersionPrefix = "PowerShellGetFormatVersion_" + +function GetAndSet-PSGetTestGalleryDetails +{ + param( + [REF]$PSGallerySourceUri, + + [REF]$PSGalleryPublishUri, + + [REF]$PSGalleryScriptSourceUri, + + [REF]$PSGalleryScriptPublishUri, + + [Switch] $IsScriptSuite, + + [Switch] $SetPSGallery + ) + + if($env:PsgetTestGallery_ModuleUri -and $env:PsgetTestGallery_ScriptUri -and $env:PsgetTestGallery_PublishUri) + { + $SourceUri = $env:PsgetTestGallery_ModuleUri + $PublishUri = $env:PsgetTestGallery_PublishUri + $ScriptSourceUri = $env:PsgetTestGallery_ScriptUri + $ScriptPublishUri = $env:PsgetTestGallery_PublishUri + } + elseif($PSVersionTable.PSVersion -ge [Version]"5.0" -and + [System.Environment]::OSVersion.Version -ge "6.2.9200.0" -and + $PSCulture -eq 'en-US') + { + $SourceUri = 'http://localhost:8765/api/v2/' + $PublishUri = 'http://localhost:8765/api/v2/package' + $ScriptSourceUri = $SourceUri + $ScriptPublishUri = $PublishUri + } + else + { + $SourceUri = 'https://dtlgalleryint.cloudapp.net/api/v2/' + $PublishUri = 'https://dtlgalleryint.cloudapp.net/api/v2/package' + $ScriptSourceUri = 'https://dtlgalleryint.cloudapp.net/api/v2/items/psscript/' + $ScriptPublishUri = $PublishUri + } + + $params = @{ + Location = $SourceUri + PublishLocation = $PublishUri + } + + if($IsScriptSuite) + { + $params['ScriptSourceLocation'] = $ScriptSourceUri + $params['ScriptPublishLocation'] = $ScriptPublishUri + } + + $params.Keys | ForEach-Object {Write-Warning -Message "GetAndSet-PSGetTestGalleryDetails, $_ : $($params[$_])"} + + if($SetPSGallery) + { + Unregister-PSRepository -Name 'PSGallery' + Set-PSGallerySourceLocation @params + + $repo = Get-PSRepository -Name 'PSGallery' + if($repo.SourceLocation -ne $SourceUri) + { + Throw 'Test repository is not set properly' + } + } + + if($PSGallerySourceUri -ne $null) + { + $PSGallerySourceUri.Value = $SourceUri + } + + if($PSGalleryPublishUri -ne $null) + { + $PSGalleryPublishUri.Value = $PublishUri + } + + if($PSGalleryScriptSourceUri -ne $null) + { + $PSGalleryScriptSourceUri.Value = $ScriptSourceUri + } + + if($PSGalleryScriptPublishUri -ne $null) + { + $PSGalleryScriptPublishUri.Value = $ScriptPublishUri + } +} + +function Install-NuGetBinaries +{ + [cmdletbinding()] + param() + + if($script:NuGetProvider -and + ($script:NuGetClient -and (Microsoft.PowerShell.Management\Test-Path -Path $script:NuGetClient))) + { + return + } + + # Invoke Install-NuGetClientBinaries internal function in PowerShellGet module to bootstrap both NuGet provider and NuGet.exe + $psgetModule = Import-Module -Name PowerShellGet -PassThru -Scope Local + & $psgetModule Install-NuGetClientBinaries -Force -BootstrapNuGetExe -CallerPSCmdlet $PSCmdlet + + $script:NuGetProvider = PackageManagement\Get-PackageProvider -ErrorAction SilentlyContinue -WarningAction SilentlyContinue | + Microsoft.PowerShell.Core\Where-Object { + $_.Name -eq $script:NuGetProviderName -and + $_.Version -ge $script:NuGetProviderVersion + } + + # Check if NuGet.exe is available under one of the predefined PowerShellGet locations under ProgramData or LocalAppData + if(Microsoft.PowerShell.Management\Test-Path -Path $script:ProgramDataExePath) + { + $script:NuGetClient = $script:ProgramDataExePath + } + elseif(Microsoft.PowerShell.Management\Test-Path -Path $script:ApplocalDataExePath) + { + $script:NuGetClient = $script:ApplocalDataExePath + } + else + { + # Get the NuGet.exe location if it is available under $env:PATH + # NuGet.exe does not work if it is under $env:WINDIR, so skipping it from the Get-Command results + $nugetCmd = Microsoft.PowerShell.Core\Get-Command -Name $script:NuGetExeName ` + -ErrorAction SilentlyContinue ` + -WarningAction SilentlyContinue | + Microsoft.PowerShell.Core\Where-Object { + $_.Path -and + ((Microsoft.PowerShell.Management\Split-Path -Path $_.Path -Leaf) -eq $script:NuGetExeName) -and + (-not $_.Path.StartsWith($env:windir, [System.StringComparison]::OrdinalIgnoreCase)) + } | Microsoft.PowerShell.Utility\Select-Object -First 1 + + if($nugetCmd -and $nugetCmd.Path) + { + $script:NuGetClient = $nugetCmd.Path + } + } +} + +function Remove-NuGetExe +{ + # Uninstall NuGet.exe if it is available under one of the predefined PowerShellGet locations under ProgramData or LocalAppData + if(Microsoft.PowerShell.Management\Test-Path -Path $script:ProgramDataExePath) + { + Remove-Item -Path $script:ProgramDataExePath -Force -Confirm:$false -WhatIf:$false + } + + if(Microsoft.PowerShell.Management\Test-Path -Path $script:ApplocalDataExePath) + { + Remove-Item -Path $script:ApplocalDataExePath -Force -Confirm:$false -WhatIf:$false + } +} + +function Get-NuGetExeFilePath +{ + Install-NuGetBinaries + + return $script:NuGetClient +} + +function CreateAndPublish-TestScript +{ + [cmdletbinding()] + param( + [Parameter(Mandatory=$true)] + [string] + $Name, + + [Parameter(Mandatory=$true)] + [string] + $NuGetApiKey, + + [Parameter(Mandatory=$true)] + [string] + $Repository, + + [Parameter()] + [string[]] + $Versions = @("1.0","1.5","2.0","2.5"), + + [Parameter()] + $RequiredModules = @(), + + [Parameter()] + $ExternalModuleDependencies = @(), + + [Parameter()] + $RequiredScripts = @(), + + [Parameter()] + $ExternalScriptDependencies = @(), + + [Parameter()] + [string] + $ScriptsPath = $env:TEMP + ) + + $scriptFilePath = Join-Path -Path $ScriptsPath -ChildPath "$Name.ps1" + $null = New-Item -Path $scriptFilePath -ItemType File -Force + + try + { + foreach($version in $Versions) + { + $params = @{ + Path = $scriptFilePath + Version = $version + Author = 'manikb' + CompanyName = 'Microsoft Corporation' + Copyright = '(c) 2015 Microsoft Corporation. All rights reserved.' + Description = "Description for the $Name script" + LicenseUri = "http://$Name.com/license" + IconUri = "http://$Name.com/icon" + ProjectUri = "http://$Name.com" + Tags = @('Tag1','Tag2', "Tag-$Name-$version") + ReleaseNotes = "$Name release notes" + Force = $true + } + + if($RequiredModules) { $params['RequiredModules'] = $RequiredModules } + if($RequiredScripts) { $params['RequiredScripts'] = $RequiredScripts } + if($ExternalModuleDependencies) { $params['ExternalModuleDependencies'] = $ExternalModuleDependencies } + if($ExternalScriptDependencies) { $params['ExternalScriptDependencies'] = $ExternalScriptDependencies } + + New-ScriptFileInfo @params + + Add-Content -Path $scriptFilePath -Value @" + +Function Test-FunctionFromScript_$Name { Get-Date } + +Workflow Test-WorkflowFromScript_$Name { Get-Date } + +"@ + + Publish-Script -Path $scriptFilePath ` + -NuGetApiKey $NuGetApiKey ` + -Repository $Repository + } + } + finally + { + Remove-Item -Path $scriptFilePath -Force -ErrorAction SilentlyContinue + } +} + +function CreateAndPublishTestModule +{ + [cmdletbinding()] + param( + [Parameter(Mandatory=$true)] + [string] + $ModuleName, + + [Parameter(Mandatory=$true)] + [string] + $NuGetApiKey, + + [Parameter(Mandatory=$true)] + [string] + $Repository, + + [Parameter()] + [string[]] + $Versions = @("1.0","1.5","2.0","2.5"), + + [Parameter()] + $RequiredModules = @(), + + [Parameter()] + $NestedModules = @(), + + [Parameter()] + [string] + $ModulesPath = $env:TEMP + ) + + $ModuleBase = Join-Path $ModulesPath $ModuleName + $null = New-Item -Path $ModuleBase -ItemType Directory -Force + + # To create a module manifest for $ModuleName with some dependencies in NestedModules and RequiredModules, + # the dependency module should be available under one of the specified path in $env:PSModulePath. + # Creating dummy module folders for them and will delete them after publishing the $ModuleName + + $ModulesToBeRemoved = @() + $RequiredModulesToBeAvailable = @() + if($RequiredModules) + { + $RequiredModulesToBeAvailable += $RequiredModules + } + + if($NestedModules) + { + $RequiredModulesToBeAvailable += $NestedModules + } + + foreach($ModuleToBeAvailable in $RequiredModulesToBeAvailable) + { + $ModuleToBeAvailable_Name = $null + $ModuleToBeAvailable_Version = "1.0" + + if($ModuleToBeAvailable.GetType().ToString() -eq 'System.Collections.Hashtable') + { + $ModuleToBeAvailable_Name = $ModuleToBeAvailable.ModuleName + + if($ModuleToBeAvailable.Keys -Contains "RequiredVersion") + { + $ModuleToBeAvailable_Version = $ModuleToBeAvailable.RequiredVersion + } + elseif($ModuleToBeAvailable.Keys -Contains 'MaximumVersion') + { + $ModuleToBeAvailable_Version = $($ModuleToBeAvailable.MaximumVersion -replace "\*",'9') + } + else + { + $ModuleToBeAvailable_Version = $ModuleToBeAvailable.ModuleVersion + } + } + else + { + $ModuleToBeAvailable_Name = $ModuleToBeAvailable.ToString() + } + + $ModulesToBeRemoved += $ModuleToBeAvailable_Name + + $ModuleToBeAvailable_Base = Join-Path $script:ProgramFilesModulesPath $ModuleToBeAvailable_Name + $null = New-Item -Path $ModuleToBeAvailable_Base -ItemType Directory -Force + + New-ModuleManifest -Path "$ModuleToBeAvailable_Base\$ModuleToBeAvailable_Name.psd1" ` + -ModuleVersion $ModuleToBeAvailable_Version ` + -Description "$ModuleToBeAvailable_Name module" + } + + Set-Content "$ModuleBase\$ModuleName.psm1" -Value "function Get-$ModuleName { Get-Date }" + + $NestedModules += "$ModuleName.psm1" + + try + { + foreach($version in $Versions) + { + $tags = @('Tag1','Tag2', "Tag-$ModuleName-$version") + + $exportedFunctions = '*' + if($ModuleName -match "ModuleWithDependencies*") + { + # For module with NestedModule dependencies, it's exported functions include the ones from NestedModules too. + # To avoid that specifying the exported functions as empty list. + $exportedFunctions = '' + } + + $params = @{ + Path = $ModuleBase + NuGetApiKey = $NuGetApiKey + Repository = $Repository + WarningAction = 'SilentlyContinue' + } + + if($PSVersionTable.PSVersion -ge [Version]"5.0") + { + New-ModuleManifest -Path "$ModuleBase\$ModuleName.psd1" ` + -ModuleVersion $version ` + -Description "$ModuleName module" ` + -FunctionsToExport $exportedFunctions ` + -NestedModules $NestedModules ` + -LicenseUri "http://$ModuleName.com/license" ` + -IconUri "http://$ModuleName.com/icon" ` + -ProjectUri "http://$ModuleName.com" ` + -Tags $tags ` + -ReleaseNotes "$ModuleName release notes" ` + -RequiredModules $RequiredModules + } + else + { + New-ModuleManifest -Path "$ModuleBase\$ModuleName.psd1" ` + -ModuleVersion $version ` + -Description "$ModuleName module" ` + -FunctionsToExport $exportedFunctions ` + -NestedModules $NestedModules ` + -RequiredModules $RequiredModules + + $params['ReleaseNotes'] = "$ModuleName release notes" + $params['Tags'] = $tags + $params['LicenseUri'] = "http://$ModuleName.com/license" + $params['IconUri'] = "http://$ModuleName.com/icon" + $params['ProjectUri'] = "http://$ModuleName.com" + } + + $null = Publish-Module @params + } + } + finally + { + $ModulesToBeRemoved | ForEach-Object { Uninstall-Module -Name $_ } + Uninstall-Module -Name $ModuleName -ErrorAction SilentlyContinue + } +} + +function PublishDscTestModule +{ + [cmdletbinding()] + param( + [Parameter(Mandatory=$true)] + [string] + $ModuleName, + + [Parameter(Mandatory=$true)] + [string] + $NuGetApiKey, + + [Parameter(Mandatory=$true)] + [string] + $Repository, + + [Parameter()] + [string[]] + $Versions = @("1.0","1.5","2.0","2.5"), + + [Parameter(Mandatory=$true)] + [string] + $TestModulesBase + ) + + $TempModulesPath = "$env:TEMP\$(Get-Random)" + $null = New-Item -Path $TempModulesPath -ItemType Directory -Force + + Copy-Item -Path "$TestModulesBase\$ModuleName" -Destination $TempModulesPath -Recurse -Force + $ModuleBase = Join-Path $TempModulesPath $ModuleName + + # Create binary module + $content = @" + using System; + using System.Management.Automation; + namespace PSGetTestModule + { + [Cmdlet("Test","PSGetTestCmdlet")] + public class PSGetTestCmdlet : PSCmdlet + { + [Parameter] + public int a { + get; + set; + } + protected override void ProcessRecord() + { + String s = "Value is :" + a; + WriteObject(s); + } + } + } +"@ + + $assemblyName = "psgettestbinary_$(Get-Random).dll" + $testBinaryPath = "$ModuleBase\$assemblyName" + Add-Type -TypeDefinition $content -OutputAssembly $testBinaryPath -OutputType Library -ErrorAction SilentlyContinue -WarningAction SilentlyContinue + + foreach($version in $Versions) + { + $tags = @("PSGet","DSC","CommandsAndResource", 'Tag1','Tag2', 'Tag3', "Tag-$ModuleName-$version") + $manfiestFilePath = "$ModuleBase\$ModuleName.psd1" + + RemoveItem -path $manfiestFilePath + + if($PSVersionTable.PSVersion -ge [Version]"5.0") + { + New-ModuleManifest -Path $manfiestFilePath ` + -ModuleVersion $version ` + -NestedModules "$ModuleName.psm1",".\$assemblyName" ` + -Tags $tags ` + -Description 'Temp Description KeyWord1 Keyword2 Keyword3' ` + -LicenseUri "http://$ModuleName.com/license" ` + -IconUri "http://$ModuleName.com/icon" ` + -ProjectUri "http://$ModuleName.com" ` + -ReleaseNotes "$ModuleName release notes" + } + else + { + New-ModuleManifest -Path $manfiestFilePath ` + -ModuleVersion $version ` + -NestedModules "$ModuleName.psm1",".\$assemblyName" ` + -Description 'Temp Description KeyWord1 Keyword2 Keyword3' ` + } + + $null = Publish-Module -Path $ModuleBase ` + -NuGetApiKey $NuGetApiKey ` + -Repository $Repository ` + -ReleaseNotes "$ModuleName release notes" ` + -Tags $tags ` + -LicenseUri "http://$ModuleName.com/license" ` + -IconUri "http://$ModuleName.com/icon" ` + -ProjectUri "http://$ModuleName.com" + } +} + +function CreateAndPublishTestModuleWithVersionFormat +{ + [cmdletbinding()] + param( + [Parameter(Mandatory=$true)] + [string] + $ModuleName, + + [Parameter(Mandatory=$true)] + [string] + $NuGetApiKey, + + [Parameter(Mandatory=$true)] + [string] + $Repository, + + [Parameter()] + [string[]] + $Versions = @("1.0","1.5","2.0","2.5"), + + [Parameter()] + [ValidateNotNullOrEmpty()] + [Version] + $PSGetFormatVersion = [Version]$script:CurrentPSGetFormatVersion, + + [Parameter()] + [string] + $ModulesPath = $env:TEMP + ) + + $repo = Get-PSRepository -Name $Repository -ErrorVariable err + if($err) + { + Throw $err + } + + $ModuleBase = Join-Path $ModulesPath $ModuleName + + if ($PSGetFormatVersion.Major -eq '1') + { + $NugetPackageRoot = $ModuleBase + $ModuleBase = "$ModuleBase\Content\Deployment\Module References\$ModuleName" + } + else + { + $NugetPackageRoot = $ModuleBase + } + + $null = New-Item -Path $ModuleBase -ItemType Directory -Force + + Set-Content "$ModuleBase\$ModuleName.psm1" -Value "function Get-$ModuleName { Get-Date }" + + foreach($version in $Versions) + { + if($PSVersionTable.PSVersion -ge [Version]"5.0") + { + New-ModuleManifest -Path "$ModuleBase\$ModuleName.psd1" ` + -ModuleVersion $version ` + -Description "$ModuleName module" ` + -NestedModules "$ModuleName.psm1" ` + -LicenseUri "http://$ModuleName.com/license" ` + -IconUri "http://$ModuleName.com/icon" ` + -ProjectUri "http://$ModuleName.com" ` + -Tags @('PSGet','PowerShellGet') ` + -ReleaseNotes "$ModuleName release notes" + } + else + { + New-ModuleManifest -Path "$ModuleBase\$ModuleName.psd1" ` + -ModuleVersion $version ` + -Description "$ModuleName module" ` + -NestedModules "$ModuleName.psm1" + } + + $PSModuleInfo = Test-ModuleManifest -Path "$ModuleBase\$ModuleName.psd1" + + $null = Publish-PSGetExtModule -PSModuleInfo $PSModuleInfo ` + -NugetPackageRoot $NugetPackageRoot ` + -NuGetApiKey $NuGetApiKey ` + -Destination $repo.PublishLocation ` + -PSGetFormatVersion $PSGetFormatVersion ` + -ReleaseNotes "$ModuleName release notes" ` + -Tags @('PSGet','PowerShellGet') ` + -LicenseUri "http://$ModuleName.com/license" ` + -IconUri "http://$ModuleName.com/icon" ` + -ProjectUri "http://$ModuleName.com" + } +} + +function Publish-PSGetExtModule +{ + [CmdletBinding(PositionalBinding=$false)] + Param + ( + [Parameter(Mandatory=$true)] + [ValidateNotNullOrEmpty()] + [PSModuleInfo] + $PSModuleInfo, + + [Parameter(Mandatory=$true)] + [ValidateNotNullOrEmpty()] + [string] + $Destination, + + [Parameter(Mandatory=$true)] + [ValidateNotNullOrEmpty()] + [string] + $NugetApiKey, + + [Parameter(Mandatory=$true)] + [ValidateNotNullOrEmpty()] + [string] + $NugetPackageRoot, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [string] + $PSGetFormatVersion = $script:CurrentPSGetFormatVersion, + + [Parameter()] + [string] + $ReleaseNotes, + + [Parameter()] + [string[]] + $Tags, + + [Parameter()] + [Uri] + $LicenseUri, + + [Parameter()] + [Uri] + $IconUri, + + [Parameter()] + [Uri] + $ProjectUri + ) + + Install-NuGetBinaries + + if($PSModuleInfo.PrivateData -and + ($PSModuleInfo.PrivateData.GetType().ToString() -eq "System.Collections.Hashtable") -and + $PSModuleInfo.PrivateData["PSData"] -and + ($PSModuleInfo.PrivateData["PSData"].GetType().ToString() -eq "System.Collections.Hashtable") + ) + { + if( -not $Tags -and $PSModuleInfo.PrivateData.PSData["Tags"]) + { + $Tags = $PSModuleInfo.PrivateData.PSData.Tags + } + + if( -not $ReleaseNotes -and $PSModuleInfo.PrivateData.PSData["ReleaseNotes"]) + { + $ReleaseNotes = $PSModuleInfo.PrivateData.PSData.ReleaseNotes + } + + if( -not $LicenseUri -and $PSModuleInfo.PrivateData.PSData["LicenseUri"]) + { + $LicenseUri = $PSModuleInfo.PrivateData.PSData.LicenseUri + } + + if( -not $IconUri -and $PSModuleInfo.PrivateData.PSData["IconUri"]) + { + $IconUri = $PSModuleInfo.PrivateData.PSData.IconUri + } + + if( -not $ProjectUri -and $PSModuleInfo.PrivateData.PSData["ProjectUri"]) + { + $ProjectUri = $PSModuleInfo.PrivateData.PSData.ProjectUri + } + } + + # Add PSModule and PSGet format version tags + if(-not $Tags) + { + $Tags = @() + } + + if($PSGetFormatVersion -ne [Version]"0.0") + { + $Tags += "$script:PSGetFormatVersionPrefix$PSGetFormatVersion" + } + + $Tags += "PSModule" + + # Populate the nuspec elements + $nuspec = @" + + + + $(Get-EscapedString -ElementValue $PSModuleInfo.Name) + $($PSModuleInfo.Version) + $(Get-EscapedString -ElementValue $PSModuleInfo.Author) + $(Get-EscapedString -ElementValue $PSModuleInfo.CompanyName) + $(Get-EscapedString -ElementValue $PSModuleInfo.Description) + $(Get-EscapedString -ElementValue $ReleaseNotes) + $(Get-EscapedString -ElementValue $PSModuleInfo.Copyright) + $(if($Tags){ Get-EscapedString -ElementValue ($Tags -join ' ')}) + $(if($LicenseUri){ + "$(Get-EscapedString -ElementValue $LicenseUri) + true" + }) + $(if($ProjectUri){ + "$(Get-EscapedString -ElementValue $ProjectUri)" + }) + $(if($IconUri){ + "$(Get-EscapedString -ElementValue $IconUri)" + }) + + + + +"@ + + try + { + + $NupkgPath = "$NugetPackageRoot\$($PSModuleInfo.Name).$($PSModuleInfo.Version.ToString()).nupkg" + $NuspecPath = "$NugetPackageRoot\$($PSModuleInfo.Name).nuspec" + + # Remove existing nuspec and nupkg files + Remove-Item $NupkgPath -Force -ErrorAction SilentlyContinue -WarningAction SilentlyContinue -Confirm:$false -WhatIf:$false + Remove-Item $NuspecPath -Force -ErrorAction SilentlyContinue -WarningAction SilentlyContinue -Confirm:$false -WhatIf:$false + + Set-Content -Value $nuspec -Path $NuspecPath + + # Create .nupkg file + $output = & $script:NuGetClient pack $NuspecPath -OutputDirectory $NugetPackageRoot + if($LASTEXITCODE) + { + $message = $LocalizedData.FailedToCreateCompressedModule -f ($output) + Write-Error -Message $message -ErrorId "FailedToCreateCompressedModule" -Category InvalidOperation + return + } + + # Publish the .nupkg to gallery + $output = & $script:NuGetClient push $NupkgPath -source $Destination -NonInteractive -ApiKey $NugetApiKey + if($LASTEXITCODE) + { + $message = $LocalizedData.FailedToPublish -f ($output) + Write-Error -Message $message -ErrorId "FailedToPublishTheModule" -Category InvalidOperation + } + else + { + $message = $LocalizedData.PublishedSuccessfully -f ($PSModuleInfo.Name, $Destination) + Write-Verbose -Message $message + } + } + finally + { + Remove-Item $NupkgPath -Force -ErrorAction SilentlyContinue -WarningAction SilentlyContinue -Confirm:$false -WhatIf:$false + Remove-Item $NuspecPath -Force -ErrorAction SilentlyContinue -WarningAction SilentlyContinue -Confirm:$false -WhatIf:$false + } +} + +function Get-EscapedString +{ + [CmdletBinding()] + [OutputType([String])] + Param + ( + [Parameter()] + [string] + $ElementValue + ) + + return [System.Security.SecurityElement]::Escape($ElementValue) +} + +function Uninstall-Module +{ + Param( + [Parameter(Mandatory=$true)] + [ValidateNotNullOrEmpty()] + [string] + $Name + ) + + Get-Module $Name -ListAvailable | %{ + + Remove-Module $_ -Force -ErrorAction SilentlyContinue; + + # Check if the module got installed with SxS version feature on PS 5.0 or later. + if($_.ModuleBase.EndsWith("$($_.Version)", [System.StringComparison]::OrdinalIgnoreCase)) + { + $ParentDir = Split-Path -Path $_.ModuleBase -Parent -WarningAction SilentlyContinue + Remove-item $ParentDir -Recurse -Force -WarningAction SilentlyContinue -ErrorAction SilentlyContinue + } + else + { + Remove-item $_.ModuleBase -Recurse -Force -WarningAction SilentlyContinue -ErrorAction SilentlyContinue + } + } +} + +function RemoveItem +{ + Param( + [string] + $path + ) + + if($path -and (Test-Path $path)) + { + Remove-Item $path -Force -Recurse -ErrorAction SilentlyContinue + } +} + +function Set-PSGallerySourceLocation +{ + Param( + [Parameter(Mandatory=$true)] + [ValidateNotNullOrEmpty()] + [string] + $Location, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [string] + $PublishLocation, + + [Parameter()] + [string] + $ScriptSourceLocation, + + [Parameter()] + [string] + $ScriptPublishLocation + ) + + $PSGetModuleSources = [ordered]@{} + $moduleSource = New-Object PSCustomObject -Property ([ordered]@{ + Name = 'PSGallery' + SourceLocation = $Location + PublishLocation = $PublishLocation + ScriptSourceLocation = $ScriptSourceLocation + ScriptPublishLocation = $ScriptPublishLocation + Trusted=$true + Registered=$true + InstallationPolicy = 'trusted' + PackageManagementProvider='NuGet' + ProviderOptions = @{} + }) + + $moduleSource.PSTypeNames.Insert(0, "Microsoft.PowerShell.Commands.PSRepository") + $PSGetModuleSources.Add("PSGallery", $moduleSource) + + if(-not (Test-Path $script:PSGetLocalAppDataPath)) + { + $null = New-Item -Path $script:PSGetLocalAppDataPath ` + -ItemType Directory -Force ` + -ErrorAction SilentlyContinue ` + -WarningAction SilentlyContinue ` + -Confirm:$false -WhatIf:$false + } + + # Persist the module sources, so that the PowerShellGet provider in different AppDomain will be able to use the custom module source Uri as the default one. + Export-Clixml -InputObject $PSGetModuleSources ` + -Path $script:moduleSourcesFilePath ` + -Force -Confirm:$false -WhatIf:$false + + $null = Import-PackageProvider -Name PowerShellGet -Force +} + +function Test-ModuleSxSVersionSupport +{ + # Side-by-Side module version is avialable on PowerShell 5.0 or later versions only + # By default, PowerShell module versions will be installed/updated Side-by-Side. + $PSVersionTable.PSVersion -ge [Version]"5.0" +} + +function Reset-PATHVariableForScriptsInstallLocation +{ + [CmdletBinding()] + param + ( + [Parameter()] + [ValidateSet("CurrentUser","AllUsers")] + [string] + $Scope = "AllUsers", + + [Parameter()] + [switch] + $OnlyProcessPathVariable, + + [Parameter()] + [switch] + $WriteWarningMessages + ) + + if($Scope -eq 'AllUsers') + { + $scopePath = "$env:ProgramFiles\WindowsPowerShell\Scripts" + $target = $script:EnvironmentVariableTarget.Machine + } + else + { + $scopePath = "$HOME\Documents\WindowsPowerShell\Scripts" + $target = $script:EnvironmentVariableTarget.User + } + + $scopePathEndingWithBackSlash = "$scopePath\" + $psgetModule = Import-Module -Name PowerShellGet -PassThru -Scope Local -Verbose:$VerbosePreference + + if(-not $OnlyProcessPathVariable) + { + # Scope specific PATH + $currentValue = & $psgetModule Get-EnvironmentVariable -Name 'PATH' -Target $target + + if($WriteWarningMessages) + { + Write-Warning "Current PATH value: `r`n $currentValue" + } + + $pathsInCurrentValue = ($currentValue -split ';') | Where-Object {$_} + + if($WriteWarningMessages) + { + Write-Warning "Current PATH value after splitting: `r`n $pathsInCurrentValue" + } + + if (($pathsInCurrentValue -contains $scopePath) -or + ($pathsInCurrentValue -contains $scopePathEndingWithBackSlash)) + { + $pathsInCurrentValueAfterRemovingScopePath = $pathsInCurrentValue | Where-Object { + ($_ -ne $scopePath) -and + ($_ -ne $scopePathEndingWithBackSlash) + } + + if($WriteWarningMessages) + { + Write-Warning "PathsInCurrentValueAfterRemovingScopePath: `r`n $pathsInCurrentValueAfterRemovingScopePath" + } + + & $psgetModule Set-EnvironmentVariable -Name 'PATH' ` + -Value ($pathsInCurrentValueAfterRemovingScopePath -join ';')` + -Target $target + + $currentValue = & $psgetModule Get-EnvironmentVariable -Name 'PATH' -Target $target + + if($WriteWarningMessages) + { + Write-Warning "Current PATH value after resetting: `r`n $currentValue" + } + } + } + + # Process + $target = $script:EnvironmentVariableTarget.Process + $currentValue = & $psgetModule Get-EnvironmentVariable -Name 'PATH' -Target $target + $pathsInCurrentValue = ($currentValue -split ';') | Where-Object {$_} + + if (($pathsInCurrentValue -contains $scopePath) -or + ($pathsInCurrentValue -contains $scopePathEndingWithBackSlash)) + { + $pathsInCurrentValueAfterRemovingScopePath = $pathsInCurrentValue | Where-Object { + ($_ -ne $scopePath) -and + ($_ -ne $scopePathEndingWithBackSlash) + } + + & $psgetModule Set-EnvironmentVariable -Name 'PATH' ` + -Value ($pathsInCurrentValueAfterRemovingScopePath -join ';')` + -Target $target + + $currentValue = & $psgetModule Get-EnvironmentVariable -Name 'PATH' -Target $target + } +} + +function Set-PATHVariableForScriptsInstallLocation +{ + [CmdletBinding()] + Param + ( + [Parameter(Mandatory=$true)] + [string] + $Scope, + + [Parameter()] + [switch] + $OnlyProcessPathVariable + ) + + $psgetModule = Import-Module -Name PowerShellGet -PassThru -Scope Local -Verbose:$VerbosePreference + + # Check and add the scope path to PATH environment variable if USER accepts the prompt. + if($Scope -eq 'AllUsers') + { + $ScopePath = "$env:ProgramFiles\WindowsPowerShell\Scripts" + $target = $script:EnvironmentVariableTarget.Machine + } + else + { + $ScopePath = "$HOME\Documents\WindowsPowerShell\Scripts" + $target = $script:EnvironmentVariableTarget.User + } + + $AddedToPath = $false + $scopePathEndingWithBackSlash = "$scopePath\" + + # Check and add the $scopePath to $env:Path value + if( (($env:PATH -split ';') -notcontains $scopePath) -and + (($env:PATH -split ';') -notcontains $scopePathEndingWithBackSlash)) + { + if(-not $OnlyProcessPathVariable) + { + $currentPATHValue = & $psgetModule Get-EnvironmentVariable -Name 'PATH' -Target $envVariableTarget + + if((($currentPATHValue -split ';') -notcontains $scopePath) -and + (($currentPATHValue -split ';') -notcontains $scopePathEndingWithBackSlash)) + { + # To ensure that the installed script is immediately usable, + # we need to add the scope path to the PATH enviroment variable. + & $psgetModule Set-EnvironmentVariable -Name 'PATH' ` + -Value "$currentPATHValue;$scopePath" ` + -Target $envVariableTarget + + $AddedToPath = $true + } + } + + # Process specific PATH + # Check and add the $scopePath to $env:Path value of current process + # so that installed scripts can be used in the current process. + $target = $script:EnvironmentVariableTarget.Process + $currentPATHValue = & $psgetModule Get-EnvironmentVariable -Name 'PATH' -Target $target + + if((($currentPATHValue -split ';') -notcontains $scopePath) -and + (($currentPATHValue -split ';') -notcontains $scopePathEndingWithBackSlash)) + { + # To ensure that the installed script is immediately usable, + # we need to add the scope path to the PATH enviroment variable. + & $psgetModule Set-EnvironmentVariable -Name 'PATH' ` + -Value "$currentPATHValue;$scopePath" ` + -Target $target + + $AddedToPath = $true + } + } + + return $AddedToPath +} + +function Get-CodeSigningCert +{ + $cert = $null; + $scriptName = $env:Temp + "\" + [IO.Path]::GetRandomFileName + ".ps1" + "get-date" >$scriptName + $cert = @(get-childitem cert:\CurrentUser\My -codesigning | Where-Object {(Set-AuthenticodeSignature $scriptName -cert $_).Status -eq "Valid"})[0]; + del $scriptName + $cert +} + +#cleanup all ca certs +function Cleanup-CACert +{ + param + ( + $CACert = 'PSCatalog Test Root Authority' + ) + + $CACertSubject = "CN=$CACert" + + get-ChildItem Cert:\LocalMachine\My\ | ?{$_.Subject -eq $CACertSubject} | remove-item -Force -ErrorAction SilentlyContinue + get-ChildItem Cert:\CurrentUser\My\ | ?{$_.Subject -eq $CACertSubject} | remove-item -Force -ErrorAction SilentlyContinue + get-ChildItem Cert:\LocalMachine\Root\ | ?{$_.Subject -eq $CACertSubject} | remove-item -Force -ErrorAction SilentlyContinue + get-ChildItem Cert:\CurrentUser\Root\ | ?{$_.Subject -eq $CACertSubject} | remove-item -Force -ErrorAction SilentlyContinue + get-ChildItem Cert:\LocalMachine\CA\ | ?{$_.Subject -eq $CACertSubject} | remove-item -Force -ErrorAction SilentlyContinue + get-ChildItem Cert:\CurrentUser\CA\ | ?{$_.Subject -eq $CACertSubject} | remove-item -Force -ErrorAction SilentlyContinue +} + +#creates a self signed ca cert +function Create-CACert +{ + param + ( + $CACert = 'PSCatalog Test Root Authority' + ) + + $cert = (dir Cert:\LocalMachine\Root | Where-Object {$_.Subject -imatch $CACert}) + if ($cert -ne $null -and $cert.Thumbprint -ne $null) + { + Write-Verbose "Cert with subject name $CACert already found, attempting to use it" + return + } + + remove-item ca.cer -Force -ErrorAction SilentlyContinue + remove-item ca.inf -Force -ErrorAction SilentlyContinue + remove-item ca.pfx -Force -ErrorAction SilentlyContinue + $certInf = @" +[Version] +Signature = "`$Windows NT`$" + +[Strings] +szOID_BASIC_CONSTRAINTS = "2.5.29.19" + +[NewRequest] +Subject = "cn=$CACert" +MachineKeySet = true +KeyLength = 2048 +HashAlgorithm = Sha256 +Exportable = true +RequestType = Cert +KeySpec = AT_SIGNATURE +KeyUsage = "CERT_KEY_CERT_SIGN_KEY_USAGE | CERT_DIGITAL_SIGNATURE_KEY_USAGE | CERT_CRL_SIGN_KEY_USAGE" +KeyUsageProperty = "NCRYPT_ALLOW_SIGNING_FLAG" +ValidityPeriod = "Years" +ValidityPeriodUnits = "1" + +[Extensions] +%szOID_BASIC_CONSTRAINTS% = "{text}ca=1&pathlength=0" +Critical = %szOID_BASIC_CONSTRAINTS% +"@ + $certInf | out-file ca.inf -force + Cleanup-CACert -CACert $CACert + certreq -new .\ca.inf ca.cer + $mypwd = ConvertTo-SecureString -String "1234" -Force -AsPlainText + Get-ChildItem -Path Cert:\LocalMachine\My\ | ?{$_.Subject -eq "CN=$CACert"} | Export-PfxCertificate -FilePath .\ca.pfx -Password $mypwd + Import-PfxCertificate -FilePath .\ca.pfx -CertStoreLocation Cert:\LocalMachine\Root\ -Password $mypwd -Exportable + remove-item ca.cer -Force -ErrorAction SilentlyContinue + remove-item ca.inf -Force -ErrorAction SilentlyContinue + remove-item ca.pfx -Force -ErrorAction SilentlyContinue +} + +#cleanup all code signing certs +function Cleanup-CodeSigningCert +{ + Param + ( + [string] + $Subject = 'PSCatalog Code Signing' + ) + + get-ChildItem Cert:\LocalMachine\My\ | ?{$_.Subject -eq "CN=$Subject"} | remove-item -Force -ErrorAction SilentlyContinue + get-ChildItem Cert:\CurrentUser\My\ | ?{$_.Subject -eq "CN=$Subject"} | remove-item -Force -ErrorAction SilentlyContinue + get-ChildItem Cert:\LocalMachine\TrustedPublisher\ | ?{$_.Subject -eq "CN=$Subject"} | remove-item -Force -ErrorAction SilentlyContinue + get-ChildItem Cert:\CurrentUser\TrustedPublisher\ | ?{$_.Subject -eq "CN=$Subject"} | remove-item -Force -ErrorAction SilentlyContinue +} + +#creates a code signing cert +function Create-CodeSigningCert +{ + Param + ( + [string] + $storeName = "Cert:\LocalMachine\TrustedPublisher", + + [string] + $subject = "PSCatalog Code Signing", + + [string] + $CertRA = "PSCatalog Test Root Authority" + ) + + if (!(Test-Path $storeName)) + { + New-Item $storeName -Verbose -Force + } + + $cert = (dir $storeName | where{$_.Subject -imatch $subject}) + if ($cert -ne $null -and $cert.Thumbprint -ne $null) + { + Write-Verbose "Cert with subject name $subject already found, attempting to use it" + return + } + + remove-item signing.cer -Force -ErrorAction SilentlyContinue + remove-item signing.inf -Force -ErrorAction SilentlyContinue + remove-item signing.pfx -Force -ErrorAction SilentlyContinue + $certInf = @" +[Version] +Signature = "`$Windows NT`$" + +[Strings] +szOID_ENHANCED_KEY_USAGE = "2.5.29.37" +szOID_CODE_SIGNING = "1.3.6.1.5.5.7.3.3" +szOID_BASIC_CONSTRAINTS = "2.5.29.19" + +[NewRequest] +Subject = "cn=$subject" +MachineKeySet = true +KeyLength = 2048 +HashAlgorithm = Sha256 +Exportable = true +RequestType = Cert +KeySpec = AT_SIGNATURE +KeyUsage = "CERT_KEY_CERT_SIGN_KEY_USAGE | CERT_DIGITAL_SIGNATURE_KEY_USAGE | CERT_CRL_SIGN_KEY_USAGE" +KeyUsageProperty = "NCRYPT_ALLOW_SIGNING_FLAG" +ValidityPeriod = "Years" +ValidityPeriodUnits = "1" + +[Extensions] +%szOID_BASIC_CONSTRAINTS% = "{text}ca=0" +%szOID_ENHANCED_KEY_USAGE% = "{text}%szOID_CODE_SIGNING%" +"@ + $certInf | out-file signing.inf -force + [void](Cleanup-CodeSigningCert -Subject $subject) + Create-CACert -CACert $CertRA + certreq -new -q -cert $CertRA .\signing.inf signing.cer + $mypwd = ConvertTo-SecureString -String "1234" -Force -AsPlainText + Get-ChildItem -Path Cert:\LocalMachine\My\ | ?{$_.Subject -eq "CN=$subject"} | Export-PfxCertificate -FilePath .\signing.pfx -Password $mypwd + Import-PfxCertificate -FilePath .\signing.pfx -CertStoreLocation "$storeName\" -Password $mypwd -Exportable + remove-item signing.cer -Force -ErrorAction SilentlyContinue + remove-item signing.inf -Force -ErrorAction SilentlyContinue + remove-item signing.pfx -Force -ErrorAction SilentlyContinue +} diff --git a/AzureAutomationRunbook/Tests/Pester.PublishRunbook.Tests.ps1 b/AzureAutomationRunbook/Tests/Pester.PublishRunbook.Tests.ps1 new file mode 100644 index 0000000..75d7e01 --- /dev/null +++ b/AzureAutomationRunbook/Tests/Pester.PublishRunbook.Tests.ps1 @@ -0,0 +1,176 @@ +# This is a Pester test suite to validate the PowerShellGet cmdlets for Publish-Runbook +# +# Copyright (c) Microsoft Corporation, 2016 + +#if ( $PSVersionTable.PSVersion -lt '5.1' ) +#{ +# return +#} + +Import-Module "$PSScriptRoot\PSGetTestUtils.psm1" -WarningAction SilentlyContinue + +$RepositoryName = 'LocalGallery' +$SourceLocation = "$PSScriptRoot\PSGalleryTestRepo" +$RegisteredINTRepo = $false +$SystemModulesPath = Join-Path -Path $PSHOME -ChildPath 'Modules' +$ProgramFilesModulesPath = Microsoft.PowerShell.Management\Join-Path -Path $env:ProgramFiles -ChildPath "WindowsPowerShell\Modules" +$Script:RunbookFolder = "$PSScriptRoot\TestRunbooks" +$Script:TempSaveLocation = "$PSScriptRoot\TestSaveRepo" + +Install-NuGetBinaries +Import-Module AzureAutomationRunbook -Scope:Local -PassThru + +if(-not (Test-Path -Path $SourceLocation -PathType Container)) +{ + $null = New-Item -Path $SourceLocation -ItemType Directory -Force +} + +if(-not (Test-Path -Path $Script:TempSaveLocation -PathType Container)) +{ + $null = New-Item -Path $Script:TempSaveLocation -ItemType Directory -Force +} + +$repo = Get-PSRepository -ErrorAction SilentlyContinue | + Where-Object {$_.SourceLocation.StartsWith($SourceLocation, [System.StringComparison]::OrdinalIgnoreCase)} +if($repo) +{ + $RepositoryName = $repo.Name +} +else +{ + Register-PSRepository -Name $RepositoryName -SourceLocation $SourceLocation -InstallationPolicy Trusted + $RegisteredINTRepo = $true +} + +Describe "PublishValidRunbook" -Tags 'BVT'{ + + Context "When it's graphical runbook with manifest" { + Publish-Runbook -Path "$Script:RunbookFolder\StartAzureRMVM" -Repository $RepositoryName -Description "Azure graph runbook test" -Author "Yuting" -Version 1.0 + It "Published the runbook"{ + $result = Find-Runbook -Name "StartAzureRMVM" -Repository $RepositoryName | Should Not BeNullOrEmpty + } + It "Has Runbook tag and AzureAutomation Tags"{ + $result = Find-Runbook -Name "StartAzureRMVM" -Repository $RepositoryName + $ResultTags = $result.Tags | Where-Object {($_ -eq 'AzureAutomation') -or + ($_ -eq 'Runbook')} + $ResultTags.Count | Should BeExactly 2 + + } + + } + Context "When it's graphical runbook without manifest" { + Publish-Runbook -Path "$Script:RunbookFolder\AzureAutomationTutorial" -Repository $RepositoryName -Description "AzureAutomationTutorial" -Author "Yuting" -Version 1.0 + It "Published the runbook"{ + $result = Find-Runbook -Name "AzureAutomationTutorial" -Repository $RepositoryName | Should Not BeNullOrEmpty + } + RemoveItem "$Script:RunbookFolder\AzureAutomationTutorial\*.psd1" + } + + Context "When the module has versions"{ + Publish-Runbook -Path "$Script:RunbookFolder\StopAzureRMVM\1.0" -Repository $RepositoryName -Description "StopAzureRMVM test folder" -Author "Yuting" -Version 1.0 + It "Published the runbook"{ + $result = Find-Runbook -Name "StopAzureRMVM" -Repository $RepositoryName | Should Not BeNullOrEmpty + } + Publish-Runbook -Path "$Script:RunbookFolder\StopAzureRMVM\1.1" -Repository $RepositoryName -Description "StopAzureRMVM test folder" -Author "Yuting" + It "Published the runbook with higher version"{ + $result = Find-Runbook -Name "StopAzureRMVM" -Repository $RepositoryName -RequiredVersion 1.1 | Should Not BeNullOrEmpty + $runbooks = Find-Runbook -Name "StopAzureRMVM" -Repository $RepositoryName -AllVersions + $runbooks.Count | Should BeExactly 2 + } + } + + Context "When it's graphic workflow runbook"{ + Publish-Runbook -Path "$Script:RunbookFolder\Find-EmptyResourceGroups" -Repository $RepositoryName -Description "Find-EmptyResourceGroups test workflow" -Author "Yuting" -Version 1.0 + It "Published the runbook"{ + $result = Find-Runbook -Name "Find-EmptyResourceGroups" -Repository $RepositoryName + $Tags = $result.Tags + $ResultTags = $result.Tags | Where-Object {($_ -eq 'GraphicalPSWFRunbook')} + $ResultTags | Should Not BeNullOrEmpty + + } + } + + Context "When the full path to runbook is specified"{ + Publish-Runbook -Path "$Script:RunbookFolder\Hello-WorldGraphical.graphrunbook" -Repository $RepositoryName -Description "Test path to graphrunbook" -Author "Yuting" -Version 1.0 + It "Published the runbook"{ + $result = Find-Runbook -Name "Hello-WorldGraphical" -Repository $RepositoryName + $Tags = $result.Tags + $ResultTags = $result.Tags | Where-Object {($_ -eq 'GraphicalPSWFRunbook')} + $ResultTags | Should Not BeNullOrEmpty + + } + } + + AfterAll{ + RemoveItem "$PSScriptRoot\PSGalleryTestRepo\*" + } +} + + +Describe "PublishInValidRunbook" -Tags 'BVT'{ + Context "When the path is invalid" { + { Publish-Runbook -Path "$Script:RunbookFolder\TestNonExistingPath" -Repository $RepositoryName -Description "Test non-existing path" -Author "Yuting" -Version 1.0 } | Should Throw + } + Context "When there is no .graphrunbook" { + { Publish-Runbook -Path "$Script:RunbookFolder\TestInvalidRunbookFolder" -Repository $RepositoryName -Description "Test module folder without runbook file" -Author "Yuting" -Version 1.0 } | Should Throw + } + Context "When the graphrunbook is invalid" { + { Publish-Runbook -Path "$Script:RunbookFolder\Invalid-GraphicalRB" -Repository $RepositoryName -Description "Invalid .graphrunbook file" -Author "Yuting" -Version 1.0 } | Should Throw + } + AfterAll{ + RemoveItem "$PSScriptRoot\PSGalleryTestRepo\*" + } +} + +Describe "FindRunbook" -Tags 'BVT'{ + Context "Find an existing runbook" { + Publish-Runbook -Path "$Script:RunbookFolder\AzureAutomationTutorial" -Repository $RepositoryName -Description "AzureAutomationTutorial test workflow" -Author "Yuting" -Version 1.0 + It "Will find the runbook"{ + $runbook = Find-Runbook -Name "AzureAutomationTutorial" + $runbook | Should Not BeNullOrEmpty + } + } + Context "Find runbook that is workflow" { + Publish-Runbook -Path "$Script:RunbookFolder\Find-EmptyResourceGroups" -Repository $RepositoryName -Description "Find-EmptyResourceGroups test workflow" -Author "Yuting" -Version 1.0 + It "can find the runbook with workflow tag"{ + $runbook = Find-Runbook -Name "Find-EmptyResourceGroups" -Tag "Workflow" | Should Not BeNullOrEmpty + } + It "can find the runbook with Azure Automation tag"{ + $runbook = Find-Runbook -Name "Find-EmptyResourceGroups" -Tag "AzureAutomation" | Should Not BeNullOrEmpty + } + } + + AfterAll{ + RemoveItem "$PSScriptRoot\PSGalleryTestRepo\*" + } +} + +Describe "SaveRunbook" -Tags 'BVT'{ + Context "Find a runbook and save it locally" { + Publish-Runbook -Path "$Script:RunbookFolder\AzureAutomationTutorial" -Repository $RepositoryName -Description "AzureAutomationTutorial test workflow" -Author "Yuting" -Version 1.0 + It "Will find the runbook and save only the .graphrunbook"{ + Save-Runbook -Name AzureAutomationTutorial -Path $Script:TempSaveLocation + Test-Path "$Script:TempSaveLocation\AzureAutomationTutorial.psd1" | Should Be $False + Get-Item "$Script:TempSaveLocation\AzureAutomationTutorial.graphrunbook" | Should Be $True + } + } + + Context "Find a runbook base on the version and save it locally" { + Publish-Runbook -Path "$Script:RunbookFolder\StopAzureRMVM\1.0" -Repository $RepositoryName -Description "StopAzureRMVM test folder" -Author "Yuting" + Publish-Runbook -Path "$Script:RunbookFolder\StopAzureRMVM\1.1" -Repository $RepositoryName -Description "StopAzureRMVM test folder" -Author "Yuting" + It "Can find the higher version and save it"{ + Save-Runbook -Name StopAzureRMVM -Path $Script:TempSaveLocation + Test-Path "$Script:TempSaveLocation\StopAzureRMVM.psd1" | Should Be $False + Get-Item "$Script:TempSaveLocation\StopAzureRMVM.graphrunbook" | Should Be $True + } + It "Can find the specified version and save it"{ + Save-Runbook -Name StopAzureRMVM -Path $Script:TempSaveLocation -RequiredVersion 1.0 + Get-Item "$Script:TempSaveLocation\StopAzureRMVM.graphrunbook" | Should Be $True + } + } + + AfterAll{ + RemoveItem "$PSScriptRoot\PSGalleryTestRepo\*" + RemoveItem "$Script:TempSaveLocation\*" + } +} \ No newline at end of file diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.graphrunbook b/AzureAutomationRunbook/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.graphrunbook new file mode 100644 index 0000000..32ff3cd --- /dev/null +++ b/AzureAutomationRunbook/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.graphrunbook @@ -0,0 +1 @@ +{"SchemaVersion":"1.7","RunbookDefinition":"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","RunbookType":"GraphPowerShell"} \ No newline at end of file diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.psd1 b/AzureAutomationRunbook/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.psd1 new file mode 100644 index 0000000..e17598e --- /dev/null +++ b/AzureAutomationRunbook/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.psd1 @@ -0,0 +1,124 @@ +# +# Module manifest for module 'PSGet_AzureAutomationTutorial' +# +# Generated by: Yuting +# +# Generated on: 7/21/2016 +# + +@{ + +# Script module or binary module file associated with this manifest. +# RootModule = '' + +# Version number of this module. +ModuleVersion = '1.0' + +# ID used to uniquely identify this module +GUID = '64f88faf-e0cf-4e4a-80eb-2792a70389cc' + +# Author of this module +Author = 'Yuting' + +# Company or vendor of this module +CompanyName = 'Unknown' + +# Copyright statement for this module +Copyright = '(c) 2016 Yuting. All rights reserved.' + +# Description of the functionality provided by this module +Description = 'AzureAutomationTutorial test workflow' + +# Minimum version of the Windows PowerShell engine required by this module +# PowerShellVersion = '' + +# Name of the Windows PowerShell host required by this module +# PowerShellHostName = '' + +# Minimum version of the Windows PowerShell host required by this module +# PowerShellHostVersion = '' + +# Minimum version of Microsoft .NET Framework required by this module +# DotNetFrameworkVersion = '' + +# Minimum version of the common language runtime (CLR) required by this module +# CLRVersion = '' + +# Processor architecture (None, X86, Amd64) required by this module +# ProcessorArchitecture = '' + +# Modules that must be imported into the global environment prior to importing this module +# RequiredModules = @() + +# Assemblies that must be loaded prior to importing this module +# RequiredAssemblies = @() + +# Script files (.ps1) that are run in the caller's environment prior to importing this module. +# ScriptsToProcess = @() + +# Type files (.ps1xml) to be loaded when importing this module +# TypesToProcess = @() + +# Format files (.ps1xml) to be loaded when importing this module +# FormatsToProcess = @() + +# Modules to import as nested modules of the module specified in RootModule/ModuleToProcess +# NestedModules = @() + +# Functions to export from this module +# FunctionsToExport = @() + +# Cmdlets to export from this module +# CmdletsToExport = @() + +# Variables to export from this module +# VariablesToExport = @() + +# Aliases to export from this module +# AliasesToExport = @() + +# DSC resources to export from this module +# DscResourcesToExport = @() + +# List of all modules packaged with this module +# ModuleList = @() + +# List of all files packaged with this module +FileList = 'AzureAutomationTutorial.psd1', + 'AzureAutomationTutorial.graphrunbook' + +# Private data to pass to the module specified in RootModule/ModuleToProcess. This may also contain a PSData hashtable with additional module metadata used by PowerShell. +PrivateData = @{ + + PSData = @{ + + # Tags applied to this module. These help with module discovery in online galleries. + Tags = 'AzureAutomation','Runbook','GraphicalPSWFRunbook','Workflow' + + # A URL to the license for this module. + # LicenseUri = '' + + # A URL to the main website for this project. + # ProjectUri = '' + + # A URL to an icon representing this module. + # IconUri = '' + + # ReleaseNotes of this module + # ReleaseNotes = '' + + # External dependent modules of this module + # ExternalModuleDependencies = '' + + } # End of PSData hashtable + + } # End of PrivateData hashtable + +# HelpInfo URI of this module +# HelpInfoURI = '' + +# Default prefix for commands exported from this module. Override the default prefix using Import-Module -Prefix. +# DefaultCommandPrefix = '' + +} + diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.graphrunbook b/AzureAutomationRunbook/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.graphrunbook new file mode 100644 index 0000000..4d60fb8 --- /dev/null +++ b/AzureAutomationRunbook/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.graphrunbook @@ -0,0 +1 @@ +{"SchemaVersion":"1.2","RunbookDefinition":"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"} \ No newline at end of file diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.psd1 b/AzureAutomationRunbook/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.psd1 new file mode 100644 index 0000000..219a88a --- /dev/null +++ b/AzureAutomationRunbook/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.psd1 @@ -0,0 +1,124 @@ +# +# Module manifest for module 'PSGet_Find-EmptyResourceGroups' +# +# Generated by: Yuting +# +# Generated on: 7/21/2016 +# + +@{ + +# Script module or binary module file associated with this manifest. +# RootModule = '' + +# Version number of this module. +ModuleVersion = '1.0' + +# ID used to uniquely identify this module +GUID = 'bc5382b6-adeb-4e94-a07d-190b2c0f08c2' + +# Author of this module +Author = 'Yuting' + +# Company or vendor of this module +CompanyName = 'Unknown' + +# Copyright statement for this module +Copyright = '(c) 2016 Yuting. All rights reserved.' + +# Description of the functionality provided by this module +Description = 'Find-EmptyResourceGroups test workflow' + +# Minimum version of the Windows PowerShell engine required by this module +# PowerShellVersion = '' + +# Name of the Windows PowerShell host required by this module +# PowerShellHostName = '' + +# Minimum version of the Windows PowerShell host required by this module +# PowerShellHostVersion = '' + +# Minimum version of Microsoft .NET Framework required by this module +# DotNetFrameworkVersion = '' + +# Minimum version of the common language runtime (CLR) required by this module +# CLRVersion = '' + +# Processor architecture (None, X86, Amd64) required by this module +# ProcessorArchitecture = '' + +# Modules that must be imported into the global environment prior to importing this module +# RequiredModules = @() + +# Assemblies that must be loaded prior to importing this module +# RequiredAssemblies = @() + +# Script files (.ps1) that are run in the caller's environment prior to importing this module. +# ScriptsToProcess = @() + +# Type files (.ps1xml) to be loaded when importing this module +# TypesToProcess = @() + +# Format files (.ps1xml) to be loaded when importing this module +# FormatsToProcess = @() + +# Modules to import as nested modules of the module specified in RootModule/ModuleToProcess +# NestedModules = @() + +# Functions to export from this module +# FunctionsToExport = @() + +# Cmdlets to export from this module +# CmdletsToExport = @() + +# Variables to export from this module +# VariablesToExport = @() + +# Aliases to export from this module +# AliasesToExport = @() + +# DSC resources to export from this module +# DscResourcesToExport = @() + +# List of all modules packaged with this module +# ModuleList = @() + +# List of all files packaged with this module +FileList = 'Find-EmptyResourceGroups.psd1', + 'Find-EmptyResourceGroups.graphrunbook' + +# Private data to pass to the module specified in RootModule/ModuleToProcess. This may also contain a PSData hashtable with additional module metadata used by PowerShell. +PrivateData = @{ + + PSData = @{ + + # Tags applied to this module. These help with module discovery in online galleries. + Tags = 'AzureAutomation','Runbook','GraphicalPSWFRunbook','Workflow' + + # A URL to the license for this module. + # LicenseUri = '' + + # A URL to the main website for this project. + # ProjectUri = '' + + # A URL to an icon representing this module. + # IconUri = '' + + # ReleaseNotes of this module + # ReleaseNotes = '' + + # External dependent modules of this module + # ExternalModuleDependencies = '' + + } # End of PSData hashtable + + } # End of PrivateData hashtable + +# HelpInfo URI of this module +# HelpInfoURI = '' + +# Default prefix for commands exported from this module. Override the default prefix using Import-Module -Prefix. +# DefaultCommandPrefix = '' + +} + diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/Hello-WorldGraphical.graphrunbook b/AzureAutomationRunbook/Tests/TestRunbooks/Hello-WorldGraphical.graphrunbook new file mode 100644 index 0000000..fe2f6c0 --- /dev/null +++ b/AzureAutomationRunbook/Tests/TestRunbooks/Hello-WorldGraphical.graphrunbook @@ -0,0 +1 @@ +{"SchemaVersion":"1.0","RunbookDefinition":"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"} \ No newline at end of file diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/Invalid-GraphicalRB/Invalid-GraphicalRB.graphrunbook b/AzureAutomationRunbook/Tests/TestRunbooks/Invalid-GraphicalRB/Invalid-GraphicalRB.graphrunbook new file mode 100644 index 0000000..9bdda11 --- /dev/null +++ b/AzureAutomationRunbook/Tests/TestRunbooks/Invalid-GraphicalRB/Invalid-GraphicalRB.graphrunbook @@ -0,0 +1 @@ +{"SchemaVersion":"1.0","RunbookDefinition":"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"} \ No newline at end of file diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.graphrunbook b/AzureAutomationRunbook/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.graphrunbook new file mode 100644 index 0000000..bbe0c6c --- /dev/null +++ b/AzureAutomationRunbook/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.graphrunbook @@ -0,0 +1 @@ +{"SchemaVersion":"1.2","RunbookDefinition":"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"} \ No newline at end of file diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.psd1 b/AzureAutomationRunbook/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.psd1 new file mode 100644 index 0000000..1d864be --- /dev/null +++ b/AzureAutomationRunbook/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.psd1 @@ -0,0 +1,123 @@ +# +# Module manifest for module 'PSGet_StartAzureRMVM' +# +# Generated by: Yuting +# +# Generated on: 7/21/2016 +# + +@{ + +# Script module or binary module file associated with this manifest. +# RootModule = '' + +# Version number of this module. +ModuleVersion = '1.0' + +# ID used to uniquely identify this module +GUID = '8777b74d-abdc-41f9-a9e1-23c72fb26adb' + +# Author of this module +Author = 'Yuting' + +# Company or vendor of this module +CompanyName = 'Microsoft Corporation' + +# Copyright statement for this module +Copyright = '(c) 2016 ManikB. All rights reserved.' + +# Description of the functionality provided by this module +Description = 'Azure graph runbook test' + +# Minimum version of the Windows PowerShell engine required by this module +# PowerShellVersion = '' + +# Name of the Windows PowerShell host required by this module +# PowerShellHostName = '' + +# Minimum version of the Windows PowerShell host required by this module +# PowerShellHostVersion = '' + +# Minimum version of Microsoft .NET Framework required by this module +# DotNetFrameworkVersion = '' + +# Minimum version of the common language runtime (CLR) required by this module +# CLRVersion = '' + +# Processor architecture (None, X86, Amd64) required by this module +# ProcessorArchitecture = '' + +# Modules that must be imported into the global environment prior to importing this module +# RequiredModules = @() + +# Assemblies that must be loaded prior to importing this module +# RequiredAssemblies = @() + +# Script files (.ps1) that are run in the caller's environment prior to importing this module. +# ScriptsToProcess = @() + +# Type files (.ps1xml) to be loaded when importing this module +# TypesToProcess = @() + +# Format files (.ps1xml) to be loaded when importing this module +# FormatsToProcess = @() + +# Modules to import as nested modules of the module specified in RootModule/ModuleToProcess +# NestedModules = @() + +# Functions to export from this module +# FunctionsToExport = @() + +# Cmdlets to export from this module +# CmdletsToExport = @() + +# Variables to export from this module +# VariablesToExport = @() + +# Aliases to export from this module +# AliasesToExport = @() + +# DSC resources to export from this module +# DscResourcesToExport = @() + +# List of all modules packaged with this module +# ModuleList = @() + +# List of all files packaged with this module +FileList = 'StartAzureRMVM.psd1', 'StartAzureRMVM.graphrunbook' + +# Private data to pass to the module specified in RootModule/ModuleToProcess. This may also contain a PSData hashtable with additional module metadata used by PowerShell. +PrivateData = @{ + + PSData = @{ + + # Tags applied to this module. These help with module discovery in online galleries. + Tags = 'MyGraphRBTag','AzureGraphRunbook','GraphicalPSWFRunbook','Workflow','Runbook','AzureAutomation' + + # A URL to the license for this module. + LicenseUri = 'http://contoso.com/License' + + # A URL to the main website for this project. + ProjectUri = 'http://contoso.com/' + + # A URL to an icon representing this module. + IconUri = 'http://contoso.com/Icon' + + # ReleaseNotes of this module + ReleaseNotes = 'This automation pack now supports feature1, feature1, etc.' + + # External dependent modules of this module + # ExternalModuleDependencies = '' + + } # End of PSData hashtable + + } # End of PrivateData hashtable + +# HelpInfo URI of this module +# HelpInfoURI = '' + +# Default prefix for commands exported from this module. Override the default prefix using Import-Module -Prefix. +# DefaultCommandPrefix = '' + +} + diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.graphrunbook b/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.graphrunbook new file mode 100644 index 0000000..7410105 --- /dev/null +++ b/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.graphrunbook @@ -0,0 +1 @@ +{"SchemaVersion":"1.2","RunbookDefinition":"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"} \ No newline at end of file diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.psd1 b/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.psd1 new file mode 100644 index 0000000..21721d5 --- /dev/null +++ b/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.psd1 @@ -0,0 +1,123 @@ +# +# Module manifest for module 'PSGet_StopAzureRMVM' +# +# Generated by: Yuting +# +# Generated on: 7/21/2016 +# + +@{ + +# Script module or binary module file associated with this manifest. +# RootModule = '' + +# Version number of this module. +ModuleVersion = '1.0' + +# ID used to uniquely identify this module +GUID = '5a529349-afc1-4969-83fc-927a8e3e8fd0' + +# Author of this module +Author = 'Yuting' + +# Company or vendor of this module +CompanyName = 'Unknown' + +# Copyright statement for this module +Copyright = '(c) 2016 Yuting. All rights reserved.' + +# Description of the functionality provided by this module +Description = 'StopAzureRMVM test folder' + +# Minimum version of the Windows PowerShell engine required by this module +# PowerShellVersion = '' + +# Name of the Windows PowerShell host required by this module +# PowerShellHostName = '' + +# Minimum version of the Windows PowerShell host required by this module +# PowerShellHostVersion = '' + +# Minimum version of Microsoft .NET Framework required by this module +# DotNetFrameworkVersion = '' + +# Minimum version of the common language runtime (CLR) required by this module +# CLRVersion = '' + +# Processor architecture (None, X86, Amd64) required by this module +# ProcessorArchitecture = '' + +# Modules that must be imported into the global environment prior to importing this module +# RequiredModules = @() + +# Assemblies that must be loaded prior to importing this module +# RequiredAssemblies = @() + +# Script files (.ps1) that are run in the caller's environment prior to importing this module. +# ScriptsToProcess = @() + +# Type files (.ps1xml) to be loaded when importing this module +# TypesToProcess = @() + +# Format files (.ps1xml) to be loaded when importing this module +# FormatsToProcess = @() + +# Modules to import as nested modules of the module specified in RootModule/ModuleToProcess +# NestedModules = @() + +# Functions to export from this module +# FunctionsToExport = @() + +# Cmdlets to export from this module +# CmdletsToExport = @() + +# Variables to export from this module +# VariablesToExport = @() + +# Aliases to export from this module +# AliasesToExport = @() + +# DSC resources to export from this module +# DscResourcesToExport = @() + +# List of all modules packaged with this module +# ModuleList = @() + +# List of all files packaged with this module +FileList = 'StopAzureRMVM.psd1', 'StopAzureRMVM.graphrunbook' + +# Private data to pass to the module specified in RootModule/ModuleToProcess. This may also contain a PSData hashtable with additional module metadata used by PowerShell. +PrivateData = @{ + + PSData = @{ + + # Tags applied to this module. These help with module discovery in online galleries. + Tags = 'AzureAutomation','Runbook','GraphicalPSWFRunbook','Workflow' + + # A URL to the license for this module. + # LicenseUri = '' + + # A URL to the main website for this project. + # ProjectUri = '' + + # A URL to an icon representing this module. + # IconUri = '' + + # ReleaseNotes of this module + # ReleaseNotes = '' + + # External dependent modules of this module + # ExternalModuleDependencies = '' + + } # End of PSData hashtable + + } # End of PrivateData hashtable + +# HelpInfo URI of this module +# HelpInfoURI = '' + +# Default prefix for commands exported from this module. Override the default prefix using Import-Module -Prefix. +# DefaultCommandPrefix = '' + +} + diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.graphrunbook b/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.graphrunbook new file mode 100644 index 0000000..7410105 --- /dev/null +++ b/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.graphrunbook @@ -0,0 +1 @@ +{"SchemaVersion":"1.2","RunbookDefinition":"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"} \ No newline at end of file diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.psd1 b/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.psd1 new file mode 100644 index 0000000..5df5969 --- /dev/null +++ b/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.psd1 @@ -0,0 +1,123 @@ +# +# Module manifest for module 'PSGet_StopAzureRMVM' +# +# Generated by: Yuting +# +# Generated on: 7/21/2016 +# + +@{ + +# Script module or binary module file associated with this manifest. +# RootModule = '' + +# Version number of this module. +ModuleVersion = '1.1' + +# ID used to uniquely identify this module +GUID = '5a529349-afc1-4969-83fc-927a8e3e8fd0' + +# Author of this module +Author = 'Yuting' + +# Company or vendor of this module +CompanyName = 'Unknown' + +# Copyright statement for this module +Copyright = '(c) 2016 Yuting. All rights reserved.' + +# Description of the functionality provided by this module +Description = 'StopAzureRMVM test folder' + +# Minimum version of the Windows PowerShell engine required by this module +# PowerShellVersion = '' + +# Name of the Windows PowerShell host required by this module +# PowerShellHostName = '' + +# Minimum version of the Windows PowerShell host required by this module +# PowerShellHostVersion = '' + +# Minimum version of Microsoft .NET Framework required by this module +# DotNetFrameworkVersion = '' + +# Minimum version of the common language runtime (CLR) required by this module +# CLRVersion = '' + +# Processor architecture (None, X86, Amd64) required by this module +# ProcessorArchitecture = '' + +# Modules that must be imported into the global environment prior to importing this module +# RequiredModules = @() + +# Assemblies that must be loaded prior to importing this module +# RequiredAssemblies = @() + +# Script files (.ps1) that are run in the caller's environment prior to importing this module. +# ScriptsToProcess = @() + +# Type files (.ps1xml) to be loaded when importing this module +# TypesToProcess = @() + +# Format files (.ps1xml) to be loaded when importing this module +# FormatsToProcess = @() + +# Modules to import as nested modules of the module specified in RootModule/ModuleToProcess +# NestedModules = @() + +# Functions to export from this module +# FunctionsToExport = @() + +# Cmdlets to export from this module +# CmdletsToExport = @() + +# Variables to export from this module +# VariablesToExport = @() + +# Aliases to export from this module +# AliasesToExport = @() + +# DSC resources to export from this module +# DscResourcesToExport = @() + +# List of all modules packaged with this module +# ModuleList = @() + +# List of all files packaged with this module +FileList = 'StopAzureRMVM.psd1', 'StopAzureRMVM.graphrunbook' + +# Private data to pass to the module specified in RootModule/ModuleToProcess. This may also contain a PSData hashtable with additional module metadata used by PowerShell. +PrivateData = @{ + + PSData = @{ + + # Tags applied to this module. These help with module discovery in online galleries. + Tags = 'AzureAutomation','Runbook','GraphicalPSWFRunbook','Workflow' + + # A URL to the license for this module. + # LicenseUri = '' + + # A URL to the main website for this project. + # ProjectUri = '' + + # A URL to an icon representing this module. + # IconUri = '' + + # ReleaseNotes of this module + # ReleaseNotes = '' + + # External dependent modules of this module + # ExternalModuleDependencies = '' + + } # End of PSData hashtable + + } # End of PrivateData hashtable + +# HelpInfo URI of this module +# HelpInfoURI = '' + +# Default prefix for commands exported from this module. Override the default prefix using Import-Module -Prefix. +# DefaultCommandPrefix = '' + +} + diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.graphrunbook b/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.graphrunbook new file mode 100644 index 0000000..7410105 --- /dev/null +++ b/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.graphrunbook @@ -0,0 +1 @@ +{"SchemaVersion":"1.2","RunbookDefinition":"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"} \ No newline at end of file diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.psd1 b/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.psd1 new file mode 100644 index 0000000..0c73c3b --- /dev/null +++ b/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.psd1 @@ -0,0 +1,123 @@ +# +# Module manifest for module 'PSGet_StopAzureRMVM' +# +# Generated by: Yuting +# +# Generated on: 7/14/2016 +# + +@{ + +# Script module or binary module file associated with this manifest. +# RootModule = '' + +# Version number of this module. +ModuleVersion = '1.2' + +# ID used to uniquely identify this module +GUID = '5a529349-afc1-4969-83fc-927a8e3e8fd0' + +# Author of this module +Author = 'Yuting' + +# Company or vendor of this module +CompanyName = 'Unknown' + +# Copyright statement for this module +Copyright = '(c) 2016 Yuting. All rights reserved.' + +# Description of the functionality provided by this module +Description = 'StopAzureRMVM test folder' + +# Minimum version of the Windows PowerShell engine required by this module +# PowerShellVersion = '' + +# Name of the Windows PowerShell host required by this module +# PowerShellHostName = '' + +# Minimum version of the Windows PowerShell host required by this module +# PowerShellHostVersion = '' + +# Minimum version of Microsoft .NET Framework required by this module +# DotNetFrameworkVersion = '' + +# Minimum version of the common language runtime (CLR) required by this module +# CLRVersion = '' + +# Processor architecture (None, X86, Amd64) required by this module +# ProcessorArchitecture = '' + +# Modules that must be imported into the global environment prior to importing this module +# RequiredModules = @() + +# Assemblies that must be loaded prior to importing this module +# RequiredAssemblies = @() + +# Script files (.ps1) that are run in the caller's environment prior to importing this module. +# ScriptsToProcess = @() + +# Type files (.ps1xml) to be loaded when importing this module +# TypesToProcess = @() + +# Format files (.ps1xml) to be loaded when importing this module +# FormatsToProcess = @() + +# Modules to import as nested modules of the module specified in RootModule/ModuleToProcess +# NestedModules = @() + +# Functions to export from this module +# FunctionsToExport = @() + +# Cmdlets to export from this module +# CmdletsToExport = @() + +# Variables to export from this module +# VariablesToExport = @() + +# Aliases to export from this module +# AliasesToExport = @() + +# DSC resources to export from this module +# DscResourcesToExport = @() + +# List of all modules packaged with this module +# ModuleList = @() + +# List of all files packaged with this module +FileList = 'StopAzureRMVM.psd1', 'StopAzureRMVM.graphrunbook' + +# Private data to pass to the module specified in RootModule/ModuleToProcess. This may also contain a PSData hashtable with additional module metadata used by PowerShell. +PrivateData = @{ + + PSData = @{ + + # Tags applied to this module. These help with module discovery in online galleries. + Tags = 'AzureAutomation','Runbook','GraphicalPSWFRunbook','Workflow' + + # A URL to the license for this module. + # LicenseUri = '' + + # A URL to the main website for this project. + # ProjectUri = '' + + # A URL to an icon representing this module. + # IconUri = '' + + # ReleaseNotes of this module + # ReleaseNotes = '' + + # External dependent modules of this module + # ExternalModuleDependencies = '' + + } # End of PSData hashtable + + } # End of PrivateData hashtable + +# HelpInfo URI of this module +# HelpInfoURI = '' + +# Default prefix for commands exported from this module. Override the default prefix using Import-Module -Prefix. +# DefaultCommandPrefix = '' + +} + diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.graphrunbook b/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.graphrunbook new file mode 100644 index 0000000..7410105 --- /dev/null +++ b/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.graphrunbook @@ -0,0 +1 @@ +{"SchemaVersion":"1.2","RunbookDefinition":"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"} \ No newline at end of file diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.psd1 b/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.psd1 new file mode 100644 index 0000000000000000000000000000000000000000..0f272f267da223712be0c3306e0c4e7fcec14b1e GIT binary patch literal 6800 zcmc(jYj0ac5QgV7692)HKO{vYCA4Y-5>l;P+DL7Qaw}hb#}LQHahev?zYe_5j<&rmnvoKPe zw`Rv0o!Hb`_NP|QH2+An&h%ef(2g8lYV1P)nP|^-?}=K+KH87Ef7IH!_+8j=g;f*H zW7TteY+JUi>-YAZo}Lxf!u5sy6~06S$JQ11kjVsK&H7lHG0>Q6r!Ada zYIRp%k}TJHo7=Bi$91F`Wj$^#5H_TxiGK4Xz5k>&YYWXq)Mr6wm!gQ=4gIf#y%WAR z^lh-jG173&Scm!k9u z3(~x_Q**k`w=Ju6WVOD2PxZ7B-k->>8{z%A#y0E+Sr+?l=-ShlZO!C;TdO*{wwI8% zgboaD(VO%GrhK;JDte=PakRybsE*}7Lcl{@J zt!tV4RDAK_p(MnMiB9)Hs9=W_tM!%u!!jl3zb>zSBpNZI^4Q$eNK2MK*FB-Y(}{e1 zWoBrjCy&ap?}qUdf6<$hebB)mcvx3b_;_2Kh$?hF743ul965bOv2vCnxpwG#5T_G;Cd3LyEqA ztG8cNm!5^EmXK4mp56m<8A+=aM|Iq!yhuhu`_v5j6DmAU^b=HbsvABOJ2Wz%*Zyd; zq4L*6^U2Mg$H>X}=0&iQ*C4Vr`4O%8`XX)b^lr-CO|3f;reansb~4C;tS_YbM_HHG z3ij#?OGgMtqH(j#NYf5o40-oU;I2kgjXv*DW6y~M>x%fPWZ4Rylx&DkdJUmF!-ia= zwYtGh^sO^hHRw=z9@=85uPx%gRCb!E{^1)jj_Ry-q8dL9a#YLwLH0afNKPl}{+iqF zI%E~sLGt6(d@b_74d(se-|Ur$p#KMV5yNe;FUL|jM#*;g3ptG(;rjq`b=)U1ns*Sz zQF>D>$}S1r_^cUTZl zrNbk7;tnp!3xYB&knUx4JO_WX)J5)ya!)=?ZM_eIoX)D;&ty$9ayw+jm=lSl+v}iA zYgH8N9l*d&;XXRZ>8#3qR~`6{Bqm?dM^U>yFWucAnxeNWYTZz+a;nw1$`$K%@HKLX zM-!Em+FFbzw8g%&tM1ObBdS&PnM3ZeAS}j7;#M6kX*@?$%x`x?vM)LD|HQ!~_TIi;3I&a!k&qyCURqT4-*pWUb(pSFwp&pG?0e#opP)zdVyFcOq+35J9 zPsB=Ew8lf{Hulvgg`Cq4J6`+%kMcg5zN#(c)Hl!`%A0rfolQq4@;+T4N>8jW3QVPXE(LtM5u2Mtwc?5J1b9gX<@d#b0To7}EwiD>4efu70FxX?NMEnKOG4Po&pWsdilu8D{_ z-V<*3^>j|^Cr{KH^zCN}(aVoQ#Y+Cmo?=bsXVJge4ZM7`^?(e$za9fogk!(>vBU?|wMh(bALSQ9Mz5z~LTAOoM)?k=ttXU_tXX z_>RPv+~5_M9jl*s#mZBSq0XN5)ZEw0HvJ?y(eR#Rrha*a$+JN@lfj>V-RfdKPr0X_ z4hUWaO-ywjeWCau$Kv}3pE1>IqH1+qyDT?zIfWcpTM>OOZTk+BFC+Dg$xGu&2>#NO z7w3JM_s;*-pOWom3?8g(o^9{>HNc;c* literal 0 HcmV?d00001 diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/TestInvalidRunbookFolder/TestInvalidRunbookFolder.txt b/AzureAutomationRunbook/Tests/TestRunbooks/TestInvalidRunbookFolder/TestInvalidRunbookFolder.txt new file mode 100644 index 0000000..e69de29 diff --git a/AzureAutomationRunbook/Tests/uiproxy.ps1 b/AzureAutomationRunbook/Tests/uiproxy.ps1 new file mode 100644 index 0000000..a3ecaa8 --- /dev/null +++ b/AzureAutomationRunbook/Tests/uiproxy.ps1 @@ -0,0 +1,262 @@ +#param($command) + +$source = @" +using System; +using System.Collections.Generic; +using System.Management.Automation; +using System.Management.Automation.Runspaces; +using System.Management.Automation.Host; + +namespace HostUIProxy +{ + public class HostProxy : System.Management.Automation.Host.PSHost + { + private System.Management.Automation.Host.PSHost realHost; + private System.Management.Automation.Host.PSHostUserInterface uiProxy; + + public HostProxy(System.Management.Automation.Host.PSHost realHost, string filePath, int sessionCount) + { + this.realHost = realHost; + uiProxy = new HostUIProxy(realHost.UI, filePath, sessionCount); + } + + public override System.Globalization.CultureInfo CurrentCulture + { + get { return realHost.CurrentCulture; } + } + + public override System.Globalization.CultureInfo CurrentUICulture + { + get { return realHost.CurrentUICulture; } + } + + public override void EnterNestedPrompt() + { + realHost.EnterNestedPrompt(); + } + + public override void ExitNestedPrompt() + { + realHost.ExitNestedPrompt(); + } + + public override Guid InstanceId + { + get { return realHost.InstanceId; } + } + + public override string Name + { + get { return realHost.Name; } + } + + public override void NotifyBeginApplication() + { + realHost.NotifyBeginApplication(); + } + + public override void NotifyEndApplication() + { + realHost.NotifyEndApplication(); + } + + public override void SetShouldExit(int exitCode) + { + realHost.SetShouldExit(exitCode); + } + + public override System.Management.Automation.Host.PSHostUserInterface UI + { + get { return uiProxy; } + } + + public override Version Version + { + get { return realHost.Version; } + } + } + + public class HostUIProxy : System.Management.Automation.Host.PSHostUserInterface + { + private string filePath = string.Empty; + private int choiceToMake = 0; + private int sessionCount = 1; + private System.Management.Automation.Host.PSHostUserInterface realUI; + + public HostUIProxy(System.Management.Automation.Host.PSHostUserInterface realUI, string filePath, int sessionCount) + { + this.filePath = filePath; + this.realUI = realUI; + this.sessionCount = sessionCount; + } + + public int ChoiceToMake + { + get { return choiceToMake; } + set { choiceToMake = value; } + } + + public override Dictionary Prompt(string caption, string message, System.Collections.ObjectModel.Collection descriptions) + { + return realUI.Prompt(caption, message, descriptions); + } + + public override int PromptForChoice(string caption, string message, System.Collections.ObjectModel.Collection choices, int defaultChoice) + { + WriteToFile(this.filePath, message,"PromptForChoice"); + return ChoiceToMake; + //return realUI.PromptForChoice(caption, message, choices, defaultChoice); + } + + public override System.Management.Automation.PSCredential PromptForCredential(string caption, string message, string userName, string targetName, System.Management.Automation.PSCredentialTypes allowedCredentialTypes, System.Management.Automation.PSCredentialUIOptions options) + { + return realUI.PromptForCredential(caption, message, userName, targetName, allowedCredentialTypes, options); + } + + public override System.Management.Automation.PSCredential PromptForCredential(string caption, string message, string userName, string targetName) + { + return realUI.PromptForCredential(caption, message, userName, targetName); + } + + public override System.Management.Automation.Host.PSHostRawUserInterface RawUI + { + get { return realUI.RawUI; } + } + + public override string ReadLine() + { + return realUI.ReadLine(); + } + + public override System.Security.SecureString ReadLineAsSecureString() + { + return realUI.ReadLineAsSecureString(); + } + + public override void Write(ConsoleColor foregroundColor, ConsoleColor backgroundColor, string value) + { + WriteToFile(this.filePath, value,"writewithcolor"); + //realUI.Write(foregroundColor, backgroundColor, value); + } + + public override void Write(string value) + { + WriteToFile(this.filePath, value,"write"); + //realUI.Write(value); + } + + public override void WriteDebugLine(string message) + { + WriteToFile(this.filePath, message, "WriteDebugLine"); + //realUI.WriteDebugLine(message); + } + + public override void WriteErrorLine(string value) + { + WriteToFile(this.filePath, value, "WriteErrorLine"); + //realUI.WriteErrorLine(value); + } + + public override void WriteLine(string value) + { + WriteToFile(this.filePath, value, "WriteLine"); + //realUI.WriteLine(value); + } + + public override void WriteProgress(long sourceId, System.Management.Automation.ProgressRecord record) + { + WriteToFile(this.filePath, record.ToString(), "WriteProgress"); + //realUI.WriteProgress(sourceId, record); + } + + public override void WriteVerboseLine(string message) + { + WriteToFile(this.filePath, message, "WriteVerboseLine"); + //realUI.WriteVerboseLine(message); + } + + public override void WriteWarningLine(string message) + { + WriteToFile(this.filePath, message, "WriteWarningLine"); + //realUI.WriteWarningLine(message.ToUpper()); + } + + private void WriteToFile(string filePath, string message,string type) + { + // Validate filepath parameter. + // handle null value. + if (filePath == null) + { + throw new ArgumentNullException("filePath cannot be null"); + } + // handle empty value. + if (filePath.Length == 0) + { + throw new ArgumentException("filePath cannot be empty"); + } + + try + { + + if (!System.IO.Directory.Exists(filePath)) + { + System.IO.Directory.CreateDirectory(filePath); + } + for (int i = 0; i < sessionCount; i++) + { + string tempFileName = System.IO.Path.Combine(filePath, (string.Concat(string.Format("{0}-{1}.txt",type,i)))); + + System.IO.File.AppendAllText(tempFileName, message.Trim()); + } + } + finally + { + GC.Collect(); + } + } + } +} +"@ + +Function CreateRunSpace($filePath,$sessionCount) +{ + if ([Type]::GetType('HostUIProxy.HostProxy',$false) -eq $null) + { + add-type -TypeDefinition $source -language CSharp + } + $Global:proxy = new-object HostUIProxy.HostProxy($host,$filePath,$sessionCount) + + $runspace = [Management.Automation.Runspaces.RunspaceFactory]::CreateRunspace($proxy) + $runspace.Open() + + return $runspace +} + +Function ExecuteCommand +{ + [CmdletBinding()] + param($runspace, $command) + + if($runspace -ne $null) + { + $pipe = $runspace.CreatePipeline($command) + + $pipe.invoke() + + if ($pipe.HadErrors) + { + $pipe.Error.ReadToEnd() | write-error + } + } +} + +Function CloseRunSpace($runspace) +{ + if($runspace -ne $null) + { + $runspace.Close() + } +} + + + From a155f794154fab2fe636317a54d759bedbaef67b Mon Sep 17 00:00:00 2001 From: Yuting Chen Date: Wed, 10 Aug 2016 13:57:26 -0700 Subject: [PATCH 5/5] Rename the module name to Azure.Automation.Get --- .../Azure.Automation.Get.Resource.psd1 | Bin .../Azure.Automation.Get.psd1 | Bin 3124 -> 3112 bytes .../Azure.Automation.Get.psm1 | 2 +- .../Orchestrator.GraphRunbook.Model.dll | Bin .../Tests/PSGetTestUtils.psm1 | 0 .../Tests/Pester.PublishRunbook.Tests.ps1 | 2 +- .../AzureAutomationTutorial.graphrunbook | 0 .../Find-EmptyResourceGroups.graphrunbook | 0 .../Find-EmptyResourceGroups.psd1 | 0 .../Hello-WorldGraphical.graphrunbook | 0 .../Invalid-GraphicalRB.graphrunbook | 0 .../StartAzureRMVM.graphrunbook | 0 .../StartAzureRMVM/StartAzureRMVM.psd1 | 35 ++-- .../1.0/StopAzureRMVM.graphrunbook | 0 .../StopAzureRMVM/1.0/StopAzureRMVM.psd1 | 0 .../1.1/StopAzureRMVM.graphrunbook | 0 .../StopAzureRMVM/1.1/StopAzureRMVM.psd1 | 0 .../1.2/StopAzureRMVM.graphrunbook | 0 .../StopAzureRMVM/1.2/StopAzureRMVM.psd1 | 0 .../1.3/StopAzureRMVM.graphrunbook | 0 .../StopAzureRMVM/1.3/StopAzureRMVM.psd1 | Bin .../TestInvalidRunbookFolder.txt | 0 .../Tests/uiproxy.ps1 | 0 .../AzureAutomationTutorial.psd1 | 124 ------------- cAzureStorage/SampleAzureStorageConfig.ps1 | 172 +++++++++--------- 25 files changed, 107 insertions(+), 228 deletions(-) rename AzureAutomationRunbook/AzureAutomationRunbook.Resource.psd1 => Azure.Automation.Get/Azure.Automation.Get.Resource.psd1 (100%) rename AzureAutomationRunbook/AzureAutomationRunbook.psd1 => Azure.Automation.Get/Azure.Automation.Get.psd1 (90%) rename AzureAutomationRunbook/AzureAutomationRunbook.psm1 => Azure.Automation.Get/Azure.Automation.Get.psm1 (99%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Orchestrator.GraphRunbook.Model.dll (100%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/PSGetTestUtils.psm1 (100%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/Pester.PublishRunbook.Tests.ps1 (99%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.graphrunbook (100%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.graphrunbook (100%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.psd1 (100%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/TestRunbooks/Hello-WorldGraphical.graphrunbook (100%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/TestRunbooks/Invalid-GraphicalRB/Invalid-GraphicalRB.graphrunbook (100%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.graphrunbook (100%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.psd1 (75%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.graphrunbook (100%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.psd1 (100%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.graphrunbook (100%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.psd1 (100%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.graphrunbook (100%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.psd1 (100%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.graphrunbook (100%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.psd1 (100%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/TestRunbooks/TestInvalidRunbookFolder/TestInvalidRunbookFolder.txt (100%) rename {AzureAutomationRunbook => Azure.Automation.Get}/Tests/uiproxy.ps1 (100%) delete mode 100644 AzureAutomationRunbook/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.psd1 diff --git a/AzureAutomationRunbook/AzureAutomationRunbook.Resource.psd1 b/Azure.Automation.Get/Azure.Automation.Get.Resource.psd1 similarity index 100% rename from AzureAutomationRunbook/AzureAutomationRunbook.Resource.psd1 rename to Azure.Automation.Get/Azure.Automation.Get.Resource.psd1 diff --git a/AzureAutomationRunbook/AzureAutomationRunbook.psd1 b/Azure.Automation.Get/Azure.Automation.Get.psd1 similarity index 90% rename from AzureAutomationRunbook/AzureAutomationRunbook.psd1 rename to Azure.Automation.Get/Azure.Automation.Get.psd1 index e0fc12458200dd5c81d9719dffa751045912ba67..e64c3349bb3d6106acc62fccda844aad3302004a 100644 GIT binary patch delta 61 tcmdlYu|i^k38UU*er{2AJqCA%RECm`p~+mRB9m`&nWKtqHsoez1OT_B4K@G( delta 73 vcmZ1>u|;Bn$>ahS5#At%QieQ+B!+w-%-$H7%!MgB`68D&rs!r>Ze~UR)ol`F diff --git a/AzureAutomationRunbook/AzureAutomationRunbook.psm1 b/Azure.Automation.Get/Azure.Automation.Get.psm1 similarity index 99% rename from AzureAutomationRunbook/AzureAutomationRunbook.psm1 rename to Azure.Automation.Get/Azure.Automation.Get.psm1 index bbb74aa..b251d88 100644 --- a/AzureAutomationRunbook/AzureAutomationRunbook.psm1 +++ b/Azure.Automation.Get/Azure.Automation.Get.psm1 @@ -9,7 +9,7 @@ Microsoft.PowerShell.Core\Set-StrictMode -Version Latest -Microsoft.PowerShell.Utility\Import-LocalizedData LocalizedData -filename AzureAutomationRunbook.Resource.psd1 +Microsoft.PowerShell.Utility\Import-LocalizedData LocalizedData -filename Azure.Automation.Get.Resource.psd1 $script:TempPath = ([System.IO.DirectoryInfo]$env:TEMP).FullName #region *-Runbook cmdlets diff --git a/AzureAutomationRunbook/Orchestrator.GraphRunbook.Model.dll b/Azure.Automation.Get/Orchestrator.GraphRunbook.Model.dll similarity index 100% rename from AzureAutomationRunbook/Orchestrator.GraphRunbook.Model.dll rename to Azure.Automation.Get/Orchestrator.GraphRunbook.Model.dll diff --git a/AzureAutomationRunbook/Tests/PSGetTestUtils.psm1 b/Azure.Automation.Get/Tests/PSGetTestUtils.psm1 similarity index 100% rename from AzureAutomationRunbook/Tests/PSGetTestUtils.psm1 rename to Azure.Automation.Get/Tests/PSGetTestUtils.psm1 diff --git a/AzureAutomationRunbook/Tests/Pester.PublishRunbook.Tests.ps1 b/Azure.Automation.Get/Tests/Pester.PublishRunbook.Tests.ps1 similarity index 99% rename from AzureAutomationRunbook/Tests/Pester.PublishRunbook.Tests.ps1 rename to Azure.Automation.Get/Tests/Pester.PublishRunbook.Tests.ps1 index 75d7e01..d7fab0c 100644 --- a/AzureAutomationRunbook/Tests/Pester.PublishRunbook.Tests.ps1 +++ b/Azure.Automation.Get/Tests/Pester.PublishRunbook.Tests.ps1 @@ -18,7 +18,7 @@ $Script:RunbookFolder = "$PSScriptRoot\TestRunbooks" $Script:TempSaveLocation = "$PSScriptRoot\TestSaveRepo" Install-NuGetBinaries -Import-Module AzureAutomationRunbook -Scope:Local -PassThru +Import-Module Azure.Automation.Get -Scope:Local -PassThru if(-not (Test-Path -Path $SourceLocation -PathType Container)) { diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.graphrunbook similarity index 100% rename from AzureAutomationRunbook/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.graphrunbook rename to Azure.Automation.Get/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.graphrunbook diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.graphrunbook similarity index 100% rename from AzureAutomationRunbook/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.graphrunbook rename to Azure.Automation.Get/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.graphrunbook diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.psd1 b/Azure.Automation.Get/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.psd1 similarity index 100% rename from AzureAutomationRunbook/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.psd1 rename to Azure.Automation.Get/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.psd1 diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/Hello-WorldGraphical.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/Hello-WorldGraphical.graphrunbook similarity index 100% rename from AzureAutomationRunbook/Tests/TestRunbooks/Hello-WorldGraphical.graphrunbook rename to Azure.Automation.Get/Tests/TestRunbooks/Hello-WorldGraphical.graphrunbook diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/Invalid-GraphicalRB/Invalid-GraphicalRB.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/Invalid-GraphicalRB/Invalid-GraphicalRB.graphrunbook similarity index 100% rename from AzureAutomationRunbook/Tests/TestRunbooks/Invalid-GraphicalRB/Invalid-GraphicalRB.graphrunbook rename to Azure.Automation.Get/Tests/TestRunbooks/Invalid-GraphicalRB/Invalid-GraphicalRB.graphrunbook diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.graphrunbook similarity index 100% rename from AzureAutomationRunbook/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.graphrunbook rename to Azure.Automation.Get/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.graphrunbook diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.psd1 b/Azure.Automation.Get/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.psd1 similarity index 75% rename from AzureAutomationRunbook/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.psd1 rename to Azure.Automation.Get/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.psd1 index 1d864be..72fc598 100644 --- a/AzureAutomationRunbook/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.psd1 +++ b/Azure.Automation.Get/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.psd1 @@ -1,9 +1,9 @@ # -# Module manifest for module 'PSGet_StartAzureRMVM' +# Module manifest for module 'NewManifest' # # Generated by: Yuting # -# Generated on: 7/21/2016 +# Generated on: 8/10/2016 # @{ @@ -14,6 +14,9 @@ # Version number of this module. ModuleVersion = '1.0' +# Supported PSEditions +# CompatiblePSEditions = @() + # ID used to uniquely identify this module GUID = '8777b74d-abdc-41f9-a9e1-23c72fb26adb' @@ -38,44 +41,44 @@ Description = 'Azure graph runbook test' # Minimum version of the Windows PowerShell host required by this module # PowerShellHostVersion = '' -# Minimum version of Microsoft .NET Framework required by this module +# Minimum version of Microsoft .NET Framework required by this module. This prerequisite is valid for the PowerShell Desktop edition only. # DotNetFrameworkVersion = '' -# Minimum version of the common language runtime (CLR) required by this module +# Minimum version of the common language runtime (CLR) required by this module. This prerequisite is valid for the PowerShell Desktop edition only. # CLRVersion = '' # Processor architecture (None, X86, Amd64) required by this module -# ProcessorArchitecture = '' +ProcessorArchitecture = 'None' # Modules that must be imported into the global environment prior to importing this module # RequiredModules = @() # Assemblies that must be loaded prior to importing this module -# RequiredAssemblies = @() +RequiredAssemblies = @() # Script files (.ps1) that are run in the caller's environment prior to importing this module. -# ScriptsToProcess = @() +ScriptsToProcess = @() # Type files (.ps1xml) to be loaded when importing this module -# TypesToProcess = @() +TypesToProcess = @() # Format files (.ps1xml) to be loaded when importing this module -# FormatsToProcess = @() +FormatsToProcess = @() # Modules to import as nested modules of the module specified in RootModule/ModuleToProcess # NestedModules = @() -# Functions to export from this module -# FunctionsToExport = @() +# Functions to export from this module, for best performance, do not use wildcards and do not delete the entry, use an empty array if there are no functions to export. +FunctionsToExport = @() -# Cmdlets to export from this module -# CmdletsToExport = @() +# Cmdlets to export from this module, for best performance, do not use wildcards and do not delete the entry, use an empty array if there are no cmdlets to export. +CmdletsToExport = @() # Variables to export from this module -# VariablesToExport = @() +VariablesToExport = @() -# Aliases to export from this module -# AliasesToExport = @() +# Aliases to export from this module, for best performance, do not use wildcards and do not delete the entry, use an empty array if there are no aliases to export. +AliasesToExport = @() # DSC resources to export from this module # DscResourcesToExport = @() diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.graphrunbook similarity index 100% rename from AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.graphrunbook rename to Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.graphrunbook diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.psd1 b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.psd1 similarity index 100% rename from AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.psd1 rename to Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.psd1 diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.graphrunbook similarity index 100% rename from AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.graphrunbook rename to Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.graphrunbook diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.psd1 b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.psd1 similarity index 100% rename from AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.psd1 rename to Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.psd1 diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.graphrunbook similarity index 100% rename from AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.graphrunbook rename to Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.graphrunbook diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.psd1 b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.psd1 similarity index 100% rename from AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.psd1 rename to Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.psd1 diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.graphrunbook similarity index 100% rename from AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.graphrunbook rename to Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.graphrunbook diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.psd1 b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.psd1 similarity index 100% rename from AzureAutomationRunbook/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.psd1 rename to Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.psd1 diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/TestInvalidRunbookFolder/TestInvalidRunbookFolder.txt b/Azure.Automation.Get/Tests/TestRunbooks/TestInvalidRunbookFolder/TestInvalidRunbookFolder.txt similarity index 100% rename from AzureAutomationRunbook/Tests/TestRunbooks/TestInvalidRunbookFolder/TestInvalidRunbookFolder.txt rename to Azure.Automation.Get/Tests/TestRunbooks/TestInvalidRunbookFolder/TestInvalidRunbookFolder.txt diff --git a/AzureAutomationRunbook/Tests/uiproxy.ps1 b/Azure.Automation.Get/Tests/uiproxy.ps1 similarity index 100% rename from AzureAutomationRunbook/Tests/uiproxy.ps1 rename to Azure.Automation.Get/Tests/uiproxy.ps1 diff --git a/AzureAutomationRunbook/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.psd1 b/AzureAutomationRunbook/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.psd1 deleted file mode 100644 index e17598e..0000000 --- a/AzureAutomationRunbook/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.psd1 +++ /dev/null @@ -1,124 +0,0 @@ -# -# Module manifest for module 'PSGet_AzureAutomationTutorial' -# -# Generated by: Yuting -# -# Generated on: 7/21/2016 -# - -@{ - -# Script module or binary module file associated with this manifest. -# RootModule = '' - -# Version number of this module. -ModuleVersion = '1.0' - -# ID used to uniquely identify this module -GUID = '64f88faf-e0cf-4e4a-80eb-2792a70389cc' - -# Author of this module -Author = 'Yuting' - -# Company or vendor of this module -CompanyName = 'Unknown' - -# Copyright statement for this module -Copyright = '(c) 2016 Yuting. All rights reserved.' - -# Description of the functionality provided by this module -Description = 'AzureAutomationTutorial test workflow' - -# Minimum version of the Windows PowerShell engine required by this module -# PowerShellVersion = '' - -# Name of the Windows PowerShell host required by this module -# PowerShellHostName = '' - -# Minimum version of the Windows PowerShell host required by this module -# PowerShellHostVersion = '' - -# Minimum version of Microsoft .NET Framework required by this module -# DotNetFrameworkVersion = '' - -# Minimum version of the common language runtime (CLR) required by this module -# CLRVersion = '' - -# Processor architecture (None, X86, Amd64) required by this module -# ProcessorArchitecture = '' - -# Modules that must be imported into the global environment prior to importing this module -# RequiredModules = @() - -# Assemblies that must be loaded prior to importing this module -# RequiredAssemblies = @() - -# Script files (.ps1) that are run in the caller's environment prior to importing this module. -# ScriptsToProcess = @() - -# Type files (.ps1xml) to be loaded when importing this module -# TypesToProcess = @() - -# Format files (.ps1xml) to be loaded when importing this module -# FormatsToProcess = @() - -# Modules to import as nested modules of the module specified in RootModule/ModuleToProcess -# NestedModules = @() - -# Functions to export from this module -# FunctionsToExport = @() - -# Cmdlets to export from this module -# CmdletsToExport = @() - -# Variables to export from this module -# VariablesToExport = @() - -# Aliases to export from this module -# AliasesToExport = @() - -# DSC resources to export from this module -# DscResourcesToExport = @() - -# List of all modules packaged with this module -# ModuleList = @() - -# List of all files packaged with this module -FileList = 'AzureAutomationTutorial.psd1', - 'AzureAutomationTutorial.graphrunbook' - -# Private data to pass to the module specified in RootModule/ModuleToProcess. This may also contain a PSData hashtable with additional module metadata used by PowerShell. -PrivateData = @{ - - PSData = @{ - - # Tags applied to this module. These help with module discovery in online galleries. - Tags = 'AzureAutomation','Runbook','GraphicalPSWFRunbook','Workflow' - - # A URL to the license for this module. - # LicenseUri = '' - - # A URL to the main website for this project. - # ProjectUri = '' - - # A URL to an icon representing this module. - # IconUri = '' - - # ReleaseNotes of this module - # ReleaseNotes = '' - - # External dependent modules of this module - # ExternalModuleDependencies = '' - - } # End of PSData hashtable - - } # End of PrivateData hashtable - -# HelpInfo URI of this module -# HelpInfoURI = '' - -# Default prefix for commands exported from this module. Override the default prefix using Import-Module -Prefix. -# DefaultCommandPrefix = '' - -} - diff --git a/cAzureStorage/SampleAzureStorageConfig.ps1 b/cAzureStorage/SampleAzureStorageConfig.ps1 index ef95c8b..4d31f45 100644 --- a/cAzureStorage/SampleAzureStorageConfig.ps1 +++ b/cAzureStorage/SampleAzureStorageConfig.ps1 @@ -1,86 +1,86 @@ -<# -.SYNOPSIS - Downloads a specific blob in an Azure Storage container or all blobs in the container to a local directory - -.DESCRIPTION - Downloads a specific blob in an Azure Storage container or all blobs in the container to a local directory. - If the Blob property is not set, then all of the blobs in the container are downloaded to the local directory. - You can use the Blob property to get just a single file or everything under a directory in the container. - - If the local file does not match the file in the Azure Storage container, then it will be downloaded, otherwise it will not download the file. - -.PARAMETER NodeName - Array of nodes for this configuration. Defaults to localhost if none are passed in. - -.PARAMETER StorageAccountName - The name of the storage account - -.PARAMETER StorageAccountKey - The storgage account key for this storage account. You can run Get-AzureRmStorageAccountKey to get the key for the storage account. - -.PARAMETER StorageAccountContainer - The name of the storage account container - -.PARAMETER Blob - The specific blob or directory in the container to download. All contents in the container are download if this property is not included. Optional Parameter. - -.EXAMPLE - SampleAzureStorageStorageConfig -Path "c:\localdirectory" -Blob "StorageDir/BlobFile" -StorageAccountName "yourstorageaccount" -StorageAccountContainer "yourstoragecontainer" -StorageAccountKey "aaabbbcco+CByOCS5/8abc6MkZEjaddddjU8APAoO4pyNXw+6U5nGJcddKKOWm8SvPvARQ==" - - Start-DscConfiguration -Path .\SampleAzureStorageStorageConfig -Wait -Force -Verbose - -.EXAMPLE - SampleAzureStorageStorageConfig -Path "c:\localdirectory" -StorageAccountName "yourstorageaccount" -StorageAccountContainer "yourstoragecontainer" -StorageAccountKey "aaabbbcco+CByOCS5/8abc6MkZEjaddddjU8APAoO4pyNXw+6U5nGJcddKKOWm8SvPvARQ==" - - Start-DscConfiguration -Path .\SampleAzureStorageStorageConfig -Wait -Force -Verbose - - -.NOTES - AUTHOR: Eamon O'Reilly - LASTEDIT: March 18th, 2016 -#> - -Configuration SampleAzureStorageStorageConfig { - param ( - [string[]]$NodeName = 'localhost', - [parameter(Mandatory = $true)] - [System.String] - $Path, - - [parameter(Mandatory = $true)] - [System.String] - $StorageAccountName, - - [parameter(Mandatory = $true)] - [System.String] - $StorageAccountKey, - - [parameter(Mandatory = $true)] - [System.String] - $StorageAccountContainer, - - [parameter(Mandatory = $false)] - [System.String] - $Blob = $null - - ) - - Import-DscResource -Module cAzureStorage -ModuleVersion 1.0.0.1 - - Node $NodeName { - - cAzureStorage SampleConfig { - Path = $Path - StorageAccountName = $StorageAccountName - StorageAccountContainer = $StorageAccountContainer - StorageAccountKey = $StorageAccountKey - Blob = $Blob - } - - } -} -SampleAzureStorageStorageConfig -Path "c:\localdirectory" -Blob "StorageDir/BlobFile" -StorageAccountName "yourstorageaccount" ` - -StorageAccountContainer "yourstoragecontainer" ` - -StorageAccountKey "aaabbbcco+CByOCS5/8abc6MkZEjaddddjU8APAoO4pyNXw+6U5nGJcddKKOWm8SvPvARQ==" - -Start-DscConfiguration -Path .\SampleAzureStorageStorageConfig -Wait -Force -Verbose +<# +.SYNOPSIS + Downloads a specific blob in an Azure Storage container or all blobs in the container to a local directory + +.DESCRIPTION + Downloads a specific blob in an Azure Storage container or all blobs in the container to a local directory. + If the Blob property is not set, then all of the blobs in the container are downloaded to the local directory. + You can use the Blob property to get just a single file or everything under a directory in the container. + + If the local file does not match the file in the Azure Storage container, then it will be downloaded, otherwise it will not download the file. + +.PARAMETER NodeName + Array of nodes for this configuration. Defaults to localhost if none are passed in. + +.PARAMETER StorageAccountName + The name of the storage account + +.PARAMETER StorageAccountKey + The storgage account key for this storage account. You can run Get-AzureRmStorageAccountKey to get the key for the storage account. + +.PARAMETER StorageAccountContainer + The name of the storage account container + +.PARAMETER Blob + The specific blob or directory in the container to download. All contents in the container are download if this property is not included. Optional Parameter. + +.EXAMPLE + SampleAzureStorageStorageConfig -Path "c:\localdirectory" -Blob "StorageDir/BlobFile" -StorageAccountName "yourstorageaccount" -StorageAccountContainer "yourstoragecontainer" -StorageAccountKey "aaabbbcco+CByOCS5/8abc6MkZEjaddddjU8APAoO4pyNXw+6U5nGJcddKKOWm8SvPvARQ==" + + Start-DscConfiguration -Path .\SampleAzureStorageStorageConfig -Wait -Force -Verbose + +.EXAMPLE + SampleAzureStorageStorageConfig -Path "c:\localdirectory" -StorageAccountName "yourstorageaccount" -StorageAccountContainer "yourstoragecontainer" -StorageAccountKey "aaabbbcco+CByOCS5/8abc6MkZEjaddddjU8APAoO4pyNXw+6U5nGJcddKKOWm8SvPvARQ==" + + Start-DscConfiguration -Path .\SampleAzureStorageStorageConfig -Wait -Force -Verbose + + +.NOTES + AUTHOR: Eamon O'Reilly + LASTEDIT: March 18th, 2016 +#> + +Configuration SampleAzureStorageStorageConfig { + param ( + [string[]]$NodeName = 'localhost', + [parameter(Mandatory = $true)] + [System.String] + $Path, + + [parameter(Mandatory = $true)] + [System.String] + $StorageAccountName, + + [parameter(Mandatory = $true)] + [System.String] + $StorageAccountKey, + + [parameter(Mandatory = $true)] + [System.String] + $StorageAccountContainer, + + [parameter(Mandatory = $false)] + [System.String] + $Blob = $null + + ) + + Import-DscResource -Module cAzureStorage -ModuleVersion 1.0.0.1 + + Node $NodeName { + + cAzureStorage SampleConfig { + Path = $Path + StorageAccountName = $StorageAccountName + StorageAccountContainer = $StorageAccountContainer + StorageAccountKey = $StorageAccountKey + Blob = $Blob + } + + } +} +SampleAzureStorageStorageConfig -Path "c:\localdirectory" -Blob "StorageDir/BlobFile" -StorageAccountName "yourstorageaccount" ` + -StorageAccountContainer "yourstoragecontainer" ` + -StorageAccountKey "aaabbbcco+CByOCS5/8abc6MkZEjaddddjU8APAoO4pyNXw+6U5nGJcddKKOWm8SvPvARQ==" + +Start-DscConfiguration -Path .\SampleAzureStorageStorageConfig -Wait -Force -Verbose