Was ist der beste Weg, um gegen vs. x86 Variabilität Powershell x64 zu programmieren

Question

Wir haben mehrere Skripte verwenden wir die Installation und die Abhängigkeiten zu konfigurieren, dass die Systeme sichern wir halten. Wir führen diese zu jeder Zeit wir schaffen einen Entwickler, Test, Demo, Zug, prod usw. Umwelt. Oft finden wir, dass wir mit x64 vs. x86-Architektur zu tun haben, vor allem, wenn die Powershell-Skripts betroffen sind.

Zum Beispiel, ich habe ein Skript, das das Windows Installer Powershell Extensions verwendet, um zu bestimmen, ob ein Programm / Patch installiert wurde. Das Skript funktioniert nicht in einer x64-Umgebung ohne Powershell explizit aufgerufen wird (x86), die nicht in dem Pfad standardmäßig. Wie wir Port diese Skripte auf die x64-Plattform wäre es toll, einen einzigen Satz von Skripten zu erhalten, die auf beiden Architekturen in Powershell arbeiten und nur x86-Code aufrufen, wenn nötig.

Kennt jemand eine Strategie, dies zu tun?

Answer 1

Die msgoodies Blog dieser Vorschlag die Architektur zu bestimmen. Man könnte diesen Ansatz verwenden, um die Architektur zu bestimmen und die x86-Powershell aufrufen, wenn es eine bekannte Unverträglichkeit ist.

Answer 2

Ich laufe in dieser Frage viel mit meiner Konfigurationsskripts. Der grundlegende Ansatz, den ich nehmen soll

mehr Funktionen
1. Verwenden Sie testen, ob ich in einer 64-Bit-Umgebung bin ( http://blogs.msdn.com/jaredpar/archive/2008/10/16/powershell-and-64-bit-windows-helper-functions.aspx )
2. Invoke x86 / x64 Powershell basiert auf den Anforderungen eines bestimmten Skript

Leider viel dies in einer Brute-Force-Art und Weise. Jeder spezielle Konfiguration Eintrag, x86 / x64 abhängig ist im wesentlichen besteht aus 2 Codepfaden (eine für jede Architektur).

Die einzige wirkliche Ausnahme ich in der Lage gewesen bin zu machen, ist für die existince bestimmte Programme auf der Festplatte zu testen. Ich habe eine praktische Funktion (Get-ProgramFiles32), die es leicht macht, Programme zu testen.

if ( test-path (join-path Get-ProgramFiles32 "subversion") ) { ...

Hier sind alle der Helferfunktionen, die ich in meiner gemeinsamen Bibliothek, die mit 32/64 Bit Unterschieden beschäftigen.

# Get the path where powershell resides.  If the caller passes -use32 then 
# make sure we are returning back a 32 bit version of powershell regardless
# of the current machine architecture
function Get-PowerShellPath() {
    param ( [switch]$use32=$false,
            [string]$version="1.0" )

    if ( $use32 -and (test-win64machine) ) {
        return (join-path $env:windir "syswow64\WindowsPowerShell\v$version\powershell.exe")
    }

    return (join-path $env:windir "System32\WindowsPowerShell\v$version\powershell.exe")
}


# Is this a Win64 machine regardless of whether or not we are currently 
# running in a 64 bit mode 
function Test-Win64Machine() {
    return test-path (join-path $env:WinDir "SysWow64") 
}

# Is this a Wow64 powershell host
function Test-Wow64() {
    return (Test-Win32) -and (test-path env:\PROCESSOR_ARCHITEW6432)
}

# Is this a 64 bit process
function Test-Win64() {
    return [IntPtr]::size -eq 8
}

# Is this a 32 bit process
function Test-Win32() {
    return [IntPtr]::size -eq 4
}

function Get-ProgramFiles32() {
    if (Test-Win64 ) {
        return ${env:ProgramFiles(x86)}
    }

    return $env:ProgramFiles
}

function Invoke-Admin() {
    param ( [string]$program = $(throw "Please specify a program" ),
            [string]$argumentString = "",
            [switch]$waitForExit )

    $psi = new-object "Diagnostics.ProcessStartInfo"
    $psi.FileName = $program 
    $psi.Arguments = $argumentString
    $psi.Verb = "runas"
    $proc = [Diagnostics.Process]::Start($psi)
    if ( $waitForExit ) {
        $proc.WaitForExit();
    }
}

# Run the specified script as an administrator
function Invoke-ScriptAdmin() {
    param ( [string]$scriptPath = $(throw "Please specify a script"),
            [switch]$waitForExit,
            [switch]$use32=$false )

    $argString = ""
    for ( $i = 0; $i -lt $args.Length; $i++ ) {
        $argString += $args[$i]
        if ( ($i + 1) -lt $args.Length ) {
            $argString += " "
        }
    }

    $p = "-Command & "
    $p += resolve-path($scriptPath)
    $p += " $argString" 

    $psPath = Get-PowershellPath -use32:$use32
    write-debug ("Running: $psPath $p")
    Invoke-Admin $psPath $p -waitForExit:$waitForExit
}