//---------------------------------------------------------------------------------------------------------------------- public void GetRequest() { var webRequest = (HttpWebRequest)WebRequest.Create(_url); webRequest.ContentType = "application/json"; webRequest.Method = "GET"; webRequest.Headers.Add(HttpRequestHeader.Authorization, $"Bearer {BearerToken}"); HttpWebResponse webResponse; try { webResponse = (HttpWebResponse)webRequest.GetResponse(); } catch (WebException e) { var httpStatusCode = ((HttpWebResponse)e.Response).StatusCode; _responseHandler.Invoke(null, httpStatusCode); return; } var resultObject = GetResultObject(webResponse); _responseHandler.Invoke(resultObject, webResponse.StatusCode); }
public virtual void ProcessPacket(XBeeResponse packet) { if (Finished) { return; } var packetAccepted = Filter == null || Filter.Accepted(packet); var finished = Filter != null && Filter.Finished(); if (!packetAccepted) { return; } if (ResponseHandler != null) { ResponseHandler.Invoke(packet, finished); } else { Packets.Add(packet); } Finished = finished; }
private static IEnumerator WaitForResponse(UnityWebRequestAsyncOperation asyncOperation, ResponseHandler onComplete) { yield return(asyncOperation); onComplete?.Invoke(asyncOperation.webRequest); }
public void SendResponseBodyContent(string content, Encoding encoding) { AssertWithMessage.NotNull(_responseHandler, "No response handler was set."); byte[] bytes = encoding.GetBytes(content); _responseHandler.Invoke(bytes, 0, bytes.Length); }
public void Process() { if (ReceiveHandler != null) { // Execute receiveHandler TReceiveReturnType retVal = ReceiveHandler(Message.PayloadValues); // Execute responseHandler, passing return Client and receiveHandler's return value ResponseHandler?.Invoke(Message.Session, retVal); } }
/// <summary> /// Reads some raw data into a ResponseHandler method. /// </summary> /// <returns> /// A task that completes when enough data has been returned by the server. /// The task returns the number of bytes sent to the ResponseHandler. /// </returns> public async Task <int> ReadBytesIntoResponseHandler(long totalBytesToRead, ResponseHandler handler, CancellationToken cancellationToken) { long totalBytesRead = 0; while (totalBytesToRead > 0) { if (cancellationToken.IsCancellationRequested) { break; } int bytesRemainingInBuffer = _bufferStopPosition - _bufferCurrentPosition; if (bytesRemainingInBuffer == 0) { await ReceiveMoreBytes(cancellationToken); bytesRemainingInBuffer = _bufferStopPosition - _bufferCurrentPosition; } int bytesToRead; if (totalBytesToRead < bytesRemainingInBuffer) { // This cast is safe because totalBytesToRead < bytesRemainingInBuffer, // and bytesRemainingInBuffer is an int. bytesToRead = (int)totalBytesToRead; } else { bytesToRead = bytesRemainingInBuffer; } await handler.Invoke(_buffer, _bufferCurrentPosition, bytesToRead); _bufferCurrentPosition += bytesToRead; totalBytesRead += bytesToRead; totalBytesToRead -= bytesToRead; } return((int)totalBytesRead); }
/// <summary> /// Called when an async result is returned /// </summary> /// <param name="e"></param> protected void OnResponseEvent(SuccessEventArgs e) { ResponseHandler?.Invoke(this, e); }
private void InvokeCallback(string error_code, SnipeObject response_data) { mCallback?.Invoke(error_code, response_data); Dispose(); }
private void HandleRequest(RequestData request, ResponseHandler responseHandler) { switch (request.Request) { case Request.Disconnect: // server closed or kicked player HandleDisconnect(); break; case Request.Heartbeat: // Response is send below. break; case Request.StartGame: if (Game != null) { responseHandler?.Invoke(ResponseType.BadState); return; } serverState = ServerState.Loading; if (PlayerIndex == 0u) { // We have to wait for first heartbeat to set the player index. SendHeartbeatRequest(response => { GameStarted?.Invoke(this, EventArgs.Empty); SendStartGameRequest(); }); } else { GameStarted?.Invoke(this, EventArgs.Empty); SendStartGameRequest(); } return; case Request.AllowUserInput: if (serverState == ServerState.Loading) { serverState = ServerState.Game; } InputAllowed?.Invoke(this, EventArgs.Empty); break; case Request.DisallowUserInput: InputDisallowed?.Invoke(this, EventArgs.Empty); break; case Request.Pause: GamePaused?.Invoke(this, EventArgs.Empty); break; case Request.Resume: GameResumed?.Invoke(this, EventArgs.Empty); break; default: // all other requests can not be send to a client throw new ExceptionFreeserf(ErrorSystemType.Network, $"Request {request} can not be send to a client."); } RespondToRequest(request); }
void ProcessData(IRemoteServer server, INetworkData networkData, ResponseHandler responseHandler) { switch (networkData.Type) { case NetworkDataType.Request: HandleRequest(networkData as RequestData, responseHandler); break; case NetworkDataType.Heartbeat: { var heartbeat = networkData as Heartbeat; // Last heartbeat time was set before. if (PlayerIndex == 0u) { PlayerIndex = heartbeat.PlayerId; } foreach (var registeredHeartbeatHandler in registeredHeartbeatHandlers.ToArray()) { registeredHeartbeatHandler?.Invoke(heartbeat); } responseHandler?.Invoke(ResponseType.Ok); break; } case NetworkDataType.LobbyData: if (serverState != ServerState.Lobby) { responseHandler?.Invoke(ResponseType.BadState); } else { responseHandler?.Invoke(ResponseType.Ok); UpdateLobbyData(networkData as LobbyData); } break; case NetworkDataType.Response: { var responseData = networkData as ResponseData; foreach (var registeredResponseHandler in registeredResponseHandlers.ToArray()) { registeredResponseHandler?.Invoke(responseData); } break; } case NetworkDataType.InSync: { if (serverState != ServerState.Game && serverState != ServerState.Loading) { responseHandler?.Invoke(ResponseType.BadState); } else { if (Game == null) { serverState = ServerState.Offline; responseHandler?.Invoke(ResponseType.BadState); return; } try { var insyncData = networkData as InSyncData; Log.Verbose.Write(ErrorSystemType.Network, $"Processing in-sync message with game time {Misc.SecondsToTime(insyncData.GameTime)}."); if (!lastSavedGameStates.ContainsKey(insyncData.GameTime)) // We don't have the saved state anymore -> need full update { Log.Verbose.Write(ErrorSystemType.Network, $"Last saved game state with game time {Misc.SecondsToTime(insyncData.GameTime)} not available. Requesting re-sync."); RequestGameStateUpdate(); return; } Log.Verbose.Write(ErrorSystemType.Network, $"Updating last synced saved state to game time {Misc.SecondsToTime(insyncData.GameTime)} and discarding outdated saved game states."); lastVerifiedSavedGameState = lastSavedGameStates[insyncData.GameTime]; // Remove all outdated (timestamp before in-sync game time) saved states. foreach (var outdatedSavedGameState in lastSavedGameStates.Where(s => s.Key <= insyncData.GameTime).ToList()) { lastSavedGameStates.Remove(outdatedSavedGameState.Key); } } catch (Exception ex) { Log.Error.Write(ErrorSystemType.Network, "Failed to update game state: " + ex.Message); Disconnect(); throw ex; // TODO: Close game instead of crash? } } break; } case NetworkDataType.SyncData: { if (serverState != ServerState.Game && serverState != ServerState.Loading) { responseHandler?.Invoke(ResponseType.BadState); } else { if (Game == null) { serverState = ServerState.Offline; responseHandler?.Invoke(ResponseType.BadState); return; } try { var syncData = networkData as SyncData; #if DEBUG var stopWatch = System.Diagnostics.Stopwatch.StartNew(); Log.Verbose.Write(ErrorSystemType.Network, "Processing sync ... "); #endif lock (Game) { lastSavedGameStates.Clear(); if (lastVerifiedSavedGameState == null) { lastVerifiedSavedGameState = SavedGameState.FromGame(Game); } lastVerifiedSavedGameState = SavedGameState.UpdateGameAndLastState(Game, lastVerifiedSavedGameState, syncData.SerializedData, syncData.Full); } #if DEBUG Log.Verbose.Write(ErrorSystemType.Network, $"Processing sync done in {stopWatch.ElapsedMilliseconds / 1000.0} seconds"); #endif } catch (Exception ex) { Log.Error.Write(ErrorSystemType.Network, "Failed to update game state: " + ex.Message); Disconnect(); throw ex; // TODO: Close game instead of crash? } } break; } default: // Should have been handled by Server_DataReceived already. break; } }