خط فرمان لینوکسlinuxcommandline.ir
فهرست مطالب
فارسی
PDFدریافت PDF
Esc
    بخش چهارم: نگارش اسکریپت‌های پوسته

    فصل ۳۶: مفاهیم تکمیلی و سناریوهای خاص

    • زمان مطالعه: ۳۰ دقیقه
    • فصل ۳۶ از ۳۶

    در گام نهایی از این مسیر آموزشی، به بررسی مباحث پراکنده و قابلیت‌های جانبی پوسته Bash می‌پردازیم. اگرچه در فصول گذشته مفاهیم بنیادین را به تفصیل شرح دادیم، اما Bash از ویژگی‌های متعددی برخوردار است که به دلیل ماهیت تخصصی‌شان، کمتر مورد بحث قرار گرفته‌اند. بسیاری از این قابلیت‌ها برای توسعه‌دهندگانی که قصد بومی‌سازی Bash در توزیع‌های لینوکس را دارند حائز اهمیت است؛ با این حال، شناخت برخی از این ابزارها برای حل چالش‌های برنامه‌نویسی خاص و پیچیده بسیار کارگشا خواهد بود. در این بخش، به تحلیل این موارد می‌پردازیم.

    گروه‌بندی دستورات و زیرپوسته‌ها (Subshells) #

    پوسته Bash امکان گروه‌بندی دستورات را فراهم می‌آورد. این عملیات به دو روش اصلی پیاده‌سازی می‌شود: دستورات گروهی (Group Commands) و زیرپوسته‌ها (Subshells). پیش‌تر در فصل ششم، با دستورات گروهی آشنا شدیم که از نحو (Syntax) زیر پیروی می‌کنند:

    { command1; command2; [command3; ...] }

    زیرپوسته‌ها نیز ساختار مشابهی دارند، با این تفاوت که از پرانتز استفاده می‌کنند:

    (command1; command2; [command3;...])

    تفاوت ظاهری این دو در این است که دستور گروهی با «آکولاد» و زیرپوسته با «پرانتز» محصور می‌شود. یک نکته حیاتی در مورد دستورات گروهی این است که به دلیل ساختار نحوی Bash، آکولادها حتماً باید با یک فاصله (Space) از دستورات جدا شوند و آخرین دستور نیز باید به یک سمی‌کالن (;) یا نویسه خط جدید (Newline) ختم گردد.

    اما کاربرد عملی این دو ساختار چیست؟ فارغ از تفاوت‌های ساختاری عمیق‌تر که به آن‌ها خواهیم پرداخت، هر دو روش برای مدیریت متمرکز بازهدایت (Redirection) بسیار کارآمد هستند. فرض کنید در یک اسکریپت، قصد دارید خروجی چندین دستور را به یک فایل واحد هدایت کنید:

    ls -l > output.txt
    echo "Listing of foo.txt" >> output.txt
    cat foo.txt >> output.txt

    اگرچه روش فوق صحیح است، اما با استفاده از یک دستور گروهی می‌توان همان فرآیند را به شکلی منسجم‌تر اجرا کرد:

    { ls -l; echo "Listing of foo.txt"; cat foo.txt; } > output.txt

    به همین ترتیب، استفاده از زیرپوسته نیز نتیجه مشابهی خواهد داشت:

    (ls -l; echo "Listing of foo.txt"; cat foo.txt) > output.txt

    مزیت اصلی این رویکرد، علاوه بر اختصار، در هنگام کار با پایپ‌لاین‌ها (Pipelines) نمایان می‌شود. ترکیب نتایج چندین دستور در یک جریان داده واحد (Stream) برای ارسال به ورودی یک دستور دیگر، با استفاده از این ساختارها بسیار ساده می‌گردد:

    { ls -l; echo "Listing of foo.txt"; cat foo.txt; } | lpr

    در این مثال، خروجی هر سه دستور ادغام شده و به‌طور مستقیم به ورودی دستور lpr ارسال می‌شود تا یک گزارش چاپی یکپارچه تولید گردد.

    علی‌رغم شباهت ظاهری دستورات گروهی و زیرپوسته‌ها در مدیریت جریان‌های خروجی، تفاوت عملکردی بنیادینی میان آن‌ها وجود دارد. دستورات گروهی تمامی فرامین را در درون پوسته جاری (Current Shell) اجرا می‌کنند، در حالی که زیرپوسته (همان‌طور که از نامش پیداست) یک فرآیند فرزند (Child Process) مجزا ایجاد کرده و دستورات را در آن محیط اجرا می‌کند.

    هنگام ایجاد یک زیرپوسته، محیط عملیاتی آن (شامل توابع، نام‌های مستعار و متغیرها) از پوسته‌ی والد کپی و به نمونه‌ی جدید منتقل می‌شود. نکته‌ی ظریف اینجاست که زیرپوسته، برخلاف فرآیندهای فرزند معمولی، کل کپی محیط والد را به ارث می‌برد، نه فقط متغیرهای صادرشده (Exported) را. با این حال، به‌محض خاتمه‌ی زیرپوسته، این کپی از میان می‌رود و تمامی تغییراتی که در محیط آن اعمال شده‌اند (مانند مقداردهی متغیرها) نیز از بین می‌روند.

    کلیدی‌ترین نکته این است که زیرپوسته‌ها برخلاف دستورات گروهی، توانایی تغییر در محیط پوسته والد را ندارند. برای درک بهتر، ابتدا عملکرد دستور گروهی را بررسی می‌کنیم:

    [me@linuxbox ~]$ foo="Original Value"
    [me@linuxbox ~]$ { foo="Altered Value"; echo $foo; }
    Altered Value
    [me@linuxbox ~]$ echo $foo
    Altered Value

    اکنون همین سناریو را در یک زیرپوسته تکرار می‌کنیم:

    [me@linuxbox ~]$ foo="Original Value"
    [me@linuxbox ~]$ ( foo="Altered Value"; echo $foo )
    Altered Value
    [me@linuxbox ~]$ echo $foo
    Original Value

    مشاهده می‌شود که دستور گروهی موفق به تغییر مقدار متغیر foo در محیط جاری شد، در حالی که تغییرات در زیرپوسته به همان محیط محدود ماند. این ویژگی زیرپوسته‌ها در سناریوهایی نظیر تغییر دایرکتوری موقت بسیار کارآمد است؛ چرا که تغییر مسیر با دستور cd در زیرپوسته، تاثیری بر دایرکتوری کاریِ پوسته والد نخواهد داشت:

    [me@linuxbox ~]$ pwd
    /home/me
    [me@linuxbox ~]$ ( cd /usr/bin; pwd )
    /usr/bin
    [me@linuxbox ~]$ pwd
    /home/me

    به‌طور کلی، مگر در مواردی که ایزوله‌سازی فرآیند ضرورت داشته باشد، استفاده از دستورات گروهی به دلیل سرعت بالاتر و مصرف کمتر حافظه (به جهت عدم نیاز به ایجاد فرآیند جدید) ارجحیت دارد.

    در اسکریپت زیر که با نام array-2 ارائه شده، از دستورات گروهی بهره گرفته‌ایم تا تکنیک‌های پیشرفته‌تری را در کار با آرایه‌های انجمنی (Associative Arrays) نمایش دهیم. این برنامه با دریافت نام یک دایرکتوری، فهرستی از فایل‌ها را به همراه نام مالک (Owner) و گروه (Group) چاپ کرده و در انتها، آمار تجمعی فایل‌های متعلق به هر کاربر و گروه را ارائه می‌دهد.

    در ادامه، نتایج خروجی اسکریپت array-2 را (که برای اختصار تلخیص شده است) هنگام واکاوی دایرکتوری /usr/bin/ مشاهده می‌کنید:

    [me@linuxbox ~]$ array-2 /usr/bin
    /usr/bin/2to3-2.6             root    root
    /usr/bin/2to3                 root    root
    /usr/bin/a2p                  root    root
    /usr/bin/abrowser             root    root
    /usr/bin/aconnect             root    root
    /usr/bin/acpi_fakekey         root    root
    /usr/bin/acpi_listen          root    root
    /usr/bin/add-apt-repository   root    root
    .
    .
    /usr/bin/zipgrep              root    root
    /usr/bin/zipinfo              root    root
    /usr/bin/zipnote              root    root
    /usr/bin/zip                  root    root
    /usr/bin/zipsplit             root    root
    /usr/bin/zjsdecode            root    root
    /usr/bin/zsoelim              root    root
    
    File owners:
    daemon  :     1 file(s)
    root    :  1394 file(s)
    
    File group owners:
    crontab :     1 file(s)
    daemon  :     1 file(s)
    lpadmin :     1 file(s)
    mail    :     4 file(s)
    mlocate :     1 file(s)
    root    :  1380 file(s)
    shadow  :     2 file(s)
    ssh     :     1 file(s)
    tty     :     2 file(s)
    utmp    :   2 file(s)

    در بخش زیر، متن کامل اسکریپت به همراه شماره‌گذاری خطوط جهت تحلیل فنی ارائه شده است:

     1  #!/bin/bash
     2
     3  # array-2: Use arrays to tally file owners
     4
     5  declare -A files file_group file_owner groups owners
     6
     7  if [[ ! -d "$1" ]]; then
     8      echo "Usage: array-2 dir" >&2
     9      exit 1
    10  fi
    11
    12  for i in "$1"/*; do
    13      owner="$(stat -c %U "$i")"
    14      group="$(stat -c %G "$i")"
    15      files["$i"]="$i"
    16      file_owner["$i"]="$owner"
    17      file_group["$i"]="$group"
    18      ((++owners[$owner]))
    19      ((++groups[$group]))
    20  done
    21
    22  # List the collected files
    23  { for i in "${files[@]}"; do
    24      printf "%-40s %-10s %-10s\n" \
    25          "$i" "${file_owner["$i"]}" "${file_group["$i"]}"
    26  done } | sort
    27  echo
    28
    29  # List owners
    30  echo "File owners:"
    31  { for i in "${!owners[@]}"; do
    32      printf "%-10s: %5d file(s)\n" "$i" "${owners["$i"]}"
    33  done } | sort
    34  echo
    35
    36  # List groups
    37  echo "File group owners:"
    38  { for i in "${!groups[@]}"; do
    39      printf "%-10s: %5d file(s)\n" "$i" "${groups["$i"]}"
    40  done } | sort

    تحلیل فنی و کالبدشکافی مکانیسم اجرایی اسکریپت array-2 به شرح زیر است:

    خط ۵: در این بخش، آرایه‌های انجمنی با استفاده از دستور declare و گزینه -A به صورت صریح تعریف شده‌اند. در این اسکریپت، پنج آرایه با وظایف متمایز ایجاد شده‌اند:

    • files: ذخیره‌سازی نام فایل‌های دایرکتوری (با استفاده از نام فایل به عنوان کلید).
    • file_group: نگاشت مالک گروه (Group Owner) به هر فایل.
    • file_owner: نگاشت مالک (User Owner) به هر فایل.
    • groups: شمارشگر تعداد فایل‌های متعلق به هر گروه.
    • owners: شمارشگر تعداد فایل‌های متعلق به هر مالک.

    خطوط ۷ تا ۱۰: این بخش شرطی اعتبار پارامتر ورودی را بررسی می‌کند. اگر مسیر ارسالی یک دایرکتوری معتبر نباشد، راهنمای استفاده از برنامه در خروجی خطای استاندارد (stderr) چاپ شده و اسکریپت با وضعیت خروجی 1 (نشان‌دهنده خطا) متوقف می‌شود.

    خطوط ۱۲ تا ۲۰: این حلقه فرآیند پیمایش فایل‌ها را بر عهده دارد. با بهره‌گیری از دستور stat در خطوط ۱۳ و ۱۴، نام مالک و گروه هر فایل استخراج شده و در آرایه‌های مربوطه ذخیره می‌گردند. در خط ۱۵ نیز خودِ نام فایل به عنوان مقدار در آرایه files درج می‌شود تا ساختار داده‌ها تکمیل گردد.

    خطوط ۱۸ و ۱۹: در این دو خط، از ویژگی محاسباتی پوسته برای افزایش واحد (Increment) استفاده شده است. هر بار که مالکی مشاهده می‌شود، مقدار متناظر با آن کلید در آرایه‌های owners و groups یک واحد افزایش می‌یابد تا آمار نهایی استخراج شود.

    خطوط ۲۲ تا ۲۷: در این مرحله، فهرست فایل‌ها چاپ می‌شود. استفاده از عبارت "${array[@]}" تضمین می‌کند که تمامی عناصر آرایه به‌صورت کلمات مجزا پردازش شوند؛ این امر برای مدیریت صحیح فایل‌هایی که نام آن‌ها حاوی «فاصله» (Space) است، حیاتی است. نکته کلیدی در اینجا محصور کردن کل حلقه در آکولاد و تشکیل یک دستور گروهی است. از آنجا که عناصر آرایه‌های انجمنی فاقد ترتیب (Order) هستند، خروجی کل حلقه به‌صورت یکپارچه به دستور sort تزریق می‌شود تا فهرستی مرتب به کاربر ارائه گردد.

    خطوط ۲۹ تا ۴۰: این دو حلقه ساختاری مشابه بخش قبل دارند، با این تفاوت که از بسط پارامتر به فرم "${!array[@]}" استفاده می‌کنند. این نحو نگارش به جای بازگرداندن مقادیر، فهرستی از کلیدها (اندیس‌ها) را بازمی‌گرداند که در اینجا همان نام مالکین و گروه‌ها هستند.

    جایگزینی فرآیند (Process Substitution) #

    در فصل ۲۸، با چالش‌های محیط زیرپوسته آشنا شدیم؛ جایی که دریافتیم دستور read در یک پایپ‌لاین (Pipeline) مطابق انتظار عمل نمی‌کند. برای یادآوری، اگر یک پایپ‌لاین مشابه نمونه زیر ایجاد کنیم:

    echo "foo" | read
    echo $REPLY

    مقدار متغیر REPLY همواره تهی خواهد بود؛ زیرا دستور read در یک زیرپوسته اجرا شده و متغیر REPLY ایجاد شده در آن، بلافاصله پس از خاتمه فرآیند زیرپوسته از بین می‌رود. از آنجا که در ساختار پایپ‌لاین، تمام دستورات در زیرپوسته‌ها اجرا می‌شوند، هر دستوری که وظیفه مقداردهی به یک متغیر را بر عهده دارد با این محدودیت مواجه خواهد شد. خوشبختانه، پوسته Bash مکانیزم خاصی به نام جایگزینی فرآیند را برای حل این معضل ارائه می‌دهد. جایگزینی فرآیند به دو صورت نحوی بیان می‌شود:

    برای فرآیندهایی که خروجی استاندارد تولید می‌کنند:

    <(list)

    برای فرآیندهایی که ورودی استاندارد می‌پذیرند:

    >(list)

    در اینجا list مجموعه‌ای از دستورات اجرایی است. برای حل مشکل دستور read در مثال قبل، می‌توانیم از جایگزینی فرآیند به شکل زیر بهره ببریم:

    read < <(echo "foo")
    echo $REPLY

    جایگزینی فرآیند به ما این امکان را می‌دهد که خروجی یک زیرپوسته را برای مقاصد بازهدایت (Redirection)، مشابه یک «فایل معمولی» در نظر بگیریم. از آنجا که این قابلیت نوعی بسط (Expansion) محسوب می‌شود، می‌توانیم مقدار واقعی آن را مشاهده کنیم:

    [me@linuxbox ~]$ echo <(echo "foo")
    /dev/fd/63

    با استفاده از دستور echo برای بررسی نتیجه بسط، درمی‌یابیم که خروجی زیرپوسته از طریق یک توصیف‌گر فایل با آدرس /dev/fd/63 (یا مشابه آن) در دسترس قرار گرفته است.

    این تکنیک اغلب در حلقه‌هایی که با دستور read کار می‌کنند استفاده می‌شود. در مثال زیر، یک حلقه read محتویات فهرستی از فایل‌ها را که توسط یک زیرپوسته تولید شده است، پردازش می‌کند:

    #!/bin/bash
    # pro-sub: demo of process substitution
    
    while read -r attr links owner group size date time filename; do
        cat << _EOF_
    Filename:   $filename
    Size:       $size
    Owner:      $owner
    Group:      $group
    Modified:   $date $time
    Links:      $links
    Attributes: $attr
    
    _EOF_
    done < <(ls -l --time-style="+%F %H:%m"| tail -n +2)

    در این اسکریپت، حلقه برای هر سطر از فهرست فایل‌ها، دستور read را اجرا می‌کند. منبع داده در سطر پایانی اسکریپت تعریف شده است؛ جایی که خروجی حاصل از جایگزینی فرآیند به ورودی استاندارد (stdin) حلقه هدایت می‌شود. استفاده از دستور tail در پایپ‌لاین داخلی، برای حذف سطر اول خروجی ls (سطر Total) است که در پردازش ما مورد نیاز نیست.

    پس از اجرا، اسکریپت خروجی منظمی مشابه زیر تولید خواهد کرد:

    [me@linuxbox ~]$ pro-sub | head -n 20
    Filename:   addresses.ldif
    Size:       14540
    Owner:      me
    Group:      me
    Modified:   2009-04-02 11:12
    Links:      1
    Attributes: -rw-r--r--
    
    Filename:   bin
    Size:       4096
    Owner:      me
    Group:      me
    Modified:   2009-07-10 07:31
    Links:      2
    Attributes: drwxr-xr-x
    
    Filename:   bookmarks.html
    Size:       394213
    Owner:      me
    Group:      me

    پردازش پویا با دستور eval #

    دستور داخلی eval یکی از ابزارهای چالش‌برانگیز و در عین حال قدرتمند در پوسته Bash است. در تعریف ساده، این دستور فهرستی از آرگومان‌ها را دریافت کرده، آن‌ها را به یک رشته واحد تبدیل می‌کند و سپس آن رشته را برای اجرا به خودِ پوسته بازمی‌گرداند. پرسش کلیدی این است: در چه سناریوهایی به این دستور نیاز داریم؟

    در برنامه‌نویسی پوسته، گاهی لازم است یک دستور را به‌صورت پویا (Dynamic)، یعنی در حین اجرای اسکریپت، تولید کنیم. بیایید با یک آزمایش ساده شروع کنیم:

    می‌توان یک دستور را در قالب یک متغیر رشته‌ای ذخیره کرد و سپس با استفاده از بسط پارامتر، آن را فراخوانی نمود:

    [me@linuxbox ~]$ cmd="echo foo"
    [me@linuxbox ~]$ $cmd
    foo
    [me@linuxbox ~]$

    حال بررسی می‌کنیم که اگر در دستور ما متغیر دیگری وجود داشته باشد، چه رخ می‌دهد:

    [me@linuxbox ~]$ str=abcde
    [me@linuxbox ~]$ cmd="echo $str"
    [me@linuxbox ~]$ $cmd
    abcde
    [me@linuxbox ~]$

    تا اینجا خروجی مطابق انتظار است. اما اگر مقدار متغیر str تغییر کند:

    [me@linuxbox ~]$ str=ABCDE
    [me@linuxbox ~]$ $cmd
    abcde
    [me@linuxbox ~]$

    مشاهده می‌شود که خروجی تغییر نکرد؛ زیرا در لحظه مقداردهی به cmd، متغیر str بسط یافته و مقدار قبلی در آن ثابت گشته است. برای اینکه بسط متغیر را به تعویق بیندازیم، از «تک‌کوتیشن» استفاده می‌کنیم:

    [me@linuxbox ~]$ cmd='echo $str'
    [me@linuxbox ~]$ $cmd
    $str
    [me@linuxbox ~]$

    در اینجا، پوسته تنها یک مرحله بسط انجام می‌دهد؛ یعنی $cmd به رشته 'echo $str' تبدیل می‌شود، اما مرحله دوم بسط (تبدیل $str به مقدار واقعی‌اش) رخ نمی‌دهد.

    اینجاست که دستور eval وارد عمل می‌شود تا سطح دوم (یا چندم) بسط را ممکن سازد:

    [me@linuxbox ~]$ str=abcde
    [me@linuxbox ~]$ cmd='echo $str'
    [me@linuxbox ~]$ eval "$cmd"
    abcde
    [me@linuxbox ~]$ str=ABCDE
    [me@linuxbox ~]$ eval "$cmd"
    ABCDE
    [me@linuxbox ~]$

    عملکرد دقیق eval به این صورت است: ابتدا آرگومان‌های خود را در یک رشته ادغام می‌کند، سپس روی محتوای آن رشته انواع بسط‌ها (مانند بسط تیلدا ~، پارامتر $VAR و جایگزینی مسیر فایل) را انجام داده و در نهایت، خروجی نهایی را در پوسته جاری (بدون ایجاد زیرپوسته) اجرا می‌کند.

    مخاطرات امنیتی دستور eval #

    دستور eval در میان توسعه‌دهندگان به بدنامی شهرت یافته است. علت این امر، پتانسیل بالای این دستور در ایجاد حفره‌های امنیتی در اسکریپت‌های پوسته است. چنانچه رشته ورودی به eval از منابع خارجی (مانند ورودی‌های مستقیم کاربر) تأمین شود، ریسک اجرای فرامین مخرب بدون مجوز افزایش می‌یابد؛ پدیده‌ای که تحت عنوان «حمله تزریق کد» (Code Injection) شناخته می‌شود. بنابراین، همواره پیش از ارجاع هرگونه محتوا به eval، اعتبارسنجی و پالایش دقیق داده‌ها الزامی است.

    اسکریپت کمکی بازی «وردل» #

    در اسکریپتی که در ادامه بررسی خواهیم کرد، از قابلیت‌های eval برای استخراج پاسخ‌های احتمالی در بازی «وردل» بهره می‌گیریم. برای آن دسته از مخاطبانی که با این بازی پرطرفدار آشنایی ندارند، ویکی‌پدیا آن را چنین تعریف می‌کند:

    «وردل یک بازی واژگان مبتنی بر وب است که توسط مهندس نرم‌افزار ولزی، جاش واردل، طراحی و توسعه یافته است. در این بازی، بازیکنان شش فرصت برای حدس زدن یک کلمه پنج‌حرفی دارند. پس از هر حدس، بازخورد سیستم در قالب کاشی‌های رنگی ارائه می‌شود؛ این رنگ‌ها مشخص می‌کنند که کدام حروف در کلمه وجود دارند و آیا در جایگاه صحیح خود قرار گرفته‌اند یا خیر.»

    در اسکریپت زیر، ما از داده‌های خروجی بازی برای فیلتر کردن هوشمند فهرست کلمات و یافتن محتمل‌ترین گزینه‌ها استفاده می‌کنیم.

    به طور خلاصه، پس از هر بار حدس زدن، سیستم بازی مشخص می‌کند که آیا حروف انتخاب شده در کلمه هدف وجود دارند یا خیر، و همچنین آیا در جایگاه صحیح خود قرار گرفته‌اند یا نه. بدین ترتیب، با هر تلاش اطلاعات بیشتری از واژه مجهول به دست می‌آید تا در نهایت (طبق هدف بازی) در کمترین تعداد دفعات، کلمه اصلی کشف شود.

    این اسکریپت کمکی، فهرستی از واژگانی را استخراج می‌کند که با داده‌های حاصل از حدس‌های قبلی مطابقت دارند. برای این منظور، برنامه یک عبارت باقاعده (Regular Expression) ساده را دریافت می‌کند که نشان‌دهنده حروف قطعی و جایگاه آن‌هاست. علاوه بر این، فهرستی از حروف موجود (بدون جایگاه مشخص) و حروف کاملاً ناموجود در کلمه را نیز به عنوان ورودی می‌پذیرد.

    فرض کنید کلمه هدف «about» باشد و ما واژه «bloat» را حدس زده باشیم. در این سناریو، بازی اعلام می‌کند که حروف «o» و «t» دقیقاً در جایگاه خود هستند، حروف «a» و «b» در کلمه وجود دارند اما در جایگاهی دیگر، و حرف «l» اصلاً در کلمه وجود ندارد. در چنین شرایطی، اسکریپت را به صورت زیر اجرا می‌کنیم:

    [me@linuxbox ~]$ eval-wordle ..o.t +a +b -l

    در این فرمان، آرگومان اول یک عبارت باقاعده پنج‌حرفی است که جایگاه تثبیت‌شده حروف «o» و «t» را نشان می‌دهد. سایر آرگومان‌ها نیز حروف موجود یا ناموجود را مشخص می‌کنند. خروجی اسکریپت به شرح زیر خواهد بود:

    abort
    about
    2

    این خروجی تأیید می‌کند که بر اساس معیارهای تعیین شده، تنها دو واژه در لغت‌نامه با شرایط مطابقت دارند.

    این اسکریپت با پالایش محتوای یک واژه‌نامه سیستمی (/usr/share/dict/words/) بر اساس معیارهای تعیین‌شده، واژگان باقی‌مانده را استخراج می‌کند. بدین منظور، یک پایپ‌لاین (Pipeline) چندمرحله‌ای و طولانی به‌صورت پویا ایجاد می‌شود که طول آن مستقیماً به تعداد پارامترهای ورودی در خط فرمان بستگی دارد. مزیت این روش، عدم نیاز به فایل‌های موقت برای ذخیره‌سازی نتایج میانی است.

     1  #!/bin/bash
    
     2  # eval-wordle - demonstrate eval by solving wordle puzzles
    
     3  PROGNAME=${0##*/}
     4  DICTIONARY=/usr/share/dict/words
    
     5  usage() {
     6      printf "%s\n" "Usage: ${PROGNAME} [-h|--help]"
     7      printf "%s\n" "       ${PROGNAME} regex +-char..."
     8  }
    
     9  help_message() {
    10      cat << _EOF_
    11  $PROGNAME - Wordle Helper
    
    12  $(usage)
    
    13  Options:
    14      -h, --help     Display this help message and exit.
    
    15  Arguments:
    16  The first argument must be a five character regular
    17  expression at minimum of '.....' representing five
    18  unknown characters in the answer. This is followed by
    19  zero or more character known to be either present or
    20  absent from the answer. These are expressed as either
    21  +char for letters known to be present or -char for
    22  letters known to not be in the answer.
    
    23  Example:
    
    24  $PROGNAME a.... +o -v
    
    25  This means we know that the answer starts with 'a' in
    26  the first position and also contains an 'o' but does
    27  not contain a 'v'.
    
      _EOF_
    
    28   return
    29  }
    
    30  add_plus() { # Add a letter
    31      local char="$1"
    
    32      echo " | grep $char"
    33      return
    34  }
    
    35  add_minus() { # Subtract a letter
    36      local char="$1"
    
    37      echo " | grep -v $char"
    38      return
    39  }
    
    40  # Parse command-line
    
    41  if [[ "$1" == "-h" || "$1" == "--help" ]]; then
    42      help_message
    43      exit 0
    44  fi
    
    45  if (( "${#1}" == 5 )); then
    46      known_chars="$1"
    47  shift
    48  else
    49      echo "First argument must be a 5 character regex." >&2
    50      exit 1
    51  fi
    
    52  cmd="LANG=C grep '^.....$' $DICTIONARY \
    53  | grep -v '[[:punct:]]' \
    54  | grep -v '[[:upper:]]' \
    55  | grep '$known_chars'"
    
    56  while [[ -n "$1" ]]; do
    57      case "$1" in
    58          -[[:alpha:]])
    59              cmd="${cmd}$(add_minus "${1:1}")"
    60              ;;
    61          +[[:alpha:]])
    62              cmd="${cmd}$(add_plus "${1:1}")"
    63              ;;
    64          *)
    65              echo "Invalid argument '$1'" >&2
    66              exit 1
    67              ;;
    68      esac
    69      shift
    70  done
    
    71  eval "$cmd | tee >(wc -l)"

    تحلیل ویژگی‌های فنی اسکریپت:

    خطوط ۳۰ تا ۳۹ (توابع کمکی): دو تابع کمکی در این محدوده تعریف شده‌اند. تابع add_plus (خطوط ۳۰ تا ۳۴) یک فیلتر grep تولید می‌کند که برای الزام حضور یک حرف خاص به کار می‌رود. تابع add_minus (خطوط ۳۵ تا ۳۹) نیز یک فیلتر grep -v ایجاد می‌کند که برای حذف کلمات حاوی حروف غیرمجاز استفاده می‌شود.

    خطوط ۴۱ تا ۵۱ (پردازش آرگومان‌های ورودی): در این محدوده، ابتدا خطوط ۴۱ تا ۴۴ بررسی می‌کنند که آیا آرگومان اول، درخواست راهنما (-h یا --help) است یا خیر؛ در صورت مثبت بودن، پیام راهنما نمایش داده شده و اسکریپت با کد خروج 0 متوقف می‌شود. سپس در خطوط ۴۵ تا ۵۱، از درستی آرگومان اول اطمینان حاصل می‌شود: اگر طول آن دقیقاً 5 کاراکتر نباشد، اسکریپت با پیام خطا و کد خروج 1 پایان می‌یابد.

    خطوط ۵۲ تا ۵۵ (پیکربندی اولیه پایپ‌لاین): ساخت اولیه‌ی دستور (متغیر cmd) در این چهار خط انجام می‌گیرد. ابتدا (خط ۵۲) واژه‌نامه با یک عبارت باقاعده که کلمات دقیقاً ۵ حرفی را انتخاب می‌کند، پالایش می‌شود. سپس (خطوط ۵۳ و ۵۴) به‌ترتیب کلمات دارای علائم نگارشی و کلمات دارای حروف بزرگ (اسامی خاص) از نتایج حذف می‌شوند. در نهایت (خط ۵۵) فیلتر مربوط به known_chars، یعنی عبارت باقاعده‌ی دریافتی از آرگومان اول، به پایپ‌لاین افزوده می‌شود.

    خط ۵۶ تا ۷۰ (حلقه‌ی پردازش آرگومان‌های اضافی): حلقه‌ی while در خط ۵۶ آغاز می‌شود و ساختار case مربوط به آن در خط ۵۷ قرار دارد. این حلقه سایر آرگومان‌های خط فرمان را که با علامت + یا - آغاز می‌شوند پیمایش کرده (الگوهای case در خطوط ۵۸ و ۶۱) و با فراخوانی توابع کمکی، فیلترهای مربوطه را به متغیر cmd اضافه می‌کند؛ در صورت نامعتبر بودن آرگومان (خطوط ۶۴ تا ۶۷)، پیام خطا چاپ شده و اسکریپت متوقف می‌شود. حلقه در خط ۷۰ با done بسته می‌شود.

    خط ۷۱ (اجرای نهایی): در این خط، دستور eval فرمان نهایی ذخیره‌شده در cmd را اجرا می‌کند. خروجی این پایپ‌لاین به دستور tee ارسال می‌شود تا هم در خروجی استاندارد نمایش داده شود و هم به یک «جایگزینی فرآیند» (Process Substitution) هدایت گردد که در آن دستور wc -l برای شمارش تعداد خطوط اجرا می‌شود؛ این روش آمار نهایی را بدون نیاز به ایجاد فایل موقت محاسبه می‌کند.

    مدیریت سیگنال‌ها با دستور trap #

    در فصل دهم، چگونگی تعامل و پاسخ‌دهی برنامه‌ها به سیگنال‌های سیستم را بررسی کردیم. این قابلیت ارزشمند را می‌توان به اسکریپت‌های پوسته نیز تعمیم داد. اگرچه اسکریپت‌های ساده به دلیل زمان اجرای کوتاه و عدم تولید فایل‌های موقت، نیازی به این ویژگی ندارند، اما در پروژه‌های بزرگ‌تر و پیچیده‌تر، پیاده‌سازی یک روال قاعده‌مند برای مدیریت سیگنال (Signal Handling) امری ضروری است.

    هنگام طراحی اسکریپت‌های جامع، باید سناریوهایی نظیر خروج ناگهانی کاربر از سیستم (Logout) یا خاموش شدن سیستم در حین اجرای برنامه را پیش‌بینی کرد. در چنین شرایطی، سیگنال‌های خاصی به تمامی فرآیندهای درگیر ارسال می‌شود. برنامه‌های استاندارد با دریافت این سیگنال‌ها، تدابیری اتخاذ می‌کنند تا خروج از برنامه به‌صورت امن و منظم انجام شود.

    به‌عنوان مثال، تصور کنید اسکریپتی طراحی کرده‌اید که در طول فرآیند خود، یک فایل موقت (Temporary File) ایجاد می‌کند. بر اساس اصول طراحی بهینه، اسکریپت باید پس از تکمیل عملیات، فایل مذکور را پاکسازی کند. علاوه بر این، رویکرد هوشمندانه حکم می‌کند که اگر برنامه بر اثر دریافت یک سیگنال خارجی به‌طور غیرمنتظره متوقف شد، باز هم مکانیزمی برای حذف آن فایل و جلوگیری از انباشت داده‌های زائد وجود داشته باشد.

    پوسته Bash مکانیزمی را برای این هدف در نظر گرفته است که تحت عنوان تله (Trap) شناخته می‌شود. این قابلیت از طریق فرمان داخلی trap پیاده‌سازی شده و از نحو (Syntax) زیر پیروی می‌کند:

    trap argument signal [signal...]

    در این ساختار، argument رشته‌ای حاوی فرامینی است که باید اجرا شوند و signal معرف سیگنالی است که ماشه اجرای آن فرامین را فعال می‌کند.

    در ادامه، یک نمونه ساده از مدیریت سیگنال ارائه شده است:

    #!/bin/bash
    # trap-demo: simple signal handling demo
    
    trap "echo 'I am ignoring you.'" SIGINT SIGTERM
    
    for i in {1..5}; do
        echo "Iteration $i of 5"
        sleep 5
    done

    این اسکریپت تله‌ای را تعریف می‌کند که با دریافت سیگنال‌های SIGINT (ارسال شده توسط کلیدهای ترکیبی Ctrl+c) یا SIGTERM (سیگنال خاتمه استاندارد)، دستور echo را اجرا می‌کند. خروجی برنامه هنگام تلاش کاربر برای متوقف کردن آن به شرح زیر است:

    [me@linuxbox ~]$ trap-demo
    Iteration 1 of 5
    Iteration 2 of 5
    ^CI am ignoring you.
    Iteration 3 of 5
    ^CI am ignoring you.
    Iteration 4 of 5
    Iteration 5 of 5

    همان‌طور که مشاهده می‌شود، با هر بار تلاش کاربر برای قطع برنامه، پیام جایگزین چاپ شده و اسکریپت به کار خود ادامه می‌دهد.

    از آنجا که گنجاندن توالی پیچیده‌ای از دستورات در قالب یک رشته متنی دشوار و غیراصولی است، روش معمول آن است که یک تابع (Function) برای مدیریت سیگنال تعریف و فراخوانی شود. در مثال زیر، برای هر سیگنال ورودی، یک تابع مجزا در نظر گرفته شده است:

    #!/bin/bash
    
    # trap-demo2: simple signal handling demo
    
    exit_on_signal_SIGINT () {
        echo "Script interrupted." 2>&1
        exit 0
    }
    
    exit_on_signal_SIGTERM () {
        echo "Script terminated." 2>&1
        exit 0
    }
    
    trap exit_on_signal_SIGINT SIGINT
    trap exit_on_signal_SIGTERM SIGTERM
    
    for i in {1..5}; do
        echo "Iteration $i of 5"
        sleep 5
    done

    این اسکریپت از دو دستور trap بهره می‌برد که هر کدام به تابعی خاص متصل شده‌اند. نکته حائز اهمیت، وجود دستور exit در انتهای این توابع است؛ چرا که بدون فراخوانی صریح exit، اسکریپت پس از اجرای بدنهٔ تله، به روند عادی خود بازگشته و متوقف نخواهد شد.

    هنگامی که کاربر در حین اجرای این اسکریپت از کلید ترکیبی Ctrl+c استفاده می‌کند، خروجی به شرح زیر خواهد بود:

    [me@linuxbox ~]$ trap-demo2
    Iteration 1 of 5
    Iteration 2 of 5
    ^CScript interrupted.

    فرمان داخلی trap علاوه بر سیگنال‌های استاندارد سیستم‌عامل، از چندین سیگنال اختصاصی پوسته (Internal Shell Signals) نیز پشتیبانی می‌کند که در مدیریت خطاهای اجرایی بسیار کارآمد هستند. دو مورد از کاربردی‌ترینِ این سیگنال‌ها، EXIT و ERR نام دارند.

    تله EXIT به محض خاتمه یافتن اسکریپت (به هر دلیلی) فعال می‌شود. تله ERR نیز زمانی فعال می‌شود که یک فرمان با وضعیت خروجی (Exit Status) غیرصفر پایان یابد. این قابلیت، در واقع نسخه‌ای هوشمندتر و انعطاف‌پذیرتر از گزینه set -e است که پیش‌تر در مبحث عیب‌یابی اسکریپت‌ها بررسی کردیم.

    در ادامه، اسکریپتی برای نمایش عملکرد این دو تله ارائه شده است. به خط شماره ۵ توجه کنید که حاوی یک خطای عمدی برای تحریک تله است:

     1  #!/bin/bash
    
     2  # trap-demo3 - demonstrate ERR and EXIT signal handling
    
     3  trap "echo \"There is an error.\"" ERR
     4  trap "echo \"The program has ended.\"" EXIT
    
     5  echox "Running..."
    
     6  read -r -p "Say something... " something
     7  echo "$something"

    در این اسکریپت، ابتدا تله‌ها تعریف می‌شوند. سپس در خط ۵، سعی می‌شود پیامی چاپ شود، اما دستور echo به اشتباه echox تایپ شده است. به محض بروز این خطا، تله ERR فعال شده و پیام خطا را چاپ می‌کند. با این حال، برخلاف دستور set -e، اسکریپت متوقف نمی‌شود و به خط بعدی می‌رود تا منتظر ورودی کاربر بماند. در نهایت، پس از اتمام اجرای آخرین دستور، تله EXIT فعال شده و پیام پایان برنامه را نمایش می‌دهد.

    پس از اجرای اسکریپت فوق، خروجی عملیاتی به شرح زیر در ترمینال ظاهر می‌شود:

    [me@linuxbox ~]$ trap-demo3
    ./trap-demo3: line 8: echox: command not found
    There is an error.
    Say something...
    
    The program has ended.

    تحلیل توالی رویدادها در این خروجی بسیار آموزنده است. ابتدا پیام خطای استاندارد پوسته مشاهده می‌شود که از عدم وجود دستور echox خبر می‌دهد. بلافاصله پس از آن، تله ERR فعال شده و رشته تعیین‌شده را در خروجی چاپ می‌کند. در گام بعد، اسکریپت متوقف نشده و دستور read اجرا می‌شود. با فشردن کلید ENTER توسط کاربر، فرآیند اجرای دستورات به پایان رسیده و در نهایت تله EXIT فعال می‌گردد تا اتمام برنامه را اعلام کند.

    این رفتار نشان‌دهنده تفاوت بنیادین میان مدیریت خطا با استفاده از تله‌ها و توقف اجباری اسکریپت است؛ در واقع تله‌ها به ما اجازه می‌دهند بدون قطع لزوماً روند برنامه، نسبت به رخدادهای غیرمنتظره واکنش نشان دهیم.

    مدیریت فایل‌های موقت (Temporary Files) #

    یکی از دلایل اصلی تعبیه «مدیریت‌کننده‌های سیگنال» (Signal Handlers) در اسکریپت‌ها، پاک‌سازی فایل‌های موقتی است که برنامه برای ذخیره نتایج میانی در طول چرخه حیات خود ایجاد می‌کند. نام‌گذاری اصولی فایل‌های موقت در دنیای یونیکس و لینوکس فراتر از یک انتخاب ساده و در واقع نوعی مهارت فنی است. به‌طور سنتی، برنامه‌ها در سیستم‌های شبه‌یونیکس فایل‌های موقت خود را در مسیر /tmp ایجاد می‌کنند؛ دایرکتوری مشترکی که دقیقاً برای همین منظور طراحی شده است. با این حال، ماهیت اشتراکی این دایرکتوری مخاطرات امنیتی خاصی را به‌ویژه برای اسکریپت‌هایی که با دسترسی ابرکاربر (Root) اجرا می‌شوند، به همراه دارد.

    علاوه بر گام بدیهیِ تنظیم سطوح دسترسی (Permissions) مناسب برای فایل‌هایی که در محیطی عمومی قرار دارند، «پیش‌بینی‌ناپذیر بودن» نام این فایل‌ها اهمیتی حیاتی دارد. این رویکرد مانع از نوعی آسیب‌پذیری امنیتی به نام شرایط رقابتی در فایل‌های موقت (Race Condition in Temp Files) می‌شود. یکی از روش‌های سنتی برای ایجاد نامی پیش‌بینی‌ناپذیر اما توصیفی، استفاده از الگوی زیر است:

    tempfile=/tmp/$(basename $0).$$.$RANDOM

    این دستور نام فایلی را می‌سازد که ترکیبی از نام اسکریپت، شناسه فرآیند (PID) و یک عدد تصادفی است. با این حال، باید توجه داشت که متغیر $RANDOM در پوسته Bash تنها عددی بین ۱ تا ۳۲۷۶۷ تولید می‌کند؛ این بازه در مقیاس محاسباتی چندان بزرگ نیست و استفاده از آن به‌تنهایی ممکن است در برابر یک مهاجم حرفه‌ای و مصمم کارساز نباشد.

    روش استاندارد و ایمن‌تر، بهره‌گیری از ابزار mktemp است (که نباید با تابع کتابخانه‌ای mktemp در زبان C اشتباه گرفته شود). این برنامه یک «الگو» (Template) را به عنوان آرگومان دریافت کرده و بر اساس آن، فایل موقت را ایجاد و نام‌گذاری می‌کند. الگو باید شامل رشته‌ای از کاراکترهای "X" باشد که با حروف و اعداد تصادفی جایگزین می‌شوند. هرچه تعداد "X"ها بیشتر باشد، پیچیدگی و امنیت نام تولید شده بالاتر خواهد بود:

    tempfile=$(mktemp /tmp/foobar.$$.XXXXXXXXXX)

    این دستور فایل را ایجاد کرده و مسیر دقیق آن را در متغیر tempfile ذخیره می‌کند. کاراکترهای الگو با مقادیر تصادفی جایگزین شده و خروجی نهایی (که در این مثال PID اسکریپت را نیز شامل می‌شود) چیزی شبیه به نمونه زیر خواهد بود:

    /tmp/foobar.6593.UOZuvM6654

    برای اسکریپت‌هایی که توسط کاربران عادی اجرا می‌شوند، به‌جای استفاده از دایرکتوری عمومی /tmp، توصیه می‌شود یک دایرکتوری اختصاصی برای فایل‌های موقت در دایرکتوری خانگی کاربر ایجاد شود، به‌عنوان مثال:

    [[ -d $HOME/tmp ]] || mkdir $HOME/tmp

    اجرای ناهمگام (Asynchronous Execution) #

    در برخی سناریوها، اجرای هم‌زمان چندین وظیفه به‌جای پردازش ترتیبی آن‌ها ضرورت می‌یابد. همان‌طور که می‌دانیم، تمامی سیستم‌عامل‌های مدرن از قابلیت چندوظیفگی (Multitasking) و در بسیاری از موارد چندکاربری (Multiuser) پشتیبانی می‌کنند. اسکریپت‌های پوسته نیز می‌توانند به‌گونه‌ای طراحی شوند که از این ظرفیت برای اجرای موازی عملیات بهره ببرند.

    این سازوکار معمولاً شامل اجرای یک اسکریپت والد است که یک یا چند اسکریپت فرزند را برای انجام وظایف جانبی فراخوانی می‌کند، در حالی که خود به اجرای دستورات اصلی ادامه می‌دهد. با این حال، زمانی که مجموعه‌ای از اسکریپت‌ها به‌صورت ناهمگام اجرا می‌شوند، چالش هماهنگ‌سازی (Synchronization) بین فرآیند والد و فرزند پدید می‌آید. به‌عبارت دیگر، اگر اسکریپت والد برای تکمیل نهایی کار خود به نتایج اسکریپت فرزند وابسته باشد، باید مکانیزمی برای انتظار و تایید اتمام کار فرزند وجود داشته باشد.

    پوسته Bash برای مدیریت این تعاملات ناهمگام، فرمان داخلی wait را ارائه کرده است. استفاده از دستور wait باعث می‌شود که اجرای اسکریپت والد تا زمان خاتمه یافتن یک فرآیند مشخص (معمولاً اسکریپت فرزند که در پس‌زمینه اجرا شده است) متوقف بماند.

    هماهنگ‌سازی فرآیندها با دستور wait #

    برای درک بهتر عملکرد دستور wait در مدیریت فرآیندهای ناهمگام، از یک سناریوی عملی شامل دو اسکریپت «والد» و «فرزند» استفاده می‌کنیم. ابتدا اسکریپت والد را بررسی می‌کنیم که وظیفه مدیریت چرخه حیات فرآیند فرزند را بر عهده دارد:

    #!/bin/bash
    
    # async-parent: Asynchronous execution demo (parent)
    
    echo "Parent: starting..."
    
    echo "Parent: launching child script..."
    async-child &
    pid=$!
    
    echo "Parent: child (PID= $pid) launched."
    
    echo "Parent: continuing..."
    sleep 2
    
    echo "Parent: pausing to wait for child to finish..."
    wait "$pid"
    
    echo "Parent: child is finished. Continuing..."
    echo "Parent: parent is done. Exiting."

    در مرحله بعد، اسکریپت فرزند را تعریف می‌کنیم که یک وظیفه زمان‌بر (در اینجا یک توقف ۵ ثانیه‌ای) را شبیه‌سازی می‌کند:

    #!/bin/bash
    
    # async-child: Asynchronous execution demo (child)
    
    echo "Child: child is running..."
    sleep 5
    echo "Child: child is done. Exiting."

    در این مدل، اسکریپت فرزند ساختار ساده‌ای دارد و منطق اصلی در اسکریپت والد پیاده‌سازی شده است. فرآیند والد پس از اجرای فرآیند فرزند، آن را با استفاده از عملگر & به پس‌زمینه (Background) می‌فرستد. بلافاصله با بهره‌گیری از پارامتر ویژه $! (که همواره حاوی PID آخرین پردازش اجرا شده در پس‌زمینه است)، شناسه فرآیند فرزند در متغیر pid ذخیره می‌شود.

    اسکریپت والد پس از انجام برخی کارهای موازی، به نقطه‌ای می‌رسد که برای ادامه مسیر به اتمام کار فرآیند فرزند نیاز دارد. در این مرحله، دستور wait به همراه PID فرزند فراخوانی می‌شود. این دستور باعث می‌شود تا اجرای اسکریپت والد دقیقاً در همین خط متوقف (Block) شود و تنها زمانی ادامه یابد که فرآیند فرزند با موفقیت یا خطا خاتمه یافته و سیگنال خروج خود را ارسال کند.

    پس از اجرای هم‌زمان، خروجی تعامل میان اسکریپت‌های والد و فرزند به شرح زیر در ترمینال نمایش داده می‌شود:

    [me@linuxbox ~]$ async-parent
    Parent: starting...
    Parent: launching child script...
    Parent: child (PID= 6741) launched.
    Parent: continuing...
    Child: child is running...
    Parent: pausing to wait for child to finish...
    Child: child is done. Exiting.

    پایپ‌های نام‌گذاری‌شده (Named Pipes) #

    در اکثر سیستم‌های شبه‌یونیکس، امکان ایجاد نوع خاصی از فایل تحت عنوان پایپ نامگذاری شده (Named Pipes) وجود دارد. این فایل‌ها ابزاری برای برقراری ارتباط میان دو فرآیند مستقل هستند و می‌توان از آن‌ها مشابه فایل‌های معمولی در سیستم فایل استفاده کرد. اگرچه امروزه این رویکرد کمتر در اولویت توسعه‌دهندگان است، اما درک مکانیسم آن برای مدیریت سیستم‌های لینوکسی بسیار حائز اهمیت است.

    در مهندسی نرم‌افزار، معماری رایجی به نام کلاینت-سرور (Client-Server) وجود دارد که می‌تواند از روش‌های مختلف ارتباط بین‌فرآیندی (IPC) نظیر پایپ نامگذاری شده یا اتصالات شبکه بهره ببرد. ملموس‌ترین نمونه از این معماری، تعامل میان مرورگر وب (در نقش کلاینت) و سرور وب است؛ کلاینت درخواست‌های خود را ارسال کرده و سرور با داده‌های مورد نظر (صفحات وب) پاسخ می‌دهد.

    پایپ نامگذاری شده در سطح سیستم فایل مانند یک فایل عادی ظاهر می‌شوند، اما در واقع بافرهایی از نوع FIFO (اولین ورودی، اولین خروجی) هستند. مشابه پایپ‌لاین‌های معمولی (Pipes)، داده‌ها از یک سمت وارد شده و با همان ترتیب از سمت دیگر خارج می‌شوند. با استفاده از این پایپ‌ها، می‌توان ساختاری مشابه زیر ایجاد کرد:

    process1 > named_pipe

    و در سمتی دیگر:

    process2 < named_pipe

    این ساختار در عمل رفتاری مشابه پایپ‌لاین استاندارد (process1 | process2) دارد، با این تفاوت که در اینجا ارتباط از طریق یک گره (Node) مشخص در سیستم فایل برقرار می‌گردد.

    ایجاد پایپ نام‌گذاری‌شده (Named Pipe) #

    برای شروع، ابتدا باید یک پایپ نامگذاری شده ایجاد کنیم. این عملیات با استفاده از فرمان mkfifo به سادگی قابل انجام است:

    [me@linuxbox ~]$ mkfifo pipe1
    [me@linuxbox ~]$ ls -l pipe1
    prw-r--r-- 1 me me 0 2009-07-17 06:41 pipe1

    در مثال فوق، پایپی به نام pipe1 ایجاد شده است. با بررسی خروجی دستور ls -l، مشاهده می‌کنید که اولین کاراکتر در بخش مشخصه‌های فایل (File Attributes)، حرف «p» است؛ این علامت در سیستم‌عامل‌های شبه‌یونیکس به معنای Pipe بوده و نشان می‌دهد که این فایل یک پایپ نام‌گذاری شده (FIFO) است و نه یک فایل معمولی یا دایرکتوری.

    تعامل با پایپ نام‌گذاری‌شده #

    برای درک سازوکار عملیاتی یک پایپ نام‌گذاری شده، از دو پنجره ترمینال (یا دو کنسول مجازی مجزا) استفاده می‌کنیم. در ترمینال اول، یک دستور ساده را اجرا کرده و خروجی آن را به سمت مجرا هدایت می‌کنیم:

    [me@linuxbox ~]$ ls -l > pipe1
    

    پس از فشردن کلید Enter، مشاهده می‌شود که خط فرمان در حالت تعلیق باقی می‌ماند و به ظاهر «قفل» شده است. این رخداد به این دلیل است که در سمت دیگر مجرا، هنوز هیچ فرآیندی برای دریافت و خواندن داده‌ها متصل نشده است. در ادبیات سیستم‌عامل، به این وضعیت مسدود شدن (Blocking) مجرا گفته می‌شود. این توقف تا زمانی ادامه می‌یابد که فرآیند دیگری به انتهای دیگر مجرا متصل شده و عملیات خواندن داده را آغاز کند.

    اکنون در پنجره دوم ترمینال، دستور زیر را وارد می‌کنیم:

    [me@linuxbox ~]$ cat < pipe1

    با اجرای این دستور، فهرست فایل‌هایی که توسط فرمان ls در ترمینال اول تولید شده بود، در خروجی دستور cat در ترمینال دوم ظاهر می‌شود. به محض برقراری این اتصال و تخلیه بافر، فرآیند ls در ترمینال اول از حالت مسدود خارج شده و با موفقیت به پایان می‌رسد.

    جمع‌بندی #

    بدین ترتیب به پایان این مسیر آموزشی می‌رسیم. از این نقطه به بعد، تداوم یادگیری تنها در گرو «تمرین، تمرین و تکرار» است. اگرچه مباحث گسترده‌ای را با هم مرور کردیم، اما دنیای لینوکس همچنان قلمروهای کشف‌نشده بسیاری دارد.

    هزاران ابزار در محیط خط فرمان (CLI) منتظر بهره‌برداری هوشمندانه شما هستند. پیشنهاد می‌شود جست‌وجو در مسیر /usr/bin/ را آغاز کنید تا با تنوع خیره‌کننده برنامه‌های موجود آشنا شوید. برای آن دسته از مخاطبانی که مشتاق یادگیری عمیق‌تر هستند، کتاب تکمیلی نویسنده‌ی اصلی با عنوان «ماجراجویی با خط فرمان لینوکس» (Adventures with the Linux Command Line) به‌صورت رایگان در وب‌سایت LinuxCommand.org برای دانلود در دسترس است.

    منابع مطالعه تکمیلی #

    بخش «دستورات مرکب» (Compound Commands) در صفحات راهنمای Bash، شرح کاملی از نشانه‌گذاری‌های دستورات گروهی (group commands) و زیرپوسته‌ها (subshells) ارائه می‌دهد.

    بخش بسط‌ها (EXPANSION) در صفحات راهنمای Bash، شامل بندی است که به مبحث جایگزینی فرآیند (process substitution) می‌پردازد.

    راهنمای پیشرفته اسکریپت‌نویسی Bash (Advanced Bash-Scripting Guide) نیز بحثی پیرامون جایگزینی فرآیند ارائه کرده است:

    مجله لینوکس (Linux Journal) دو مقاله مفید درباره پایپ‌های نام‌گذاری‌شده (named pipes) دارد. مقاله نخست، منتشرشده در سپتامبر ۱۹۹۷:

    و مقاله دوم، منتشرشده در مارس ۲۰۰۹:

    شناسنامه فنی و پیکربندی کتاب #

    این اثر با بهره‌گیری از قلم آزاد و متن‌باز «وزیرمتن» (Vazirmatn) برای متون فارسی و قلم‌های خانواده‌ی Liberation (شامل Liberation Sans برای متون انگلیسی و Liberation Mono برای نمایش دستورات و متن‌های تک‌فاصله (Monospaced)) طراحی و صفحه‌آرایی شده است. خانواده‌ی قلم وزیرمتن، یک قلم فارسی-عربی با استاندارد کیفی بالا و خوانایی بهینه در محیط‌های دیجیتال است که توسط صابر راستی‌کردار طراحی و توسعه یافته و تحت مجوز SIL Open Font License (نسخه ۱.۱) منتشر شده است. این مجوز، حق استفاده، اصلاح و توزیع آزادانه‌ی قلم را با حفظ اصالت حقوق طراح برای همگان تضمین می‌کند. مخزن رسمی این پروژه در پیوند زیر در گیت‌هاب در دسترس است:

    یاد و خاطره‌ی زنده‌یاد صابر راستی‌کردار و میراث ماندگار او در توسعه‌ی فونت‌های آزاد فارسی همواره گرامی خواهد ماند.

    فرآیند تدوین و بومی‌سازی ترجمه‌ی فارسی ویرایش نخست، با استفاده از نرم‌افزار LibreOffice در محیط سیستم‌عامل اتمیک Fedora Kinoite انجام شده است.