优化

reg.go

@@ -15,29 +15,28 @@ import (
 )
 
 var (
-	ErrGetKeyTooLong    = errors.New("get key too long")
-	ErrDecAck           = errors.New("decrypt ack error")
-	ErrInternalServer   = errors.New("internal server error")
-	ErrPermissionDenied = errors.New("permission denied")
-	ErrSetKeyTooLong    = errors.New("set key too long")
-	ErrSetValTooLong    = errors.New("set val too long")
-	ErrUnknownAck       = errors.New("unknown ack error")
-	ErrNoSuchKey        = errors.New("no such key")
-	ErrRawDataTooLong   = errors.New("raw data too long")
-	ErrMd5NotEqual      = errors.New("md5 not equal")
+	ErrGetKeyTooLong    = errors.New("reg: get key too long")
+	ErrDecAck           = errors.New("reg: decrypt ack error")
+	ErrInternalServer   = errors.New("reg: internal server error")
+	ErrPermissionDenied = errors.New("reg: permission denied")
+	ErrSetKeyTooLong    = errors.New("reg: set key too long")
+	ErrSetValTooLong    = errors.New("reg: set val too long")
+	ErrUnknownAck       = errors.New("reg: unknown ack error")
+	ErrNoSuchKey        = errors.New("reg: no such key")
+	ErrRawDataTooLong   = errors.New("reg: raw data too long")
+	ErrMd5NotEqual      = errors.New("reg: md5 not equal")
 )
 
 type Regedit struct {
-	sync.Mutex
-	conn       net.Conn
-	addr       string
-	tp         tea.TEA
-	ts         *tea.TEA
-	dksz, ddsz int
-	seq        byte
+	mu   sync.Mutex
+	conn net.Conn
+	addr string
+	tp   tea.TEA
+	ts   *tea.TEA
+	seq  byte
 }
 
