One of those routines is a periodic reboot of Windows servers (you should do it at least once a month after installing new patches). In this post, I will show you how to reboot as many servers as you want at the same time, and collect the reboot status for each of them.

Let’s start from the easiest step – reboot remotely one computer (computer name: MyServer1)

Restart-Computer -ComputerName MyServer1

In my examples, I will execute reboot processes from the domain admin session that has the same privileges on all rebooted servers. Otherwise, you need to the “-Credential” parameter. E.g.:
$Cred = Get-Credential
Restart-Computer -ComputerName “MyServer1” -Credential $Cred

The command above does the job, but it doesn’t return the reboot results, so you do not know if the server was successfully rebooted.
So let’s try to add a few helpful parameters:

Restart-Computer -ComputerName MyServer1 -Wait -For Wmi -Timeout 600 -Force

In the example above I execute the reboot on the MyServer1 computer and wait until receiving a reply to a Win32_ComputerSystem query for the MyServer1. I also added a timeout of 600 seconds (10 minutes) to get an error if the computer is not rebooted in 10 minutes.
To reboot more than one computer, you can add more computer names to the ComputerName parameter:
-ComputerName MyServer1, MyServer2, MyServer3

It looks almost great, but I prepared a script that automates the whole rebooting process (including stopping and starting processes) and I wanted to have the reboot under better control. So I prepared a robust solution that executes each reboot as a separate asynchronous job and collects results when all jobs are completed.
The script can look like that:

#define the script that will be executed for each computer
$script = {
    $computer = $args[0]
    try {
        Restart-Computer -ComputerName $computer -Wait -For Wmi -Timeout 600 -Force -ErrorAction Stop
        Return New-Object PSObject -property  @{status = 'OK'; computer = $computer; error = ''}
    } catch {
        Return New-Object PSOobject -property  @{status = 'ERROR'; computer = $computer; error = ($Error[0].Exception.Message)}
    }
}

#start asynchronous jobs for each computer (all jobs will be executed at the same time)
Start-Job -Name 'reboot' -ScriptBlock $script -ArgumentList 'MyServer1' | Out-Null
Start-Job -Name 'reboot' -ScriptBlock $script -ArgumentList 'MyServer2' | Out-Null
Start-Job -Name 'reboot' -ScriptBlock $script -ArgumentList 'MyServer3' | Out-Null

$rebootResults = @()

#wait until all jobs are finished and collect results
While (Get-Job | Where {$_.State -eq 'Running' -and $_.name -eq 'reboot'}) {
  Start-Sleep -Milliseconds 500   
  $rebootResults += Receive-Job -Name 'reboot'
}

#display results of servers rebooting
$rebootResults | Select-Object status, computer, error | Format-Table

If you like this post, please share it and leave a comment.

The post How to reboot many computers at the same time (remotely) appeared first on Mr. Panas.

A few practical/real examples how this can be applied :

