שאלה טיפוסית ממפתחי Windows: "למה עדיין אין <ВСТАВЬТЕ ТУТ ЛЮБИМУЮ КОМАНДУ LINUX>?. בין אם מדובר בהחלקה חזקה less או כלים מוכרים grep או sed, מפתחי Windows רוצים גישה נוחה לפקודות אלו בעבודה היומיומית שלהם.

מערכת המשנה של Windows עבור לינוקס (WSL) עשה צעד ענק קדימה בהקשר זה. זה מאפשר לך להתקשר לפקודות לינוקס מ-Windows על ידי העברת אותן באמצעות proxy wsl.exe (דוגמא: wsl ls). למרות שמדובר בשיפור משמעותי, אפשרות זו סובלת ממספר חסרונות.

• תוספת בכל מקום wsl מייגע ולא טבעי.
• נתיבי Windows בארגומנטים לא תמיד עובדים מכיוון שהלוכסנים האחוריים מתפרשים כתווי בריחה ולא כמפרידי ספריות.
• נתיבי Windows בארגומנטים אינם מתורגמים לנקודת הטעינה המתאימה ב-WSL.
• הגדרות ברירת המחדל אינן מכובדות בפרופילי WSL עם כינויים ומשתני סביבה.
• השלמת נתיב לינוקס אינה נתמכת.
• השלמת פקודה אינה נתמכת.
• השלמת טיעונים אינה נתמכת.

כתוצאה מכך, פקודות לינוקס מטופלות כמו אזרחים סוג ב' תחת Windows - והן קשות יותר לשימוש מאשר פקודות מקוריות. כדי להשוות את זכויותיהם, יש צורך לפתור את הבעיות המפורטות.

עטיפות פונקציות של PowerShell

עם עטיפות פונקציות של PowerShell, אנו יכולים להוסיף השלמת פקודות ולבטל את הצורך בקידומות wsl, תרגום נתיבי Windows לנתיבי WSL. דרישות בסיסיות לקונכיות:

• עבור כל פקודת לינוקס חייבת להיות מעטפת פונקציה אחת עם אותו שם.
• המעטפת חייבת לזהות את נתיבי Windows שהועברו כארגומנטים ולהמיר אותם לנתיבי WSL.
• הקליפה צריכה להתקשר wsl עם פקודת Linux המתאימה לכל קלט צינור והעברת כל ארגומנטים של שורת הפקודה המועברים לפונקציה.

מכיוון שניתן להחיל את התבנית הזו על כל פקודה, אנו יכולים לפשט את ההגדרה של עטיפות אלו וליצור אותן באופן דינמי מתוך רשימה של פקודות לייבוא.

# 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 ' ')
    }
}
"@
}

רשימה $command מגדיר פקודות ייבוא. לאחר מכן אנו יוצרים באופן דינמי מעטפת פונקציות עבור כל אחד מהם באמצעות הפקודה Invoke-Expression (על ידי הסרת תחילה כינויים שיתנגשו עם הפונקציה).

הפונקציה חוזרת על ארגומנטים של שורת הפקודה, קובעת נתיבים של Windows באמצעות פקודות Split-Path и Test-Pathולאחר מכן ממיר נתיבים אלה לנתיבי WSL. אנו מפעילים את השבילים דרך פונקציית עוזר Format-WslArgument, אותו נגדיר בהמשך. הוא בורח מתווים מיוחדים כמו רווחים וסוגריים שאחרת היו מתפרשים בצורה לא נכונה.

לבסוף, אנו מעבירים wsl קלט צינור וכל ארגומנטים של שורת הפקודה.

עם העטיפות האלה אתה יכול לקרוא לפקודות לינוקס המועדפות עליך בצורה טבעית יותר מבלי להוסיף קידומת wsl ובלי לדאוג לגבי אופן ההמרה של השבילים:

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

קבוצת הפקודות הבסיסית מוצגת כאן, אבל אתה יכול ליצור מעטפת עבור כל פקודת לינוקס על ידי הוספתה לרשימה. אם תוסיף את הקוד הזה לשלך פרופיל PowerShell, הפקודות הללו יהיו זמינות לך בכל הפעלת PowerShell, בדיוק כמו פקודות מקוריות!

הגדרות ברירת מחדל

בלינוקס, מקובל להגדיר כינויים ו/או משתני סביבה בפרופילי התחברות, הגדרת פרמטרי ברירת מחדל עבור פקודות בשימוש תכוף (לדוגמה, alias ls=ls -AFh או export LESS=-i). אחד החסרונות של פרוקסי דרך מעטפת לא אינטראקטיבית wsl.exe - שהפרופילים אינם נטענים, ולכן אפשרויות אלו אינן זמינות כברירת מחדל (כלומר. ls ב-WSL ו wsl ls יתנהג אחרת עם הכינוי שהוגדר לעיל).

PowerShell מספקת $PSDefaultParameterValues, מנגנון סטנדרטי להגדרת פרמטרי ברירת מחדל, אך רק עבור cmdlets ופונקציות מתקדמות. כמובן, אנחנו יכולים ליצור פונקציות מתקדמות מהקליפות שלנו, אבל זה מציג סיבוכים מיותרים (לדוגמה, PowerShell מתאם שמות פרמטרים חלקיים (לדוגמה, -a מתאם עם -ArgumentList), שתתנגש עם פקודות לינוקס שלוקחות שמות חלקיים כארגומנטים), והתחביר להגדרת ערכי ברירת מחדל לא יהיה המתאים ביותר (ארגומנטים ברירת מחדל דורשים את שם הפרמטר במפתח, לא רק את שם הפקודה) .

