LazyWinAdmin

Moving my blog

2017-04-03T15:45:00.001-04:00

I decided to give a try to Jekyll and moved my blog to Github Pages.

Here is the new link: https://lazywinadmin.github.io/

You can subscribe to my RSS feed here: http://feeds.feedburner.com/lazywinadmin

See you there ! 😉

My presentation at the first meetup of the French PowerShell User Group

2016-09-20T23:56:00.000-04:00

Today I presented a session on Parsing Data using PowerShell at the first meeting of the French PowerShell User Group.

This User Group is organized by a couple of Francophone PowerShell MVPs, including me, from different parts of the world.

Below are the presentation, the scripts and the recording of the meeting. Even if you don't speak the language of Molière you should be able to follow along with the PowerShell language.

Presentation (PPTX) and Scripts : Github Repository of FRPSUG

Registration to our next events: Meetup.com

Slack: Feel free to drop by on our channel #french on powershell.slack.com (register first)

Thanks for reading! If you have any questions, leave a comment or send me an email at fxcat@lazywinadmin.com. I invite you to follow me on Twitter @lazywinadm / Google+ / LinkedIn. You can also follow the LazyWinAdmin Blog on Facebook Page and Google+ Page.

PowerShell Tip - Generate a list of Mac Addresses

2016-08-29T00:13:00.001-04:00

While playing in my lab I needed to create a bunch of fake Devices in System Center Configuration Manager (SCCM). When creation devices you need two pieces of information, the computer name and the Mac Address of the device.

I used the following method to generate my list of mac addresses.

# First, get a list of mac address.
1..150 | ForEach-Object { '{0:X12}' -f $_ }
# Second step: Before we import we need to add a colon ":" every two characters
1..150|%{((('{0:X12}' -f $_) -split '(..)')|?{$_}) -join ":"}

What is happening here

We list from the number 1 to 150

```
1..150
```

We send each number to the pipeline and use composite formatting to convert the number to an hexadecimal that must me 12 characters. It will add leading zeros in this case.

```
'{0:X12}' -f $_
```

We then split every two characters using regex

```
-split '(..)'
```

We send this output to Where-Object to make sure we have a value. Our split is generating some empty values. We can double check that using those examples:

("000000000000" -split "(..)").count # returns 13
("000000000000" -split "(..)" | where { $_ }).count #returns 6

Finally we join the whole string (that is currently splitted every two characters) using -join with the delimiter ":"

```
-join ":"
```

Extra: Here is a list of fake ComputerName with their fake Mac Addresses

1..10 | ForEach-Object{
    # ComputerName
    $CompNumber = "TestFakeDevice{0:0000}" -f $_
    
    # Mac Address
    $CompMac = (('{0:X12}' -f $_) -split '(..)' | Where-Object { $_ }) -join '-'
    
    # Output information
    New-Object -TypeName PSObject -Property @{
        ComputerNumber = $CompNumber
        ComputerMacAddress = $CompMac
    }
}

Output:

ComputerNumber     ComputerMacAddress
--------------     ------------------
TestFakeDevice0001 00-00-00-00-00-00
TestFakeDevice0002 00-00-00-00-00-01
TestFakeDevice0003 00-00-00-00-00-02
TestFakeDevice0004 00-00-00-00-00-03
TestFakeDevice0005 00-00-00-00-00-04
TestFakeDevice0006 00-00-00-00-00-05
TestFakeDevice0007 00-00-00-00-00-06
TestFakeDevice0008 00-00-00-00-00-07
TestFakeDevice0009 00-00-00-00-00-08
TestFakeDevice0010 00-00-00-00-00-09

PowerShell - Composite Formatting references (-f Operator)

2016-08-28T23:16:00.002-04:00

If you play often with PowerShell you might have encountered something called "Composite Formatting". What is that ? Here is a quick example

"Welcome to {0}" -f "LazyWinAdmin.com"

Each format item takes the following form and consists of the following components:
{index[,alignment][:formatString]}
The matching braces "{" and "}" are required.

Composite Formation

The .NET Framework composite formatting feature takes a list of objects and a composite format string as input. A composite format string consists of fixed text intermixed with indexed placeholders, called format items, that correspond to the objects in the list. The formatting operation yields a result string that consists of the original fixed text intermixed with the string representation of the objects in the list.
https://msdn.microsoft.com/en-us/library/txafckwd(v=vs.110).aspx

