diff --git a/Azure.Automation.Get/Azure.Automation.Get.Resource.psd1 b/Azure.Automation.Get/Azure.Automation.Get.Resource.psd1 new file mode 100644 index 0000000..8217179 Binary files /dev/null and b/Azure.Automation.Get/Azure.Automation.Get.Resource.psd1 differ diff --git a/Azure.Automation.Get/Azure.Automation.Get.psd1 b/Azure.Automation.Get/Azure.Automation.Get.psd1 new file mode 100644 index 0000000..e64c334 Binary files /dev/null and b/Azure.Automation.Get/Azure.Automation.Get.psd1 differ diff --git a/Azure.Automation.Get/Azure.Automation.Get.psm1 b/Azure.Automation.Get/Azure.Automation.Get.psm1 new file mode 100644 index 0000000..b251d88 --- /dev/null +++ b/Azure.Automation.Get/Azure.Automation.Get.psm1 @@ -0,0 +1,904 @@ + +######################################################################################### +# +# Copyright (c) Microsoft Corporation. All rights reserved. +# +# AzureGraphRunbook Module +# +######################################################################################### + +Microsoft.PowerShell.Core\Set-StrictMode -Version Latest + +Microsoft.PowerShell.Utility\Import-LocalizedData LocalizedData -filename Azure.Automation.Get.Resource.psd1 +$script:TempPath = ([System.IO.DirectoryInfo]$env:TEMP).FullName + +#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; 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. + - 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 + } + + $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(Microsoft.PowerShell.Management\Test-Path $Path) + { + $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 + } + else + { + $message = $LocalizedData.PathNotFound -f ($Path) + ThrowError -ExceptionName 'System.ArgumentException' ` + -ExceptionMessage $message ` + -ErrorId 'GraphRunbookPathNotFound' ` + -CallerPSCmdlet $CallerPSCmdlet ` + -ErrorCategory InvalidArgument ` + -ExceptionObject $Path + return + } + } + else + { + $GraphRunbookBase = Validate-AzureGraphRunbookFolder -Path $Path -CallerPSCmdlet $PSCmdlet + + if($GraphRunbookBase) + { + if($Repository) + { + $null = $PSBoundParameters.Remove('Repository') + } + + if($NuGetApiKey) + { + $null = $PSBoundParameters.Remove('NuGetApiKey') + } + + $GraphRunbookName = Microsoft.PowerShell.Management\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 + + $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 + } + 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) + { + 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 + } + } +} + +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 + # 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 + } + } +} + +#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 = Split-Path $Path -Parent + $ModuleFullName = Split-Path $Path -Leaf + $GraphRunbookName = [System.IO.Path]::GetFileNameWithoutExtension($ModuleFullName) + + $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 = Split-Path $Path -Parent + $ModuleFullName = Split-Path $Path -Leaf + $GraphRunbookName = [System.IO.Path]::GetFileNameWithoutExtension($ModuleFullName) + + $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/Azure.Automation.Get/Orchestrator.GraphRunbook.Model.dll b/Azure.Automation.Get/Orchestrator.GraphRunbook.Model.dll new file mode 100644 index 0000000..12c350e Binary files /dev/null and b/Azure.Automation.Get/Orchestrator.GraphRunbook.Model.dll differ diff --git a/Azure.Automation.Get/Tests/PSGetTestUtils.psm1 b/Azure.Automation.Get/Tests/PSGetTestUtils.psm1 new file mode 100644 index 0000000..6083127 --- /dev/null +++ b/Azure.Automation.Get/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/Azure.Automation.Get/Tests/Pester.PublishRunbook.Tests.ps1 b/Azure.Automation.Get/Tests/Pester.PublishRunbook.Tests.ps1 new file mode 100644 index 0000000..d7fab0c --- /dev/null +++ b/Azure.Automation.Get/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 Azure.Automation.Get -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/Azure.Automation.Get/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/AzureAutomationTutorial/AzureAutomationTutorial.graphrunbook new file mode 100644 index 0000000..32ff3cd --- /dev/null +++ b/Azure.Automation.Get/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/Azure.Automation.Get/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.graphrunbook new file mode 100644 index 0000000..4d60fb8 --- /dev/null +++ b/Azure.Automation.Get/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/Azure.Automation.Get/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.psd1 b/Azure.Automation.Get/Tests/TestRunbooks/Find-EmptyResourceGroups/Find-EmptyResourceGroups.psd1 new file mode 100644 index 0000000..219a88a --- /dev/null +++ b/Azure.Automation.Get/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/Azure.Automation.Get/Tests/TestRunbooks/Hello-WorldGraphical.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/Hello-WorldGraphical.graphrunbook new file mode 100644 index 0000000..fe2f6c0 --- /dev/null +++ b/Azure.Automation.Get/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/Azure.Automation.Get/Tests/TestRunbooks/Invalid-GraphicalRB/Invalid-GraphicalRB.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/Invalid-GraphicalRB/Invalid-GraphicalRB.graphrunbook new file mode 100644 index 0000000..9bdda11 --- /dev/null +++ b/Azure.Automation.Get/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/Azure.Automation.Get/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.graphrunbook new file mode 100644 index 0000000..bbe0c6c --- /dev/null +++ b/Azure.Automation.Get/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/Azure.Automation.Get/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.psd1 b/Azure.Automation.Get/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.psd1 new file mode 100644 index 0000000..72fc598 --- /dev/null +++ b/Azure.Automation.Get/Tests/TestRunbooks/StartAzureRMVM/StartAzureRMVM.psd1 @@ -0,0 +1,126 @@ +# +# Module manifest for module 'NewManifest' +# +# Generated by: Yuting +# +# Generated on: 8/10/2016 +# + +@{ + +# Script module or binary module file associated with this manifest. +# RootModule = '' + +# Version number of this module. +ModuleVersion = '1.0' + +# Supported PSEditions +# CompatiblePSEditions = @() + +# 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. This prerequisite is valid for the PowerShell Desktop edition only. +# DotNetFrameworkVersion = '' + +# 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 = '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 = @() + +# 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, 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, 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 = @() + +# 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 = @() + +# 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/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.graphrunbook new file mode 100644 index 0000000..7410105 --- /dev/null +++ b/Azure.Automation.Get/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/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.psd1 b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.0/StopAzureRMVM.psd1 new file mode 100644 index 0000000..21721d5 --- /dev/null +++ b/Azure.Automation.Get/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/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.graphrunbook new file mode 100644 index 0000000..7410105 --- /dev/null +++ b/Azure.Automation.Get/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/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.psd1 b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.1/StopAzureRMVM.psd1 new file mode 100644 index 0000000..5df5969 --- /dev/null +++ b/Azure.Automation.Get/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/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.graphrunbook new file mode 100644 index 0000000..7410105 --- /dev/null +++ b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.graphrunbook @@ -0,0 +1 @@ +{"SchemaVersion":"1.2","RunbookDefinition":"AAEAAAD/////AQAAAAAAAAAMAgAAAFZPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLCBWZXJzaW9uPTcuMi4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbAUBAAAALE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuR3JhcGhSdW5ib29rAwAAAApwYXJhbWV0ZXJzCmFjdGl2aXRpZXMFbGlua3MDAwOmAVN5c3RlbS5Db2xsZWN0aW9ucy5HZW5lcmljLkxpc3RgMVtbT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5QYXJhbWV0ZXIsIE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwsIFZlcnNpb249Ny4yLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1udWxsXV2lAVN5c3RlbS5Db2xsZWN0aW9ucy5HZW5lcmljLkxpc3RgMVtbT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5BY3Rpdml0eSwgT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbCwgVmVyc2lvbj03LjIuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPW51bGxdXaEBU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuTGlzdGAxW1tPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkxpbmssIE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwsIFZlcnNpb249Ny4yLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1udWxsXV0CAAAACQMAAAAJBAAAAAkFAAAABAMAAACmAVN5c3RlbS5Db2xsZWN0aW9ucy5HZW5lcmljLkxpc3RgMVtbT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5QYXJhbWV0ZXIsIE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwsIFZlcnNpb249Ny4yLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1udWxsXV0DAAAABl9pdGVtcwVfc2l6ZQhfdmVyc2lvbgQAACtPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLlBhcmFtZXRlcltdAgAAAAgICQYAAAAEAAAABAAAAAQEAAAApQFTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5MaXN0YDFbW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuQWN0aXZpdHksIE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwsIFZlcnNpb249Ny4yLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1udWxsXV0DAAAABl9pdGVtcwVfc2l6ZQhfdmVyc2lvbgQAACpPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkFjdGl2aXR5W10CAAAACAgJBwAAAA4AAAAOAAAABAUAAAChAVN5c3RlbS5Db2xsZWN0aW9ucy5HZW5lcmljLkxpc3RgMVtbT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5MaW5rLCBPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLCBWZXJzaW9uPTcuMi4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbF1dAwAAAAZfaXRlbXMFX3NpemUIX3ZlcnNpb24EAAAmT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5MaW5rW10CAAAACAgJCAAAAA4AAAAOAAAABwYAAAAAAQAAAAQAAAAEKU9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyAgAAAAkJAAAACQoAAAAJCwAAAAkMAAAABwcAAAAAAQAAABAAAAAEKE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuQWN0aXZpdHkCAAAACQ0AAAAJDgAAAAkPAAAACRAAAAAJEQAAAAkSAAAACRMAAAAJFAAAAAkVAAAACRYAAAAJFwAAAAkYAAAACRkAAAAJGgAAAA0CBwgAAAAAAQAAABAAAAAEJE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuTGluawIAAAAJGwAAAAkcAAAACR0AAAAJHgAAAAkfAAAACSAAAAAJIQAAAAkiAAAACSMAAAAJJAAAAAklAAAACSYAAAAJJwAAAAkoAAAADQIFCQAAAClPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLlBhcmFtZXRlcgUAAAAdPERlZmF1bHRWYWx1ZT5rX19CYWNraW5nRmllbGQVPE5hbWU+a19fQmFja2luZ0ZpZWxkGTxPcHRpb25hbD5rX19CYWNraW5nRmllbGQZPFR5cGVOYW1lPmtfX0JhY2tpbmdGaWVsZBw8RGVzY3JpcHRpb24+a19fQmFja2luZ0ZpZWxkAgQAAQE8T3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5FeGVjdXRhYmxlVmlldy5QYXJhbWV0ZXJOYW1lAgAAAAECAAAACgkpAAAAAQYqAAAADVN5c3RlbS5TdHJpbmcKAQoAAAAJAAAABisAAAATQXp1cmVTdWJzY3JpcHRpb25JZAksAAAAAQYtAAAADVN5c3RlbS5TdHJpbmcKAQsAAAAJAAAABi4AAAAPQXp1cmVDcmVkZW50aWFsCS8AAAABBjAAAAANU3lzdGVtLlN0cmluZwoBDAAAAAkAAAAKCTEAAAABBjIAAAANU3lzdGVtLlN0cmluZwoFDQAAAC9PcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkNvbW1hbmRBY3Rpdml0eQwAAAAcPENvbW1hbmRUeXBlPmtfX0JhY2tpbmdGaWVsZDRJbnZvY2F0aW9uQWN0aXZpdHkrPFBhcmFtZXRlclNldE5hbWU+a19fQmFja2luZ0ZpZWxkLkludm9jYXRpb25BY3Rpdml0eSs8UGFyYW1ldGVycz5rX19CYWNraW5nRmllbGQ0SW52b2NhdGlvbkFjdGl2aXR5KzxDdXN0b21QYXJhbWV0ZXJzPmtfX0JhY2tpbmdGaWVsZDNJbnZvY2F0aW9uQWN0aXZpdHkrPENoZWNrcG9pbnRBZnRlcj5rX19CYWNraW5nRmllbGQiTG9vcGFibGVBY3Rpdml0eStsb29wRXhpdENvbmRpdGlvbitMb29wYWJsZUFjdGl2aXR5KzxMb29wRGVsYXk+a19fQmFja2luZ0ZpZWxkHkFjdGl2aXR5KzxOYW1lPmtfX0JhY2tpbmdGaWVsZCJBY3Rpdml0eSs8RW50aXR5SWQ+a19fQmFja2luZ0ZpZWxkI0FjdGl2aXR5KzxQb3NpdGlvblg+a19fQmFja2luZ0ZpZWxkI0FjdGl2aXR5KzxQb3NpdGlvblk+a19fQmFja2luZ0ZpZWxkJUFjdGl2aXR5KzxEZXNjcmlwdGlvbj5rX19CYWNraW5nRmllbGQEAQMBAAQEBAEAAAEzT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5Db21tYW5kQWN0aXZpdHlUeXBlAgAAANkCU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuRGljdGlvbmFyeWAyW1tPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkV4ZWN1dGFibGVWaWV3LlBhcmFtZXRlck5hbWUsIE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwsIFZlcnNpb249Ny4yLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1udWxsXSxbT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5FeGVjdXRhYmxlVmlldy5JVmFsdWVEZXNjcmlwdG9yLCBPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLCBWZXJzaW9uPTcuMi4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbF1dASlPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkNvbmRpdGlvbgIAAAA3T3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5Db25zdGFudFZhbHVlRGVzY3JpcHRvcgIAAAA7T3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5FeGVjdXRhYmxlVmlldy5BY3Rpdml0eU5hbWUCAAAACAgCAAAACTMAAAAGNAAAABJfX0FsbFBhcmFtZXRlclNldHMJNQAAAAY2AAAAAAAJNwAAAAk4AAAACTkAAAAGOgAAACQ3RTAxRTI2MC1CODI0LTRGNzAtOTBGMy0zNEUyQzZENjJGRDKUAgAA6gEAAAY7AAAAL091dHB1dCBhIG5vdGljZSB0aGF0IHRoZSBWTSBpcyBhbHJlYWR5IHN0b3BwZWQuAQ4AAAANAAAACTwAAAAGPQAAABJfX0FsbFBhcmFtZXRlclNldHMJPgAAAAk2AAAAAAlAAAAACUEAAAAJQgAAAAZDAAAAJDYxOTk3QzJBLTQ0NDktNDk2OS04QjczLTZCN0FBMkZDQUY3NzYBAABYAgAABkQAAAAoT3V0cHV0IGEgbm90aWNlIHRoYXQgdGhlIFZNIHdhcyBzdG9wcGVkLgEPAAAADQAAAAlFAAAABkYAAAASX19BbGxQYXJhbWV0ZXJTZXRzCUcAAAAJNgAAAAAJSQAAAAlKAAAACUsAAAAGTAAAACQ4NjZFMEU0OC00QjY2LTQ3NUItOUEzQS1BM0YwOUIxMTBCMTT0AQAAWAIAAAZNAAAAKU91dHB1dCBhIG5vdGljZSB0aGF0IHRoZSBWTSBkaWQgbm90IHN0b3AuARAAAAANAAAACU4AAAAGTwAAABJfX0FsbFBhcmFtZXRlclNldHMJUAAAAAk2AAAAAAlSAAAACVMAAAAJVAAAAAZVAAAAJDEyOUJCQkFBLUQxQ0MtNEM5RC1BOEVFLUIwQ0UwNzlFQUM3NRICAADSAAAABlYAAACXAVRoaXMgYWN0aXZpdHkgd2lsbCBtZXJnZSB0aGUgb3V0cHV0IG9mIHRoZSBpbmNvbWluZyBsaW5rZWQgYWN0aXZpdGllcy4gIEl0IGFsbG93cyB0aGUgZG93bnN0cmVhbSBhY3Rpdml0aWVzIHRvIHJlZmVyIHRvIHRoaXMgc2luZ2xlIGFjdGl2aXR5IGZvciBpbnB1dC4BEQAAAA0AAAAJVwAAAAZYAAAAB0RlZmF1bHQJWQAAAAk2AAAAAAlbAAAACVwAAAAJXQAAAAZeAAAAJEJCRDYyNzhBLUEyNkQtNDc3RC04QjhDLTk4MkIxRUFDOUJFRBICAABq////Bl8AAABzR2V0IHRoZSBBenVyZSBzdWJzY3JpcHRpb24gaWQgZnJvbSB0aGUgQXV0b21hdGlvbiB2YXJpYWJsZSBhc3NldCB3aG9zZSBuYW1lIGlzIHBhc3NlZCBpbiBhIHJ1bmJvb2sgaW5wdXQgcGFyYW1ldGVyLgESAAAADQAAAAlgAAAABmEAAAAHRGVmYXVsdAliAAAACTYAAAAACWQAAAAJZQAAAAlmAAAABmcAAAAkNzJEN0Y3MjktOEY2My00QkJELTlGQUMtNUM2NDZBODA1NTYwEgIAALr///8GaAAAAHhHZXQgdGhlIEF6dXJlIEFEIHVzZXIgY3JlZGVudGlhbCBmcm9tIHRoZSBBdXRvbWF0aW9uIGNyZWRlbnRpYWwgYXNzZXQgd2hvc2UgbmFtZSBpcyBwYXNzZWQgaW4gYSBydW5ib29rIGlucHV0IHBhcmFtZXRlci4BEwAAAA0AAAAJaQAAAAZqAAAADlN1YnNjcmlwdGlvbklkCWsAAAAJNgAAAAAJbQAAAAluAAAACW8AAAAGcAAAACRFREMzMUVBRi04QjBCLTQyRDctQTNFQi1BRjdGQ0E5NjMxMDUSAgAACgAAAAZxAAAAVkNvbm5lY3Qgd2l0aCBBenVyZS4gIFJlcXVpcmVzIGFuIEF1dG9tYXRpb24gY3JlZGVudGlhbCBhc3NldCB3aXRoIEF6dXJlIEFEIHVzZXIgY3JlZHMuARQAAAANAAAACXIAAAAGcwAAAClMaXN0VmlydHVhbE1hY2hpbmVJblJlc291cmNlR3JvdXBQYXJhbVNldAl0AAAACTYAAAAACXYAAAAJdwAAAAl4AAAABnkAAAAkMkM4QzFFMDQtNDY5QS00QkI5LUFFNTQtMDVDN0Q0NUZGRDdGEgIAAG4AAAAGegAAACxHZXQgYWxsIEF6dXJlIFJNIFZNcyBmb3IgdGhlIHJlc291cmNlIGdyb3VwLgEVAAAADQAAAAl7AAAABnwAAAAoR2V0VmlydHVhbE1hY2hpbmVJblJlc291cmNlR3JvdXBQYXJhbVNldAl9AAAACTYAAAAACX8AAAAJgAAAAAmBAAAABoIAAAAkMTJCMzQyREYtQkRFQi00QkNELTlGRDMtRkVGRjMyOUNGRURGXgEAAG4AAAAGgwAAAC9HZXQgYSBwYXJ0aWN1bGFyIFZNIGJ5IG5hbWUgYW5kIHJlc291cmNlIGdyb3VwLgEWAAAADQAAAAmEAAAACTYAAAAJhgAAAAk2AAAAAAmIAAAACYkAAAAJigAAAAaLAAAAJDFCMUNERjY4LUUzMTgtNDhDNS04NkE4LUMzOTcxMjU3QkY5Q8YCAABuAAAABowAAAAtR2V0IGFsbCB0aGUgQXp1cmUgUk0gVk1zIGluIHRoZSBzdWJzY3JpcHRpb24uARcAAAANAAAACY0AAAAGjgAAAChHZXRWaXJ0dWFsTWFjaGluZUluUmVzb3VyY2VHcm91cFBhcmFtU2V0CY8AAAAJNgAAAAAJkQAAAAmSAAAACZMAAAAGlAAAACQzNUIyMTUwRi0yRjc1LTQyMTgtOUU0Mi0yMzBFRENCOTMxREESAgAAIgEAAAaVAAAAggFHZXQgdGhlIFZNIG9iamVjdCBhZ2FpbiBidXQgdGhpcyB0aW1lIHdpdGggc3RhdHVzIGluZm9ybWF0aW9uLiAgR2V0dGluZyB0aGUgc3RhdHVzIGluZm8gaXMgcG9zc2libGUgb25seSB3aGVuIGdldHRpbmcgYSBzaW5nbGUgVk0uARgAAAANAAAACZYAAAAGlwAAACFSZXNvdXJjZUdyb3VwTmFtZVBhcmFtZXRlclNldE5hbWUJmAAAAAk2AAAAAAmaAAAACZsAAAAJnAAAAAadAAAAJDZBM0VGMEI5LTk2RUMtNDFDRi04QzQyLTMwQjYyRDMzRUNGNJABAADqAQAACTYAAAAFGQAAADZPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLldvcmtmbG93U2NyaXB0QWN0aXZpdHkLAAAAFjxCZWdpbj5rX19CYWNraW5nRmllbGQYPFByb2Nlc3M+a19fQmFja2luZ0ZpZWxkFDxFbmQ+a19fQmFja2luZ0ZpZWxkIDxDaGVja3BvaW50QWZ0ZXI+a19fQmFja2luZ0ZpZWxkIkxvb3BhYmxlQWN0aXZpdHkrbG9vcEV4aXRDb25kaXRpb24rTG9vcGFibGVBY3Rpdml0eSs8TG9vcERlbGF5PmtfX0JhY2tpbmdGaWVsZB5BY3Rpdml0eSs8TmFtZT5rX19CYWNraW5nRmllbGQiQWN0aXZpdHkrPEVudGl0eUlkPmtfX0JhY2tpbmdGaWVsZCNBY3Rpdml0eSs8UG9zaXRpb25YPmtfX0JhY2tpbmdGaWVsZCNBY3Rpdml0eSs8UG9zaXRpb25ZPmtfX0JhY2tpbmdGaWVsZCVBY3Rpdml0eSs8RGVzY3JpcHRpb24+a19fQmFja2luZ0ZpZWxkAQEBAAQEBAEAAAEBKU9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuQ29uZGl0aW9uAgAAADdPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkNvbnN0YW50VmFsdWVEZXNjcmlwdG9yAgAAADtPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkV4ZWN1dGFibGVWaWV3LkFjdGl2aXR5TmFtZQIAAAAICAIAAAAJNgAAAAafAAAAoQ48IwpUaGlzIHJ1bmJvb2sgY29ubmVjdHMgdG8gQXp1cmUgYW5kIHN0b3BzIGFsbCBBUk0gVk1zIGluIGFuIEF6dXJlIHN1YnNjcmlwdGlvbiBvciByZXNvdXJjZSBncm91cCBvciBhIHNpbmdsZSBuYW1lZCBWTS4KWW91IGNhbiBhdHRhY2ggYSByZWN1cnJpbmcgc2NoZWR1bGUgdG8gdGhpcyBydW5ib29rIHRvIHJ1biBpdCBhdCBhIHNwZWNpZmljIHRpbWUuIAoKUkVRVUlSRUQKMS4gQW4gQXV0b21hdGlvbiB2YXJpYWJsZSBhc3NldCBjYWxsZWQgQXp1cmVTdWJzY3JpcHRpb25JZCB0aGF0IGNvbnRhaW5zIHRoZSBHVUlEIGZvciB0aGlzIEF6dXJlIHN1YnNjcmlwdGlvbi4gIFRvIHVzZSBhbiBhc3NldCB3aXRoIGEgZGlmZmVyZW50IG5hbWUgeW91IGNhbiBwYXNzIHRoZSBhc3NldCBuYW1lIGFzIGEgcnVuYm9vayBpbnB1dCBwYXJhbWV0ZXIgb3IgY2hhbmdlIHRoZSBkZWZhdWx0IHZhbHVlIGZvciB0aGUgaW5wdXQgcGFyYW1ldGVyLgoyLiBBbiBBdXRvbWF0aW9uIGNyZWRlbnRpYWwgYXNzZXQgY2FsbGVkIEF6dXJlQ3JlZGVudGlhbCB0aGF0IGNvbnRhaW5zIHRoZSBBenVyZSBBRCB1c2VyIGNyZWRlbnRpYWwgd2l0aCBhdXRob3JpemF0aW9uIGZvciB0aGlzIHN1YnNjcmlwdGlvbi4gVG8gdXNlIGFuIGFzc2V0IHdpdGggYSBkaWZmZXJlbnQgbmFtZSB5b3UgY2FuIHBhc3MgdGhlIGFzc2V0IG5hbWUgYXMgYSBydW5ib29rIGlucHV0IHBhcmFtZXRlciBvciBjaGFuZ2UgdGhlIGRlZmF1bHQgdmFsdWUgZm9yIHRoZSBpbnB1dCBwYXJhbWV0ZXIuCgpPUFRJT05BTAozLiBBIFJlc291cmNlR3JvdXBOYW1lIGlucHV0IHBhcmFtZXRlciB2YWx1ZSB0aGF0IGFsbG93cyBzY29waW5nIHRoZSBWTXMgdG8gYSBwYXJ0aWN1bGFyIHJlc291cmNlIGdyb3VwLgo0LiBBIFZNTmFtZSBpbnB1dCBwYXJhbWV0ZXIgdGhhdCBhbGxvd3Mgc3BlY2lmaWNhdGlvbiBvZiBhIHNpbmdsZSBWTS4KCk5PVEVTCgotIExpbmsgQ29uZGl0aW9ucyB0byBkZXRlcm1pbmUgaG93IHRvIGdldCB0aGUgVk1zIC0KRm9sbG93aW5nIHRoZSAnQ29ubmVjdCB0byBBenVyZScgYWN0aXZpdHkgdGhlcmUgYXJlIHRocmVlIHNlcXVlbmNlIGxpbmtzIHRoYXQgaGF2ZSBjb25kaXRpb25zIHNldC4gIFRoZXNlIGNvbmRpdGlvbnMgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSBhbmQgd2lsbCBkaXJlY3QgdGhlIHdvcmtmbG93IHRvIG9ubHkgb25lIG9mIHRoZSBjb25uZWN0ZWQgYWN0aXZpdGllcyB0byBnZXQgVk1zLgoKLSBNZXJnZSBWTXMgYWN0aXZpdHkgLQpUaGUgJ01lcmdlIFZNcycgYWN0aXZpdHkgaXMgdXNlZCB0byBtZXJnZSB0aGUgb3V0cHV0IG9mIHRoZSBpbW1lZGlhdGVseSBwcmVjZWRpbmcgYWN0aXZpdGllcy4gIEJ5IG1lcmdpbmcgdGhlIG91dHB1dCBpbnRvIGEgc2luZ2xlIGFjdGl2aXR5LCB3aGljaCB0aGVuIHJlLW91dHB1dHMgdGhlIG9iamVjdHMsIHRoZSBkb3duc3RyZWFtIGFjdGl2aXRpZXMsIGxpa2UgJ1N0b3AgVk0nICBhcmUgYWJsZSB0byByZWZlciB0byBhIHNpbmdsZSBhY3Rpdml0eSBmb3IgaW5wdXQgZGF0YS4gIEF0IGRlc2lnbiB0aW1lLCB3ZSBkb24ndCBrbm93IHdoaWNoIG9mIHRoZSBpbW1lZGlhdGVseSBwcmVjZWRpbmcgYWN0aXZpdGllcyB3aWxsIHJ1biwgc28gJ1N0b3AgVk0nIGRvZXNuJ3Qga25vdyB3aGljaCBhY3Rpdml0eSB0byByZWZlciB0byBmb3IgaW5wdXQgZGF0YS4gIEJ5IGNyZWF0aW5nICdNZXJnZSBWTXMnLCAnU3RvcCBWTScgaGFzIGEgc2luZ2xlIGFjdGl2aXR5IHRvIHJlZmVyIHRvIGZvciBpbnB1dC4KCkFVVEhPUgpTeXN0ZW0gQ2VudGVyIEF1dG9tYXRpb24gVGVhbSAKCkxBU1RFRElUCjIwMTYtMS0xCiM+CTYAAAAACaEAAAAJogAAAAmjAAAABqQAAAAkRjM0QTY3RUQtNTJBNi00MDA4LTk1ODgtNEYyOTMyQjVBOURD2gIAAGr///8GpQAAAFZWaWV3IHRoZSBXb3JrZmxvdyBTY3JpcHQgZm9yIGluZm9ybWF0aW9uIGFib3V0IHRoaXMgcnVuYm9vayBpbmNsdWRpbmcgUkVRVUlSRUQgYXNzZXRzLgEaAAAAGQAAAAk2AAAABqcAAADGAiRTdGF0dXNlc0pzb24gPSAkQWN0aXZpdHlPdXRwdXRbJ0dldCBWTSB3aXRoIFN0YXR1cyddLlN0YXR1c2VzVGV4dAokU3RhdHVzZXMgPSBDb252ZXJ0RnJvbS1Kc29uICRTdGF0dXNlc0pzb24KJFN0YXR1c091dCA9ICIiCmZvcmVhY2ggKCRTdGF0dXMgaW4gJFN0YXR1c2VzKSB7CiAgICBpZiAoJFN0YXR1cy5Db2RlICAtZXEgIlBvd2Vyc3RhdGUvcnVubmluZyIpIHskU3RhdHVzT3V0ID0gInJ1bm5pbmcifQogICAgZWxzZWlmICgkU3RhdHVzLkNvZGUgIC1lcSAiUG93ZXJzdGF0ZS9kZWFsbG9jYXRlZCIpIHskU3RhdHVzT3V0ID0gInN0b3BwZWQifSAKfQokU3RhdHVzT3V0CTYAAAAACakAAAAJqgAAAAmrAAAABqwAAAAkMTZEOEM5N0UtMTJBQS00MTM2LUIwNTgtQzRFMEZCMzQ4QjM1EgIAAHwBAAAJNgAAAAUbAAAAJE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuTGluawUAAAAJY29uZGl0aW9uHDxEZXNjcmlwdGlvbj5rX19CYWNraW5nRmllbGQsPERlc3RpbmF0aW9uQWN0aXZpdHlFbnRpdHlJZD5rX19CYWNraW5nRmllbGQZPExpbmtUeXBlPmtfX0JhY2tpbmdGaWVsZCc8U291cmNlQWN0aXZpdHlFbnRpdHlJZD5rX19CYWNraW5nRmllbGQEAQEEASlPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkNvbmRpdGlvbgIAAAA3T3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5FeGVjdXRhYmxlVmlldy5MaW5rVHlwZQIAAAACAAAACa4AAAAJNgAAAAawAAAAJDcyRDdGNzI5LThGNjMtNEJCRC05RkFDLTVDNjQ2QTgwNTU2MAVP////N09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuRXhlY3V0YWJsZVZpZXcuTGlua1R5cGUBAAAAB3ZhbHVlX18ACAIAAAABAAAABrIAAAAkQkJENjI3OEEtQTI2RC00NzdELThCOEMtOTgyQjFFQUM5QkVEARwAAAAbAAAACbMAAAAJNgAAAAa1AAAAJEVEQzMxRUFGLThCMEItNDJENy1BM0VCLUFGN0ZDQTk2MzEwNQFK////T////wEAAAAGtwAAACQ3MkQ3RjcyOS04RjYzLTRCQkQtOUZBQy01QzY0NkE4MDU1NjABHQAAABsAAAAJuAAAAAk2AAAABroAAAAkMkM4QzFFMDQtNDY5QS00QkI5LUFFNTQtMDVDN0Q0NUZGRDdGAUX///9P////AAAAAAa8AAAAJEVEQzMxRUFGLThCMEItNDJENy1BM0VCLUFGN0ZDQTk2MzEwNQEeAAAAGwAAAAm9AAAACTYAAAAGvwAAACQxMjlCQkJBQS1EMUNDLTRDOUQtQThFRS1CMENFMDc5RUFDNzUBQP///0////8BAAAABsEAAAAkMTJCMzQyREYtQkRFQi00QkNELTlGRDMtRkVGRjMyOUNGRURGAR8AAAAbAAAACcIAAAAJNgAAAAbEAAAAJDEyQjM0MkRGLUJERUItNEJDRC05RkQzLUZFRkYzMjlDRkVERgE7////T////wAAAAAGxgAAACRFREMzMUVBRi04QjBCLTQyRDctQTNFQi1BRjdGQ0E5NjMxMDUBIAAAABsAAAAJxwAAAAk2AAAABskAAAAkMUIxQ0RGNjgtRTMxOC00OEM1LTg2QTgtQzM5NzEyNTdCRjlDATb///9P////AAAAAAbLAAAAJEVEQzMxRUFGLThCMEItNDJENy1BM0VCLUFGN0ZDQTk2MzEwNQEhAAAAGwAAAAnMAAAACTYAAAAGzgAAACQxMjlCQkJBQS1EMUNDLTRDOUQtQThFRS1CMENFMDc5RUFDNzUBMf///0////8BAAAABtAAAAAkMkM4QzFFMDQtNDY5QS00QkI5LUFFNTQtMDVDN0Q0NUZGRDdGASIAAAAbAAAACdEAAAAJNgAAAAbTAAAAJDEyOUJCQkFBLUQxQ0MtNEM5RC1BOEVFLUIwQ0UwNzlFQUM3NQEs////T////wEAAAAG1QAAACQxQjFDREY2OC1FMzE4LTQ4QzUtODZBOC1DMzk3MTI1N0JGOUMBIwAAABsAAAAJ1gAAAAk2AAAABtgAAAAkMzVCMjE1MEYtMkY3NS00MjE4LTlFNDItMjMwRURDQjkzMURBASf///9P////AQAAAAbaAAAAJDEyOUJCQkFBLUQxQ0MtNEM5RC1BOEVFLUIwQ0UwNzlFQUM3NQEkAAAAGwAAAAnbAAAACTYAAAAG3QAAACQxNkQ4Qzk3RS0xMkFBLTQxMzYtQjA1OC1DNEUwRkIzNDhCMzUBIv///0////8BAAAABt8AAAAkMzVCMjE1MEYtMkY3NS00MjE4LTlFNDItMjMwRURDQjkzMURBASUAAAAbAAAACeAAAAAG4QAAACZGb2xsb3cgdGhpcyBsaW5rIGlmIHRoZSBWTSBpcyBzdG9wcGVkLgbiAAAAJDdFMDFFMjYwLUI4MjQtNEY3MC05MEYzLTM0RTJDNkQ2MkZEMgEd////T////wEAAAAG5AAAACQxNkQ4Qzk3RS0xMkFBLTQxMzYtQjA1OC1DNEUwRkIzNDhCMzUBJgAAABsAAAAJ5QAAAAbmAAAAJkZvbGxvdyB0aGlzIGxpbmsgaWYgdGhlIFZNIGlzIHJ1bm5pbmcuBucAAAAkNkEzRUYwQjktOTZFQy00MUNGLThDNDItMzBCNjJEMzNFQ0Y0ARj///9P////AQAAAAbpAAAAJDE2RDhDOTdFLTEyQUEtNDEzNi1CMDU4LUM0RTBGQjM0OEIzNQEnAAAAGwAAAAnqAAAABusAAAAdSWYgVk0gc3RvcCBvcGVyYXRpb24gc3VjY2VlZHMG7AAAACQ2MTk5N0MyQS00NDQ5LTQ5NjktOEI3My02QjdBQTJGQ0FGNzcBE////0////8BAAAABu4AAAAkNkEzRUYwQjktOTZFQy00MUNGLThDNDItMzBCNjJEMzNFQ0Y0ASgAAAAbAAAACe8AAAAG8AAAABpJZiBWTSBzdG9wIG9wZXJhdGlvbiBmYWlscwbxAAAAJDg2NkUwRTQ4LTRCNjYtNDc1Qi05QTNBLUEzRjA5QjExMEIxNAEO////T////wEAAAAG8wAAACQ2QTNFRjBCOS05NkVDLTQxQ0YtOEM0Mi0zMEI2MkQzM0VDRjQFKQAAADxPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkV4ZWN1dGFibGVWaWV3LlBhcmFtZXRlck5hbWUBAAAAGkNhc2VJbnNlbnNpdGl2ZU5hbWVgMStuYW1lAQIAAAAG9AAAABFSZXNvdXJjZUdyb3VwTmFtZQEsAAAAKQAAAAb1AAAAHEF6dXJlU3Vic2NyaXB0aW9uSWRBc3NldE5hbWUBLwAAACkAAAAG9gAAABhBenVyZUNyZWRlbnRpYWxBc3NldE5hbWUBMQAAACkAAAAG9wAAAAZWTU5hbWUFMwAAADNPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkNvbW1hbmRBY3Rpdml0eVR5cGUDAAAAIzxJbnB1dFBhcmFtZXRlclNldHM+a19fQmFja2luZ0ZpZWxkHDxDb21tYW5kTmFtZT5rX19CYWNraW5nRmllbGQbPE1vZHVsZU5hbWU+a19fQmFja2luZ0ZpZWxkAwEBqQFTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5MaXN0YDFbW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyU2V0LCBPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLCBWZXJzaW9uPTcuMi4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbF1dAgAAAAn4AAAABvkAAAAMV3JpdGUtT3V0cHV0BvoAAAAcTWljcm9zb2Z0LlBvd2VyU2hlbGwuVXRpbGl0eQQ1AAAA2QJTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5EaWN0aW9uYXJ5YDJbW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuRXhlY3V0YWJsZVZpZXcuUGFyYW1ldGVyTmFtZSwgT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbCwgVmVyc2lvbj03LjIuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPW51bGxdLFtPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkV4ZWN1dGFibGVWaWV3LklWYWx1ZURlc2NyaXB0b3IsIE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwsIFZlcnNpb249Ny4yLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1udWxsXV0EAAAAB1ZlcnNpb24IQ29tcGFyZXIISGFzaFNpemUNS2V5VmFsdWVQYWlycwADAAMIywFTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5PYmplY3RFcXVhbGl0eUNvbXBhcmVyYDFbW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuRXhlY3V0YWJsZVZpZXcuUGFyYW1ldGVyTmFtZSwgT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbCwgVmVyc2lvbj03LjIuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPW51bGxdXQjdAlN5c3RlbS5Db2xsZWN0aW9ucy5HZW5lcmljLktleVZhbHVlUGFpcmAyW1tPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkV4ZWN1dGFibGVWaWV3LlBhcmFtZXRlck5hbWUsIE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwsIFZlcnNpb249Ny4yLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1udWxsXSxbT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5FeGVjdXRhYmxlVmlldy5JVmFsdWVEZXNjcmlwdG9yLCBPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLCBWZXJzaW9uPTcuMi4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbF1dW10BAAAACfsAAAADAAAACfwAAAAFNwAAAClPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkNvbmRpdGlvbgIAAAAKZXhwcmVzc2lvbhU8TW9kZT5rX19CYWNraW5nRmllbGQBBC1PcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkNvbmRpdGlvbk1vZGUCAAAAAgAAAAk2AAAABQL///8tT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5Db25kaXRpb25Nb2RlAQAAAAd2YWx1ZV9fAAgCAAAAAQAAAAU4AAAAN09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuQ29uc3RhbnRWYWx1ZURlc2NyaXB0b3IBAAAAFjxWYWx1ZT5rX19CYWNraW5nRmllbGQCAgAAAAgMAAAAAAAAAAAFOQAAADtPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkV4ZWN1dGFibGVWaWV3LkFjdGl2aXR5TmFtZQEAAAAaQ2FzZUluc2Vuc2l0aXZlTmFtZWAxK25hbWUBAgAAAAb/AAAAFk5vdGlmeSBBbHJlYWR5IFN0b3BwZWQBPAAAADMAAAAJAAEAAAYBAQAADFdyaXRlLU91dHB1dAYCAQAAHE1pY3Jvc29mdC5Qb3dlclNoZWxsLlV0aWxpdHkBPgAAADUAAAABAAAACfsAAAADAAAACQQBAAABQAAAADcAAAAJNgAAAAH6/v//Av///wEAAAABQQAAADgAAAAIDAAAAAAAAAAAAUIAAAA5AAAABgcBAAARTm90aWZ5IFZNIFN0b3BwZWQBRQAAADMAAAAJCAEAAAYJAQAADFdyaXRlLU91dHB1dAYKAQAAHE1pY3Jvc29mdC5Qb3dlclNoZWxsLlV0aWxpdHkBRwAAADUAAAABAAAACfsAAAADAAAACQwBAAABSQAAADcAAAAJNgAAAAHy/v//Av///wEAAAABSgAAADgAAAAIDAAAAAAAAAAAAUsAAAA5AAAABg8BAAAVTm90aWZ5IEZhaWxlZCBUbyBTdG9wAU4AAAAzAAAACRABAAAGEQEAAAxXcml0ZS1PdXRwdXQGEgEAABxNaWNyb3NvZnQuUG93ZXJTaGVsbC5VdGlsaXR5AVAAAAA1AAAAAQAAAAn7AAAAAwAAAAkUAQAAAVIAAAA3AAAACTYAAAAB6v7//wL///8BAAAAAVMAAAA4AAAACAwAAAAAAAAAAAFUAAAAOQAAAAYXAQAACU1lcmdlIFZNcwFXAAAAMwAAAAkYAQAABhkBAAAWR2V0LUF1dG9tYXRpb25WYXJpYWJsZQk2AAAAAVkAAAA1AAAAAQAAAAn7AAAAAwAAAAkcAQAAAVsAAAA3AAAACTYAAAAB4v7//wL///8BAAAAAVwAAAA4AAAACAwAAAAAAAAAAAFdAAAAOQAAAAYfAQAAE0dldCBTdWJzY3JpcHRpb24gSWQBYAAAADMAAAAJIAEAAAYhAQAAGkdldC1BdXRvbWF0aW9uUFNDcmVkZW50aWFsCTYAAAABYgAAADUAAAABAAAACfsAAAADAAAACSQBAAABZAAAADcAAAAJNgAAAAHa/v//Av///wEAAAABZQAAADgAAAAIDAAAAAAAAAAAAWYAAAA5AAAABicBAAAUR2V0IEF6dXJlIENyZWRlbnRpYWwBaQAAADMAAAAJKAEAAAYpAQAAEkFkZC1BenVyZVJtQWNjb3VudAYqAQAAD0F6dXJlUk0uUHJvZmlsZQFrAAAANQAAAAIAAAAJ+wAAAAMAAAAJLAEAAAFtAAAANwAAAAk2AAAAAdL+//8C////AQAAAAFuAAAAOAAAAAgMAAAAAAAAAAABbwAAADkAAAAGLwEAABBDb25uZWN0IHRvIEF6dXJlAXIAAAAzAAAACTABAAAGMQEAAA1HZXQtQXp1cmVSbVZNBjIBAAAPQXp1cmVSTS5Db21wdXRlAXQAAAA1AAAAAQAAAAn7AAAAAwAAAAk0AQAAAXYAAAA3AAAACTYAAAAByv7//wL///8BAAAAAXcAAAA4AAAACAwAAAAAAAAAAAF4AAAAOQAAAAY3AQAAEUdldCBhbGwgVk1zIGluIFJHAXsAAAAzAAAACTgBAAAGOQEAAA1HZXQtQXp1cmVSbVZNBjoBAAAPQXp1cmVSTS5Db21wdXRlAX0AAAA1AAAAAwAAAAn7AAAAAwAAAAk8AQAAAX8AAAA3AAAACTYAAAABwv7//wL///8BAAAAAYAAAAA4AAAACAwAAAAAAAAAAAGBAAAAOQAAAAY/AQAADUdldCBzaW5nbGUgVk0BhAAAADMAAAAJQAEAAAZBAQAADUdldC1BenVyZVJtVk0GQgEAAA9BenVyZVJNLkNvbXB1dGUEhgAAANkCU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuRGljdGlvbmFyeWAyW1tPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkV4ZWN1dGFibGVWaWV3LlBhcmFtZXRlck5hbWUsIE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwsIFZlcnNpb249Ny4yLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1udWxsXSxbT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5FeGVjdXRhYmxlVmlldy5JVmFsdWVEZXNjcmlwdG9yLCBPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLCBWZXJzaW9uPTcuMi4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbF1dAwAAAAdWZXJzaW9uCENvbXBhcmVyCEhhc2hTaXplAAMACMsBU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuT2JqZWN0RXF1YWxpdHlDb21wYXJlcmAxW1tPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkV4ZWN1dGFibGVWaWV3LlBhcmFtZXRlck5hbWUsIE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwsIFZlcnNpb249Ny4yLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1udWxsXV0IAAAAAAn7AAAAAAAAAAGIAAAANwAAAAk2AAAAAbv+//8C////AQAAAAGJAAAAOAAAAAgMAAAAAAAAAAABigAAADkAAAAGRgEAABJHZXQgYWxsIFZNcyBpbiBTdWIBjQAAADMAAAAJRwEAAAZIAQAADUdldC1BenVyZVJtVk0GSQEAAA9BenVyZVJNLkNvbXB1dGUBjwAAADUAAAADAAAACfsAAAADAAAACUsBAAABkQAAADcAAAAJNgAAAAGz/v//Av///wEAAAABkgAAADgAAAAIDAAAAAAAAAAAAZMAAAA5AAAABk4BAAASR2V0IFZNIHdpdGggU3RhdHVzAZYAAAAzAAAACU8BAAAGUAEAAA5TdG9wLUF6dXJlUm1WTQZRAQAAD0F6dXJlUk0uQ29tcHV0ZQGYAAAANQAAAAMAAAAJ+wAAAAMAAAAJUwEAAAGaAAAANwAAAAk2AAAAAav+//8C////AQAAAAGbAAAAOAAAAAgMAAAAAAAAAAABnAAAADkAAAAGVgEAAAdTdG9wIFZNAaEAAAA3AAAACTYAAAABqP7//wL///8BAAAAAaIAAAA4AAAACAwAAAAAAAAAAAGjAAAAOQAAAAZZAQAAB1JFQUQgTUUBqQAAADcAAAAJNgAAAAGl/v//Av///wEAAAABqgAAADgAAAAIDAAAAAAAAAAAAasAAAA5AAAABlwBAAAKR2V0IFN0YXR1cwGuAAAANwAAAAk2AAAAAaL+//8C////AQAAAAGzAAAANwAAAAk2AAAAAaH+//8C////AQAAAAG4AAAANwAAAAZgAQAA2AE8IyAKUmVzb3VyY2VHcm91cE5hbWUgcnVuYm9vayBpbnB1dCBwYXJhbWV0ZXJzIGhhcyBhIHZhbHVlIGJ1dCBWTU5hbWUgZG9lcyBub3QuCiM+CigKKCgkVk1OYW1lIC1lcSAkbnVsbCkgLW9yICgkVk1OYW1lLkxlbmd0aCAtZXEgMCkpCikgLWFuZCAoCigoJFJlc291cmNlR3JvdXBOYW1lIC1uZSAkbnVsbCkgLWFuZCAoJFJlc291cmNlR3JvdXBOYW1lLkxlbmd0aCAtZ3QgMCkpCikBn/7//wL///8AAAAAAb0AAAA3AAAACTYAAAABnf7//wL///8BAAAAAcIAAAA3AAAABmQBAADVATwjIApCb3RoIFZNTmFtZSBhbmQgUmVzb3VyY2VHcm91cE5hbWUgcnVuYm9vayBpbnB1dCBwYXJhbWV0ZXJzIGhhdmUgdmFsdWVzIAojPgooCigoJFZNTmFtZSAtbmUgJG51bGwpIC1hbmQgKCRWTU5hbWUuTGVuZ3RoIC1ndCAwKSkKKSAtYW5kICgKKCgkUmVzb3VyY2VHcm91cE5hbWUgLW5lICRudWxsKSAtYW5kICgkUmVzb3VyY2VHcm91cE5hbWUuTGVuZ3RoIC1ndCAwKSkKKQGb/v//Av///wAAAAABxwAAADcAAAAGZgEAANcBPCMgCk5laXRoZXIgUmVzb3VyY2VHcm91cE5hbWUgbm9yIFZNTmFtZSBydW5ib29rIGlucHV0IHBhcmFtZXRlcnMgaGF2ZSB2YWx1ZXMuCiM+CigKKCgkVk1OYW1lIC1lcSAkbnVsbCkgLW9yICgkVk1OYW1lLkxlbmd0aCAtZXEgMCkpCikgLWFuZCAoCigoJFJlc291cmNlR3JvdXBOYW1lIC1lcSAkbnVsbCkgLWFuZCAoJFJlc291cmNlR3JvdXBOYW1lLkxlbmd0aCAtZXEgMCkpCikBmf7//wL///8AAAAAAcwAAAA3AAAACTYAAAABl/7//wL///8BAAAAAdEAAAA3AAAACTYAAAABlv7//wL///8BAAAAAdYAAAA3AAAACTYAAAABlf7//wL///8BAAAAAdsAAAA3AAAACTYAAAABlP7//wL///8BAAAAAeAAAAA3AAAABm0BAAArJEFjdGl2aXR5T3V0cHV0WydHZXQgU3RhdHVzJ10gLWVxICJzdG9wcGVkIgGS/v//Av///wAAAAAB5QAAADcAAAAGbwEAACskQWN0aXZpdHlPdXRwdXRbJ0dldCBTdGF0dXMnXSAtZXEgInJ1bm5pbmciAZD+//8C////AAAAAAHqAAAANwAAAAZxAQAAOCRBY3Rpdml0eU91dHB1dFsnU3RvcCBWTSddLklzU3VjY2Vzc1N0YXR1c0NvZGUgLWVxICR0cnVlAY7+//8C////AAAAAAHvAAAANwAAAAZzAQAAOCRBY3Rpdml0eU91dHB1dFsnU3RvcCBWTSddLklzU3VjY2Vzc1N0YXR1c0NvZGUgLW5lICR0cnVlAYz+//8C////AAAAAAT4AAAAqQFTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5MaXN0YDFbW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyU2V0LCBPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLCBWZXJzaW9uPTcuMi4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbF1dAwAAAAZfaXRlbXMFX3NpemUIX3ZlcnNpb24EAAAuT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5QYXJhbWV0ZXJTZXRbXQIAAAAICAl1AQAAAQAAAAEAAAAE+wAAAMsBU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuT2JqZWN0RXF1YWxpdHlDb21wYXJlcmAxW1tPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkV4ZWN1dGFibGVWaWV3LlBhcmFtZXRlck5hbWUsIE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwsIFZlcnNpb249Ny4yLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1udWxsXV0AAAAAB/wAAAAAAQAAAAEAAAAD2wJTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5LZXlWYWx1ZVBhaXJgMltbT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5FeGVjdXRhYmxlVmlldy5QYXJhbWV0ZXJOYW1lLCBPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLCBWZXJzaW9uPTcuMi4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbF0sW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuRXhlY3V0YWJsZVZpZXcuSVZhbHVlRGVzY3JpcHRvciwgT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbCwgVmVyc2lvbj03LjIuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPW51bGxdXQSK/v//2wJTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5LZXlWYWx1ZVBhaXJgMltbT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5FeGVjdXRhYmxlVmlldy5QYXJhbWV0ZXJOYW1lLCBPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLCBWZXJzaW9uPTcuMi4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbF0sW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuRXhlY3V0YWJsZVZpZXcuSVZhbHVlRGVzY3JpcHRvciwgT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbCwgVmVyc2lvbj03LjIuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPW51bGxdXQIAAAADa2V5BXZhbHVlBAQ8T3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5FeGVjdXRhYmxlVmlldy5QYXJhbWV0ZXJOYW1lAgAAAENPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLlBvd2VyU2hlbGxFeHByZXNzaW9uVmFsdWVEZXNjcmlwdG9yAgAAAAl3AQAACXgBAAABAAEAAPgAAAAJeQEAAAEAAAABAAAABwQBAAAAAQAAAAEAAAAD2wJTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5LZXlWYWx1ZVBhaXJgMltbT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5FeGVjdXRhYmxlVmlldy5QYXJhbWV0ZXJOYW1lLCBPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLCBWZXJzaW9uPTcuMi4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbF0sW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuRXhlY3V0YWJsZVZpZXcuSVZhbHVlRGVzY3JpcHRvciwgT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbCwgVmVyc2lvbj03LjIuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPW51bGxdXQGG/v//iv7//wl7AQAACXwBAAABCAEAAPgAAAAJfQEAAAEAAAABAAAABwwBAAAAAQAAAAEAAAAD2wJTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5LZXlWYWx1ZVBhaXJgMltbT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5FeGVjdXRhYmxlVmlldy5QYXJhbWV0ZXJOYW1lLCBPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLCBWZXJzaW9uPTcuMi4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbF0sW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuRXhlY3V0YWJsZVZpZXcuSVZhbHVlRGVzY3JpcHRvciwgT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbCwgVmVyc2lvbj03LjIuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPW51bGxdXQGC/v//iv7//wl/AQAACYABAAABEAEAAPgAAAAJgQEAAAEAAAABAAAABxQBAAAAAQAAAAEAAAAD2wJTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5LZXlWYWx1ZVBhaXJgMltbT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5FeGVjdXRhYmxlVmlldy5QYXJhbWV0ZXJOYW1lLCBPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLCBWZXJzaW9uPTcuMi4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbF0sW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuRXhlY3V0YWJsZVZpZXcuSVZhbHVlRGVzY3JpcHRvciwgT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbCwgVmVyc2lvbj03LjIuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPW51bGxdXQF+/v//iv7//wmDAQAACYQBAAABGAEAAPgAAAAJhQEAAAEAAAABAAAABxwBAAAAAQAAAAEAAAAD2wJTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5LZXlWYWx1ZVBhaXJgMltbT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5FeGVjdXRhYmxlVmlldy5QYXJhbWV0ZXJOYW1lLCBPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLCBWZXJzaW9uPTcuMi4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbF0sW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuRXhlY3V0YWJsZVZpZXcuSVZhbHVlRGVzY3JpcHRvciwgT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbCwgVmVyc2lvbj03LjIuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPW51bGxdXQF6/v//iv7//wmHAQAACYgBAAABIAEAAPgAAAAJiQEAAAEAAAABAAAAByQBAAAAAQAAAAEAAAAD2wJTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5LZXlWYWx1ZVBhaXJgMltbT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5FeGVjdXRhYmxlVmlldy5QYXJhbWV0ZXJOYW1lLCBPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLCBWZXJzaW9uPTcuMi4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbF0sW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuRXhlY3V0YWJsZVZpZXcuSVZhbHVlRGVzY3JpcHRvciwgT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbCwgVmVyc2lvbj03LjIuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPW51bGxdXQF2/v//iv7//wmLAQAACYwBAAABKAEAAPgAAAAJjQEAAAYAAAAGAAAABywBAAAAAQAAAAIAAAAD2wJTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5LZXlWYWx1ZVBhaXJgMltbT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5FeGVjdXRhYmxlVmlldy5QYXJhbWV0ZXJOYW1lLCBPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLCBWZXJzaW9uPTcuMi4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbF0sW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuRXhlY3V0YWJsZVZpZXcuSVZhbHVlRGVzY3JpcHRvciwgT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbCwgVmVyc2lvbj03LjIuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPW51bGxdXQFy/v//iv7//wmPAQAACZABAAABb/7//4r+//8JkgEAAAmTAQAAATABAAD4AAAACZQBAAADAAAAAwAAAAc0AQAAAAEAAAABAAAAA9sCU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuS2V5VmFsdWVQYWlyYDJbW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuRXhlY3V0YWJsZVZpZXcuUGFyYW1ldGVyTmFtZSwgT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbCwgVmVyc2lvbj03LjIuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPW51bGxdLFtPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkV4ZWN1dGFibGVWaWV3LklWYWx1ZURlc2NyaXB0b3IsIE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwsIFZlcnNpb249Ny4yLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1udWxsXV0Ba/7//4r+//8JlgEAAAmXAQAAATgBAAD4AAAACZgBAAADAAAAAwAAAAc8AQAAAAEAAAADAAAAA9sCU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuS2V5VmFsdWVQYWlyYDJbW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuRXhlY3V0YWJsZVZpZXcuUGFyYW1ldGVyTmFtZSwgT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbCwgVmVyc2lvbj03LjIuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPW51bGxdLFtPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkV4ZWN1dGFibGVWaWV3LklWYWx1ZURlc2NyaXB0b3IsIE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwsIFZlcnNpb249Ny4yLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1udWxsXV0BZ/7//4r+//8JmgEAAAmbAQAAAWT+//+K/v//CZ0BAAAJngEAAAFh/v//iv7//wmgAQAACaEBAAABQAEAAPgAAAAJogEAAAMAAAADAAAAAUcBAAD4AAAACaMBAAADAAAAAwAAAAdLAQAAAAEAAAADAAAAA9sCU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWMuS2V5VmFsdWVQYWlyYDJbW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuRXhlY3V0YWJsZVZpZXcuUGFyYW1ldGVyTmFtZSwgT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbCwgVmVyc2lvbj03LjIuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPW51bGxdLFtPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkV4ZWN1dGFibGVWaWV3LklWYWx1ZURlc2NyaXB0b3IsIE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwsIFZlcnNpb249Ny4yLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1udWxsXV0BXP7//4r+//8JpQEAAAmmAQAAAVn+//+K/v//CagBAAAJqQEAAAFW/v//iv7//wmrAQAACawBAAABTwEAAPgAAAAJrQEAAAIAAAACAAAAB1MBAAAAAQAAAAMAAAAD2wJTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5LZXlWYWx1ZVBhaXJgMltbT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5FeGVjdXRhYmxlVmlldy5QYXJhbWV0ZXJOYW1lLCBPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLCBWZXJzaW9uPTcuMi4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbF0sW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuRXhlY3V0YWJsZVZpZXcuSVZhbHVlRGVzY3JpcHRvciwgT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbCwgVmVyc2lvbj03LjIuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPW51bGxdXQFS/v//iv7//wmvAQAACbABAAABT/7//4r+//8JsgEAAAmzAQAAAUz+//+K/v//CbUBAAAJtgEAAAd1AQAAAAEAAAAEAAAABCxPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLlBhcmFtZXRlclNldAIAAAAJtwEAAA0DAXcBAAApAAAABrgBAAALSW5wdXRPYmplY3QFeAEAAENPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLlBvd2VyU2hlbGxFeHByZXNzaW9uVmFsdWVEZXNjcmlwdG9yAQAAAApleHByZXNzaW9uAQIAAAAGuQEAADokQWN0aXZpdHlPdXRwdXRbJ01lcmdlIFZNcyddLk5hbWUgKyAiIGlzIGFscmVhZHkgc3RvcHBlZC4iB3kBAAAAAQAAAAQAAAAELE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyU2V0AgAAAAm6AQAADQMBewEAACkAAAAGuwEAAAtJbnB1dE9iamVjdAF8AQAAeAEAAAa8AQAAOCRBY3Rpdml0eU91dHB1dFsnTWVyZ2UgVk1zJ10uTmFtZSArICIgaGFzIGJlZW4gc3RvcHBlZC4iB30BAAAAAQAAAAQAAAAELE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyU2V0AgAAAAm9AQAADQMBfwEAACkAAAAGvgEAAAtJbnB1dE9iamVjdAGAAQAAeAEAAAa/AQAAbCRBY3Rpdml0eU91dHB1dFsnTWVyZ2UgVk1zJ10uTmFtZSArICIgZmFpbGVkIHRvIHN0b3AuIgoKIlJlYXNvbjogIiArICRBY3Rpdml0eU91dHB1dFsnU3RvcCBWTSddLlJlYXNvblBocmFzZQeBAQAAAAEAAAAEAAAABCxPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLlBhcmFtZXRlclNldAIAAAAJwAEAAA0DAYMBAAApAAAABsEBAAALSW5wdXRPYmplY3QBhAEAAHgBAAAGwgEAACwjIE1lcmdlIHRoZSBvdXRwdXQgb2YgaW5jb21pbmcgYWN0aXZpdGllcwokXweFAQAAAAEAAAAEAAAABCxPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLlBhcmFtZXRlclNldAIAAAAJwwEAAA0DAYcBAAApAAAABsQBAAAETmFtZQWIAQAAP09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUnVuYm9va1BhcmFtZXRlclZhbHVlRGVzY3JpcHRvcgEAAAAePFBhcmFtZXRlck5hbWU+a19fQmFja2luZ0ZpZWxkBDxPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLkV4ZWN1dGFibGVWaWV3LlBhcmFtZXRlck5hbWUCAAAAAgAAAAnFAQAAB4kBAAAAAQAAAAQAAAAELE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyU2V0AgAAAAnGAQAADQMBiwEAACkAAAAGxwEAAAROYW1lAYwBAACIAQAACcgBAAAHjQEAAAABAAAACAAAAAQsT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5QYXJhbWV0ZXJTZXQCAAAACckBAAAJygEAAAnLAQAACcwBAAAJzQEAAAnOAQAADQIBjwEAACkAAAAGzwEAAA5TdWJzY3JpcHRpb25JZAWQAQAAPU9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuQWN0aXZpdHlPdXRwdXRWYWx1ZURlc2NyaXB0b3ICAAAAHTxBY3Rpdml0eU5hbWU+a19fQmFja2luZ0ZpZWxkGjxGaWVsZFBhdGg+a19fQmFja2luZ0ZpZWxkBAM7T3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5FeGVjdXRhYmxlVmlldy5BY3Rpdml0eU5hbWUCAAAAhgFTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5JRW51bWVyYWJsZWAxW1tTeXN0ZW0uU3RyaW5nLCBtc2NvcmxpYiwgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODldXQIAAAAJ0AEAAAoBkgEAACkAAAAG0QEAAApDcmVkZW50aWFsAZMBAACQAQAACdIBAAAKB5QBAAAAAQAAAAQAAAAELE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyU2V0AgAAAAnTAQAACdQBAAAJ1QEAAAoBlgEAACkAAAAG1gEAABFSZXNvdXJjZUdyb3VwTmFtZQGXAQAAiAEAAAnXAQAAB5gBAAAAAQAAAAQAAAAELE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyU2V0AgAAAAnYAQAACdkBAAAJ2gEAAAoBmgEAACkAAAAG2wEAAAROYW1lAZsBAACIAQAACdwBAAABnQEAACkAAAAG3QEAABFSZXNvdXJjZUdyb3VwTmFtZQGeAQAAiAEAAAneAQAAAaABAAApAAAABt8BAAAGU3RhdHVzAaEBAAA4AAAACAEAB6IBAAAAAQAAAAQAAAAELE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyU2V0AgAAAAngAQAACeEBAAAJ4gEAAAoHowEAAAABAAAABAAAAAQsT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5QYXJhbWV0ZXJTZXQCAAAACeMBAAAJ5AEAAAnlAQAACgGlAQAAKQAAAAbmAQAABlN0YXR1cwGmAQAAOAAAAAgBAQGoAQAAKQAAAAbnAQAABE5hbWUBqQEAAJABAAAJ6AEAAAnpAQAAAasBAAApAAAABuoBAAARUmVzb3VyY2VHcm91cE5hbWUBrAEAAJABAAAJ6wEAAAnsAQAAB60BAAAAAQAAAAQAAAAELE9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyU2V0AgAAAAntAQAACe4BAAANAgGvAQAAKQAAAAbvAQAABUZvcmNlAbABAAA4AAAACAEBAbIBAAApAAAABvABAAAETmFtZQGzAQAAkAEAAAnxAQAACfIBAAABtQEAACkAAAAG8wEAABFSZXNvdXJjZUdyb3VwTmFtZQG2AQAAkAEAAAn0AQAACfUBAAAFtwEAACxPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLlBhcmFtZXRlclNldAMAAAAVPE5hbWU+a19fQmFja2luZ0ZpZWxkHzxPdXRwdXRUeXBlTmFtZT5rX19CYWNraW5nRmllbGQbPFBhcmFtZXRlcnM+a19fQmFja2luZ0ZpZWxkAQEDpgFTeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5MaXN0YDFbW09yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyLCBPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLCBWZXJzaW9uPTcuMi4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbF1dAgAAAAb2AQAAEl9fQWxsUGFyYW1ldGVyU2V0cwoJ9wEAAAG6AQAAtwEAAAb4AQAAEl9fQWxsUGFyYW1ldGVyU2V0cwoJ+QEAAAG9AQAAtwEAAAb6AQAAEl9fQWxsUGFyYW1ldGVyU2V0cwoJ+wEAAAHAAQAAtwEAAAb8AQAAEl9fQWxsUGFyYW1ldGVyU2V0cwoJ/QEAAAHDAQAAtwEAAAb+AQAAB0RlZmF1bHQKCf8BAAABxQEAACkAAAAGAAIAABxBenVyZVN1YnNjcmlwdGlvbklkQXNzZXROYW1lAcYBAAC3AQAABgECAAAHRGVmYXVsdAoJAgIAAAHIAQAAKQAAAAYDAgAAGEF6dXJlQ3JlZGVudGlhbEFzc2V0TmFtZQHJAQAAtwEAAAYEAgAAG1NlcnZpY2VQcmluY2lwYWxDZXJ0aWZpY2F0ZQoJBQIAAAHKAQAAtwEAAAYGAgAABFVzZXIKCQcCAAABywEAALcBAAAGCAIAABBTdWJzY3JpcHRpb25OYW1lCgkJAgAAAcwBAAC3AQAABgoCAAALQWNjZXNzVG9rZW4KCQsCAAABzQEAALcBAAAGDAIAABBTZXJ2aWNlUHJpbmNpcGFsCgkNAgAAAc4BAAC3AQAABg4CAAAOU3Vic2NyaXB0aW9uSWQKCQ8CAAAB0AEAADkAAAAGEAIAABNHZXQgU3Vic2NyaXB0aW9uIElkAdIBAAA5AAAABhECAAAUR2V0IEF6dXJlIENyZWRlbnRpYWwB0wEAALcBAAAGEgIAAChHZXRWaXJ0dWFsTWFjaGluZUluUmVzb3VyY2VHcm91cFBhcmFtU2V0CgkTAgAAAdQBAAC3AQAABhQCAAAjTGlzdE5leHRMaW5rVmlydHVhbE1hY2hpbmVzUGFyYW1TZXQKCRUCAAAB1QEAALcBAAAGFgIAAClMaXN0VmlydHVhbE1hY2hpbmVJblJlc291cmNlR3JvdXBQYXJhbVNldAoJFwIAAAHXAQAAKQAAAAYYAgAAEVJlc291cmNlR3JvdXBOYW1lAdgBAAC3AQAABhkCAAAoR2V0VmlydHVhbE1hY2hpbmVJblJlc291cmNlR3JvdXBQYXJhbVNldAoJGgIAAAHZAQAAtwEAAAYbAgAAI0xpc3ROZXh0TGlua1ZpcnR1YWxNYWNoaW5lc1BhcmFtU2V0CgkcAgAAAdoBAAC3AQAABh0CAAApTGlzdFZpcnR1YWxNYWNoaW5lSW5SZXNvdXJjZUdyb3VwUGFyYW1TZXQKCR4CAAAB3AEAACkAAAAGHwIAAAZWTU5hbWUB3gEAACkAAAAGIAIAABFSZXNvdXJjZUdyb3VwTmFtZQHgAQAAtwEAAAYhAgAAKEdldFZpcnR1YWxNYWNoaW5lSW5SZXNvdXJjZUdyb3VwUGFyYW1TZXQKCSICAAAB4QEAALcBAAAGIwIAACNMaXN0TmV4dExpbmtWaXJ0dWFsTWFjaGluZXNQYXJhbVNldAoJJAIAAAHiAQAAtwEAAAYlAgAAKUxpc3RWaXJ0dWFsTWFjaGluZUluUmVzb3VyY2VHcm91cFBhcmFtU2V0CgkmAgAAAeMBAAC3AQAABicCAAAoR2V0VmlydHVhbE1hY2hpbmVJblJlc291cmNlR3JvdXBQYXJhbVNldAoJKAIAAAHkAQAAtwEAAAYpAgAAI0xpc3ROZXh0TGlua1ZpcnR1YWxNYWNoaW5lc1BhcmFtU2V0CgkqAgAAAeUBAAC3AQAABisCAAApTGlzdFZpcnR1YWxNYWNoaW5lSW5SZXNvdXJjZUdyb3VwUGFyYW1TZXQKCSwCAAAB6AEAADkAAAAGLQIAAAlNZXJnZSBWTXMR6QEAAAEAAAAGLgIAAAROYW1lAesBAAA5AAAABi8CAAAJTWVyZ2UgVk1zEewBAAABAAAABjACAAARUmVzb3VyY2VHcm91cE5hbWUB7QEAALcBAAAGMQIAACFSZXNvdXJjZUdyb3VwTmFtZVBhcmFtZXRlclNldE5hbWUKCTICAAAB7gEAALcBAAAGMwIAABJJZFBhcmFtZXRlclNldE5hbWUKCTQCAAAB8QEAADkAAAAGNQIAAAlNZXJnZSBWTXMR8gEAAAEAAAAGNgIAAAROYW1lAfQBAAA5AAAABjcCAAAJTWVyZ2UgVk1zEfUBAAABAAAABjgCAAARUmVzb3VyY2VHcm91cE5hbWUB9wEAAAMAAAAJOQIAAAIAAAACAAAAAfkBAAADAAAACToCAAACAAAAAgAAAAH7AQAAAwAAAAk7AgAAAgAAAAIAAAAB/QEAAAMAAAAJPAIAAAIAAAACAAAAAf8BAAADAAAACT0CAAABAAAAAQAAAAECAgAAAwAAAAk+AgAAAQAAAAEAAAABBQIAAAMAAAAJPwIAAAYAAAAGAAAAAQcCAAADAAAACUACAAAEAAAABAAAAAEJAgAAAwAAAAlBAgAACQAAAAkAAAABCwIAAAMAAAAJQgIAAAUAAAAFAAAAAQ0CAAADAAAACUMCAAAHAAAABwAAAAEPAgAAAwAAAAlEAgAACQAAAAkAAAABEwIAAAMAAAAJRQIAAAMAAAADAAAAARUCAAADAAAACUYCAAABAAAAAQAAAAEXAgAAAwAAAAlHAgAAAQAAAAEAAAABGgIAAAMAAAAJSAIAAAMAAAADAAAAARwCAAADAAAACUkCAAABAAAAAQAAAAEeAgAAAwAAAAlKAgAAAQAAAAEAAAABIgIAAAMAAAAJSwIAAAMAAAADAAAAASQCAAADAAAACUwCAAABAAAAAQAAAAEmAgAAAwAAAAlNAgAAAQAAAAEAAAABKAIAAAMAAAAJTgIAAAMAAAADAAAAASoCAAADAAAACU8CAAABAAAAAQAAAAEsAgAAAwAAAAlQAgAAAQAAAAEAAAABMgIAAAMAAAAJUQIAAAQAAAAEAAAAATQCAAADAAAACVICAAAEAAAABAAAAAc5AgAAAAEAAAAEAAAABClPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLlBhcmFtZXRlcgIAAAAJUwIAAAlUAgAADQIHOgIAAAABAAAABAAAAAQpT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5QYXJhbWV0ZXICAAAACVUCAAAJVgIAAA0CBzsCAAAAAQAAAAQAAAAEKU9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyAgAAAAlXAgAACVgCAAANAgc8AgAAAAEAAAAEAAAABClPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLlBhcmFtZXRlcgIAAAAJWQIAAAlaAgAADQIHPQIAAAABAAAABAAAAAQpT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5QYXJhbWV0ZXICAAAACVsCAAANAwc+AgAAAAEAAAAEAAAABClPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLlBhcmFtZXRlcgIAAAAJXAIAAA0DBz8CAAAAAQAAAAgAAAAEKU9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyAgAAAAldAgAACV4CAAAJXwIAAAlgAgAACWECAAAJYgIAAA0CB0ACAAAAAQAAAAQAAAAEKU9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyAgAAAAljAgAACWQCAAAJZQIAAAlmAgAAB0ECAAAAAQAAABAAAAAEKU9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyAgAAAAlnAgAACWgCAAAJaQIAAAlqAgAACWsCAAAJbAIAAAltAgAACW4CAAAJbwIAAA0HB0ICAAAAAQAAAAgAAAAEKU9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyAgAAAAlwAgAACXECAAAJcgIAAAlzAgAACXQCAAANAwdDAgAAAAEAAAAIAAAABClPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLlBhcmFtZXRlcgIAAAAJdQIAAAl2AgAACXcCAAAJeAIAAAl5AgAACXoCAAAJewIAAAoHRAIAAAABAAAAEAAAAAQpT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5QYXJhbWV0ZXICAAAACXwCAAAJfQIAAAl+AgAACX8CAAAJgAIAAAmBAgAACYICAAAJgwIAAAmEAgAADQcHRQIAAAABAAAABAAAAAQpT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5QYXJhbWV0ZXICAAAACYUCAAAJhgIAAAmHAgAACgdGAgAAAAEAAAAEAAAABClPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLlBhcmFtZXRlcgIAAAAJiAIAAA0DB0cCAAAAAQAAAAQAAAAEKU9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyAgAAAAmJAgAADQMHSAIAAAABAAAABAAAAAQpT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5QYXJhbWV0ZXICAAAACYoCAAAJiwIAAAmMAgAACgdJAgAAAAEAAAAEAAAABClPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLlBhcmFtZXRlcgIAAAAJjQIAAA0DB0oCAAAAAQAAAAQAAAAEKU9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyAgAAAAmOAgAADQMHSwIAAAABAAAABAAAAAQpT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5QYXJhbWV0ZXICAAAACY8CAAAJkAIAAAmRAgAACgdMAgAAAAEAAAAEAAAABClPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLlBhcmFtZXRlcgIAAAAJkgIAAA0DB00CAAAAAQAAAAQAAAAEKU9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyAgAAAAmTAgAADQMHTgIAAAABAAAABAAAAAQpT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5QYXJhbWV0ZXICAAAACZQCAAAJlQIAAAmWAgAACgdPAgAAAAEAAAAEAAAABClPcmNoZXN0cmF0b3IuR3JhcGhSdW5ib29rLk1vZGVsLlBhcmFtZXRlcgIAAAAJlwIAAA0DB1ACAAAAAQAAAAQAAAAEKU9yY2hlc3RyYXRvci5HcmFwaFJ1bmJvb2suTW9kZWwuUGFyYW1ldGVyAgAAAAmYAgAADQMHUQIAAAABAAAABAAAAAQpT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5QYXJhbWV0ZXICAAAACZkCAAAJmgIAAAmbAgAACZwCAAAHUgIAAAABAAAABAAAAAQpT3JjaGVzdHJhdG9yLkdyYXBoUnVuYm9vay5Nb2RlbC5QYXJhbWV0ZXICAAAACZ0CAAAJngIAAAmfAgAACaACAAABUwIAAAkAAAAKCaECAAAABqICAAAnU3lzdGVtLk1hbmFnZW1lbnQuQXV0b21hdGlvbi5QU09iamVjdFtdCgFUAgAACQAAAAoJowIAAAEGpAIAACxTeXN0ZW0uTWFuYWdlbWVudC5BdXRvbWF0aW9uLlN3aXRjaFBhcmFtZXRlcgoBVQIAAAkAAAAKCaUCAAAABqYCAAAnU3lzdGVtLk1hbmFnZW1lbnQuQXV0b21hdGlvbi5QU09iamVjdFtdCgFWAgAACQAAAAoJpwIAAAEGqAIAACxTeXN0ZW0uTWFuYWdlbWVudC5BdXRvbWF0aW9uLlN3aXRjaFBhcmFtZXRlcgoBVwIAAAkAAAAKCakCAAAABqoCAAAnU3lzdGVtLk1hbmFnZW1lbnQuQXV0b21hdGlvbi5QU09iamVjdFtdCgFYAgAACQAAAAoJqwIAAAEGrAIAACxTeXN0ZW0uTWFuYWdlbWVudC5BdXRvbWF0aW9uLlN3aXRjaFBhcmFtZXRlcgoBWQIAAAkAAAAKCa0CAAAABq4CAAAnU3lzdGVtLk1hbmFnZW1lbnQuQXV0b21hdGlvbi5QU09iamVjdFtdCgFaAgAACQAAAAoJrwIAAAEGsAIAACxTeXN0ZW0uTWFuYWdlbWVudC5BdXRvbWF0aW9uLlN3aXRjaFBhcmFtZXRlcgoBWwIAAAkAAAAKCbECAAAABrICAAANU3lzdGVtLlN0cmluZwoBXAIAAAkAAAAKCbMCAAAABrQCAAANU3lzdGVtLlN0cmluZwoBXQIAAAkAAAAKCbUCAAAABrYCAAANU3lzdGVtLlN0cmluZwoBXgIAAAkAAAAKCbcCAAAABrgCAAANU3lzdGVtLlN0cmluZwoBXwIAAAkAAAAKCbkCAAABBroCAAA9TWljcm9zb2Z0LkF6dXJlLkNvbW1vbi5BdXRoZW50aWNhdGlvbi5Nb2RlbHMuQXp1cmVFbnZpcm9ubWVudAoBYAIAAAkAAAAKCbsCAAABBrwCAAANU3lzdGVtLlN0cmluZwoBYQIAAAkAAAAKCb0CAAAABr4CAAAsU3lzdGVtLk1hbmFnZW1lbnQuQXV0b21hdGlvbi5Td2l0Y2hQYXJhbWV0ZXIKAWICAAAJAAAACgm/AgAAAAbAAgAADVN5c3RlbS5TdHJpbmcKAWMCAAAJAAAACgnBAgAAAQbCAgAAKVN5c3RlbS5NYW5hZ2VtZW50LkF1dG9tYXRpb24uUFNDcmVkZW50aWFsCgFkAgAACQAAAAoJwwIAAAEGxAIAAD1NaWNyb3NvZnQuQXp1cmUuQ29tbW9uLkF1dGhlbnRpY2F0aW9uLk1vZGVscy5BenVyZUVudmlyb25tZW50CgFlAgAACQAAAAoJxQIAAAEGxgIAAA1TeXN0ZW0uU3RyaW5nCgFmAgAACQAAAAoJxwIAAAEGyAIAAA1TeXN0ZW0uU3RyaW5nCgFnAgAACQAAAAoJyQIAAAEGygIAAA1TeXN0ZW0uU3RyaW5nCgFoAgAACQAAAAoJywIAAAEGzAIAAA1TeXN0ZW0uU3RyaW5nCgFpAgAACQAAAAoJzQIAAAEGzgIAAA1TeXN0ZW0uU3RyaW5nCgFqAgAACQAAAAoJzwIAAAEG0AIAAA1TeXN0ZW0uU3RyaW5nCgFrAgAACQAAAAoJ0QIAAAEG0gIAAClTeXN0ZW0uTWFuYWdlbWVudC5BdXRvbWF0aW9uLlBTQ3JlZGVudGlhbAoBbAIAAAkAAAAKCdMCAAABBtQCAAA9TWljcm9zb2Z0LkF6dXJlLkNvbW1vbi5BdXRoZW50aWNhdGlvbi5Nb2RlbHMuQXp1cmVFbnZpcm9ubWVudAoBbQIAAAkAAAAKCdUCAAABBtYCAAANU3lzdGVtLlN0cmluZwoBbgIAAAkAAAAKCdcCAAABBtgCAAANU3lzdGVtLlN0cmluZwoBbwIAAAkAAAAKCdkCAAABBtoCAAANU3lzdGVtLlN0cmluZwoBcAIAAAkAAAAKCdsCAAAABtwCAAANU3lzdGVtLlN0cmluZwoBcQIAAAkAAAAKCd0CAAAABt4CAAANU3lzdGVtLlN0cmluZwoBcgIAAAkAAAAKCd8CAAABBuACAAA9TWljcm9zb2Z0LkF6dXJlLkNvbW1vbi5BdXRoZW50aWNhdGlvbi5Nb2RlbHMuQXp1cmVFbnZpcm9ubWVudAoBcwIAAAkAAAAKCeECAAABBuICAAANU3lzdGVtLlN0cmluZwoBdAIAAAkAAAAKCeMCAAABBuQCAAANU3lzdGVtLlN0cmluZwoBdQIAAAkAAAAKCeUCAAAABuYCAAApU3lzdGVtLk1hbmFnZW1lbnQuQXV0b21hdGlvbi5QU0NyZWRlbnRpYWwKAXYCAAAJAAAACgnnAgAAAQboAgAAPU1pY3Jvc29mdC5BenVyZS5Db21tb24uQXV0aGVudGljYXRpb24uTW9kZWxzLkF6dXJlRW52aXJvbm1lbnQKAXcCAAAJAAAACgnpAgAAAQbqAgAADVN5c3RlbS5TdHJpbmcKAXgCAAAJAAAACgnrAgAAAAbsAgAALFN5c3RlbS5NYW5hZ2VtZW50LkF1dG9tYXRpb24uU3dpdGNoUGFyYW1ldGVyCgF5AgAACQAAAAoJ7QIAAAEG7gIAAA1TeXN0ZW0uU3RyaW5nCgF6AgAACQAAAAoJ7wIAAAEG8AIAAA1TeXN0ZW0uU3RyaW5nCgF7AgAACQAAAAoJ8QIAAAAG8gIAAA1TeXN0ZW0uU3RyaW5nCgF8AgAACQAAAAoJ8wIAAAEG9AIAAA1TeXN0ZW0uU3RyaW5nCgF9AgAACQAAAAoJ9QIAAAEG9gIAAA1TeXN0ZW0uU3RyaW5nCgF+AgAACQAAAAoJ9wIAAAEG+AIAAA1TeXN0ZW0uU3RyaW5nCgF/AgAACQAAAAoJ+QIAAAEG+gIAAA1TeXN0ZW0uU3RyaW5nCgGAAgAACQAAAAoJ+wIAAAEG/AIAAClTeXN0ZW0uTWFuYWdlbWVudC5BdXRvbWF0aW9uLlBTQ3JlZGVudGlhbAoBgQIAAAkAAAAKCf0CAAABBv4CAAA9TWljcm9zb2Z0LkF6dXJlLkNvbW1vbi5BdXRoZW50aWNhdGlvbi5Nb2RlbHMuQXp1cmVFbnZpcm9ubWVudAoBggIAAAkAAAAKCf8CAAABBgADAAANU3lzdGVtLlN0cmluZwoBgwIAAAkAAAAKCQEDAAABBgIDAAANU3lzdGVtLlN0cmluZwoBhAIAAAkAAAAKCQMDAAABBgQDAAANU3lzdGVtLlN0cmluZwoBhQIAAAkAAAAKCQUDAAAABgYDAAANU3lzdGVtLlN0cmluZwoBhgIAAAkAAAAKCQcDAAAABggDAAANU3lzdGVtLlN0cmluZwoBhwIAAAkAAAAKCQkDAAABBgoDAAAsU3lzdGVtLk1hbmFnZW1lbnQuQXV0b21hdGlvbi5Td2l0Y2hQYXJhbWV0ZXIKAYgCAAAJAAAACgkLAwAAAAYMAwAAClN5c3RlbS5VcmkKAYkCAAAJAAAACgkNAwAAAAYOAwAADVN5c3RlbS5TdHJpbmcKAYoCAAAJAAAACgkPAwAAAAYQAwAADVN5c3RlbS5TdHJpbmcKAYsCAAAJAAAACgkRAwAAAAYSAwAADVN5c3RlbS5TdHJpbmcKAYwCAAAJAAAACgkTAwAAAQYUAwAALFN5c3RlbS5NYW5hZ2VtZW50LkF1dG9tYXRpb24uU3dpdGNoUGFyYW1ldGVyCgGNAgAACQAAAAoJFQMAAAAGFgMAAApTeXN0ZW0uVXJpCgGOAgAACQAAAAoJFwMAAAAGGAMAAA1TeXN0ZW0uU3RyaW5nCgGPAgAACQAAAAoJGQMAAAAGGgMAAA1TeXN0ZW0uU3RyaW5nCgGQAgAACQAAAAoJGwMAAAAGHAMAAA1TeXN0ZW0uU3RyaW5nCgGRAgAACQAAAAoJHQMAAAEGHgMAACxTeXN0ZW0uTWFuYWdlbWVudC5BdXRvbWF0aW9uLlN3aXRjaFBhcmFtZXRlcgoBkgIAAAkAAAAKCR8DAAAABiADAAAKU3lzdGVtLlVyaQoBkwIAAAkAAAAKCSEDAAAABiIDAAANU3lzdGVtLlN0cmluZwoBlAIAAAkAAAAKCSMDAAAABiQDAAANU3lzdGVtLlN0cmluZwoBlQIAAAkAAAAKCSUDAAAABiYDAAANU3lzdGVtLlN0cmluZwoBlgIAAAkAAAAKCScDAAABBigDAAAsU3lzdGVtLk1hbmFnZW1lbnQuQXV0b21hdGlvbi5Td2l0Y2hQYXJhbWV0ZXIKAZcCAAAJAAAACgkpAwAAAAYqAwAAClN5c3RlbS5VcmkKAZgCAAAJAAAACgkrAwAAAAYsAwAADVN5c3RlbS5TdHJpbmcKAZkCAAAJAAAACgktAwAAAQYuAwAALFN5c3RlbS5NYW5hZ2VtZW50LkF1dG9tYXRpb24uU3dpdGNoUGFyYW1ldGVyCgGaAgAACQAAAAoJLwMAAAAGMAMAAA1TeXN0ZW0uU3RyaW5nCgGbAgAACQAAAAoJMQMAAAAGMgMAAA1TeXN0ZW0uU3RyaW5nCgGcAgAACQAAAAoJMwMAAAEGNAMAACxTeXN0ZW0uTWFuYWdlbWVudC5BdXRvbWF0aW9uLlN3aXRjaFBhcmFtZXRlcgoBnQIAAAkAAAAKCTUDAAABBjYDAAAsU3lzdGVtLk1hbmFnZW1lbnQuQXV0b21hdGlvbi5Td2l0Y2hQYXJhbWV0ZXIKAZ4CAAAJAAAACgk3AwAAAAY4AwAADVN5c3RlbS5TdHJpbmcKAZ8CAAAJAAAACgk5AwAAAAY6AwAADVN5c3RlbS5TdHJpbmcKAaACAAAJAAAACgk7AwAAAQY8AwAALFN5c3RlbS5NYW5hZ2VtZW50LkF1dG9tYXRpb24uU3dpdGNoUGFyYW1ldGVyCgGhAgAAKQAAAAY9AwAAC0lucHV0T2JqZWN0AaMCAAApAAAABj4DAAALTm9FbnVtZXJhdGUBpQIAACkAAAAGPwMAAAtJbnB1dE9iamVjdAGnAgAAKQAAAAZAAwAAC05vRW51bWVyYXRlAakCAAApAAAABkEDAAALSW5wdXRPYmplY3QBqwIAACkAAAAGQgMAAAtOb0VudW1lcmF0ZQGtAgAAKQAAAAZDAwAAC0lucHV0T2JqZWN0Aa8CAAApAAAABkQDAAALTm9FbnVtZXJhdGUBsQIAACkAAAAGRQMAAAROYW1lAbMCAAApAAAABkYDAAAETmFtZQG1AgAAKQAAAAZHAwAADUFwcGxpY2F0aW9uSWQBtwIAACkAAAAGSAMAABVDZXJ0aWZpY2F0ZVRodW1icHJpbnQBuQIAACkAAAAGSQMAAAtFbnZpcm9ubWVudAG7AgAAKQAAAAZKAwAAD0Vudmlyb25tZW50TmFtZQG9AgAAKQAAAAZLAwAAEFNlcnZpY2VQcmluY2lwYWwBvwIAACkAAAAGTAMAAAhUZW5hbnRJZAHBAgAAKQAAAAZNAwAACkNyZWRlbnRpYWwBwwIAACkAAAAGTgMAAAtFbnZpcm9ubWVudAHFAgAAKQAAAAZPAwAAD0Vudmlyb25tZW50TmFtZQHHAgAAKQAAAAZQAwAACFRlbmFudElkAckCAAApAAAABlEDAAALQWNjZXNzVG9rZW4BywIAACkAAAAGUgMAAAlBY2NvdW50SWQBzQIAACkAAAAGUwMAAA1BcHBsaWNhdGlvbklkAc8CAAApAAAABlQDAAAVQ2VydGlmaWNhdGVUaHVtYnByaW50AdECAAApAAAABlUDAAAKQ3JlZGVudGlhbAHTAgAAKQAAAAZWAwAAC0Vudmlyb25tZW50AdUCAAApAAAABlcDAAAPRW52aXJvbm1lbnROYW1lAdcCAAApAAAABlgDAAAQU3Vic2NyaXB0aW9uTmFtZQHZAgAAKQAAAAZZAwAACFRlbmFudElkAdsCAAApAAAABloDAAALQWNjZXNzVG9rZW4B3QIAACkAAAAGWwMAAAlBY2NvdW50SWQB3wIAACkAAAAGXAMAAAtFbnZpcm9ubWVudAHhAgAAKQAAAAZdAwAAD0Vudmlyb25tZW50TmFtZQHjAgAAKQAAAAZeAwAACFRlbmFudElkAeUCAAApAAAABl8DAAAKQ3JlZGVudGlhbAHnAgAAKQAAAAZgAwAAC0Vudmlyb25tZW50AekCAAApAAAABmEDAAAPRW52aXJvbm1lbnROYW1lAesCAAApAAAABmIDAAAQU2VydmljZVByaW5jaXBhbAHtAgAAKQAAAAZjAwAADlN1YnNjcmlwdGlvbklkAe8CAAApAAAABmQDAAAQU3Vic2NyaXB0aW9uTmFtZQHxAgAAKQAAAAZlAwAACFRlbmFudElkAfMCAAApAAAABmYDAAALQWNjZXNzVG9rZW4B9QIAACkAAAAGZwMAAAlBY2NvdW50SWQB9wIAACkAAAAGaAMAAA1BcHBsaWNhdGlvbklkAfkCAAApAAAABmkDAAAVQ2VydGlmaWNhdGVUaHVtYnByaW50AfsCAAApAAAABmoDAAAKQ3JlZGVudGlhbAH9AgAAKQAAAAZrAwAAC0Vudmlyb25tZW50Af8CAAApAAAABmwDAAAPRW52aXJvbm1lbnROYW1lAQEDAAApAAAABm0DAAAOU3Vic2NyaXB0aW9uSWQBAwMAACkAAAAGbgMAAAhUZW5hbnRJZAEFAwAAKQAAAAZvAwAABE5hbWUBBwMAACkAAAAGcAMAABFSZXNvdXJjZUdyb3VwTmFtZQEJAwAAKQAAAAZxAwAABlN0YXR1cwELAwAAKQAAAAZyAwAACE5leHRMaW5rAQ0DAAApAAAABnMDAAARUmVzb3VyY2VHcm91cE5hbWUBDwMAACkAAAAGdAMAAAROYW1lAREDAAApAAAABnUDAAARUmVzb3VyY2VHcm91cE5hbWUBEwMAACkAAAAGdgMAAAZTdGF0dXMBFQMAACkAAAAGdwMAAAhOZXh0TGluawEXAwAAKQAAAAZ4AwAAEVJlc291cmNlR3JvdXBOYW1lARkDAAApAAAABnkDAAAETmFtZQEbAwAAKQAAAAZ6AwAAEVJlc291cmNlR3JvdXBOYW1lAR0DAAApAAAABnsDAAAGU3RhdHVzAR8DAAApAAAABnwDAAAITmV4dExpbmsBIQMAACkAAAAGfQMAABFSZXNvdXJjZUdyb3VwTmFtZQEjAwAAKQAAAAZ+AwAABE5hbWUBJQMAACkAAAAGfwMAABFSZXNvdXJjZUdyb3VwTmFtZQEnAwAAKQAAAAaAAwAABlN0YXR1cwEpAwAAKQAAAAaBAwAACE5leHRMaW5rASsDAAApAAAABoIDAAARUmVzb3VyY2VHcm91cE5hbWUBLQMAACkAAAAGgwMAAAVGb3JjZQEvAwAAKQAAAAaEAwAABE5hbWUBMQMAACkAAAAGhQMAABFSZXNvdXJjZUdyb3VwTmFtZQEzAwAAKQAAAAaGAwAAD1N0YXlQcm92aXNpb25lZAE1AwAAKQAAAAaHAwAABUZvcmNlATcDAAApAAAABogDAAACSWQBOQMAACkAAAAGiQMAAAROYW1lATsDAAApAAAABooDAAAPU3RheVByb3Zpc2lvbmVkCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="} \ No newline at end of file diff --git a/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.psd1 b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.2/StopAzureRMVM.psd1 new file mode 100644 index 0000000..0c73c3b --- /dev/null +++ b/Azure.Automation.Get/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/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.graphrunbook b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.graphrunbook new file mode 100644 index 0000000..7410105 --- /dev/null +++ b/Azure.Automation.Get/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/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.psd1 b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.psd1 new file mode 100644 index 0000000..0f272f2 Binary files /dev/null and b/Azure.Automation.Get/Tests/TestRunbooks/StopAzureRMVM/1.3/StopAzureRMVM.psd1 differ diff --git a/Azure.Automation.Get/Tests/TestRunbooks/TestInvalidRunbookFolder/TestInvalidRunbookFolder.txt b/Azure.Automation.Get/Tests/TestRunbooks/TestInvalidRunbookFolder/TestInvalidRunbookFolder.txt new file mode 100644 index 0000000..e69de29 diff --git a/Azure.Automation.Get/Tests/uiproxy.ps1 b/Azure.Automation.Get/Tests/uiproxy.ps1 new file mode 100644 index 0000000..a3ecaa8 --- /dev/null +++ b/Azure.Automation.Get/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() + } +} + + + 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