###########################################################################
#
# NAME: Create Share on Remote Servers
#
# AUTHOR:  Brady Randolph
#
# COMMENT:
#
# VERSION HISTORY:
# 1.0 12/8/2011 – Initial release
#
###########################################################################
##    Gather list of server names
$utlservrs = Get-Content c:\admin\utl_servers.txt

##    Loop through each server
foreach ($s in $utlservrs) {
   
    ##    Create folder structure
    if (Test-Path -Path "\\$s\d$\admin") { "Admin folder exists"
    New-Item -ItemType directory "\\$s\d$\admin\DAGFileShareWitness"
    }
    else {"Admin folder doesn’t exist"
    New-Item -ItemType directory "\\$s\d$\admin\"
    New-Item -ItemType directory "\\$s\d$\admin\DAGFileShareWitness"
    }
##    Create folder share   
"Creating Share"   
$cshare = [WMIClass]"\\$s\root\cimv2:Win32_Share"
$result = $cshare.create("D:\admin\DAGFileShareWitness","DAGFileShareWitness",0,25,"DAG File Share Witness")
"Return Result: $result.ReturnValue"

"Adding Exchange Trusted Subsystem group to local admins"
    $Domain = ‘mydomain.corp’
    $ADGroup = ‘Exchange Trusted Subsystem’
    ([ADSI]"WinNT://$s/Administrators,group").add("WinNT://$Domain/$ADGroup,group")
}

http://www.itadmintools.com/2011/09/avoiding-token-bloat-in-your-active.html

If your environment is already experiencing this issue, here is an article that explains how to increase your token size within AD.

http://support.microsoft.com/kb/327825

First let’s start with server 2008.  There is the default configuration to “Automatically manage paging file size for all drives.”  This is not available in server 2003 or 2000 and can be found in Win32_ComputerSystem under AutomaticManagedPagefile.  If this is set to true, paging is automatically managed by the OS and the WMI class Win32_PageFileSetting is never created within the OS. 

If it is set to false, you can query Win32_PageFileSetting and gather information from that class which includes initial and max page file sizes.

On server 2003, “Automatically manage page file sizes for all drives” isn’t an option so Win32_PageFileSetting is always available. 

Here are a few links to articles I used:

http://www.planetmps.com/Essentials/Properties/CIMV2/ms_409/Win32/Win32_ComputerSystem.html

http://msdn.microsoft.com/en-us/library/aa394245(v=VS.85).aspx

http://msdn.microsoft.com/en-us/library/aa394246(v=VS.85).aspx

http://msdn.microsoft.com/en-us/library/aa394243(v=VS.85).aspx

The script queries AD and loops through a list of servers and exports data to an Excel document.

##################################################################################
##    This script is used to query every server for their page file configs       
##    1. Connect to the domain using ADSI                                            
##  2. Opens Excel, Add a workbook and deletes default workbooks 2 and 3       
##  3. Builds Array of Values to display in header                                
##  4. Creates Excel Header                                                       
##    5. Loop through each server                                                   
##    6. Collect data on each server                                               
##  7. Exports array to Excel                                                   
##  8. Autofit Excel columns                                                   
##  9. Get Time and Date                                                       
##  10. Save Workbook                                                           
##    Script written by Brady Randolph of RBA Consulting 9/29/2011               
##################################################################################