• to store a script data and configuration (it is more flexible than hard-coded parameters or configuration (.ini) files,
• read and process data from other systems (great for processes automation),
• monitor other systems activity and alert users and admins when some events occur,
• enter manipulated/calculated data directly to other systems’ databases.

I also created a solution that monitors all configuration changes in different systems and creates an external audit trail functionality that can detect changes (and send a notification) applied directly to the database.
But let’s talk about efficient technics of working with databases from PowerShell.

The Oracle Database is one of the most advanced, enterprise-level database systems. I use PowerShell very often to create monitoring or data manipulation solutions for advanced applications, that are not easily maintain or the maintenance cost is very high.
You can find a few different methods of how to accessing Oracle database from PowerShell (e.g. using sqlplus or ExecuteReader(), but I will describe the easiest and the fastest method.

Module installation

You will need ADO .NET provider (Oracle.ManagedDataAccess.dll) for Oracle.
You can find here information about how to download it: https://docs.oracle.com/database/121/ODPNT/installODPmd.htm#ODPNT8149

No module installation is needed. Just add the .NET Core class (Oracle.ManagedDataAccess.dll file) as to the PowerShell session by adding at the beginning of your script:

Add-Type -Path "<path>\Oracle.ManagedDataAccess.dll"

Use example

After loading the .NET Core class, follow the steps:

$OraConn = New-Object Oracle.ManagedDataAccess.Client.OracleConnection("<connection string>")
$OraCmd = New-Object Oracle.ManagedDataAccess.Client.OracleCommand
$OraCmd.FetchSize = $OraCmd.FetchSize * 64
$OraCmd.Connection = $OraConn
$OraCmd.CommandText = "<query>"
$OraConn.Open()
$OraAdap = New-Object Oracle.ManagedDataAccess.Client.OracleDataAdapter($oraCmd)
$DataTable = New-object "System.Data.DataTable"
$OraAdap.Fill($DataTable) | Out-Null
$results = $DataTable | Select $DataTable.Columns.ColumnName
$oraConn.Close()

The explanation of a few things:

"<connection string>" – this is the connection string to the database, like:
“Data Source=(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=ServerName)(PORT=1521))(CONNECT_DATA=(SERVER=DEDICATED)(SERVICE_NAME=ServiceName)));User Id=User; Password=Password“

$OraCmd.FetchSize = $OraCmd.FetchSize * 64 – to speed up a bigger data reading, I increased the reading buffer 64 times (from 127KB to 8MB). You will see a huge difference in data read speed.

$OraAdap.Fill($DataTable) | Out-Null – pumps data to an in-memory data table (I added “| Out-Null” to prevent displaying messages on the screen – it is important if you create a function that returns $results)

I hope that this post will be helpful in database access directly from PowerShell.

The post PowerShell and Oracle DB appeared first on Mr. Panas.

A few practical/real examples how this can be applied :