##########################
# Numeric Format Strings #
##########################

# The Decimal ("D") Format Specifier
"{0:D}" -f 50999994 #50999994
"{0:D10}" -f 50999994 #0050999994
"{0:D6}" -f -1234 #-001234

# The Numeric ("N") Format Specifier
"{0:N1}" -f 0.55567884654 #0.6
"{0:N3}" -f 0.55567884654 #0.556
"{0:N5}" -f 0.55567884654 #0.55568
"{0:N}" -f 55567884654 #55,567,884,654.00
"{0:N5}" -f 55567884654 #55,567,884,654.00000

# Fixed points
"{0:F}" -f 50999994 #50999994.00
"{0:F5}" -f 50999994 #50999994.00000

# The General ("G") Format Specifier
"{0:G}" -f 50999994 #50999994
"{0:G1}" -f 50999994 #5E+07
"{0:G2}" -f 50999994 #5.1E+07
"{0:G5}" -f 50999994 #5.1E+07

# Exponentielle
"{0:E}" -f 1052.0329112756 #1.052033E+003
"{0:e}" -f 1052.0329112756 #1.052033e+003

# Round-Trip (used to ensure that a numeric value that is converted to a string will be parsed back into the same numeric value)
"{0:R}" -f 5.665599292333 #5.665599292333
"{0:R}" -f 5.665590000000 #5.66559
# Interesting example from @MuchToDiscuss (thank you!)
# "The following example yields different results from a 32-bit prompt vs 64-bit,
#  showing that converting this particular 64-bit value to and from string will
#  result in a loss of precision"
"{0:R}" -f [double]0.6822871999174
#0.68228719991740006 (in PowerShell 64-bits)
#0.6822871999174     (in PowerShell 32-bits)


# Hexadecimal
"0x{0:x}" -f 181300 #0x2c434
"0x{0:X}" -f 181300 #0x2C434   (Uppercase here)
"{0:X}" -f 12 #C
"{0:X}" -f 121 #79
"{0:X12}" -f 121 #000000000079

# Leading Zeros
"{0:000}" -f 1 #001
"{0:000}" -f 12 #012
"{0:000}" -f 123 #123
"{0:000}" -f 1234 #1234

# Currency
"{0:C}" -f 100 # $100.00
"{0:C1}" -f 100 # $100.0
"{0:C3}" -f 100 # $100.000
"{0:C3,en-CA}" -f 100 # $100.000

# Mix of types
"0x{0:X} {0:E} {0:N}" -f [Int64]::MaxValue
#0x7FFFFFFFFFFFFFFF 9.223372E+018 9,223,372,036,854,775,807.00





###############
# TIME / DATE #
###############
"Year = {0:yyyy}, Hours = {0:hh}, Hours(24 format) = {0:HH}" -f $(Get-date)
#Year = 2016, Hours = 11, Hours(24 format) = 23
"Time = {0:HH:mm:ss}" -f $(Get-date)
#Time = 23:55:44
"Time = {0:HH:mm:ss:ffff}" -f $(Get-date)
#Time = 23:55:45:6569

# Short date pattern
"{0:d}" -f $(Get-date) #2016-08-28

# Long date pattern
"{0:D}" -f $(Get-date) #August 28, 2016

# Full date/time pattern (short time)
"{0:f}" -f $(Get-date) #August 28, 2016 7:32 PM

# Full date/time pattern (long time)
"{0:F}" -f $(Get-date) #August 28, 2016 7:31:55 PM

# General date/time pattern (short time)
"{0:g}" -f $(Get-date) #2016-08-28 7:32 PM

# General date/time pattern (long time).
"{0:G}" -f $(Get-date) #2016-08-28 7:34:03 PM

# Month/day pattern
"{0:m}" -f $(Get-date) #28 August
"{0:M}" -f $(Get-date) #28 August

# Round-trip date/time pattern.
"{0:o}" -f $(Get-date) #2016-08-28T19:35:29.1878628-04:00
"{0:O}" -f $(Get-date) #2016-08-28T19:35:50.7359703-04:00

