Golang client.Ns类代码示例

func main() {
	flag.Parse()

	naddr := *addr
	if strings.LastIndex(naddr, ":") == -1 {
		naddr = naddr + ":5640"
	}

	c, err := g9pc.Mount("tcp", naddr, "")
	if err != nil {
		log.Fatalf("error mounting %s: %v", naddr, err)
	}

	ns := new(g9pc.Ns)
	root, err := c.Walk("")
	if err != nil {
		log.Fatalf("error walking to /: %v", err)
	}
	ns.Root = g9pc.NewNsFile(root.File())
	ns.Dot = ns.Root

	if flag.NArg() > 0 {
		flags := flag.Args()
		for _, uc := range flags {
			cmd(ns, uc)
		}
	} else {
		interactive(ns)
	}

	return
}

func lsone(ns *g9pc.Ns, s string, long bool) {
	st, err := ns.Stat(s)
	if err != nil {
		fmt.Fprintf(os.Stderr, "error stat: %s\n", err)
		return
	}
	if st.Mode&g9p.DMDIR != 0 {
		file, err := ns.Open(s, g9p.OREAD)
		if err != nil {
			fmt.Fprintf(os.Stderr, "error opening dir: %s\n", err)
			return
		}
		defer file.Close()
		for {
			d, err := file.Dirread()
			if err != nil && err != io.EOF {
				fmt.Fprintf(os.Stderr, "error reading dir: %s\n", err)
			}
			if d == nil || len(d) == 0 {
				break
			}
			for _, dir := range d {
				if long {
					fmt.Fprintf(os.Stdout, "%s\n", dirtostr(dir))
				} else {
					os.Stdout.WriteString(dir.Name + "\n")
				}
			}
		}
	} else {
		fmt.Fprintf(os.Stdout, "%s\n", dirtostr(st))
	}
}

func cmdread(ns *g9pc.Ns, s []string) {
	sq, results := seq.NewSequencer()
	go func() {
		r := <-results // walk result
		r = <-results  // open result
		r = <-results  // readstream result
		_, ok := <-results
		if ok {
			panic("expected closed")
		}
	}()

	f := ns.SeqWalk(sq, s[0])
	sq.Do(f.File(), seq.OpenReq{g9p.OREAD})
	rd := f.SeqReadStream(sq, 200, 20)

	buf := make([]byte, 10)
	for {
		n, err := rd.Read(buf)
		if n == 0 {
			fmt.Fprintf(os.Stderr, "read error: %v\n", err)
			break
		}
		fmt.Printf("%q\n", buf[0:n])
	}
	rd.Close()
	sq.Do(f.File(), seq.ClunkReq{}) // strictly speaking unnecessary.
	sq.Do(nil, nil)
	sq.Wait()
}

// Remove f from remote server
func rmone(ns *g9pc.Ns, f string) {
	err := ns.Remove(f)
	if err != nil {
		fmt.Fprintf(os.Stderr, "error in stat %s: %s\n", f, err)
		return
	}
}

// Copy a remote file to local filesystem
func cmdget(ns *g9pc.Ns, s []string) {
	var from, to string
	switch len(s) {
	case 1:
		from, to = path.Split(path.Clean(s[0]))
	case 2:
		from, to = s[0], s[1]
	default:
		fmt.Fprintf(os.Stderr, "from arguments; usage: get from to\n")
	}

	tofile, err := os.Create(to)
	if err != nil {
		fmt.Fprintf(os.Stderr, "error opening %s for writing: %s\n", to, err)
		return
	}
	defer tofile.Close()

	file, err := ns.Open(from, g9p.OREAD)
	if err != nil {
		fmt.Fprintf(os.Stderr, "error opening %s for writing: %s\n", to, err)
		return
	}
	defer file.Close()

	_, err = io.Copy(tofile, file)
	if err != nil {
		fmt.Fprintf(os.Stderr, "error copying: %v\n", err)
		return
	}
}

// Create a single directory on remote server
func mkone(ns *g9pc.Ns, fname string) {
	file, err := ns.Create(fname, g9p.OREAD, 0777|g9p.DMDIR)
	if err != nil {
		fmt.Fprintf(os.Stderr, "error creating directory %s: %s\n", fname, err)
		return
	}
	file.Close()
}

// Stat the remote file f
func statone(ns *g9pc.Ns, f string) {
	stat, err := ns.Stat(f)
	if err != nil {
		fmt.Fprintf(os.Stderr, "error in stat %s: %s\n", f, err)
		return
	}
	fmt.Fprintf(os.Stdout, "%v\n", stat)
}

