insang Git - wevape-lu1_pos.git/blob

   1 data LocalizedData
   2 {
   3     # culture="en-US"
   4     ConvertFrom-StringData @'
   5 SetTargetResourceInstallwhatIfMessage=Trying to install feature {0}
   6 SetTargetResourceUnInstallwhatIfMessage=Trying to Uninstall feature {0}
   7 FeatureNotFoundError=The requested feature {0} is not found on the target machine.
   8 FeatureDiscoveryFailureError=Failure to get the requested feature {0} information from the target machine. Wildcard pattern is not supported in the feature name.
   9 FeatureInstallationFailureError=Failure to successfully install the feature {0} .
  10 FeatureUnInstallationFailureError=Failure to successfully Unintstall the feature {0} .
  11 QueryFeature=Querying for feature {0} using Server Manager cmdlet Get-WindowsFeature.
  12 InstallFeature=Trying to install feature {0} using Server Manager cmdlet Add-WindowsFeature.
  13 UninstallFeature=Trying to Uninstall feature {0} using Server Manager cmdlet Remove-WindowsFeature.
  14 RestartNeeded=The Target machine needs to be restarted.
  15 GetTargetResourceStartVerboseMessage=Begin executing Get functionality on the {0} feature.
  16 GetTargetResourceEndVerboseMessage=End executing Get functionality on the {0} feature.
  17 SetTargetResourceStartVerboseMessage=Begin executing Set functionality on the {0} feature.
  18 SetTargetResourceEndVerboseMessage=End executing Set functionality on the {0} feature.
  19 TestTargetResourceStartVerboseMessage=Begin executing Test functionality on the {0} feature.
  20 TestTargetResourceEndVerboseMessage=End executing Test functionality on the {0} feature.
  21 ServerManagerModuleNotFoundDebugMessage=ServerManager module is not installed on the machine.
  22 SkuNotSupported=Installing roles and features using PowerShell Desired State Configuration is supported only on Server SKU's. It is not supported on Client SKU.
  23 SourcePropertyNotSupportedDebugMessage=Source property in MSFT_RoleResource is not supported on this operating system and it was ignored.
  24 EnableServerManagerPSHCmdletsFeature=Windows Server 2008R2 Core operating system detected: ServerManager-PSH-Cmdlets feature has been enabled.
  25 UninstallSuccess=Successfully uninstalled the feature {0}.
  26 InstallSuccess=Successfully installed the feature {0}.
  27 '@
  28 }
  29
  30 Import-LocalizedData  LocalizedData -filename MSFT_RoleResourceStrings
  31
  32 # The Get-TargetResource cmdlet is used to fetch the status of role or feature on the target machine.
  33 # It gives the feature info of the requested role/feature on the target machine.
  34 function Get-TargetResource
  35 {
  36      param
  37      (
  38         [parameter(Mandatory = $true)]
  39         [ValidateNotNullOrEmpty()]
  40         [string]
  41         $Name,
  42
  43         [Parameter(Mandatory=$false)]
  44         [System.Management.Automation.PSCredential]
  45         $Credential
  46      )
  47
  48         $getTargetResourceResult = $null;
  49
  50         $getTargetResourceStartVerboseMessage = $($LocalizedData.GetTargetResourceStartVerboseMessage) -f ${Name} ;
  51         Write-Debug -Message $getTargetResourceStartVerboseMessage;
  52
  53         ValidatePrerequisites ;
  54
  55         $qyeryFeatureMessage = $($LocalizedData.QueryFeature) -f ${Name} ;
  56         Write-Debug -Message $qyeryFeatureMessage;
  57
  58         $isR2Sp1 = IsWinServer2008R2SP1;
  59         if($isR2Sp1 -and $psboundparameters.ContainsKey("Credential"))
  60         {
  61             $parameters = $psboundparameters.Remove("Credential");
  62             $feature = Invoke-Command -ScriptBlock { Get-WindowsFeature @using:psboundparameters } -ComputerName . -Credential $Credential -ErrorVariable ev
  63             $psboundparameters.Add("Credential", $Credential);
  64         }
  65         else
  66         {
  67             $feature = Get-WindowsFeature @psboundparameters -ErrorVariable ev
  68         }
  69
  70         if($null -eq $ev -or $ev.Count -eq 0)
  71         {
  72             $foundError = $false;
  73
  74             ValidateFeature $feature $Name;
  75
  76             # If a feature does not contain SubFeature then $includeAllSubFeature would be set to $false.
  77             # If a feature contains one or more subfeatures then $includeAllSubFeature would be set to
  78             # $true only if all the subfeatures are installed, or else $includeAllSubFeature would be set to $false.
  79             $includeAllSubFeature = $true;
  80
  81             if($feature.SubFeatures.Count -eq 0)
  82             {
  83                 $includeAllSubFeature = $false;
  84             }
  85             else
  86             {
  87                 foreach($currentSubFeature in $feature.SubFeatures)
  88                 {
  89                    if($foundError -eq $false)
  90                    {
  91                         $parameters = $psboundparameters.Remove("Name");
  92                         $psboundparameters.Add("Name", $currentSubFeature);
  93
  94                         $isR2Sp1 = IsWinServer2008R2SP1;
  95                         if($isR2Sp1 -and $psboundparameters.ContainsKey("Credential"))
  96                         {
  97                             $parameters = $psboundparameters.Remove("Credential");
  98                             $subFeature = Invoke-Command -ScriptBlock { Get-WindowsFeature @using:psboundparameters } -ComputerName . -Credential $Credential -ErrorVariable errorVar
  99                             $psboundparameters.Add("Credential", $Credential);
 100                         }
 101                         else
 102                         {
 103                             $subFeature = Get-WindowsFeature @psboundparameters -ErrorVariable errorVar
 104                         }
 105
 106                         if($null -eq $errorVar -or $errorVar.Count -eq 0)
 107                         {
 108                             ValidateFeature $subFeature $currentSubFeature;
 109
 110                             if(!$subFeature.Installed)
 111                             {
 112                                 $includeAllSubFeature = $false;
 113                                 break;
 114                             }
 115                         }
 116                         else
 117                         {
 118                             $foundError = $true;;
 119                         }
 120                     }
 121                 }
 122             }
 123
 124             if($foundError -eq $false)
 125             {
 126                 if($feature.Installed)
 127                 {
 128                     $ensureResult = "Present";
 129                 }
 130                 else
 131                 {
 132                     $ensureResult = "Absent";
 133                 }
 134
 135                 # Add all feature properties to the hash table
 136                 $getTargetResourceResult = @{
 137                                                 Name = $feature.Name;
 138                                                 DisplayName = $feature.DisplayName;
 139                                                 Ensure = $ensureResult;
 140                                                 IncludeAllSubFeature = $includeAllSubFeature;
 141                                             }
 142
 143                 $getTargetResourceEndVerboseMessage = $($LocalizedData.GetTargetResourceEndVerboseMessage) -f ${Name} ;
 144                 Write-Debug -Message $getTargetResourceEndVerboseMessage;
 145
 146                 $getTargetResourceResult;
 147             }
 148         }
 149 }
 150
 151
 152 # The Set-TargetResource cmdlet is used to install or uninstall a role on the target machine.
 153 # It also supports installing & uninstalling the role or feature specific subfeatures.
 154 function Set-TargetResource
 155 {
 156     [CmdletBinding(SupportsShouldProcess=$true, DefaultParameterSetName = "FeatureName")]
 157
 158      param
 159      (
 160         [parameter(Mandatory=$true, ParameterSetName = "FeatureName")]
 161         [ValidateNotNullOrEmpty()]
 162         [string]
 163         $Name,
 164
 165         [parameter()]
 166         [ValidateSet("Present", "Absent")]
 167         [string]
 168         $Ensure = "Present",
 169
 170         [parameter()]
 171         [ValidateNotNullOrEmpty()]
 172         [string]
 173         $Source,
 174
 175         [parameter()]
 176         [switch]
 177         $IncludeAllSubFeature,
 178
 179         [Parameter(Mandatory=$false)]
 180         [System.Management.Automation.PSCredential]
 181         $Credential,
 182
 183         [ValidateNotNullOrEmpty()]
 184         [string]
 185         $LogPath
 186      )
 187
 188     $getTargetResourceResult = $null;
 189
 190     $inputParameter = $null;
 191
 192     $setTargetResourceStartVerboseMessage = $($LocalizedData.SetTargetResourceStartVerboseMessage) -f ${Name} ;
 193     Write-Debug -Message $setTargetResourceStartVerboseMessage;
 194
 195     ValidatePrerequisites ;
 196
 197     # -Source Parameter is not applicable to Windows Server 2008 R2 SP1. Hence removing it.
 198     # all role/feature spcific binaries are avaliable inboc on Windows Server 2008 R2 SP1, hence
 199     # -Source is not supported on Windows Server 2008 R2 SP1.
 200     $isR2Sp1 = IsWinServer2008R2SP1;
 201     if($isR2Sp1 -and $psboundparameters.ContainsKey("Source"))
 202     {
 203         $sourcePropertyNotSupportedDebugMessage = $($LocalizedData.SourcePropertyNotSupportedDebugMessage) ;
 204         Write-Debug -Message $sourcePropertyNotSupportedDebugMessage;
 205
 206         $parameters = $psboundparameters.Remove("Source");
 207     }
 208
 209
 210     if($Ensure -eq "Present")
 211     {
 212         $parameters = $psboundparameters.Remove("Ensure");
 213
 214         $installFeatureMessage = $($LocalizedData.InstallFeature) -f ${Name} ;
 215         Write-Debug -Message $installFeatureMessage;
 216
 217         $isR2Sp1 = IsWinServer2008R2SP1;
 218         if($isR2Sp1 -and $psboundparameters.ContainsKey("Credential"))
 219         {
 220             $parameters = $psboundparameters.Remove("Credential");
 221             $feature = Invoke-Command -ScriptBlock { Add-WindowsFeature @using:psboundparameters } -ComputerName . -Credential $Credential -ErrorVariable ev
 222             $psboundparameters.Add("Credential", $Credential);
 223         }
 224         else
 225         {
 226             $feature = Add-WindowsFeature @psboundparameters -ErrorVariable ev
 227         }
 228
 229         if($feature -ne $null -and $feature.Success -eq $true)
 230         {
 231             Write-Verbose ($LocalizedData.InstallSuccess -f $Name)
 232
 233             # Check if reboot is required, if so notify CA.
 234             if($feature.RestartNeeded -eq "Yes")
 235             {
 236                 $restartNeededMessage = $($LocalizedData.RestartNeeded);
 237                 Write-Verbose -Message $restartNeededMessage;
 238
 239                 $global:DSCMachineStatus = 1;
 240             }
 241         }
 242         else
 243         {
 244             # Add-WindowsFeature cmdlet falied to successfully install the requested feature.
 245             # If there are errors from the Add-WindowsFeature cmdlet. We surface those errors.
 246             # If Add-WindwosFeature cmdlet does not surface any errors. Then the provider throws a
 247             # terminating error.
 248             if($null -eq $ev -or $ev.Count -eq 0)
 249             {
 250                 $errorId = "FeatureInstallationFailure";
 251                 $errorCategory = [System.Management.Automation.ErrorCategory]::InvalidOperation;
 252                 $errorMessage = $($LocalizedData.FeatureInstallationFailureError) -f ${Name} ;
 253                 $exception = New-Object System.InvalidOperationException $errorMessage ;
 254                 $errorRecord = New-Object System.Management.Automation.ErrorRecord $exception, $errorId, $errorCategory, $null
 255
 256                 $PSCmdlet.ThrowTerminatingError($errorRecord);
 257             }
 258         }
 259     }
 260     else
 261     {
 262         $parameters = $psboundparameters.Remove("Ensure");
 263         $parameters = $psboundparameters.Remove("IncludeAllSubFeature");
 264         $parameters = $psboundparameters.Remove("Source");
 265
 266         $uninstallFeatureMessage = $($LocalizedData.UninstallFeature) -f ${Name} ;
 267         Write-Debug -Message $uninstallFeatureMessage;
 268
 269         $isR2Sp1 = IsWinServer2008R2SP1;
 270         if($isR2Sp1 -and $psboundparameters.ContainsKey("Credential"))
 271         {
 272             $parameters = $psboundparameters.Remove("Credential");
 273             $feature = Invoke-Command -ScriptBlock { Remove-WindowsFeature @using:psboundparameters } -ComputerName . -Credential $Credential -ErrorVariable ev
 274             $psboundparameters.Add("Credential", $Credential);
 275         }
 276         else
 277         {
 278             $feature = Remove-WindowsFeature @psboundparameters -ErrorVariable ev
 279         }
 280
 281         if($feature -ne $null -and $feature.Success -eq $true)
 282         {
 283             Write-Verbose ($LocalizedData.UninstallSuccess -f $Name)
 284
 285             # Check if reboot is required, if so notify CA.
 286             if($feature.RestartNeeded -eq "Yes")
 287             {
 288                 $restartNeededMessage = $($LocalizedData.RestartNeeded);
 289                 Write-Verbose -Message $restartNeededMessage;
 290
 291                 $global:DSCMachineStatus = 1;
 292             }
 293         }
 294         else
 295         {
 296             # Remove-WindowsFeature cmdlet falied to successfully Uninstall the requested feature.
 297             # If there are errors from the Remove-WindowsFeature cmdlet. We surface those errors.
 298             # If Remove-WindwosFeature cmdlet does not surface any errors. Then the provider throws a
 299             # terminating error.
 300             if($null -eq $ev -or $ev.Count -eq 0)
 301             {
 302                 $errorId = "FeatureUnInstallationFailure";
 303                 $errorCategory = [System.Management.Automation.ErrorCategory]::InvalidOperation;
 304                 $errorMessage = $($LocalizedData.FeatureUnInstallationFailureError) -f ${Name} ;
 305                 $exception = New-Object System.InvalidOperationException $errorMessage ;
 306                 $errorRecord = New-Object System.Management.Automation.ErrorRecord $exception, $errorId, $errorCategory, $null
 307
 308                 $PSCmdlet.ThrowTerminatingError($errorRecord);
 309             }
 310         }
 311     }
 312
 313     $setTargetResourceEndVerboseMessage = $($LocalizedData.SetTargetResourceEndVerboseMessage) -f ${Name} ;
 314     Write-Debug -Message $setTargetResourceEndVerboseMessage;
 315 }
 316
 317 # The Test-TargetResource cmdlet is used to validate if the role or feature is in a state as expected in the instance document.
 318 function Test-TargetResource
 319 {
 320     param
 321     (
 322         [parameter(Mandatory = $true)]
 323         [ValidateNotNullOrEmpty()]
 324         [string]
 325         $Name,
 326
 327         [parameter()]
 328         [ValidateSet("Present", "Absent")]
 329         [string]
 330         $Ensure = "Present",
 331
 332         [parameter()]
 333         [ValidateNotNullOrEmpty()]
 334         [string]
 335         $Source,
 336
 337         [parameter()]
 338         [switch]
 339         $IncludeAllSubFeature,
 340
 341         [Parameter()]
 342         [System.Management.Automation.PSCredential]
 343         $Credential,
 344
 345         [ValidateNotNullOrEmpty()]
 346         [string]
 347         $LogPath
 348
 349     )
 350
 351         $testTargetResourceStartVerboseMessage = $($LocalizedData.TestTargetResourceStartVerboseMessage) -f ${Name} ;
 352         Write-Debug -Message $testTargetResourceStartVerboseMessage;
 353
 354         ValidatePrerequisites ;
 355
 356         $testTargetResourceResult = $false;
 357
 358         $parameters = $psboundparameters.Remove("Ensure");
 359         $parameters = $psboundparameters.Remove("IncludeAllSubFeature");
 360         $parameters = $psboundparameters.Remove("Source");
 361
 362         $qyeryFeatureMessage = $($LocalizedData.QueryFeature) -f ${Name} ;
 363         Write-Debug -Message $qyeryFeatureMessage;
 364
 365         $isR2Sp1 = IsWinServer2008R2SP1;
 366         if($isR2Sp1 -and $psboundparameters.ContainsKey("Credential"))
 367         {
 368             $parameters = $psboundparameters.Remove("Credential");
 369             $feature = Invoke-Command -ScriptBlock { Get-WindowsFeature @using:psboundparameters } -ComputerName . -Credential $Credential -ErrorVariable ev
 370             $psboundparameters.Add("Credential", $Credential);
 371         }
 372         else
 373         {
 374             $feature = Get-WindowsFeature @psboundparameters -ErrorVariable ev
 375         }
 376
 377
 378         if($null -eq $ev -or $ev.Count -eq 0)
 379         {
 380             ValidateFeature $feature $Name;
 381
 382
 383             # Check if the feature is in the requested Ensure state.
 384             # If so then check if then check if the subfeature is in the requested Ensure state.
 385             if(($Ensure -eq "Present" -and $feature.Installed -eq $true) -or
 386                 ($Ensure -eq "Absent" -and $feature.Installed -eq $false))
 387             {
 388                 $testTargetResourceResult = $true;
 389
 390                 # IncludeAllSubFeature is set to $true, so we need to make
 391                 # sure that all Sub Features are alsi installed.
 392                 if($IncludeAllSubFeature)
 393                 {
 394
 395                     foreach($currentSubFeature in $feature.SubFeatures)
 396                     {
 397                         $parameters = $psboundparameters.Remove("Name");
 398                         $parameters = $psboundparameters.Remove("Ensure");
 399                         $parameters = $psboundparameters.Remove("IncludeAllSubFeature");
 400                         $parameters = $psboundparameters.Remove("Source");
 401                         $psboundparameters.Add("Name", $currentSubFeature);
 402
 403                         $isR2Sp1 = IsWinServer2008R2SP1;
 404                         if($isR2Sp1 -and $psboundparameters.ContainsKey("Credential"))
 405                         {
 406                             $parameters = $psboundparameters.Remove("Credential");
 407                             $subFeature = Invoke-Command -ScriptBlock { Get-WindowsFeature @using:psboundparameters } -ComputerName . -Credential $Credential -ErrorVariable errorVar
 408                             $psboundparameters.Add("Credential", $Credential);
 409                         }
 410                         else
 411                         {
 412                             $subFeature = Get-WindowsFeature @psboundparameters -ErrorVariable errorVar
 413                         }
 414
 415
 416                         if($null -eq $errorVar -or $errorVar.Count -eq 0)
 417                         {
 418                             ValidateFeature $subFeature $currentSubFeature;
 419
 420                             if(!$subFeature.Installed)
 421                             {
 422                                 $testTargetResourceResult = $false;
 423                                 break;
 424                             }
 425                         }
 426                     }
 427                 }
 428             }
 429
 430             $testTargetResourceEndVerboseMessage = $($LocalizedData.TestTargetResourceEndVerboseMessage) -f ${Name} ;
 431             Write-Debug -Message $testTargetResourceEndVerboseMessage;
 432
 433             $testTargetResourceResult;
 434         }
 435 }
 436
 437
 438 # ValidateFeature is a helper function used to validate the results of SM+ cmdlets
 439 # Get-Windowsfeature for the user supplied feature name.
 440 function ValidateFeature
 441 {
 442     param
 443     (
 444         [object] $feature,
 445
 446         [string] $Name
 447     )
 448
 449     if($null -eq $feature)
 450     {
 451         $errorId = "FeatureNotFound";
 452         $errorCategory = [System.Management.Automation.ErrorCategory]::InvalidOperation
 453         $errorMessage = $($LocalizedData.FeatureNotFoundError) -f ${Name}
 454         $exception = New-Object System.InvalidOperationException $errorMessage
 455         $errorRecord = New-Object System.Management.Automation.ErrorRecord $exception, $errorId, $errorCategory, $null
 456
 457         $PSCmdlet.ThrowTerminatingError($errorRecord);
 458     }
 459
 460     # WildCard pattern is not supported by the role provider.
 461     # Hence we restrict user to request only one feature information in a single request.
 462     if($feature.Count -gt 1)
 463     {
 464         $errorId = "FeatureDiscoveryFailure";
 465         $errorCategory = [System.Management.Automation.ErrorCategory]::InvalidResult
 466         $errorMessage = $($LocalizedData.FeatureDiscoveryFailureError) -f ${Name}
 467         $exception = New-Object System.InvalidOperationException $errorMessage
 468         $errorRecord = New-Object System.Management.Automation.ErrorRecord $exception, $errorId, $errorCategory, $null
 469
 470         $PSCmdlet.ThrowTerminatingError($errorRecord);
 471     }
 472 }
 473
 474 # ValidatePrerequisites is a helper function used to validate if the MSFT_RoleResource is supported on the target machine.
 475 # MSFT_RoleResource is supported only on Server SKU's. MSFT_RoleResource depend on ServerManagerModule which is avaliable
 476 # only on Server SKU's.
 477 function ValidatePrerequisites
 478 {
 479     param
 480     (
 481     )
 482
 483     #Enable ServerManager-PSH-Cmdlets feature if os is WS2008R2 Core.
 484     $datacenterServerCore = 12
 485     $standardServerCore = 13
 486     $EnterpriseServerCore = 14
 487
 488     $operatingSystem = Get-WmiObject -Class Win32_operatingsystem
 489     if($operatingSystem.Version.StartsWith('6.1.') -and
 490         (($operatingSystem.OperatingSystemSKU -eq $datacenterServerCore) -or ($operatingSystem.OperatingSystemSKU -eq $standardServerCore) -or ($operatingSystem.OperatingSystemSKU -eq $EnterpriseServerCore)))
 491     {
 492         Write-Verbose -Message $($LocalizedData.EnableServerManagerPSHCmdletsFeature)
 493
 494         # Update:ServerManager-PSH-Cmdlets has a depndency on Powershell 2 update: MicrosoftWindowsPowerShell
 495         # Hence enabling MicrosoftWindowsPowerShell.
 496         dism /online /enable-feature /FeatureName:MicrosoftWindowsPowerShell | Out-Null
 497         dism /online /enable-feature /FeatureName:ServerManager-PSH-Cmdlets | Out-Null
 498     }
 499
 500     if(Import-Module ServerManager -PassThru -Verbose:$false -ErrorAction Ignore)
 501     {
 502     }
 503     else
 504     {
 505
 506         $serverManagerModuleNotFoundDebugMessage = $($LocalizedData.ServerManagerModuleNotFoundDebugMessage);
 507         Write-Debug -Message $serverManagerModuleNotFoundDebugMessage;
 508
 509         $errorId = "SkuNotSupported";
 510         $errorCategory = [System.Management.Automation.ErrorCategory]::InvalidOperation
 511         $errorMessage = $($LocalizedData.SkuNotSupported)
 512         $exception = New-Object System.InvalidOperationException $errorMessage
 513         $errorRecord = New-Object System.Management.Automation.ErrorRecord $exception, $errorId, $errorCategory, $null
 514
 515         $PSCmdlet.ThrowTerminatingError($errorRecord);
 516     }
 517 }
 518
 519
 520 # IsWinServer2008R2SP1 is a helper function to detect if the target machine is a Win 2008 R2 SP1.
 521 function IsWinServer2008R2SP1
 522 {
 523     param
 524     (
 525     )
 526
 527     # We are already checking for the Presence of ServerManager module before using this helper function.
 528     # Hence checking for the version shoudl be good enough to confirm that the target machine is
 529     # Windows Server 2008 R2 machine.
 530     if([Environment]::OSVersion.Version.ToString().Contains("6.1."))
 531     {
 532         return $true;
 533     }
 534
 535     return $false;
 536 }
 537
 538 Export-ModuleMember -function Get-TargetResource, Set-TargetResource, Test-TargetResource