One-Touch BizTalk Configuration in Windows Azure Virtual Machine

Hello, today, I would like to write some blog about the new improvements of the Windows Azure Platform.

After the General Availability, Scott Guthrie has announced  some improvements about Virtual Machine here.

What is interesting here is the support for Optionally Enabling Remote Powershell on Windows Virtual Machine. Why is it cool ? Because with this you can automate not only the provisioning of a Virtual Machine but also automate some task of installation and configuration. We’ve already see how to provision a BizTalk Virtual Machine in a previous post. In this post, with the new capability, we will go further with an automatic configuration of BizTalk after the provision of the Virtual Machine.

Here is the different steps that we’re going to achieve with this scripts:

1. Provisioning BizTalk Evaluation Virtual Machine from the gallery
2. Configure the remote session
3. Downloading the prerequisites
4. Configuring remotely the BizTalk Engine
5. Wait… with a coffee

The prerequisites for the execution of the scripts is the latest version of the Windows Azure PowerShell Command Lets available here

Then, the procedure needs 3 PowerShell script files :

• Azure BizTalk One Touch.ps1 : regroup all the scripts command to do the work
• BizTalk.Management.Automation.psd1 and BizTalk.Management.Automation.psm1 that regroup custom function needed by the principal script and embedded in a module.

You need to copy the Module files in the PowerShell Module Path, if you do not know this path, just type

 $env:psmodulepath 

in a powershell windows to know the list of path where the module are loaded.

Then you need to fill the different parameters according to your subscription and the name of the Virtual Machine you want to create.

First of all, you need to fill the different parameters according to your subscription :

 
########################################### #Azure Subscription Configuration ########################################### 
$subName = '' 
$subId = '' 
$vmStorageAccount = '' 
$cert = Get-Item Cert:\CurrentUser\My\ 

########################################### #VM Configuration ########################################### 
$vmName = ''; 
$adminUserName = '' 
$adminPassword = '' 

########################################### #BizTalk Configuration ########################################### 
$BizTalkAppAccount = "" 
$BizTalkAppPassword = "" 

Here is some details about the script :

A new Virtual Machine is created with this azure Command Let :

 
$azureQuickVMResult = New-AzureQuickVM -Windows -ServiceName $vmName ` 
-name $vmName ` 
-ImageName "2cdc6229df6344129ee553dd3499f0d3__BizTalk-Server-2013-Evaluation" ` 
-EnableWinRMHttp -Location "West Europe" ` 
-AdminUsername $adminUserName ` 
-Password $adminPassword ` 
-InstanceSize Small 

Then I use a custom function which will wait until the Virtual Machine Status is in ReadyRole Mode. This function is Get-AzureVM using the name of the VM to retrieve the Vm Status, output the status and loop until a timeout if the status is not desired.

Then I use a new commandlet called GetAzureWinRMUri with the name of the Vm. This commandlet allow me to retrieve the Powershell Remote Configuration of the Vm and especially the port number that is not fixed.

Then I Create the credentials and the PowerShell Session :

 
Write-host "Get Azure Windows Remote Uri" 
$winRmConfiguration = Get-AzureWinRMUri $vmName; 

$secpasswd = ConvertTo-SecureString $adminPassword -AsPlainText -Force 
$mycreds = New-Object System.Management.Automation.PSCredential ($adminUserName, $secpasswd) 

Write-host "Create Session to Virtual Machine" 
$pssessionOption = New-PSSessionOption -SkipCACheck $mysession = New-PSSession -ComputerName "$($vmName).cloudapp.net" -Credential $mycreds -Port $winRmConfiguration.Port -UseSSL -Verbose -SessionOption $pssessionOption 

An interesting part in this code is the use of the $pssessionOption, used with –SkipCACheck, this allows us to not Check the Certificate Authorities and allow us to connect to the VM without knowing the certificate (necessary because we use –UseSSL)

Then I use the function Invoke-Command with the current session in parameters to launch all the command in the Virtual Machine (localy)

BizTalk can be configured automatically (in pseudo-silent mode) using Configuration.exe in commandline with the following parameters :

Indeed, if some of you have already tried to launch the configuration.exe remotely, some of you might have noticed that nothing really happens and the log file doesn’t show an good information on the error. It’s because the configuration.exe is base on a Form Component that use MessageBox.Show even in silent mode.

