BSonPoSH

##########################################
####     Citrix Server Functions      ####
##########################################

## Publish Application to Server(s)
## -app: Name of Application to remove. This is required
## -Server: Name of Server
## PIPED: It will take Servers via Pipe. It expects a list or Citrix Server Object
## NOTE: App Name must include subfolders of the app.
##       If the app in in Applications\Test then app would be Test\MyApp
##       Example: Publish-CitrixApplication -server myserver -app Test\MyApp
function Publish-CitrixApplication{
    Param([string]$server,[string]$app)
    Begin{
        Write-Host
        function gcs{
            Param($srv)
            $type = [System.Type]::GetTypeFromProgID("MetaframeCOM.MetaframeServer",$Server)
            $mfServer = [system.Activator]::CreateInstance($type)
            $mfServer.Initialize(6,$Server)
            $mfServer
        }
        function gca{
            Param($srv,$ma)
            $type = [System.Type]::GetTypeFromProgID("MetaFrameCOM.MetaFrameApplication",$Server)
            $mfApp = [system.Activator]::CreateInstance($type)
            $mfApp.Initialize(3,"Applications\$ma")
            $mfApp.LoadData($true)
            $mfApp
        }
        function cPublish {
            Param([string]$Srv,[string]$myapp)
            $Srv = $Srv.toUpper()
            $mfSrv = gcs $srv
            $mfApp = gca $srv $myapp
            $mfAppBinding = New-Object -ComObject MetaFrameCOM.MetaFrameAppSrvBinding
            $mfAppBinding.Initialize(6,$Srv,"Applications\$app")
            if($mfAppBinding)
            {
                Write-Host "Publishing App[$myapp] on Server [$Srv]" -ForegroundColor Green
                $mfApp.AddServer($mfAppBinding)
                $mfApp.SaveData()
            }
            else
            {
                Write-Host "Unable To Create App Binding" -ForegroundColor Red
            }
        }
        $process = @()
    }
    Process{
        if($_){
            if($_.ServerName){
                $process += $_.ServerName
            }
            else{
                $process += $_
            }
        }
    }
    End{
        if($Server){$Process += $Server}
        foreach($s in $process){
            cPublish -srv $s -myapp $app
            Write-Host
        }
    }
}

## UnPublishes ALL Application from Server(s)
## -Server: Name of Server
## PIPED: It will take Servers via Pipe. It expects a list or Citrix Server Object
function UnPublish-CitrixServer{
    Param([string]$server)
    Begin{
        function gcs{
            Param($srv)
            $type = [System.Type]::GetTypeFromProgID("MetaframeCOM.MetaframeServer",$Server)
            $mfServer = [system.Activator]::CreateInstance($type)
            $mfServer.Initialize(6,$Server)
            $mfServer
        }
        function cUnPublish {
            Param([string]$Srv)
            $Srv = $Srv.toUpper()
            $mfSrv = gcs $srv
            If($mfSrv.Applications.Count -gt 0)
            {
                Write-Host "Removing All Published Applications from $Srv" -ForegroundColor Red
                Write-Host "===================================================" -ForegroundColor Green
                ForEach($a in $mfSrv.Applications)
                {
                    $myApp = $a.AppName
                    Write-Host "Removing App [$myApp] from Server [$Srv]" -ForegroundColor White
                    $a.RemoveServer($Srv)
                    $a.SaveData()
                }
            }
            else
            {
                Write-Host "No Published Applications for $Srv" -ForegroundColor Red
            }
        }
        Write-Host
        $process = @()
    }
    Process{
        if($_){
            if($_.ServerName)
            {
                $process += $_.ServerName
            }
            else
            {
                $process += $_
            }
        }
    }
    End{
        if($Server){$Process += $Server}
        foreach($s in $process){
            cUnPublish $s
            Write-Host
        }
    }
}

