Tipiska programma izstrādātājiem Windows: „Kāpēc šeit joprojām nav <ВСТАВЬТЕ ТУТ ЛЮБИМУЮ КОМАНДУ LINUX>?». Будь то мощное пролистывание less vai ierastie rīki grep vai sed, izstrādātāji Windows vēlas viegli piekļūt šīm komandām ikdienas darbā.

Windows subsistēma Linux (WSL) ir būtiski uzlabojusi šo situāciju. Tā ļauj izsaukt Linux komandas no Windows, tās proksējot caur wsl.exe (piemēram, wsl ls). Lai gan tas ir būtisks uzlabojums, šāds risinājums cieš no vairākiem trūkumiem.

Vispārēja pievienošana wsl ir nogurdinoša un dabiski nejauka.
Windows ceļi argumentu sarakstā ne vienmēr strādā, jo atpakaļ slīpsvītras tiek interpretētas kā escape simboli, nevis katalogu dalītāji.
Windows ceļi argumentu sarakstā netiek pārvērsti atbilstošajā WSL piekļuves punktā.
Nekādas noklusējuma opcijas WSL profilos ar aliasiem un vides mainīgajiem netiek ņemtas vērā.
Linux ceļu pabeigšana netiek atbalstīta.
Komandu pabeigšana netiek atbalstīta.
Argumentu pabeigšana netiek atbalstīta.

Tādējādi Linux komandas Windows sistēmā tiek uztvertas kā otro šķiru pilsoņi — un tās ir grūtāk izmantot nekā vietējās komandas. Lai izlīdzinātu viņu tiesības, ir jāatrisina uzskaitītās problēmas.

PowerShell funkciju apvalki

Ar PowerShell funkciju apvalku palīdzību mēs varam pievienot komandu automātisku pabeigšanu un novērst priekšnosacījumu nepieciešamību, wsl, tulkojot Windows ceļus WSL ceļos. Galvenās prasības apvalkiem ir:

Katram Linux komandam jābūt vienam funkciju apvalkam ar to pašu nosaukumu.
Apvalkam jāatzīst Windows ceļi, kas nodoti kā argumenti, un jāpārveido tie par WSL ceļiem.
Apvalkam jāizsauc wsl ar attiecīgu Linux komandu par jebkuru caurlaides ievadi un jāpārsūta jebkuri komandrindas argumenti, kas nodoti funkcijai.

Kā šis šablons var tikt piemērots jebkurai komandai, mēs varam abstrahēt šo apvalku definīciju un dinamiski ģenerēt tos no komandu saraksta importam.

# The commands to import.
$commands = "awk", "emacs", "grep", "head", "less", "ls", "man", "sed", "seq", "ssh", "tail", "vim"
 
