『Golang』—— 标准库之 os

Golang 的 os 库基本承袭 Unix 下 C 语言的用法

path 库：

func Base(path string) string    //取文件名，不含目录部分
func Dir(path string) string    //取路径中的目录名部分，不含文件名
func Join(elem ...string) string    //拼接字段，中间自动添加 ‘/’

os 库：

package main

import "os"
import "os/exec"

import "time"
import "fmt"
import "log"
import "errors"

//    const (// {{{
//        O_RDONLY int = syscall.O_RDONLY // open the file read-only.
//        O_WRONLY int = syscall.O_WRONLY // open the file write-only.
//        O_RDWR   int = syscall.O_RDWR   // open the file read-write.
//        O_APPEND int = syscall.O_APPEND // append data to the file when writing.
//        O_CREATE int = syscall.O_CREAT  // create a new file if none exists.
//        O_EXCL   int = syscall.O_EXCL   // used with O_CREATE, file must not exist
//        O_SYNC   int = syscall.O_SYNC   // open for synchronous I/O.
//        O_TRUNC  int = syscall.O_TRUNC  // if possible, truncate file when opened.
//    )
//
//    var (
//        Stdin  = newfile(uintptr(syscall.Stdin), "/dev/stdin")
//        Stdout = NewFile(uintptr(syscall.Stdout), "/dev/stdout")
//        Stderr = NewFile(uintptr(syscall.Stderr), "/dev/stderr")
//    )
// }}}
const (
    Unknown   int = -1
    Dir       int = 0
    Regular   int = 1
    Symlink   int = 2
    Socket    int = 3
    NamedPipe int = 4
)

var (
    path string = "/tmp/link_to_testfile"
    err  error
)

