shithub: snarflog

ref: 4bc4f278c65d7e9f8e854ed411d7fb9ac43e7870
dir: /main.go/

package main

import (
	"fmt"
	"os"
	"io"
	"sync"
	"time"

	"golang.org/x/sys/plan9"
	"github.com/knusbaum/go9p/fs"
	"github.com/knusbaum/go9p"
	"github.com/knusbaum/go9p/proto"
)

type snarfile struct {
	fs.BaseFile
	snarfStream fs.Stream
	mu sync.Mutex
}

func (f *snarfile) Write(fid uint64, offset uint64, data []byte) (uint32, error) {
	f.mu.Lock()
	defer f.mu.Unlock()
	realwrite, err := os.OpenFile("/mnt/snarflog/rsnarf", os.O_WRONLY, 0644)
	if err != nil {
		fmt.Printf("Coudn't open snarf for writing: %s\n", err)
		return 0, err
	}

	defer realwrite.Close()
	realwrite.Write(data)
	_, err = f.snarfStream.Write(data)
	if err != nil {
		return 0, err
	}
	if data[len(data)-1] != '\n' {
		f.snarfStream.Write([]byte{'\n'})
	}
	return uint32(len(data)), nil
}

func (f *snarfile) Read(fid uint64, offset uint64, count uint64) ([]byte, error) {
	real, err := os.Open("/mnt/snarflog/rsnarf")
	if err != nil {
		return nil, err
	}
	defer real.Close()

	buf := make([]byte, count)
	n, err := real.ReadAt(buf, int64(offset))
	if err != nil && err != io.EOF {
		return nil, err
	}
	return buf[:n], nil
}

func newSnarf(fsys *fs.FS, name, uid, gid string, perm uint32, stream fs.Stream) *snarfile {
	stat := fsys.NewStat(name, uid, gid, perm)
	return &snarfile{
		BaseFile: *fs.NewBaseFile(stat),
		snarfStream: stream,
	}
}

func mountmnt(user string) {
	fid, dir := fs.NewFS(user, user, proto.DMDIR|0644)
	stat := fid.NewStat("rsnarf", user, user, 0644)
	mntfile := fs.NewBaseFile(stat)
	dir.AddChild(mntfile)
	var fds [2]int
	var err error
	err = plan9.Pipe(fds[:])
	if err != nil {
		fmt.Printf("Failed to create pipe for /mnt/snarflog: %s\n", err)
		os.Exit(1)
	}
	rw := os.NewFile(uintptr(fds[0]), "")

	go func() {
		if err := go9p.ServeReadWriter(rw, rw, fid.Server()); err != nil {
			fmt.Printf("failed to serve /mnt/snarflog: %v\n", err)
			os.Exit(1)
		}
	}()

	plan9.Mount(fds[1], -1, "/mnt/snarflog", plan9.MREPL, "")
	err = plan9.Bind("/dev/snarf", "/mnt/snarflog/rsnarf", plan9.MREPL)
}

func main() {
	_, err := os.Stat("/srv/snarflog")
	if err == nil {
		srvFd, err := plan9.Open("/srv/snarflog", plan9.O_RDWR)
		if err != nil {
			fmt.Printf("bad snarflog in srv: %v\n", err)
			os.Exit(1)
		}
		defer plan9.Close(srvFd)
		err = plan9.Mount(srvFd, -1, "/dev", plan9.MBEFORE, "")
		os.Exit(1)
	}
	
	user := os.Getenv("user")
	
	mountmnt(user)
	fid, dir := fs.NewFS(user, user, proto.DMDIR|0644)

	snarfStream := fs.NewSkippingStream(1024)
	snarfLogStat := fid.NewStat("snarflog", user, user, 0644)
	snarfLogFile := fs.NewStreamFile(snarfLogStat, snarfStream)

	if err := dir.AddChild(snarfLogFile); err != nil {
		fmt.Printf("Err adding snarflog: %s\n", err)
		return
	}
	snarf := newSnarf(fid, "snarf", user, user, 0644, snarfStream)

	if err := dir.AddChild(snarf); err != nil {
		fmt.Printf("Err: %s\n", err)
		return
	}
	
	go func() {
		if err := go9p.PostSrv("snarflog", fid.Server()); err != nil {
			fmt.Printf("Failed to post server: %v\n", err)
			os.Exit(1)
		}
	}()

	for {
		_, err := os.Stat("/srv/snarflog")
		if err == nil {
			break
		}
		time.Sleep(100 * time.Millisecond)
	}

	srvFd, err := plan9.Open("/srv/snarflog", plan9.O_RDWR)
	if err != nil {
		fmt.Printf("Failed to open /srv/snarflog: %v\n", err)
		os.Exit(1)
	}
	defer plan9.Close(srvFd)

	err = plan9.Mount(srvFd, -1, "/dev", plan9.MBEFORE, "")
	if err != nil {
		fmt.Printf("Failed to mount: %v\n", err)
		os.Exit(1)
	}

	select{}
}