-func NewRegedit(addr, pwd, sps string, dksz, ddsz int) *Regedit {
+func NewRegedit(addr, pwd, sps string) *Regedit {
 	var tp, ts [16]byte
 	if len(pwd) > 15 {
 		pwd = pwd[:15]
@@ -45,44 +44,44 @@ func NewRegedit(addr, pwd, sps string, dksz, ddsz int) *Regedit {
 	if len(sps) > 15 {
 		sps = sps[:15]
 	}
-	copy(tp[:], StringToBytes(pwd))
-	copy(ts[:], StringToBytes(sps))
+	copy(tp[:], pwd)
+	copy(ts[:], sps)
 	s := tea.NewTeaCipherLittleEndian(ts[:])
-	return &Regedit{addr: addr, tp: tea.NewTeaCipherLittleEndian(tp[:]), ts: &s, dksz: dksz, ddsz: ddsz}
+	return &Regedit{addr: addr, tp: tea.NewTeaCipherLittleEndian(tp[:]), ts: &s}
 }
 
-func NewRegReader(addr, pwd string, dksz, ddsz int) *Regedit {
+func NewRegReader(addr, pwd string) *Regedit {
 	var tp [16]byte
 	if len(pwd) > 15 {
 		pwd = pwd[:15]
 	}
-	copy(tp[:], StringToBytes(pwd))
-	return &Regedit{addr: addr, tp: tea.NewTeaCipherLittleEndian(tp[:]), dksz: dksz, ddsz: ddsz}
+	copy(tp[:], pwd)
+	return &Regedit{addr: addr, tp: tea.NewTeaCipherLittleEndian(tp[:])}
 }
 
 func (r *Regedit) Connect() (err error) {
-	r.Lock()
+	r.mu.Lock()
 	if r.conn == nil {
 		r.conn, err = net.Dial("tcp", r.addr)
 	}
-	r.Unlock()
+	r.mu.Unlock()
 	return
 }
 
-func (r *Regedit) ConnectIn(wait time.Duration) (err error) {
-	r.Lock()
+func (r *Regedit) ConnectIn(timeout time.Duration) (err error) {
+	r.mu.Lock()
 	if r.conn == nil {
-		r.conn, err = net.DialTimeout("tcp", r.addr, wait)
+		r.conn, err = net.DialTimeout("tcp", r.addr, timeout)
 	}
-	r.Unlock()
+	r.mu.Unlock()
 	return
 }
 
 func (r *Regedit) Close() (err error) {
-	r.Lock()
-	defer r.Unlock()
+	r.mu.Lock()
+	defer r.mu.Unlock()
 	if r.conn != nil {
-		p := NewCmdPacket(CMDEND, []byte("fill"), &r.tp)
+		p := NewCmdPacket(CMDEND, fill(), &r.tp)
 		r.conn.Write(p.Encrypt(r.seq))
 		p.Put()
 		r.seq = 0
@@ -99,17 +98,17 @@ func (r *Regedit) Get(key string) (string, error) {
 	}
 	p := NewCmdPacket(CMDGET, StringToBytes(key), &r.tp)
 	defer p.Put()
-	r.Lock()
+	r.mu.Lock()
 	r.conn.Write(p.Encrypt(r.seq))
 	r.seq++
 	err := r.ack(p)
 	if err != nil {
-		r.Unlock()
+		r.mu.Unlock()
 		return "", err
 	}
 	err = p.Decrypt(r.seq)
 	r.seq++
-	r.Unlock()
+	r.mu.Unlock()
 	if err != nil {
 		return "", ErrDecAck
 	}
@@ -124,14 +123,14 @@ func (r *Regedit) Get(key string) (string, error) {
 }
 
 func (r *Regedit) Cat() (*Storage, error) {
-	p := NewCmdPacket(CMDCAT, []byte("fill"), &r.tp)
+	p := NewCmdPacket(CMDCAT, fill(), &r.tp)
 	defer p.Put()
-	r.Lock()
+	r.mu.Lock()
 	r.conn.Write(p.Encrypt(r.seq))
 	r.seq++
 	seq := r.seq
 	r.seq++
-	r.Unlock()
+	r.mu.Unlock()
 	var buf [64]byte
 	i := 0
 	for {
@@ -179,17 +178,17 @@ func (r *Regedit) Cat() (*Storage, error) {
 func (r *Regedit) IsMd5Equal(m [md5.Size]byte) (bool, error) {
 	p := NewCmdPacket(CMDMD5, m[:], &r.tp)
 	defer p.Put()
-	r.Lock()
+	r.mu.Lock()
 	r.conn.Write(p.Encrypt(r.seq))
 	r.seq++
 	err := r.ack(p)
 	if err != nil {
-		r.Unlock()
+		r.mu.Unlock()
 		return false, err
 	}
 	err = p.Decrypt(r.seq)
 	r.seq++
-	r.Unlock()
+	r.mu.Unlock()
 	if err != nil {
 		return false, ErrDecAck
 	}
@@ -218,8 +217,8 @@ func (r *Regedit) Set(key, value string) error {
 	}
 	p := NewCmdPacket(CMDSET, StringToBytes(key), r.ts)
 	defer p.Put()
-	r.Lock()
-	defer r.Unlock()
+	r.mu.Lock()
+	defer r.mu.Unlock()
 	r.conn.Write(p.Encrypt(r.seq))
 	r.seq++
 	ack := NewCmdPacket(CMDACK, nil, &r.tp)
@@ -271,19 +270,19 @@ func (r *Regedit) Del(key string) error {
 	}
 	p := NewCmdPacket(CMDDEL, StringToBytes(key), r.ts)
 	defer p.Put()
-	r.Lock()
+	r.mu.Lock()
 	r.conn.Write(p.Encrypt(r.seq))
 	r.seq++
 	ack := NewCmdPacket(CMDACK, nil, &r.tp)
 	defer ack.Put()
 	err := r.ack(ack)
 	if err != nil {
-		r.Unlock()
+		r.mu.Unlock()
 		return err
 	}
 	err = ack.Decrypt(r.seq)
 	r.seq++
-	r.Unlock()
+	r.mu.Unlock()
 	if err != nil {
 		return ErrDecAck
 	}