皇爷提交

.gitignore

@@ -0,0 +1,37 @@
+# ---> Go
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof
+
+
+.idea
+*.exe
+*.test
+*.prof
+*.exe
+*.exe~
+pkg
+swagger
+go.mod
+

src/zks.com/gotcp/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Jie Li
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

src/zks.com/gotcp/README.md

@@ -0,0 +1,88 @@
+gotcp is a powerful package for quickly writing tcp applications/services in golang.
+
+
+Install the gotcp package:
+~~~
+go get github.com/gansidui/gotcp
+~~~
+
+Create server.go file:
+
+~~~ go
+package main
+
+import (
+	"fmt"
+	"github.com/gansidui/gotcp"
+	"log"
+	"net"
+	"os"
+	"os/signal"
+	"runtime"
+	"syscall"
+	"time"
+)
+
+type ConnDelegate struct{}
+
+func (this *ConnDelegate) OnConnect(c *gotcp.Conn) bool {
+	fmt.Println("OnConnect")
+	return true
+}
+
+func (this *ConnDelegate) OnMessage(c *gotcp.Conn, p *gotcp.Packet) bool {
+	fmt.Println("OnMessage:", p.GetLen(), p.GetType(), string(p.GetData()))
+	return true
+}
+
+func (this *ConnDelegate) OnClose(c *gotcp.Conn) {
+	fmt.Println("OnClose")
+}
+
+func (this *ConnDelegate) OnIOError(c *gotcp.Conn, err error) {
+	fmt.Println("OnIOError:", err)
+}
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	tcpAddr, err := net.ResolveTCPAddr("tcp4", "127.0.0.1:8989")
+	checkError(err)
+	listener, err := net.ListenTCP("tcp", tcpAddr)
+	checkError(err)
+
+	config := &gotcp.Config{
+		AcceptTimeout:          5 * time.Second,
+		ReadTimeout:            5 * time.Second,
+		WriteTimeout:           5 * time.Second,
+		MaxPacketLength:        int32(2048),
+		SendPacketChanLimit:    int32(10),
+		ReceivePacketChanLimit: int32(10),
+	}
+	delegate := &ConnDelegate{}
+
+	svr := gotcp.NewServer(config, delegate)
+	go svr.Start(listener)
+
+	ch := make(chan os.Signal)
+	signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
+	log.Printf("Signal: %v\r\n", <-ch)
+
+	svr.Stop()
+}
+
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+
+~~~
+
+
+Run server:
+~~~
+go run server.go
+~~~
+

src/zks.com/gotcp/conn.go

@@ -0,0 +1,320 @@
+package gotcp
+
+import (
+	"errors"
+	"fmt"
+	"log"
+	"net"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// Conn exposes a set of callbacks for the
+// various events that occur on a connection
+type Conn struct {
+	conn        *net.TCPConn     // the raw TCPConn
+	config      *Config          // configure information
+	delegate    ConnDelegate     // callbacks in Conn
+	protocol    Protocol         // data protocol
+	deliverData *deliverConnData // server delivery deliverConnData to the connection to control
+
+	extraData interface{} // save the extra data with conn
+
+	closeOnce sync.Once // close the conn, once, per instance.
+	closeFlag int32
+	closeChan chan struct{}
+
+	sendPacketChan    chan *Packet // send packet queue
+	receivePacketChan chan *Packet // receive packet queue
+}
+
+// ConnDelegate is an interface of methods
+// that are used as callbacks in Conn
+type ConnDelegate interface {
+	// OnConnect is called when the connection was accepted,
+	// If the return value of false is closed
+	OnConnect(*Conn) bool
+
+	// OnMessage is called when the connection receives a packet,
+	// If the return value of false is closed
+	OnMessage(*Conn, *Packet) bool
+
+	// OnClose is called when the connection closed
+	OnClose(*Conn)
+
+	// OnIOError is called when the connection experiences
+	// a low-level TCP transport error
+	OnIOError(*Conn, error)
+}
+
+// The configure of connection
+type Config struct {
+	AcceptTimeout          time.Duration // connection accepted timeout
+	ReadTimeout            time.Duration // connection read timeout
+	WriteTimeout           time.Duration // connection write timeout
+	MaxPacketLength        uint32        // the maximum length of packet
+	SendPacketChanLimit    uint32        // the limit of packet send channel
+	ReceivePacketChanLimit uint32        // the limit of packet receive channel
+}
+
+func newConn(conn *net.TCPConn,, config *Config, delegate ConnDelegate, protocol Protocol, deliverData *deliverConnData) *Conn {
+	return &Conn{
+		conn:              conn,
+		config:            config,
+		delegate:          delegate,
+		protocol:          protocol,
+		deliverData:       deliverData,
+		closeChan:         make(chan struct{}),
+		sendPacketChan:    make(chan *Packet, config.SendPacketChanLimit),
+		receivePacketChan: make(chan *Packet, config.ReceivePacketChanLimit),
+	}
+}
+
+// Get extra data
+func (c *Conn) GetExtraData() interface{} {
+	return c.extraData
+}
+
+// Put extra data
+func (c *Conn) PutExtraData(data interface{}) {
+	c.extraData = data
+}
+
+// Get the raw connection to use more features
+func (c *Conn) GetRawConn() *net.TCPConn {
+	return c.conn
+}
+
+// Close the Conn
+func (c *Conn) Close() {
+	c.closeOnce.Do(func() {
+		atomic.StoreInt32(&c.closeFlag, 1)
+		close(c.closeChan)
+		c.conn.Close()
+		c.delegate.OnClose(c)
+	})
+}
+
+func (c *Conn) SetReadDeadline(timeout time.Duration) {
+	c.conn.SetReadDeadline(time.Now().Add(timeout))
+}
+
+func (c *Conn) SetWriteDeadline(timeout time.Duration) {
+	c.conn.SetWriteDeadline(time.Now().Add(timeout))
+}
+
+// Indicates whether or not the connection is closed
+func (c *Conn) IsClosed() bool {
+	return atomic.LoadInt32(&c.closeFlag) == 1
+}
+
+// Sync read a packet, this method will block on IO
+func (c *Conn) ReadPacket() (*Packet, error) {
+	return c.protocol.ReadPacket(c.conn, c.config.MaxPacketLength)
+}
+
+// Async read a packet, this method will never block
+func (c *Conn) AsyncReadPacket(timeout time.Duration) (*Packet, error) {
+	if c.IsClosed() {
+		return nil, ConnClosedError
+	}
+
+	if timeout == 0 {
+		select {
+		case p := <-c.receivePacketChan:
+			return p, nil
+
+		case <-c.closeChan:
+			return nil, ConnClosedError
+
+		default:
+			return nil, ReadBlockedError
+		}
+
+	} else {
+		select {
+		case p := <-c.receivePacketChan:
+			return p, nil
+
+		case <-c.closeChan:
+			return nil, ConnClosedError
+
+		case <-time.After(timeout):
+			return nil, ReadBlockedError
+		}
+	}
+}
+
+// Sync write a packet, this method will block on IO
+func (c *Conn) WritePacket(p *Packet) error {
+	if c.IsClosed() {
+		return ConnClosedError
+	}
+
+	if n, err := c.conn.Write(p.Serialize()); err != nil || n != int(p.GetLen()) {
+		return errors.New(fmt.Sprintf("Write error: [%v], n[%v], p len[%v]", err, n, p.GetLen()))
+	}
+
+	return nil
+}
+func (c *Conn) WritePacketN(p *Packet) (int ,error) {
+	if c.IsClosed() {
+		return 100,ConnClosedError
+	}
+	n, err := c.conn.Write(p.Serialize());
+	if  err != nil || n != int(p.GetLen()) {
+		return n,errors.New(fmt.Sprintf("Write error: [%v], n[%v], p len[%v]", err, n, p.GetLen()))
+	}
+
+	return n,nil
+}
+
+// Async write a packet, this method will never block
+func (c *Conn) AsyncWritePacket(p *Packet, timeout time.Duration) error {
+	if c.IsClosed() {
+		return ConnClosedError
+	}
+
+	if timeout == 0 {
+		select {
+		case c.sendPacketChan <- p:
+			return nil
+
+		case <-c.closeChan:
+			return ConnClosedError
+
+		default:
+			return WriteBlockedError
+		}
+
+	} else {
+		select {
+		case c.sendPacketChan <- p:
+			return nil
+
+		case <-c.closeChan:
+			return ConnClosedError
+
+		case <-time.After(timeout):
+			return WriteBlockedError
+		}
+	}
+}
+
+func (c *Conn) Do() {
+	c.deliverData.waitGroup.Add(3)
+	go c.handleLoop()
+	go c.readLoop()
+	go c.writeLoop()
+}
+
+func (c *Conn) readLoop() {
+	defer func() {
+		if e := recover(); e != nil {
+			log.Printf("readLoop panic: %v\r\n", e)
+		}
+		c.Close()
+		c.deliverData.waitGroup.Done()
+	}()
+
+	for {
+		select {
+		case <-c.deliverData.exitChan:
+			return
+
+		case <-c.closeChan:
+			return
+
+		default:
+		}
+
+		c.conn.SetReadDeadline(time.Now().Add(c.config.ReadTimeout))
+
+		recPacket, err := c.ReadPacket()
+		if err != nil {
+			c.delegate.OnIOError(c, err)
+			return
+		}
+
+		c.receivePacketChan <- recPacket
+	}
+}
+
+func (c *Conn) writeLoop() {
+	defer func() {
+		if e := recover(); e != nil {
+			log.Printf("writeLoop panic: %v\r\n", e)
+		}
+		c.Close()
+		c.deliverData.waitGroup.Done()
+	}()
+
+	for {
+		select {
+		case <-c.deliverData.exitChan:
+			return
+
+		case <-c.closeChan:
+			return
+
+		case p := <-c.sendPacketChan:
+			err := c.WritePacket(p)
+			if err != nil {
+				c.delegate.OnIOError(c, err)
+				return
+			}
+		}
+	}
+}
+
+func (c *Conn) handleLoop() {
+	defer func() {
+		if e := recover(); e != nil {
+			log.Printf("handleLoop panic: %v\r\n", e)
+		}
+		c.Close()
+		c.deliverData.waitGroup.Done()
+	}()
+
+	if !c.delegate.OnConnect(c) {
+		return
+	}
+
+	rawConn, err := c.(*net.TCPConn).SyscallConn()
+	if err != nil {
+		fmt.Println("Error getting raw connection:", err.Error())
+		continue
+	}
+
+	rawConn.Control(func(fd uintptr) {
+		err := syscall.SetsockoptInt(syscall.Handle(fd), syscall.SOL_SOCKET, syscall.SO_RCVBUF, 1024)
+		if err != nil {
+			fmt.Println("Error setting receive buffer size:", err.Error())
+			return
+		}
+
+		var val int
+		val, err = syscall.GetsockoptInt(syscall.Handle(fd), syscall.SOL_SOCKET, syscall.SO_RCVBUF)
+		if err != nil {
+			fmt.Println("Error getting receive buffer size:", err.Error())
+			return
+		}
+
+		fmt.Printf("Receive buffer size: %d\n", val)
+	})
+	for {
+		select {
+		case <-c.deliverData.exitChan:
+			return
+
+		case <-c.closeChan:
+			return
+
+		case p := <-c.receivePacketChan:
+			if !c.delegate.OnMessage(c, p) {
+				return
+			}
+		}
+	}
+}

src/zks.com/gotcp/dial_test.go

@@ -0,0 +1,122 @@
+package gotcp
+
+import (
+	"fmt"
+	"net"
+	"testing"
+	"time"
+)
+
+// Server delegate
+type ServerDelegate struct {
+	t *testing.T
+}
+
+func (this *ServerDelegate) OnConnect(c *Conn) bool {
+	fmt.Println("Server OnConnect")
+	return true
+}
+
+func (this *ServerDelegate) OnMessage(c *Conn, p *Packet) bool {
+	fmt.Println("Server OnMessage")
+
+	if p.GetType() == 777 {
+		if string(p.GetData()) != "BYE" {
+			this.t.Fatal()
+		}
+		return false
+	}
+
+	if p.GetType() != 999 || string(p.GetData()) != "hello" {
+		this.t.Fatal()
+	}
+
+	c.WritePacket(NewPacket(888, []byte("world")))
+
+	return true
+}
+
+func (this *ServerDelegate) OnClose(c *Conn) {
+	fmt.Println("Server OnClose")
+}
+
+func (this *ServerDelegate) OnIOError(c *Conn, err error) {
+	fmt.Println("Server OnIOError")
+}
+
+// Client delegate
+type ClientDelegate struct {
+	t *testing.T
+}
+
+func (this *ClientDelegate) OnConnect(c *Conn) bool {
+	fmt.Println("Client OnConnect")
+	return true
+}
+
+func (this *ClientDelegate) OnMessage(c *Conn, p *Packet) bool {
+	fmt.Println("Client OnMessage")
+
+	if p.GetType() != 888 || string(p.GetData()) != "world" {
+		this.t.Fatal()
+	}
+
+	c.AsyncWritePacket(NewPacket(777, []byte("BYE")), time.Second)
+
+	return true
+}
+
+func (this *ClientDelegate) OnClose(c *Conn) {
+	fmt.Println("Client OnClose")
+}
+
+func (this *ClientDelegate) OnIOError(c *Conn, err error) {
+	fmt.Println("Client OnIOError")
+}
+
+func TestDial(t *testing.T) {
+	tcpAddr, _ := net.ResolveTCPAddr("tcp4", "127.0.0.1:8990")
+	listener, _ := net.ListenTCP("tcp", tcpAddr)
+
+	config := &Config{
+		AcceptTimeout:          5 * time.Second,
+		ReadTimeout:            5 * time.Second,
+		WriteTimeout:           5 * time.Second,
+		MaxPacketLength:        int32(2048),
+		SendPacketChanLimit:    int32(10),
+		ReceivePacketChanLimit: int32(10),
+	}
+	delegate := &ServerDelegate{t: t}
+
+	svr := NewServer(config, delegate)
+	go svr.Start(listener)
+
+	time.Sleep(time.Second)
+
+	simulateClientDial(t, svr)
+
+	svr.Stop()
+}
+
+func simulateClientDial(t *testing.T, svr *Server) {
+	config := &Config{
+		AcceptTimeout:          5 * time.Second,
+		ReadTimeout:            5 * time.Second,
+		WriteTimeout:           5 * time.Second,
+		MaxPacketLength:        int32(2048),
+		SendPacketChanLimit:    int32(10),
+		ReceivePacketChanLimit: int32(10),
+	}
+	delegate := &ClientDelegate{t: t}
+
+	conn, err := svr.Dial("tcp4", "127.0.0.1:8990", config, delegate)
+	if err != nil {
+		t.Fatal()
+	}
+
+	go conn.Do()
+	time.Sleep(time.Second)
+
+	conn.WritePacket(NewPacket(999, []byte("hello")))
+	time.Sleep(time.Second)
+}

src/zks.com/gotcp/example/client/client.go

@@ -0,0 +1,108 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"log"
+	"net"
+	"time"
+
+	"zks.com/gotcp/example"
+)
+
+const (
+	TYPE_LOGIN = iota + 1
+	TYPE_LOGOUT
+	TYPE_MSG
+
+	TYPE_REPLY_LOGIN
+	TYPE_REPLY_LOGOUT
+	TYPE_REPLY_MSG
+)
+
+func main() {
+	for j := 0; j < 100000; j++ {
+
+		go func(j int) {
+			conn, err := connect()
+			if err != nil {
+				log.Fatal(err)
+			}
+			defer conn.Close()
+
+			fmt.Println("connect  ====== ", j)
+
+			if err = sendLogin(conn); err != nil {
+				log.Fatal(err)
+			}
+
+			for i := 0; i < 200; i++ {
+				time.Sleep(6 * time.Second)
+				if err = sendMsg(conn); err != nil {
+					log.Fatal(err)
+				}
+			}
+
+			if err = sendLogout(conn); err != nil {
+				log.Fatal(err)
+			}
+
+			fmt.Println("disconnect  ****** ", j)
+
+		}(j)
+
+		time.Sleep(20 * time.Millisecond)
+	}
+
+	time.Sleep(time.Hour)
+}
+
+func connect() (*net.TCPConn, error) {
+	tcpAddr, _ := net.ResolveTCPAddr("tcp4", "127.0.0.1:8989")
+	return net.DialTCP("tcp", nil, tcpAddr)
+}
+
+func sendLogin(conn *net.TCPConn) error {
+	conn.Write(example.NewPacket(TYPE_LOGIN, []byte("LOGIN")).Serialize())
+	ltvProtocol := new(example.LtvProtocol)
+	p, err := ltvProtocol.ReadPacket(conn, 2048)
+	if err != nil {
+		return err
+	}
+
+	if p.GetTypeInt() != TYPE_REPLY_LOGIN || string(p.GetData()) != "LOGIN OK" {
+		return errors.New("LOGIN FAILED")
+	}
+
+	return nil
+}
+
+func sendLogout(conn *net.TCPConn) error {
+	conn.Write(example.NewPacket(TYPE_LOGOUT, []byte("BYE BYE")).Serialize())
+	ltvProtocol := new(example.LtvProtocol)
+	p, err := ltvProtocol.ReadPacket(conn, 2048)
+	if err != nil {
+		return err
+	}
+
+	if p.GetTypeInt() != TYPE_REPLY_LOGOUT || string(p.GetData()) != "LOGOUT OK" {
+		return errors.New("LOGOUT FAILED")
+	}
+
+	return nil
+}
+
+func sendMsg(conn *net.TCPConn) error {
+	conn.Write(example.NewPacket(TYPE_MSG, []byte("hello world")).Serialize())
+	ltvProtocol := new(example.LtvProtocol)
+	p, err := ltvProtocol.ReadPacket(conn, 2048)
+	if err != nil {
+		return err
+	}
+
+	if p.GetTypeInt() != TYPE_REPLY_MSG || string(p.GetData()) != "REPLY_hello world" {
+		return errors.New("MSG FAILED")
+	}
+
+	return nil
+}

