Example #1
0
func main() {
	var addr string

	flag.StringVar(&addr, "addr", "127.0.0.1:10010", "echo server address")
	flag.Parse()

	session, err := link.Connect("tcp://"+addr, link.Packet(link.Uint16BE), link.String())
	if err != nil {
		panic(err)
	}

	go func() {
		var msg string
		for {
			if err := session.Receive(&msg); err != nil {
				break
			}
			fmt.Printf("%s\n", msg)
		}
	}()

	for {
		var msg string
		if _, err := fmt.Scanf("%s\n", &msg); err != nil {
			break
		}
		if err = session.Send(msg); err != nil {
			break
		}
	}

	session.Close()
	println("bye")
}
Example #2
0
func main() {
	var addr string

	flag.StringVar(&addr, "addr", ":10010", "echo server address")
	flag.Parse()

	server, err := link.Serve("tcp", addr, link.Packet(2, 1024*1024, 1024, binary.LittleEndian, TestCodec{}))
	if err != nil {
		panic(err)
	}

	println("server start:", server.Listener().Addr().String())
	for {
		session, err := server.Accept()
		if err != nil {
			break
		}
		go func() {
			//addr := session.Conn().RemoteAddr().String()
			//println("client", addr, "connected")
			for {
				var msg []byte
				if err = session.Receive(&msg); err != nil {
					break
				}
				if err = session.Send(msg); err != nil {
					break
				}
			}
			//println("client", addr, "closed")
		}()
	}
}
Example #3
0
func main() {
	var addr string

	flag.StringVar(&addr, "addr", "127.0.0.1:10010", "echo server address")
	flag.Parse()

	session, err := link.Connect("tcp", addr, link.Packet(2, 1024*1024, 1024, binary.LittleEndian, TestCodec{}))
	if err != nil {
		panic(err)
	}

	go func() {
		var msg string
		for {
			if err := session.Receive(&msg); err != nil {
				break
			}
			fmt.Printf("%s\n", msg)
		}
	}()

	for {
		var msg string
		if _, err := fmt.Scanf("%s\n", &msg); err != nil {
			break
		}
		if err = session.Send(msg); err != nil {
			break
		}
	}

	session.Close()
	println("bye")
}
Example #4
0
func Test_Simple(t *testing.T) {
	backend, err := StartEchoBackend()
	unitest.NotError(t, err)

	gateway := StartTestGateway(t, backend.Listener().Addr().String())
	gatewayAddr := gateway.server.Listener().Addr().String()

	client, err := link.Connect("tcp://"+gatewayAddr, link.Packet(link.Uint16BE), link.Bytes())
	unitest.NotError(t, err)

	for i := 0; i < 10000; i++ {
		msg1 := RandBytes(1024)
		err1 := client.Send(msg1)
		unitest.NotError(t, err1)

		var msg2 []byte
		err2 := client.Receive(&msg2)
		unitest.NotError(t, err2)

		if bytes.Equal(msg1, msg2) == false {
			t.Log(i, msg1, msg2)
			t.Fail()
		}
		unitest.Pass(t, bytes.Equal(msg1, msg2))
	}
	client.Close()

	gateway.Stop()
	backend.Stop()

	time.Sleep(time.Second * 2)
	MakeSureSessionGoroutineExit(t)
}
Example #5
0
// This is an benchmark tool work with the echo_server.
//
// Start echo_server with 'bench' flag
//     go run echo_server.go -bench
//
// Start benchmark with echo_server address
//     go run echo_benchmark.go
//     go run echo_benchmark.go -num=100
//     go run echo_benchmark.go -size=1024
//     go run echo_benchmark.go -time=20
//     go run echo_benchmark.go -addr="127.0.0.1:10010"
func main() {
	flag.Parse()

	if MultiProcess() {
		return
	}

	var (
		msg       = make([]byte, *messageSize)
		timeout   = time.Now().Add(time.Second * time.Duration(*runTime))
		initWait  = new(sync.WaitGroup)
		startChan = make(chan int)
		conns     = make([]*CountConn, 0, *clientNum)
	)

	var codecType link.CodecType

	if *pro {
		pool := binary.NewBufferPool(2, 1, 32)
		codecType = link.PacketPro(2, *messageSize, *messageSize*2, link.LittleEndian, pool, TestCodec{})
	} else {
		codecType = link.Packet(2, *messageSize, *messageSize*2, link.LittleEndian, TestCodec{})
	}

	for i := 0; i < *clientNum; i++ {
		conn, err := net.DialTimeout("tcp", *serverAddr, time.Second*3)
		if err != nil {
			panic(err)
		}

		countConn := &CountConn{Conn: conn}
		conns = append(conns, countConn)

		initWait.Add(2)
		go client(initWait, countConn, startChan, timeout, msg, codecType)
	}
	initWait.Wait()
	close(startChan)

	time.Sleep(time.Second * time.Duration(*runTime))
	var sum CountConn
	for i := 0; i < *clientNum; i++ {
		conn := conns[i]
		conn.Conn.Close()
		sum.SendCount += conn.SendCount
		sum.RecvCount += conn.RecvCount
		sum.ReadCount += conn.ReadCount
		sum.WriteCount += conn.WriteCount
	}
	fmt.Printf(OutputFormat, sum.SendCount, sum.RecvCount, sum.ReadCount, sum.WriteCount)
}
Example #6
0
// This is broadcast server demo work with the echo_client.
// usage:
//     cd src/github.com/funny/link
//     go generate channel.go
//     go run example/echo/broadcast.go
func main() {
	var addr string

	flag.StringVar(&addr, "addr", ":10010", "echo server address")
	flag.Parse()

	server, err := link.Serve("tcp", addr, link.Async(1024, link.Packet(2, 1024*1024, 1024, binary.LittleEndian, TestCodec{})))
	if err != nil {
		panic(err)
	}
	println("server start:", server.Listener().Addr().String())

	channel := link.NewUint64Channel()
	go func() {
		for range time.Tick(time.Second * 2) {
			now := "from channel: " + time.Now().Format("2006-01-02 15:04:05")
			channel.Fetch(func(session *link.Session) {
				session.Send(now)
			})
		}
	}()

	for {
		session, err := server.Accept()
		if err != nil {
			break
		}

		go func() {
			addr := session.Conn().RemoteAddr().String()
			println("client", addr, "connected")

			channel.Put(session.Id(), session)

			for {
				var msg string
				if err := session.Receive(&msg); err != nil {
					break
				}
				println(addr, "say:", msg)
				channel.Fetch(func(session *link.Session) {
					session.Send("from " + addr + ": " + string(msg))
				})
			}

			println("client", addr, "closed")
			channel.Remove(session.Id())
		}()
	}
}
Example #7
0
func client(initWait *sync.WaitGroup, conn *CountConn, startChan chan int, timeout time.Time, msg []byte) {
	pConn, _ := link.Packet(link.Uint16BE).NewClientConn(conn)
	client := link.NewSession(pConn, link.Bytes())

	var wg sync.WaitGroup

	wg.Add(1)
	go func() {
		defer wg.Done()
		initWait.Done()
		<-startChan

		for {
			outMsg := msg
			if *randsize {
				outMsg = make([]byte, rand.Intn(*messageSize))
			}
			if err := client.Send(outMsg); err != nil {
				if timeout.After(time.Now()) {
					println("send error:", err.Error())
				}
				break
			}
			atomic.AddUint32(&conn.SendCount, 1)
		}
	}()

	wg.Add(1)
	go func() {
		defer wg.Done()
		initWait.Done()
		<-startChan

		var inMsg []byte
		for {
			if err := client.Receive(&inMsg); err != nil {
				if timeout.After(time.Now()) {
					println("recv error:", err.Error())
				}
				break
			}
			atomic.AddUint32(&conn.RecvCount, 1)
		}
	}()

	wg.Wait()
}
Example #8
0
func client(initWait *sync.WaitGroup, conn *CountConn, startChan chan int, timeout time.Time, msg []byte) {
	client := link.NewSession(conn, link.Packet(2, *messageSize, 4096, binary.LittleEndian, TestCodec{}))

	var wg sync.WaitGroup

	wg.Add(1)
	go func() {
		defer wg.Done()
		initWait.Done()
		<-startChan

		for {
			outMsg := msg
			if *randsize {
				outMsg = msg[:rand.Intn(*messageSize)]
			}
			if err := client.Send(outMsg); err != nil {
				if timeout.After(time.Now()) {
					println("send error:", err.Error())
				}
				break
			}
			atomic.AddUint32(&conn.SendCount, 1)
		}
	}()

	wg.Add(1)
	go func() {
		defer wg.Done()
		initWait.Done()
		<-startChan

		var inMsg []byte
		for {
			if err := client.Receive(&inMsg); err != nil {
				if timeout.After(time.Now()) {
					println("recv error:", err.Error())
				}
				break
			}
			atomic.AddUint32(&conn.RecvCount, 1)
		}
	}()

	wg.Wait()
}
Example #9
0
func StartTestGateway(t *testing.T, backendAddr string) *Frontend {
	listener, err := link.ListenPacket("tcp://0.0.0.0:0", link.Packet(link.Uint16BE))
	unitest.NotError(t, err)

	var linkIds []uint64

	gateway := NewFrontend(listener, func(_ *link.Session) (uint64, error) {
		return linkIds[rand.Intn(len(linkIds))], nil
	})

	for i := 0; i < 1; i++ {
		id, err := gateway.AddBackend("tcp://"+backendAddr, link.Stream())
		unitest.NotError(t, err)
		linkIds = append(linkIds, id)
	}

	return gateway
}
Example #10
0
func main() {
	var addr string
	var pro bool

	flag.StringVar(&addr, "addr", ":10010", "echo server address")
	flag.BoolVar(&pro, "pro", true, "use PacketPro()")
	flag.Parse()

	var codecType link.CodecType

	if pro {
		pool := binary.NewBufferPool(2, 1, 32)
		codecType = link.PacketPro(2, 1024*1024, 1024, link.LittleEndian, pool, TestCodec{})
	} else {
		codecType = link.Packet(2, 1024*1024, 1024, link.LittleEndian, TestCodec{})
	}

	server, err := link.Serve("tcp", addr, codecType)
	if err != nil {
		panic(err)
	}

	println("server start:", server.Listener().Addr().String())
	for {
		session, err := server.Accept()
		if err != nil {
			break
		}
		go func() {
			//addr := session.Conn().RemoteAddr().String()
			//println("client", addr, "connected")
			for {
				var msg []byte
				if err = session.Receive(&msg); err != nil {
					break
				}
				if err = session.Send(msg); err != nil {
					break
				}
			}
			//println("client", addr, "closed")
		}()
	}
}
Example #11
0
// This is broadcast server demo work with the echo_client.
// usage:
//     go run echo_broadcast.go
func main() {
	var addr string

	flag.StringVar(&addr, "addr", ":10010", "echo server address")
	flag.Parse()

	server, err := link.Serve("tcp://"+addr, link.Packet(link.Uint16BE), link.String())
	if err != nil {
		panic(err)
	}
	println("server start:", server.Listener().Addr().String())

	channel := link.NewChannel()
	go func() {
		for range time.Tick(time.Second * 2) {
			now := time.Now().Format("2006-01-02 15:04:05")
			channel.Broadcast("from channel: " + now)
		}
	}()

	server.Loop(func(session *link.Session) {
		addr := session.Conn().RemoteAddr().String()
		println("client", addr, "connected")

		session.EnableAsyncSend(1024)
		channel.Join(session)

		for {
			var msg string
			if err := session.Receive(&msg); err != nil {
				break
			}
			println(addr, "say:", msg)
			channel.Broadcast("from " + addr + ": " + string(msg))
		}

		println("client", addr, "closed")
		channel.Exit(session)
	})
}
Example #12
0
func Test_Broadcast(t *testing.T) {
	var (
		clientNum     = 20
		packetNum     = 2000
		channel       = NewChannel(link.Bytes())
		broadcastMsg  []byte
		broadcastWait sync.WaitGroup
		clientWait    sync.WaitGroup
	)

	backend, err := link.Serve("tcp://0.0.0.0:0", NewBackend(), link.Bytes())
	unitest.NotError(t, err)

	go backend.Loop(func(session *link.Session) {
		channel.Join(session)
		clientWait.Done()
		for {
			var msg []byte
			if err := session.Receive(&msg); err != nil {
				break
			}
			unitest.Pass(t, bytes.Equal(msg, broadcastMsg))
			broadcastWait.Done()
		}
	})

	clientWait.Add(clientNum)
	go func() {
		clientWait.Wait()
		for i := 0; i < packetNum; i++ {
			broadcastMsg = RandBytes(1024)
			channel.Broadcast(broadcastMsg)
			broadcastWait.Add(clientNum)
			broadcastWait.Wait()
		}
	}()

	gateway := StartTestGateway(t, backend.Listener().Addr().String())
	gatewayAddr := gateway.server.Listener().Addr().String()

	var wg sync.WaitGroup
	for i := 0; i < clientNum; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()

			client, err := link.Connect("tcp://"+gatewayAddr, link.Packet(link.Uint16BE), link.Bytes())
			unitest.NotError(t, err)

			for j := 0; j < packetNum; j++ {
				var msg []byte
				err := client.Receive(&msg)
				unitest.NotError(t, err)

				err = client.Send(msg)
				unitest.NotError(t, err)
			}

			client.Close()
		}()
	}
	wg.Wait()

	gateway.Stop()
	backend.Stop()

	time.Sleep(time.Second * 2)
	MakeSureSessionGoroutineExit(t)
}
Example #13
0
package global

