public async static Task <WebSocketResponse> ProcessRequest(WebSocketRequest request, IMemoryCache memoryCache) { var bl = new CacheBL(memoryCache, request.authorization, request.cacheKey, request.cacheLifespanSeconds); var response = new WebSocketResponse { cacheEntry = null, responseCode = "OK", responseMessage = "" }; switch (request.method) { case "GET": response.cacheEntry = await bl.GetFromDictionary(request.autoPopulateEndpoint); break; case "POST": bl.PostToDictionary(request.values); break; case "DELETE": bl.DeleteFromDictionary(); break; } return(response); }
/// <summary> /// Client code don't use it if AsyncWebSocketRequests.Instance.Start() is not called which will use a bunch of threads to /// send websocket requests asynchronously /// </summary> /// <param name="webSocketRequest"></param> /// <returns></returns> public object AsyncSendRequest(WebSocketRequest webSocketRequest) { var syncRequest = new WebSocketSyncRequest(webSocketRequest); WebSocketNotificationHandler.InitWaitEvent(syncRequest); AsyncWebSocketRequests.Instance.Add(syncRequest.Request); return WebSocketNotificationHandler.WaitResponse(syncRequest); }
/// <summary> /// 接受数据 /// </summary> /// <param name="obj"></param> private void WebSocketSession_OnRecevied(object sender, WebSocketRequest e) { var session = (WebSocketSession)sender; try { Func <string, WebSocketResult> handle = null; if (e.ActionCode != HandleCode.None && Handles.TryGetValue(e.ActionCode, out handle)) { var result = handle(e.Data); if (result != null) { result.ActionCode = e.ActionCode; result.DeviceID = e.DeviceID; result.WeChatID = e.WeChatID; result.MessageID = e.MessageID; session.Send(result); } } } catch (Exception ex) { LogHelper.WriteException(ex); session.Send(new WebSocketResult() { ActionCode = e.ActionCode, ErrorCode = ErrorCode.sys_fail }); } }
public static void Run() { var url = "ws://localhost:5000"; var concurrentCopies = 50; var webSocketsPool = ConnectionPool.Create( name: "webSocketsPool", connectionsCount: concurrentCopies, openConnection: (number) => { var ws = new ClientWebSocket(); ws.ConnectAsync(new Uri(url), CancellationToken.None).Wait(); return(ws); }, closeConnection: (connection) => { connection.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None) .Wait(); } ); var pingStep = Step.Create("ping", webSocketsPool, async context => { var msg = new WebSocketRequest { CorrelationId = context.CorrelationId.Id, RequestType = RequestType.Ping }; var bytes = MsgConverter.ToJsonByteArray(msg); await context.Connection.SendAsync(bytes, WebSocketMessageType.Text, true, context.CancellationToken); return(Response.Ok()); }); var pongStep = Step.Create("pong", webSocketsPool, async context => { while (true) { var(response, message) = await WebSocketsMiddleware.ReadFullMessage(context.Connection, context.CancellationToken); var msg = MsgConverter.FromJsonByteArray <WebSocketResponse>(message); if (msg.CorrelationId == context.CorrelationId.Id) { return(Response.Ok(msg)); } } }); var scenario = ScenarioBuilder .CreateScenario("web_socket test", new[] { pingStep, pongStep }) .WithOutWarmUp() .WithLoadSimulations(new[] { Simulation.KeepConcurrentScenarios(concurrentCopies, during: TimeSpan.FromSeconds(10)) }); NBomberRunner.RegisterScenarios(scenario) .RunInConsole(); }
public override void OnMessage(string message) { try { WebSocketRequest mywebsocketrequest = JsonConvert.DeserializeObject <WebSocketRequest>(message); //TAKE JSON JOINTEAMREQUEST,VALIDATE AND IF VALID SEND THE SAME MESSAGE BACK, AND UPDATE SERVERSIDED TEAMS if (mywebsocketrequest.typeofalert.Equals("jointeamrequest")) { string data = JsonConvert.SerializeObject(mywebsocketrequest.data); JoinTeamRequest jointeamrequest = JsonConvert.DeserializeObject <JoinTeamRequest>(data); if (isvalidupdateteamrequest(jointeamrequest)) { clients.Broadcast(message); } } //TAKE JSON REQUEST TO GET TEAMS AND GENERATE A NEW JSONRESPONSE WIH THE CURRENT STATE OF TEAMS if (mywebsocketrequest.typeofalert.Equals("getstateofteams")) { JObject o = new JObject(); JArray serializedteams = new JArray(); JObject teamAjJObject = new JObject(); teamAjJObject["team"] = JToken.Parse(JsonConvert.SerializeObject(clients.teamA)); JObject teamBjJObject = new JObject(); teamBjJObject["team"] = JToken.Parse(JsonConvert.SerializeObject(clients.teamB)); serializedteams.Add(teamAjJObject); serializedteams.Add(teamBjJObject); o["teams"] = serializedteams; o["typeofalert"] = "getstateofteams"; clients.Broadcast(o.ToString()); } if (mywebsocketrequest.typeofalert.Equals("startthegamerequest")) { string data = JsonConvert.SerializeObject(mywebsocketrequest.data); StartTheGameRequest startthegamerequest = JsonConvert.DeserializeObject <StartTheGameRequest>(data); if (isvalidstartthegamerequest(startthegamerequest)) { clients.Broadcast(message); } } if (mywebsocketrequest.typeofalert.Equals("ingamerequest")) { clients.Broadcast(message); } if (mywebsocketrequest.typeofalert.Equals("victoryrequest")) { clients.Broadcast(message); } } catch (Exception e) { //IF DESERIALIZING DOES NOT WORK, THEN TREAT MESSAGE AS CHAT MESSAGE clients.Broadcast(name + " has said " + message); } }
/// <summary> /// Kim /// </summary> /// <param name="messageHandler"></param> public void PingEndpoint(ApiClientAbstract.MessageHandler <OrderResponse> messageHandler) { var requestData = new WebSocketRequest() { Action = "ping", ID = "sample_id" }; _apiClient.SuscribeToWebSocket(messageHandler, requestData); }
/// <see cref="ICobinhoodClient.ListenOrderEndpoint(ApiClientAbstract.MessageHandler{OrderResponse})"/> public void ListenOrderEndpoint(ApiClientAbstract.MessageHandler <OrderResponse> messageHandler) { var requestData = new WebSocketRequest() { Action = "subscribe", Type = "order" }; _apiClient.SuscribeToWebSocket(messageHandler, requestData); }
/// <see cref="ICobinhoodClient.UnsubscribeFromEndpoint(string, ApiClientAbstract.MessageHandler{UnsubscribeResponse})"/> public void UnsubscribeFromEndpoint(string channelId, ApiClientAbstract.MessageHandler <UnsubscribeResponse> messageHandler) { var requestData = new WebSocketRequest() { Action = "unsubscribe", ChannelId = channelId }; _apiClient.SuscribeToWebSocket(messageHandler, requestData); }
public AskToHandleWebSocketRequest( WebSocketRequest requestType, string interfaceName, dynamic data ) { RequestType = requestType; Interface = interfaceName; Data = data; }
public static object SendRequestReturnResult(WebSocketClient handler, WebSocketRequest request) { var syncRequest = new WebSocketSyncRequest(request); WebSocketNotificationHandler.InitWaitEvent(syncRequest); object result = null; if (handler.SendRequest(request)) { result = WebSocketNotificationHandler.WaitResponse(syncRequest); } return result; }
public override WebResponse OnPreprocess(Session session, WebSocketRequest request) { if (request.opcode != OpCode.Ping) { return(null); } var pong = new WebSocketResponse(); pong.opcode = OpCode.Pong; pong.content = request.content; return(pong); }
public static void Run() { var url = "ws://localhost:53231"; var webSocketsPool = ConnectionPool.Create("webSocketsPool", openConnection: () => { var ws = new ClientWebSocket(); ws.ConnectAsync(new Uri(url), CancellationToken.None).Wait(); return(ws); }, closeConnection: (connection) => { connection.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None) .Wait(); }); //connectionsCount: 50); var pingStep = Step.Create("ping", async context => { var msg = new WebSocketRequest { CorrelationId = context.CorrelationId, RequestType = RequestType.Ping }; var bytes = MsgConverter.ToJsonByteArray(msg); await context.Connection.SendAsync(bytes, WebSocketMessageType.Text, true, context.CancellationToken); return(Response.Ok()); }, pool: webSocketsPool); var pongStep = Step.Create("pong", async context => { while (true) { var(response, message) = await WebSocketsMiddleware.ReadFullMessage(context.Connection, context.CancellationToken); var msg = MsgConverter.FromJsonByteArray <WebSocketResponse>(message); if (msg.CorrelationId == context.CorrelationId) { return(Response.Ok(msg)); } } }, pool: webSocketsPool); var scenario = ScenarioBuilder.CreateScenario("web_socket test", pingStep, pongStep); NBomberRunner.RegisterScenarios(scenario) .RunInConsole(); }
/// <summary> /// 推送最新的日志(rabbitmq推送过来的日志) /// </summary> /// <param name="request"></param> /// <returns></returns> public static WebSocketRequest AddPushNewLogs(this WebSocketRequest request) { if (RoutePath.PushNewLogs == request.Route.Trim().ToLower()) { try { } catch (Exception ex) { throw ex; } } return(request); }
private void WebsocketRead(Task <WebSocketReceiveResult> task, WebSocket ws, ArraySegment <byte> buffer, List <byte[]> messageParts) { switch (task.Result.MessageType) { case WebSocketMessageType.Binary: ws.CloseAsync(WebSocketCloseStatus.InvalidMessageType, "Binary messages are not supported", CancellationTokenSource.Token); break; case WebSocketMessageType.Text: if (task.Result.EndOfMessage) { string message; if (messageParts == null) { message = Encoding.UTF8.GetString(buffer.Array, buffer.Offset, task.Result.Count); } else { message = Encoding.UTF8.GetString(messageParts.SelectMany(a => a).Concat(buffer.Array.Skip(buffer.Offset).Take(task.Result.Count)).ToArray()); } WebSocketRequest req = JsonConvert.DeserializeObject <WebSocketRequest>(message); ApiClient client = Clients.ContainsKey(req.ClientId) ? Clients[req.ClientId].Ping() : null; WebSocketResponse res = new WebSocketResponse() { Responses = new string[req.Tasks.Length] }; for (int i = 0; i < req.Tasks.Length; ++i) { res.Responses[i] = Handle(req.Tasks[i].Url, req.Tasks[i].Request, client); } WebsocketSendPart(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(res)), 0, ws, buffer); } else { if (messageParts == null) { messageParts = new List <byte[]>(); } messageParts.Add(buffer.Array.Skip(buffer.Offset).Take(task.Result.Count).ToArray()); ws.ReceiveAsync(buffer, CancellationTokenSource.Token).ContinueWith(tsk => WebsocketRead(tsk, ws, buffer, messageParts)); } break; case WebSocketMessageType.Close: ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "Client closed", CancellationTokenSource.Token); break; } }
public async Task AuthorizeUserAsync(CancellationToken ct) { var request = new WebSocketRequest <AuthorizationRequest> { Request = "auth-apikey", Data = new AuthorizationRequest { ApiKey = this.m_apiKey, UserId = this.m_userId } }; var json = JsonConvert.SerializeObject(request); this.m_logger.Debug($"Authorizing user: {json}"); var segment = new ArraySegment <byte>(Encoding.UTF8.GetBytes(json)); await this.m_socket.SendAsync(segment, WebSocketMessageType.Text, true, ct); }
public async Task PingAsync(CancellationToken ct) { var request = new WebSocketRequest <PingRequest> { Request = "keepalive", Data = new PingRequest { Ping = "pong" } }; var json = JsonConvert.SerializeObject(request); this.m_logger.Info("Writing PING request."); var segment = new ArraySegment <byte>(Encoding.UTF8.GetBytes(json)); await this.m_socket.SendAsync(segment, WebSocketMessageType.Text, true, ct); }
public WebSocketRequest <SensorAuthorizationRequest> GenerateWebSocketSignature(string sensorId, string secret) { var request = new WebSocketRequest <SensorAuthorizationRequest> { Request = "subscribe", Data = new SensorAuthorizationRequest { Secret = secret, SensorId = sensorId, Timestamp = DateTime.UtcNow } }; var json = JsonConvert.SerializeObject(request.Data); request.Data.Secret = this.GenerateSha256Signature(json); return(request); }
public override WebResponse OnPreprocess(Session session, WebSocketRequest request) { if (request.opcode != OpCode.Close) { return(null); } if (session.state != SessionState.Opened) { return(null); } var close = new WebSocketResponse(); close.opcode = OpCode.Close; close.content = request.content; throw new CloseSessionException(close); }
public static Scenario BuildScenario() { var url = "ws://localhost:53231"; var webSocketsPool = ConnectionPool.Create("webSocketsPool", openConnection: () => { var ws = new ClientWebSocket(); ws.ConnectAsync(new Uri(url), CancellationToken.None).Wait(); return(ws); }, closeConnection: (connection) => { connection.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None) .Wait(); }); //connectionsCount: 50); var pingStep = Step.CreatePull("ping", webSocketsPool, async context => { var msg = new WebSocketRequest { CorrelationId = context.CorrelationId, RequestType = RequestType.Ping }; var bytes = MsgConverter.ToJsonByteArray(msg); await context.Connection.SendAsync(bytes, WebSocketMessageType.Text, true, CancellationToken.None); return(Response.Ok()); }); var pongStep = Step.CreatePush("pong", webSocketsPool, async context => { var(response, message) = await WebSocketsMiddleware.ReadFullMessage(context.Connection); var msg = MsgConverter.FromJsonByteArray <WebSocketResponse>(message); if (msg.CorrelationId == context.CorrelationId) { context.UpdatesChannel.ReceivedUpdate(Response.Ok(msg)); } }); return(ScenarioBuilder.CreateScenario("web_socket test", pingStep, pongStep)); }
private async Task UnsubscribeAll() { foreach (var(sensorId, _) in this.m_sensors) { var subscribe = new WebSocketRequest <SensorUnsubscribeRequest> { Request = UnsubscribeRequest, Data = new SensorUnsubscribeRequest { SensorId = sensorId } }; var json = JsonConvert.SerializeObject(subscribe); var segment = new ArraySegment <byte>(Encoding.UTF8.GetBytes(json)); this.m_logger.Info($"Unsubscribing sensor: {sensorId}."); this.m_logger.Debug($"Unsubscribe message: {json}"); await this.m_socket.SendAsync(segment, WebSocketMessageType.Text, true, CancellationToken.None); } }
public void HandleWebSocket(WebSocketRequest req, WebSocketResponse resp) { if (req.OpCode == Opcode.Text) { string clientMsg = req.ReadAsString(); if (clientMsg == null) { resp.Write(""); return; } string serverMsg = null; if (clientMsg.StartsWith("LOOPBACK")) { serverMsg = "from SERVER " + clientMsg; } else { serverMsg = "server:" + (count++); } resp.Write(serverMsg); #if DEBUG System.Diagnostics.Debug.WriteLine(serverMsg); #endif } else if (req.OpCode == Opcode.Binary) { //this is binary data byte[] binaryData = req.ReadAsBinary(); #if DEBUG count++; string serverMsg = count + " binary_len" + binaryData.Length; System.Diagnostics.Debug.WriteLine(serverMsg); resp.Write(serverMsg); #endif } }
/// <see cref="ICobinhoodClient.ListenTickerEndpoint(string, string, ApiClientAbstract.MessageHandler{TickerResponse})"/> public void ListenTickerEndpoint(string quoteSymbol, string baseSymbol, ApiClientAbstract.MessageHandler <TickerResponse> messageHandler) { if (string.IsNullOrWhiteSpace(quoteSymbol)) { throw new ArgumentException("QuoteSymbol cannot be empty. ", "quoteSymbol"); } if (string.IsNullOrWhiteSpace(baseSymbol)) { throw new ArgumentException("BaseSymbol cannot be empty. ", "baseSymbol"); } var tradingPair = (quoteSymbol + "-" + baseSymbol).ToUpper(); var requestData = new WebSocketRequest() { Action = "subscribe", Type = "ticker", TradingPairId = tradingPair }; _apiClient.SuscribeToWebSocket(messageHandler, requestData); }
public async Task <JObject> Handle(WebSocketRequest <JObject> message, CancellationToken cancellationToken) { this.logger.LogJson(message); var response = new WebSocketResponse { Type = WebSocketResponseType.Reply }; if (string.IsNullOrWhiteSpace(message.TypeName)) { return(response.ToJObject()); } var type = TypeExtensions.GetAppDomainType(message.TypeName); if (type.IsMediatorRequest()) { var command = this.mapper.Map(message.Typed ?? new JObject(), typeof(JObject), type); response.Data = await this.mediator.Result(command).NoCapture(); } this.logger.LogJson(response); return(response.ToJObject()); }
public WebSocketResponse Analyze(WebSocketRequest request,WebSocketResponse response) { response.Data = request.Body; return response; }
/// <summary> /// Точка входа в библиотеку. Отделяет полезные запросы от бесполезных и направляет каждый на свои парсеры /// </summary> /// <param name="page_type">Тип страницы: список матчей или страница кефа. Если страницы кефов нет - по умолчанию страница матчей</param> /// <param name="request_type">Тип запроса: обычный или фрейм WebSocket`а</param> /// <param name="request">Инфо с обычного запроса, либо NULL</param> /// <param name="wsFrame">Инфо о фрейме WebSocket`а, либо NULL</param> /// <returns>Вернуть распаршенную структуру Parsed или NULL, если запросу парсинг не требуется</returns> public Parsed Router(pageTypes page_type, requestTypes request_type, ref NormalRequest request, ref WebSocketRequest wsFrame) { // По request.request_url (если надо request_headers) направить на выполнение // Вернуть Parsed или null, если парсинг не нужен return(null); }
/// <summary> /// Запустить парсер нужной страницы, отправляя запросы вручную /// Предпочтение отдавать асинхронным запросам и использованию WebClientCookie /// </summary> /// <param name="page">Какую страницу парсить: список матчей или одного матча</param> /// <param name="urlMatches">Ссылка на страницу списка матчей, обязательно указывать даже если парсится страница матча</param> /// <param name="urlOneMatch">Ссылка на страницу конкретного матча, не нужно указывать, если парсится список матчей</param> /// <param name="speed_kef">Коэффициент ускорения отправки запросов</param> /// <param name="callback">Коллбек, который надо вызвать со структурой Parsed, которую вернёт роутер, если нужно</param> public async Task Start(pageTypes page, string urlMatches, string urlOneMatch, double speed_kef = 1, Action <Parsed> callback = null) { // Пример того как этой функции желательно выглядеть, можете даже просто подставить свои Fetch-запросы // WebClientCookie - расширенная версия вебклиента, которая сама хранит сессию, подставляет User-agent // и другие стандартные заголовки // использовать глобальный куки контейнер GlobalCookies для каждого нового экземпляра WebClientCookie WebClientCookie WC = new WebClientCookie(GlobalCookies); // Разогреть страницу и получить куки if (!await preloadPage(page, urlMatches, urlOneMatch, WC)) { sendException("Не удалось разогреть страницу"); return; } // ID матча из URL, если нужно string matchID = ""; // if(page== pageTypes.OneMatch) // matchID = urlOneMatch.Split(new string[] { "hl=" }, StringSplitOptions.None)[1]; // запустить цикл обновлений NormalRequest request = new NormalRequest(); WebSocketRequest noRequest = null; Parsed data = null; string response; while (true) { // Запускаем парсер страницы матчей if (page == pageTypes.MatchesList) { try { response = await WC.DownloadStringTaskAsync("https://www.parimatch.com/live_as.html?curs=0&curName=$&shed=0"); } catch { continue; } // Экземпляр запроса request = new NormalRequest { request_url = "https://www.parimatch.com/live_as.html?curs=0&curName=$&shed=0", response_data = response, //response_headers = WC.ResponseHeaders // только если нужно для парсинга }; // отправить NormalRequest в роутер data = Router(pageTypes.MatchesList, requestTypes.Normal, ref request, ref noRequest); // Вызывать коллбек с данными, если он есть [асинхронен в вызывающем коде] if (callback != null) { callback.Invoke(data); } Debugger.Break(); // Подождать стандартное для букмекера время обновления списка матчей await Task.Delay(TimeSpan.FromMilliseconds(speed_kef * 7500)); } // Страница одного матча [если для этого букмекера это применимо] else if (page == pageTypes.OneMatch) { // * Запросим данные try { response = await WC.DownloadStringTaskAsync("https://www.parimatch.com/live_ar.html?hl=" + matchID + "&hl=" + matchID + ",&curs=0&curName=$"); } catch { continue; } // Экземпляр запроса request = new NormalRequest { request_url = "https://www.parimatch.com/live_ar.html?hl=" + matchID + "&hl=" + matchID + ",&curs=0&curName=$", response_data = response, //response_headers = wc.response_headers // только если нужно для парсинга }; // отправить NormalRequest в роутер data = Router(pageTypes.OneMatch, requestTypes.Normal, ref request, ref noRequest); // Вызывать коллбек с данными, если он есть [асинхронен в вызывающем коде] if (callback != null) { callback.Invoke(data); } // Подождать стандартное для букмекера время обновления 1 страницы матча await Task.Delay(TimeSpan.FromMilliseconds(speed_kef * 7500)); } // Останавливаем поток, если нужно if (needStop) { return; } } }
/// <summary> /// Отделяет полезные запросы от бесполезных и направляет каждый на свои парсеры /// </summary> /// <param name="page_type">Тип страницы: список матчей или страница кефа. Если страницы кефов нет - по умолчанию страница матчей</param> /// <param name="request_type">Тип запроса: обычный или фрейм WebSocket`а</param> /// <param name="request">Инфо с обычного запроса, либо NULL</param> /// <param name="wsFrame">Инфо о фрейме WebSocket`а, либо NULL</param> /// <returns>Вернуть распаршенную структуру Parsed или NULL, если запросу парсинг не требуется</returns> public Parsed Router(pageTypes page_type, requestTypes request_type, ref NormalRequest request, ref WebSocketRequest wsFrame) { // Выходная структура Parsed parsed = new Parsed { BookmakerID = BookmakerID }; // По request.request_url (если надо request_headers) направить на нужный парсер // Пример: получено xhr-обновление матчей if (page_type == pageTypes.MatchesList && request.request_url.Contains("/live_as.html?curs=0&curName=$")) { // Направляем на парсер списка матчей try { parsed.matches = Matches(request.response_data); } catch { sendException("Неизвестная ошибка парсинга", "Router", request.response_data); return(null); } // Отдаём распаршенную структуру с матчами return(parsed); } // Получена страница одного матча else if (page_type == pageTypes.OneMatch && request.request_url.Contains("/live_ar.html?hl=")) { // Направляем на парсер списка матчей try { parsed.matches = Matches(request.response_data); } catch { sendException("Неизвестная ошибка парсинга", "Router", request.response_data); return(null); } // Отдаём распаршенную структуру с одним матчем return(parsed); } // Вернуть null, если парсинг не нужен return(null); }
public static WebSocketResponse StartClient(WebSocketRequest request, IPAddress remoteIPAddress, int remotePort) { // Data buffer for incoming data. byte[] bytes = new byte[1024]; // Connect to a remote device. try { // Establish the remote endpoint for the socket. // This example uses port 11000 on the local computer. //IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName()); //IPAddress ipAddress = ipHostInfo.AddressList[0]; IPEndPoint remoteEP = new IPEndPoint(remoteIPAddress, remotePort); // Create a TCP/IP socket. Socket sender = new Socket(remoteIPAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp); // Connect the socket to the remote endpoint. Catch any errors. try { sender.Connect(remoteEP); Console.WriteLine("Socket connected to {0}", sender.RemoteEndPoint.ToString()); var requestString = JsonSerializer.Serialize(request) + "<EOF>"; // Encode the data string into a byte array. byte[] msg = Encoding.ASCII.GetBytes(requestString); // Send the data through the socket. int bytesSent = sender.Send(msg); // Receive the response from the remote device. int bytesRec = sender.Receive(bytes); var responseString = Encoding.ASCII.GetString(bytes, 0, bytesRec); var response = JsonSerializer.Deserialize <WebSocketResponse>(responseString); // Release the socket. sender.Shutdown(SocketShutdown.Both); sender.Close(); return(response); } catch (ArgumentNullException ane) { Console.WriteLine("ArgumentNullException : {0}", ane.ToString()); } catch (SocketException se) { Console.WriteLine("SocketException : {0}", se.ToString()); } catch (Exception e) { Console.WriteLine("Unexpected exception : {0}", e.ToString()); } } catch (Exception e) { Console.WriteLine(e.ToString()); } return(null); }
public void Add(WebSocketRequest request) { _nextElement.Put(request); }
public WebSocketSyncRequest(WebSocketRequest request) { Request = request; WaitEvent = new ManualResetEvent(false); }
public void HandleWebSocket(WebSocketRequest req, WebSocketResponse resp) { resp.Write("server:" + (count++)); }
/// <summary> /// Точка входа в библиотеку. Отделяет полезные запросы от бесполезных и направляет каждый на свои парсеры /// </summary> /// <param name="page_type">Тип страницы: список матчей или страница кефа. Если страницы кефов нет - по умолчанию страница матчей</param> /// <param name="request_type">Тип запроса: обычный или фрейм WebSocket`а</param> /// <param name="request">Инфо с обычного запроса, либо NULL</param> /// <param name="wsFrame">Инфо о фрейме WebSocket`а, либо NULL</param> /// <returns>Вернуть распаршенную структуру Parsed или NULL, если запросу парсинг не требуется</returns> public Parsed Router(pageTypes page_type, requestTypes request_type, ref NormalRequest request, ref WebSocketRequest wsFrame) { return(new Parsed()); }
public bool SendRequest(WebSocketRequest request, bool isAsync = false) { request.ClientGuid = _applianceGuid; if (Status == WebSessionStatus.Logging) { _waitConnectionOpenedEvent.WaitOne(TimeSpan.FromSeconds(20)); } if (Status != WebSessionStatus.Active) { Console.WriteLine("Inactive connection. Refuse this request " + request); if (isAsync) { WebSocketNotificationHandler.ReceiveResponse(request.RequestId, false); } return false; } if (request.RequestType == WebSocketRequestType.PutFileProxyRequest) { PutFileProxyRequest putFileProxyRequest = (PutFileProxyRequest)request; foreach (NeedSendData needSendData in NeedSendDataManager.Instance.NeedSendDatas) { PutFileRequest putFileRequest = new PutFileRequest { RequestId = RequestHelper.NextRequestId(), FilePath = putFileProxyRequest.FilePath, FileData = needSendData.FileData, Position = needSendData.Position }; bool isSuccess = (bool)WebSocketHandler.SendRequestReturnResult(this, putFileRequest); Interlocked.Add(ref _sendDataLengthCount, needSendData.FileData.Length); if (!isSuccess) { WebSocketNotificationHandler.ReceiveResponse(putFileProxyRequest.RequestId, false); return false; } } WebSocketNotificationHandler.ReceiveResponse(putFileProxyRequest.RequestId, true); return true; } //Send file bytes directly to ESS Server without Json because frequent Json deserialization costs high // CPU in ESS Server. if (request.RequestType == WebSocketRequestType.PutFileRequest) { Interlocked.Increment(ref _getPutRequestCnt); PutFileRequest putFileRequest = (PutFileRequest)request; var data = WebSocketBlockWrite.PutFileRequestToByte(putFileRequest); var arrayList = new List<ArraySegment<byte>>(); var array = new ArraySegment<byte>(data); arrayList.Add(array); _webSocket.Send(arrayList); } return true; }