func main() {
    defer defer_printBye()

    cwd, _ := os.Getwd()
    fmt.Println("Work dir:", cwd)
    os.Chdir("/tmp")
    cwd, _ = os.Getwd()
    fmt.Println("New work dir:", cwd)

    hostname, _ := os.Hostname()
    pagesize := os.Getpagesize()
    fmt.Printf("hostname = %s
pagesize = %d
", hostname, pagesize)

    if nil != os.Setenv("HISTSIZE", "1000") {
        log.Fatal("Can't set env HISTSIZE")
    }

    fmt.Println(os.Getenv("HISTSIZE"))
    os.Unsetenv("HISTSIZE")
    fmt.Println("After Unsetenv:", os.Getenv("HISTSIZE"))

    //for _, env := range os.Environ() {
    //    fmt.Println(env)
    //}

    os.Clearenv()
    fmt.Println("Env variables after os.Clearenv: ", os.Environ())

    groups, _ := os.Getgroups()
    fmt.Println("groups IDs:", groups)
    fmt.Println("uid:", os.Getuid(), "euid:", os.Geteuid(), "gid:", os.Getgid(), "egid:", os.Getegid(), "pid:", os.Getpid(), "ppid:", os.Getppid())
    // {{{
    /*
        type FileInfo interface {
              Name() string       // base name of the file
              Size() int64        // length in bytes for regular files; system-dependent for others
              Mode() FileMode     // file mode bits
              ModTime() time.Time // modification time
              IsDir() bool        // abbreviation for Mode().IsDir()
              Sys() interface{}   // underlying data source (can return nil)
        }

        const (
                // The single letters are the abbreviations used by the String method's formatting.
                ModeDir        FileMode = 1 << (32 - 1 - iota) // d: is a directory
                ModeAppend                                     // a: append-only
                ModeExclusive                                  // l: exclusive use
                ModeTemporary                                  // T: temporary file (not backed up)
                ModeSymlink                                    // L: symbolic link
                ModeDevice                                     // D: device file
                ModeNamedPipe                                  // p: named pipe (FIFO)
                ModeSocket                                     // S: Unix domain socket
                ModeSetuid                                     // u: setuid
                ModeSetgid                                     // g: setgid
                ModeCharDevice                                 // c: Unix character device, when ModeDevice is set
                ModeSticky                                     // t: sticky

                // Mask for the type bits. For regular files, none will be set.
                ModeType = ModeDir | ModeSymlink | ModeNamedPipe | ModeSocket | ModeDevice

                ModePerm FileMode = 0777 // Unix permission bits
        )
    */ // }}}

    ftype, fm := file_info(path)
    fmt.Println("File type is:", file_type_string(ftype))

    fmt.Printf("permission: %s, %b
", fm.String(), fm.Perm())
    fm = fm & 0400
    os.Chmod(path, fm)
    fmt.Printf("After os.Chmod, permission: %s, %b
", fm.String(), fm.Perm())

    err = os.Chown(path, 1000, -1)
    print_err("Change owner to 1000/-1 failed!")
    err = os.Lchown(path, 0, 0)
    print_err("Change owner to 0/0 failed!")
    os.Link(path, "tempfile_new")
    os.Symlink(path, "tempfile_new_symlink")
    os.Mkdir("/tmp/tempfile_dir", 0755)
    os.MkdirAll("/tmp/tempfile_dir_All/teem", 0755)

    out, _ := exec.Command("/bin/ls", "/tmp").Output()
    fmt.Printf("%s", out)
    fmt.Println()

    os.Rename("/tmp/tempfile_dir", "/tmp/tempfiledir")
    os.Remove("/tmp/tempfiledir")
    os.RemoveAll("/tmp/tempfile_dir_All")
    fmt.Println("Delete all tmp files")

    out, _ = exec.Command("/bin/ls", "/tmp").Output()
    fmt.Printf("%s", out)
    fmt.Println()

    realname, _ := os.Readlink(path)
    tmp0, _ := os.Stat(realname)
    tmp1, _ := os.Stat(path)
    if os.SameFile(tmp0, tmp1) {
        fmt.Println("SameFile")
    }
    os.Truncate(path, 1024)
    fi, _ := os.Stat(path)
    fmt.Println("New file size is:", fi.Size())

    //    type File struct {// {{{
    //        *file // os specific
    //    }
    // }}}
    fp, er := os.OpenFile("/tmp/xxxmyfile", os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0644)
    err = er
    print_err("Create /tmp/xxxmyfile failed!")
    fp.Close()
    os.Mkdir("/tmp/test", 0700)
    fp, _ = os.Open("/tmp/test")
    fp.Chdir()
    cwd, _ = os.Getwd()
    fmt.Printf("Current dir:%s 
", cwd)
    fp.Chmod(0700)
    fp.Chown(-1, -1)
    fmt.Printf("%p, %s
", fp.Fd(), fp.Name())
    fr, fw, _ := os.Pipe()
    in := []byte("aljkdflajs;lfjalsjfoawjlfkjaslkjflkashglhaklsjfjalsjfklasjklf")

    out = make([]byte, 100)

    go gofn(fw, in)

    fr.Read(out)
    fmt.Println(string(out))

    go func() {
        fw.WriteString("--------------------------------------------------------------")
        fr.Read(out)
        fmt.Println(string(out))
    }()

    dirname, _ := fp.Readdirnames(-1)
    for _, yy := range dirname {
        fmt.Printf("--------%s
", yy)
    }

    fp.Seek(0, 0)

    fii, _ := fp.Readdir(-1)
    for _, xx := range fii {
        fmt.Printf("+++++++%s
", xx.Name())
    }

    //    type Process struct {// {{{
    //        Pid int
    //    }
    //
    //    type ProcAttr struct {
    //        Dir string
    //        Env []string
    //        Files []*File
    //        Sys *syscall.SysProcAttr
    //    }
    //
    //    type ProcessState struct {}
    // }}}

    pattr := os.ProcAttr{Files: []*os.File{os.Stdin, os.Stdout, os.Stderr}}
    cmd := []string{"", "/tmp"}

    var ps *os.Process
    go func() {
        ps, _ = os.StartProcess("/bin/ls", cmd, &pattr)
    }()

    go func() {
        fmt.Println("Sleeping...3s...")
        time.Sleep(time.Second * 3)

        ps.Kill()
        ps.Signal(os.Interrupt)

    }()

    fmt.Println("Sleeping...3s...")
    time.Sleep(time.Second * 3)

    procstat, _ := ps.Wait()
    fmt.Println(procstat.String(), procstat.Exited(), procstat.Pid(), procstat.SystemTime(), procstat.UserTime())

    fp.Close()
}

func defer_printBye() {
    fmt.Println("Bye, thanks for CPU time")
}

func print_err(info string) {
    if nil != err {
        fmt.Fprintln(os.Stderr, errors.New(info))
    }
}

func file_info(path string) (int, os.FileMode) {
    var ftype int
    var fm os.FileMode

    fi, err := os.Lstat(path)
    if nil != err {
        switch {
        case os.IsNotExist(err):
            print_err("IsNotExist")
        case os.IsPermission(err):
            print_err("IsPermission")
        default:
            print_err("Unknown errors")
            break
        }
        os.Exit(1)
    } else {
        switch fm = fi.Mode(); {
        case fm.IsDir():
            ftype = Dir
        case fm&os.ModeSymlink != 0:
            ftype = Symlink
        case fm.IsRegular():
            ftype = Regular
        case fm&os.ModeSocket != 0:
            ftype = Socket
        case fm&os.ModeNamedPipe != 0:
            ftype = NamedPipe
        default:
            ftype = Unknown
        }
    }
    return ftype, fm
}

func file_type_string(ftype int) string {
    var res string
    switch ftype {
    case Dir:
        res = "Dir"
    case Regular:
        res = "Regular"
    case Socket:
        res = "Socket"
    case NamedPipe:
        res = "NamedPipe"
    case Unknown:
        res = "Unknown"
    default:
        res = "Symlink"
    }
    return res
}

func gofn(fw *os.File, in []byte) {
    num, _ := fw.Write(in)
    if num != len(in) {
        print_err("write failed")
    }
} 

...