## Remove Specific Application from Server(s)
## -app: Name of Application to remove. This is required
## -Server: Name Server.
## PIPED: It will take Servers via Pipe. It expects a list or Citrix Server Object
function Remove-CitrixApplication {
    Param([string]$server,[string]$app)
    Begin{
        function gcs{
            Param($srv)
            $type = [System.Type]::GetTypeFromProgID("MetaframeCOM.MetaframeServer",$Server)
            $mfServer = [system.Activator]::CreateInstance($type)
            $mfServer.Initialize(6,$Server)
            $mfServer
        }
        function RemoveApp {
            Param([string]$Srv,[string]$myapp)
            $AppRemoved = $false
            $Srv = $Srv.toUpper()
            $mfSrv = gcs $srv
            If($mfSrv.Applications.Count -gt 0)
            {
                ForEach($a in $mfSrv.Applications)
                {
                    If(($a.AppName -eq "$myapp") -or ($a.BrowserName -eq "$myapp"))
                    {
                        Write-Host "Removing App [$myApp] from Server [$Srv]" -ForegroundColor Green
                        $a.RemoveServer($Srv)
                        $a.SaveData()
                        $AppRemoved = $true
                    }
                }
            }
            else
            {
                Write-Host "No Applications Published for $Srv" -ForegroundColor Red
                $AppRemoved = $true
            }
            If($AppRemoved -eq $false)
            {
                Write-Host "This Application not Published for $Srv" -ForegroundColor Red
            }
        }
        Write-Host
        $process = @()
    }
    Process{
        if($_)
        {
            if($_.ServerName){

                $process += $_.ServerName
            }
            else
            {
                $process += $_
            }
        }
    }
    End{
        if($Server){$Process += $Server}
        if($process.Length -eq 0){$Process += get-content env:COMPUTERNAME}
        foreach($s in $process)
        {
            RemoveApp -Srv $s -myapp $app
            Write-Host
        }
    }
}

#########################################
####     Citrix App Functions        ####
#########################################
## Returns Citrix Application for Farm
## -Server: Name of Farm Server. This is required
## -App: Name of Application to remove. This is required
function Get-CitrixApp{
    Param($Server =$(throw ‘$Server is Required’),$App= $(throw ‘$FarmServer is Required’))
    $type = [System.Type]::GetTypeFromProgID("MetaFrameCOM.MetaFrameApplication",$Server)
    $mfApp = [system.Activator]::CreateInstance($type)
    $mfApp.Initialize(3,"Applications\$myapp")
    $mfApp.LoadData($true)
    $mfApp
}

## Returns Users currently using APP
## -app: Name of Application. This is required
## -Server: Name of Farm Server. Defaults to local if not passed
## -count: Switch… if set just returns count of servers
function Get-CitrixAppUsers {
    Param($app = $(throw ‘$app is required’),$server,[switch]$count)
    function gcf{
        param($srv)
        $type = [System.Type]::GetTypeFromProgID("MetaframeCOM.MetaframeFarm",$Server)
        $mfarm = [system.Activator]::CreateInstance($type)
        $mfarm.Initialize(1)
        return $mFarm
    }
    $ErrorActionPreference = "SilentlyContinue"
    Write-host
    if($server){$mfm = gcf $server}
    else{$mfm = New-Object -com MetaFrameCOM.MetaFrameFarm;$mfm.Initialize(1)}
    $users = $mfm.Applications | ?{($_.AppName -eq $app) -or ($_.BrowserName -eq $app)}
    $Users = $users.Sessions | sort -Property UserName
    if($count){
        Write-Host "Found [$($Users.Count)] Users for Application [$app]" -ForegroundColor White
        Write-Host
    }
    else{
        Write-Host ""
        Write-Host "Found [$($Users.Count)] Users for Application [$app]" -ForegroundColor White
        Write-Host "—————————————————–" -ForegroundColor gray
        foreach($user in $Users){
            If($User.SessionState -eq 1){
                Write-Host ($User.UserName).PadRight(10) -ForegroundColor Green -NoNewline
            }
            else{
                Write-Host ($User.UserName).PadRight(10) -ForegroundColor yellow -NoNewline
            }
        }
        Write-Host
        Write-Host "—————————————————–" -ForegroundColor gray
        Write-Host "Found [$($Users.Count)] Users for Application [$app]" -ForegroundColor White
        Write-Host
    }
}