עם זאת, עם שינוי קל בקונכיות שלנו, נוכל ליישם מודל דומה לזה $PSDefaultParameterValues, ואפשר אפשרויות ברירת מחדל עבור פקודות לינוקס!

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 ' ')
    }
}

חוֹלֵף $WslDefaultParameterValues לשורת הפקודה, אנו שולחים פרמטרים באמצעות wsl.exe. להלן נראה כיצד להוסיף הוראות לפרופיל PowerShell שלך כדי להגדיר את הגדרות ברירת המחדל. עכשיו אנחנו יכולים לעשות את זה!

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

מכיוון שהפרמטרים מעוצבים לאחר $PSDefaultParameterValuesאתה יכול קל להשבית אותם באופן זמני על ידי התקנת המפתח "Disabled" לתוך משמעות $true. יתרון נוסף של טבלת hash נפרדת הוא היכולת להשבית $WslDefaultParameterValues בנפרד מ $PSDefaultParameterValues.

השלמת טיעון

PowerShell מאפשר לך לרשום טריילרים של ארגומנטים באמצעות הפקודה Register-ArgumentCompleter. לבש יש עוצמה כלי השלמה אוטומטית הניתנים לתכנות. WSL מאפשר לך להתקשר ל-bash מ- PowerShell. אם נוכל לרשום השלמות ארגומנטים עבור עוטפי פונקציות PowerShell שלנו ולקרוא bash כדי ליצור את ההשלמות, נקבל השלמת ארגומנטים מלאה באותה דיוק כמו 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]
    }
}

הקוד מעט צפוף מבלי להבין חלק מהפונקציות הפנימיות של bash, אבל בעצם מה שאנחנו עושים זה:

• רישום משלים ארגומנטים עבור כל עטיפות הפונקציות שלנו על ידי העברת רשימה $commands בפרמטר -CommandName עבור Register-ArgumentCompleter.
• אנו ממפים כל פקודה לפונקציית המעטפת שבה משתמשת bash להשלמה אוטומטית (כדי להגדיר מפרטי השלמה אוטומטית, bash משתמשת $F, קיצור של complete -F <FUNCTION>).
• המרת ארגומנטים של PowerShell $wordToComplete, $commandAst и $cursorPosition לפורמט המצופה מפונקציות ההשלמה האוטומטית של bash בהתאם למפרטים השלמה אוטומטית הניתנת לתכנות לַחֲבוֹט.
• אנו מרכיבים שורת פקודה להעברה wsl.exe, המבטיח שהסביבה מוגדרת כהלכה, קורא לפונקציית ההשלמה האוטומטית המתאימה, ומוציא את התוצאות בשורה אחר שורה.
• ואז אנחנו מתקשרים wsl עם שורת הפקודה, אנו מפרידים את הפלט לפי מפרידי שורות ומייצרים עבור כל אחד מהם CompletionResults, מיון שלהם והימלטות תווים כגון רווחים וסוגריים שאחרת היו מתפרשים לא נכון.

כתוצאה מכך, מעטפות הפקודות של לינוקס שלנו ישתמשו בדיוק באותה השלמה אוטומטית כמו bash! לדוגמה:

• ssh -c <TAB> -J <TAB> -m <TAB> -O <TAB> -o <TAB> -Q <TAB> -w <TAB> -b <TAB>

כל השלמה אוטומטית מספקת ערכים ספציפיים לארגומנט הקודם, וקוראת נתוני תצורה כגון מארחים ידועים מ-WSL!

<TAB> יעבור על הפרמטרים. <Ctrl + пробел> יציג את כל האפשרויות הזמינות.

בנוסף, מכיוון שיש לנו כעת השלמה אוטומטית של bash, אתה יכול להשלים אוטומטית נתיבי לינוקס ישירות ב-PowerShell!

• less /etc/<TAB>
• ls /usr/share/<TAB>
• vim ~/.bash<TAB>

במקרים בהם השלמה אוטומטית של bash אינה מניבה תוצאות, PowerShell חוזר לנתיבי ברירת המחדל של Windows. כך, בפועל, אתה יכול להשתמש בשני הנתיבים בו זמנית לפי שיקול דעתך.

מסקנה

באמצעות PowerShell ו-WSL, אנו יכולים לשלב פקודות לינוקס ב-Windows כיישומים מקוריים. אין צורך לחפש בניית Win32 או כלי עזר של לינוקס או להפריע לזרימת העבודה שלך על ידי מעבר למעטפת לינוקס. רַק להתקין WSL, להגדיר פרופיל PowerShell и רשום את הפקודות שברצונך לייבא! השלמה אוטומטית עשירה עבור פרמטרי פקודות ונתיבי קבצים של Linux ו-Windows היא פונקציונליות שאינה זמינה אפילו בפקודות מקוריות של Windows כיום.

קוד המקור המלא המתואר לעיל, כמו גם הנחיות נוספות לשילובו בזרימת העבודה שלך, זמין כאן.

אילו פקודות Linux הכי שימושיות בעיניך? אילו דברים נפוצים נוספים חסרים בעבודה ב-Windows? כתבו בתגובות או ב-GitHub!

מקור: www.habr.com