clean code

.gitignore

@@ -4,4 +4,7 @@ makesbvj01/makesbvj01
 dumpsbvj01/dumpsbvj01
 dumpbtreedb/dumpbtreedb
 makebtreedb/makebtreedb
+test
 */*.exe
+*.world
+world*

dumpbtreedb/main.go

@@ -5,16 +5,18 @@ import (
 	"compress/zlib"
 	"encoding/hex"
 	"flag"
+	"fmt"
 	"io"
 	"log"
 	"os"
 
-	"../lib/btreedb5"
+	"github.com/xhebox/sbutils/lib/btreedb5"
 )
 
 func main() {
-	var in string
+	var in, mode string
 	flag.StringVar(&in, "i", "input", "input file")
+	flag.StringVar(&mode, "m", "default", "default/records")
 	flag.Parse()
 	log.SetFlags(log.Llongfile)
 
@@ -24,46 +26,49 @@ func main() {
 	}
 	defer h.Close()
 
-	h.SetTree(1)
-	e = h.Traverse(func(record btreedb5.Record) error {
-		z, e := zlib.NewReader(bytes.NewReader(record.Data))
-		if e != nil {
-			return e
-		}
+	switch mode {
+	/*
+		case "records":
+			e = h.DumpBlocks(func(record btreedb5.Record) error {
+				z, e := zlib.NewReader(bytes.NewReader(record.Data))
+				if e != nil {
+					return e
+				}
 
-		f, e := os.OpenFile("tree1_"+hex.EncodeToString(record.Key), os.O_RDWR|os.O_CREATE, 0644)
-		if e != nil {
-			return e
-		}
+				f, e := os.OpenFile(hex.EncodeToString(record.Key), os.O_RDWR|os.O_CREATE, 0644)
+				if e != nil {
+					return e
+				}
 
-		io.Copy(f, z)
+				io.Copy(f, z)
 
-		z.Close()
-		f.Close()
-		return nil
-	})
-	if e != nil {
-		log.Fatalln(e)
-	}
+				z.Close()
+				f.Close()
+				return nil
+			})
+			if e != nil {
+				log.Fatalln(e)
+			}
+	*/
+	default:
+		e = h.Ascend(func(key btreedb5.Key, data []byte) {
+			z, e := zlib.NewReader(bytes.NewReader(data))
+			if e != nil {
+				panic(e)
+			}
 
-	h.SetTree(2)
-	e = h.Traverse(func(record btreedb5.Record) error {
-		z, e := zlib.NewReader(bytes.NewReader(record.Data))
-		if e != nil {
-			return e
-		}
+			f, e := os.OpenFile(fmt.Sprintf("data_%s", hex.EncodeToString(key)), os.O_RDWR|os.O_CREATE, 0644)
+			if e != nil {
+				panic(e)
+			}
+
+			io.Copy(f, z)
 
-		f, e := os.OpenFile("tree2_"+hex.EncodeToString(record.Key), os.O_RDWR|os.O_CREATE, 0644)
+			z.Close()
+			f.Close()
+		})
 		if e != nil {
-			return e
+			log.Fatalf("%+v\n", e)
 		}
-
-		io.Copy(f, z)
-		z.Close()
-		f.Close()
-		return nil
-	})
-	if e != nil {
-		log.Fatalln(e)
 	}
 }

dumpsbvj01/main.go

