Viết lại Linux Shell với Go

Ngày đăng

Jan 26, 2023 12:47 PM

Tác giả

Quân Huỳnh

Giới thiệu

Shell chắc rất quen thuộc đối với các anh em sử dụng Linux, và để hiểu rõ hơn về cách Shell hoạt động thì ở bài này chúng ta sẽ tìm hiểu bằng cách tự viết lại một chương trình Shell đơn giản bằng Golang.

Mục lục

Shell?
Đọc giá trị đầu vào
Viết Shell
Câu lệnh Commands
Arguments
Chương trình cd?
Cải thiện Prompt
Kết luận
Bài viết liên quan

Bài này mình tham khảo từ bài Writing a simple shell in Go của Simon Jürgensmeyer. Trước khi viết code thì ta sẽ tìm hiểu xem Shell là gì?

Shell?

Khi ta làm việc với terminal, ta mở terminal lên và gõ các câu lệnh, sau đó nhấn enter để các câu lệnh được thực thi. Thì thứ mà đọc các câu lệnh từ terminal và thực thi các câu lệnh ta nhập vào, đó chính là Shell.

Shell là một user interface để ta có thể tương tác được với hệ điều hành (Operating System). Shell sẽ thu thập các câu lệnh đầu vào từ người dùng (thông qua terminal hoặc GUI), sau đó nó sẽ thực thi các câu lệnh đó. Sau khi các câu lệnh chạy xong kết quả của các câu lệnh đó sẽ được Shell hiển thị cho người dùng (thông qua terminal hoặc GUI).

Một vài ví dụ của Shell:

Bash
Zsh
Gnome Shell
Windows Shell

Ví dụ cách hoạt động của Shell, các bạn mở terminal lên và gõ ls.

ls -l

total 8
drwxr-xr-x 2 ubuntu ubuntu 4096 Sep 11 22:20 load-balancer
drwxr-xr-x 2 ubuntu ubuntu 4096 Sep 11 22:21 simple-shell

Shell sẽ đọc từ terminal câu lệnh ls -l, sau đó thực thi và in kết quả ra terminal. Vậy trong Golang ta sẽ đọc dữ liệu đầu vào của người dùng như thế nào?

Đọc giá trị đầu vào

Để đọc được dữ liệu đầu vào từ người dùng, ta sẽ làm như sau:

reader := bufio.NewReader(os.Stdin)
input, err := reader.ReadString('\n')

Bàn phím của ta là một thiết bị đầu vào, do đó ta có thể truy cập được nó thông qua os.Stdin, sau đó để đọc được dữ liệu từ nó ta sẽ dùng bufio.NewReader với thông số truyền vào là os.Stdin. Lúc này hàm NewReader sẽ trả cho ta về một reader để đọc dữ liệu từ bàn phím.

Ở dòng tiếp theo thì ta sẽ đọc dữ liệu nhập vào từ bàn phím cho tới khi nào người dùng gõ phím enter, tương ứng với kí tự /n. Bây giờ ta sẽ bắt đầu code nào.

Viết Shell

Tạo một file tên là main.go với đoạn code đơn giản như sau:

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    reader := bufio.NewReader(os.Stdin)

    for {
        // Read the keyboad input.
        input, err := reader.ReadString('\n')
        if err != nil {
            fmt.Fprintln(os.Stderr, err)
        }

    }
}

Ta sẽ dùng vòng lập để liên tục đọc dữ liệu nhập vào từ người dùng và thực thi, cho tới khi người dùng bấm Crtl + C để kết thúc.

Câu lệnh Commands

Tiếp theo để thực thi câu lệnh người dùng nhập vào, ta sẽ dùng hàm exec.Command của Go. Ví dụ:

cmd := exec.Command("ls")
cmd.Run()

Tạo một hàm tên là execInput(input string) với đoạn code như sau.

func execInput(input string) error {
    input = strings.TrimSuffix(input, "\n")

    cmd := exec.Command(input)

    cmd.Stderr = os.Stderr
    cmd.Stdout = os.Stdout

    return cmd.Run()
}

Hàm execInput sẽ nhận tham số truyền vào là dữ liệu đọc từ người dùng, thay vì thực thi ngay thì trước tiên ta sẽ cắt kí tự /n của dữ liệu đầu vào đi, sau đó mới truyền vào exec.Command và thực thi.