If you look at the error, you will encountered this following :

If you look at the Information Message – Windows Error Reporting, you will see a link to a detailed dump file where you could find the following stack trace :

 
<?xml version="1.0" encoding="utf-16"?>
<WatsonInfo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <osVersion>Microsoft Windows NT 6.2.9200.0</osVersion>
  <AppName>Microsoft ® BizTalk ® Server 2013</AppName>
  <AppVersion>3.10.229.0</AppVersion>
  <exceptionString>System.InvalidOperationException: Showing a modal dialog box or form when the application is not running in UserInteractive mode is not a valid operation. Specify the ServiceNotification or DefaultDesktopOnly style to display a notification from a service application.
   at System.Windows.Forms.Form.ShowDialog(IWin32Window owner)
   at System.Windows.Forms.Form.ShowDialog()
   at Microsoft.BizTalk.Configuration.Program.RunConfigProgressUIThread()
   at System.Threading.ThreadHelper.ThreadStart_Context(Object state)
   at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
   at System.Threading.ThreadHelper.ThreadStart()</exceptionString>
  <exceptionMessage>Showing a modal dialog box or form when the application is not running in UserInteractive mode is not a valid operation. Specify the ServiceNotification or DefaultDesktopOnly style to display a notification from a service application.</exceptionMessage>
  <exceptionStackTrace>   at System.Windows.Forms.Form.ShowDialog(IWin32Window owner)
   at System.Windows.Forms.Form.ShowDialog()
   at Microsoft.BizTalk.Configuration.Program.RunConfigProgressUIThread()
   at System.Threading.ThreadHelper.ThreadStart_Context(Object state)
   at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
   at System.Threading.ThreadHelper.ThreadStart()</exceptionStackTrace>
  <targetSite>System.Windows.Forms.DialogResult ShowDialog(System.Windows.Forms.IWin32Window)</targetSite>
  <HResult>80131509</HResult>
</WatsonInfo>
 

To accomplish the configuration, I’ve needed to rewrite this component.

What I have done is simply (but after a little bit of re-engineering…) create an other piece of code that wrap the configuration.exe tools. I‘ve tried to re-use as many as possible the original code of this component with a change to be sure to not use any MessageBox.Show.

System.InvalidOperationException: Showing a modal dialog box or form when the application is not running in UserInteractive mode is not a valid operation. Specify the ServiceNotification or DefaultDesktopOnly style to display a notification from a service application.

One this new program compiled and work, all what you need is to copy it in the BizTalk Installation Path and launch it with the same parameters.

An other issue that I encountered was security issue due to the remote PowerShell. I think this is due to some double hop credentials that are not allowed. To by-pass this constraint, I decided to create a Schedule Task with the required execution right, launch it and watch for the log file to know in real-time the progress of the installation.

The file Log watcher is simply done by the Get-Content command with the –wait parameters.

All the necessary file are downloaded and transformed (using the specified parameters on top of the script) from my blob storage account (public) so you can use it. This is done by the Download-File, configure-BizTalk and Configure-BizTalkConfigurationTask function of the module.

And  finally, for the next step of this process, I install the Powershell Provider for BizTalk that will allow me to control my BizTalk in command line.

That’s all, after less than 20 minutes you will have a complete BizTalk Evaluation Environment  ready for use.

Thanks to Windows Azure Platform. This platform really ROCKS!!!!!!!!!!!!!

