예제 #1
0
        public void StartServer(string address, int port)
        {
            host = WebSocketHostBuilder.Create()
                   .UseWebSocketMessageHandler(
                async(session, message) =>
            {
                await session.SendAsync(message.Message);
            }
                )
                   .ConfigureAppConfiguration((hostCtx, configApp) =>
            {
                configApp.AddInMemoryCollection(new Dictionary <string, string>
                {
                    { "serverOptions:name", "EchoWebSocketServer" },
                    { "serverOptions:listeners:0:ip", address },
                    { "serverOptions:listeners:0:port", port.ToString() }
                });
            })
                   .ConfigureLogging((hostCtx, loggingBuilder) =>
            {
                loggingBuilder.AddConsole();
            })
                   .Build();

            host.Start();
        }
예제 #2
0
        static async System.Threading.Tasks.Task Main(string[] args)
        {
            var host = WebSocketHostBuilder.Create()
                       .UseWebSocketMessageHandler(
                async(session, message) =>
            {
                Console.WriteLine(message.Message);
                await session.SendAsync(message.Message);
            }
                )
                       .ConfigureAppConfiguration((hostCtx, configApp) =>
            {
                configApp.AddInMemoryCollection(new Dictionary <string, string>
                {
                    { "serverOptions:name", "JT808.Server" },
                    { "serverOptions:listeners:0:ip", "Any" },
                    { "serverOptions:listeners:0:port", "4040" }
                });
            })
                       .ConfigureLogging((hostCtx, loggingBuilder) =>
            {
                loggingBuilder.AddConsole();
            })
                       .Build();

            await host.RunAsync();
        }
        public async Task TestStartByHost()
        {
            var hostBuilder = WebSocketHostBuilder.Create()
                              .ConfigureLogging((hostCtx, loggingBuilder) =>
            {
                loggingBuilder.AddConsole();
                loggingBuilder.AddDebug();
            });

            using (var host = hostBuilder.Build())
            {
                await host.StartAsync();

                var websocket = new ClientWebSocket();

                await websocket.ConnectAsync(new Uri($"ws://localhost:{DefaultServerPort}"), CancellationToken.None);

                Assert.Equal(WebSocketState.Open, websocket.State);

                await Task.Delay(1000 * 5);

                await websocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);

                Assert.Equal(WebSocketState.Closed, websocket.State);

                await host.StopAsync();
            }
        }
예제 #4
0
        static async Task Main(string[] args)
        {
            var host = WebSocketHostBuilder.Create()
                       .UseWebSocketMessageHandler(async(session, message) =>
            {
                if (message.Message.Equals("StartPush", StringComparison.OrdinalIgnoreCase))
                {
                    var server       = session.Server as IServer;
                    var sessionCount = server.SessionCount;
                    var serverPush   = server.ServiceProvider.GetServices <IMiddleware>().OfType <ServerPushMiddleware>()
                                       .FirstOrDefault();
                    serverPush.StartPush(sessionCount);
                    session.GetDefaultLogger().LogInformation($"Start pushing to {sessionCount} clients...");
                    return;
                }

                // echo message back to the client
                await session.SendAsync(message.Message);
            })
                       .UseSession <PushSession>()
                       .UseInProcSessionContainer()
                       .UseMiddleware <ServerPushMiddleware>()
                       .ConfigureLogging((hostCtx, loggingBuilder) =>
            {
                // register your logging library here
                loggingBuilder.AddConsole();
            })
                       .Build();

            await host.RunAsync();
        }
예제 #5
0
        static async Task Main(string[] args)
        {
            var host = WebSocketHostBuilder.Create(args)
                       .UseWebSocketMessageHandler(async(session, message) =>
            {
                var s = session as PushSession;

                if (message.Message.Equals("ACK", StringComparison.OrdinalIgnoreCase))
                {
                    s.Ack();
                }

                await Task.CompletedTask;
            })
                       .UseSession <PushSession>()
                       .UseInProcSessionContainer()
                       .UseMiddleware <ServerPushMiddleware>()
                       .ConfigureLogging((hostCtx, loggingBuilder) =>
            {
                // register your logging library here
                loggingBuilder.AddConsole();
            })
                       .Build();

            await host.RunAsync();
        }
예제 #6
0
        public async Task RunAsync()
        {
            var host = WebSocketHostBuilder.Create()
                       .UseWebSocketMessageHandler(
                async(session, message) =>
            {
                await session.SendAsync(message.Message);
            }
                ).UseCommand <StringPackageInfo, StringPackageConverter>(commandOptions =>
            {
                // register commands one by one
                commandOptions.AddCommand <ADD>();
            })
                       .ConfigureAppConfiguration((hostCtx, configApp) =>
            {
                configApp.AddInMemoryCollection(new Dictionary <string, string>
                {
                    { "serverOptions:name", "WebsockServer" },
                    { "serverOptions:listeners:0:ip", "Any" },
                    { "serverOptions:listeners:0:port", "4040" }
                });
            })
                       .ConfigureLogging((hostCtx, loggingBuilder) =>
            {
                loggingBuilder.AddConsole();
            })
                       .Build();

            await host.RunAsync();
        }