# Register a function for each command.
$commands | ForEach-Object { Invoke-Expression @"
Remove-Alias $_ -Force -ErrorAction Ignore
function global:$_() {
    for (`$i = 0; `$i -lt `$args.Count; `$i++) {
        # If a path is absolute with a qualifier (e.g. C:), run it through wslpath to map it to the appropriate mount point.
        if (Split-Path `$args[`$i] -IsAbsolute -ErrorAction Ignore) {
            `$args[`$i] = Format-WslArgument (wsl.exe wslpath (`$args[`$i] -replace "", "/"))
        # If a path is relative, the current working directory will be translated to an appropriate mount point, so just format it.
        } elseif (Test-Path `$args[`$i] -ErrorAction Ignore) {
            `$args[`$i] = Format-WslArgument (`$args[`$i] -replace "", "/")
        }
    }
 
    if (`$input.MoveNext()) {
        `$input.Reset()
        `$input | wsl.exe $_ (`$args -split ' ')
    } else {
        wsl.exe $_ (`$args -split ' ')
    }
}
"@
}

Saraksts $command nosaka komandas importēšanai. Pēc tam mēs dinamiski ģenerējam funkciju apvalku katrai no tām, izmantojot komandu Invoke-Expression (sākumā izņemot jebkurus aliasus, kas varētu konfliktēt ar funkciju).

Funkcija pārlūko komandrindas argumentus, nosaka Windows ceļus, izmantojot komandas Split-Path un Test-Path, un pēc tam tos pārvērš WSL ceļos. Mēs palaidām ceļus caur palīgfunkciju Format-WslArgument, kuru definēsim vēlāk. Tā aizsargā speciālos simbolus, piemēram, atstarpes un iekavas, kas citādi tiktu nepareizi interpretēti.

Visbeidzot, nododam wsl ievades cauruli un jebkurus komandrindas argumentus.

Izmantojot šādus ietvarus, varat izsaukt savas iecienītākās Linux komandas dabiski, nepievienojot prefiksu wsl un neuztraucoties, kā ceļi tiks pārvērsti:

man bash
less -i $profile.CurrentUserAllHosts
ls -Al C:Windows | less
grep -Ein error *.log
tail -f *.log

Šeit ir parasts komandu kopums, bet jūs varat izveidot apvalku jebkurai Linux komandai, vienkārši pievienojot to sarakstam. Ja jūs pievienosiet šo kodu savam profilam PowerShell, šīs komandas būs pieejamas katrā PowerShell sesijā, tāpat kā vietējās komandas!

Noklusējuma opcijas

Linux ir pierasts definēt aliasus un/vai vides mainīgos profilos (login profile), nosakot noklusējuma parametrus bieži lietotām komandām (piemēram, alias ls=ls -AFh vai export LESS=-i). Viens no trūkumiem, izmantojot neinteraktīvu apvalku wsl.exe ir tas, ka profili netiek ielādēti, tāpēc šie noklusējuma parametri nav pieejami (t.i., ls WSL un wsl ls uzvedīsies savādāk ar iepriekš noteikto aliasu).

PowerShell nodrošina $PSDefaultParameterValues, standarta mehānisms, lai noteiktu noklusējuma parametrus, bet tikai komandletiem un paplašinātām funkcijām. Protams, varam no mūsu apvalkiem izveidot paplašinātas funkcijas, bet tas radīs liekas sarežģījumus (tādējādi PowerShell sasaistīs daļējas parametru nosaukumu (piemēram, -a sasaistās ar -ArgumentList), kas radīs konfliktus ar Linux komandām, kas pieņem daļējus nosaukumus kā argumentus), un sintakse noklusējuma vērtību noteikšanai nebūs vispiemērotākā (lai noteiktu noklusējuma argumentus, parametra nosaukumam jābūt atslēgā, nevis tikai komandas nosaukumam).

Tomēr ar nelielu mūsu apvalku izmaiņu mēs varam ieviest modeli, kas ir līdzīgs $PSDefaultParameterValues, un iekļaut noklusējuma parametrus Linux komandām!

function global:$_() {
    …
 
    `$defaultArgs = ((`$WslDefaultParameterValues.$_ -split ' '), "")[`$WslDefaultParameterValues.Disabled -eq `$true]
    if (`$input.MoveNext()) {
        `$input.Reset()
        `$input | wsl.exe $_ `$defaultArgs (`$args -split ' ')
    } else {
        wsl.exe $_ `$defaultArgs (`$args -split ' ')
    }
}

Pārsūtot $WslDefaultParameterValues komandrā mēs nosūtām parametrus caur wsl.exe. Zemāk norādīts, kā pievienot instrukcijas PowerShell profilam, lai iestatītu noklusējuma parametrus. Tagad mēs to varam izdarīt!

$WslDefaultParameterValues["grep"] = "-E"
$WslDefaultParameterValues["less"] = "-i"
$WslDefaultParameterValues["ls"] = "-AFh --group-directories-first"

Jo parametri tiek modelēti pēc $PSDefaultParameterValues, jūs varat viegli tos atspējot uz laiku, iestatot atslēgu "Disabled" uz vērtību $true. Papildu priekšrocība atsevišķai Hash tabulai ir iespēja atspējot $WslDefaultParameterValues atsevišķi no $PSDefaultParameterValues.

Automātiskā pabeigšana argumentiem

PowerShell ļauj reģistrēt argumentu pabeidotājus, izmantojot komandu Register-ArgumentCompleter. Bash ir jaudīgas programmējamas automātiskās pabeigšanas iespējas. WSL ļauj izsaukt bash no PowerShell. Ja mēs varam reģistrēt argumentu pabeidotājus savām funkciju konsolēm PowerShell un izsaukt bash, lai izveidotu pabeigšanas, tad mēs iegūsim pilnīgu argumentu automātisko pabeigšanu ar tādu pašu precizitāti kā pašā bash!