You will find all the scripts in a gist repository :

	#
	# Module manifest for module 'BizTalk.Management.Automation'
	#
	# Generated by: jdevillard
	#
	# Generated on: 30/04/2013
	#
	@{
	# Script module or binary module file associated with this manifest.
	# RootModule = ''
	# Version number of this module.
	ModuleVersion = '1.0'
	# ID used to uniquely identify this module
	GUID = '3f4d1966-a449-4e10-bcca-b18179586731'
	# Author of this module
	Author = 'jdevillard'
	# Company or vendor of this module
	CompanyName = 'Unknown'
	# Copyright statement for this module
	Copyright = '(c) 2013 jdevillard. All rights reserved.'
	# Description of the functionality provided by this module
	# Description = ''
	# Minimum version of the Windows PowerShell engine required by this module
	# PowerShellVersion = ''
	# Name of the Windows PowerShell host required by this module
	# PowerShellHostName = ''
	# Minimum version of the Windows PowerShell host required by this module
	# PowerShellHostVersion = ''
	# Minimum version of the .NET Framework required by this module
	# DotNetFrameworkVersion = ''
	# Minimum version of the common language runtime (CLR) required by this module
	# CLRVersion = ''
	# Processor architecture (None, X86, Amd64) required by this module
	# ProcessorArchitecture = ''
	# Modules that must be imported into the global environment prior to importing this module
	# RequiredModules = @()
	# Assemblies that must be loaded prior to importing this module
	# RequiredAssemblies = @()
	# Script files (.ps1) that are run in the caller's environment prior to importing this module.
	# ScriptsToProcess = @()
	# Type files (.ps1xml) to be loaded when importing this module
	# TypesToProcess = @()
	# Format files (.ps1xml) to be loaded when importing this module
	# FormatsToProcess = @()
	# Modules to import as nested modules of the module specified in RootModule/ModuleToProcess
	NestedModules = @(
	'BizTalk.Management.Automation.psm1'
	)
	# Functions to export from this module
	FunctionsToExport = '*'
	# Cmdlets to export from this module
	CmdletsToExport = '*'
	# Variables to export from this module
	VariablesToExport = '*'
	# Aliases to export from this module
	AliasesToExport = '*'
	# List of all modules packaged with this module.
	# ModuleList = @()
	# List of all files packaged with this module
	# FileList = @()
	# Private data to pass to the module specified in RootModule/ModuleToProcess
	# PrivateData = ''
	# HelpInfo URI of this module
	# HelpInfoURI = ''
	# Default prefix for commands exported from this module. Override the default prefix using Import-Module -Prefix.
	# DefaultCommandPrefix = ''
	}