## Returns Servers currently published APP
## -app: Name of Application. This is required
## -Server: Name of Farm Server. Defaults to local if not passed
## -count: Switch… if set just returns count of servers
function Get-CitrixAppServers {
    Param($app = $(throw ‘$app is required’),$Server,[switch]$count)
    function gcf{
        param($srv)
        $type = [System.Type]::GetTypeFromProgID("MetaframeCOM.MetaframeFarm",$Server)
        $mfarm = [system.Activator]::CreateInstance($type)
        $mfarm.Initialize(1)
        return $mFarm
    }
    if($server){$mfm = gcf $server}
    else{$mfm = New-Object -com MetaFrameCOM.MetaFrameFarm;$mfm.Initialize(1)}
    $Apps = $mfm.Applications | ?{($_.AppName -eq $app) -or ($_.BrowserName -eq $app)}
    # for XP farms
    $servers = $apps | %{$_.Servers} | sort -Property ServerName | Select-Object ServerName
    if(!$servers){
        # for 40/45 farms
        $servers = $Apps.Sessions | Select-Object ServerName | Sort-Object -unique ServerName
    }
    if($count)
    {
        Write-Host
        Write-Host "Found [$($Servers.Count)] Servers for Application [$app]" -ForegroundColor White
        Write-Host
    }
    else
    {
        Write-Host ""
        Write-Host "Found [$($Servers.Count)] Servers for Application [$app]" -ForegroundColor White
        Write-Host "———————————————–" -ForegroundColor gray
        foreach($server in $servers){Write-Host "$($server.ServerName)" -ForegroundColor Green}
        Write-Host "———————————————–" -ForegroundColor gray
        Write-Host "Found [$($Servers.Count)] Servers for Application [$app]" -ForegroundColor White
        Write-Host ""
    }
}