# Register an ArgumentCompleter that shims bash's programmable completion.
Register-ArgumentCompleter -CommandName $commands -ScriptBlock {
    param($wordToComplete, $commandAst, $cursorPosition)
 
    # Map the command to the appropriate bash completion function.
    $F = switch ($commandAst.CommandElements[0].Value) {
        {$_ -in "awk", "grep", "head", "less", "ls", "sed", "seq", "tail"} {
            "_longopt"
            break
        }
 
        "man" {
            "_man"
            break
        }
 
        "ssh" {
            "_ssh"
            break
        }
 
        Default {
            "_minimal"
            break
        }
    }
 
    # Populate bash programmable completion variables.
    $COMP_LINE = "`"$commandAst`""
    $COMP_WORDS = "('$($commandAst.CommandElements.Extent.Text -join "' '")')" -replace "''", "'"
    for ($i = 1; $i -lt $commandAst.CommandElements.Count; $i++) {
        $extent = $commandAst.CommandElements[$i].Extent
        if ($cursorPosition -lt $extent.EndColumnNumber) {
            # The cursor is in the middle of a word to complete.
            $previousWord = $commandAst.CommandElements[$i - 1].Extent.Text
            $COMP_CWORD = $i
            break
        } elseif ($cursorPosition -eq $extent.EndColumnNumber) {
            # The cursor is immediately after the current word.
            $previousWord = $extent.Text
            $COMP_CWORD = $i + 1
            break
        } elseif ($cursorPosition -lt $extent.StartColumnNumber) {
            # The cursor is within whitespace between the previous and current words.
            $previousWord = $commandAst.CommandElements[$i - 1].Extent.Text
            $COMP_CWORD = $i
            break
        } elseif ($i -eq $commandAst.CommandElements.Count - 1 -and $cursorPosition -gt $extent.EndColumnNumber) {
            # The cursor is within whitespace at the end of the line.
            $previousWord = $extent.Text
            $COMP_CWORD = $i + 1
            break
        }
    }
 
    # Repopulate bash programmable completion variables for scenarios like '/mnt/c/Program Files'/<TAB> where <TAB> should continue completing the quoted path.
    $currentExtent = $commandAst.CommandElements[$COMP_CWORD].Extent
    $previousExtent = $commandAst.CommandElements[$COMP_CWORD - 1].Extent
    if ($currentExtent.Text -like "/*" -and $currentExtent.StartColumnNumber -eq $previousExtent.EndColumnNumber) {
        $COMP_LINE = $COMP_LINE -replace "$($previousExtent.Text)$($currentExtent.Text)", $wordToComplete
        $COMP_WORDS = $COMP_WORDS -replace "$($previousExtent.Text) '$($currentExtent.Text)'", $wordToComplete
        $previousWord = $commandAst.CommandElements[$COMP_CWORD - 2].Extent.Text
        $COMP_CWORD -= 1
    }
 
    # Build the command to pass to WSL.
    $command = $commandAst.CommandElements[0].Value
    $bashCompletion = ". /usr/share/bash-completion/bash_completion 2> /dev/null"
    $commandCompletion = ". /usr/share/bash-completion/completions/$command 2> /dev/null"
    $COMPINPUT = "COMP_LINE=$COMP_LINE; COMP_WORDS=$COMP_WORDS; COMP_CWORD=$COMP_CWORD; COMP_POINT=$cursorPosition"
    $COMPGEN = "bind `"set completion-ignore-case on`" 2> /dev/null; $F `"$command`" `"$wordToComplete`" `"$previousWord`" 2> /dev/null"
    $COMPREPLY = "IFS=`$'n'; echo `"`${COMPREPLY[*]}`""
    $commandLine = "$bashCompletion; $commandCompletion; $COMPINPUT; $COMPGEN; $COMPREPLY" -split ' '
 
    # Invoke bash completion and return CompletionResults.
    $previousCompletionText = ""
    (wsl.exe $commandLine) -split 'n' |
    Sort-Object -Unique -CaseSensitive |
    ForEach-Object {
        if ($wordToComplete -match "(.*=).*") {
            $completionText = Format-WslArgument ($Matches[1] + $_) $true
            $listItemText = $_
        } else {
            $completionText = Format-WslArgument $_ $true
            $listItemText = $completionText
        }
 
        if ($completionText -eq $previousCompletionText) {
            # Differentiate completions that differ only by case otherwise PowerShell will view them as duplicate.
            $listItemText += ' '
        }
 
        $previousCompletionText = $completionText
        [System.Management.Automation.CompletionResult]::new($completionText, $listItemText, 'ParameterName', $completionText)
    }
}
 
