{"id":2061,"date":"2010-02-09T09:20:14","date_gmt":"2010-02-09T17:20:14","guid":{"rendered":"http:\/\/www.sapien.com\/blog\/?p=2061"},"modified":"2010-02-10T10:20:23","modified_gmt":"2010-02-10T18:20:23","slug":"primalforms-2009-the-packager-and-command-line-arguments","status":"publish","type":"post","link":"https:\/\/dev.sapien.com\/blog\/2010\/02\/09\/primalforms-2009-the-packager-and-command-line-arguments\/","title":{"rendered":"PrimalForms 2009: The Packager and Command line Arguments"},"content":{"rendered":"

Per forum request, this blog provides examples of how to access the packager\u2019s command line arguments as well as provide some useful functions to parse the contents. These examples apply to PrimalForms 2009\u2019s Packager and as well as PrimalScript 2009\u2019s packager.<\/p>\n

The package\u2019s script host provides a convenient string variable named $CommandLine. This variable contains the complete argument string that is passed to the package. To illustrate how the $CommandLine variable is used, a script package named \u201cmypackage.exe\u201d will be executed  with the following arguments:<\/p>\n\n\n\n
<\/p>\n

mypackage.exe \u2013Parameter1 Value1 \u2013Parameter2 Value2<\/p>\n

<\/font><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

The resulting string value of $CommandLine is as follows:<\/p>\n\n\n\n
\n

$CommandLine: \u201c\u2013Parameter1\u201d \u201cValue1\u201d \u201c\u2013Parameter2\u201d \u201cValue2\u201d<\/font><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

As you can see all the parameter \/ values are in a single line and each surrounded by quotes. <\/p>\n

Accessing the Argument Parameters<\/strong><\/p>\n

The simplest example of command line argument use is when a parameter is passed and there is no associated value. In order to determine if the argument is present, a simple search of the string will suffice. <\/p>\n

For example:<\/p>\n\n\n\n
\n

mypackage.exe \/? \/a<\/font><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

In this example we only care that \u201c\/?\u201d is present; therefore, we only need to search the $CommandLine string for \u201c\/?\u201d parameter.<\/p>\n\n\n\n
\n

$CommandLine: \u201c\/?\u201d \u201c\/a\u201d<\/font><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n\n\n\n
if($CommandLine.Contains("""\/?"""))
{
    Write-Host "Found Parameter"
}
<\/font><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

In other instances a value pair may be needed. The first example above illustrates the value pair.<\/p>\n\n\n\n
\n

mypackage.exe \u2013Parameter1 Value1 \u2013Parameter2 Value2<\/font><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

In this case, the information will need to be parsed from the command line string which requires a more complex approach then a simple search. To help facilitate this, a function called Parse-Commandline<\/strong> was created which will parse the $CommandLine string values from the quotes and place them into a StringCollection.<\/p>\n<\/p>\n\n\n\n
\n

function Parse-Commandline
{
    Param([string]$CommandLine)
    $Arguments = New-Object System.Collections.Specialized.StringCollection
    #Find First Quote
    $index = $CommandLine.IndexOf(‘"’) <\/font><\/p>\n

    while ( $index -ne -1)
    {#Continue as along as we find a quote
        #Find Closing Quote
        $closeIndex = $CommandLine.IndexOf(‘"’,$index + 1)
        if($closeIndex -eq -1)
        {
            break #Can’t find a match
        }
        $value = $CommandLine.Substring($index + 1,$closeIndex – ($index + 1))
        [void]$Arguments.Add($value)
        $index = $closeIndex <\/font><\/p>\n

        #Find First Quote
        $index = $CommandLine.IndexOf(‘"’,$index + 1)
    }
    return $Arguments
}<\/font><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Using the following command line will yield these results: <\/p>\n\n\n\n
\n

$CommandLine: \u201c\u2013Parameter1\u201d \u201cValue1\u201d \u201c\u2013Parameter2\u201d \u201cValue2\u201d<\/font> <\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Results:<\/p>\n\n\n\n
\n

$Parameter[0] = \u2013Parameter<\/font><\/p>\n

$Parameter[1] = Value1<\/font><\/p>\n

$Parameter[2] = \u2013Parameter2<\/font><\/p>\n

$Parameter[3] = Value2<\/font><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

 <\/p>\n

The parameters can be compared by simply checking each element of the collection. It can be taken even further by creating a function called Convert-ArgumentsToDictionary<\/strong> which will convert the value pairs into a Dictionary (Hashtable).  Convert-ArgumentsToDictionary<\/strong> takes two parameters: The first is the parsed StringCollection and the second is a character that denotes a parameter. In the argument string above, the \u2018-\u2018 character denotes a parameter.<\/p>\n\n\n\n
\n

function Convert-ArgumentsToDictionary
{
    Param([System.Collections.Specialized.StringCollection] $Params, [char] $ParamIndicator)
    $Dictionary = New-Object System.Collections.Specialized.StringDictionary
    for($index = 0; $index -lt $Params.Count; $index++)
    {
        [string]$param = $Params[$index]
        #Clear the values
        $key = ""
        $value = "" <\/font><\/p>\n

        if($param.StartsWith($ParamIndicator))
        {
            #Remove the indicator
            $key = $param.Remove(0,1)
            if($index  + 1 -lt $Params.Count)
            {
                #Check if the next Argument is a parameter
                [string]$param = $Params[$index + 1]
                if($param.StartsWith($ParamIndicator) -ne $true )
                {
                    #If it isn’t a parameter then set it as the value
                    $value = $param
                    $index++
                }
            }
            $Dictionary[$key] = $value
        }#else skip
    }
    return $Dictionary
}<\/font><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/p>\n

Once the parsed arguments are converted to a Dictionary, simply check for the parameter name and it will return the value. <\/p>\n\n\n\n
\n

$value = $Dictionary[\u201cParameter\u201d] <\/font><\/p>\n

if($value \u2013eq $null){<\/font><\/p>\n

Write-Host \u201cParameter = {0}\u201d \u2013 f $value<\/font><\/p>\n

}<\/font><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

The following script utilizes the functions described above:<\/p>\n\n\n\n
#Verify that the $CommandLine variable exists
if($CommandLine -ne $null -and $CommandLine -ne "")
{
    $Arguments = Parse-Commandline $CommandLine
    #Convert the Arguments. Use – as the Argument Indicator
    $Dictionary= Convert-ArgumentsToHashtable $Arguments ‘-‘
    #Output the original command line string
    "Command Line: {0}`r`n" -f $CommandLine | Write-Output
    #Output the Dictionary in a formatted table
    $Dictionary<\/font> | Format-Table @{label="Key";Expression={$_.Key}},@{label="Value";Expression={$_.Value}} | Out-String | Write-Output
}
else
{
    #Not running in a packager or no command line arguments passed
    Write-Output "There are no command line arguments to parse."
}<\/font><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

The script verifies the $CommandLine variable is not null because it only exists in the package\u2019s Script Host. Then the function are used to parse the $CommandLine variable and convert it to a Dictionary. Once the Dictionary is generated, the contents are formatted and displayed. <\/p>\n

The results are as follows:<\/p>\n\n\n\n
\n

***Run Powershell***
Command Line: "-Parameter1" "Value1" "-Parameter2" "Value2" <\/font><\/p>\n

Key                                     Value                                 
—                                     —–                                 
Parameter2                              Value2                                
Parameter1                              Value1                                 <\/font><\/p>\n

***Exiting Powershell***<\/font><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

You should now have a better understanding on how do use command line arguments with your packaged scripts. Feel free to use and customize these functions to make accessing  the command line arguments quick and easy.<\/p>\n","protected":false},"excerpt":{"rendered":"

Per forum request, this blog provides examples of how to access the packager\u2019s command line arguments as well as provide some useful functions to parse the contents. These examples apply to PrimalForms 2009\u2019s Packager and as well as PrimalScript 2009\u2019s packager. The package\u2019s script host provides a convenient string variable named $CommandLine. This variable contains […]<\/p>\n","protected":false},"author":10,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":""},"categories":[283,509,410,25],"tags":[294,437,314,415],"class_list":["post-2061","post","type-post","status-publish","format-standard","hentry","category-howto","category-primalforms-software-news","category-primalscript-software-news","category-windows-powershell","tag-commandline","tag-packager","tag-primalforms","tag-primalscript-2009"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t