@@ -18,7 +18,7 @@ func main() {
 	var skip int
 	flag.StringVar(&in, "i", "input", "versioned json file")
 	flag.StringVar(&out, "o", "stdout", "output json")
-	flag.StringVar(&mode, "m", "vj", "vjmagic/vj/raw")
+	flag.StringVar(&mode, "m", "vj", "vjmagic/vj/raw/nvj")
 	flag.IntVar(&skip, "n", 0, "skip first n bytes")
 	flag.Parse()
 	log.SetFlags(log.Llongfile)
@@ -60,7 +60,7 @@ func main() {
 			log.Fatalln(e)
 		}
 	case "vj":
-		r, e := sbvj01.Parse(contents)
+		r, _, e := sbvj01.Parse(contents)
 		if e != nil {
 			log.Fatalln(e)
 		}
@@ -74,8 +74,30 @@ func main() {
 		if e != nil {
 			log.Fatalln(e)
 		}
+	case "nvj":
+		r := int(int8(contents[0]))
+
+		off := 1
+		for i := 0; i < r; i++ {
+			r, l, e := sbvj01.Parse(contents[off:])
+			if e != nil {
+				log.Fatalln(e)
+			}
+
+			out, e := json.MarshalIndent(r, "", "\t")
+			if e != nil {
+				log.Fatalln(e)
+			}
+
+			_, e = io.Copy(outwt, bytes.NewReader(out))
+			if e != nil {
+				log.Fatalln(e)
+			}
+
+			off += l
+		}
 	case "vjmagic":
-		r, e := sbvj01.ParseMagic(contents)
+		r, _, e := sbvj01.ParseMagic(contents)
 		if e != nil {
 			log.Fatalln(e)
 		}

filter/.gitignore

@@ -0,0 +1,2 @@
+filter
+log

filter/main.go

@@ -0,0 +1,101 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"net"
+
+	"github.com/xhebox/sbutils/lib/packet"
+)
+
+func Callback(r *Filter, p packet.Packet) {
+	fmt.Printf("%+v\n", p)
+}
+
+var laddr, saddr, mode string
+
+func forward(conn net.Conn) {
+	rconn, err := net.Dial("tcp", saddr)
+	if err != nil {
+		log.Fatalln("dial failed: ", err)
+	}
+
+	log.Println("connected to: ", rconn.RemoteAddr())
+	switch mode {
+	case "all":
+		p := NewFilter(conn, rconn, Callback)
+		q := NewFilter(rconn, conn, Callback)
+		go func() {
+			defer conn.Close()
+			defer rconn.Close()
+			e := p.Loop()
+			log.Printf("parse cs: %+v\n", e)
+		}()
+		go func() {
+			defer conn.Close()
+			defer rconn.Close()
+			e := q.Loop()
+			log.Printf("parse sc: %+v\n", e)
+		}()
+	case "client":
+		p := NewFilter(conn, rconn, Callback)
+		go func() {
+			defer conn.Close()
+			defer rconn.Close()
+			e := p.Loop()
+			log.Printf("parse cs: %+v\n", e)
+		}()
+		go func() {
+			io.Copy(conn, rconn)
+		}()
+	case "server":
+		q := NewFilter(rconn, conn, Callback)
+		go func() {
+			defer conn.Close()
+			defer rconn.Close()
+			e := q.Loop()
+			log.Printf("parse sc: %+v\n", e)
+		}()
+		go func() {
+			io.Copy(rconn, conn)
+		}()
+	default:
+		go func() {
+			defer rconn.Close()
+			defer conn.Close()
+			io.Copy(conn, rconn)
+		}()
+		go func() {
+			defer rconn.Close()
+			defer conn.Close()
+			io.Copy(rconn, conn)
+		}()
+	}
+}
+
+func main() {
+	flag.StringVar(&laddr, "l", "127.0.0.1:21026", "listened address")
+	flag.StringVar(&saddr, "t", "127.0.0.1:21025", "server address")
+	flag.StringVar(&mode, "m", "all", "could be client(filter packages from client to server)/server(filter packages from server to client)/all")
+	flag.Parse()
+	log.SetFlags(log.Lshortfile)
+
+	listener, err := net.Listen("tcp", laddr)
+	if err != nil {
+		log.Fatalln("failed to listen: ", err)
+	}
+	log.Println("listened to: ", laddr)
+	log.Println("forward to: ", saddr)
+
+	for {
+		conn, err := listener.Accept()
+		if err != nil {
+			log.Fatalln("failed to accept connection: ", err)
+		}
+
+		log.Println("accepted connection: ", conn.RemoteAddr())
+		go forward(conn)
+	}
+}

filter/packet.go

@@ -0,0 +1,124 @@
+package main
+
+import (
+	"bytes"
+	"compress/zlib"
+	"fmt"
+	"io"
+	"io/ioutil"
+
+	"github.com/pkg/errors"
+	"github.com/xhebox/bstruct/byteorder"
+	"github.com/xhebox/sbutils/lib/packet"
+)
+
+var (
+	ErrUnknownType = errors.New("packet of unknown type")
+)
+
+type FilterCallback func(*Filter, packet.Packet)
+
+type Filter struct {
+	in  io.Reader
+	out io.Writer
+	// filter function
+	cb  FilterCallback
+	End byteorder.ByteOrder
+}
+
+func NewFilter(in io.Reader, out io.Writer, cb FilterCallback) *Filter {
+	r := &Filter{}
+	r.in = in
+	r.out = out
+	r.cb = cb
+	r.End = byteorder.BigEndian
+	return r
+}
+
+func (r *Filter) ReadPacket() (*packet.BasePacket, error) {
+	pktType, e := byteorder.Uint8(r.in)
+	if e != nil {
+		return nil, errors.WithStack(e)
+	}
+
+	length, e := byteorder.Varint(r.in, r.End)
+	if e != nil {
+		return nil, errors.WithStack(e)
+	}
+	abslength := int64(length)
+	if abslength < 0 {
+		abslength = -abslength
+	}
+
+	buf := &bytes.Buffer{}
+
+	in := io.LimitReader(r.in, abslength)
+
+	if length < 0 {
+		zin, e := zlib.NewReader(in)
+		if e != nil {
+			return nil, errors.WithStack(e)
+		}
+
+		defer zin.Close()
+		in = zin
+	}
+
+	_, e = io.Copy(buf, in)
+	if e != nil {
+		return nil, errors.WithStack(e)
+	}
+
+	return &packet.BasePacket{Type: pktType, Buf: buf.Bytes()}, nil
+}
+
+func (r *Filter) WritePacket(pkt *packet.BasePacket) error {
+	e := byteorder.PutUint8(r.out, pkt.Type)
+	if e != nil {
+		return errors.WithStack(e)
+	}
+
+	e = byteorder.PutVarint(r.out, r.End, int64(len(pkt.Buf)))
+	if e != nil {
+		return errors.WithStack(e)
+	}
+
+	_, e = r.out.Write(pkt.Buf)
+	if e != nil {
+		return errors.WithStack(e)
+	}
+
+	return nil
+}
+
+// loop function
+func (r *Filter) Loop() error {
+	for {
+		pkt, e := r.ReadPacket()
+		if e != nil {
+			return errors.WithStack(e)
+		}
+
+		p, e := pkt.Parse(r.End)
+		if e != nil {
+			fmt.Println(e)
+		}
+
+		if p != nil {
+			if r.cb != nil {
+				r.cb(r, p)
+			}
+
+			pkt, e = p.Pack(r.End)
+			if e != nil {
+				return errors.WithStack(e)
+			}
+		} else if pkt.Type == 13 {
+			ioutil.WriteFile("../out", pkt.Buf, 0644)
+		}
+
+		if e := r.WritePacket(pkt); e != nil {
+			return errors.WithStack(e)
+		}
+	}
+}