// Print the contents of f using streaming.
func cmdstream(ns *g9pc.Ns, s []string) {
	for _, fname := range s {
		r := ns.ReadStream(fname, 20, 10)
		_, err := io.Copy(os.Stdout, r)
		if err != nil {
			fmt.Fprintf(os.Stderr, "error reading %s: %v\n", fname, err)
		}
		r.Close()
	}
}

func cmdcd(ns *g9pc.Ns, s []string) {
	if s == nil {
		return
	}
	d := s[0]
	err := ns.Chdir(d)
	if err != nil {
		fmt.Fprintf(os.Stderr, "chdir: %v\n", err)
		return
	}
	cwd = path.Clean(cwd + "/" + d)
}

// Print the contents of f
func cmdcat(ns *g9pc.Ns, s []string) {
	for _, fname := range s {
		file, err := ns.Open(fname, g9p.OREAD)
		if err != nil {
			fmt.Fprintf(os.Stderr, "error opening %s: %s\n", fname, err)
			continue
		}
		defer file.Close()
		_, err = io.Copy(os.Stdout, file)
		if err != nil {
			fmt.Fprintf(os.Stderr, "error: %v\n", err)
		}
	}
}

func cmdtorture(ns *g9pc.Ns, s []string) {
	path := "."
	if len(s) > 0 {
		path = s[0]
	}
	t := &traverser{
		out:  make(chan string),
		refc: make(chan int),
		//		tokc: make(chan bool, 2),
	}
	if len(s) > 1 {
		max, err := strconv.Atoi(s[1])
		if err != nil {
			fmt.Fprintf(os.Stderr, "max?: %v\n", err)
			return
		}
		t.tokc = make(chan bool, max)
		for i := 0; i < max; i++ {
			t.tokc <- true
		}
	}
	fid, err := ns.Walk(path)
	if fid == nil {
		fmt.Fprintf(os.Stderr, "cannot walk to %s: %v\n", s[0], err)
		return
	}
	ref := 1
	maxref := 1
	go func() {
		t.traverse(fid, path, "", make(chan bool, 1))
		t.refc <- -1
	}()
	for ref > 0 {
		select {
		case s := <-t.out:
			fmt.Print("************ ", s)
		case r := <-t.refc:
			ref += r
			if ref > maxref {
				maxref = ref
			}
		}
	}
	fmt.Printf("\n")
	fmt.Printf("max procs %d\n", maxref)
}

// Write the string s to remote file f. Create f if it doesn't exist
func writeone(ns *g9pc.Ns, fname, s string) {
	file, err := ns.Open(fname, g9p.OWRITE|g9p.OTRUNC)
	if err != nil {
		file, err = ns.Create(fname, g9p.OWRITE, 0666)
		if err != nil {
			fmt.Fprintf(os.Stderr, "error opening %s: %v\n", fname, err)
			return
		}
	}
	defer file.Close()

	m, err := file.Write([]byte(s))
	if err != nil {
		fmt.Fprintf(os.Stderr, "error writing to %s: %s\n", fname, err)
		return
	}

	if m != len(s) {
		fmt.Fprintf(os.Stderr, "short write %s\n", fname)
		return
	}
}

// Copy a local file to remote server
func cmdput(ns *g9pc.Ns, s []string) {
	var from, to string
	switch len(s) {
	case 1:
		_, to = path.Split(s[0])
		to = normpath(to)
		from = s[0]
	case 2:
		from, to = s[0], normpath(s[1])
	default:
		fmt.Fprintf(os.Stderr, "incorrect arguments; usage: put local [remote]\n")
	}

	fromfile, err := os.Open(from)
	if err != nil {
		fmt.Fprintf(os.Stderr, "error opening %s for reading: %s\n", from, err)
		return
	}
	defer fromfile.Close()

	file, err := ns.Open(to, g9p.OWRITE|g9p.OTRUNC)
	if err != nil {
		file, err = ns.Create(to, g9p.OWRITE, 0666)
		if err != nil {
			fmt.Fprintf(os.Stderr, "error opening %s for writing: %s\n", to, err)
			return
		}
	}
	fmt.Fprintf(os.Stderr, "opened file ok\n")
	defer file.Close()
	n, err := Copy(file, fromfile)
	if err != nil {
		fmt.Fprintf(os.Stderr, "error copying file: %v (%d bytes copied)\n", err, n)
	}
	fmt.Fprintf(os.Stderr, "copied %d bytes\n", n)
}