src/zks.com/gotcp/example/ltvProtocol.go

@@ -0,0 +1,60 @@
+package example
+
+import (
+	"io"
+
+	"zks.com/gotcp"
+)
+
+// Packet: pacLen + pacType + pacData
+// Big endian: int32 + int32 + []byte
+type LtvPacketDelegate struct {
+	pacLen  uint32
+	pacType uint32
+	pacData []byte
+}
+
+func (p *LtvPacketDelegate) Serialize() []byte {
+	buf := make([]byte, 8+len(p.pacData))
+	copy(buf[0:4], gotcp.Uint32ToBytes(p.pacLen))
+	copy(buf[4:8], gotcp.Uint32ToBytes(p.pacType))
+	copy(buf[8:], p.pacData)
+	return buf
+}
+
+func (p *LtvPacketDelegate) GetLen() uint32 {
+	return p.pacLen
+}
+
+func (p *LtvPacketDelegate) GetTypeInt() uint32 {
+	return p.pacType
+}
+
+func (p *LtvPacketDelegate) GetTypeString() string {
+	return ""
+}
+
+func (p *LtvPacketDelegate) GetData() []byte {
+	return p.pacData
+}
+
+func NewPacket(pacType uint32, pacData []byte) *gotcp.Packet {
+	packet := new(gotcp.Packet)
+	packet.Delegate = &LtvPacketDelegate{
+		pacLen:  uint32(8) + uint32(len(pacData)),
+		pacType: pacType,
+		pacData: pacData,
+	}
+	return packet
+}
+
+type LtvProtocol struct {
+}
+
+func (this *LtvProtocol) ReadPacket(r io.Reader, MaxPacketLength uint32) (*gotcp.Packet, error) {
+
+	data := make([]byte, MaxPacketLength) // 设定缓存空间
+	readLengh, _ := r.Read(data)
+
+	return NewPacket(1, data[:readLengh]), nil
+}

src/zks.com/gotcp/example/server/server.go

@@ -0,0 +1,122 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net"
+	"os"
+	"os/signal"
+	"runtime"
+	"syscall"
+	"time"
+
+	"zks.com/gotcp"
+	"zks.com/gotcp/example"
+)
+
+const (
+	TYPE_LOGIN = iota + 1
+	TYPE_LOGOUT
+	TYPE_MSG
+
+	TYPE_REPLY_LOGIN
+	TYPE_REPLY_LOGOUT
+	TYPE_REPLY_MSG
+)
+
+type ConnDelegate struct {
+	connectCount int
+	closeCount   int
+	messageCount int
+}
+
+func (this *ConnDelegate) OnConnect(c *gotcp.Conn) bool {
+	p, err := c.AsyncReadPacket(5 * time.Second)
+	if err != nil {
+		fmt.Printf("OnConnect[Error]:[%v]\n", err)
+		return false
+	}
+
+	if p.GetTypeInt() == TYPE_LOGIN && string(p.GetData()) == "LOGIN" {
+		c.WritePacket(example.NewPacket(TYPE_REPLY_LOGIN, []byte("LOGIN OK")))
+
+		this.connectCount++
+		c.PutExtraData(this.connectCount)
+
+		fmt.Printf("OnConnect[LOGIN][***%v***]\n", c.GetExtraData().(int))
+		return true
+	}
+
+	return false
+}
+
+func (this *ConnDelegate) OnMessage(c *gotcp.Conn, p *gotcp.Packet) bool {
+	if p.GetTypeInt() == TYPE_LOGOUT {
+		c.WritePacket(example.NewPacket(TYPE_REPLY_LOGOUT, []byte("LOGOUT OK")))
+		fmt.Printf("OnMessage[LOGOUT][***%v***]:[%v]\n", c.GetExtraData().(int), string(p.GetData()))
+		return false
+	}
+
+	if p.GetTypeInt() == TYPE_MSG {
+		c.AsyncWritePacket(example.NewPacket(TYPE_REPLY_MSG, []byte("REPLY_"+string(p.GetData()))), 5*time.Second)
+
+		this.messageCount++
+
+		fmt.Printf("OnMessage[MSG][***%v***]:[%v]\n", c.GetExtraData().(int), string(p.GetData()))
+		return true
+	}
+
+	return true
+}
+
+func (this *ConnDelegate) OnClose(c *gotcp.Conn) {
+	this.closeCount++
+	fmt.Printf("OnClose[***%v***]\n", c.GetExtraData().(int))
+}
+
+func (this *ConnDelegate) OnIOError(c *gotcp.Conn, err error) {
+	fmt.Printf("OnIOError[***%v***]:[%v]\n", c.GetExtraData().(int), err)
+}
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	tcpAddr, err := net.ResolveTCPAddr("tcp4", "127.0.0.1:8989")
+	checkError(err)
+
+	listener, err := net.ListenTCP("tcp", tcpAddr)
+	checkError(err)
+
+	config := &gotcp.Config{
+		AcceptTimeout:          10 * time.Second,
+		ReadTimeout:            120 * time.Second,
+		WriteTimeout:           120 * time.Second,
+		MaxPacketLength:        2048,
+		SendPacketChanLimit:    10,
+		ReceivePacketChanLimit: 10,
+	}
+	delegate := &ConnDelegate{}
+	protocol := &example.LtvProtocol{}
+	svr := gotcp.NewServer(config, delegate, protocol)
+	go svr.Start(listener)
+
+	go func() {
+		for {
+			fmt.Println("===========goroutine==========", runtime.NumGoroutine())
+			fmt.Println(delegate.connectCount, delegate.closeCount, delegate.messageCount)
+			time.Sleep(2 * time.Second)
+		}
+	}()
+
+	ch := make(chan os.Signal)
+	signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
+	log.Printf("Signal: %v\r\n", <-ch)
+
+	svr.Stop()
+}
+
+func checkError(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
+}

src/zks.com/gotcp/protocol.go

@@ -0,0 +1,42 @@
+package gotcp
+
+import (
+	"io"
+)
+
+type PacketDelegate interface {
+	Serialize() []byte
+	GetLen() uint32
+	GetData() []byte
+	GetTypeInt() uint32
+	GetTypeString() string
+}
+
+type Packet struct {
+	length   int32
+	Delegate PacketDelegate
+}
+
+func (p *Packet) Serialize() []byte {
+	return p.Delegate.Serialize()
+}
+
+func (p *Packet) GetLen() uint32 {
+	return p.Delegate.GetLen()
+}
+
+func (p *Packet) GetData() []byte {
+	return p.Delegate.GetData()
+}
+
+func (p *Packet) GetTypeInt() uint32 {
+	return p.Delegate.GetTypeInt()
+}
+
+func (p *Packet) GetTypeString() string {
+	return p.Delegate.GetTypeString()
+}
+
+type Protocol interface {
+	ReadPacket(r io.Reader, MaxPacketLength uint32) (*Packet, error)
+}

src/zks.com/gotcp/server.go

@@ -0,0 +1,84 @@
+package gotcp
+
+import (
+	"log"
+	"net"
+	"sync"
+	"time"
+)
+
+// Server struct
+type Server struct {
+	config      *Config          // configure infomation
+	delegate    ConnDelegate     // conn delegate(message callbacks)
+	protocol    Protocol         // data protocol
+	deliverData *deliverConnData // deliver to conn
+}
+
+// Server delivery deliverConnData to the connection to control
+type deliverConnData struct {
+	exitChan  chan struct{}   // server notify all goroutines to shutdown
+	waitGroup *sync.WaitGroup // wait for all goroutines
+}
+
+func NewServer(config *Config, delegate ConnDelegate, protocol Protocol) *Server {
+	return &Server{
+		config:   config,
+		delegate: delegate,
+		protocol: protocol,
+		deliverData: &deliverConnData{
+			exitChan:  make(chan struct{}),
+			waitGroup: &sync.WaitGroup{},
+		},
+	}
+}
+
+// Start server
+func (s *Server) Start(listener *net.TCPListener) {
+	log.Printf("Start listen on %v\r\n", listener.Addr())
+	s.deliverData.waitGroup.Add(1)
+	defer func() {
+		log.Printf("Stop listen on %v\r\n", listener.Addr())
+		listener.Close()
+		s.deliverData.waitGroup.Done()
+	}()
+
+	for {
+		select {
+		case <-s.deliverData.exitChan:
+			return
+
+		default:
+		}
+
+		listener.SetDeadline(time.Now().Add(s.config.AcceptTimeout))
+
+		conn, err := listener.AcceptTCP()
+		if err != nil {
+			continue
+		}
+
+		go newConn(conn, s.config, s.delegate, s.protocol, s.deliverData).Do()
+	}
+}
+
+// Stop server
+func (s *Server) Stop() {
+	close(s.deliverData.exitChan)
+	s.deliverData.waitGroup.Wait()
+}
+
+// Server dial to the other server
+func (s *Server) Dial(network, address string, config *Config, delegate ConnDelegate, protocol Protocol) (*Conn, error) {
+	tcpAddr, err := net.ResolveTCPAddr(network, address)
+	if err != nil {
+		return nil, err
+	}
+
+	conn, err := net.DialTCP("tcp", nil, tcpAddr)
+	if err != nil {
+		return nil, err
+	}
+
+	return newConn(conn, config, delegate, protocol, s.deliverData), nil
+}

src/zks.com/gotcp/server_test.go

@@ -0,0 +1,135 @@
+package gotcp
+
+import (
+	"fmt"
+	"net"
+	"testing"
+	"time"
+)
+
+// test tips
+/******************************************************/
+
+var OnConnectTip, OnMessageTip, OnCloseTip, OnIOErrorTip string
+
+/******************************************************/
+
+// delegate
+/******************************************************/
+type Delegate struct{}
+
+func (this *Delegate) OnConnect(c *Conn) bool {
+	p, err := c.AsyncReadPacket(5 * time.Second)
+	if err != nil {
+		return false
+	}
+
+	OnConnectTip = fmt.Sprintf("OnConnect[%v,%v,%v]", p.GetLen(), p.GetType(), string(p.GetData()))
+
+	fmt.Println(OnConnectTip)
+	return true
+}
+
+func (this *Delegate) OnMessage(c *Conn, p *Packet) bool {
+	OnMessageTip = fmt.Sprintf("OnMessage[%v,%v,%v]", p.GetLen(), p.GetType(), string(p.GetData()))
+	fmt.Println(OnMessageTip)
+
+	if string(p.GetData()) == "logout" {
+		c.WritePacket(NewPacket(888, []byte("ok")))
+		return false
+	}
+
+	c.AsyncWritePacket(NewPacket(999, []byte(string(p.GetData())+",ok")), 5*time.Second)
+
+	return true
+}
+
+func (this *Delegate) OnClose(c *Conn) {
+	OnCloseTip = fmt.Sprintf("OnClose[%v]", c.IsClosed())
+	fmt.Println(OnCloseTip)
+}
+
+func (this *Delegate) OnIOError(c *Conn, err error) {
+	if err != nil {
+		OnIOErrorTip = fmt.Sprintf("OnIOError[%v]", err)
+	}
+	fmt.Println(OnIOErrorTip)
+}
+
+/******************************************************/
+
+func simulateClient(t *testing.T) {
+	tcpAddr, _ := net.ResolveTCPAddr("tcp4", "127.0.0.1:8989")
+	conn, _ := net.DialTCP("tcp", nil, tcpAddr)
+
+	// OnConnect
+	conn.Write(NewPacket(777, []byte("login")).Serialize())
+	time.Sleep(100 * time.Millisecond)
+	if OnConnectTip != "OnConnect[13,777,login]" {
+		t.Fatal()
+	}
+
+	// OnMessage
+	conn.Write(NewPacket(666, []byte("helloworld")).Serialize())
+	time.Sleep(100 * time.Millisecond)
+	if OnMessageTip != "OnMessage[18,666,helloworld]" {
+		t.Fatal()
+	}
+
+	retPacket, _ := ReadPacket(conn, 2048)
+	if retPacket.GetLen() != 21 || retPacket.GetType() != 999 || string(retPacket.GetData()) != "helloworld,ok" {
+		t.Fatal()
+	}
+
+	// OnClose
+	conn.Write(NewPacket(555, []byte("logout")).Serialize())
+	time.Sleep(100 * time.Millisecond)
+	if OnMessageTip != "OnMessage[14,555,logout]" {
+		t.Fatal()
+	}
+
+	retPacket, _ = ReadPacket(conn, 2048)
+	if retPacket.GetLen() != 10 || retPacket.GetType() != 888 || string(retPacket.GetData()) != "ok" {
+		t.Fatal()
+	}
+
+	if OnCloseTip != "OnClose[true]" {
+		t.Fatal()
+	}
+
+	// OnIOError
+	if OnIOErrorTip != fmt.Sprintf("OnIOError[%v]", ReadPacketError) {
+		t.Fatal()
+	}
+}
+
+func TestServer(t *testing.T) {
+	tcpAddr, err := net.ResolveTCPAddr("tcp4", "127.0.0.1:8989")
+	if err != nil {
+		t.Fatal()
+	}
+
+	listener, err := net.ListenTCP("tcp", tcpAddr)
+	if err != nil {
+		t.Fatal()
+	}
+
+	config := &Config{
+		AcceptTimeout:          5 * time.Second,
+		ReadTimeout:            5 * time.Second,
+		WriteTimeout:           5 * time.Second,
+		MaxPacketLength:        2048,
+		SendPacketChanLimit:    10,
+		ReceivePacketChanLimit: 10,
+	}
+	delegate := &Delegate{}
+
+	svr := NewServer(config, delegate)
+	go svr.Start(listener)
+
+	time.Sleep(time.Second)
+
+	simulateClient(t)
+
+	svr.Stop()
+}

src/zks.com/gotcp/startTag/starttagProtocol.go

@@ -0,0 +1,85 @@
+package example
+
+import (
+	"io"
+
+	"zks.com/gotcp"
+)
+
+var (
+	fullBuf *bytes.Buffer = bytes.NewBuffer([]byte{}) //缓存区
+	SOH     []byte        = []byte{0xBE, 0xBE}        //开始标记 start of head
+)
+
+// Packet: SOH + Data
+type StartTagPacketDelegate struct {
+	pacLen  int32
+	pacType int32
+	pacData []byte
+}
+
+func (p *StartTagPacketDelegate) Serialize() []byte {
+	buf := make([]byte, 8+len(p.pacData))
+	copy(buf[0:4], gotcp.Int32ToBytes(p.pacLen))
+	copy(buf[4:8], gotcp.Int32ToBytes(p.pacType))
+	copy(buf[8:], p.pacData)
+	return buf
+}
+
+func (p *StartTagPacketDelegate) GetLen() int32 {
+	return p.pacLen
+}
+
+func (p *StartTagPacketDelegate) GetTypeInt() int32 {
+	return p.pacType
+}
+
+func (p *StartTagPacketDelegate) GetTypeString() string {
+	return ""
+}
+
+func (p *StartTagPacketDelegate) GetData() []byte {
+	return p.pacData
+}
+
+func NewPacket(pacType int32, pacData []byte) *gotcp.Packet {
+	packet := new(gotcp.Packet)
+	packet.Delegate = &LtvPacketDelegate{
+		pacLen:  int32(8) + int32(len(pacData)),
+		pacType: pacType,
+		pacData: pacData,
+	}
+	return packet
+}
+
+type StartTagProtocol struct {
+}
+
+func (this *StartTagProtocol) ReadPacket(r io.Reader, MaxPacketLength int32) (*gotcp.Packet, error) {
+	var (
+		pacBLen  []byte = make([]byte, 4)
+		pacBType []byte = make([]byte, 4)
+		pacLen   int32
+	)
+
+	// read pacLen
+	if n, err := io.ReadFull(r, pacBLen); err != nil && n != 4 {
+		return nil, gotcp.ReadPacketError
+	}
+	if pacLen = gotcp.BytesToInt32(pacBLen); pacLen > MaxPacketLength {
+		return nil, gotcp.PacketTooLargeError
+	}
+
+	// read pacType
+	if n, err := io.ReadFull(r, pacBType); err != nil && n != 4 {
+		return nil, gotcp.ReadPacketError
+	}
+
+	// read pacData
+	pacData := make([]byte, pacLen-8)
+	if n, err := io.ReadFull(r, pacData); err != nil && n != int(pacLen) {
+		return nil, gotcp.ReadPacketError
+	}
+
+	return NewPacket(gotcp.BytesToInt32(pacBType), pacData), nil
+}