# Helper function to escape characters in arguments passed to WSL that would otherwise be misinterpreted.
function global:Format-WslArgument([string]$arg, [bool]$interactive) {
    if ($interactive -and $arg.Contains(" ")) {
        return "'$arg'"
    } else {
        return ($arg -replace " ", " ") -replace "([()|])", ('$1', '`$1')[$interactive]
    }
}

Kods ir nedaudz blīvs bez izpratnes par dažām iekšējām bash funkcijām, bet galvenokārt mēs darām sekojošo:

Reģistrējam argumentu pabeidotāju visām mūsu funkciju apvalku, nododot sarakstu $commands parametrā -CommandName lai Register-ArgumentCompleter.
Saskaņojam katru komandu ar funkciju apvalku, ko bash izmanto automātiskai pabeigšanai (specifikāciju noteikšanai automātiskai pabeigšanai bash tiek izmantots $F, saīsinājums no complete -F).
Pārvēršam PowerShell argumentus $wordToComplete, $commandAst un $cursorPosition formātā, ko sagaida bash automātiskās pabeigšanas funkcijas saskaņā ar programmējamo automātisko pabeigšanu bash.
Sastādām komandrindas komandu, lai nodotu wsl.exe, kas nodrošina pareizu vides iestatījumu, izsauc attiecīgo automātiskās pabeigšanas funkciju un izvada rezultātus ar līniju sadalījumu.
Tad izsaucam wsl ar komandrindu, sadalām rezultātu pa rindām un ģenerējam katram CompletionResults, sakārtojot tos un izvairoties no simboliem, piemēram, atstarpēm un iekavām, kas citādi tiktu nepareizi interpretēti.

Galu galā mūsu Linux komandrindas apvalki izmantos tieši tādu pašu automātisko pabeigšanu kā bash! Piemēram:

ssh -c -J -m -O -o -Q -w -b

Katram automātiskajam pabeigšanai ir pieejami iepriekšējā argumenta specifiski vērtības, nolasot konfigurācijas datus, piemēram, zināmās viesu resursus no WSL!

<TAB> cikliski pārskatīs parametrus. <Ctrl + пробел> parādīs visus pieejamos variantus.

Turklāt, tagad, kad mums darbojas bash automātiskā pabeigšana, jūs varat automātiski pabeigt Linux ceļus tieši PowerShell!

less /etc/
ls /usr/share/
vim ~/\.bash

Ja gadījumos, kad bash automātiskā pabeigšana nenodrošina rezultātus, PowerShell atgriežas pie noklusējuma sistēmas ar Windows ceļiem. Tādējādi jūs varat praktiski vienlaikus izmantot abus ceļus pēc jūsu izvēles.

Secinājums

Ar PowerShell un WSL mēs varam integrēt Linux komandas Windows kā vietējās lietojumprogrammas. Nav nepieciešams meklēt Win32 versijas vai Linux utilītus vai pārtraukt darba plūsmu, pārejot uz Linux komandu rindu. Vienkārši uzstādiet WSL, konfigurējiet PowerShell profilu un uzskaitiet komandas, kuras vēlaties importēt! Bagātīga automātiskā pabeigšana komandparametriem un ceļiem uz failiem Linux un Windows — šī ir funkcionalitāte, kāda šodien pat nav vietējās Windows komandās.

Pilnais izstrādātais kods, kas aprakstīts iepriekš, kā arī papildu ieteikumi tā integrēšanai darba plūsmā ir pieejami. šeit.

Kuras Linux komandas jūs uzskatāt par visnoderīgākajām? Kādas citas ierastas lietas trūkst, strādājot Windows? Rakstiet komentāros vai GitHub!

Avots: habr.com

Integrējam Linux komandas Windows vidē ar PowerShell un WSL

PowerShell funkciju apvalki

Noklusējuma opcijas

Automātiskā pabeigšana argumentiem

Secinājums