예제 #7
0
        public async static Task Main(string[] args)
        {
            var svcProvider   = RegisterServices();
            var stateManager  = svcProvider.GetService <IStateManager>();
            var mainHandler   = svcProvider.GetService <IMainMessageHandler>();
            var socketManager = svcProvider.GetService <ISessionHandler>();

            socketManager.RegisterStateManager(stateManager);

            await stateManager.ChangeState("disconnected");

            var host = WebSocketHostBuilder.Create()
                       .UseWebSocketMessageHandler(mainHandler.HandleIncoming)
                       .UseSessionHandler(socketManager.OnConnected, socketManager.OnDisconnected)
                       .ConfigureAppConfiguration((_, conf) =>
            {
                conf.AddInMemoryCollection(new Dictionary <string, string>
                {
                    ["serverOptions:name"]             = "MaterialFader",
                    ["serverOptions:listeners:0:ip"]   = "Any",
                    ["serverOptions:listeners:0:port"] = "2021"
                });
            })
                       .Build();

            host.Run();
        }
        protected IHostBuilder CreateWebSocketServerBuilder(Func <IWebSocketHostBuilder, IWebSocketHostBuilder> configurator = null, IHostConfigurator hostConfigurator = null)
        {
            var builder = WebSocketHostBuilder.Create();

            if (configurator != null)
            {
                builder = configurator(builder);
            }

            return(Configure(builder, hostConfigurator));
        }
예제 #9
0
        protected ISuperSocketHostBuilder <WebSocketPackage> CreateWebSocketSocketServerBuilder(Func <ISuperSocketHostBuilder <WebSocketPackage>, ISuperSocketHostBuilder <WebSocketPackage> > configurator = null, IHostConfigurator hostConfigurator = null)
        {
            var hostBuilder = WebSocketHostBuilder.Create() as ISuperSocketHostBuilder <WebSocketPackage>;

            if (configurator != null)
            {
                hostBuilder = configurator(hostBuilder);
            }

            return(Configure(hostBuilder, hostConfigurator) as ISuperSocketHostBuilder <WebSocketPackage>);
        }
예제 #10
0
        static async Task Main(string[] args)
        {
            var host = WebSocketHostBuilder.Create()
                       .UseWebSocketMessageHandler(async(session, message) =>
            {
                // echo message back to the client
                await session.SendAsync(message.Message);
            })
                       .ConfigureLogging((hostCtx, loggingBuilder) =>
            {
                // register your logging library here
                loggingBuilder.AddConsole();
            }).Build();

            await host.RunAsync();
        }
예제 #11
0
        public async Task Build()
        {
            var host = WebSocketHostBuilder.Create()
                       .UseWebSocketMessageHandler(
                async(session, message) =>
            {
                yzbcore.Bussiness.LogHelper.Info(JsonConvert.SerializeObject(message));
                ConnectionManager.AddSocket(session);
                var socketId = ConnectionManager.GetId(session);
                var uid      = JsonConvert.DeserializeObject <wsmessgae>(message.Message);
                ConnectionManager.AddSerial(uid.uid, socketId);
                yzbcore.Bussiness.LogHelper.Info(uid.uid);
                //await session.SendAsync(uid.uid);
                LogHelper.Error("收到ws连接uid" + uid + "socketId" + socketId);
            }
                )
                       .ConfigureAppConfiguration((hostCtx, configApp) =>
            {
                configApp.AddInMemoryCollection(new Dictionary <string, string>
                {
                    //{ "handshakeoptions:checkinginterval", "1800" },
                    { "serverOptions:name", "YZBServer" },
                    { "serverOptions:listeners:0:ip", "Any" },
                    { "serverOptions:listeners:0:port", "2347" }
                });
            }).ConfigureServices((ctx, services) =>
            {
                services.Configure <HandshakeOptions>(options =>
                {
                    options.CheckingInterval      = 1800;
                    options.OpenHandshakeTimeOut  = 1;
                    options.CloseHandshakeTimeOut = 1800;
                });
            })
                       .ConfigureLogging((hostCtx, loggingBuilder) =>
            {
                loggingBuilder.AddConsole();
            })
                       .Build();

            await host.RunAsync();
        }
예제 #12
0
        public Sensor(DeviceConfiguration configuration, DeviceStatusReport status)
        {
            Configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
            StatusReport  = status ?? throw new ArgumentNullException(nameof(status));

            _marsClients        = new Dictionary <string, MrsClient>();
            _pendingIndications = new List <IndicationType>(400);

            _socketHost = WebSocketHostBuilder.Create()
                          .ConfigureAppConfiguration((context, builder) =>
            {
                builder.AddInMemoryCollection(new Dictionary <string, string>
                {
                    { "serverOptions:name", "MrsSensorServer" },
                    { "serverOptions:listeners:0:ip", $"{IP}" },
                    { "serverOptions:listeners:0:port", $"{Port}" }
                });
            })
                          .UseWebSocketMessageHandler(WebSocketMessageHandler)
                          .Build();

            _timer          = new Timer();
            _timer.Elapsed += Timer_Elapsed;
        }
 protected IHostBuilder CreateWebSocketServerBuilder()
 {
     return(Configure(WebSocketHostBuilder.Create()));
 }