src/zks.com/gotcp/util.go

@@ -0,0 +1,27 @@
+package gotcp
+
+import (
+	"encoding/binary"
+	"errors"
+)
+
+// Error types
+var (
+	ConnClosedError     = errors.New("connection was closed")
+	WriteBlockedError   = errors.New("write blocking")
+	ReadBlockedError    = errors.New("read blocking")
+	ReadPacketError     = errors.New("read packet error")
+	PacketTooLargeError = errors.New("packet too large")
+)
+
+// BigEndian: uint32 --> []byte
+func Uint32ToBytes(v uint32) []byte {
+	b := make([]byte, 4)
+	binary.BigEndian.PutUint32(b, v)
+	return b
+}
+
+// BigEndian: []byte --> uint32
+func BytesToUint32(b []byte) uint32 {
+	return binary.BigEndian.Uint32(b)
+}

src/zks.com/newbbfrontsocketv2/blackbox/bboxProtocol.go

@@ -0,0 +1,316 @@
+package blackbox
+
+import (
+	"fmt"
+	"io"
+
+	"bytes"
+	"sync"
+	"time"
+
+	"zks.com/gotcp"
+	utils "zks.com/socketutils"
+	coldcloud "zks.com/zcoldcloud"
+)
+
+//var SockeData = struct {
+//	sync.RWMutex
+//	m map[string][]byte
+//}{m: make(map[string][]byte)}
+
+type SockeBody struct {
+	Time int64
+	Body []byte
+}
+
+var SockeData = struct {
+	sync.RWMutex
+	m map[string]SockeBody
+}{m: make(map[string]SockeBody)}
+
+// Packet
+type BBoxPacketDelegate struct {
+	pLen  uint32
+	pType uint32
+	pData []byte
+}
+type blackboxddata struct {
+	Code      string
+	Datapoint coldcloud.DatapointColdCloud
+}
+
+func (p *BBoxPacketDelegate) Serialize() []byte {
+	return p.pData
+}
+
+func (p *BBoxPacketDelegate) GetLen() uint32 {
+	return p.pLen
+}
+
+func (p *BBoxPacketDelegate) GetTypeInt() uint32 {
+	return p.pType
+}
+
+func (p *BBoxPacketDelegate) GetTypeString() string {
+	return ""
+}
+
+func (p *BBoxPacketDelegate) GetData() []byte {
+	return p.pData
+}
+
+func NewPacket(pType uint32, pData []byte) *gotcp.Packet {
+	packet := new(gotcp.Packet)
+	packet.Delegate = &BBoxPacketDelegate{
+		pLen:  uint32(len(pData)),
+		pType: pType,
+		pData: pData,
+	}
+	return packet
+}
+
+type BBoxProtocol struct {
+}
+
+//通用
+func (this *BBoxProtocol) ReadPacket(r io.Reader, MaxPacketLength uint32) (*gotcp.Packet, error) {
+	data := make([]byte, MaxPacketLength) // 设定缓存空间
+	readLengh, err := r.Read(data)
+	//utils.InformationalWithFormat("request: % X", data[:readLengh])
+	if err != nil { //EOF, or worse
+		fmt.Println(1, err)
+		return nil, err
+	}
+	if readLengh == 0 { // 连接可能已被客户端关闭
+		fmt.Println("数据长度读取为零")
+		return nil, gotcp.ReadPacketError
+		//return nil, err
+	} else {
+		//fmt.Println("next execuse NewPacket")
+		return NewPacket(1, data[:readLengh]), nil
+	}
+
+}
+func (this *BBoxProtocol) ReadPacket_OK(r io.Reader, MaxPacketLength uint32) (*gotcp.Packet, error) {
+	var fullBuf *bytes.Buffer = bytes.NewBuffer([]byte{}) //缓存区
+	for {
+		data := make([]byte, MaxPacketLength) // 设定缓存空间
+		readLengh, err := r.Read(data)
+		if err != nil { //EOF, or worse
+			return nil, err
+		}
+		if readLengh == 0 { // 连接可能已被客户端关闭
+			return nil, gotcp.ReadPacketError
+		} else {
+			//记录日志
+			utils.InformationalWithFormat("% X", data[:readLengh])
+			if (data[0] == 0x7E && data[readLengh-1] == 0x7E) || (data[0] == 0x8E && data[readLengh-1] == 0x8E) {
+				if len(fullBuf.Bytes()) > 0 {
+					fmt.Println("错误日志>黏包", fmt.Sprintf("% X", fullBuf.Bytes()))
+				}
+				return NewPacket(1, data[:readLengh]), nil
+			} else {
+				fullBuf.Write(data[:readLengh]) //写入数据到缓冲区
+				if (fullBuf.Bytes()[0] == 0x7E && fullBuf.Bytes()[len(fullBuf.Bytes())-1] == 0x7E) || (fullBuf.Bytes()[0] == 0x8E && fullBuf.Bytes()[len(fullBuf.Bytes())-1] == 0x8E) {
+					return NewPacket(1, fullBuf.Bytes()), nil
+				} else if fullBuf.Bytes()[0] == 0x7E {
+					continue
+				}
+			}
+		}
+	}
+}
+
+type BBoxConnDelegate struct {
+	connectCount int
+	closeCount   int
+	messageCount int
+}
+
+func (this *BBoxConnDelegate) OnConnect(c *gotcp.Conn) bool {
+
+	this.connectCount++
+	Conns.Lock()
+	fmt.Println("连接数：", len(Conns.m))
+	Conns.Unlock()
+	c.PutExtraData(this.connectCount)
+
+	return true
+}
+
+// 正式使用
+func (this *BBoxConnDelegate) OnMessage_OK(c *gotcp.Conn, p *gotcp.Packet) bool {
+	fmt.Println("连接数：", c.GetRawConn().RemoteAddr())
+	bs := p.GetData()
+	utils.InformationalWithFormat("OnMessage:% X", bs)
+	if len(bs) >= 2 {
+		if bs[0] == 0x8E {
+			go DoWork(c, bs)
+		} else {
+			data := []byte{}
+			for i := 0; i < len(bs); i++ {
+				data = append(data, bs[i])
+				if i != 0 && bs[i] == 0x7E && len(data) > 2 {
+					go DoWork(c, data)
+					data = []byte{}
+				}
+			}
+		}
+	}
+	return true
+}
+
+//记录socket通道存断开数据
+func (this *BBoxConnDelegate) OnMessage(c *gotcp.Conn, p *gotcp.Packet) bool {
+	bs := p.GetData()
+	utils.InformationalWithFormat("OnMessage:% X", bs)
+	if len(bs) >= 2 {
+		data := []byte{}
+		//正常数据有7E开头结束
+		if bs[0] == 0x7E && bs[len(bs)-1] == 0x7E {
+			SockeData.Lock()
+			if len(SockeData.m[utils.ToStr(c.GetRawConn().RemoteAddr())].Body) > 0 { //map中有待发数据
+				oldbs := SockeData.m[utils.ToStr(c.GetRawConn().RemoteAddr())].Body
+				var newbs []byte
+				rightdata := false
+				for i := 0; i < len(oldbs); i++ {
+					if len(newbs) == 0 && oldbs[i] == 0x7E && len(oldbs)-1 > i && oldbs[i+1] != 0x7E {
+						rightdata = true
+					}
+					if rightdata == true {
+						newbs = append(newbs, oldbs[i])
+					}
+					if len(newbs) > 5 && oldbs[i] == 0x7E { //获取黏包中有效数据
+						rightdata = false
+						go DoWork(c, newbs)
+						newbs = []byte{}
+					}
+				}
+				fmt.Println(c.GetRawConn().RemoteAddr(), "错误日志>黏包", fmt.Sprintf("% X", SockeData.m[utils.ToStr(c.GetRawConn().RemoteAddr())].Body))
+				Writedata_v2(fmt.Sprintf("% X", SockeData.m[utils.ToStr(c.GetRawConn().RemoteAddr())].Body))
+			}
+			delete(SockeData.m, utils.ToStr(c.GetRawConn().RemoteAddr()))
+			SockeData.Unlock()
+			for i := 0; i < len(bs); i++ {
+				data = append(data, bs[i])
+				if i != 0 && bs[i] == 0x7E && len(data) > 2 {
+					go DoWork(c, data)
+					data = []byte{}
+				}
+			}
+		} else if bs[0] == 0x8E && bs[len(bs)-1] == 0x8E { //平台下发命令
+			go DoWork(c, bs)
+		} else { //异常数据
+			SockeData.Lock()
+			bodylen := len(SockeData.m[utils.ToStr(c.GetRawConn().RemoteAddr())].Body)
+			if bodylen > 0 && SockeData.m[utils.ToStr(c.GetRawConn().RemoteAddr())].Body[0] == 0x7E && bs[len(bs)-1] == 0x7E { //断包处理，map中有7E开头，新来数据有7E结尾
+				okbody := append(SockeData.m[utils.ToStr(c.GetRawConn().RemoteAddr())].Body, bs...)
+				delete(SockeData.m, utils.ToStr(c.GetRawConn().RemoteAddr()))
+				SockeData.Unlock()
+				for i := 0; i < len(okbody); i++ {
+					data = append(data, okbody[i])
+					if i != 0 && okbody[i] == 0x7E && len(data) > 2 {
+						go DoWork(c, data)
+						data = []byte{}
+					}
+				}
+			} else if bodylen == 0 && bs[0] != 0x7E { //map中没有信息，新来数据没有7E开头（处理脏数据）
+				var newbs []byte
+				rightdata := false
+				for i := 0; i < len(bs); i++ {
+					if len(newbs) == 0 && bs[i] == 0x7E && len(bs)-1 > i && bs[i+1] != 0x7E {
+						rightdata = true
+					}
+					if rightdata == true {
+						newbs = append(newbs, bs[i])
+					}
+
+					if len(newbs) > 5 && bs[i] == 0x7E { //捕获带有脏数据有7E开头结尾的数据
+						rightdata = false
+						go DoWork(c, newbs)
+						newbs = []byte{}
+					}
+				}
+				//处理带有脏数据的有7E开头没有7E结尾的数据，去掉开头脏数据保留有效数据存入map
+				if len(newbs) > 5 {
+					SockeData.m[utils.ToStr(c.GetRawConn().RemoteAddr())] = SockeBody{Time: time.Now().Unix(), Body: newbs}
+					fmt.Println(c.GetRawConn().RemoteAddr(), "错误日志>无7E开头(黏指令)", fmt.Sprintf("% X", bs))
+				} else {
+					fmt.Println(c.GetRawConn().RemoteAddr(), "错误日志>无7E开头", fmt.Sprintf("% X", bs))
+				}
+				SockeData.Unlock()
+				Writedata_v2(fmt.Sprintf("% X", bs))
+			} else { //断包处理后半段数据，（map中有信息，新来数据没有7E开头）？
+				SockeData.m[utils.ToStr(c.GetRawConn().RemoteAddr())] = SockeBody{Time: time.Now().Unix(), Body: append(SockeData.m[utils.ToStr(c.GetRawConn().RemoteAddr())].Body, bs...)}
+				SockeData.Unlock()
+			}
+		}
+	}
+	return true
+}
+func (this *BBoxConnDelegate) OnMessage1(c *gotcp.Conn, p *gotcp.Packet) bool {
+	fmt.Println("连接数：", c.GetRawConn().RemoteAddr())
+	bs := p.GetData()
+	utils.InformationalWithFormat("OnMessage:% X", bs)
+	if len(bs) >= 2 {
+		if bs[0] == 0x8E {
+			go DoWork(c, bs)
+		} else {
+			data := []byte{}
+			for i := 0; i < len(bs); i++ {
+				data = append(data, bs[i])
+				if i != 0 && bs[i] == 0x7E && len(data) > 2 {
+					go DoWork(c, data)
+					data = []byte{}
+				}
+			}
+		}
+	}
+	return true
+}
+func (this *BBoxConnDelegate) OnClose(c *gotcp.Conn) {
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Println("OnClose Recovered in f", r)
+		}
+	}()
+	this.closeCount++
+	Conns.Lock()
+	for k, v := range Conns.m {
+		if v == c {
+			fmt.Println(k + "已断开")
+			delete(Conns.m, k)
+			fmt.Println("剩余连接数：", len(Conns.m))
+		}
+	}
+	Conns.Unlock()
+	SockeData.Lock()
+	if len(SockeData.m[utils.ToStr(c.GetRawConn().RemoteAddr())].Body) > 0 {
+		oldbs := SockeData.m[utils.ToStr(c.GetRawConn().RemoteAddr())].Body
+		var newbs []byte
+		rightdata := false
+		for i := 0; i < len(oldbs); i++ {
+			if len(newbs) == 0 && oldbs[i] == 0x7E && len(oldbs)-1 > i && oldbs[i+1] != 0x7E {
+				rightdata = true
+			}
+			if rightdata == true {
+				newbs = append(newbs, oldbs[i])
+			}
+			if len(newbs) > 5 && oldbs[i] == 0x7E {
+				rightdata = false
+				go DoWork(c, newbs)
+				newbs = []byte{}
+			}
+		}
+		fmt.Println("错误日志>连接断开数据包丢失", fmt.Sprintf("% X", SockeData.m[utils.ToStr(c.GetRawConn().RemoteAddr())].Body))
+		Writedata_v2(fmt.Sprintf("% X", SockeData.m[utils.ToStr(c.GetRawConn().RemoteAddr())].Body))
+	}
+	delete(SockeData.m, utils.ToStr(c.GetRawConn().RemoteAddr()))
+	fmt.Println("统计黏包socket", len(SockeData.m))
+	SockeData.Unlock()
+	fmt.Printf("OnClose[%s][***%v***]\n")
+}
+
+func (this *BBoxConnDelegate) OnIOError(c *gotcp.Conn, err error) {
+	fmt.Printf("OnIOError[%s][***%v***]:[%v]\n", c.GetRawConn().RemoteAddr(), c.GetExtraData().(int), err)
+}

src/zks.com/newbbfrontsocketv2/blackbox/blackboxcommon.go

