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