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

    فصل ۲۶: طراحی سلسله‌مراتبی و روش‌شناسی بالا به پایین

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

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

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

    1. سوار شدن به خودرو.
    2. رانندگی به سمت مقصد.
    3. پارک کردن خودرو.
    4. ورود به فروشگاه.
    5. خرید اقلام مورد نیاز.
    6. بازگشت به خودرو.
    7. رانندگی به سمت خانه.
    8. پارک کردن خودرو.
    9. ورود به خانه.

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

    1. یافتن فضای مناسب پارک.
    2. هدایت خودرو به داخل فضای پارک.
    3. خاموش کردن موتور.
    4. کشیدن ترمز دستی.
    5. خروج از خودرو.
    6. قفل کردن درب‌ها.

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

    این متدولوژی که در آن ابتدا مؤلفه‌های سطح‌بالا (High-level) شناسایی شده و سپس هر یک با جزئیات فزاینده تبیین می‌شوند، طراحی از بالا به پایین (Top-Down Design) نامیده می‌شود. این تکنیک به ما اجازه می‌دهد تا چالش‌های پیچیده را به قطعاتی کوچک و قابل‌مدیریت تبدیل کنیم. طراحی بالا به پایین یکی از روش‌های بنیادین در توسعه نرم‌افزار است و به‌ویژه در محیط پوسته (Shell) که بر پایه پیوند دستورات ساده استوار است، کارایی بسیار بالایی دارد.

    در این فصل، از استراتژی طراحی بالا به پایین برای توسعه و ارتقای اسکریپتِ تولید گزارش سیستمی خود استفاده خواهیم کرد.

    توابع در پوسته (Shell Functions) #

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

    1. باز کردن تگ سند (<html>).
    2. باز کردن بخش سرآیند (<head>).
    3. تعیین عنوان صفحه (<title>).
    4. بستن بخش سرآیند.
    5. باز کردن بدنه سند (<body>).
    6. درج عنوان اصلی گزارش (<h1>).
    7. درج برچسب زمانی تولید گزارش (Timestamp).
    8. بستن بدنه سند.
    9. بستن تگ نهایی سند.

    در گام بعدی توسعه، وظایف عملیاتی جدیدی را حدفاصل مراحل ۷ و ۸ اضافه خواهیم کرد. این ماژول‌ها شامل موارد زیر هستند:

    • مدت‌زمان فعالیت و بار سیستم (Uptime & Load): این بخش بازه‌ی زمانی سپری‌شده از آخرین راه‌اندازی مجدد (Reboot) سیستم و میانگین تعداد فرآیندهای در حال اجرا در پردازنده (Load Average) را در فواصل زمانی مشخص ارائه می‌دهد.
    • وضعیت فضای ذخیره‌سازی (Disk Space): این تحلیل، میزان اشغال حافظه و فضای دردسترس در پارتیشن‌های مختلف سیستم را گزارش می‌کند.
    • میزان مصرف دایرکتوری‌های خانگی (Home Space Usage): این ماژول مقدار فضای اشغال‌شده توسط دایرکتوری اختصاصی هر کاربر را محاسبه و نمایش می‌دهد.

    چنانچه برای هر یک از این وظایف، دستور مجزایی در اختیار داشتیم، می‌توانستیم به سادگی و از طریق جایگزینی فرمان (Command Substitution)، آن‌ها را به اسکریپت خود الحاق کنیم:

    #!/bin/bash
    
    # Program to output a system information page
    
    TITLE="System Information Report For $HOSTNAME"
    CURRENT_TIME="$(date +"%x %r %Z")"
    TIMESTAMP="Generated $CURRENT_TIME, by $USER"
    
    cat << _EOF_
    <html>
          <head>
                 <title>$TITLE</title>
          </head>
          <body>
                 <h1>$TITLE</h1>
                 <p>$TIMESTAMP</p>
                  $(report_uptime)
                  $(report_disk_space)
                  $(report_home_space)
          </body>
    </html>
    _EOF_

    ما می‌توانیم این دستورات تکمیلی را به دو روش پیاده‌سازی کنیم: نخست، نگارش سه اسکریپت مجزا و قرار دادن آن‌ها در مسیرهای تعریف شده در متغیر محیطی PATH؛ و دوم، گنجاندن این اسکریپت‌ها در قالب «توابع پوسته» (Shell Functions) درون برنامه‌ی اصلی. همان‌طور که پیش‌تر اشاره شد، توابع پوسته در واقع «اسکریپت‌های کوچکی» (Mini-scripts) هستند که در دل اسکریپت‌های دیگر محصور شده و مانند فرامین مستقل عمل می‌کنند. توابع پوسته در لینوکس از دو ساختار نحوی (Syntax) رایج پیروی می‌کنند.

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

    function name {
        commands
        return
    }

    و ساختار ساده‌تر (که غالباً ترجیح داده می‌شود) به این شرح است:

    name () {
        commands
        return
    }

    در این ساختارها، name بیانگر نام تابع و commands مجموعه‌ای از دستورات محصور در آن است. هر دو فرم از نظر فنی معادل یکدیگرند و می‌توان آن‌ها را به‌جای هم به کار برد. در ادامه، اسکریپتی جهت نمایش نحوه‌ی به‌کارگیری توابع پوسته ارائه شده است:

    1 #!/bin/bash
    2
    3 # Shell function demo
    4
    5 function step2 {
    6    echo "Step 2"
    7    return
    8 }
    9
    10 # Main program starts here
    11
    12 echo "Step 1"
    13 step2
    14 echo "Step 3"

    هنگامی که مفسر پوسته شروع به خواندن اسکریپت می‌کند، از خطوط ۱ تا ۱۱ عبور می‌کند؛ چرا که این بخش صرفاً شامل توضیحات (Comments) و تعریف تابع است. اجرای عملیاتی برنامه از خط ۱۲ و با دستور echo آغاز می‌شود. در خط ۱۳، تابع step2 فراخوانی شده و پوسته آن را دقیقاً مشابه یک دستور مستقل اجرا می‌کند. در این لحظه، کنترل برنامه به خط ۶ منتقل شده و دومین دستور echo اجرا می‌گردد. سپس با رسیدن به خط ۷، دستور return موجب خاتمه‌ی تابع شده و کنترل اجرای برنامه را به خط پس از فراخوانی (خط ۱۴) بازمی‌گرداند تا در نهایت آخرین دستور echo اجرا شود. شایان ذکر است که تعاریف توابع پوسته الزاماً باید پیش از فراخوانی آن‌ها در متن اسکریپت درج شوند تا توسط مفسر به عنوان تابع شناسایی شده و با برنامه‌های خارجی (External binaries) اشتباه گرفته نشوند.

    ما تعاریف حداقلی توابع پوسته را به اسکریپت خود اضافه می‌کنیم؛ قطعه کد نهایی به شرح زیر است:

    #!/bin/bash
    
    # Program to output a system information page
    
    TITLE="System Information Report For $HOSTNAME"
    CURRENT_TIME="$(date +"%x %r %Z")"
    TIMESTAMP="Generated $CURRENT_TIME, by $USER"
    
    report_uptime () {
        return
    }
    
    report_disk_space () {
        return
    }
    
    report_home_space () {
        return
    }
    
    cat << _EOF_
    <html>
        <head>
             <title>$TITLE</title>
        </head>
        <body>
             <h1>$TITLE</h1>
             <p>$TIMESTAMP</p>
             $(report_uptime)
             $(report_disk_space)
             $(report_home_space)
        </body>
    </html>
    _EOF_

    قواعد نام‌گذاری توابع پوسته دقیقاً از همان اصولی پیروی می‌کند که در نام‌گذاری متغیرها به کار می‌رود. بدنه هر تابع باید دست‌کم شامل یک دستور عملیاتی باشد؛ در این راستا، استفاده از دستور return (که به طور معمول اختیاری است) می‌تواند این الزام ساختاری را برای توابع تهی برآورده سازد.

    متغیرهای محلی #

    در اسکریپت‌هایی که تاکنون بررسی کرده‌ایم، تمامی متغیرها (از جمله ثابت‌ها) در دسته‌ی متغیرهای سراسری (Global Variables) قرار داشتند؛ به این معنا که در تمامی بخش‌های برنامه در دسترس و معتبر هستند. اگرچه این رویکرد در بسیاری از موارد کارآمد است، اما گاهی می‌تواند مدیریت توابع پوسته را با دشواری مواجه کند. در مقابل، استفاده از متغیرهای محلی (Local Variables) در داخل توابع ترجیح داده می‌شود؛ چرا که این متغیرها تنها در محدوده‌ی همان تابعی که در آن تعریف شده‌اند قابل دسترسی بوده و با خاتمه‌ی اجرای تابع، از حافظه حذف می‌شوند.

    بهره‌گیری از متغیرهای محلی به برنامه‌نویس این امکان را می‌دهد تا از نام‌هایی که ممکن است پیش‌تر در سطح اسکریپت یا در سایر توابع استفاده شده باشند، بدون واهمه از تداخل نام‌ها (Naming Conflicts)، مجدداً استفاده کند.

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

    #!/bin/bash
    
    # local-vars: script to demonstrate local variables
    
    foo=0  # global variable foo
    
    funct_1 () {
    
        local foo  # variable local to funct_1
    
        foo=1
        echo "funct_1: foo = $foo"
    }
    
    funct_2 () {
    
        local foo  # variable local to funct_2
    
        foo=2
        echo "funct_2: foo = $foo"
    }
    
    echo "global:  foo = $foo"
    funct_1
    echo "global:  foo = $foo"
    funct_2
    echo "global:  foo = $foo"

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

    [me@linuxbox ~]$ local-vars
    global:  foo = 0
    funct_1: foo = 1
    global:  foo = 0
    funct_2: foo = 2
    global:  foo = 0

    مشاهده می‌کنیم که تخصیص مقدار به متغیر محلی foo در هر دو تابع، هیچ‌گونه تاثیری بر مقدار متغیر foo که در خارج از توابع تعریف شده، نداشته است.

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

    توابع پوسته و بازهدایت ورودی/خروجی (I/O Redirection) #

    با نگاهی دقیق‌تر به ساختار نگارشی توابع پوسته، متوجه شباهت آن‌ها با مفاهیم «دستورات گروهی» (Group Commands) می‌شویم که پیش‌تر بررسی کردیم:

    my_funct () {
        command1
        command2
        command3
    }

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

    { command1; command2; command3; } > some_output.txt

    و:

    { command1; command2; command3; } < some_input.txt

    این منطق دقیقاً بر توابع پوسته نیز حاکم است. قطعه کد زیر را در نظر بگیرید:

    my_funct () {
        echo "My Documents"
        ls ~/Documents
        echo "My Music"
        ls ~/Music
        echo "My Videos"
        ls ~/Videos
        return
    }

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

    my_funct > my_directories.txt

    یا از طریق یک پایپ‌لاین (Pipeline) پردازش کرد:

    my_funct | sort

    حتی می‌توان با بهره‌گیری از تکنیک «جایگزینی فرمان» (Command Substitution)، خروجی تابع را در یک متغیر ذخیره نمود:

    my_var="$(my_funct)"

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

    my_funct < input.txt

    توسعه تدریجی و اجرای مستمر اسکریپت‌ها #

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

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

    [me@linuxbox ~]$ sys_info_page
    <html>
         <head>
              <title>System Information Report For twin2</title>
         </head>
         <body>
              <h1>System Information Report For linuxbox</h1>
              <p>Generated 03/19/2009 04:02:10 PM EDT, by me</p>
    
    
         </body>
    </html>

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

    report_uptime () {
        echo "Function report_uptime executed."
        return
    }
    
    report_disk_space () {
        echo "Function report_disk_space executed."
        return
    }
    
    report_home_space () {
        echo "Function report_home_space executed."
        return
    }

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

    [me@linuxbox ~]$ sys_info_page
    <html>
       <head>
            <title>System Information Report For linuxbox</title>
       </head>
       <body>
            <h1>System Information Report For linuxbox</h1>
            <p>Generated 03/20/2009 05:17:26 AM EDT, by me</p>
            Function report_uptime executed.
            Function report_disk_space executed.
            Function report_home_space executed.
       </body>
    </html>

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

    report_uptime () {
        cat << _EOF_
             <h2>System Uptime</h2>
             <pre>$(uptime)</pre>
    _EOF_
        return
    }

    این تابع از ساختاری بسیار ساده بهره می‌برد؛ به این ترتیب که خروجی دستور uptime را جهت حفظ قالب‌بندی متنی، درون تگ‌های HTML محصور کرده و به خروجی استاندارد ارسال می‌کند.

    ما از یک Here Document برای تولید خروجی بهره می‌گیریم که شامل یک عنوان برای بخش مربوطه و خروجی دستور uptime است. استفاده از تگ‌های <pre> باعث می‌شود قالب‌بندی متنی خروجی دستور در صفحه وب دقیقاً حفظ شود. تابع report_disk_space نیز از ساختار مشابهی پیروی می‌کند:

    report_disk_space () {
        cat << _EOF_
             <h2>Disk Space Utilization</h2>
             <pre>$(df -h)</pre>
    _EOF_
        return
    }

    این تابع از دستور df -h برای گزارش‌گیری از وضعیت فضای مصرفی دیسک با قالب قابل خواندن برای انسان (Human-readable) استفاده می‌کند. در نهایت، تابع report_home_space را به‌صورت زیر پیاده‌سازی می‌کنیم:

    report_home_space () {
        cat << _EOF_
             <h2>Home Space Utilization</h2>
             <pre>$(du -sh /home/*)</pre>
    _EOF_
        return
    }

    در این تابع، دستور du با گزینه‌های -sh به کار رفته است تا خلاصه‌ای از حجم دایرکتوری‌های کاربران را نمایش دهد. با این حال، این راهکار با محدودیتی جدی روبروست؛ اگرچه این دستور در برخی توزیع‌ها (مانند اوبونتو) به درستی عمل می‌کند، اما در بسیاری از سیستم‌های دیگر با خطا مواجه خواهد شد. علت این امر، سیاست‌های امنیتی لینوکس در تنظیم مجوزهای دسترسی (Permissions) دایرکتوری‌های خانگی است که اجازه خواندن محتوا را به سایر کاربران نمی‌دهد. در چنین سیستم‌هایی، تابع report_home_space تنها در صورتی خروجی صحیح خواهد داشت که اسکریپت با امتیازات ابرکاربر (Superuser) اجرا شود. راهکار بهینه، طراحی اسکریپت به گونه‌ای است که رفتار خود را با سطح دسترسی کاربر تطبیق دهد؛ موضوعی که در فصل آینده به تفصیل به آن خواهیم پرداخت.

    درج توابع پوسته در فایل bashrc #

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

    به عنوان نمونه، اگر عملکرد تابع report_disk_space که پیش‌تر طراحی کردیم برایتان کاربردی است، می‌توانید نسخه‌ای بهینه از آن را با نام اختصاری ds (مخفف Disk Space) در فایل پیکربندی .bashrc خود تعریف کنید:

    ds () {
        echo "Disk Space Utilization For $HOSTNAME"
        df -h
    }

    جمع‌بندی #

    در این فصل، با یکی از روش‌های بنیادین و پرکاربرد در مهندسی نرم‌افزار تحت عنوان طراحی بالا به پایین (Top-down Design) آشنا شدیم و چگونگی بهره‌گیری از توابع پوسته را برای پیاده‌سازی این متدولوژی بررسی کردیم. همچنین آموختیم که چگونه استفاده از متغیرهای محلی (Local Variables) منجر به استقلال عملکردی توابع از یکدیگر و از بدنه اصلی اسکریپت می‌شود. این استقلال، زیربنای نگارش توابع قابل حمل (Portable) است که امکان استفاده مجدد (Reusability) از کد را در پروژه‌های مختلف فراهم آورده و موجب صرفه‌جویی قابل‌توجهی در زمان توسعه می‌گردد.

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

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