@@ -0,0 +1,601 @@
+package blackbox
+
+import (
+	"strconv"
+	"time"
+
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"github.com/axgle/mahonia"
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"zks.com/gotcp"
+	"zks.com/newbbfrontsocketv2/business/versionmanage"
+	"zks.com/socketutils"
+	utils "zks.com/zUtils"
+	coldcloud "zks.com/zcoldcloud"
+)
+
+type GaoDeGpsChange struct {
+	Status    string `json:"status"`
+	Info      string `json:"info"`
+	Locations string `json:"locations"`
+}
+
+func GetChannelValue(c *gotcp.Conn, value, command []byte, msgid, msggatewayid string, msgliusid int64) (dataarray []blackboxddata) {
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Println("Recovered in f", r)
+		}
+	}()
+	switch msgid {
+	case "2004":
+		Conns2004.Lock()
+		if v, ok := Conns2004.m[msggatewayid]; ok {
+			socketutils.InformationalWithFormat("授时:", msggatewayid, "数据:", v)
+			if time.Now().Unix()-v.Time < 300 && v.Count+1 > 5 {
+				socketutils.InformationalWithFormat("授时主动断开:", msggatewayid)
+				c.Close()
+				delete(Conns2004.m, msggatewayid)
+				Conns2004.Unlock()
+				return nil
+			}
+			if time.Now().Unix()-v.Time > 60*60 {
+				Conns2004.m[msggatewayid] = Status2004{time.Now().Unix(), 1}
+			} else {
+				Conns2004.m[msggatewayid] = Status2004{v.Time, v.Count + 1}
+			}
+		} else {
+			Conns2004.m[msggatewayid] = Status2004{time.Now().Unix(), 1}
+		}
+		Conns2004.Unlock()
+		var uyear, umonth, uday, uhour, uminute, usecond uint64
+		t := time.Now().Format("20060102150405")
+		uyear, _ = strconv.ParseUint(t[2:4], 16, 0)
+		umonth, _ = strconv.ParseUint(t[4:6], 16, 0)
+		uday, _ = strconv.ParseUint(t[6:8], 16, 0)
+		uhour, _ = strconv.ParseUint(t[8:10], 16, 0)
+		uminute, _ = strconv.ParseUint(t[10:12], 16, 0)
+		usecond, _ = strconv.ParseUint(t[12:], 16, 0)
+		sendms := []byte{0xA0, 0x04, 0x00, 0x06, command[5], command[6], command[7], command[8], command[9], command[10], command[11], command[12], byte(uyear), byte(umonth), byte(uday), byte(uhour), byte(uminute), byte(usecond)}
+		sendms = append(sendms, yihuo(sendms))
+		send := []byte{0x7E}
+		for _, v := range sendms {
+			if v == 0x7E {
+				send = append(send, 0x7D, 0x02)
+			} else if v == 0x7D {
+				send = append(send, 0x7D, 0x01)
+			} else {
+				send = append(send, v)
+			}
+		}
+		send = append(send, 0x7E)
+		//err_send := c.WritePacket(NewPacket(3, send))
+		n, err_send := c.WritePacketN(NewPacket(3, send))
+		socketutils.InformationalWithFormat("守时:", n, "错误信息:", err_send)
+	case "2010", "2011":
+		temp := value
+		if len(temp) < 19 {
+			fmt.Println("2010类型数据长度下小于19", len(temp))
+			return
+		}
+		var gdzdcd int64
+		switch int(temp[0]) {
+		case 3:
+			sensors := make(map[string]string)
+			temp = temp[10:]
+			for {
+				sensorid := fmt.Sprintf("%X", temp[1:5])
+				fmt.Println("sensorid ", sensorid) //sensorid
+				if sensorid != msggatewayid {
+					sensors[sensorid] = sensorid
+				}
+				gdzdcd = 14
+				sjnewcom := temp[gdzdcd+1:]
+				tempnew := S6ForWriter(sjnewcom)
+				temp = tempnew
+				fmt.Println("剩余长度", len(temp))
+				if len(temp) == 0 {
+
+					break
+				}
+			}
+			for sensor, _ := range sensors {
+				DParamSensorSet(c, sensor, msggatewayid)
+			}
+		}
+		if msgid == "2011" {
+			fmt.Println("-------> [反馈分支][2011]")
+			// 发送反馈信息
+			rawMsg := []byte{0xA0, 0x01, 0x00, 0x05, command[5], command[6], command[7], command[8], command[9], command[10], command[11], command[12]}
+			rawMsg = append(rawMsg, Valuebyte2(int(msgliusid))...)
+			rawMsg = append(rawMsg, 0x20, 0x11, 0x00)
+			rawMsg = append(rawMsg, yihuo(rawMsg))
+			message := []byte{0x7E}
+			for _, v := range rawMsg {
+				if v == 0x7E {
+					message = append(message, 0x7D, 0x02)
+				} else if v == 0x7D {
+					message = append(message, 0x7D, 0x01)
+				} else {
+					message = append(message, v)
+				}
+			}
+			message = append(message, 0x7E)
+			fmt.Println("_ _ _ _ _ _ _ _ _ _ _ _ _ _ [2011][Response] _ _ _ _ _ _ _ _ _ _ _ _ _ _")
+			fmt.Println("[Msg]", fmt.Sprintf("%X", message))
+			go WritePacketAndLog(c, message, time.Now().Unix())
+		}
+	case "2024":
+		if len(value) < 3 {
+			return
+		}
+		//当前软件版本
+		banben := fmt.Sprintf("%X", value[0:2])
+		fmt.Println("当前软件版本 ", banben)
+		//项目名长度
+		namelengthx := fmt.Sprintf("%X", value[2])
+		namelength, _ := strconv.ParseInt(namelengthx, 16, 64)
+		fmt.Println("项目名长度 ", namelength)
+		if len(value) < (3 + int(namelength)) {
+			return
+		}
+		projectname := byteToAscii(value[3 : 3+namelength])
+		fmt.Println("项目名 ", projectname)
+		var version versionmanage.VersionManage
+		strUrl := Config.Send.Waterdrop.Service + "/remoteupgrade/newestversion?projecttag=1&projectname=" + projectname + "&versionnum=" + banben + "&mainserial=" + msggatewayid
+		json.Unmarshal(Apiget(strUrl), &version)
+		strUrl = Config.Send.Waterdrop.Service + "/remoteupgrade/upgradehistory/device?projecttag=1&projectname=" + projectname + "&currversion=" + banben + "&mainserial=" + msggatewayid + "&upversion=" + utils.ToStr(version.VersionNum)
+		json.Unmarshal(Apiget(strUrl), nil)
+		if version.Id == 0 {
+			fmt.Println("无升级数据包")
+			return
+		}
+		var newbanben = version.VersionName
+		//var banbenname ="S6_1139"
+		bytestr, err := ioutil.ReadFile("/home/wwwroot/zksiotservice/waterdrop/web" + version.FilePath)
+		if err != nil {
+			fmt.Println("升级文件读取异常", err)
+		}
+		one, _ := strconv.ParseUint(newbanben[1:3], 16, 0)
+		two, _ := strconv.ParseUint(newbanben[3:5], 16, 0)
+		message := []byte{byte(one), byte(two)}
+		message = append(message, Valuebyte4(len(bytestr))...)
+		sendms := []byte{0xA0, 0x08, 0x00, byte(len(message)), command[5], command[6], command[7], command[8], command[9], command[10], command[11], command[12], byte(one), byte(two)}
+		sendms = append(sendms, Valuebyte4(len(bytestr))...)
+		sendms = append(sendms, yihuo(sendms))
+		send := []byte{0x7E}
+		for _, v := range sendms {
+			if v == 0x7E {
+				send = append(send, 0x7D, 0x02)
+			} else if v == 0x7D {
+				send = append(send, 0x7D, 0x01)
+			} else {
+				send = append(send, v)
+			}
+		}
+		send = append(send, 0x7E)
+		c.WritePacket(NewPacket(3, send))
+		var emtity coldcloud.DUpgrade
+		coldcloud.UpdateControlDUpgrade("CTL"+msggatewayid, emtity)
+	case "2025":
+		if len(value) < 7 {
+			return
+		}
+		//当前软件版本
+		banben := fmt.Sprintf("%X", value[0:2])
+		fmt.Println("升级软件版本 ", banben)
+		//分包序号
+		fenbaoxuliehaox := fmt.Sprintf("%X", value[2:4])
+		fenbaoxuliehaod, _ := strconv.ParseInt(fenbaoxuliehaox, 16, 64)
+		fmt.Println("分包序号 ", fenbaoxuliehaod)
+		//分包长度
+		fenbaoxchangdux := fmt.Sprintf("%X", value[4:6])
+		fenbaoxchangdud, _ := strconv.ParseInt(fenbaoxchangdux, 16, 64)
+		fmt.Println("分包长度 ", fenbaoxchangdud)
+		//项目名长度
+		namelengthx := fmt.Sprintf("%X", value[6])
+		namelength, _ := strconv.ParseInt(namelengthx, 16, 64)
+		fmt.Println("项目名长度 ", namelength)
+		if len(value) < (7 + int(namelength)) {
+			return
+		}
+		//项目名
+		projectname := byteToAscii(value[7 : 7+namelength])
+		fmt.Println("项目名 ", projectname)
+		var version versionmanage.VersionManage
+		strUrl := Config.Send.Waterdrop.Service + "/remoteupgrade/versiondetail?projecttag=1&projectname=" + projectname + "&versionnum=" + banben
+		json.Unmarshal(Apiget(strUrl), &version)
+		if version.Id == 0 {
+			fmt.Println("无升级数据包")
+			return
+		}
+		bytestr, err := ioutil.ReadFile("/home/wwwroot/zksiotservice/waterdrop/web" + version.FilePath)
+		if err != nil {
+			fmt.Println("升级文件读取异常", err)
+		}
+		databyte := []byte{}
+		if (int(fenbaoxuliehaod)+1)*int(fenbaoxchangdud) > len(bytestr) {
+			databyte = bytestr[fenbaoxuliehaod*fenbaoxchangdud:]
+		} else {
+			databyte = bytestr[fenbaoxuliehaod*fenbaoxchangdud : (int(fenbaoxuliehaod)+1)*int(fenbaoxchangdud)]
+		}
+		fmt.Println(databyte)
+		message := []byte{}
+		message = append(message, value[0:4]...)
+		message = append(message, Valuebyte2(len(databyte))...)
+		message = append(message, databyte...)
+		sendms := []byte{0xA0, 0x09}
+		sendms = append(sendms, Valuebyte2(len(message))...)
+		sendms = append(sendms, []byte{command[5], command[6], command[7], command[8], command[9], command[10], command[11], command[12]}...)
+		sendms = append(sendms, message...)
+		sendms = append(sendms, yihuo(sendms))
+		send := []byte{0x7E}
+		for _, v := range sendms {
+			if v == 0x7E {
+				send = append(send, 0x7D, 0x02)
+			} else if v == 0x7D {
+				send = append(send, 0x7D, 0x01)
+			} else {
+				send = append(send, v)
+			}
+		}
+		send = append(send, 0x7E)
+		c.WritePacket(NewPacket(3, send))
+	}
+	return
+}
+
+//S6多探头循环写入
+func S6ForWriter(sjnewcom []byte) (temp []byte) {
+	for {
+		//数据项列表长度
+		sjlength := len(sjnewcom)
+		if sjlength < 2 {
+			sjnewcom = []byte{}
+			break
+		}
+		//获取端口编号
+		portnumx := fmt.Sprintf("%X", sjnewcom[0])
+		portnumint64, _ := strconv.ParseInt(portnumx, 16, 32)
+		portnumint := int(portnumint64)
+		if portnumint == 255 {
+			sjnewcom = sjnewcom[1:]
+			break
+		}
+		//获取数据类型
+		datatypestr := fmt.Sprintf("%X", sjnewcom[1])
+		datatype, _ := strconv.ParseInt(datatypestr, 16, 32)
+		if datatype == 1 {
+			if len(sjnewcom[2:]) < 4 {
+				sjnewcom = sjnewcom[2:]
+				break
+			}
+			sjnewcom = sjnewcom[6:]
+		} else if datatype == 2 {
+			if len(sjnewcom[2:]) < 2 {
+				sjnewcom = sjnewcom[2:]
+				break
+			}
+			sjnewcom = sjnewcom[4:]
+		} else if datatype == 3 {
+			if len(sjnewcom[2:]) < 4 {
+				sjnewcom = sjnewcom[2:]
+				break
+			}
+			sjnewcom = sjnewcom[6:]
+		} else if datatype == 4 {
+			if len(sjnewcom[2:]) < 3 {
+				sjnewcom = sjnewcom[2:]
+				break
+			}
+			sjnewcom = sjnewcom[5:]
+		} else if datatype == 5 { //压力传感器
+			if len(sjnewcom[2:]) < 4 {
+				sjnewcom = sjnewcom[2:]
+				break
+			}
+			sjnewcom = sjnewcom[6:]
+		} else if datatype == 10 {
+			if len(sjnewcom[2:]) < 4 {
+				sjnewcom = sjnewcom[2:]
+				break
+			}
+			sjnewcom = sjnewcom[6:]
+		} else if datatype == 11 {
+			if len(sjnewcom[2:]) < 16 {
+				sjnewcom = sjnewcom[2:]
+				break
+			}
+			sjnewcom = sjnewcom[18:]
+		} else if datatype == 12 {
+			if len(sjnewcom[2:]) < 1 {
+				sjnewcom = sjnewcom[2:]
+				break
+			}
+			sjnewcom = sjnewcom[3:]
+		} else if datatype == 13 {
+			if len(sjnewcom[2:]) < 1 {
+				sjnewcom = sjnewcom[2:]
+				break
+			}
+			sjnewcom = sjnewcom[2:]
+		} else if datatype == 254 {
+
+			if len(sjnewcom[2:]) < 6 {
+				sjnewcom = sjnewcom[2:]
+				break
+			}
+			sjnewcom = sjnewcom[8:]
+		} else {
+			fmt.Println("不定项的除了STH20和NTC其他类型", datatype)
+			sjnewcom = []byte{}
+			break
+		}
+	}
+	return sjnewcom
+}
+
+//设置参数
+func DParamSensorSet(c *gotcp.Conn, sensor, msggatewayid string) {
+	paramset, _ := coldcloud.GetReverseControlDParam("CTL" + sensor)
+	if paramset.Id != 0 && len(sensor) >= 8 {
+		head := []byte{0xA0, 0x02, 0x00}
+		sendms := []byte{}
+		sensormac1, _ := strconv.ParseInt(sensor[0:2], 16, 64)
+		sensormac2, _ := strconv.ParseInt(sensor[2:4], 16, 64)
+		sensormac3, _ := strconv.ParseInt(sensor[4:6], 16, 64)
+		sensormac4, _ := strconv.ParseInt(sensor[6:8], 16, 64)
+		sendms = append(sendms, 0x00, byte(sensormac1), byte(sensormac2), byte(sensormac3), byte(sensormac4))
+		for _, v := range paramset.SetValue {
+			if time.Now().Unix()-v.CreateOn.Unix() > (60 * 120) {
+				break
+			}
+			switch v.Dtype {
+			case 1:
+				zksint, _ := utils.StrTo(v.Value).Int()
+				sendms = append(sendms, byte(v.Dtype))
+				sendms = append(sendms, Valuebyte4(zksint)...)
+			case 2:
+				zksint, _ := utils.StrTo(v.Value).Int()
+				sendms = append(sendms, byte(v.Dtype))
+				fmt.Println(fmt.Sprintf("% X", sendms))
+				sendms = append(sendms, Valuebyte4(zksint)...)
+			case 3:
+				zksfloat, _ := utils.StrTo(v.Value).Float32()
+				zksint := int(zksfloat * 100)
+				sendms = append(sendms, byte(v.Dtype))
+				sendms = append(sendms, byte(v.Port))
+				if zksint >= 0 {
+					sendms = append(sendms, Valuebyte2(zksint)...)
+				} else {
+					sendms = append(sendms, Bumatobyte2(zksint)...)
+				}
+			case 4:
+				zksfloat, _ := utils.StrTo(v.Value).Float32()
+				zksint := int(zksfloat * 100)
+				sendms = append(sendms, byte(v.Dtype))
+				sendms = append(sendms, byte(v.Port))
+				if zksint >= 0 {
+					sendms = append(sendms, Valuebyte2(zksint)...)
+				} else {
+					sendms = append(sendms, Bumatobyte2(zksint)...)
+				}
+			case 11:
+				name := []byte(CodertoGBK(utils.Substr(v.Value, 0, 10)))
+				sendms = append(sendms, byte(v.Dtype))
+				sendms = append(sendms, byte(len(name)))
+				sendms = append(sendms, name...)
+			case 27:
+				zksfloat, _ := utils.StrTo(v.Value).Float32()
+				zksint := int(zksfloat * 100)
+				sendms = append(sendms, byte(v.Dtype))
+				sendms = append(sendms, byte(v.Port))
+				if zksint >= 0 {
+					sendms = append(sendms, Valuebyte2(zksint)...)
+				} else {
+					sendms = append(sendms, Bumatobyte2(zksint)...)
+				}
+			case 28: //湿度校正
+				zksfloat, _ := utils.StrTo(v.Value).Float32()
+				zksint := int(zksfloat * 100)
+				sendms = append(sendms, byte(v.Dtype))
+				sendms = append(sendms, byte(v.Port))
+				if zksint >= 0 {
+					sendms = append(sendms, Valuebyte2(zksint)...)
+				} else {
+					sendms = append(sendms, Bumatobyte2(zksint)...)
+				}
+			}
+		}
+		if len(sendms) == 0 {
+			//Apipost(Config.Send.Waterdrop.Service+"/dparamset/setv2?mainserial="+sensor+"&num="+utils.ToStr(paramset.ControlNum)+"&state=2", "POST", nil)
+			var dparamset coldcloud.DParamSet
+			coldcloud.UpdateCTLDParamSet("CTL"+sensor, dparamset)
+		} else {
+			mac1, _ := strconv.ParseInt(msggatewayid[0:2], 16, 64)
+			mac2, _ := strconv.ParseInt(msggatewayid[2:4], 16, 64)
+			mac3, _ := strconv.ParseInt(msggatewayid[4:6], 16, 64)
+			mac4, _ := strconv.ParseInt(msggatewayid[6:8], 16, 64)
+			head = append(head, byte(len(sendms)), byte(mac1), byte(mac2), byte(mac3), byte(mac4), 0x00, 0x00)
+			head = append(head, Valuebyte2(paramset.ControlNum)...)
+			sendms = append(head, sendms...)
+			sendms = append(sendms, yihuo(sendms))
+			send := []byte{0x7E}
+			for _, v := range sendms {
+				if v == 0x7E {
+					send = append(send, 0x7D, 0x02)
+				} else if v == 0x7D {
+					send = append(send, 0x7D, 0x01)
+				} else {
+					send = append(send, v)
+				}
+			}
+			send = append(send, 0x7E)
+			fmt.Println("反向控制命令", fmt.Sprintf("% X", send))
+			c.WritePacket(NewPacket(3, send))
+		}
+	}
+}
+func byteToAscii(signalList []byte) (str string) {
+	for i := 0; i < len(signalList); i++ {
+		if signalList[i] != 0x00 {
+			str += string(signalList[i])
+		}
+	}
+	return str
+}
+func yihuo(signalList []byte) byte {
+	var xor byte
+	xor = signalList[0]
+	for i := 1; i < len(signalList); i++ {
+		xor ^= signalList[i]
+	}
+	return xor
+}
+
+//把16进制转换为二进制字符串
+func ByteToBinaryString(data byte) (str string) {
+	var a byte
+	for i := 0; i < 8; i++ {
+		a = data
+		data <<= 1
+		data >>= 1
+		switch a {
+		case data:
+			str += "0"
+		default:
+			str += "1"
+		}
+		data <<= 1
+	}
+	return str
+}
+
+//把一个字节的二进制字符串转换为十进制数字
+func btox(b string) string {
+	base, _ := strconv.ParseInt(b, 2, 12)
+
+	return strconv.FormatInt(base, 10)
+}
+
+//把一个字节的二进制字符串转换为十六进制数字
+func btox16(b string) string {
+	base, _ := strconv.ParseInt(b, 2, 12)
+
+	return strconv.FormatInt(base, 16)
+}
+func Substr(str string, start int, length int) string {
+	rs := []rune(str)
+	rl := len(rs)
+	end := 0
+
+	if start < 0 {
+		start = rl - 1 + start
+	}
+	end = start + length
+
+	if start > end {
+		start, end = end, start
+	}
+
+	if start < 0 {
+		start = 0
+	}
+	if start > rl {
+		start = rl
+	}
+	if end < 0 {
+		end = 0
+	}
+	if end > rl {
+		end = rl
+	}
+
+	return string(rs[start:end])
+}
+
+//数值转为2个字节
+func Valuebyte2(v int) []byte {
+	value := make([]byte, 2)
+	value[0] = byte(v >> 8 & 0xff)
+	value[1] = byte(v & 0xff)
+	return value
+}
+
+//数值转为4个字节
+func Valuebyte4(v int) []byte {
+	value := make([]byte, 4)
+	value[0] = byte(v >> 24 & 0xff)
+	value[1] = byte(v >> 16 & 0xff)
+	value[2] = byte(v >> 8 & 0xff)
+	value[3] = byte(v & 0xff)
+	return value
+}
+
+//2个字节的补码
+func Bumatobyte2(v int) []byte {
+	value := make([]byte, 2)
+	if v < 0 {
+		v = 65535 + 1 + v
+	}
+	value[0] = byte(v >> 8 & 0xff)
+	value[1] = byte(v & 0xff)
+	return value
+}
+
+//4个字节的补码
+func Bumabyte4(v int64) []byte {
+	value := make([]byte, 4)
+	if v < 0 {
+		v = 4294967295 + 1 + v
+	}
+	value[0] = byte(v >> 24 & 0xff)
+	value[1] = byte(v >> 16 & 0xff)
+	value[2] = byte(v >> 8 & 0xff)
+	value[3] = byte(v & 0xff)
+	return value
+}
+func Apipost(strUrl, method string, postDict interface{}) (body []byte) {
+	strUrl = strings.Replace(strUrl, " ", "%20", -1)
+	httpClient := &http.Client{
+		//Transport:nil,
+		//CheckRedirect: nil,
+	}
+
+	var httpReq *http.Request
+
+	b, _ := json.Marshal(postDict)
+	postBytesReader := bytes.NewReader(b)
+	httpReq, _ = http.NewRequest(method, strUrl, postBytesReader)
+	httpReq.Header.Add("Content-Type", "application/json")
+	response, _ := httpClient.Do(httpReq)
+	body, _ = ioutil.ReadAll(response.Body)
+	return
+}
+func Apiget(str string) (body []byte) {
+	str = strings.Replace(str, " ", "%20", -1)
+	response, _ := http.Get(str)
+	if response != nil {
+		defer response.Body.Close()
+		body, _ = ioutil.ReadAll(response.Body)
+	}
+	//json.Unmarshal(body, &devices)
+	return
+}
+func CodertoGBK(str string) string {
+	dec := mahonia.NewDecoder("UTF-8")
+	enc := mahonia.NewEncoder("GBK")
+	return enc.ConvertString(dec.ConvertString(str))
+}
+
+//发送给设备并且打印日志
+func WritePacketAndLog(c *gotcp.Conn, message []byte, sendtime int64) {
+	responseError := c.WritePacket(NewPacket(3, message))
+	fmt.Println("反向控制[UsedTime]", time.Now().Unix()-sendtime, "[Msg]", fmt.Sprintf("%X", message))
+	if responseError != nil {
+		fmt.Println("[ResponseError]", responseError)
+	}
+}