# RFC1123 pattern
"{0:r}" -f $(Get-date) #Sun, 28 Aug 2016 19:36:09 GMT
"{0:R}" -f $(Get-date) #Sun, 28 Aug 2016 19:36:09 GMT
# Sortable date/time pattern
"{0:s}" -f $(Get-date) #2016-08-28T19:36:47

#Short time pattern
"{0:t}" -f $(Get-date) #7:37 PM

#Long time pattern
"{0:T}" -f $(Get-date) #7:37:48 PM

#Universal sortable date/time pattern.
"{0:u}" -f $(Get-date) #2016-08-28 19:38:07Z

#Universal full date/time pattern.
"{0:U}" -f $(Get-date) #August 28, 2016 11:38:28 PM

#Year month pattern.
"{0:y}" -f $(Get-date) #August, 2016
"{0:Y}" -f $(Get-date) #August, 2016

# Custom format
"{0:hh}:{0:mm}" -f (Get-Date) #10:51
"{0:hh}:{0:mm}:{0:ss}" -f (Get-Date) #10:51:23


# Note that all the above works also using the ToString method
#  https://msdn.microsoft.com/en-us/library/az4se3k1(v=vs.110).aspx
(Get-date).tostring('y') #August, 2016

# Custom Date and Time Format Strings
#  https://msdn.microsoft.com/en-us/library/8kb3ddd4(v=vs.110).aspx
(Get-date).tostring('yyyyMMdd') #20160828






########################
# ALIGNEMENT / SPACING #
########################

# Spacing and Define the width of the string
"{0,6} {1,15:N0}" -f "2016", "1000000"      #  2016         1000000
"{0,6} {1,15:N0}" -f "2017", "88000000"     #  2017        88000000
'{0,-10:C2}{1,14:C2}' -f "2017", "88000000" #2017            88000000
"{0,-20:C} (amount)" -f 52353253.27 #$52,353,253.27       (amount)
"|{0,-10}|" -f "hello" #|hello     |
"|{0,10}|" -f "hello" #|     hello|




##########
# STRING #
##########

# One string
"{0}" -f "Francois-Xavier" #Francois-Xavier

# Multiple Strings
"My name is {0}, From {1} and live in {2}" -f 'FX', 'France', 'Montreal (Canada)'

# You can also shuffle around the tags
"My name is {2} I'm From {1} and live in {0}" -f 'Montreal (Canada)', 'France', 'FX'

PowerShell/Pester - Make sure your parameters are separated by an empty line

2016-08-24T21:40:00.001-04:00

Today, I continue with another post on Pester. I want to check that each of my parameters declared in my PARAM() block is separated by a empty line.

This will help bring clarity to my code and make it easier to read for other people.

Here is an example, I don't want this:

Instead, I want all the comment based help in that format

This can be accomplish by something like that:

[CmdletBinding()]
PARAM (
    $ModuleName = "ADSIPS",
    $GithubRepository = "github.com/lazywinadmin/"
)

# Make sure one or multiple versions of the module are note loaded
Get-Module -Name $ModuleName | remove-module

# Find the Manifest file
$ManifestFile = "$(Split-path (Split-Path -Parent -Path $MyInvocation.MyCommand.Definition))\$ModuleName\$ModuleName.psd1"

# Import the module and store the information about the module
$ModuleInformation = Import-module -Name $ManifestFile -PassThru

# Get the functions present in the Manifest
$ExportedFunctions = $ModuleInformation.ExportedFunctions.Values.name

# Testing the Module
Describe "$ModuleName Module - HELP" -Tags "Module" {
    FOREACH ($funct in $ExportedFunctions)
    {
        $FunctionContent = Get-Content function:$funct
        $AST = [System.Management.Automation.Language.Parser]::ParseInput($FunctionContent, [ref]$null, [ref]$null)
        
        Context "$funct - Help"{
            
            # Parameters separated by a space
            $ParamText = $AST.ParamBlock.extent.text -split '\r\n' # split on carriage return
            $ParamText = $ParamText.trim() # Trim the edges
            $ParamTextSeparator = $ParamText | select-string ',$' #line that finish by a ','
            
            if ($ParamTextSeparator)
            {
                Foreach ($ParamLine in $ParamTextSeparator.linenumber)
                {
                    it "Parameter - Separated by space (Line $ParamLine)"{
                        $ParamText[$ParamLine] -match '^$|\s+' | Should Be $true
                    }
                }
            }
        } #Context
    } #FOREACH
} #Describe