## Returns Server(s) user is logged into via Citrix
## -LoginName: Login Name of user (Domain\User). This is Required
## -Server: Name of Farm Server. Defaults to local if not passed
## -Verbose: Details about User
function Find-CitrixUser {
    Param([string]$LoginName,$Server,[switch]$verbose)
    $user = $LoginName.Split("\")[1]
    $Domain = $LoginName.Split("\")[0]
    if($server)
    {
        $type = [System.Type]::GetTypeFromProgID("MetaframeCOM.MetaframeUser",$Server)
        $mfuser = [system.Activator]::CreateInstance($type)
        $mfuser.Initialize(1,$Domain,1,$user)
    }
    else
    {
        $mfuser = New-Object -ComObject MetaframeCOM.MetaframeUser
        $mfuser.Initialize(1,$Domain,1,$user)
    }
    Write-Host
    Write-Host "User: $($mfuser.UserName) found on the Following:"
    foreach ($s in $mfuser.Sessions)
    {
        if($verbose)
        {
            Write-Host
            Write-Host "$($s.ServerName)"
            Write-Host "-=-=-=-=-=-"
            Write-Host "AppName          : $($s.AppName)" -foregroundcolor yellow
            Write-Host "SessionName      : $($s.SessionName)" -foregroundcolor yellow
            Write-Host "SessionID        : $($s.SessionID)" -foregroundcolor yellow
            Write-Host "ClientAddress    : $($s.ClientAddress)" -foregroundcolor yellow
            Write-Host "ClientEncryption : $($s.ClientEncryption)" -foregroundcolor yellow
            Write-Host
            Write-Host "Processes"
            Write-Host "========="
            foreach ($proc in $s.Processes)
            {
                Write-Host $proc.ProcessName -foregroundcolor Green
            }
            Write-host
        }
        else
        {
            write-Host "   -> $($s.ServerName)"
        }
    }
}

function Test-Port{
    Param([string]$srv,$port=135,$timeout=3000,[switch]$verbose)
    $ErrorActionPreference = "SilentlyContinue"
    $tcpclient = new-Object system.Net.Sockets.TcpClient
    $iar = $tcpclient.BeginConnect($srv,$port,$null,$null)
    $wait = $iar.AsyncWaitHandle.WaitOne($timeout,$false)
    if(!$wait)
    {
        $tcpclient.Close()
        if($verbose){Write-Host "Connection Timeout"}
        Return $false
    }
    else
    {
        $error.Clear()
        $tcpclient.EndConnect($iar) | out-Null
        if($error[0]){if($verbose){write-host $error[0]};$failed = $true}
        $tcpclient.Close()
    }
    if($failed){return $false}else{return $true}
}

$servers = Get-Content $file
foreach($server in $servers)
{
   Do Something Here Like
   psexec \\$server mycmd.exe param1
}

Param($file,$cmd,[switch]$whatif,[switch]$verbose)
Begin{
    function Ping-Server {
        Param([string]$srv)
        $pingresult = Get-WmiObject win32_pingstatus -f "address=’$srv’"
        if($pingresult.statuscode -eq 0) {$true} else {$false}
    }
    $servers = @()
}
Process{
    if($_)
    {
        if($_.ServerName){$servers += $_.ServerName}
        else{$servers += $_}
    }
}
End{
    if($file){Get-Content $file | %{$servers += $_}}
    foreach($server in $servers)
    {
        if(ping-server $server)
        {
            if($verbose){Write-Host "+ Processing Server $Server"}
            $mycmd = $cmd -replace "\%S\%",$Server
            if($whatif){Write-Host "  - WOULD RUN $mycmd"}
            else{if($verbose){Write-Host "  - Running $mycmd"};invoke-Expression $mycmd}
        }
        else
        {
            Write-Host "+ $Server FAILED PING" -foregroundcolor RED
        }
    }
}

function Get-CitrixOnline {
   Param([string]$zone)
   $mfzone = New-Object -ComObject MetaFrameCOM.MetaFrameZone
   $mfzone.Initialize("$zone")
   $servers = $mfzone.OnlineServers
   $servers | sort ServerName | Write-Output
}

function Get-CitrixApplications {
   Param([string]$server)
   $Server = $Server.ToUpper() # Citrix requires Server in CAPS (how odd)
   $mfsrv = New-Object -ComObject MetaFrameCOM.MetaFrameServer
   $mfsrv.Initialize(6,"$Server")
   Write-Host "SERVER $Server" -foregroundcolor Red
   Write-Host "==================" -ForegroundColor Green
   If($mfSrv.Applications.Count -gt 0) {
      $mfSrv.Applications %{Write-Host "Published: $($_.AppName.ToUpper())"}
   }
   else {
      Write-Host "No Applications Published for $Server" -foregroundcolor white
   }
}

function Publish-CitrixApplication {
   Param([string]$Srv,[string]$myapp)
   $Srv = $Srv.toUpper()
   $mfSrv = New-Object -ComObject MetaFrameCOM.MetaFrameServer
   $mfSrv.Initialize(6,"$Srv")
   $mfApp = New-Object -ComObject MetaFrameCOM.MetaFrameApplication
   $mfApp.Initialize(3,"Applications\$myapp")
   $mfApp.LoadData($true)
   $mfAppBinding = New-Object -ComObject MetaFrameCOM.MetaFrameAppSrvBinding
   $mfAppBinding.Initialize(6,$Srv,"Applications\$app")
   if($mfAppBinding) {
      Write-Host "Publishing App[$myapp] on Server [$Srv]" -ForegroundColor Green
      $mfApp.AddServer($mfAppBinding)
      $mfApp.SaveData()
   }
   else {
      Write-Host "Unable To Create App Binding" -ForegroundColor Red
   }
}

function UnPublish-CitrixServer {
   Param([string]$Server)
   Write-Host   $Server = $Server.toUpper()
   $mfSrv = New-Object -ComObject MetaFrameCOM.MetaFrameServer
   $mfSrv.Initialize(6,"$Server")
   If($mfSrv.Applications.Count -gt 0) {
      Write-Host "Removing All Published Applications from $Server"
      Write-Host "==================================================="
      ForEach($app in $mfSrv.Applications) {
         $myApp = $App.AppName
         Write-Host "Removing App [$myApp] from Server [$Server]"
         $app.RemoveServer($Server)
         $app.SaveData()
      }
   }
   else {
     Write-Host "No Published Applications for $Server"
  }
}

function Remove-CitrixApplication {
   Param([string]$Srv,[string]$myapp)
   Write-Host
   $AppRemoved = $false
   $Srv = $Srv.toUpper()
   $mfSrv = New-Object -ComObject MetaFrameCOM.MetaFrameServer
   $mfSrv.Initialize(6,"$Srv")
   If($mfSrv.Applications.Count -gt 0) {
      ForEach($app in $mfSrv.Applications) {
         If($app.AppName -eq "$myapp") {
            Write-Host "Removing App [$myApp] from Server [$Srv]"
            $app.RemoveServer($Srv)
            $app.SaveData()
            $AppRemoved = $true
         }
      }
   }
   else {
     Write-Host "No Applications Published for $Srv" -ForegroundColor Red
     $AppRemoved = $true
   }
   If($AppRemoved -eq $false) {
      Write-Host "This Application not Published for $Srv" -ForegroundColor Red
   }
}