src/zks.com/newbbfrontsocketv2/blackbox/conf.go

@@ -0,0 +1,50 @@
+package blackbox
+
+import (
+	"io/ioutil"
+	"os"
+
+	"github.com/naoina/toml"
+)
+
+type AppConfig struct {
+	Send struct {
+		Redis struct {
+			Addr    string
+			Poolnum int
+			Pwd     string
+		}
+		Nsq struct {
+			Nsqdtcpaddr string
+			Topic       string
+		}
+		Nsqrequest struct {
+			Nsqdtcpaddr string
+			Topic       string
+		}
+		Waterdrop struct {
+			Service string
+		}
+	}
+	Service struct {
+		Ipandport string
+	}
+}
+
+var Config AppConfig
+
+func ReadAppConfig(path string) (config AppConfig) {
+	f, err := os.Open(path)
+	if err != nil {
+		panic(err)
+	}
+	defer f.Close()
+	buf, err := ioutil.ReadAll(f)
+	if err != nil {
+		panic(err)
+	}
+	if err := toml.Unmarshal(buf, &config); err != nil {
+		panic(err)
+	}
+	return
+}

src/zks.com/newbbfrontsocketv2/blackbox/dataserver.go

@@ -0,0 +1,586 @@
+/*更新记录
+20-5-7-23 zh 增加深低温校准（温度在-195到-190之间时 将温度改为 196）
+20-5-9-8 zh 增加深低温校准（温度小于-197时 将温度改为 196 小数点后为随机数）
+20-5-10-13 zh 修改校准规则，存储前一条数据到缓存boltdb中
+*/
+
+package blackbox
+
+import (
+	"fmt"
+	"strconv"
+	"sync"
+	"time"
+
+	"encoding/json"
+
+	"zks.com/gotcp"
+	zksutils "zks.com/zUtils"
+	coldcloud "zks.com/zcoldcloud"
+)
+
+var format string = "2006-1-2 15:4:5"
+var Conns = struct {
+	sync.RWMutex
+	m map[string]*gotcp.Conn
+}{m: make(map[string]*gotcp.Conn)}
+var Conns2004 = struct {
+	sync.RWMutex
+	m map[string]Status2004
+}{m: make(map[string]Status2004)}
+
+type Status2004 struct {
+	Time  int64
+	Count int64
+}
+type Status struct {
+	Status  int    `json:"status"`
+	Id      string `json:"id"`
+	Message string `json:"message"`
+}
+
+func DoWork(c *gotcp.Conn, command []byte) error {
+	fmt.Println("DoWork", time.Now(), fmt.Sprintf("%X", command))
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Println("Recovered in f", r)
+		}
+	}()
+	if 0x7E != command[0] || 0x7E != command[len(command)-1] {
+		if 0x8E == command[0] && 0x8E == command[len(command)-1] {
+			go ControlDevice(c, command)
+		}
+	} else {
+		//创建新的byte数组
+		newcom := make([]byte, 0)
+		//循环便利原数组,去掉首尾的0x7E,把数据中的0x7D 0x01转义为0x7D,0x7D 0x02转义为0x7E
+		for i := 1; i < len(command)-1; i++ {
+
+			if command[i] == 0x7D && command[i+1] == 0x01 {
+				newcom = append(newcom, 0x7D)
+				i++
+			} else if command[i] == 0x7D && command[i+1] == 0x02 {
+				newcom = append(newcom, 0x7E)
+				i++
+			} else {
+				newcom = append(newcom, command[i])
+			}
+		}
+		if len(newcom) >= 13 {
+			bytejh := yihuo(newcom[0 : len(newcom)-1])
+			//fmt.Println("校验码： ", bytejh)
+			//fmt.Println("原校验码： ", newcom[len(newcom)-1])
+			//消息ID
+			msgid := fmt.Sprintf("%X", newcom[0:2])
+			//fmt.Println("消息ID ", msgid)
+			//消息体属性
+			msgattr := newcom[2:4]
+			str := ByteToBinaryString(msgattr[0])
+			str1 := ByteToBinaryString(msgattr[1])
+			//消息体长度
+			msglength := btox(Substr(str+str1, len(str+str1)-11, 11))
+			//fmt.Println("标记消息体长度 ", msglength)
+			//实际消息体长度
+			msgsjcd := len(newcom[12:]) - 1
+			msglengthint, _ := strconv.Atoi(msglength)
+			//fmt.Println("实际消息体长度 ", msgsjcd)
+			//网关ID
+			msggatewayid := fmt.Sprintf("%X", newcom[4:8])
+			fmt.Println("网关ID ", msggatewayid)
+			coldcloud.UpdateBoxIpAndPort(msggatewayid, coldcloud.IpAndPortStruct{Config.Service.Ipandport, time.Now()})
+			//UUID
+			//msguuid := fmt.Sprintf("%X", newcom[8:10])
+			//fmt.Println("msguuid  ", msguuid) //msguuid
+			//消息流水号
+			msgliusidx := fmt.Sprintf("%X", newcom[10:12])
+			msgliusid, _ := strconv.ParseInt(msgliusidx, 16, 64)
+			//fmt.Println("消息流水号 ", msgliusid)
+			//消息包总数
+			//var msgtotal int64
+			//fmt.Println(msgtotal) //msgtotal
+			//消息包序号
+			//var msgnum int64
+			//fmt.Println(msgnum) //msgnum
+			if bytejh == newcom[len(newcom)-1] && msglengthint == msgsjcd {
+				//A029下发报警给报警器
+				if msgid != "A029" {
+					Conns.Lock()
+					Conns.m[msggatewayid] = c
+					Conns.Unlock()
+				}
+				switch msgid {
+				case "2004", "2024", "2025", "2010", "2011":
+					var datacom []byte
+					datacom = newcom[12 : 12+msgsjcd]
+					fmt.Println(fmt.Sprintf("% X", datacom))
+					GetChannelValue(c, datacom, command, msgid, msggatewayid, msgliusid)
+				case "A029":
+					Conns.Lock()
+					if v, ok := Conns.m[msggatewayid]; ok {
+						fmt.Println("A029发送", fmt.Sprintf("%X", command))
+						go v.WritePacket(NewPacket(3, command))
+					}
+					Conns.Unlock()
+				}
+				DParamSet(c, msggatewayid)
+				ShutdownOrBoot(c, msggatewayid)
+			}
+		}
+		Writedata_v2(fmt.Sprintf("% X", command))
+	}
+	return nil
+}
+
+//设置参数
+func DParamSet(c *gotcp.Conn, msggatewayid string) {
+	paramset, _ := coldcloud.GetReverseControlDParam("CTL" + msggatewayid)
+	if paramset.Id != 0 && len(msggatewayid) >= 8 {
+		head := []byte{0xA0, 0x02, 0x00}
+		sendms := []byte{}
+		for _, v := range paramset.SetValue {
+			if time.Now().Unix()-v.CreateOn.Unix() > (60 * 30) {
+				sendms = []byte{}
+				break
+			}
+			switch v.Dtype {
+			case 1:
+				zksint, _ := zksutils.StrTo(v.Value).Int()
+				sendms = append(sendms, byte(v.Dtype))
+				sendms = append(sendms, Valuebyte4(zksint)...)
+			case 2:
+				zksint, _ := zksutils.StrTo(v.Value).Int()
+				sendms = append(sendms, byte(v.Dtype))
+				fmt.Println(fmt.Sprintf("% X", sendms))
+				sendms = append(sendms, Valuebyte4(zksint)...)
+			case 3:
+				zksfloat, _ := zksutils.StrTo(v.Value).Float32()
+				zksint := int(zksfloat * 100)
+				sendms = append(sendms, byte(v.Dtype))
+				sendms = append(sendms, byte(v.Port))
+				if zksint >= 0 {
+					sendms = append(sendms, Valuebyte2(zksint)...)
+				} else {
+					sendms = append(sendms, Bumatobyte2(zksint)...)
+				}
+			case 4:
+				zksfloat, _ := zksutils.StrTo(v.Value).Float32()
+				zksint := int(zksfloat * 100)
+				sendms = append(sendms, byte(v.Dtype))
+				sendms = append(sendms, byte(v.Port))
+				if zksint >= 0 {
+					sendms = append(sendms, Valuebyte2(zksint)...)
+				} else {
+					sendms = append(sendms, Bumatobyte2(zksint)...)
+				}
+			case 11:
+				name := []byte(CodertoGBK(zksutils.Substr(v.Value, 0, 10)))
+				sendms = append(sendms, byte(v.Dtype))
+				sendms = append(sendms, byte(len(name)))
+				sendms = append(sendms, name...)
+			case 27:
+				zksfloat, _ := zksutils.StrTo(v.Value).Float32()
+				zksint := int(zksfloat * 100)
+				sendms = append(sendms, byte(v.Dtype))
+				sendms = append(sendms, byte(v.Port))
+				if zksint >= 0 {
+					sendms = append(sendms, Valuebyte2(zksint)...)
+				} else {
+					sendms = append(sendms, Bumatobyte2(zksint)...)
+				}
+			case 28: //湿度校正
+				zksfloat, _ := zksutils.StrTo(v.Value).Float32()
+				zksint := int(zksfloat * 100)
+				sendms = append(sendms, byte(v.Dtype))
+				sendms = append(sendms, byte(v.Port))
+				if zksint >= 0 {
+					sendms = append(sendms, Valuebyte2(zksint)...)
+				} else {
+					sendms = append(sendms, Bumatobyte2(zksint)...)
+				}
+			}
+		}
+		if len(sendms) == 0 {
+			//Apipost(Config.Send.Waterdrop.Service+"/dparamset/setv2?mainserial="+msggatewayid+"&num="+zksutils.ToStr(paramset.ControlNum)+"&state=2", "POST", nil)
+			var dparamset coldcloud.DParamSet
+			coldcloud.UpdateCTLDParamSet("CTL"+msggatewayid, dparamset)
+		} else {
+			mac1, _ := strconv.ParseInt(msggatewayid[0:2], 16, 64)
+			mac2, _ := strconv.ParseInt(msggatewayid[2:4], 16, 64)
+			mac3, _ := strconv.ParseInt(msggatewayid[4:6], 16, 64)
+			mac4, _ := strconv.ParseInt(msggatewayid[6:8], 16, 64)
+			//		ctlnum, _ := coldcloud.GetReverseControlCtlSNum("CTL" + msggatewayid)
+			//		numint, _ := zksutils.StrTo(ctlnum).Int()
+			head = append(head, byte(len(sendms)), byte(mac1), byte(mac2), byte(mac3), byte(mac4), 0x00, 0x00)
+			head = append(head, Valuebyte2(paramset.ControlNum)...)
+			sendms = append(head, sendms...)
+			sendms = append(sendms, yihuo(sendms))
+			send := []byte{0x7E}
+			for _, v := range sendms {
+				if v == 0x7E {
+					send = append(send, 0x7D, 0x02)
+				} else if v == 0x7D {
+					send = append(send, 0x7D, 0x01)
+				} else {
+					send = append(send, v)
+				}
+			}
+			send = append(send, 0x7E)
+			fmt.Println("反向控制命令", fmt.Sprintf("% X", send))
+			c.WritePacket(NewPacket(3, send))
+		}
+	}
+	//设置飞行模式
+	lightset, _ := coldcloud.GetReverseControlSetLight("CTL" + msggatewayid)
+	if lightset.SetType == 1 && len(msggatewayid) >= 8 && lightset.RequestState == 0 {
+		if time.Now().Unix() > (lightset.OccurTime.Unix() - 120) {
+			var status Status
+			if time.Now().Unix() < lightset.CloseTime.Unix() || lightset.RemainMin == 0 {
+				head := []byte{0xA0, 0x0B, 0x00}
+				sendms := []byte{}
+				mac1, _ := strconv.ParseInt(msggatewayid[0:2], 16, 64)
+				mac2, _ := strconv.ParseInt(msggatewayid[2:4], 16, 64)
+				mac3, _ := strconv.ParseInt(msggatewayid[4:6], 16, 64)
+				mac4, _ := strconv.ParseInt(msggatewayid[6:8], 16, 64)
+				head = append(head, 0x02, byte(mac1), byte(mac2), byte(mac3), byte(mac4), 0x00, 0x00)
+				head = append(head, Valuebyte2(lightset.ControlNumber)...)
+				sendms = append(sendms, Valuebyte2(lightset.RemainMin)...)
+				sendms = append(head, sendms...)
+				sendms = append(sendms, yihuo(sendms))
+				send := []byte{0x7E}
+				for _, v := range sendms {
+					if v == 0x7E {
+						send = append(send, 0x7D, 0x02)
+					} else if v == 0x7D {
+						send = append(send, 0x7D, 0x01)
+					} else {
+						send = append(send, v)
+					}
+				}
+				send = append(send, 0x7E)
+				fmt.Println("设置飞行模式", fmt.Sprintf("% X", send))
+				c.WritePacket(NewPacket(3, send))
+				json.Unmarshal(Apipost(Config.Send.Waterdrop.Service+"/devicestate/state?mainserial="+msggatewayid+"&controlnumber="+zksutils.ToStr(lightset.ControlNumber)+"&settype=1&requeststate=1&requesttime="+time.Now().Format("2006-01-02 15:04:05"), "PUT", nil), &status)
+				if status.Status == 1 {
+					lightset.RequestState = 1
+					lightset.OccurTime = time.Now()
+					coldcloud.UpdateCtlSetLight("CTL"+msggatewayid, lightset)
+				}
+			} else {
+				json.Unmarshal(Apipost(Config.Send.Waterdrop.Service+"/devicestate/state?mainserial="+msggatewayid+"&controlnumber="+zksutils.ToStr(lightset.ControlNumber)+"&settype=1&requeststate=4&requesttime="+time.Now().Format("2006-01-02 15:04:05"), "PUT", nil), &status)
+				if status.Status == 1 {
+					lightset.RequestState = 4
+					lightset.OccurTime = time.Now()
+					coldcloud.UpdateCtlSetLight("CTL"+msggatewayid, lightset)
+				}
+			}
+
+		}
+	}
+	//远程升级
+	dupgrade, err := coldcloud.GetReverseControlDUpgrade("CTL" + msggatewayid)
+	if err == nil && len(dupgrade.Data) > 0 {
+		if time.Now().Unix()-dupgrade.Time < 1800 {
+			mac1, _ := strconv.ParseInt(msggatewayid[0:2], 16, 64)
+			mac2, _ := strconv.ParseInt(msggatewayid[2:4], 16, 64)
+			mac3, _ := strconv.ParseInt(msggatewayid[4:6], 16, 64)
+			mac4, _ := strconv.ParseInt(msggatewayid[6:8], 16, 64)
+			sendms := []byte{0xA0, 0x0A, 0x00, 0x00, byte(mac1), byte(mac2), byte(mac3), byte(mac4), 0x00, 0x00, 0x00, 0x00}
+			sendms = append(sendms, yihuo(sendms))
+			send := []byte{0x7E}
+			for _, v := range sendms {
+				if v == 0x7E {
+					send = append(send, 0x7D, 0x02)
+				} else if v == 0x7D {
+					send = append(send, 0x7D, 0x01)
+				} else {
+					send = append(send, v)
+				}
+			}
+			send = append(send, 0x7E)
+			err := c.WritePacket(NewPacket(3, send))
+			fmt.Println(err, "缓存远程升级", fmt.Sprintf("% X", send))
+		}
+	}
+}
+
+//平台发送多条同一推送报警信息(暂时不用)
+func ServiceToTriggerMsg(c *gotcp.Conn, msggatewayid string) {
+	cachevalue, err := coldcloud.GetReverseControlTriggerMac("CTL" + msggatewayid)
+	//cachevalue, err := coldcloud.GetTriggerMac("TMac" + msggatewayid)
+	if err == nil && len(cachevalue.TriggerMac) > 0 {
+		fmt.Println("平台发送报警信息")
+		var data []byte
+		for _, v := range cachevalue.TriggerMac {
+			mac1, _ := strconv.ParseInt(v.MainMac[0:2], 16, 64)
+			mac2, _ := strconv.ParseInt(v.MainMac[2:4], 16, 64)
+			mac3, _ := strconv.ParseInt(v.MainMac[4:6], 16, 64)
+			mac4, _ := strconv.ParseInt(v.MainMac[6:8], 16, 64)
+			port, _ := strconv.ParseUint(v.Port, 16, 64)
+			lastdata, err1 := coldcloud.GetTriggerHistoryLast("trigger_c" + v.Mac)
+			macdata := []byte{}
+			if err1 == nil {
+				for _, v1 := range lastdata {
+					if v1.IsSend == 2 && v1.ActionType == "alertor" && v1.SendTo == msggatewayid {
+						if v1.EventFiled == "temperature" {
+							macdata = []byte{byte(mac1), byte(mac2), byte(mac3), byte(mac4), byte(port), byte(1)}
+							macdata = append(macdata, Bumabyte4(int64(v1.Value*100))...)
+						} else if v1.EventFiled == "humidity" {
+							macdata = []byte{byte(mac1), byte(mac2), byte(mac3), byte(mac4), byte(port), byte(2)}
+							macdata = append(macdata, Bumabyte4(int64(v1.Value*100))...)
+						}
+					}
+				}
+			}
+			if len(macdata) > 0 {
+				data = append(data, macdata...)
+			}
+		}
+		var sendms []byte
+		if len(data) > 0 && len(data) < 100 {
+			mac1, _ := strconv.ParseInt(msggatewayid[0:2], 16, 64)
+			mac2, _ := strconv.ParseInt(msggatewayid[2:4], 16, 64)
+			mac3, _ := strconv.ParseInt(msggatewayid[4:6], 16, 64)
+			mac4, _ := strconv.ParseInt(msggatewayid[6:8], 16, 64)
+			ctlnum, _ := coldcloud.GetReverseControlCtlSNum("CTL" + msggatewayid)
+			numint, _ := zksutils.StrTo(ctlnum).Int()
+			sendms = []byte{0xA0, 0x03, 0x00, byte(len(data)), byte(mac1), byte(mac2), byte(mac3), byte(mac4), 0x00, 0x00}
+			sendms = append(sendms, Valuebyte2(numint)...)
+			sendms = append(sendms, data...)
+			sendms = append(sendms, yihuo(sendms))
+			send := []byte{0x7E}
+			for _, v := range sendms {
+				if v == 0x7E {
+					send = append(send, 0x7D, 0x02)
+				} else if v == 0x7D {
+					send = append(send, 0x7D, 0x01)
+				} else {
+					send = append(send, v)
+				}
+			}
+			send = append(send, 0x7E)
+			fmt.Println("平台发送报警信息", fmt.Sprintf("% X", send))
+			c.WritePacket(NewPacket(3, send))
+		}
+	}
+}
+
+//平台推送单条报警信息
+func ServiceToTriggerSingleMsg(c *gotcp.Conn, msggatewayid string) {
+	cachevalue, err := coldcloud.GetReverseControlTriggerMac("CTL" + msggatewayid)
+	if err == nil && len(cachevalue.TriggerMac) > 0 {
+		fmt.Println("平台发送报警信息", len(cachevalue.TriggerMac))
+		for _, v := range cachevalue.TriggerMac {
+			if len(v.MainMac) >= 8 && len(msggatewayid) >= 8 {
+				mac1, _ := strconv.ParseInt(v.MainMac[0:2], 16, 64)
+				mac2, _ := strconv.ParseInt(v.MainMac[2:4], 16, 64)
+				mac3, _ := strconv.ParseInt(v.MainMac[4:6], 16, 64)
+				mac4, _ := strconv.ParseInt(v.MainMac[6:8], 16, 64)
+				port, _ := strconv.ParseUint(v.Port, 16, 64)
+				lastdata, err1 := coldcloud.GetTriggerHistoryLast("trigger_c" + v.Mac)
+				if err1 == nil {
+					for _, v1 := range lastdata {
+						if v1.IsSend == 2 && v1.ActionType == "alertor" && v1.SendTo == msggatewayid {
+							macdata := []byte{}
+							if v1.EventFiled == "temperature" {
+								macdata = []byte{byte(mac1), byte(mac2), byte(mac3), byte(mac4), byte(port), byte(1)}
+								macdata = append(macdata, Bumabyte4(int64(v1.Value*100))...)
+								t := v1.AlarmOn.Format("20060102150405")
+								uyear, _ := strconv.ParseUint(t[2:4], 16, 0)
+								umonth, _ := strconv.ParseUint(t[4:6], 16, 0)
+								uday, _ := strconv.ParseUint(t[6:8], 16, 0)
+								uhour, _ := strconv.ParseUint(t[8:10], 16, 0)
+								uminute, _ := strconv.ParseUint(t[10:12], 16, 0)
+								usecond, _ := strconv.ParseUint(t[12:], 16, 0)
+								macdata = append(macdata, byte(uyear), byte(umonth), byte(uday), byte(uhour), byte(uminute), byte(usecond))
+								var sendms []byte
+								mac1, _ := strconv.ParseInt(msggatewayid[0:2], 16, 64)
+								mac2, _ := strconv.ParseInt(msggatewayid[2:4], 16, 64)
+								mac3, _ := strconv.ParseInt(msggatewayid[4:6], 16, 64)
+								mac4, _ := strconv.ParseInt(msggatewayid[6:8], 16, 64)
+								sendms = []byte{0xA0, 0x03, 0x00, byte(len(macdata)), byte(mac1), byte(mac2), byte(mac3), byte(mac4), 0x00, 0x00}
+								sendms = append(sendms, Valuebyte2(v1.ControlNum)...)
+								sendms = append(sendms, macdata...)
+								sendms = append(sendms, yihuo(sendms))
+								send := []byte{0x7E}
+								for _, v := range sendms {
+									if v == 0x7E {
+										send = append(send, 0x7D, 0x02)
+									} else if v == 0x7D {
+										send = append(send, 0x7D, 0x01)
+									} else {
+										send = append(send, v)
+									}
+								}
+								send = append(send, 0x7E)
+								fmt.Println(time.Now(), "流水号", v1.ControlNum, "平台发送报警信息温度 ", fmt.Sprintf("% X", send))
+								c.WritePacket(NewPacket(3, send))
+							} else if v1.EventFiled == "humidity" {
+								macdata = []byte{byte(mac1), byte(mac2), byte(mac3), byte(mac4), byte(port), byte(2)}
+								macdata = append(macdata, Bumabyte4(int64(v1.Value*100))...)
+								t := v1.AlarmOn.Format("20060102150405")
+								uyear, _ := strconv.ParseUint(t[2:4], 16, 0)
+								umonth, _ := strconv.ParseUint(t[4:6], 16, 0)
+								uday, _ := strconv.ParseUint(t[6:8], 16, 0)
+								uhour, _ := strconv.ParseUint(t[8:10], 16, 0)
+								uminute, _ := strconv.ParseUint(t[10:12], 16, 0)
+								usecond, _ := strconv.ParseUint(t[12:], 16, 0)
+								macdata = append(macdata, byte(uyear), byte(umonth), byte(uday), byte(uhour), byte(uminute), byte(usecond))
+								var sendms []byte
+								mac1, _ := strconv.ParseInt(msggatewayid[0:2], 16, 64)
+								mac2, _ := strconv.ParseInt(msggatewayid[2:4], 16, 64)
+								mac3, _ := strconv.ParseInt(msggatewayid[4:6], 16, 64)
+								mac4, _ := strconv.ParseInt(msggatewayid[6:8], 16, 64)
+								ctlnum, _ := coldcloud.GetReverseControlCtlSNum("CTL" + msggatewayid)
+								numint, _ := zksutils.StrTo(ctlnum).Int()
+								sendms = []byte{0xA0, 0x03, 0x00, byte(len(macdata)), byte(mac1), byte(mac2), byte(mac3), byte(mac4), 0x00, 0x00}
+								sendms = append(sendms, Valuebyte2(numint)...)
+								sendms = append(sendms, macdata...)
+								sendms = append(sendms, yihuo(sendms))
+								send := []byte{0x7E}
+								for _, v := range sendms {
+									if v == 0x7E {
+										send = append(send, 0x7D, 0x02)
+									} else if v == 0x7D {
+										send = append(send, 0x7D, 0x01)
+									} else {
+										send = append(send, v)
+									}
+								}
+								send = append(send, 0x7E)
+								fmt.Println(time.Now(), "流水号", "平台发送报警信息湿度", fmt.Sprintf("% X", send))
+								c.WritePacket(NewPacket(3, send))
+
+							}
+						}
+					}
+				}
+			}
+
+		}
+	}
+}
+
+//平台远程控制设备（关机、重启）
+func ShutdownOrBoot(c *gotcp.Conn, msggatewayid string) {
+	//设置关机、重启
+	shutdown, _ := coldcloud.GetReverseControlShutDown("CTL" + msggatewayid)
+	if len(msggatewayid) >= 8 && len(shutdown.Serial) >= 8 && shutdown.ControlType != 0 {
+		if time.Now().Unix() > (shutdown.CreatTime.Unix() - 120) {
+			head := []byte{0xA0, 0x05, 0x00}
+			sendms := []byte{}
+			mac1, _ := strconv.ParseInt(msggatewayid[0:2], 16, 64)
+			mac2, _ := strconv.ParseInt(msggatewayid[2:4], 16, 64)
+			mac3, _ := strconv.ParseInt(msggatewayid[4:6], 16, 64)
+			mac4, _ := strconv.ParseInt(msggatewayid[6:8], 16, 64)
+			head = append(head, 0x05, byte(mac1), byte(mac2), byte(mac3), byte(mac4), 0x00, 0x00)
+			head = append(head, Valuebyte2(shutdown.ControlNumber)...)
+			mac1, _ = strconv.ParseInt(shutdown.Serial[0:2], 16, 64)
+			mac2, _ = strconv.ParseInt(shutdown.Serial[2:4], 16, 64)
+			mac3, _ = strconv.ParseInt(shutdown.Serial[4:6], 16, 64)
+			mac4, _ = strconv.ParseInt(shutdown.Serial[6:8], 16, 64)
+			sendms = append(sendms, byte(mac1), byte(mac2), byte(mac3), byte(mac4))
+			sendms = append(sendms, byte(shutdown.ControlType))
+			sendms = append(head, sendms...)
+			sendms = append(sendms, yihuo(sendms))
+			send := []byte{0x7E}
+			for _, v := range sendms {
+				if v == 0x7E {
+					send = append(send, 0x7D, 0x02)
+				} else if v == 0x7D {
+					send = append(send, 0x7D, 0x01)
+				} else {
+					send = append(send, v)
+				}
+			}
+			send = append(send, 0x7E)
+			fmt.Println("设置关机重启", fmt.Sprintf("% X", send))
+			c.WritePacket(NewPacket(3, send))
+			Apipost(Config.Send.Waterdrop.Service+"/devicestate/state?mainserial="+msggatewayid+"&controlnumber="+zksutils.ToStr(shutdown.ControlNumber)+"&requeststate=1&requesttime="+time.Now().Format("2006-01-02 15:04:05"), "PUT", nil)
+		}
+	}
+}
+
+//func ControlDevice(c *gotcp.Conn, command []byte) {
+//	fmt.Println("实时发送", len(Conns.m))
+//	Conns.Lock()
+//	for k, v := range Conns.m {
+//		if len(command) > 7 && k == fmt.Sprintf("%X", command[1:5]) {
+//			switch fmt.Sprintf("%X", command[5:7]) {
+//			case "A002":
+//				fmt.Println("设置设备参数进入", k)
+//				DParamSet(v, k)
+//			case "A003":
+//				fmt.Println("报警推送")
+//				ServiceToTriggerSingleMsg(v, k)
+//			case "A005":
+//				fmt.Println("远程控制设备")
+//			case "A00A":
+//				mac1, _ := strconv.ParseInt(k[0:2], 16, 64)
+//				mac2, _ := strconv.ParseInt(k[2:4], 16, 64)
+//				mac3, _ := strconv.ParseInt(k[4:6], 16, 64)
+//				mac4, _ := strconv.ParseInt(k[6:8], 16, 64)
+//				//ctlnum, _ := coldcloud.GetReverseControlCtlSNum("CTL" + k)
+//				//numint, _ := zksutils.StrTo(ctlnum).Int()
+//				sendms := []byte{0xA0, 0x0A, 0x00, 0x00, byte(mac1), byte(mac2), byte(mac3), byte(mac4), 0x00, 0x00, 0x00, 0x00}
+//				//sendms = append(sendms, Valuebyte2(numint)...)
+//				sendms = append(sendms, yihuo(sendms))
+//				send := []byte{0x7E}
+//				for _, v := range sendms {
+//					if v == 0x7E {
+//						send = append(send, 0X7D, 0X02)
+//					} else if v == 0x7D {
+//						send = append(send, 0X7D, 0X01)
+//					} else {
+//						send = append(send, v)
+//					}
+//				}
+//				send = append(send, 0x7E)
+//				err := v.WritePacket(NewPacket(3, send))
+//				fmt.Println(err, "远程升级", fmt.Sprintf("% X", send))
+//			}
+//		}
+//	}
+//	Conns.Unlock()
+//}
+func ControlDevice(c *gotcp.Conn, command []byte) {
+	if len(command) > 7 {
+		k := fmt.Sprintf("%X", command[1:5])
+		Conns.Lock()
+		if v, ok := Conns.m[k]; ok {
+			Conns.Unlock()
+			switch fmt.Sprintf("%X", command[5:7]) {
+			case "A002":
+				fmt.Println("设置设备参数进入", k)
+				DParamSet(v, k)
+			case "A003":
+				fmt.Println("报警推送")
+				ServiceToTriggerSingleMsg(v, k)
+			case "A005":
+				fmt.Println("远程控制设备")
+			case "A00A":
+				mac1, _ := strconv.ParseInt(k[0:2], 16, 64)
+				mac2, _ := strconv.ParseInt(k[2:4], 16, 64)
+				mac3, _ := strconv.ParseInt(k[4:6], 16, 64)
+				mac4, _ := strconv.ParseInt(k[6:8], 16, 64)
+				sendms := []byte{0xA0, 0x0A, 0x00, 0x00, byte(mac1), byte(mac2), byte(mac3), byte(mac4), 0x00, 0x00, 0x00, 0x00}
+				sendms = append(sendms, yihuo(sendms))
+				send := []byte{0x7E}
+				for _, v := range sendms {
+					if v == 0x7E {
+						send = append(send, 0x7D, 0x02)
+					} else if v == 0x7D {
+						send = append(send, 0x7D, 0x01)
+					} else {
+						send = append(send, v)
+					}
+				}
+				send = append(send, 0x7E)
+				err := v.WritePacket(NewPacket(3, send))
+				fmt.Println(err, "远程升级", fmt.Sprintf("% X", send))
+			}
+		} else {
+			Conns.Unlock()
+			fmt.Println("Key Not Found")
+		}
+	}
+}

