9sh

main.go (3968B)

---

 package main
 
 import (
 	"context"
 	"errors"
 	"fmt"
 	"io"
 	"io/fs"
 	"log"
 	"net"
 	"os"
 	"path"
 	"strings"
 
 	"git.mtkn.jp/lib9p"
 	"git.mtkn.jp/lib9p/client"
 )
 
 
 type stat struct {
 	cwd  string // current working directory. absolute path.
 	f    lib9p.File
 	fsys *unionFS
 }
 
 type token struct {
 	cmd string
 	err error
 }
 
 type cmd struct {
 	args []string
 	err error
 }
 
 func (c *cmd) run(s *stat) error {
 	defer func() {
 		p := recover()
 		if p != nil {
 			log.Printf("s.cwd: %q", s.cwd)
 			panic(p)
 		}
 	}()
 	if len(c.args) < 1 {
 		return errors.New("no command specified")
 	}
 	switch c.args[0] {
 	case "cd":
 		var p string
 		if len(c.args) == 1 {
 			p = "."
 		} else if len(c.args) == 2 {
 			p = absPath(s.cwd, c.args[1])
 		} else {
 			return fmt.Errorf("usage: cd <dir>")
 		}
 		if s.f != nil {
 			s.f.Close()
 		}
 		fi, err := fs.Stat(lib9p.ExportFS{s.fsys}, p)
 		if err != nil {
 			return err
 		}
 		if !fi.IsDir() {
 			return fmt.Errorf("not a directory")
 		}
 		f, err := s.fsys.OpenFile(p, lib9p.OREAD)
 		if err != nil {
 			return err
 		}
 		s.f = f
 		s.cwd = p
 		return nil
 	case "pwd":
 		fmt.Println(s.cwd)
 		return nil
 	case "ls":
 		p := s.cwd
 		if len(c.args) > 1 {
 			p = absPath(p, c.args[1])
 		}
 		files, err := fs.Glob(lib9p.ExportFS{s.fsys}, path.Join(p, "*"))
 		if err != nil {
 			return err
 		}
 		for _, f := range files {
 			fmt.Println(f)
 		}
 		return nil
 	case "mount":
 		if len(c.args) != 3 {
 			return fmt.Errorf("usage: mount servename mtpt")
 		}
 		servname, mtpt := c.args[1], c.args[2]
 		conn, err := net.Dial("tcp", servname)
 		if err != nil {
 			return err
 		}
 		var p string
 		if len(mtpt) != 0 && mtpt[0] == '/' {
 			p = absPath("", mtpt)
 		} else {
 			p = absPath(s.cwd, mtpt)
 		}
 		cfsys, err := client.Mount(context.TODO(), conn, conn, "kenji", "")
 		if err != nil {
 			return err
 		}
 		s.fsys.Mount(cfsys, p)
 		return nil
 	case "fstab" :
 		fmt.Println(s.fsys.fstab)
 		return nil
 	default:
 		return fmt.Errorf("unknown command %v", c.args[0])
 	}
 }
 
 func main() {
 	conn, err := net.Dial("tcp", "127.0.0.1:5640")
 	if err != nil {
 		log.Fatalf("dial: %v", err)
 	}
 	defer conn.Close()
 	ctx, cancel := context.WithCancel(context.Background())
 	fsys, err := client.Mount(ctx, conn, conn, "kenji", "")
 	if err != nil {
 		log.Fatalf("mount: %v", err)
 	}
 	defer cancel()
 	tc := runTokenizer(ctx, os.Stdin)
 	cc := runParser(ctx, tc)
 	s := &stat{
 		cwd: ".",
 		fsys: &unionFS{fstab: map[string]lib9p.FS{".": fsys}},
 	}
 	for {
 		fmt.Printf("9%% ")
 		c := <-cc
 		if c.err == io.EOF {
 			break
 		} else if c.err != nil {
 			log.Println(c.err)
 			continue
 		}
 		if err := c.run(s); err != nil {
 			log.Println(err)
 		}
 	}
 }
 
 func read(r io.Reader) (string, error) {
 	b := make([]byte, 128)
 	n, err := r.Read(b)
 	if err != nil {
 		return "", err
 	}
 	return string(b[:n]), nil
 }
 
 func runTokenizer(ctx context.Context, r io.Reader) <-chan *token {
 	tc := make(chan *token)
 	go func() {
 		defer close(tc)
 L:
 		for {
 			select {
 			case <-ctx.Done():
 				break L
 			default:
 			}
 			str, err := read(r)
 			if err != nil {
 				select {
 				case tc <-&token{cmd: "", err: err}:
 					continue L
 				case <-ctx.Done():
 					break L
 				}
 			}
 			ts := strings.Split(str, " ")
 			for _, s := range ts {
 				t := &token{cmd: s, err: nil}
 				select {
 				case tc <- t:
 				case <-ctx.Done():
 					break L
 				}
 			}
 		}
 	}()
 	return tc
 }
 
 func runParser(ctx context.Context, tc <-chan *token) <-chan *cmd {
 	cc := make(chan *cmd)
 	go func() {
 		defer close(cc)
 L:
 		for {
 			c := new(cmd)
 M:
 			for {
 				select {
 				case <-ctx.Done():
 					break L
 				case t := <-tc:
 					if t.err != nil {
 						c.err = t.err
 						break M
 					}
 					end := false
 					if len(t.cmd) == 0 {
 						continue M
 					}
 					if t.cmd[len(t.cmd)-1] == '\n' {
 						t.cmd = t.cmd[:len(t.cmd)-1]
 						end = true
 					}
 					c.args = append(c.args, t.cmd)
 					if end {
 						break M
 					}
 				}
 			}
 			select {
 			case <-ctx.Done():
 				break L
 			case cc<- c:
 			}
 		}
 	}()
 	return cc
 }