So what is happening here ?

#1- Using Abstract Syntax Tree (AST), we retrieve the content of the PARAM() block and split on the carriage return character

$ParamText = $AST.ParamBlock.extent.text -split '\r\n'

#2- We trim the edges of each lines

$ParamText = $ParamText.trim()

#3- We find the line that finish by a comma character ','. Here we are using Regex and the Dollar sign '$' that will matches the ending of a line.

$ParamTextSeparator = $ParamText | select-string ',$'

#4- Then for each lines that finish by a comma character, we will check if the next line is empty or contains only white spaces, which is fine too. Again we will be using regex here, ^$ matches an empty line and \s+ matches one ore more whitespaces. This should return either $true or $false and we can use Pester from here to return the success of failure of the test.

$ParamText[$ParamLine] -match '^$|\s+' | Should Be $true

PowerShell/Pester - Make sure your Comment Based Help is not indented

2016-08-22T21:42:00.000-04:00

While writing some PowerShell Pester tests for my module AdsiPS, I wanted to make sure for each functions that all the help keywords of the comment based help were not indented.

Depending of the script editor you are using, the number of spaces or tabs might differ and once published on GitHub the code might looks not so pretty.

My goal is just to keep my code clean and enforce the same practice across all the functions.

Here for example, I don't want this:

Instead, I want all the comment based help in that format

This can be accomplish by something like that:

[CmdletBinding()]
PARAM (
    $ModuleName = "ADSIPS",
    $GithubRepository = "github.com/lazywinadmin/"
)

# Make sure one or multiple versions of the module are note loaded
Get-Module -Name $ModuleName | remove-module

# Find the Manifest file
$ManifestFile = "$(Split-path (Split-Path -Parent -Path $MyInvocation.MyCommand.Definition))\$ModuleName\$ModuleName.psd1"

# Import the module and store the information about the module
$ModuleInformation = Import-module -Name $ManifestFile -PassThru

# Get the functions present in the Manifest
$ExportedFunctions = $ModuleInformation.ExportedFunctions.Values.name

# Testing the Module
Describe "$ModuleName Module - HELP" -Tags "Module" {
    #$Commands = (get-command -Module ADSIPS).Name
    
    FOREACH ($funct in $ExportedFunctions)
    {
        # Retrieve the content of the current function
        $FunctionContent = Get-Content function:$funct
        
        Context "$funct - Comment Based Help - Indentation Checks"{
            
            # Validate Help start at the beginning of the line
            It "Help - Starts at the beginning of the line"{
                $Pattern = ".Synopsis"
                ($FunctionContent -split '\r\n' |
                    select-string $Pattern).line -match "^$Pattern" | Should Be $true
            }
        }
    }
}

So what is happening here ?

#1- I get the content of the function using Get-Content

$FunctionContent = Get-Content function:$funct

#2- I define the pattern that I want to retrieve, here I'm just looking for the help keyword Synopsis

$Pattern = ".Synopsis"

I guess i could check each help keywords as an improvement of the current code.

#3- I split the content of the Function file on each Carriage Return character and look for the pattern I define in #2. This will give me any lines that contains '.Synopsis' (We should only have one)

$FunctionContent -split '\r\n' | select-string $Pattern

#4- Using regex, we specify the caret character '^' which will matches the beginning of a line with the pattern we defined. Finally we validate that it is $true using the Pester syntax 'Should Be'

line -match "^$Pattern" | Should Be $true

Launch of / Lancement du French PowerShell User Group

2016-08-20T18:49:00.004-04:00

[English below]

Depuis un moment, dans la Communauté PowerShell francophone, je vois un certain nombre de développeurs, administrateurs et MVP d’un peu partout dans le monde exprimer le désir d’avoir un groupe d’utilisateurs PowerShell.

Nous avons tous une famille, un travail, des loisirs et organisé un évènement prend beaucoup de temps, surtout pour trouver des salles, des sponsors, des présenteurs, etc…

