ctxfarmer

XATools.psm1 is a work in progress. Most of the functions are still being developed. Please use at your own risk.

Start-XASessionCounter
Get-XASessionCount
Measure-XAZoneLatency
Test-XAActiveICASession
Test-XALatencyValue
New-XAPublishDesktop

XATools.psm1

Function Get-XASessionCount()
{
  BEGIN
  {
    #Uses Citrix MCLI Powershell snapin
    Add-PSSnapin Citrix* -ErrorAction SilentlyContinue
  }
  PROCESS
  {
    $dateTime = Get-Date
    $sessions = Get-XaSession
    Clear-Host
    $active =  ($sessions | ? {$_.State -eq "Active" -and $_.Protocol -eq "Ica"}).Count
    $disconnected = ($sessions | ? {$_.State -eq "Disconnected" -and $_.Protocol -eq "Ica"}).Count
    $total = ($sessions | ? {$_.Protocol -eq "Ica"}).Count
    if($active -gt $global:peakActiveSessions)
    {
      $global:peakActiveSessions = $active
      $global:peakASTime = $dateTime.ToString()
    }
    if($disconnected -gt $global:peakDisconnectedSessions)
    {
      $global:peakDisconnectedSessions = $disconnected
      $global:peakDSTime = $dateTime.ToString()
    }
    if($total -gt $global:peakTotalSessions)
    {
      $global:peakTotalSessions = $total
      $global:peakTSTime = $dateTime.ToString()
    }
    Write-Host $dateTime
    Write-Host "`nActive Sessions: $active"
    Write-Host "Disconnected Sessions: $disconnected"
    Write-Host "Total Sessions: $total"
  }
}
Function Measure-XAZoneLatency()
{
  param
  (
    [Parameter(Mandatory=$true,
               ValueFromPipeline=$true)]
    [string]$zoneName=""
  )
  BEGIN
  {

  }
  PROCESS
  {
    foreach($zone in $zoneName)
    {
      $XASessions = Get-XAServer -ZoneName $zone -OnlineOnly | Get-XASession
      $XASessionCounters = $XASessions | Where-Object {(Test-XAActiveICASession -XASession $_)} | Get-XASessionCounter -ErrorAction SilentlyContinue
      $XASessionCounters = $XASessionCounters | Where-Object {(Test-XALatencyValue -Value $_.AverageLatency)}
      $XASessionCounters = $XASessionCounters | Where-Object {(Test-XALatencyValue -Value $_.LastLatency)}
      $XASessionCounters = $XASessionCounters | Where-Object {(Test-XALatencyValue -Value $_.LatencyDeviation)}

      $AverageLatency = $XASessionCounters | Measure-Object -Property AverageLatency -ave -max -min
      $LastLatency = $XASessionCounters | Measure-Object -Property LastLatency -ave -max -min
      $LatencyDeviation = $XASessionCounters | Measure-Object -Property LatencyDeviation -ave -max -min

      $obj = New-Object PSObject
      $obj | Add-Member -MemberType NoteProperty -Name ZoneName -Value $zone

      $obj | Add-Member -MemberType NoteProperty -Name AverageLatency -Value ("{0:N2}" -f $AverageLatency.Average)
      $obj | Add-Member -MemberType NoteProperty -Name MinAverageLatency -Value ("{0:N2}" -f $AverageLatency.Minimum)
      $obj | Add-Member -MemberType NoteProperty -Name MaxAverageLatency -Value ("{0:N2}" -f $AverageLatency.Maximum)

      $obj | Add-Member -MemberType NoteProperty -Name AvgLastLatency -Value ("{0:N2}" -f $LastLatency.Average)
      $obj | Add-Member -MemberType NoteProperty -Name MinLastLatency -Value ("{0:N2}" -f $LastLatency.Minimum)
      $obj | Add-Member -MemberType NoteProperty -Name MaxLastLatency -Value ("{0:N2}" -f $LastLatency.Maximum)

      $obj | Add-Member -MemberType NoteProperty -Name AvgLatencyDeviation -Value ("{0:N2}" -f $LatencyDeviation.Average)
      $obj | Add-Member -MemberType NoteProperty -Name MinLatencyDeviation -Value ("{0:N2}" -f $LatencyDeviation.Minimum)
      $obj | Add-Member -MemberType NoteProperty -Name MaxLatencyDeviation -Value ("{0:N2}" -f $LatencyDeviation.Maximum)

      $obj

    }
  }
}
Function Start-XASessionCounter()
{
  param
  (
    [Parameter(Mandatory=$false)]
    [int]$UpdateInterval=30,
    [Parameter(Mandatory=$false)]
    [boolean]$showPeak=$true
  )
  BEGIN
  {
    #Uses Citrix MCLI Powershell snapin
    Add-PSSnapin Citrix* -ErrorAction SilentlyContinue
    $global:peakActiveSessions = 0
    $global:peakASTime = ""
    $global:peakDisconnectedSessions = 0
    $global:peakDSTime = ""
    $global:peakTotalSessions = 0
    $global:peakTSTime = ""
  }
  PROCESS
  {
    while($true)
    {
      Get-XASessionCount
      if($showPeak)
      {
        Write-Host "`nPeak Active Sessions: $global:peakActiveSessions @ $global:peakASTime"
        Write-Host "Peak Disconnected Sessions: $global:peakDisconnectedSessions @ $global:peakDSTime"
        Write-Host "Peak Total Sessions: $global:peakTotalSessions @ $global:peakTSTime"
      }
      Start-Sleep -seconds $UpdateInterval
    }
  }
}
Function Test-XAActiveICASession()
{
  param
  (
    [Parameter(Mandatory=$true,
               ValueFromPipeLine=$true)]
    $XASession
  )
  BEGIN
  {

  }
  PROCESS
  {
    [boolean]$result = $true 

    if($XASession.State -ne "Active")
    {
      $result = $false
    }

    if(-not $XASession.SessionName.StartsWith("ICA"))
    {
      $result = $false
    }

    if($XASession.Protocol -ne "Ica")
    {
      $result = $false
    }
    return $result
  }
}
Function Test-XALatencyValue()
{
  param
  (
    [Parameter(Mandatory=$true)]
    [long]$Value
  )
  BEGIN
  {
    $badValues = @(4294967295)
  }
  PROCESS
  {
    [int]$minValue = 0
    [boolean]$result = $true

    foreach($badValue in $badValues)
    {
      if($Value -eq $badValue)
      {
        $result = $false
      }
    }

    if($Value -lt $minValue)
    {
      $result = $false
    }
    return $result
  }
}
Function New-XAPublishDesktop()
{
  param
  (
    [Parameter(ValueFromPipeline=$true)]
    [string]$ServerName,
    [Parameter(Mandatory=$true)]
    [string]$TemplateName
  )
  BEGIN
  {
    Add-PSSnapin Citrix* -ErrorAction SilentlyContinue
  }
  PROCESS
  {
    foreach($Server in $ServerName)
    {
      $app = Copy-XAApplication -BrowserName $TemplateName
      $app = Add-XAApplicationServer -InputObject $app -ServerNames $Server
      $NewDisplayName = $Server.ToUpper()+" Desktop"
      $app = Rename-XAApplication -BrowserName ($app).BrowserName -NewDisplayName $NewDisplayName
      $app
    }
  }
}