Hàm exec.Command() sẽ trả về cho ta một Cmd struct, sau đó ta sẽ gán Stderr và Stdout cho nó. Trong Go để truy cập được các thiết bị đầu ra ta sẽ dùng os.Stdout.

Cuối cùng ta sẽ dùng hàm cmd.Run() để thực thi câu lệnh đầu vào. Tiếp theo ta cập nhật lại file main.go.

package main

import (
    "bufio"
    "fmt"
    "os"
    "os/exec"
    "strings"
)

func main() {
    reader := bufio.NewReader(os.Stdin)

    for {
        fmt.Print("> ")

        // Read the keyboad input.
        input, err := reader.ReadString('\n')
        if err != nil {
            fmt.Fprintln(os.Stderr, err)
        }

        if err := execInput(input); err != nil {
            fmt.Fprintln(os.Stderr, err)
        }
    }
}

func execInput(input string) error {
    input = strings.TrimSuffix(input, "\n")

    cmd := exec.Command(input)

    cmd.Stderr = os.Stderr
    cmd.Stdout = os.Stdout

    return cmd.Run()
}

Ta kiểm tra thử nào.

go run main.go

> ls
main.go
> date
Sun Sep 11 23:21:16 +07 2022
>

Nhấn Ctrl + C để thoát, vậy là ta đã hoàn thành đoạn code Shell đơn giản thành công 😁.

Arguments

Bạn gõ thử câu lệnh ls mà có truyền thêm tham số vào.

> ls -l
exec: "ls -l": executable file not found in $PATH

Ta sẽ thấy nó bị lỗi, vì hiện tại ta đang lấy toàn bộ dữ liệu đầu vào để thực thi, trong khi dữ liệu đầu vào chỉ có giá trị đầu tiên là chương trình được thực thi, các giá trị còn lại đều là tham số của chương trình đó.

Ta cập nhật lại code như sau để nó chạy đúng.

...

func execInput(input string) error {
    input = strings.TrimSuffix(input, "\n")
    args := strings.Split(input, " ")

    cmd := exec.Command(args[0], args[1:]...)

    cmd.Stderr = os.Stderr
    cmd.Stdout = os.Stdout

    return cmd.Run()
}

Để lấy được tên của chương trình thực thi và các thông số của nó, ta sẽ tách chuỗi dữ liệu đầu vào của người dùng bằng hàm strings.Split(input, " "). Ví dụ với chuỗi ls -l -a thì sau khi truyền vào hàm Split ta sẽ có được mảng như sau.

args := strings.Split("ls -l -a", " ")

args[0] // ls
args[1] // -l
args[2] // -a

Với giá trị thứ 0 của mảng args sẽ là tên của chương trình sẽ được thực thi, còn các giá trị còn lại của mảng sẽ là thông số của chương trình đó. Hàm exec.Command sẽ nhận giá trị đầu tiên là tên của chương trình, còn các giá trị còn lại là thông số của nó, nên ta sẽ truyền vào hàm exec.Command như sau.

cmd := exec.Command(args[0], args[1:]...)

Chạy thử lại code của ta.

go run main.go
> ls -l
total 4
-rw-r--r-- 1 hmquan hmquan 584 Sep 12 09:38 main.go

Giờ thì nó chạy đúng rồi đó 😁.

Chương trình cd?

Khi bạn mở terminal lên và muốn thay đổi thư mục làm việc, ta sẽ dùng câu lệnh cd, ví dụ nếu bạn muốn di chuyển tới một thưc mục /etc thì ta sẽ gõ cd /etc. Ta thử chạy chương trình Shell của ta và gõ câu lệnh cd xem nó có hoạt động đúng không.

go run main.go
> cd /etc
exec: "cd": executable file not found in $PATH

Nó bị lỗi? Tại sao nó lại báo là chương trình cd không có? Thì đây là một kiến thức mà mình đã học Linux rất lâu cũng không ngờ tới, đó là trong Linux không có cái gọi là chương trình cd, cd chỉ là một chức năng của Shell.

Để Shell có thể thực hiện được chức năng thay đổi thư mục bằng cd, ta cập nhật lại code như sau.

...

func execInput(input string) error {
    input = strings.TrimSuffix(input, "\n")
    args := strings.Split(input, " ")

    cmd := exec.Command(args[0], args[1:]...)

    switch args[0] {
    case "cd":
        if len(args) < 2 {
            return errors.New("path required")
        }

        return os.Chdir(args[1])
    case "exit":
        os.Exit(0)
    }

    cmd.Stderr = os.Stderr
    cmd.Stdout = os.Stdout

    return cmd.Run()
}