Donc, … il y a quelques semaines j’ai commencé une conversation avec quelques gars du domaine et lancer l’idée d’un groupe d’utilisateurs uniquement en ligne (pour le moment) en utilisant Meetup.com / Google Hangout On Air / Youtube Live. Cela facilite énormément l’organisation, permet l’enregistrement du meeting automatiquement et à tous d’assister au meeting peu importe l’endroit.

Et bien voilà nous y sommes…

Je suis content de vous annoncer le lancement du French PowerShell User Group (Groupe d’utilisateurs Francophone PowerShell). Ce groupe est pour tout francophone désireux d’apprendre et d’étendre ses connaissances.

Notre but est de développer une communauté forte pour partager et promouvoir le transfert de connaissances.

Nous organiserons un meeting mensuel. Le premier étant planifié pour le 20 septembre 2016 sur l'Analyse syntaxique de données avec PowerShell.

Et… nous avons déjà des présenteurs tous les mois jusqu’en Janvier 2017 !!! Merci a tous!

Voici notre calendrier:
• 2016/09/20 Analyse syntaxique de données avec PowerShell (Francois-Xavier Cat - @lazywinadm)
• 2016/10/18 Les Classes PowerShell (Stephane Van Gulick - @stephanevg)
• 2016/11/16 PowerShell et Unity (Micky Balladelli - @mickyballadelli)
• 2016/12/14 PowerShell Pester (Fabien Dibot - @fdibot)
• 2017/01/11 Gérer les Windows Containers avec PowerShell (Florent Appointaire - @florent_app)

Assister aux meetings

Il est important de choisir l'option 'J'y vais' si vous planifiez d'assister à un meeting (sur meetup.com). Quelques minutes avant l'événement nous enverrons le lien Google Hangout/Youtube Live aux gens aillant repondu 'J'y vais'.

Cependant une fois le meeting démarrer, celui-ci devrait apparaître sur notre chaine Youtube.

Présenteurs

SVP nous contactez sur notre courriel ou par twitter si vous souhaitez faire une presentation.

Liens

Meetup (Meeting, RSVP, Forum, ...) - https://www.meetup.com/FrenchPSUG/
Twitter - https://twitter.com/frpsug
Facebook - https://www.facebook.com/frpsug/
Github - https://github.com/FrPSUG
Email - frpsug at gmail.com

[English]

For a while now I saw francophone PowerShell developers, admins, enthusiasts or MVP from different part of world occasionally express the need to have a User Group that could help them learn, share and promote the transfer of PowerShell knowledge.

We all have family/jobs/hobbies and organizing a physical event takes a lot of time, especially if you need to find venues, sponsors, speakers to come on site, etc.…

So a couple of weeks ago I started a thread with a few guys, launching the idea to make the User Group Online (for now) using meetup.com and Google Hangout On air/Youtube Live.

And here we are…

I'm very excited to announce the launch of the French PowerShell User Group. This group is for any Francophone out there interested to learn more about PowerShell.

Our goal is to develop a strong community of people to share and promote the transfer of PowerShell knowledge.

We will organize an Online monthly meeting. The first event is scheduled for the 20th of September 2016 on Data Parsing with PowerShell.

AND…We already have speakers lined-up until January 2017!!! :-)

Here the current calendar:
• 2016/09/20 Parsing Data with PowerShell – (Francois-Xavier Cat - @lazywinadm)
• 2016/10/18 Using PowerShell Classes – (Stephane Van Gulick - @stephanevg)
• 2016/11/16 PowerShell and Unity engine – (Micky Balladelli - @mickyballadelli)
• 2016/12/14 PowerShell Pester – (Fabien Dibot - @fdibot)
• 2017/01/11 Managing Windows Container with PowerShell – (Florent Appointaire - @florent_app)

Attending the User Group

RSVP is recommended for each meeting (on meetup.com). We will be sending the link to the Google Hangout/Youtube Live to the people who RSVPed a few minutes before we start.

During the meeting the broadcast might show up on our Youtube Channel as well.

Speakers

We are looking for Speaker French preferably and we might open to have English speaker as well in the future.

Important Links