##  1. Connect to the domain using ADSI
$objDomain = [adsi] (“LDAP://OU=Servers,OU=Company,dc=domain,dc=corp”)
$objSearcher = New-Object System.DirectoryServices.DirectorySearcher
$objSearcher.SearchRoot = $objDomain
$objSearcher.PageSize = 1000
$objSearcher.Filter = ‘(objectClass=Computer)’
$colResults = $objSearcher.FindAll()

##  2. Opens Excel, Add a workbook and deletes default workbooks 2 and 3
    $excel = new-object -comobject excel.application
    $excel.visible = $true
    $workbook = $excel.workbooks.add()
    $workbook.WorkSheets.item(3).delete()
    $workbook.WorkSheets.item(2).delete()
    #Names the worksheet
    $workbook.WorkSheets.item(1).Name = "Servers"
    $sheet = $workbook.WorkSheets.Item("Servers")

    $lineStyle = "microsoft.office.interop.excel.xlLineStyle" -as [type]
    $colorIndex = "microsoft.office.interop.excel.xlColorIndex" -as [type]
    $borderWeight = "microsoft.office.interop.excel.xlBorderWeight" -as [type]
    $chartType = "microsoft.office.interop.excel.xlChartType" -as [type]
   
    ##  3. Builds Array of Values to display in header
    $Borders = @("Server","Pagefile Location","Automanaged","Pagefile Size","RAM Size","PF Initial Size","PF Max Size","System Drive Free Space","Data Drive Free Space")
    $b = 1
   
    ##  4. Creates Excel Header
    Foreach ($item in $Borders) {
        $sheet.cells.item(1,$b).interior.ColorIndex = 1
        $sheet.cells.item(1,$b).font.bold = $true
        $sheet.cells.item(1,$b).font.colorindex = 2
        $sheet.cells.item(1,$b).borders.LineStyle = $lineStyle::xlContinuous
        $sheet.cells.item(1,$b).borders.ColorIndex = $colorIndex::xlColorIndexAutomatic
        #$sheet.cells.item(1,$b).borders.Weight = $borderWeight::xlMedium
        $sheet.cells.item(1,$b) = $item
        $b = $b + 1
    }
    $x = 2
   
##    5. Loop through each server
foreach ($i in $colResults){
    # Set variables to null
    $Server = $null;$PageFileLocation = $null;$SystemManaged = $null;$PageFileSize = $null;$physicalmem = $null;$SysDriveFreeSpace = $null;$DDriveFreeSpace = $null;
    $PFInitial = $null;$PFMax = $null;
    # Set server name to a string
    [string]$server = $i.properties.name
    $OS_Ver = $i.Properties.operatingsystem
    If (($OS_Ver -like "*server*") -and (Test-Connection -ComputerName $server -Count ’2′)){
        $os = get-wmiobject Win32_OperatingSystem -ComputerName $server
        # Verify if server is 2008 R2 because AutomaticManagedPagefile isn’t an property 2000 and 2003
        if ($os.Version -like "6.1*")  {
            $SystemManaged  = Get-WmiObject -ComputerName $server -Class Win32_ComputerSystem | % {$_.AutomaticManagedPagefile}
            if ($SystemManaged -eq "True"){
           
            ##  6. Collect data on each server
                $physicalmem = gwmi -computer $server Win32_ComputerSystem | % {[Math]::round($_.TotalPhysicalMemory/1MB,0)}
                #$SystemManaged  = Get-WmiObject -ComputerName $server -Class Win32_ComputerSystem | % {$_.AutomaticManagedPagefile}
                $PF = gwmi -computer $server Win32_PageFileUsage
                $PageFileLocation = $PF.Name; $PageFileSize = $PF.AllocatedBaseSize
                $LogicalDrives = Get-WmiObject Win32_logicaldisk -ComputerName $server -Filter "DriveType=’3′"
                    Foreach ($drive in $LogicalDrives) {
                        If ($drive.DeviceID -eq ‘c:’){$SysDriveFreeSpace = [Math]::round($drive.FreeSpace / 1GB,0)}
                        elseif ($drive.DeviceID -eq ‘d:’){$DDriveFreeSpace = [Math]::round($drive.FreeSpace / 1GB,0)}
                        elseif ($drive.DeviceID -eq ‘s:’){$SysDriveFreeSpace = [Math]::round($drive.FreeSpace / 1GB,0)}
                        elseif ($drive.DeviceID -eq ‘t:’){$DDriveFreeSpace = [Math]::round($drive.FreeSpace / 1GB,0)}
                    }
                   
                $values = @($Server,$PageFileLocation,$SystemManaged,$PageFileSize,$physicalmem,$PFInitial,$PFMax,$SysDriveFreeSpace,$DDriveFreeSpace)
                            $y = 1
                           
                            ##  7. Exports array to Excel
                            foreach ($val in $values) {
                                #Add Values to row x and column y
                                $sheet.cells.item($x,$y) = $val
                                #increase column by 1
                                $y = $y + 1}
            }
            else{
           
            ##  6. Collect data on each server
                $physicalmem = gwmi -computer $server Win32_ComputerSystem | % {[Math]::round($_.TotalPhysicalMemory/1MB,0)}
                #$SystemManaged  = Get-WmiObject -ComputerName $server -Class Win32_ComputerSystem | % {$_.AutomaticManagedPagefile}
                $PF = gwmi -computer $server Win32_PageFileUsage
                $PageFileLocation = $PF.Name; $PageFileSize = $PF.AllocatedBaseSize
                $LogicalDrives = Get-WmiObject Win32_logicaldisk -ComputerName $server -Filter "DriveType=’3′"
                    Foreach ($drive in $LogicalDrives) {
                        If ($drive.DeviceID -eq ‘c:’){$SysDriveFreeSpace = [Math]::round($drive.FreeSpace / 1GB,0)}
                        elseif ($drive.DeviceID -eq ‘d:’){$DDriveFreeSpace = [Math]::round($drive.FreeSpace / 1GB,0)}
                        elseif ($drive.DeviceID -eq ‘s:’){$SysDriveFreeSpace = [Math]::round($drive.FreeSpace / 1GB,0)}
                        elseif ($drive.DeviceID -eq ‘t:’){$DDriveFreeSpace = [Math]::round($drive.FreeSpace / 1GB,0)}
                    }
                $PageFileSetting = Get-WmiObject Win32_PageFileSetting -ComputerName $server
                $PFInitial = $PageFileSetting.InitialSize; $PFMax = $PageFileSetting.MaximumSize
                $values = @($Server,$PageFileLocation,$SystemManaged,$PageFileSize,$physicalmem,$PFInitial,$PFMax,$SysDriveFreeSpace,$DDriveFreeSpace)
                            $y = 1   
                           
                            ##  7. Exports array to Excel
                            foreach ($val in $values) {
                                #Add Values to row x and column y
                                $sheet.cells.item($x,$y) = $val
                                #increase column by 1
                                $y = $y + 1}
            }
           
            $x = $x + 1
        }
        Else{
       
        ##  6. Collect data on each server
            $physicalmem = gwmi -computer $server Win32_ComputerSystem | % {[Math]::round($_.TotalPhysicalMemory/1MB,0)}
            #$SystemManaged  = Get-WmiObject -ComputerName $server -Class Win32_ComputerSystem | % {$_.AutomaticManagedPagefile}
            $PF = gwmi -computer $server Win32_PageFileUsage
            $PageFileLocation = $PF.Name; $PageFileSize = $PF.AllocatedBaseSize
            $LogicalDrives = Get-WmiObject Win32_logicaldisk -ComputerName $server -Filter "DriveType=’3′"
                Foreach ($drive in $LogicalDrives) {
                    If ($drive.DeviceID -eq ‘c:’){$SysDriveFreeSpace = [Math]::round($drive.FreeSpace / 1GB,0)}
                    elseif ($drive.DeviceID -eq ‘d:’){$DDriveFreeSpace = [Math]::round($drive.FreeSpace / 1GB,0)}
                    elseif ($drive.DeviceID -eq ‘s:’){$SysDriveFreeSpace = [Math]::round($drive.FreeSpace / 1GB,0)}
                    elseif ($drive.DeviceID -eq ‘t:’){$DDriveFreeSpace = [Math]::round($drive.FreeSpace / 1GB,0)}
                }
            $PageFileSetting = Get-WmiObject Win32_PageFileSetting -ComputerName $server
            $PFInitial = $PageFileSetting.InitialSize; $PFMax = $PageFileSetting.MaximumSize
            $values = @($Server,$PageFileLocation,$SystemManaged,$PageFileSize,$physicalmem,$PFInitial,$PFMax,$SysDriveFreeSpace,$DDriveFreeSpace)
                        $y = 1   
                       
                        ##  7. Exports array to Excel
                        foreach ($val in $values) {
                            #Add Values to row x and column y
                            $sheet.cells.item($x,$y) = $val
                            #increase column by 1
                            $y = $y + 1}
            $x = $x + 1
            }
    }
}
## 8.  Autofit Excel columns
$range = $sheet.usedRange
$range.EntireColumn.AutoFit() | out-null

##  9. Get Time and Date
$date = Get-Date -Format "yyyyMMd"
$time = Get-Date -Format "HHms"

##  10. Save Workbook
$strPath = "c:\temp\ServerPageFiles-$date-$time.xls"
$excel.ActiveWorkbook.SaveAs($strPath)
$excel.quit()
spps -n excel

##################################################################################
##    This script will create a domain local group and add the group to a servers   
##    local administrators group                                                   
##    1. Set Variables                                                            
##  2. Gather list of servers                                                   
##  3. Connect to OU                                                           
##  4. Loop through each server                                                    
##  5. Create group name                                                       
##  6. Create group                                                               
##  7. Create sAMAccountName                                                   
##  8. Set Description                                                           
##  9. Set group security descriptor                                           
##  10. Complete group addition                                                   
##  11. Add group to server local administrators group                           
##    Script written by Brady Randolph of RBA Consulting 9/27/2011               
##################################################################################

## 1. Set your variables
$DLSecDescriptor = ‘-2147483644′
$Domain = ‘Domain.corp’
$objOU = ‘LDAP://OU=Domain Local,OU=Security,OU=Groups,OU=Company,DC=domain,DC=corp’

## 2. Gather list of servers
$List = Get-Content -Path c:\temp\servers.txt

## 3. Connect to OU
$objDomain = New-Object System.DirectoryServices.DirectoryEntry $objOU

if ($List -ne "") {
   
    ## 4. Loop through each server
    foreach ($Comp in $List) {
        ## 5. Create group name
        $DomainLocalGroup = "DL_" + $Comp + "_Local_Admins"
        ## 6. Create group
        $objGroup = $objDomain.Create("group","CN=" + $DomainLocalGroup)
        ## 7. Create sAMAccountName
        $objGroup.Put("sAMAccountName", $DomainLocalGroup)
        ## 8. Set Description
        $objGroup.Put("Description","Nested in Local Administrators on $Comp")
        ## 9. Set group security descriptor
        $objGroup.Put("groupType", $DLSecDescriptor )
        ## 10. Complete group addition
        $objGroup.SetInfo()
       
        ## 11. Add group to server local administrators group
        ([ADSI]"WinNT://$Comp/Administrators,group").add("WinNT://$Domain/$DomainLocalGroup,group")
    }
}

#1. Set Variables
$output = ‘c:\temp\ServersLocalAdmins.csv’
## Sets Global Variable for $Now to eliminate repeatable Get-Date queries
$Global:Now = Set-PSBreakpoint -Variable Now -Mode Read -Action {Set-Variable Now (Get-Date) -Option ReadOnly, AllScope -Scope Global -Force}

#2. Connect to the domain using ADSI
$objDomain = [adsi] ("LDAP://OU=Servers,dc=domain,dc=corp")
$objSearcher = New-Object System.DirectoryServices.DirectorySearcher
$objSearcher.SearchRoot = $objDomain
$objSearcher.PageSize = 1000
$objSearcher.Filter = ‘(objectClass=Computer)’
$colResults = $objSearcher.FindAll()
# Creates an empty array
$results = @()

#3. Loop through each server
foreach ($Computer in $colResults) {
    [string]$CompName = $Computer.Properties.name
    #$CompName = $Computer
    $OS_Ver = $Computer.Properties.operatingsystem
    #$OS_Ver = Get-WmiObject -ComputerName $CompName -Class Win32_OperatingSystem | Select-Object {$_.caption}
    #Setting Members to null so values aren’t carried over to next computer
    $members = $null
    If ($OS_Ver -like "*server*"){
        If (Test-Connection -ComputerName $CompName -Count ’2′){
        Out-Host -InputObject "$Now $CompName is Online"
         $group =[ADSI]"WinNT://$CompName/Administrators"
        #4. Gather every member of the Administrators group
        $members = $group.Members() | foreach {$_.GetType().InvokeMember("Name", ‘GetProperty’, $null, $_, $null) }
        #$localmembers | foreach {$_.GetType().InvokeMember("AdsPath","GetProperty",$null,$_,$null)}
        #5. Add those values to an array
        $results += New-Object PsObject -Property @{
        Server = $CompName
        Members = $members -join ";"}
       
          }
   
      Else { Write-Host "$Now $CompName is Offline"}
    }
}
#6. Export array to a CSV
$results | Export-Csv $Output -NoTypeInformation

[system.Reflection.Assembly]::LoadWithPartialName(‘System.Windows.Forms’) | Out-Null

$balloon = New-Object System.Windows.Forms.NotifyIcon

$path = Get-Process -id $pid | Select-Object -ExpandProperty Path

$icon = [System.Drawing.Icon]::ExtractAssociatedIcon($path)

$balloon.Icon = $icon

$balloon.BalloonTipIcon = ‘Info’

$balloon.BalloonTipText = ‘Completed Operation’

$balloon.BalloonTipTitle = ‘Done’

$balloon.Visible = $true

$balloon.ShowBalloonTip(10000)

Note that the code uses the icon of your PowerShell application inside the tray area so the user can associate the message with the application that produced it.

I received this code from PowerShell.com’s PowerTip of the Day.

http://www.techrepublic.com/blog/datacenter/calculate-iops-in-a-storage-array/2182

$cutoff = (Get-Date) – (New-TimeSpan -Days 30)

$before = (Get-ChildItem $env:temp | Measure-Object Length -Sum).Sum

Get-ChildItem $env:temp |                           

  Where-Object { $_.Length -ne $null } |            

  Where-Object { $_.LastWriteTime -lt $cutoff } |   

  Remove-Item -Force -ErrorAction SilentlyContinue -WhatIf  # REMOVE -whatif to ENABLE DELETING!

$after = (Get-ChildItem $env:temp | Measure-Object Length -Sum).Sum

‘Freed {0:0.00} MB disk space’ -f (($before-$after)/1MB)

Since deleting stuff is always risky, we left a -WhatIf in the code so you can check that you are actually deleting your temp folder and not anything else (due to a typo for example). Once you are comfortable, remove –WhatIf to invoke the cleanup process. You may be surprised how much garbage can be removed.

Thanks to PowerShell.com for providing this script.

net stop w32time
w32tm /unregister
w32tm /register
net start w32time
w32tm /resync

http://www.minasi.com/newsletters/nws1109.htm