src/zks.com/newbbfrontsocketv2/blackbox/writedata.go

@@ -0,0 +1,22 @@
+package blackbox
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/nsqio/go-nsq"
+)
+
+var Producernsq *nsq.Producer
+var Producernsqrequest *nsq.Producer
+var err error
+
+func Writedata_v2(data string) error {
+	bdata, err := json.Marshal(data)
+	Producernsqrequest.Publish(Config.Send.Nsqrequest.Topic, bdata)
+	err = Producernsq.Publish(Config.Send.Nsq.Topic, bdata)
+	if err != nil {
+		fmt.Println("nsq err", err)
+		return err
+	}
+	return nil
+}

src/zks.com/newbbfrontsocketv2/business/sensordata/sensordata.go

@@ -0,0 +1,18 @@
+package sensordata
+
+import (
+	"time"
+)
+
+type SensorData struct {
+	Id            int       `xorm:"not null pk autoincr INT(11)"`
+	IType         int       `xorm:"'itype'"`
+	TagId         string    `xorm:"'tagId'"`
+	Temperature   float64   `xorm:"'temperature'"`
+	Humidity      float64   `xorm:"'humidity'"`
+	BatteryLevel  float64   `xorm:"'batteryLevel'"`
+	RecordTime    time.Time `xorm:"'recordTime'"`
+	UploadTime    time.Time `xorm:"'uploadTime'"`
+	BatteryStatus int       `xorm:"'batteryStatus'"`
+	AlarmStatus   int       `xorm:"'alarmStatus'"`
+}