Meetings / RSVP / Forum - https://www.meetup.com/FrenchPSUG/
Twitter - https://twitter.com/frpsug
Facebook - https://www.facebook.com/frpsug/
Github - https://github.com/FrPSUG
Email - frpsug at gmail.com

PowerShell 10th Anniversary - Open Source / Running on Linux and Mac OS X

2016-08-18T11:24:00.001-04:00

The PowerShell Team just dropped a bombshell !

Windows PowerShell is now a cross platform technology with the availability of PowerShell on Linux and Mac !! .... AND.... The PowerShell team is Open Sourcing Windows PowerShell (.Net) and PowerShell Core (.Net Core) !! This is so Cool !!!

Today (2016/08/18) also marks the 10th Anniversary of PowerShell ! Quite a surprise that the PowerShell team prepared for us :-) Given the recent changes in leadership and culture, It is really nice to see Microsoft taking that direction.

PowerShell is now Open Source

Under the MIT License, PowerShell is now an Open Source Software (OSS).

This was made possible with the release of the .NET Core Framework, foundational libraries called CoreFX. A framework available on Windows, OS X and Linux! .NET Core is cross-platform and open source.

PowerShell Core is fairly recent and does not offer all the cmdlets available on PowerShell yet since they don't rely on the same Net Framework as Windows PowerShell (.NET). As a side note, Windows Server 2016 Nano Edition (aka Nano Server) is running on PowerShell Core.

PowerShell is now a Cross Platform technology

In addition to Windows Client and Server, PowerShell is now available on the following operating systems:

Linux

Ubuntu 14.04 \ 16.04
CentOs 7.1
RHEL 7

MAC OS X

OS X 10.11

Download / Test / Contribute

The source are located on Github on the following repository https://github.com/PowerShell/PowerShell

It also worth to note that the PowerShell Team is also providing some nice examples/demos on their GitHub repository: https://github.com/PowerShell/PowerShell/tree/master/demos

Some of the examples available:

Managing Apache
Desired State Configuration (DSC) to set an Apache web Server

More information on DSC for Linux

Managing Docker
Managing Cron jobs via CronTab
Using PowerShellGet
Using PowerShell and Python including how to use JSON to exchange structured objects between Python and PowerShell.
Invoke-WebRequest

Some of those are also demoed in a video here:

Installing PowerShell Core on Linux and Mac

Here is the documentation on how to proceed with the installation of PowerShell Core on Linux and Mac. https://github.com/PowerShell/PowerShell/blob/master/docs/installation

At the time I'm writing this, I only see documentation on how to install PowerShell Core on Linux

PowerShell Core on Linux

PowerShell Core on MAC OS X

More information

Windows PowerShell is now “PowerShell”: An Open Source Project with Linux support – How did we do it? - PowerShell Team Blog
PowerShell on Linux and Open Source! - PowerShell Team Blog
PowerShell is open sourced and is available on Linux - Azure Team Blog
PowerShell on Linux and Open Source - Jeffery Snover (Video)
PowerShell Open Sourcing Launch - PowerShell Team (Video)
Open source PowerShell on Windows, Linux, and OS X! - PowerShell Magazine
Why PowerShell on Linux is Such an Accomplishment ? - PowerShell.org

RECAP : 2006 PowerShell v1 > 2016 PowerShell v5

Here is a small recap of the previous version of powershell over the last 10 years with some of most important features introduced for each versions