Ta sẽ dùng cú pháp switch case để kiểm tra, nếu người dùng nhập vào là cd thì ta sẽ dùng hàm os.Chdir để thay đổi thư mục làm việc. Ta cũng kiểm tra thêm là nếu người dùng nhập vào exit thì ta sẽ thoát Shell, không cần phải nhấn Ctrl + C. Chạy thử nào.

go run main.go
> cd ..
> ls
load-balancer  simple-shell
> cd simple-shell
> ls
main.go
> exit

Ngon 😁.

Cải thiện Prompt

prompt là kí hiệu hiển thị của Shell để báo cho người dùng biết là ta có thể nhập dữ liệu vào terminal, hiện tại prompt của ta hiển thị với kí hiệu >.

Một vài thứ ta cần cải thiện là cách hiển thị prompt, các bạn để ý ở đầu chương trình ta dùng fmt.Print("> ") để in ra prompt. Ta sẽ sửa lại prompt để nó hiển thị theo định dạng <username>@<host>:<path> giống với các chương trình Shell khác.

package main

import (
    "bufio"
    "errors"
    "fmt"
    "os"
    "os/exec"
    "os/user"
    "strings"
)

func main() {
    reader := bufio.NewReader(os.Stdin)
    for {
        hostname, err := os.Hostname()
        if err != nil {
            fmt.Fprintln(os.Stderr, err)
        }

        currentUser, err := user.Current()
        if err != nil {
            fmt.Fprintln(os.Stderr, err)
        }

        path, err := os.Getwd()
        if err != nil {
            fmt.Fprintln(os.Stderr, err)
        }

        path = strings.Replace(path, "/home/"+currentUser.Username+"", "~", -1)

        fmt.Printf("%s@%s:%s$ ", currentUser.Username, hostname, path)

        ...
    }
}

...

Đầu tiên, ta sẽ lấy ra giá trị của hostname và username bằng hàm os.Hostname() và user.Current().

Tiếp theo ta sẽ lấy giá trị của thư mục làm việc bằng hàm os.Getwd(). Trong Linux thì thư mục của người dùng hiện tại sẽ tương ứng với kí tự ~, nên ta dùng hàm strings.Replace để thay thế thư mục của người dùng hiện tại thành ~, ví dụ đường dẫn /home/hmquan/blog/devops-practice/simple-shell sẽ thành ~/blog/devops-practice/simple-shell.

Cuối cùng ta sẽ in ra prompt theo định dạng <username>@<host>:<path> bằng hàm fmt.Printf.

fmt.Printf("%s@%s:%s$ ", currentUser.Username, hostname, path)

Chạy thử nào.

go run main.go
hmquan@LAPTOP-2COB82RG:~/blog/devops-practice/simple-shell$ ls
main.go

Vậy là ta đã thành công xây dựng một chương trình Shell đơn giản bằng Go 😁. Code hoàn chỉnh.

package main

import (
    "bufio"
    "errors"
    "fmt"
    "os"
    "os/exec"
    "os/user"
    "strings"
)

func main() {
    reader := bufio.NewReader(os.Stdin)
    for {
        hostname, err := os.Hostname()
        if err != nil {
            fmt.Fprintln(os.Stderr, err)
        }

        currentUser, err := user.Current()
        if err != nil {
            fmt.Fprintln(os.Stderr, err)
        }

        path, err := os.Getwd()
        if err != nil {
            fmt.Fprintln(os.Stderr, err)
        }

        path = strings.Replace(path, "/home/"+currentUser.Username+"", "~", -1)

        fmt.Printf("%s@%s:%s$ ", currentUser.Username, hostname, path)

        // Read the keyboad input.
        input, err := reader.ReadString('\n')
        if err != nil {
            fmt.Fprintln(os.Stderr, err)
        }

        if err := execInput(input); err != nil {
            fmt.Fprintln(os.Stderr, err)
        }
    }
}

func execInput(input string) error {
    input = strings.TrimSuffix(input, "\n")

    args := strings.Split(input, " ")

    switch args[0] {
    case "cd":
        if len(args) < 2 {
            return errors.New("path required")
        }

        return os.Chdir(args[1])
    case "exit":
        os.Exit(0)
    }

    cmd := exec.Command(args[0], args[1:]...)

    cmd.Stderr = os.Stderr
    cmd.Stdout = os.Stdout

    return cmd.Run()
}