src/zks.com/newbbfrontsocketv2/business/sensordata/sensordataService.go

@@ -0,0 +1,16 @@
+package sensordata
+
+import (
+	"github.com/go-xorm/xorm"
+	. "zks.com/zUtils/db"
+)
+
+type SensorDataService struct {
+	ServiceBase
+}
+
+func GetSensorDataService(xormEngine *xorm.Engine) *SensorDataService {
+	s := new(SensorDataService)
+	s.DBE = xormEngine
+	return s
+}

src/zks.com/newbbfrontsocketv2/business/versionmanage/versionmanage.go

@@ -0,0 +1,25 @@
+package versionmanage
+
+import "time"
+
+type VersionManage struct {
+	Id             int       `xorm:"<- not null pk autoincr INT(10)"`
+	ProjectTag     int       `xorm:"INT(10)"`
+	ProjectName    string    `xorm:"VARCHAR(255)"`
+	VersionNum     int       `xorm:"INT(10)"`
+	VersionName    string    `xorm:"VARCHAR(255)"`
+	FileType       string    `xorm:"VARCHAR(255)"`
+	MainSerials    string    `xorm:"VARCHAR(255)"`
+	FileName       string    `xorm:"VARCHAR(255)"`
+	FilePath       string    `xorm:"VARCHAR(255)"`
+	FileLenNum     int       `xorm:"INT(11)"`
+	SizeNum        int       `xorm:"INT(11)"`
+	VersionDes     string    `xorm:"VARCHAR(255)"`
+	CreateOn       time.Time `xorm:"DATETIME created"`
+	CreateUserId   int       `xorm:"INT(11)"`
+	CreateBy       string    `xorm:"VARCHAR(50)"`
+	ModifiedUserId int       `xorm:"INT(11)"`
+	ModifiedBy     string    `xorm:"VARCHAR(255)"`
+	ModifiedOn     time.Time `xorm:"DATETIME updated"`
+	Remark         string    `xorm:"VARCHAR(255)"`
+}

src/zks.com/newbbfrontsocketv2/business/versionmanage/versionmanageService.go

@@ -0,0 +1,16 @@
+package versionmanage
+
+import (
+	"github.com/go-xorm/xorm"
+	. "zks.com/zUtils/db"
+)
+
+type VersionManageService struct {
+	ServiceBase
+}
+
+func GetVersionManageService(xormEngine *xorm.Engine) *VersionManageService {
+	s := new(VersionManageService)
+	s.DBE = xormEngine
+	return s
+}

src/zks.com/newbbfrontsocketv2/conf/app.conf

@@ -0,0 +1,15 @@
+[send]
+[send.redis]
+addr = "192.168.1.251:26379"
+poolnum = 50
+pwd = "Zks201812iot"
+[send.nsq]
+nsqdtcpaddr = "127.0.0.1:9150"
+topic = "blackfront"
+[send.nsqrequest]
+nsqdtcpaddr = "127.0.0.1:9150"
+topic = "blackfrontrequest"
+[send.waterdrop]
+service = "http://114.215.122.32:8089/v1"
+[service]
+ipandport = ""

src/zks.com/newbbfrontsocketv2/conf/port.txt

@@ -0,0 +1 @@
+12200

src/zks.com/newbbfrontsocketv2/main.go

@@ -0,0 +1,80 @@
+package main
+
+import (
+	"bufio"
+	"net"
+	"os"
+	"os/signal"
+	"runtime"
+	"syscall"
+	"time"
+
+	"github.com/nsqio/go-nsq"
+	"zks.com/gotcp"
+	service "zks.com/newbbfrontsocketv2/blackbox"
+	utils "zks.com/socketutils"
+	"zks.com/zUtils/redis"
+)
+
+var port string = "11100"
+
+func main() {
+	service.Config = service.ReadAppConfig("conf/app.conf")
+	//初始化缓存区
+	redis.InitRedisAuth(service.Config.Send.Redis.Poolnum, service.Config.Send.Redis.Addr, service.Config.Send.Redis.Pwd)
+	//redis.InitRedis(service.Config.Send.Redis.Poolnum, service.Config.Send.Redis.Addr)
+	//nsq
+	cfg := nsq.NewConfig()
+	service.Producernsq, _ = nsq.NewProducer(service.Config.Send.Nsq.Nsqdtcpaddr, cfg)
+	service.Producernsqrequest, _ = nsq.NewProducer(service.Config.Send.Nsqrequest.Nsqdtcpaddr, cfg)
+	initport()
+	//初始化日志设定
+	os.Mkdir("./runlog", os.ModePerm)
+	utils.SetLevel(utils.LevelInformational)
+	utils.SetLogger("file", `{"filename":"runlog/runlog.log"}`)
+	//启动服务
+	runtime.GOMAXPROCS(runtime.NumCPU())
+	tcpAddr, err := net.ResolveTCPAddr("tcp4", ":"+port)
+
+	utils.LogError(err)
+
+	listener, err := net.ListenTCP("tcp", tcpAddr)
+	utils.LogError(err)
+	utils.Informational("服务启动，端口:", port)
+
+	config := &gotcp.Config{
+		AcceptTimeout:          10 * 60 * time.Second,
+		ReadTimeout:            20 * 60 * time.Second,
+		WriteTimeout:           120 * time.Second,
+		MaxPacketLength:        20240,
+		SendPacketChanLimit:    50,
+		ReceivePacketChanLimit: 100,
+	}
+
+	//因未获取到此代码引用，故暂时使用其他方法
+	//delegate := &mos.MosConnDelegate{}
+	//protocol := &mos.MosProtocol{}
+	delegate := &service.BBoxConnDelegate{}
+	protocol := &service.BBoxProtocol{}
+	svr := gotcp.NewServer(config, delegate, protocol)
+	go svr.Start(listener)
+
+	//停止服务
+	ch := make(chan os.Signal)
+	signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
+	utils.Informational("Signal:", <-ch)
+
+	svr.Stop()
+}
+func initport() {
+	f, err := os.OpenFile("conf/port.txt", os.O_RDONLY, 0)
+	if err != nil {
+		panic(err)
+	}
+	defer f.Close()
+
+	br := bufio.NewReader(f)
+
+	//每次读取一行
+	port, _ = br.ReadString('\n')
+}

src/zks.com/socketutils/dbgutil/debug.go

@@ -0,0 +1,523 @@
+//from github.com/realint/dbgutil
+
+package dbgutil
+
+import (
+	"bytes"
+	"fmt"
+	"log"
+	"os"
+	"reflect"
+	"runtime"
+)
+
+var (
+	dunno     = []byte("???")
+	centerDot = []byte("·")
+	dot       = []byte(".")
+	lbr       = []byte("{")
+	lbrn      = []byte("{\n")
+	com       = []byte(",")
+	comn      = []byte(",\n")
+	rbr       = []byte("}")
+	comnrbr   = []byte(",\n}")
+)
+
+//
+// 变量打印时不格式化代码，（支持指针关系打印）
+//
+func Display(data ...interface{}) breaker {
+	return display(false, data...)
+}
+
+//
+// 变量打印时格式化代码（不支持指针关系打印）
+//
+func FormatDisplay(data ...interface{}) breaker {
+	return display(true, data...)
+}
+
+func display(formated bool, data ...interface{}) breaker {
+	var pc, file, line, ok = runtime.Caller(2)
+
+	if !ok {
+		return breaker{}
+	}
+
+	var buf = new(bytes.Buffer)
+
+	fmt.Fprintf(buf, "[Debug] at %s() [%s:%d]\n", function(pc), file, line)
+
+	fmt.Fprintf(buf, "\n[Variables]\n")
+
+	for i := 0; i < len(data); i += 2 {
+		var output = Print(len(data[i].(string))+3, !formated, formated, "    ", nil, data[i+1])
+
+		fmt.Fprintf(buf, "%s = %s", data[i], output)
+	}
+
+	log.Print(buf)
+
+	return breaker{}
+}
+
+type breaker struct {
+}
+
+//
+// 根据条件暂停程序并打印堆栈信息，回车后继续运行
+//
+func (this breaker) Break(condition bool) {
+	if condition {
+		fmt.Fprintf(os.Stderr, "\n[Stack]\n%s", Stack(2, ""))
+		fmt.Fprint(os.Stderr, "\npress ENTER to continue")
+		fmt.Scanln()
+	}
+}
+
+//
+// 暂停程序并打印堆栈信息，回车后继续运行
+//
+func Break() {
+	var pc, file, line, ok = runtime.Caller(1)
+
+	if !ok {
+		return
+	}
+
+	var buf = new(bytes.Buffer)
+
+	fmt.Fprintf(buf, "[Debug] at %s() [%s:%d]\n", function(pc), file, line)
+
+	fmt.Fprintf(buf, "\n[Stack]\n%s", Stack(2, ""))
+
+	fmt.Fprintf(buf, "\npress ENTER to continue")
+
+	log.Print(buf)
+
+	fmt.Scanln()
+}
+
+type pointerInfo struct {
+	prev *pointerInfo
+	n    int
+	addr uintptr
+	pos  int
+	used []int
+}
+
+//
+// 输出变量值
+//
+func Print(headlen int, printPointers, formatOutput bool, indent string, structFilter func(string, string) bool, data ...interface{}) []byte {
+	var buf = new(bytes.Buffer)
+
+	if len(data) > 1 {
+		fmt.Fprint(buf, indent)
+
+		fmt.Fprint(buf, "[")
+
+		if formatOutput {
+			fmt.Fprintln(buf)
+		}
+	}
+
+	for k, v := range data {
+		var buf2 = new(bytes.Buffer)
+		var pointers *pointerInfo
+		var interfaces []reflect.Value = make([]reflect.Value, 0, 10)
+
+		printKeyValue(buf2, reflect.ValueOf(v), &pointers, &interfaces, structFilter, formatOutput, indent, 1)
+
+		if k < len(data)-1 {
+			fmt.Fprint(buf2, ", ")
+		}
+
+		fmt.Fprintln(buf2)
+
+		if printPointers && pointers != nil {
+			printPointerInfo(buf2, headlen, pointers)
+		}
+
+		buf.Write(buf2.Bytes())
+	}
+
+	if len(data) > 1 {
+		if formatOutput {
+			fmt.Fprintln(buf)
+		}
+
+		fmt.Fprint(buf, indent)
+
+		fmt.Fprint(buf, "]")
+	}
+
+	return buf.Bytes()
+}
+
+func isSimpleType(val reflect.Value, kind reflect.Kind, pointers **pointerInfo, interfaces *[]reflect.Value) bool {
+	switch kind {
+	case reflect.Bool:
+		return true
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return true
+	case reflect.Uint8, reflect.Uint16, reflect.Uint, reflect.Uint32, reflect.Uint64:
+		return true
+	case reflect.Float32, reflect.Float64:
+		return true
+	case reflect.Complex64, reflect.Complex128:
+		return true
+	case reflect.String:
+		return true
+	case reflect.Chan:
+		return true
+	case reflect.Invalid:
+		return true
+	case reflect.Interface:
+		for _, in := range *interfaces {
+			if reflect.DeepEqual(in, val) {
+				return true
+			}
+		}
+		return false
+	case reflect.UnsafePointer:
+		if val.IsNil() {
+			return true
+		}
+
+		var elem = val.Elem()
+
+		if isSimpleType(elem, elem.Kind(), pointers, interfaces) {
+			return true
+		}
+
+		var addr = val.Elem().UnsafeAddr()
+
+		for p := *pointers; p != nil; p = p.prev {
+			if addr == p.addr {
+				return true
+			}
+		}
+
+		return false
+	}
+
+	return false
+}
+
+func printKeyValue(buf *bytes.Buffer, val reflect.Value, pointers **pointerInfo, interfaces *[]reflect.Value, structFilter func(string, string) bool, formatOutput bool, indent string, level int) {
+	var t = val.Kind()
+
+	switch t {
+	case reflect.Bool:
+		fmt.Fprint(buf, val.Bool())
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		fmt.Fprint(buf, val.Int())
+	case reflect.Uint8, reflect.Uint16, reflect.Uint, reflect.Uint32, reflect.Uint64:
+		fmt.Fprint(buf, val.Uint())
+	case reflect.Float32, reflect.Float64:
+		fmt.Fprint(buf, val.Float())
+	case reflect.Complex64, reflect.Complex128:
+		fmt.Fprint(buf, val.Complex())
+	case reflect.UnsafePointer:
+		fmt.Fprintf(buf, "unsafe.Pointer(0x%X)", val.Pointer())
+	case reflect.Ptr:
+		if val.IsNil() {
+			fmt.Fprint(buf, "nil")
+			return
+		}
+
+		var addr = val.Elem().UnsafeAddr()
+
+		for p := *pointers; p != nil; p = p.prev {
+			if addr == p.addr {
+				p.used = append(p.used, buf.Len())
+				fmt.Fprintf(buf, "0x%X", addr)
+				return
+			}
+		}
+
+		*pointers = &pointerInfo{
+			prev: *pointers,
+			addr: addr,
+			pos:  buf.Len(),
+			used: make([]int, 0),
+		}
+
+		fmt.Fprint(buf, "&")
+
+		printKeyValue(buf, val.Elem(), pointers, interfaces, structFilter, formatOutput, indent, level)
+	case reflect.String:
+		fmt.Fprint(buf, "\"", val.String(), "\"")
+	case reflect.Interface:
+		var value = val.Elem()
+
+		if !value.IsValid() {
+			fmt.Fprint(buf, "nil")
+		} else {
+			for _, in := range *interfaces {
+				if reflect.DeepEqual(in, val) {
+					fmt.Fprint(buf, "repeat")
+					return
+				}
+			}
+
+			*interfaces = append(*interfaces, val)
+
+			printKeyValue(buf, value, pointers, interfaces, structFilter, formatOutput, indent, level+1)
+		}
+	case reflect.Struct:
+		var t = val.Type()
+
+		fmt.Fprint(buf, t)
+		fmt.Fprint(buf, "{")
+
+		for i := 0; i < val.NumField(); i++ {
+			if formatOutput {
+				fmt.Fprintln(buf)
+			} else {
+				fmt.Fprint(buf, " ")
+			}
+
+			var name = t.Field(i).Name
+
+			if formatOutput {
+				for ind := 0; ind < level; ind++ {
+					fmt.Fprint(buf, indent)
+				}
+			}
+
+			fmt.Fprint(buf, name)
+			fmt.Fprint(buf, ": ")
+
+			if structFilter != nil && structFilter(t.String(), name) {
+				fmt.Fprint(buf, "ignore")
+			} else {
+				printKeyValue(buf, val.Field(i), pointers, interfaces, structFilter, formatOutput, indent, level+1)
+			}
+
+			fmt.Fprint(buf, ",")
+		}
+
+		if formatOutput {
+			fmt.Fprintln(buf)
+
+			for ind := 0; ind < level-1; ind++ {
+				fmt.Fprint(buf, indent)
+			}
+		} else {
+			fmt.Fprint(buf, " ")
+		}
+
+		fmt.Fprint(buf, "}")
+	case reflect.Array, reflect.Slice:
+		fmt.Fprint(buf, val.Type())
+		fmt.Fprint(buf, "{")
+
+		var allSimple = true
+
+		for i := 0; i < val.Len(); i++ {
+			var elem = val.Index(i)
+
+			var isSimple = isSimpleType(elem, elem.Kind(), pointers, interfaces)
+
+			if !isSimple {
+				allSimple = false
+			}
+
+			if formatOutput && !isSimple {
+				fmt.Fprintln(buf)
+			} else {
+				fmt.Fprint(buf, " ")
+			}
+
+			if formatOutput && !isSimple {
+				for ind := 0; ind < level; ind++ {
+					fmt.Fprint(buf, indent)
+				}
+			}
+
+			printKeyValue(buf, elem, pointers, interfaces, structFilter, formatOutput, indent, level+1)
+
+			if i != val.Len()-1 || !allSimple {
+				fmt.Fprint(buf, ",")
+			}
+		}
+
+		if formatOutput && !allSimple {
+			fmt.Fprintln(buf)
+
+			for ind := 0; ind < level-1; ind++ {
+				fmt.Fprint(buf, indent)
+			}
+		} else {
+			fmt.Fprint(buf, " ")
+		}
+
+		fmt.Fprint(buf, "}")
+	case reflect.Map:
+		var t = val.Type()
+		var keys = val.MapKeys()
+
+		fmt.Fprint(buf, t)
+		fmt.Fprint(buf, "{")
+
+		var allSimple = true
+
+		for i := 0; i < len(keys); i++ {
+			var elem = val.MapIndex(keys[i])
+
+			var isSimple = isSimpleType(elem, elem.Kind(), pointers, interfaces)
+
+			if !isSimple {
+				allSimple = false
+			}
+
+			if formatOutput && !isSimple {
+				fmt.Fprintln(buf)
+			} else {
+				fmt.Fprint(buf, " ")
+			}
+
+			if formatOutput && !isSimple {
+				for ind := 0; ind <= level; ind++ {
+					fmt.Fprint(buf, indent)
+				}
+			}
+
+			printKeyValue(buf, keys[i], pointers, interfaces, structFilter, formatOutput, indent, level+1)
+			fmt.Fprint(buf, ": ")
+			printKeyValue(buf, elem, pointers, interfaces, structFilter, formatOutput, indent, level+1)
+
+			if i != val.Len()-1 || !allSimple {
+				fmt.Fprint(buf, ",")
+			}
+		}
+
+		if formatOutput && !allSimple {
+			fmt.Fprintln(buf)
+
+			for ind := 0; ind < level-1; ind++ {
+				fmt.Fprint(buf, indent)
+			}
+		} else {
+			fmt.Fprint(buf, " ")
+		}
+
+		fmt.Fprint(buf, "}")
+	case reflect.Chan:
+		fmt.Fprint(buf, val.Type())
+	case reflect.Invalid:
+		fmt.Fprint(buf, "invalid")
+	default:
+		fmt.Fprint(buf, "unknow")
+	}
+}
+
+func printPointerInfo(buf *bytes.Buffer, headlen int, pointers *pointerInfo) {
+	var anyused = false
+	var pointerNum = 0
+
+	for p := pointers; p != nil; p = p.prev {
+		if len(p.used) > 0 {
+			anyused = true
+		}
+		pointerNum += 1
+		p.n = pointerNum
+	}
+
+	if anyused {
+		var pointerBufs = make([][]rune, pointerNum+1)
+
+		for i := 0; i < len(pointerBufs); i++ {
+			var pointerBuf = make([]rune, buf.Len()+headlen)
+
+			for j := 0; j < len(pointerBuf); j++ {
+				pointerBuf[j] = ' '
+			}
+
+			pointerBufs[i] = pointerBuf
+		}
+
+		for pn := 0; pn <= pointerNum; pn++ {
+			for p := pointers; p != nil; p = p.prev {
+				if len(p.used) > 0 && p.n >= pn {
+					if pn == p.n {
+						pointerBufs[pn][p.pos+headlen] = '└'
+
+						var maxpos = 0
+
+						for i, pos := range p.used {
+							if i < len(p.used)-1 {
+								pointerBufs[pn][pos+headlen] = '┴'
+							} else {
+								pointerBufs[pn][pos+headlen] = '┘'
+							}
+
+							maxpos = pos
+						}
+
+						for i := 0; i < maxpos-p.pos-1; i++ {
+							if pointerBufs[pn][i+p.pos+headlen+1] == ' ' {
+								pointerBufs[pn][i+p.pos+headlen+1] = '─'
+							}
+						}
+					} else {
+						pointerBufs[pn][p.pos+headlen] = '│'
+
+						for _, pos := range p.used {
+							if pointerBufs[pn][pos+headlen] == ' ' {
+								pointerBufs[pn][pos+headlen] = '│'
+							} else {
+								pointerBufs[pn][pos+headlen] = '┼'
+							}
+						}
+					}
+				}
+			}
+
+			buf.WriteString(string(pointerBufs[pn]) + "\n")
+		}
+	}
+}
+
+//
+// 获取堆栈信息（从系统自带的debug模块中提取代码改造的）
+//
+func Stack(skip int, indent string) []byte {
+	var buf = new(bytes.Buffer)
+
+	for i := skip; ; i++ {
+		var pc, file, line, ok = runtime.Caller(i)
+
+		if !ok {
+			break
+		}
+
+		buf.WriteString(indent)
+
+		fmt.Fprintf(buf, "at %s() [%s:%d]\n", function(pc), file, line)
+	}
+
+	return buf.Bytes()
+}
+
+// function returns, if possible, the name of the function containing the PC.
+func function(pc uintptr) []byte {
+	fn := runtime.FuncForPC(pc)
+	if fn == nil {
+		return dunno
+	}
+	name := []byte(fn.Name())
+	// The name includes the path name to the package, which is unnecessary
+	// since the file name is already included.  Plus, it has center dots.
+	// That is, we see
+	//	runtime/debug.*T·ptrmethod
+	// and want
+	//	*T.ptrmethod
+	if period := bytes.Index(name, dot); period >= 0 {
+		name = name[period+1:]
+	}
+	name = bytes.Replace(name, centerDot, dot, -1)
+	return name
+}