Source: Wikipedia (https://en.wikipedia.org/wiki/Windows_PowerShell)

PowerShell v1 (2006)

PowerShell 1.0 was released in November 2006 for Windows XP SP2, Windows Server 2003 and Windows Vista. It is an optional component of Windows Server 2008.

PowerShell v2 (2008)

PowerShell 2.0 is integrated with Windows 7 and Windows Server 2008 R2 and is released for Windows XP with Service Pack 3, Windows Server 2003 with Service Pack 2, and Windows Vista with Service Pack 1.

PowerShell V2 includes changes to the scripting language and hosting API, in addition to including more than 240 new cmdlets.

Some of the features:

PowerShell Remoting
Background Jobs
Transactions
Modules
Debugging
Eventing
PowerShell ISE
...

PowerShell v3 (2012)

Some of the features:

Scheduled Jobs
Web Cmdlets
AST
Workflow
CIM Cmdlets

PowerShell v4 (2013)

Some of the features:

Desired State Configuration (DSC)
Save-Help
Remote Debugging
PowerShell Web Access (PWA)
PSReadLine

PowerShell v5 (2016)

Some of the features:

PowerShell Classes
Pester
PowerShell JEA (Just Enought Administration)
PacketManagement (OneGet)
Debugging Runspaces in remote processes
Debugging PowerShell Background jobs
DSC LCM v2
DSC Partial Configurations
DSC LCM meta-Configuration
Authoring DSC Resource
Script Analyzer

PowerShell v5.1 (2016)

Some of the features:

PacketManagement (Support for proxies)
PSReadline (VIMode)
LocalAccount module

PowerShell/WinForms - Row Header

2016-07-28T23:52:00.002-04:00

If you are creating Windows Forms (WinForms) using PowerShell with tools such as PowerShell Studio from Sapien, you might have some scenario where you want to use Row Header instead of Column Header in a DataGridView control.

Those can be controlled using the properties RowHeaderVisible and ColumnHeaderVisible.

Assuming you already have a form with a Datagridview in it, you will need to do the following:

Create a Column
Create a Row with the Header value (and optionally a value for the first column)
Add the Row to the DataGridView
Set RowHeaderVisible to $true
Set ColumnHeaderVisiable to $false (Optional)

(The example can be download on my github)

Creating a Column

# Create Column object
$NewColumn = New-Object -TypeName System.Windows.Forms.DataGridViewTextBoxColumn
$NewColumn.Name = "Column1"
$NewColumn.HeaderText = "Column1"

# Add the Column to the Datagridview
$DataGridView.Columns.Add($NewColumn)

Creating a Row with Header value

# Create a Row
$Row = New-Object -TypeName System.Windows.Forms.DataGridViewRow

# Set a Row Header value
$Row.HeaderCell.Value = "Header1"

# Set the Header and a row value (for the first column)
$Row.CreateCells($DataGridView, "Value1")


Add Row to Datagridview

# Add the row to the DataGridView control
$DataGridView.Rows.Add($Row)

Hide the Column Header and Show the Row Header

# Make the Row Header Visible
$DataGridView.RowHeadersVisible = $true

# Make the Column Header Invisible
$DataGridView.ColumnHeadersVisible = $false

Easy way: Using the PowerShell module WinFormPS

I started a Window Forms module a while ago called WinFormPS. This module allows you to interact with WinForms control using PowerShell.
The module is available on GitHub here: https://github.com/lazywinadmin/WinFormPS

For our case here, you can either use the entire module or just copy the functions you need in your module.

Performing the same steps is way easier:

# Add Column
Add-WFDataGridViewColumn -DataGridView $datagridview1 -ColumnName "First Column"

# Add Row and Row Header
Add-WFDataGridViewRow -DataGridView $datagridview1 -Title "Header1" -Values "Value1"

# Set the Row Header to Visible
Set-WFDataGridView -DataGridView $datagridview1 -ShowRowHeader

# Set the Column Header to Invisible
Set-WFDataGridView -DataGridView $datagridview1 -HideColumnHeader

Download this example

Thanks for reading! If you have any questions, leave a comment or send me an email at fxcat@lazywinadmin.com. I invite you to follow me on Twitter @lazywinadm / Google+ / LinkedIn. You can also follow the LazyWinAdmin Blog on Facebook Page and Google+ Page.

Offline Domain Join - Recreating the Blob file using PowerShell

2016-07-01T17:12:00.000-04:00

When you need to join a machine to the Active Directory It is a pretty straight forward task using either the User Interface or the PowerShell cmdlet available for that usage.

However in some situation you don't have network connectivity and need to rely on Offline Domain Join, using the Djoin.exe tool. Typically you use djoin in two phases. First you generates a provisioning file that you drop on a newly deployed machine. In the second phase you run djoin with the file as a parameter and the machine is joined to the domain without connection to the domain controller.

My problem
Using that same method, I recently had a tricky problem to solve. The environment where I was performing this was very locked down, not allowing me to copy files to the new provisioned machine.

Fortunately the system handling the deployment could perform action on other systems and gather data. I could rely on something like System Center Orchestrator (or SMA) and get the content of the Blob file over HTTP/HTTPS by invoking a runbook.

Recreating the djoin file with the content was a bit trickier. Djoin is really picky on how the file is created. (see here and here for more information)

Using Djoin

Djoin comes with Windows Client and Server since Windows 7 and Windows Server 2008 R2 installation. Djoin requires administrator privileges, you have to use the tool on an elevated command prompt. Of course, you also need an account that has sufficient rights to create domain computer accounts.

1 - First, Run Djoin.exe to provision the computer account metadata. When you run the provisioning command, the computer account metadata is created in a blob .txt file that you specify as part of the command.

Example:
djoin /provision /domain fx.lab /machine testdjoin01 /savefile provisioning.txt

2 - This blob then has to be copied on the machine and used to offline domain join the Windows machine.

Example:
djoin /requestODJ /loadfile provisionning.txt /windowspath %SystemRoot% /localos

Here is what we see when we open the output file (provisionning.txt)

And here in a hexadecimal editor, you can see it is an unicode base64 encoded string by the two first bytes "FF FE".

Copying the content of the blob to another file

Creating a copy of the file is easy, even copying the content on the same machine and dumping it in another file works, djoin will accept those files.

Get-Content provisionning.txt -Encoding Unicode |
Set-Content newfile.txt -Encoding Unicode

Recreating the djoin blob file from the content

Using Djoin with the same parameters we used to create the blob earlier, we will add the parameter /PRINTBLOB which will output the Blob to the console.

The output can then be stored in a Variable and parse to retrieve only the Blob:

# Store the djoin

$djoin = djoin /provision /domain fx.lab /machine testdjoin02 /savefile provisioning /printblob

# Get the blob

$djoin[12]

Next, this string can be passed across the network using tools such as System Center Orchestrator or SMA. (I won't demonstrate this part in this post)

Finally, on the new deployed machine, we can recreate the Blob file using New-DjoinFile, function available on Github.

# Blob generated 
$Blob = "<Blob generated previously on the domain machine>"

# Recreate djoin file
New-DjoinFile -Blob $blob -DestinationFile $home\desktop\blob.txt -Verbose

You can now use Djoin.exe with the file blob.txt to join your new machine to the domain:

Download the function from Github.

Now if you compare the file generated by djoin.exe and the one recreated by New-DjoinFile, you should get the same content, byte by byte.

Original File:

File created with New-DjoinFile

More information

http://www.win7dll.info/netjoin_dll.html
http://www.msuiche.net/2009/01/29/windows-7-and-windows-server-2008-r2-djoin-offline-domain-join-utility/
http://mctexpert.blogspot.com/2016/03/just-for-fun-storing-blob-files-as-xml.html

LazyWinAdmin

Moving my blog

My presentation at the first meetup of the French PowerShell User Group

PowerShell Tip - Generate a list of Mac Addresses

What is happening here

Extra: Here is a list of fake ComputerName with their fake Mac Addresses

PowerShell - Composite Formatting references (-f Operator)

Composite Formation

PowerShell/Pester - Make sure your parameters are separated by an empty line

Other posts on Pester

PowerShell/Pester - Make sure your Comment Based Help is not indented

Other posts on Pester

Launch of / Lancement du French PowerShell User Group

Et bien voilà nous y sommes…

Assister aux meetings

Présenteurs

Liens

And here we are…

Attending the User Group

Speakers

Important Links

PowerShell 10th Anniversary - Open Source / Running on Linux and Mac OS X

PowerShell is now Open Source

PowerShell is now a Cross Platform technology

Download / Test / Contribute

Installing PowerShell Core on Linux and Mac

More information

RECAP : 2006 PowerShell v1 > 2016 PowerShell v5

PowerShell v1 (2006)

PowerShell v2 (2008)

PowerShell v3 (2012)

PowerShell v4 (2013)

PowerShell v5 (2016)

PowerShell v5.1 (2016)

PowerShell/WinForms - Row Header

Creating a Column

Creating a Row with Header value

Add Row to Datagridview

Hide the Column Header and Show the Row Header

Easy way: Using the PowerShell module WinFormPS

Offline Domain Join - Recreating the Blob file using PowerShell

Using Djoin

Copying the content of the blob to another file

Recreating the djoin blob file from the content

More information