• to store a script data and configuration (it is more flexible than hard-coded parameters or configuration (.ini) files,
• read and process data from other systems (great for processes automation),
• monitor other systems activity and alert users and admins when some events occur,
• enter manipulated/calculated data directly to other systems’ databases.

I also created a solution that monitors all configuration changes in different systems and creates an external audit trail functionality that can detect changes (and send a notification) applied directly to the database.
But let’s talk about efficient technics of working with databases from PowerShell.

MS SQL Server is a very popular database system from Microsoft. Accessing SQL Server data from PowerShell gives us the possibility of data processing and data monitoring. There are a few methods of accessing data on SQL Server, but I will describe the easiest and most efficient one (in my opinion).

Module installation

MS SQL Server module for PowerShell is available at PowerShell Gallery and you can easily install it with the following cmdlet:

Install-Module -Name SqlServer

Use example

The basic use of the module is very similar to SQLite. First, you have to load the module:
Import-Module SqlServer
After that, execute any SQL statement (Select, Insert, Update, Delete, …) using:
$results = Invoke-Sqlcmd -Query "<query>" -ConnectionString "<connection_string>"
The connection string can look for example like this:
Server=<server>;database=<db_name>; User ID=<user>; Password=<password>;ApplicationIntent=ReadOnly

Like in the SQLite example, I recommend converting the returned results to the array of objects adding [pscustomobject[]] before $results.
The example of the source code can look like this (replace the italic text with your connection data):

Import-Module SqlServer
[pscustomobject[]]$results = Invoke-Sqlcmd -Query "SELECT * FROM Customer" -ConnectionString "Server=SERVER1;database=CRMdb; User ID=user1; Password=password1;ApplicationIntent=ReadOnly"
if ($results.count -gt 0) {
   Write-Host "Numer of selected records:" $results.count
} else {
   Write-Host "No records found"
}

I hope that this post will be helpful in database access directly from PowerShell.
If you like it, feel free to share.

The post PowerShell and MS SQL Server DB appeared first on Mr. Panas.

SQLite is perfect to store a script data and configuration (it is more flexible than hard-coded parameters or configuration .ini files

I also created a solution that monitors all configuration changes in different systems and creates an external audit trail functionality that can detect changes (and send a notification) applied directly to the database.
But let’s talk about efficient technics of working with databases in PowerShell.

SQLite is a very simple but most popular database engine in the world (based on the SQLite website, more than 1 trillion databases are in use). It is used in all smartphones and most operational systems. All data is stored in one file and managed by the C-language library. There are many extensions to SQLite that give some level of security (I will describe it in another post) and data compression, but the PowerShell library that I describe here has none of them.
You can create a database structure from the script, but in my opinion, the best tool to create a database, manually browse data, etc. is an open-source tool – DB Browser for SQLite (https://sqlitebrowser.org/), so I will focus on how to execute SQL statements from PowerShell on an SQLite database.

Module installation

SQLite module (PSSQLite) for PowerShell is available at PowerShell Gallery and you can easily install it with the following cmdlet:

Install-Module -Name PSSQLite -Force

Use example

First, need to load the module:
Import-Module PSSQLite
After that, execute any SQL statement (Select, Insert, Update, Delete, …) using:
$results = Invoke-SqliteQuery -Query "<query>" -DataSource "<sqlite_db_file_path>"

The result will be returned as an array of objects, but there is one exception. If the results return only one record, it is just an object, not an array. In this case, if you want to simply check the number of returned records $results.count, you receive an empty value instead of 1.
That is why I prefer to use the following method (always convert returned results to the array of PSObjects:
[pscustomobject[]]$results = Invoke-SqliteQuery -Query "<query>" -DataSource "<sqlite_db_file_path>"

The example of the source code can look like this:

Import-Module PSSQLite
[pscustomobject[]]$results = Invoke-SqliteQuery -Query "SELECT * FROM Customer" -DataSource "MyDB.sqlite3"
if ($results.count -gt 0) {
   Write-Host "Numer of selected records:" $results.count
} else {
   Write-Host "No records found"
}

The module supports also a few other cmdlets, like New-SQLiteConnection (creates SQLite connection), Invoke-SQLiteBulkCopy (allows load data faster), and Out-DataTable (creates data table for a PowerShell object).

SQlite database encryption

A default SQLite database file is not encrypted. But .Net library, used in the PSSQLite module gives us the possibility of database encryption.
The encryption algorithm is RC4, which is not the most advanced, but at least the database cannot be easily open without the password.
To encrypt the database, we have to use New-SQLiteConnection command and ChangePassword method:

$Connection = New-SQLiteConnection -DataSource "MyDB.sqlite3"
$Connection.ChangePassword("Password123")
$Connection.Close()

After encrypting the database can be open only with the password. The password has to be added as a part of the DataSource parameter:

Invoke-SqliteQuery -Query "SELECT * FROM Customer" -DataSource "MyDB.sqlite3;Password=Password123"

To remove password form the database the $null value has to be passed as a password:

$Connection = New-SQLiteConnection -DataSource "MyDB.sqlite3;Password=Password123"
$Connection.ChangePassword($null)
$Connection.Close()

I hope that this post will be helpful in SQLite access from PowerShell.
If you like it, please feel free to share.

The post PowerShell and SQLite appeared first on Mr. Panas.

But there is the other, very simple, way to pass many parameters to your script. Create a simple configuration (.ini) file that will store all all parameters that can be changed. The biggest advantage of the .ini file is clarity of all parameters, you can easily create section for your parameters, and even add comments to describe how to use them.

I created a simple function that load the .ini file:

Function loadConfig ($fileName, $oneSection) {
    $config = Get-Content ($fileName)    
    $cfg = @{}
    $sec = $cfg
    $section = ''
    ForEach ($line in $config) {
       $line = $line.Trim()
       if ($line.startswith('[')) {
          $section = $line.replace('[','').replace(']','')
          if ($oneSection -eq '*') {
             $cfg.Add($section,@{})
             $sec = $cfg.$section
          }   
          continue
       }       
       if ($oneSection -ne $null -and $section -ne $oneSection -and $oneSection -ne '*') {continue}
       $k = $line.IndexOf('=')
       if ($line -eq '' -or $k -lt 1 -or $line[0] -in '[','#') {continue}
       $sec.Add($line.Substring(0,$k), $line.Substring($k+1))
    }
    Return $cfg
 }

The function returns a hashtable with all parameters specified in .ini file. There are only four rules that you have to remember when you create the .ini file:
– there must be “=” (equal sign) after the parameter name
– lines started with “#” will be skipped
– section names are represented like “[section_name]”
– parameter names in one section must be unique

Now let’s prepare a simple .ini file (config.ini):

#demo config file
min=5

[website section]
min=10
url=http:\mrpanas.com

[other section]
min=15
max=255
data with space=200

The function is prepared to read all sections or only one specific section.
We have a few options how it can be executed:

1. Without the second parameter. In this case, parameter names in the .ini file have to be unique and all will be loaded as a flat structure.

2. We can specify in the second parameter which section do we want to load – empty ( “” ) section name means that only parameters on the main block (without the section will be loaded).
Examples:

$conf = loadConfig "c:\tmp\config.ini" ""
the result of $conf.min is 5

$conf = loadConfig "c:\tmp\config.ini" "website section"
the result of $conf.min is 10

$conf = loadConfig "c:\tmp\config.ini" "other section"
the result of $conf.min is 15

3. The last option is to read all sections in a hierarchical structure. In this case for all sections will be created a hash table that will store parameters from the section. To do this, use “*” as the second parameter of the function.
Example:

$conf = loadConfig "c:\tmp\config.ini" "*"
the result of $conf.min is 5
the result of $conf."website section".min is 10
the result of $conf."other section".min is 15

If you like this post, please share or/and recommend it on Facebook.

The post PowerShell – config (.ini) file for your script appeared first on Mr. Panas.

I created a small function that does it for us:

function array2hash ($array, [string]$keyName) {  
   $hash = @{}  
   foreach ($element in $array) {    
       $key = $element."$keyName"    
       if ($hash[$key] -eq $null) {       
          $hash[$key] = $element    
       } 
       elseif ($hash[$key] -is [Collections.ArrayList]) {       
          ($hash[$key]).Add($element)    
       } else {       
          $hash[$key] = [Collections.ArrayList]@(($hash[$key]), $element)    
       }  
    }  
    return $hash
}

How does it work?

This function converts an Array (the first parameter) to a HashTable with a specified Key (KeyName is the second parameter of the function).
If there is more than one value for the specified Key, the function fill create an ArrayList with all Array records that contain the same Key value.

How to use this?

Let’s show it on an example. As an example I will use the database of US zip codes downloaded as a CSV file from:
https://public.opendatasoft.com/explore/dataset/us-zip-code-latitude-and-longitude/export/

As a first step, load data to the array:
$arr = import-csv C:\tmp\us-zip-code-latitude-and-longitude.csv -Delimiter ";"

Now create a hash table for “zip” data (that will take less than 1 second):
$hsh = array2hash $arr "Zip"

Let’s find the zip code = 33418.

To find the zip code in Array I use:
$arr | where {$_.Zip -eq "33418"}
It took 950 milliseconds on my laptop.

Now the same for HashTable:
$hsh."33418"
This operation took 0.2 milliseconds (4750 times faster).
When I repeated the same operations for 100 random zip codes, the Array search took me 103695 milliseconds (1 minute 43 seconds) and HashTable 148 milliseconds (0.1 seconds). As you can see, it is a huge improvement.

Now let’s build a hash table for cities:
$hsh = array2hash $arr "City"

This time search $hsh."New York" returns array with 167 records.

I hope that this post will help you to improve data processing.

The post PowerShell – fastest search in array appeared first on Mr. Panas.