src/zks.com/socketutils/log.go

@@ -0,0 +1,127 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package socketutils
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/astaxie/beego/logs"
+)
+
+// Log levels to control the logging output.
+const (
+	LevelEmergency = iota
+	LevelAlert
+	LevelCritical
+	LevelError
+	LevelWarning
+	LevelNotice
+	LevelInformational
+	LevelDebug
+)
+
+func init() {
+	// init BeeLogger
+	BeeLogger = logs.NewLogger(10000)
+	err := BeeLogger.SetLogger("console", "")
+	if err != nil {
+		fmt.Println("init console log error:", err)
+	}
+}
+
+// SetLogLevel sets the global log level used by the simple
+// logger.
+func SetLevel(l int) {
+	BeeLogger.SetLevel(l)
+}
+
+func SetLogFuncCall(b bool) {
+	BeeLogger.EnableFuncCallDepth(b)
+	BeeLogger.SetLogFuncCallDepth(3)
+}
+
+// logger references the used application logger.
+var BeeLogger *logs.BeeLogger
+
+// SetLogger sets a new logger.
+func SetLogger(adaptername string, config string) error {
+	err := BeeLogger.SetLogger(adaptername, config)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func Emergency(v ...interface{}) {
+	BeeLogger.Emergency(generateFmtStr(len(v)), v...)
+}
+
+func Alert(v ...interface{}) {
+	BeeLogger.Alert(generateFmtStr(len(v)), v...)
+}
+
+// Critical logs a message at critical level.
+func Critical(v ...interface{}) {
+	BeeLogger.Critical(generateFmtStr(len(v)), v...)
+}
+
+// Error logs a message at error level.
+func Error(v ...interface{}) {
+	BeeLogger.Error(generateFmtStr(len(v)), v...)
+}
+
+// Warning logs a message at warning level.
+func Warning(v ...interface{}) {
+	BeeLogger.Warning(generateFmtStr(len(v)), v...)
+}
+
+//// Deprecated: compatibility alias for Warning(), Will be removed in 1.5.0.
+//func Warn(v ...interface{}) {
+//	Warning(v...)
+//}
+
+func Notice(v ...interface{}) {
+	BeeLogger.Notice(generateFmtStr(len(v)), v...)
+}
+
+// Info logs a message at info level.
+func Informational(v ...interface{}) {
+	BeeLogger.Informational(generateFmtStr(len(v)), v...)
+}
+
+func InformationalWithFormat(format string, v ...interface{}) {
+	BeeLogger.Informational(format, v...)
+}
+
+//// Deprecated: compatibility alias for Warning(), Will be removed in 1.5.0.
+//func Info(v ...interface{}) {
+//	Informational(v...)
+//}
+
+// Debug logs a message at debug level.
+func Debug(v ...interface{}) {
+	BeeLogger.Debug(generateFmtStr(len(v)), v...)
+}
+
+//// Trace logs a message at trace level.
+//// Deprecated: compatibility alias for Warning(), Will be removed in 1.5.0.
+//func Trace(v ...interface{}) {
+//	BeeLogger.Trace(generateFmtStr(len(v)), v...)
+//}
+
+func generateFmtStr(n int) string {
+	return strings.Repeat("%v ", n)
+}

src/zks.com/socketutils/nsqlog.go

@@ -0,0 +1,22 @@
+package socketutils
+
+import (
+	"os"
+)
+
+type Logger struct {
+}
+
+func NewLogger(filename string) *Logger {
+	//初始化日志设定
+	os.Mkdir("./log", os.ModePerm)
+	SetLevel(LevelInformational)
+	SetLogger("file", `{"filename":"log/`+filename+`"}`)
+
+	return &Logger{}
+}
+
+func (l *Logger) Output(calldepth int, s string) error {
+	Informational(calldepth, s)
+	return nil
+}

src/zks.com/socketutils/stringConv.go

@@ -0,0 +1,223 @@
+package socketutils
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"time"
+)
+
+var DefaultTimeLoc = time.Local
+
+// 转换字符串到其他类型
+
+type StrTo string
+
+func (f *StrTo) Set(v string) {
+	if v != "" {
+		*f = StrTo(v)
+	} else {
+		f.Clear()
+	}
+}
+
+func (f *StrTo) Clear() {
+	*f = StrTo(0x1E)
+}
+
+func (f StrTo) Exist() bool {
+	return string(f) != string(0x1E)
+}
+
+func (f StrTo) Bool() (bool, error) {
+	return strconv.ParseBool(f.String())
+}
+
+func (f StrTo) Float32() (float32, error) {
+	v, err := strconv.ParseFloat(f.String(), 32)
+	return float32(v), err
+}
+
+func (f StrTo) Float64() (float64, error) {
+	return strconv.ParseFloat(f.String(), 64)
+}
+
+func (f StrTo) Int() (int, error) {
+	v, err := strconv.ParseInt(f.String(), 10, 32)
+	return int(v), err
+}
+
+func (f StrTo) Int8() (int8, error) {
+	v, err := strconv.ParseInt(f.String(), 10, 8)
+	return int8(v), err
+}
+
+func (f StrTo) Int16() (int16, error) {
+	v, err := strconv.ParseInt(f.String(), 10, 16)
+	return int16(v), err
+}
+
+func (f StrTo) Int32() (int32, error) {
+	v, err := strconv.ParseInt(f.String(), 10, 32)
+	return int32(v), err
+}
+
+func (f StrTo) Int64() (int64, error) {
+	v, err := strconv.ParseInt(f.String(), 10, 64)
+	return int64(v), err
+}
+
+func (f StrTo) Uint() (uint, error) {
+	v, err := strconv.ParseUint(f.String(), 10, 32)
+	return uint(v), err
+}
+
+func (f StrTo) Uint8() (uint8, error) {
+	v, err := strconv.ParseUint(f.String(), 10, 8)
+	return uint8(v), err
+}
+
+func (f StrTo) Uint16() (uint16, error) {
+	v, err := strconv.ParseUint(f.String(), 10, 16)
+	return uint16(v), err
+}
+
+func (f StrTo) Uint32() (uint32, error) {
+	v, err := strconv.ParseUint(f.String(), 10, 32)
+	return uint32(v), err
+}
+
+func (f StrTo) Uint64() (uint64, error) {
+	v, err := strconv.ParseUint(f.String(), 10, 64)
+	return uint64(v), err
+}
+
+func (f StrTo) String() string {
+	if f.Exist() {
+		return string(f)
+	}
+	return ""
+}
+
+// 转换其他类型到字符串
+func ToStr(value interface{}, args ...int) (s string) {
+	switch v := value.(type) {
+	case bool:
+		s = strconv.FormatBool(v)
+	case float32:
+		s = strconv.FormatFloat(float64(v), 'f', argInt(args).Get(0, -1), argInt(args).Get(1, 32))
+	case float64:
+		s = strconv.FormatFloat(v, 'f', argInt(args).Get(0, -1), argInt(args).Get(1, 64))
+	case int:
+		s = strconv.FormatInt(int64(v), argInt(args).Get(0, 10))
+	case int8:
+		s = strconv.FormatInt(int64(v), argInt(args).Get(0, 10))
+	case int16:
+		s = strconv.FormatInt(int64(v), argInt(args).Get(0, 10))
+	case int32:
+		s = strconv.FormatInt(int64(v), argInt(args).Get(0, 10))
+	case int64:
+		s = strconv.FormatInt(v, argInt(args).Get(0, 10))
+	case uint:
+		s = strconv.FormatUint(uint64(v), argInt(args).Get(0, 10))
+	case uint8:
+		s = strconv.FormatUint(uint64(v), argInt(args).Get(0, 10))
+	case uint16:
+		s = strconv.FormatUint(uint64(v), argInt(args).Get(0, 10))
+	case uint32:
+		s = strconv.FormatUint(uint64(v), argInt(args).Get(0, 10))
+	case uint64:
+		s = strconv.FormatUint(v, argInt(args).Get(0, 10))
+	case string:
+		s = v
+	case []byte:
+		s = string(v)
+	default:
+		s = fmt.Sprintf("%v", v)
+	}
+	return s
+}
+
+// convert any numeric value to int64
+func ToInt64(value interface{}) (d int64) {
+	val := reflect.ValueOf(value)
+	switch value.(type) {
+	case int, int8, int16, int32, int64:
+		d = val.Int()
+	case uint, uint8, uint16, uint32, uint64:
+		d = int64(val.Uint())
+	default:
+		panic(fmt.Errorf("ToInt64 need numeric not `%T`", value))
+	}
+	return
+}
+
+//参数列表取值常用
+type argString []string
+
+func (a argString) Get(i int, args ...string) (r string) {
+	if i >= 0 && i < len(a) {
+		r = a[i]
+	} else if len(args) > 0 {
+		r = args[0]
+	}
+	return
+}
+
+type argInt []int
+
+func (a argInt) Get(i int, args ...int) (r int) {
+	if i >= 0 && i < len(a) {
+		r = a[i]
+	}
+	if len(args) > 0 {
+		r = args[0]
+	}
+	return
+}
+
+type argAny []interface{}
+
+func (a argAny) Get(i int, args ...interface{}) (r interface{}) {
+	if i >= 0 && i < len(a) {
+		r = a[i]
+	}
+	if len(args) > 0 {
+		r = args[0]
+	}
+	return
+}
+
+// 把字符串转换为time.Time对象
+func Str2DateTime(timeStr string) (timeObj time.Time, err error) {
+	format := "2006-01-02 15:04:05"
+	timeObj, err = time.Parse(format, timeStr)
+	//Check(err)
+	return
+}
+
+func Str2Date(timeStr string) (timeObj time.Time, err error) {
+	format := "2006-01-02"
+	timeObj, err = time.Parse(format, timeStr)
+	//Check(err)
+	return
+}
+
+func TimeParse(dateString, format string) (time.Time, error) {
+	tp, err := time.ParseInLocation(format, dateString, DefaultTimeLoc)
+	return tp, err
+}
+
+func TimeFormat(t time.Time, format string) string {
+	return t.Format(format)
+}
+
+func indirectType(v reflect.Type) reflect.Type {
+	switch v.Kind() {
+	case reflect.Ptr:
+		return indirectType(v.Elem())
+	default:
+		return v
+	}
+	return v
+}

src/zks.com/socketutils/utils.go

@@ -0,0 +1,43 @@
+// Copyright 2014 zks
+//
+
+package socketutils
+
+import (
+	"fmt"
+	//"strings"
+	"os"
+
+	"github.com/Unknwon/com"
+	"github.com/Unknwon/goconfig"
+)
+
+var Cfg *goconfig.ConfigFile
+
+// LoadConfig loads configuration file.
+func LoadConfig(cfgPath string) {
+	if !com.IsExist(cfgPath) {
+		os.Create(cfgPath)
+	}
+
+	var err error
+	Cfg, err = goconfig.LoadConfigFile(cfgPath)
+	if err == nil {
+		Informational("Initialize app.ini")
+	} else {
+		fmt.Println(err)
+		os.Exit(2)
+	}
+
+}
+
+// SaveConfig saves configuration file.
+func SaveConfig(cfgPath string) error {
+	return goconfig.SaveConfigFile(Cfg, cfgPath)
+}
+
+func LogError(err error) {
+	if err != nil {
+		Critical(err.Error())
+	}
+}