import (
	//	"runtime"
	"github.com/funny/link"
	. "tools"
	"tools/codecType"
	"tools/dispatch"
	"tools/gc"
)

var (
	PackCodecType_UnSafe link.CodecType = link.Packet(4, 1024*1024, 4096, link.LittleEndian, codecType.NetCodecType{})
	PackCodecType_Safe   link.CodecType = link.ThreadSafe(PackCodecType_UnSafe)
	PackCodecType_Async  link.CodecType = link.Async(4096, PackCodecType_UnSafe)
)

//服务器启动
func Startup(serverName string, logFile string, stopServerFunc func()) {
	//	runtime.GOMAXPROCS(runtime.NumCPU())

	// 开启Log记录
	SetLogFile(logFile)
	SetLogPrefix(serverName)

	// 信号量监听
	go SignalProc(stopServerFunc)

	// 开启GC及系统环境信息监测
	gc.SysRoutine()
Example #14
0
	"strconv"
	"sync"
	"testing"
	"time"
	"tools/codecType"
)

import (
	proto "code.google.com/p/goprotobuf/proto"
	"protos/gameProto"
	. "tools"
	"tools/cfg"
	"tools/unitest"
)

var protocol = link.Packet(4, 1024*1024, 4096, link.LittleEndian, codecType.NetCodecType{})

func Test_gateway(t *testing.T) {
	DEBUG("消息通信测试")
	var wg sync.WaitGroup
	var successNum uint32
	for i := 0; i < 3000; i++ {
		wg.Add(1)
		go func(flag int) {
			//			if flag != 0 && random.RandomInt31n(100) < 50 {
			//				flag -= 1
			//			}
			defer wg.Done()

			var count uint32 = 0
			var userName string = "User" + strconv.Itoa(flag)