SharePoint Automation Gary Lapointe – Founding Partner, Aptillon, Inc.

   1: [xml]$config = Get-Content $settingsFile

   2: $svcConfig = $config.Services.EnterpriseSearchService

   1: $searchSvc = Get-SPEnterpriseSearchServiceInstance -Local

   2: if ($searchSvc -eq $null) {

   3:     throw "Unable to retrieve search service."

   4: }

   1: Write-Host "Getting $($svcConfig.Account) account for search service..."

   2: $searchSvcManagedAccount = (Get-SPManagedAccount -Identity $svcConfig.Account -ErrorVariable err -ErrorAction SilentlyContinue)

   3: if ($err) {

   4:     $searchSvcAccount = Get-Credential $svcConfig.Account

   5:     $searchSvcManagedAccount = New-SPManagedAccount -Credential $searchSvcAccount

   6: }

   1: Get-SPEnterpriseSearchService | Set-SPEnterpriseSearchService `

   2:     -ServiceAccount $searchSvcManagedAccount.Username `

   3:     -ServicePassword $searchSvcManagedAccount.SecurePassword `

   4:     -ContactEmail $svcConfig.ContactEmail `

   5:     -ConnectionTimeout $svcConfig.ConnectionTimeout `

   6:     -AcknowledgementTimeout $svcConfig.AcknowledgementTimeout `

   7:     -ProxyType $svcConfig.ProxyType `

   8:     -IgnoreSSLWarnings $svcConfig.IgnoreSSLWarnings `

   9:     -InternetIdentity $svcConfig.InternetIdentity `

  10:     -PerformanceLevel $svcConfig.PerformanceLevel

  11:  

  12: Write-Host "Setting default index location on search service..."

  13: $searchSvc | Set-SPEnterpriseSearchServiceInstance -DefaultIndexLocation $svcConfig.IndexLocation -ErrorAction SilentlyContinue -ErrorVariable err

   1: $svcConfig.EnterpriseSearchServiceApplications.EnterpriseSearchServiceApplication | ForEach-Object {

   1: $appConfig = $_

   2:  

   3: #Try and get the application pool if it already exists

   4: $pool = Get-ApplicationPool $appConfig.ApplicationPool

   5: $adminPool = Get-ApplicationPool $appConfig.AdminComponent.ApplicationPool

   1: $searchApp = Get-SPEnterpriseSearchServiceApplication -Identity $appConfig.Name -ErrorAction SilentlyContinue

   2: if ($searchApp -eq $null) {

   3:     Write-Host "Creating enterprise search service application..."

   4:     $searchApp = New-SPEnterpriseSearchServiceApplication -Name $appConfig.Name `

   5:         -DatabaseServer $appConfig.DatabaseServer `

   6:         -DatabaseName $appConfig.DatabaseName `

   7:         -FailoverDatabaseServer $appConfig.FailoverDatabaseServer `

   8:         -ApplicationPool $pool `

   9:         -AdminApplicationPool $adminPool `

  10:         -Partitioned:([bool]::Parse($appConfig.Partitioned)) `

  11:         -SearchApplicationType $appConfig.SearchServiceApplicationType

  12: } else {

  13:     Write-Host "Enterprise search service application already exists, skipping creation."

  14: }

   1: $proxy = Get-SPEnterpriseSearchServiceApplicationProxy -Identity $appConfig.Proxy.Name -ErrorAction SilentlyContinue

   2: if ($proxy -eq $null) {

   3:     Write-Host "Creating enterprise search service application proxy..."

   4:     $proxy = New-SPEnterpriseSearchServiceApplicationProxy -Name $appConfig.Proxy.Name -SearchApplication $searchApp -Partitioned:([bool]::Parse($appConfig.Proxy.Partitioned))

   5: } else {

   6:     Write-Host "Enterprise search service application proxy already exists, skipping creation."

   7: }

   8: if ($proxy.Status -ne "Online") {

   9:     $proxy.Status = "Online"

  10:     $proxy.Update()

  11: }

  12: $proxy | Set-ProxyGroupsMembership $appConfig.Proxy.ProxyGroup

   1: $installCrawlSvc = (($appConfig.CrawlServers.Server | where {$_.Name -eq $env:computername}) -ne $null)

   2: $installQuerySvc = (($appConfig.QueryServers.Server | where {$_.Name -eq $env:computername}) -ne $null)

   3: $installAdminCmpnt = (($appConfig.AdminComponent.Server | where {$_.Name -eq $env:computername}) -ne $null)

   4: $installSyncSvc = (($appConfig.SearchQueryAndSiteSettingsServers.Server | where {$_.Name -eq $env:computername}) -ne $null)

   1: if ($searchSvc.Status -ne "Online" -and ($installCrawlSvc -or $installQuerySvc)) {

   2:     $searchSvc | Start-SPEnterpriseSearchServiceInstance

   3: }

   1: if ($installAdminCmpnt) {

   2:     Write-Host "Setting administration component..."

   3:     Set-SPEnterpriseSearchAdministrationComponent -SearchApplication $searchApp -SearchServiceInstance $searchSvc

   4: }

   1: $crawlTopology = Get-SPEnterpriseSearchCrawlTopology -SearchApplication $searchApp | where {$_.CrawlComponents.Count -gt 0 -or $_.State -eq "Inactive"}

   2: if ($crawlTopology -eq $null) {

   3:     Write-Host "Creating new crawl topology..."

   4:     $crawlTopology = $searchApp | New-SPEnterpriseSearchCrawlTopology

   5: } else {

   6:     Write-Host "A crawl topology with crawl components already exists, skipping crawl topology creation."

   7: }

   8:  

   9: if ($installCrawlSvc) {

  10:     $crawlComponent = $crawlTopology.CrawlComponents | where {$_.ServerName -eq $env:ComputerName}

  11:     if ($crawlTopology.CrawlComponents.Count -eq 0 -and $crawlComponent -eq $null) {

  12:         $crawlStore = $searchApp.CrawlStores | where {$_.Name -eq "$($appConfig.DatabaseName)_CrawlStore"}

  13:         Write-Host "Creating new crawl component..."

  14:         $crawlComponent = New-SPEnterpriseSearchCrawlComponent -SearchServiceInstance $searchSvc -SearchApplication $searchApp -CrawlTopology $crawlTopology -CrawlDatabase $crawlStore.Id.ToString() -IndexLocation $appConfig.IndexLocation

  15:     } else {

  16:         Write-Host "Crawl component already exist, skipping crawl component creation."

  17:     }

  18: }

   1: $queryTopology = Get-SPEnterpriseSearchQueryTopology -SearchApplication $searchApp | where {$_.QueryComponents.Count -gt 0 -or $_.State -eq "Inactive"}

   2: if ($queryTopology -eq $null) {

   3:     Write-Host "Creating new query topology..."

   4:     $queryTopology = $searchApp | New-SPEnterpriseSearchQueryTopology -Partitions $appConfig.Partitions

   5: } else {

   6:     Write-Host "A query topology with query components already exists, skipping query topology creation."

   7: }

   8: if ($installQuerySvc) {

   9:     $queryComponent = $queryTopology.QueryComponents | where {$_.ServerName -eq $env:ComputerName}

  10:     if ($queryTopology.QueryComponents.Count -eq 0 -and $queryComponent -eq $null) {

  11:         $partition = ($queryTopology | Get-SPEnterpriseSearchIndexPartition)

  12:         Write-Host "Creating new query component..."

  13:         $queryComponent = New-SPEnterpriseSearchQueryComponent -IndexPartition $partition -QueryTopology $queryTopology -SearchServiceInstance $searchSvc

  14:         Write-Host "Setting index partition and property store database..."

  15:         $propertyStore = $searchApp.PropertyStores | where {$_.Name -eq "$($appConfig.DatabaseName)_PropertyStore"}

  16:         $partition | Set-SPEnterpriseSearchIndexPartition -PropertyDatabase $propertyStore.Id.ToString()

  17:     } else {

  18:         Write-Host "Query component already exist, skipping query component creation."

  19:     }

  20: }

   1: if ($installSyncSvc) {

   2:     Start-SPServiceInstance -Identity "Search Query and Site Settings Service"

   3: }

   1: #Don't activate until we've added all components

   2: $allCrawlServersDone = $true

   3: $appConfig.CrawlServers.Server | ForEach-Object {

   4:     $server = $_.Name

   5:     $top = $crawlTopology.CrawlComponents | where {$_.ServerName -eq $server}

   6:     if ($top -eq $null) { $allCrawlServersDone = $false }

   7: }

   8:  

   9: if ($allCrawlServersDone -and $crawlTopology.State -ne "Active") {

  10:     Write-Host "Setting new crawl topology to active..."

  11:     $crawlTopology | Set-SPEnterpriseSearchCrawlTopology -Active -Confirm:$false

  12:     

  13:     Write-Host -ForegroundColor Yellow "Waiting on Crawl Components to provision..."

  14:     while ($true) {

  15:         $ct = Get-SPEnterpriseSearchCrawlTopology -Identity $crawlTopology -SearchApplication $searchApp

  16:         $state = $ct.CrawlComponents | where {$_.State -ne "Ready"}

  17:         if ($ct.State -eq "Active" -and $state -eq $null) {

  18:             break

  19:         }

  20:         Write-Host -ForegroundColor Yellow "Waiting on Crawl Components to provision..."

  21:         Start-Sleep 2

  22:     }

  23:     # Need to delete the original crawl topology that was created by default

  24:     $searchApp | Get-SPEnterpriseSearchCrawlTopology | where {$_.State -eq "Inactive"} | Remove-SPEnterpriseSearchCrawlTopology -Confirm:$false

  25: }

   1: $allQueryServersDone = $true

   2: $appConfig.QueryServers.Server | ForEach-Object {

   3:     $server = $_.Name

   4:     $top = $queryTopology.QueryComponents | where {$_.ServerName -eq $server}

   5:     if ($top -eq $null) { $allQueryServersDone = $false }

   6: }

   7:  

   8: #Make sure we have a crawl component added and started before trying to enable the query component

   9: if ($allCrawlServersDone -and $allQueryServersDone -and $queryTopology.State -ne "Active") {

  10:     Write-Host "Setting query topology as active..."

  11:     $queryTopology | Set-SPEnterpriseSearchQueryTopology -Active -Confirm:$false -ErrorAction SilentlyContinue -ErrorVariable err

  12:  

  13:     Write-Host -ForegroundColor Yellow "Waiting on Query Components to provision..."

  14:     while ($true) {

  15:         $qt = Get-SPEnterpriseSearchQueryTopology -Identity $queryTopology -SearchApplication $searchApp

  16:         $state = $qt.QueryComponents | where {$_.State -ne "Ready"}

  17:         if ($qt.State -eq "Active" -and $state -eq $null) {

  18:             break

  19:         }

  20:         Write-Host -ForegroundColor Yellow "Waiting on Query Components to provision..."

  21:         Start-Sleep 2

  22:     }

  23:     # Need to delete the original query topology that was created by default

  24:     $searchApp | Get-SPEnterpriseSearchQueryTopology | where {$_.State -eq "Inactive"} | Remove-SPEnterpriseSearchQueryTopology -Confirm:$false

  25: }

   1: function Start-EnterpriseSearch([string]$settingsFile = "Configurations.xml") {

   2:     [xml]$config = Get-Content $settingsFile

   3:     $svcConfig = $config.Services.EnterpriseSearchService

   4:  

   5:     $searchSvc = Get-SPEnterpriseSearchServiceInstance -Local

   6:     if ($searchSvc -eq $null) {

   7:         throw "Unable to retrieve search service."

   8:     }

   9:     

  10:     Write-Host "Getting $($svcConfig.Account) account for search service..."

  11:     $searchSvcManagedAccount = (Get-SPManagedAccount -Identity $svcConfig.Account -ErrorVariable err -ErrorAction SilentlyContinue)

  12:     if ($err) {

  13:         $searchSvcAccount = Get-Credential $svcConfig.Account

  14:         $searchSvcManagedAccount = New-SPManagedAccount -Credential $searchSvcAccount

  15:     }

  16:     

  17:     Get-SPEnterpriseSearchService | Set-SPEnterpriseSearchService `

  18:         -ServiceAccount $searchSvcManagedAccount.Username `

  19:         -ServicePassword $searchSvcManagedAccount.SecurePassword `

  20:         -ContactEmail $svcConfig.ContactEmail `

  21:         -ConnectionTimeout $svcConfig.ConnectionTimeout `

  22:         -AcknowledgementTimeout $svcConfig.AcknowledgementTimeout `

  23:         -ProxyType $svcConfig.ProxyType `

  24:         -IgnoreSSLWarnings $svcConfig.IgnoreSSLWarnings `

  25:         -InternetIdentity $svcConfig.InternetIdentity `

  26:         -PerformanceLevel $svcConfig.PerformanceLevel

  27:     

  28:     Write-Host "Setting default index location on search service..."

  29:     $searchSvc | Set-SPEnterpriseSearchServiceInstance -DefaultIndexLocation $svcConfig.IndexLocation -ErrorAction SilentlyContinue -ErrorVariable err

  30:  

  31:     $svcConfig.EnterpriseSearchServiceApplications.EnterpriseSearchServiceApplication | ForEach-Object {

  32:         $appConfig = $_

  33:  

  34:         #Try and get the application pool if it already exists

  35:         $pool = Get-ApplicationPool $appConfig.ApplicationPool

  36:         $adminPool = Get-ApplicationPool $appConfig.AdminComponent.ApplicationPool

  37:  

  38:         $searchApp = Get-SPEnterpriseSearchServiceApplication -Identity $appConfig.Name -ErrorAction SilentlyContinue

  39:         if ($searchApp -eq $null) {

  40:             Write-Host "Creating enterprise search service application..."

  41:             $searchApp = New-SPEnterpriseSearchServiceApplication -Name $appConfig.Name `

  42:                 -DatabaseServer $appConfig.DatabaseServer `

  43:                 -DatabaseName $appConfig.DatabaseName `

  44:                 -FailoverDatabaseServer $appConfig.FailoverDatabaseServer `

  45:                 -ApplicationPool $pool `

  46:                 -AdminApplicationPool $adminPool `

  47:                 -Partitioned:([bool]::Parse($appConfig.Partitioned)) `

  48:                 -SearchApplicationType $appConfig.SearchServiceApplicationType

  49:         } else {

  50:             Write-Host "Enterprise search service application already exists, skipping creation."

  51:         }

  52:  

  53:         $installCrawlSvc = (($appConfig.CrawlServers.Server | where {$_.Name -eq $env:computername}) -ne $null)

  54:         $installQuerySvc = (($appConfig.QueryServers.Server | where {$_.Name -eq $env:computername}) -ne $null)

  55:         $installAdminCmpnt = (($appConfig.AdminComponent.Server | where {$_.Name -eq $env:computername}) -ne $null)

  56:         $installSyncSvc = (($appConfig.SearchQueryAndSiteSettingsServers.Server | where {$_.Name -eq $env:computername}) -ne $null)

  57:         

  58:         if ($searchSvc.Status -ne "Online" -and ($installCrawlSvc -or $installQuerySvc)) {

  59:             $searchSvc | Start-SPEnterpriseSearchServiceInstance

  60:         }

  61:  

  62:         if ($installAdminCmpnt) {

  63:             Write-Host "Setting administration component..."

  64:             Set-SPEnterpriseSearchAdministrationComponent -SearchApplication $searchApp -SearchServiceInstance $searchSvc

  65:         }

  66:  

  67:         $crawlTopology = Get-SPEnterpriseSearchCrawlTopology -SearchApplication $searchApp | where {$_.CrawlComponents.Count -gt 0 -or $_.State -eq "Inactive"}

  68:         if ($crawlTopology -eq $null) {

  69:             Write-Host "Creating new crawl topology..."

  70:             $crawlTopology = $searchApp | New-SPEnterpriseSearchCrawlTopology

  71:         } else {

  72:             Write-Host "A crawl topology with crawl components already exists, skipping crawl topology creation."

  73:         }

  74:  

  75:         if ($installCrawlSvc) {

  76:             $crawlComponent = $crawlTopology.CrawlComponents | where {$_.ServerName -eq $env:ComputerName}

  77:             if ($crawlTopology.CrawlComponents.Count -eq 0 -and $crawlComponent -eq $null) {

  78:                 $crawlStore = $searchApp.CrawlStores | where {$_.Name -eq "$($appConfig.DatabaseName)_CrawlStore"}

  79:                 Write-Host "Creating new crawl component..."

  80:                 $crawlComponent = New-SPEnterpriseSearchCrawlComponent -SearchServiceInstance $searchSvc -SearchApplication $searchApp -CrawlTopology $crawlTopology -CrawlDatabase $crawlStore.Id.ToString() -IndexLocation $appConfig.IndexLocation

  81:             } else {

  82:                 Write-Host "Crawl component already exist, skipping crawl component creation."

  83:             }

  84:         }

  85:  

  86:         $queryTopology = Get-SPEnterpriseSearchQueryTopology -SearchApplication $searchApp | where {$_.QueryComponents.Count -gt 0 -or $_.State -eq "Inactive"}

  87:         if ($queryTopology -eq $null) {

  88:             Write-Host "Creating new query topology..."

  89:             $queryTopology = $searchApp | New-SPEnterpriseSearchQueryTopology -Partitions $appConfig.Partitions

  90:         } else {

  91:             Write-Host "A query topology with query components already exists, skipping query topology creation."

  92:         }

  93:         if ($installQuerySvc) {

  94:             $queryComponent = $queryTopology.QueryComponents | where {$_.ServerName -eq $env:ComputerName}

  95:             if ($queryTopology.QueryComponents.Count -eq 0 -and $queryComponent -eq $null) {

  96:                 $partition = ($queryTopology | Get-SPEnterpriseSearchIndexPartition)

  97:                 Write-Host "Creating new query component..."

  98:                 $queryComponent = New-SPEnterpriseSearchQueryComponent -IndexPartition $partition -QueryTopology $queryTopology -SearchServiceInstance $searchSvc

  99:                 Write-Host "Setting index partition and property store database..."

 100:                 $propertyStore = $searchApp.PropertyStores | where {$_.Name -eq "$($appConfig.DatabaseName)_PropertyStore"}

 101:                 $partition | Set-SPEnterpriseSearchIndexPartition -PropertyDatabase $propertyStore.Id.ToString()

 102:             } else {

 103:                 Write-Host "Query component already exist, skipping query component creation."

 104:             }

 105:         }

 106:         

 107:         if ($installSyncSvc) {

 108:             Start-SPServiceInstance -Identity "Search Query and Site Settings Service"

 109:         }

 110:         

 111:         #Don't activate until we've added all components

 112:         $allCrawlServersDone = $true

 113:         $appConfig.CrawlServers.Server | ForEach-Object {

 114:             $server = $_.Name

 115:             $top = $crawlTopology.CrawlComponents | where {$_.ServerName -eq $server}

 116:             if ($top -eq $null) { $allCrawlServersDone = $false }

 117:         }

 118:         

 119:         if ($allCrawlServersDone -and $crawlTopology.State -ne "Active") {

 120:             Write-Host "Setting new crawl topology to active..."

 121:             $crawlTopology | Set-SPEnterpriseSearchCrawlTopology -Active -Confirm:$false

 122:             

 123:             Write-Host -ForegroundColor Yellow "Waiting on Crawl Components to provision..."

 124:             while ($true) {

 125:                 $ct = Get-SPEnterpriseSearchCrawlTopology -Identity $crawlTopology -SearchApplication $searchApp

 126:                 $state = $ct.CrawlComponents | where {$_.State -ne "Ready"}

 127:                 if ($ct.State -eq "Active" -and $state -eq $null) {

 128:                     break

 129:                 }

 130:                 Write-Host -ForegroundColor Yellow "Waiting on Crawl Components to provision..."

 131:                 Start-Sleep 2

 132:             }

 133:             # Need to delete the original crawl topology that was created by default

 134:             $searchApp | Get-SPEnterpriseSearchCrawlTopology | where {$_.State -eq "Inactive"} | Remove-SPEnterpriseSearchCrawlTopology -Confirm:$false

 135:         }

 136:         

 137:         $allQueryServersDone = $true

 138:         $appConfig.QueryServers.Server | ForEach-Object {

 139:             $server = $_.Name

 140:             $top = $queryTopology.QueryComponents | where {$_.ServerName -eq $server}

 141:             if ($top -eq $null) { $allQueryServersDone = $false }

 142:         }

 143:  

 144:         #Make sure we have a crawl component added and started before trying to enable the query component

 145:         if ($allCrawlServersDone -and $allQueryServersDone -and $queryTopology.State -ne "Active") {

 146:             Write-Host "Setting query topology as active..."

 147:             $queryTopology | Set-SPEnterpriseSearchQueryTopology -Active -Confirm:$false -ErrorAction SilentlyContinue -ErrorVariable err

 148:  

 149:             Write-Host -ForegroundColor Yellow "Waiting on Query Components to provision..."

 150:             while ($true) {

 151:                 $qt = Get-SPEnterpriseSearchQueryTopology -Identity $queryTopology -SearchApplication $searchApp

 152:                 $state = $qt.QueryComponents | where {$_.State -ne "Ready"}

 153:                 if ($qt.State -eq "Active" -and $state -eq $null) {

 154:                     break

 155:                 }

 156:                 Write-Host -ForegroundColor Yellow "Waiting on Query Components to provision..."

 157:                 Start-Sleep 2

 158:             }

 159:             # Need to delete the original query topology that was created by default

 160:             $searchApp | Get-SPEnterpriseSearchQueryTopology | where {$_.State -eq "Inactive"} | Remove-SPEnterpriseSearchQueryTopology -Confirm:$false

 161:         }

 162:         

 163:         $proxy = Get-SPEnterpriseSearchServiceApplicationProxy -Identity $appConfig.Proxy.Name -ErrorAction SilentlyContinue

 164:         if ($proxy -eq $null) {

 165:             Write-Host "Creating enterprise search service application proxy..."

 166:             $proxy = New-SPEnterpriseSearchServiceApplicationProxy -Name $appConfig.Proxy.Name -SearchApplication $searchApp -Partitioned:([bool]::Parse($appConfig.Proxy.Partitioned))

 167:         } else {

 168:             Write-Host "Enterprise search service application proxy already exists, skipping creation."

 169:         }

 170:         if ($proxy.Status -ne "Online") {

 171:             $proxy.Status = "Online"

 172:             $proxy.Update()

 173:         }

 174:         $proxy | Set-ProxyGroupsMembership $appConfig.Proxy.ProxyGroup

 175:         

 176:     }

 177: }

 178: