Exemplo n.º 1
0
        private void SendP2pInternal(
            NetDataWriter writer,
            ushort sessionId,
            DeliveryMethod deliveryMethod)
        {
            if (deliveryMethod == DeliveryMethod.Tcp)
            {
                _logger.LogError("not support tcp transfer in p2p");
                return;
            }

            if (sessionId == SessionId)
            {
                // 내가 받아야 한다면
                _readerForSendInternal.SetSource(writer);
                OnP2pReceive(this, _readerForSendInternal);
            }
            else
            {
                var member = P2pGroup.Find(sessionId);

                if (member != null)
                {
                    member.SendAsync(writer, deliveryMethod);
                }
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// 나 자산이 마스터인지 여부
        /// </summary>
        /// <returns>마스터 여부</returns>
        public bool MasterIsMine()
        {
            if (P2pGroup == null)
            {
                return(false);
            }

            return(P2pGroup.MasterIsMine());
        }
Exemplo n.º 3
0
        public void Run()
        {
            var serverOption = new ServerOption()
            {
                Name          = "SampleGameServer",
                TcpServerPort = 12000,
                IsServiceUdp  = true,
                UdpServerPort = 12001,
                MaxSession    = 100,
            };

            var loggerFactory = DefaultLoggerFactory.Create(
                builder =>
            {
                builder.SetMinimumLevel(LogLevel.Information);
                builder.AddConsoleLogger();
            }
                );

            var statistics     = new NetStatistic();
            var sessionFactory = new DefaultSessionFactory(
                serverOption,
                loggerFactory,
                statistics,
                (createInfo) => {
                return(new UserSession(createInfo));
            });

            _server = new NetServer(
                serverOption,
                statistics,
                loggerFactory,
                sessionFactory);

            _server.AddRpcService(new LoginRpcServiceSession());

            _server.StartAsync().Wait();

            _p2pGroup = _server.P2pManager.CreateP2pGroup();

            while (true)
            {
                var key = Console.ReadKey();
                if (key.Key == ConsoleKey.Escape)
                {
                    Console.WriteLine("quit");
                    break;
                }
            }

            _server.StopAsync().Wait();
        }
Exemplo n.º 4
0
        private void SendP2pInternal(
            NetDataWriter writer,
            DeliveryTarget deliveryTarget,
            DeliveryMethod deliveryMethod)
        {
            if (deliveryMethod == DeliveryMethod.Tcp)
            {
                _logger.LogError("not support tcp transfer in p2p");
                return;
            }

            if (P2pGroup == null)
            {
                _logger.LogWarning("No joined any P2pGroup");
                return;
            }

            if (deliveryTarget == DeliveryTarget.All)
            {
                P2pGroup.SendAll(writer, deliveryMethod);

                _readerForSendInternal.SetSource(writer);
                OnP2pReceive(this, _readerForSendInternal);
            }
            else if (deliveryTarget == DeliveryTarget.Others)
            {
                P2pGroup.SendAll(writer, deliveryMethod);
            }
            else if (deliveryTarget == DeliveryTarget.Master)
            {
                var member = P2pGroup.Find(P2pGroup.MasterSessionId);

                if (member != null)
                {
                    if (member.IsMine())
                    {
                        // 내가 마스터라면 바로 호출함
                        _readerForSendInternal.SetSource(writer);
                        OnP2pReceive(this, _readerForSendInternal);
                    }
                    else
                    {
                        member.SendAsync(writer, deliveryMethod);
                    }
                }
            }
        }
Exemplo n.º 5
0
        public async Task Start()
        {
            // 서버 옵션을 정의
            var serverOption = new ServerOption()
            {
                Name               = "StarterServer",
                TcpServerPort      = 12000,
                IsServiceUdp       = true,
                UdpServerPort      = 12001,
                MaxSession         = 1000,
                IsCheckAlive       = true,
                CheckAliveInterval = 50000,
                CheckAliveTimeout  = 60000,
            };

            // 로거 팩토리를 생성
            var loggerFactory = DefaultLoggerFactory.Create(
                builder =>
            {
                builder.SetMinimumLevel(LogLevel.Information);
                builder.AddConsoleLogger();
            }
                );

            var statistics = new NetStatistic();

            // UserSession 을 사용하기 위해서 팩토리를 만듬
            var sessionFactory = new DefaultSessionFactory(
                serverOption,
                loggerFactory,
                statistics,
                (createInfo) => {
                return(new UserSession(createInfo));
            });

            // 서버를 생성
            _server = new NetServer(
                serverOption,
                statistics,
                loggerFactory,
                sessionFactory);

            // 자동으로 생성된 Rpc 서비스를 등록함
            _server.AddRpcService(new LoginRpcServiceSession());
            _server.AddRpcService(new ShopRpcServiceSession());

            // P2p 그룹을 만듬 (현재는 1개만 필요하니 한개만 만듬. 여러개 생성가능)
            _p2pGroup = _server.P2pManager.CreateP2pGroup();

            // 서버를 시작함
            await _server.StartAsync();

            // 메인스레드에 키 입력을 받을 수 있게 함
            while (true)
            {
                var key = Console.ReadKey();
                if (key.Key == ConsoleKey.Escape)
                {
                    Console.WriteLine("quit");
                    break;
                }
            }

            // 서버 정지
            await _server.StopAsync();
        }
Exemplo n.º 6
0
 /// <summary>
 /// P2P 그룹의 모든 유저에게 데이터를 전송함
 /// </summary>
 /// <param name="dataWriter">전송할 데이터</param>
 /// <param name="deliveryMethod">전송 방식</param>
 public void SendAll(NetDataWriter dataWriter, DeliveryMethod deliveryMethod)
 {
     P2pGroup?.SendAll(dataWriter, deliveryMethod);
 }
Exemplo n.º 7
0
        public async Task Test(
            [Values(3)] int clientCount,
            [Values(1)] int sendCount)
        {
            var serverTcs = new TaskCompletionSource <string>();
            int receivedUnreliableCount = 0;
            int receivedTcpCount        = 0;

            NetServer server = new NetServer(
                new ServerOption()
            {
                Name          = "TestServer",
                TcpServerPort = 9000,
                IsServiceUdp  = true,
                UdpServerPort = 9001,
                TcpBackLog    = Math.Max(clientCount, 512),
                MaxSession    = clientCount,
            });

            server.OnSessionReceived += (ISession session, NetDataReader reader) =>
            {
                var text = reader.ReadString();

                var writer = NetPool.DataWriterPool.Alloc();
                try
                {
                    if (text == "Join")
                    {
                        var result = _p2pGroup.Join(session as ServerSession);

                        Console.WriteLine($"P2p joined {result}");
                    }
                    else if (text == "Leave")
                    {
                        var result = _p2pGroup.Leave(session as ServerSession);

                        Console.WriteLine($"P2p leaved {result}");
                    }
                    else if (text == "Unreliable")
                    {
                        Interlocked.Increment(ref receivedUnreliableCount);

                        writer.Write("Unreliable");

                        session.SendAsync(writer, DeliveryMethod.Unreliable);
                    }
                    else
                    {
                        Interlocked.Increment(ref receivedTcpCount);

                        if (text == "Finish")
                        {
                            writer.Write("Finish");
                        }
                        else
                        {
                            writer.Write($"Hello Client{session.SessionId}");
                        }

                        session.SendAsync(writer, DeliveryMethod.Tcp);
                    }
                }
                finally
                {
                    NetPool.DataWriterPool.Free(writer);
                }

                return(Task.CompletedTask);
            };

            server.OnSessionErrored += (ISession session, Exception ex) =>
            {
                serverTcs.TrySetException(ex);
                Assert.Fail(ex.ToString());
            };

            await server.StartAsync();

            Assert.AreEqual("Started", server.State.ToString());

            _p2pGroup = server.P2pManager.CreateP2pGroup();

            List <Task <NetClient> > taskList = new List <Task <NetClient> >();

            for (int i = 0; i < clientCount; i++)
            {
                taskList.Add(WorkClient(i, sendCount));
            }

            await Task.WhenAny(Task.WhenAll(taskList), serverTcs.Task);

            Assert.AreEqual(clientCount, server.SessionCount);

            foreach (var task in taskList)
            {
                task.Result.Close();
            }

            await Task.Delay(1000);

            Assert.AreEqual(0, server.SessionCount);
            Assert.AreEqual(0, _p2pGroup.MemberCount);

            await server.StopAsync();

            await Task.Delay(1000);

            Assert.AreEqual("Stopped", server.State.ToString());

            Console.WriteLine($"Server receivedTcpCount : {receivedTcpCount}");
            Console.WriteLine($"Server receivedUnreliableCount : {receivedUnreliableCount}");

            Console.WriteLine("****** PacketPool ******");
            Console.WriteLine(NetPool.PacketPool.ToString());
            Console.WriteLine("");

            Console.WriteLine("****** DataWriterPool ******");
            Console.WriteLine(NetPool.DataWriterPool.ToString());
            Console.WriteLine("");

            Assert.AreEqual(clientCount * sendCount, receivedTcpCount);
            Assert.AreEqual(0, NetPool.PacketPool.AllocCount);
            Assert.AreEqual(0, NetPool.DataWriterPool.AllocCount);

            Assert.Pass();
        }