From e8da39e26b2be5ef8283c4a00f3b2eae1e7f50da Mon Sep 17 00:00:00 2001 From: medusa Date: Tue, 18 Jun 2024 05:00:19 +0000 Subject: [PATCH] Add tech_docs/go_getting_started.md --- tech_docs/go_getting_started.md | 258 ++++++++++++++++++++++++++++++++ 1 file changed, 258 insertions(+) create mode 100644 tech_docs/go_getting_started.md diff --git a/tech_docs/go_getting_started.md b/tech_docs/go_getting_started.md new file mode 100644 index 0000000..ddf1915 --- /dev/null +++ b/tech_docs/go_getting_started.md @@ -0,0 +1,258 @@ +Here's a comprehensive guide to using some essential Go packages for interacting with the operating system and handling various system-level tasks. + +## Go Syscall Package + +### Overview +The `syscall` package in Go provides an interface for low-level system calls. It's part of the Go standard library but has been somewhat deprecated in favor of `golang.org/x/sys/unix`. However, understanding `syscall` is still beneficial for legacy code or very low-level operations. + +### Common Functions +- **syscall.Syscall**: Calls a system service by its index. +- **syscall.ForkExec**: Runs a new process with forks and execs. +- **syscall.Getpid**: Returns the process ID of the calling process. + +### Example +```go +package main + +import ( + "fmt" + "syscall" + "unsafe" +) + +func main() { + buf := make([]byte, 64) + _, _, err := syscall.Syscall(syscall.SYS_GETHOSTNAME, uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)), 0) + if err != 0 { + fmt.Println("Error getting hostname:", err) + return + } + fmt.Println("Hostname:", string(buf)) +} +``` + +## Go os/exec Package + +### Overview +The `os/exec` package runs external commands and interacts with them. + +### Common Functions +- **exec.Command**: Creates a new command to run. +- **cmd.Run**: Runs the command and waits for it to finish. +- **cmd.Output**: Runs the command and returns its standard output. + +### Example +```go +package main + +import ( + "fmt" + "os/exec" +) + +func main() { + cmd := exec.Command("ls", "-lah") + out, err := cmd.Output() + if err != nil { + fmt.Println("Error running command:", err) + return + } + fmt.Println(string(out)) +} +``` + +## Go os/signal Package + +### Overview +The `os/signal` package allows for handling of Unix signals. + +### Common Functions +- **signal.Notify**: Registers the given channel to receive notifications of specified signals. +- **signal.Stop**: Stops the given channel from receiving notifications. + +### Example +```go +package main + +import ( + "fmt" + "os" + "os/signal" + "syscall" +) + +func main() { + sigs := make(chan os.Signal, 1) + signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM) + + go func() { + sig := <-sigs + fmt.Println("Received signal:", sig) + os.Exit(0) + }() + + fmt.Println("Press Ctrl+C to exit") + select {} +} +``` + +## Go os Package + +### Overview +The `os` package provides a platform-independent interface to operating system functionality. + +### Common Functions +- **os.Open**: Opens a file for reading. +- **os.Create**: Creates a new file. +- **os.Remove**: Removes a file or directory. +- **os.Getenv**: Retrieves the value of an environment variable. + +### Example +```go +package main + +import ( + "fmt" + "os" +) + +func main() { + file, err := os.Create("test.txt") + if err != nil { + fmt.Println("Error creating file:", err) + return + } + defer file.Close() + + file.WriteString("Hello, Go!") + fmt.Println("File created and written to successfully.") + + value := os.Getenv("HOME") + fmt.Println("HOME environment variable:", value) +} +``` + +## Go net Package + +### Overview +The `net` package provides a portable interface for network I/O, including TCP/IP, UDP, domain name resolution, and Unix domain sockets. + +### Common Functions +- **net.Dial**: Connects to a network address. +- **net.Listen**: Listens for network connections. +- **net.Accept**: Accepts network connections on a listener. + +### Example +```go +package main + +import ( + "fmt" + "net" +) + +func main() { + l, err := net.Listen("tcp", ":8080") + if err != nil { + fmt.Println("Error listening:", err) + return + } + defer l.Close() + + fmt.Println("Listening on :8080") + for { + conn, err := l.Accept() + if err != nil { + fmt.Println("Error accepting connection:", err) + return + } + go handleRequest(conn) + } +} + +func handleRequest(conn net.Conn) { + buf := make([]byte, 1024) + n, err := conn.Read(buf) + if err != nil { + fmt.Println("Error reading:", err) + return + } + fmt.Println("Received message:", string(buf[:n])) + conn.Write([]byte("Message received")) + conn.Close() +} +``` + +## Go unix Package + +### Overview +The `golang.org/x/sys/unix` package provides a more comprehensive interface for Unix system calls compared to the `syscall` package. + +### Common Functions +- **unix.Socket**: Creates an endpoint for communication. +- **unix.Bind**: Binds a name to a socket. +- **unix.Listen**: Listens for connections on a socket. +- **unix.Accept**: Accepts a connection on a socket. + +### Example +```go +package main + +import ( + "fmt" + "golang.org/x/sys/unix" + "os" + "syscall" +) + +func main() { + socketPath := "/tmp/unix.sock" + syscall.Unlink(socketPath) + fd, err := unix.Socket(unix.AF_UNIX, unix.SOCK_STREAM, 0) + if err != nil { + fmt.Println("Error creating socket:", err) + return + } + defer unix.Close(fd) + + addr := unix.SockaddrUnix{Name: socketPath} + if err := unix.Bind(fd, &addr); err != nil { + fmt.Println("Error binding socket:", err) + return + } + + if err := unix.Listen(fd, 5); err != nil { + fmt.Println("Error listening on socket:", err) + return + } + + fmt.Println("Server listening on", socketPath) + nfd, _, err := unix.Accept(fd) + if err != nil { + fmt.Println("Error accepting connection:", err) + return + } + defer unix.Close(nfd) + + buf := make([]byte, 1024) + n, err := unix.Read(nfd, buf) + if err != nil { + fmt.Println("Error reading from connection:", err) + return + } + fmt.Println("Received message:", string(buf[:n])) + unix.Write(nfd, []byte("Hello from server")) + os.Remove(socketPath) +} +``` + +### Resources + +1. **[Go Syscall Package Documentation](https://pkg.go.dev/syscall)** +2. **[Go os/exec Package Documentation](https://pkg.go.dev/os/exec)** +3. **[Go os/signal Package Documentation](https://pkg.go.dev/os/signal)** +4. **[Go os Package Documentation](https://pkg.go.dev/os)** +5. **[Go net Package Documentation](https://pkg.go.dev/net)** +6. **[Go unix Package Documentation](https://pkg.go.dev/golang.org/x/sys/unix)** + +These guides should help you get started with each package and provide a solid foundation for building more complex Go applications that interact with the operating system and network. \ No newline at end of file