func StreamTest(t *testing.T, callback func(*link.Session)) { protocol := New(1024, 1024, 1024) server, err := link.Serve("tcp", "0.0.0.0:0", protocol) unitest.NotError(t, err) addr := server.Listener().Addr().String() go server.Serve(func(session *link.Session) { for { var msg TestMessage if err := session.Receive(&msg); err != nil { break } if err := session.Send(msg); err != nil { break } } }) session, err := link.Connect("tcp", addr, protocol) unitest.NotError(t, err) callback(session) session.Close() server.Stop() MakeSureSessionGoroutineExit(t) }
func PacketTest(t *testing.T, callback func(*link.Session)) { protocol := New(binary.SplitByUvarint, 1024, 1024, 1024) server, err := link.Serve("tcp", "0.0.0.0:0", protocol) unitest.NotError(t, err) go server.Serve(func(session *link.Session) { for { var msg RAW if err := session.Receive(&msg); err != nil { break } if err := session.Send(msg); err != nil { break } } }) session, err := link.Connect("tcp", server.Listener().Addr().String(), protocol) unitest.NotError(t, err) callback(session) session.Close() server.Stop() MakeSureSessionGoroutineExit(t) }
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") }() } }
func main() { flag.Parse() server, err := link.Serve("tcp", *addr, packet.New( binary.SplitByUint16BE, 1024, 1024, 1024, )) if err != nil { panic(err) } println("server start:", server.Listener().Addr().String()) server.Serve(func(session *link.Session) { addr := session.Conn().RemoteAddr().String() log(addr, "connected") for { var msg packet.RAW if err := session.Receive(&msg); err != nil { break } log(addr, "say:", string(msg)) if err = session.Send(msg); err != nil { break } } log(addr, "closed") }) }
func startLocalServer() { //连接DB db.Init() //连接Redis redisProxyErr := redisProxy.InitClient(cfg.GetValue("redis_ip"), cfg.GetValue("redis_port")) checkError(redisProxyErr) listener, err := link.Serve("tcp", "0.0.0.0:"+local_port, packet.New( binary.SplitByUint32BE, 1024, 1024, 1024, )) checkError(err) listener.Serve(func(session *link.Session) { session.AddCloseCallback(session, func() { session.Close() }) global.AddSession(session) var msg packet.RAW for { if err := session.Receive(&msg); err != nil { break } module.ReceiveMessage(session, msg) } }) }
func StartTestBackend(t *testing.T, handler func(*link.Session)) *link.Server { backend, err := link.Serve("tcp", "0.0.0.0:0", NewBackend( 1024, 1024, 1024, )) unitest.NotError(t, err) go backend.Serve(handler) return backend }
func main() { var addr string flag.StringVar(&addr, "addr", ":10010", "echo server address") flag.Parse() server, err := link.Serve("tcp://"+addr, link.Stream(), nil) if err != nil { panic(err) } println("server start:", server.Listener().Addr().String()) server.Loop(link.Echo) }
// 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()) }() } }
// 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.String(link.Uint16BE)) 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) } }() for { session, err := server.Accept() if err != nil { break } go func() { 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) }() } }
//初始化 func InitServer(port string) error { servers = make(map[string]*link.Session) asyncMsgs = list.New() db.Init() startSysDB() createRevGoroutines() listener, err := link.Serve("tcp", "0.0.0.0:"+port, packet.New( binary.SplitByUint32BE, 1024, 1024, 1024, )) if err != nil { return err } listener.Serve(func(session *link.Session) { for { var msg packet.RAW if err := session.Receive(&msg); err != nil { break } msgID := binary.GetUint16LE(msg[:2]) if systemProto.IsValidID(msgID) { //系统消息 dealReceiveSystemMsgC2S(session, msg) } else if dbProto.IsValidAsyncID(msgID) { //异步DB消息 asyncMsgs.PushBack(msg) } else { //同步DB消息 useObj := revSyncMsgGoroutines[revSyncMsgGoroutineIndex] useObj.revMsgChan <- goroutineMsg{msg, session} revSyncMsgGoroutineIndex++ if revSyncMsgGoroutineIndex == revSyncMsgGoroutineNum { revSyncMsgGoroutineIndex = 0 } } } }) return nil }
func StartEchoBackend() (*link.Server, error) { backend, err := link.Serve("tcp://0.0.0.0:0", NewBackend(), link.Bytes()) if err != nil { return nil, err } go backend.Loop(func(session *link.Session) { var msg []byte for { if err := session.Receive(&msg); err != nil { break } if err := session.Send(msg); err != nil { break } } }) return backend, nil }
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") }() } }
func main() { var addr string flag.StringVar(&addr, "addr", ":10010", "echo server address") flag.Parse() server, err := link.Serve("tcp", addr, codec.Bytes(codec.Uint16BE)) if err != nil { panic(err) } println("server start:", server.Listener().Addr().String()) for { session, err := server.Accept() if err != nil { break } go io.Copy(session.Conn(), session.Conn()) } }
func main() { funnk() go tcp_test() go func() { var addr string flag.StringVar(&addr, "addr", ":10010", "echo server address") flag.Parse() fmt.Println("addr:", addr) server, err := link.Serve("tcp", addr, codec.Bytes(codec.Uint16BE)) if err != nil { panic(err) } println("server start:", server.Listener().Addr().String()) for { session, err := server.Accept() if err != nil { break } go io.Copy(session.Conn(), session.Conn()) } }() fmt.Println(test1) fmt.Println("ssssssssssssssssss") test_struct(&test2{}) test_struct(&test2{}) test_struct(&test2{}) test_struct(&test2{}) test_struct(&test2{}) http.HandleFunc("/", sayhelloName) http.HandleFunc("/login/", login) http.HandleFunc("/upload/", upload) // amqp_connect() err := http.ListenAndServe(":9099", nil) //设置监听的端口 if err != nil { log.Fatal("ListenAndServe: ", err) } }
func startGateway() { listener, err := link.Serve("tcp", "0.0.0.0:"+gateway_port, packet.New( binary.SplitByUint32BE, 1024, 1024, 1024, )) checkError(err) listener.Serve(func(session *link.Session) { session.AddCloseCallback(session, func() { transferProxy.SendClientSessionOffline(session.Id()) }) transferProxy.SendClientSessionOnline(session) var msg packet.RAW for { if err := session.Receive(&msg); err != nil { break } transferProxy.SendToTransferServer(msg, session) } }) }
// This is broadcast server demo work with the echo_client. // usage: // go run echo_broadcast.go func main() { flag.Parse() protocol := packet.New( binary.SplitByUint16BE, 1024, 1024, 1024, ) server, err := link.Serve("tcp", *addr, protocol) if err != nil { panic(err) } println("server start:", server.Listener().Addr().String()) channel := link.NewChannel(link.DefaultBroadcast) go func() { for range time.Tick(time.Second * 2) { now := time.Now().Format("2006-01-02 15:04:05") channel.Broadcast(packet.RAW("from channel: " + now)) } }() server.Serve(func(session *link.Session) { addr := session.Conn().RemoteAddr().String() println("client", addr, "connected") channel.Join(session, nil) for { var msg packet.RAW if err := session.Receive(&msg); err != nil { break } println(addr, "say:", string(msg)) channel.Broadcast(packet.RAW("from " + addr + ": " + string(msg))) } println("client", addr, "closed") channel.Exit(session) }) }
// 开启服务器监听 func Listener(network, address string, codecType link.CodecType, acceptFunc func(*link.Session), dispatch dispatch.DispatchInterface) error { listener, err := link.Serve(network, address, codecType) if err != nil { return err } go func() { for { session, err := listener.Accept() if err != nil { break } go acceptFunc(session) if dispatch != nil { go sessionReceive(session, dispatch) } } }() return nil }
func SessionTest(t *testing.T, codecType link.CodecType, test func(*testing.T, *link.Session)) { server, err := link.Serve("tcp", "0.0.0.0:0", Bytes(Uint16BE)) unitest.NotError(t, err) addr := server.Listener().Addr().String() serverWait := new(sync.WaitGroup) go func() { for { session, err := server.Accept() if err != nil { break } serverWait.Add(1) go func() { io.Copy(session.Conn(), session.Conn()) serverWait.Done() }() } }() clientWait := new(sync.WaitGroup) for i := 0; i < 60; i++ { clientWait.Add(1) go func() { session, err := link.Connect("tcp", addr, codecType) unitest.NotError(t, err) test(t, session) session.Close() clientWait.Done() }() } clientWait.Wait() server.Stop() serverWait.Wait() MakeSureSessionGoroutineExit(t) }
//初始化 func InitServer(port string) error { servers = make(map[string][]*link.Session) gameConsistent = hashs.NewConsistent() gameUserSessions = make(map[uint64]int) listener, err := link.Serve("tcp", "0.0.0.0:"+port, packet.New( binary.SplitByUint32BE, 1024, 1024, 1024, )) if err != nil { return err } listener.Serve(func(session *link.Session) { var msg packet.RAW for { if err := session.Receive(&msg); err != nil { break } dealReceiveMsgC2S(session, msg) } }) return nil }
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) }