view raw BizTalk.Management.Automation.psd1 hosted with ❤ by GitHub

	#Wait Process
	function Wait-AzureVMStatus{
	[CmdLetBinding()]
	param(
	[string] $vmName,
	[string] $status,
	[int] $timeout = 5000
	)
	BEGIN{
	$startTime = [System.DateTime]::UtcNow
	$lastStatus;
	}
	PROCESS{
	while($true)
	{
	$vmStatus = Get-AzureVM |? { $_.ServiceName -eq $vmName }
	if($vmStatus.Status -eq $status){
	Write-Host "$(Get-Date) $($vmName) has reached the status $($status)"
	Write-Output $vmStatus.Status
	break
	}
	Write-Host "$(Get-Date): Pending... $($vmName) has the status $($vmStatus.Status)"
	Start-Sleep -s 5
	if($startTime.AddMilliseconds($timeout) -lt [System.DateTime]::UtcNow){
	Write-Host "$(Get-Date): Timeout Exceed... $($vmName) has the status $($vmStatus.Status)"
	Write-Output $vmStatus.Status
	break
	}
	}
	}
	END {}
	}
	function Download-File{
	[CmdLetBinding()]
	param(
	[string] $fileName,
	[string] $httpUrl
	)
	BEGIN{
	#if not FullPath
	#All File Are downloaded to AppData Folder
	if(![System.IO.Path]::IsPathRooted($fileName))
	{
	$fileName = [System.IO.Path]::Combine("$($env:APPDATA)", $fileName);
	}
	}
	PROCESS{
	"Downloading $httpUrl"
	$uri = New-Object "System.Uri" "$httpUrl"
	$request = [System.Net.HttpWebRequest]::Create($uri)
	$request.set_Timeout(15000) #15 second timeout
	$response = $request.GetResponse()
	if([System.Math]::Floor($response.get_ContentLength()/1024) -ne 0)
	{
	$totalLength = [System.Math]::Floor($response.get_ContentLength()/1024)
	}
	else{ #less than 1K
	$totalLength = $response.get_ContentLength()
	}
	$responseStream = $response.GetResponseStream()
	$targetStream = New-Object -TypeName System.IO.FileStream -ArgumentList $fileName, Create
	$buffer = new-object byte[] 10KB
	$count = $responseStream.Read($buffer,0,$buffer.length)
	$downloadedBytes = $count
	while ($count -gt 0)
	{
	$targetStream.Write($buffer, 0, $count)
	$count = $responseStream.Read($buffer,0,$buffer.length)
	$downloadedBytes = $downloadedBytes + $count
	Write-Progress -activity "Downloading file '$($httpUrl.split('/') | Select -Last 1)'" -status "Downloaded ($([System.Math]::Floor($downloadedBytes/1024))K of $($totalLength)K): " -PercentComplete ((([System.Math]::Floor($downloadedBytes/1024)) / $totalLength) * 100)
	}
	}
	END{
	Write-Progress -activity "Finished downloading file '$($httpUrl.split('/') | Select -Last 1)'"
	Write-Host "File Downloaded $($httpUrl) to $($fileName)"
	$targetStream.Flush()
	$targetStream.Close()
	$targetStream.Dispose()
	$responseStream.Dispose()
	}
	}
	function create-account
	{
	[CmdLetBinding()]
	param(
	[string]$accountName,
	[string]$accountDescription,
	[string]$password
	)
	$hostname = hostname
	$comp = [adsi]"WinNT://$hostname"
	$user = $comp.Create("User", $accountName)
	$user.SetPassword($password)
	$user.SetInfo()
	$user.description = $accountDescription
	$user.SetInfo()
	#$User.UserFlags[0] = $User.UserFlags[0] -bor 0×10000 #ADS_UF_DONT_EXPIRE_PASSWD flag is 0×10000
	#$user.SetInfo()
	$objOU = [ADSI]"WinNT://$hostname/Administrators,group"
	$objOU.add(“WinNT://$hostname/$accountName”)
	}
	function Configure-BizTalk
	{
	[CmdLetBinding()]
	param(
	[string] $BizTalkConfigurationFilePath,
	[string] $BizTalkMachineName,
	[string] $BizTalkAppAccount,
	[string] $BizTalkAppPassword,
	[string] $OutputPath
	)
	BEGIN{
	if(![System.IO.Path]::IsPathRooted($BizTalkConfigurationFilePath))
	{
	$BizTalkConfigurationFilePath = [System.IO.Path]::Combine($env:APPDATA,$BizTalkConfigurationFilePath)
	}
	[xml]$xmlConfigurationFile = Get-Content $BizTalkConfigurationFilePath
	}
	PROCESS{
	#Change Server Name
	$xmlConfigurationFile.SelectNodes("//*[local-name()='Server']") | % { if(! [String]::IsNullOrEmpty($_.InnerXml)){$_.InnerXml = $BizTalkMachineName } }
	#Change UserName BizTalk App
	$xmlConfigurationFile.SelectNodes("//*[local-name()='NTService'][UserName!='']") | % {
	if($_.UserName.StartsWith("."))
	{
	$_.UserName = ".\$($BizTalkAppAccount)"
	}
	else
	{
	$_.UserName = $BizTalkAppAccount
	}
	$_.Password = $BizTalkAppPassword
	}
	}
	END{
	if($OutputPath -ne $null)
	{
	if(![System.IO.Path]::IsPathRooted($OutputPath))
	{
	$OutputPath = [System.IO.Path]::Combine($env:APPDATA,$OutputPath)
	}
	$xmlConfigurationFile.Save($OutputPath);
	}
	else
	{
	Write-Output $xmlConfigurationFile
	}
	}
	}
	function Configure-BizTalkConfigurationTask
	{
	[CmdLetBinding()]
	param(
	[string] $BizTalkConfigurationTaskFilePath,
	[string] $BizTalkMachineName,
	[string] $AdminUserAccount,
	[string] $OutputPath
	)
	BEGIN{
	if(![System.IO.Path]::IsPathRooted($BizTalkConfigurationTaskFilePath))
	{
	$BizTalkConfigurationTaskFilePath = [System.IO.Path]::Combine($env:APPDATA,$BizTalkConfigurationTaskFilePath)
	}
	[xml]$xmlTaskConfigurationFile = Get-Content $BizTalkConfigurationTaskFilePath
	}
	PROCESS{
	#Change UserId
	$xmlTaskConfigurationFile.Task.Principals.Principal.UserId = "$($BizTalkMachineName)\$($AdminUserAccount)"
	#change CommandLine Argument
	$xmlTaskConfigurationFile.Task.Actions.Exec.Arguments = "/s $($env:APPDATA)\BizTalkConfiguration.xml /l $($env:APPDATA)\BizTalkConfigurationLog.xml /ExtLog"
	}
	END{
	if($OutputPath -ne $null)
	{
	if(![System.IO.Path]::IsPathRooted($OutputPath))
	{
	$OutputPath = [System.IO.Path]::Combine($env:APPDATA,$OutputPath)
	}
	$xmlTaskConfigurationFile.Save($OutputPath);
	}
	else
	{
	Write-Output $xmlTaskConfigurationFile
	}
	}
	}

view raw BizTalk.Management.Automation.psm1 hosted with ❤ by GitHub

	#Set-ExecutionPolicy unrestricted
	Import-Module BizTalk.Management.Automation
	###########################################
	#Azure Subscription Configuration
	###########################################
	$subName = '<Subscription Name>'
	$subId = '<Subscription Id>'
	$vmStorageAccount = '<Vm Storage Account -- or Default storage account of your subscription>'
	$cert = Get-Item Cert:\CurrentUser\My\<Certificate Thumbprint>
	###########################################
	#VM Configuration
	###########################################
	$vmName = '<Virtual Machine Name>';
	$adminUserName = '<Virtual Machine Admin Account>'
	$adminPassword = '<Virtual Mahcine Admin Password>'
	###########################################
	#BizTalk Configuration
	###########################################
	$BizTalkAppAccount = "<BizTalk Application User Account>"
	$BizTalkAppPassword = "<BizTalk Application User Password>"
	###########################################
	#Beginning of the script
	###########################################
	Write-Host "-------- Start Of Script --------"
	$startTimeDate = Get-Date;
	Write-host "Configuring Azure Subscription"
	Set-AzureSubscription -SubscriptionName $subName -SubscriptionId $subid -Certificate $cert
	$storageAccount = Get-AzureStorageAccount -StorageAccountName $vmstorageAccount
	Set-AzureSubscription -SubscriptionName $subName -SubscriptionId $subid -Certificate $cert -CurrentStorageAccount $vmStorageAccount
	Write-Host 'Creating Virtual Machine'
	$azureQuickVMResult = New-AzureQuickVM -Windows -ServiceName $vmName `
	-name $vmName `
	-ImageName "2cdc6229df6344129ee553dd3499f0d3__BizTalk-Server-2013-Evaluation" `
	-EnableWinRMHttp -Location "West Europe" `
	-AdminUsername $adminUserName `
	-Password $adminPassword `
	-InstanceSize Small
	if($azureQuickVMResult.OperationStatus -ne 'Succeeded')
	{
	Write-Host 'Error Creating the VM'
	return
	}
	#Wait for the Ready Role Status of the Virtual Machine
	$result = Wait-AzureVMStatus -vmName $vmName -status 'ReadyRole' -timeout 800000
	if($result -eq 'ReadyRole'){
	Write-Host 'VM Successfully started'
	$secpasswd = ConvertTo-SecureString $adminPassword -AsPlainText -Force
	$mycreds = New-Object System.Management.Automation.PSCredential ($adminUserName, $secpasswd)
	Write-host "Get Azure Windows Remote Uri"
	$winRmConfiguration = Get-AzureWinRMUri $vmName;
	Write-host "Create Session to Virtual Machine"
	$pssessionOption = New-PSSessionOption -SkipCACheck
	$mysession = New-PSSession -ComputerName "$($vmName).cloudapp.net" -Credential $mycreds -Port $winRmConfiguration.Port -UseSSL -Verbose -SessionOption $pssessionOption
	Write-Host "Creating BizTalk User"
	#Create User
	Invoke-Command -ScriptBlock ${function:create-account} -ArgumentList $BizTalkAppAccount,$BizTalkAppAccount,$BizTalkAppPassword -Session $mysession
	Write-Host "Downloading BizTalk Configuration Template and Transformation"
	Invoke-Command -Session $mysession -Script ${function:Download-File} -argumentlist "BizTalkConfigurationDefaultAll.xml","https://jdevillard.blob.core.windows.net/biztalk/VMProvisioning/BizTalkConfigurationDefaultAll.xml"
	Invoke-Command -Session $mysession -Script ${function:configure-BizTalk} -ArgumentList "BizTalkConfigurationDefaultAll.xml", $vmName,$BizTalkAppAccount,$BizTalkAppPassword, "BizTalkConfiguration.xml"
	#Create BackupSSO folder
	Write-Host "Creating Backup SSO Folder"
	Invoke-Command -Session $mysession -ScriptBlock { New-Item c:\BackupSSO -type directory }
	#Download Schedule Task Template File
	Write-Host "Download Schedule Task Template File and Transformation"
	Invoke-Command -ScriptBlock ${function:Download-File} -argumentlist "ScheduleTaskTemplate.xml","https://jdevillard.blob.core.windows.net/biztalk/VMProvisioning/ScheduleTaskTemplate.xml" -Session $mysession
	invoke-command -session $mysession -script ${function:Configure-BizTalkConfigurationTask} -argumentlist "ScheduleTaskTemplate.xml",$vmName, $adminUserName, "ScheduleTask.xml"
	#Create Schedule Task
	Write-Host "Creating the Schedule task"
	invoke-command -session $mysession -script {param($computerName, $userName, $password) . schtasks.exe /create /tn "BizTalk Configuration Task " /xml "$($env:APPDATA)\ScheduleTask.xml" /RU "$($computerName)\$($userName)" /RP $password} -Args $vmName,$adminUserName,$adminPassword
	#Download ExtendedConfiguration
	Write-Host "Downloading ExtendedConfiguration from Blob Storage"
	Invoke-Command -ScriptBlock ${function:Download-File} -argumentlist "C:\Program Files (x86)\Microsoft BizTalk Server 2013\ExtendedConfiguration.exe","https://jdevillard.blob.core.windows.net/biztalk/ExtendedConfiguration/ExtendedConfiguration.exe" -Session $mysession
	Invoke-Command -ScriptBlock ${function:Download-File} -argumentlist "C:\Program Files (x86)\Microsoft BizTalk Server 2013\ExtendedConfiguration.exe.config","https://jdevillard.blob.core.windows.net/biztalk/ExtendedConfiguration/ExtendedConfiguration.exe.config" -Session $mysession
	#execute Schedule Task
	Write-Host "Running Configuration"
	invoke-command -session $mysession -script {param() . schtasks.exe /run /tn "BizTalk Configuration Task "}
	#wait for end, reading file
	Write-Host "Waiting for File Log"
	Start-Sleep -s 10
	Invoke-Command -session $mysession -ScriptBlock {Get-Content "C:\Program Files (x86)\Microsoft BizTalk Server 2013\ExtendedConfiguration.log" -Wait | ForEach-Object { if($_.StartsWith("End Of Program")){break}else{$_}}}
	##For further use of the platform 😉
	Write-Host "Downloading BizTalk Provider Powershell http://psbiztalk.codeplex.com"
	#Download-File -httpUrl "http://download-codeplex.sec.s-msft.com/Download/Release?ProjectName=psbiztalk&DownloadId=276965&FileTime=129737326236800000&Build=20442&quot; -fileName "C:\Users\jdevillard\Downloads\psbiztalk.msi"
	Invoke-Command -ScriptBlock ${function:Download-File} -argumentlist "psbiztalk.msi","http://jdevillard.blob.core.windows.net/biztalk/BizTalkFactory%20PowerShell%20Provider%201.2.0.4.msi" -Session $mysession
	Write-Host "Installing BizTalk Provider Powershell"
	Invoke-Command -ScriptBlock {
	Push-Location $env:APPDATA; . msiexec.exe /i "$($env:APPDATA)\psbiztalk.msi" /quiet /l* log.txt; Pop-Location
	} -Session $mysession
	#Next --- Need to be in x86 mode to use the Powershell Provider
	#end of the scripts -- Total time
	$endDateTime = Get-Date
	$scriptDuration = $endDateTime.Subtract($startTimeDate)
	Write-Host "-------- End Of Script --------"
	Write-Host "Total Script Duration : $($scriptDuration.Hours):$($scriptDuration.Minutes):$($scriptDuration.Seconds)"
	}

view raw BizTalkOneTouchConfiguration.ps1 hosted with ❤ by GitHub

Advertisement