Ejemplo n.º 1
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();
        }
Ejemplo n.º 2
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();
        }
Ejemplo n.º 3
0
        public async Task Test(
            [Values(1)] int clientCount,
            [Values(2)] int sendCount,
            [Values(false)] bool isServiceUdp)
        {
            CustomResolver.Register(GeneratedResolver.Instance);

            var serverTcs = new TaskCompletionSource <string>();

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

            server.AddRpcService(new GreeterService());

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

            await server.StartAsync();

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

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

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

            await server.SessionManager.InvokeAllSessionAsync(async (ISession session) =>
            {
                var rpc = new GreeterRpc(session);

                var result = await rpc.Greet("Greet client!");
                Console.WriteLine(result);

                result = await rpc.Greet("Greet client!");
                Console.WriteLine(result);
            });

            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);

            await server.StopAsync();

            await Task.Delay(1000);

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

            Console.WriteLine(NetPool.BufferPool.ToString());

            Assert.Pass();
        }