private void CC_ResponseReceived(object sender, ResponseReceivedEventArgs e)
{
FtpResponse response = e.Response;
int code = response.Code;
if (code != 150)
{
return;
}
//FtpResponseLine line = response.Lines[0];
//string resText = _client.UsedEncoding.GetString(line.Content);
string resText = response.RawStrings[0]; //_client.UsedEncoding.GetString(line.Content);
//------------------------------------
//Here we need to extract the name
//from the response.
for (int i = 0; i < _nameRegEx.Count; i++)
{
Regex r = (Regex)_nameRegEx[i];
Match m = r.Match(resText);
if (null != m)
{
Group gr = m.Groups["name"];
if (gr.Success)
{
_uniqueFileName = gr.Value.TrimEnd('.');
break;
}
}
}
}
private bool OnResponseReceived(DownloadResponse response)
{
var args = new ResponseReceivedEventArgs(Request, response);
ResponseReceived?.Invoke(this, args);
return(args.Abort);
}
protected bool OnResponseReceived(DownloadResponse response)
{
var eventArgs = new ResponseReceivedEventArgs(Request, response);
ResponseReceived?.Invoke(this, eventArgs);
return(eventArgs.Abort);
}
public void InvalidResponseRange()
{
Server.FileName = "MyFile.zip";
var file = GetDummyFile();
ResponseReceivedEventArgs responseReceivedEventArgs = null;
using (var fs = file.OpenWrite())
{
using (var connection = new DownloadConnection(GetDummyRequest(), new DownloadRange(0, File.Size * 2), fs)
)
{
connection.ResponseReceived += (sender, args) => { responseReceivedEventArgs = args; };
try
{
Assert.IsNotNull(StartConnection(connection).Result);
Assert.Fail("Connection failed to capture invalid response.");
}
catch (Exception ex)
{
Assert.IsTrue(ex.InnerException is DownloadException);
}
}
fs.Close();
}
Assert.IsNotNull(responseReceivedEventArgs);
Assert.AreEqual(HttpStatusCode.RequestedRangeNotSatisfiable, responseReceivedEventArgs.Response.StatusCode);
Assert.AreEqual(0, responseReceivedEventArgs.Response.Range.Start);
Assert.AreEqual(File.Size, responseReceivedEventArgs.Response.FileSize);
Assert.AreEqual(0, responseReceivedEventArgs.Response.ContentLength);
Assert.AreEqual(Server.FileName, responseReceivedEventArgs.Response.FileName);
Assert.AreEqual(Server.ContactType, responseReceivedEventArgs.Response.ContentType);
Assert.AreEqual(DummyUri, responseReceivedEventArgs.Response.Url);
file.Delete();
}
private async Task ProcessingTaskAsync(byte[] data)
{
var oldContext = Core.ContextGroupName;
try
{
(var body, var correlationId) = NATSQueueClient.GetFromMessageBody(data);
Counters.IncrementTotalReceivingBytes(body.Count);
Core.Log.LibVerbose("Received {0} bytes from the Queue '{1}/{2}'", body.Count, Connection.Route, Connection.Name);
var messageBody = ReceiverSerializer.Deserialize(body, _messageType);
switch (messageBody)
{
case RequestMessage request when request.Header != null:
if (!string.IsNullOrEmpty(request.Header.ContextGroupName))
{
Core.ContextGroupName = request.Header.ContextGroupName;
}
request.Header.ApplicationReceivedTime = Core.Now;
Counters.IncrementReceivingTime(request.Header.TotalTime);
if (request.Header.ClientName != Config.Name)
{
Core.Log.Warning("The Message Client Name '{0}' is different from the Server Name '{1}'", request.Header.ClientName, Config.Name);
}
var evArgs = new RequestReceivedEventArgs(_name, Connection, request, body.Count, SenderSerializer, Config.RequestOptions.ServerReceiverOptions.CancellationBeforeClientResponseTimeoutInSec);
if (request.Header.ResponseQueue != null)
{
evArgs.ResponseQueues.Add(request.Header.ResponseQueue);
}
await OnRequestReceivedAsync(evArgs).ConfigureAwait(false);
break;
case ResponseMessage response when response.Header != null:
if (!string.IsNullOrEmpty(response.Header.Request.Header.ContextGroupName))
{
Core.ContextGroupName = response.Header.Request.Header.ContextGroupName;
}
response.Header.Response.ApplicationReceivedTime = Core.Now;
Counters.IncrementReceivingTime(response.Header.Response.TotalTime);
var evArgs2 = new ResponseReceivedEventArgs(_name, response, body.Count);
await OnResponseReceivedAsync(evArgs2).ConfigureAwait(false);
break;
}
Counters.IncrementTotalMessagesProccesed();
}
catch (Exception ex)
{
Counters.IncrementTotalExceptions();
Core.Log.Write(ex);
Interlocked.Exchange(ref _exceptionSleep, 1);
}
finally
{
Core.ContextGroupName = oldContext;
}
}
private void Secure_OnResponseReceiveds(object sender, ResponseReceivedEventArgs e)
{
var data = e.Response;
Dictionary <string, object> result = new JavaScriptSerializer().DeserializeObject(data) as Dictionary <string, object>;
string action = (string)result["action"];
if (action == "banned_app")
{
MessageBox.Show("This application is banned, please contact the developer.", Auth.appName, MessageBoxButtons.OK, MessageBoxIcon.Error);
Environment.Exit(0);
}
else if (action == "failed_connection" || action == "internal_error")
{
MessageBox.Show("There was an error in the connection to the server!", Auth.appName, MessageBoxButtons.OK, MessageBoxIcon.Error);
Environment.Exit(0);
}
else if (action == "null_entry")
{
MessageBox.Show("You must send all parameters to the server!", Auth.appName, MessageBoxButtons.OK, MessageBoxIcon.Error);
Environment.Exit(0);
}
else if (action == "unfound_application")
{
MessageBox.Show("The application could not be found!", Auth.appName, MessageBoxButtons.OK, MessageBoxIcon.Error);
Environment.Exit(0);
}
else if (action == "initialize")
{
init_response(result);
Task_Done = true;
}
else if (action == "login")
{
login_response(result);
Task_Done = true;
}
else if (action == "licenseLogin")
{
licenseLogin_response(result);
Task_Done = true;
}
else if (action == "register")
{
register_response(result);
Task_Done = true;
}
else if (action == "extend_subscription")
{
extendtime_response(result);
Task_Done = true;
}
else if (action == "var")
{
var_response(result);
Task_Done = true;
}
}
/// <summary>
/// This method handles the Response Received event.
/// </summary>
/// <param name="e">Arguments for this event call.</param>
protected virtual void OnResponseReceived(ResponseReceivedEventArgs e)
{
EventHandler <ResponseReceivedEventArgs> handler = ResponseReceivedHandler;
if (handler != null)
{
handler(this, e);
}
}
private void OnStartGameRequest(ResponseReceivedEventArgs args)
{
if (args.Message.GetType() != typeof(ShowGameWindowRequest))
{
return;
}
var request = (ShowGameWindowRequest)args.Message;
Application.Current.Dispatcher.Invoke(() => new GameWindow(request.Rows, request.Columns, request.GameId, Username).Show());
}
private void OnTestRequest(ResponseReceivedEventArgs args)
{
if (args.Message.GetType() != typeof(TestRequest))
{
return;
}
var test = (TestRequest)args.Message;
MessageBox.Show(test.M);
}
public void SimlBot_Responsereceived(object sender, ResponseReceivedEventArgs e)
{
var chatResult = e.Result;
string botMessage = chatResult.BotMessage;
if (botMessage != "" && botMessage != null)
{
Messagereceived_processing(botMessage);
}
}
private void RefreshUsers(ResponseReceivedEventArgs args)
{
if (args.Message.GetType() != typeof(UserListMessage))
{
return;
}
var response = (UserListMessage)args.Message;
ConnectedPeople = new ObservableCollection <string>(response.Users);
}
private void AddMessage(ResponseReceivedEventArgs args)
{
if (args.Message.GetType() != typeof(GameSendMessageResponse))
{
return;
}
var responseMessage = (GameSendMessageResponse)args.Message;
Application.Current.Dispatcher.Invoke(() => {
Chat += $"{responseMessage.UserName}:{responseMessage.Message}{Environment.NewLine}";
});
}
/// <summary>
/// This function receives SIP responses, updates
/// session state variables, and proxies the response
/// </summary>
/// <remarks>
/// The response handler's name must be the name of
/// the function that is given in the SPL Dispatch
/// function for SIP responses.
/// </remarks>
/// <param name="sender">not used</param>
/// <param name="e">the response state</param>
public void ResponseHandler(object sender, ResponseReceivedEventArgs e)
{
/* If this is a 200 response and the method is
* BYE then the session is ending.
*/
Response response = e.Response;
if (e.ClientTransaction.ServerTransaction.Request.StandardMethod == Request.StandardMethodType.Bye)
{
///extract the call-id and cleanup session state
///ignore errors
Header callIdHeader = response.AllHeaders.FindFirst("Call-ID");
if (callIdHeader != null)
{
lock (sessionStateTable.SyncRoot) {
if (sessionStateTable[callIdHeader.Value] != null)
{
sessionStateTable.Remove(callIdHeader.Value);
statistics.Update(false /* SessionTearDown */);
}
}
}
}
///update other counters
statistics.Update(response.StatusClass);
///notify listeners
this.StateChangeListeners(e);
///Add a header if requested by user.
if (AddHeader)
{
Header h = new Header(SipSnoopHeaderName, SipSnoopHeaderValue);
e.Response.AllHeaders.Add(h);
}
if (ModifyToHeader)
{
Header toHeader = response.AllHeaders.FindFirst("To");
NameValueCollection toParamColl = toHeader.Parameters;
toParamColl.Set(SipSnoopParamName, SipSnoopParamValue);
toHeader.Parameters = toParamColl;
}
///done with state management, so forward the response
e.ClientTransaction.ServerTransaction.SendResponse(e.Response);
return;
}
private async Task ProcessingTaskAsync(NSQMessage message)
{
if (message.Body == null)
{
return;
}
try
{
Core.Log.LibVerbose("Received {0} bytes from the Queue '{1}/{2}'", message.Body.Count, Connection.Route, Connection.Name);
var messageBody = ReceiverSerializer.Deserialize(message.Body, _messageType);
switch (messageBody)
{
case RequestMessage request when request.Header != null:
request.Header.ApplicationReceivedTime = Core.Now;
Counters.IncrementReceivingTime(request.Header.TotalTime);
if (request.Header.ClientName != Config.Name)
{
Core.Log.Warning("The Message Client Name '{0}' is different from the Server Name '{1}'", request.Header.ClientName, Config.Name);
}
var evArgs = new RequestReceivedEventArgs(_name, Connection, request, message.Body.Count);
if (request.Header.ResponseQueue != null)
{
evArgs.ResponseQueues.Add(request.Header.ResponseQueue);
}
await OnRequestReceivedAsync(evArgs).ConfigureAwait(false);
break;
case ResponseMessage response when response.Header != null:
response.Header.Response.ApplicationReceivedTime = Core.Now;
Counters.IncrementReceivingTime(response.Header.Response.TotalTime);
var evArgs2 = new ResponseReceivedEventArgs(_name, response, message.Body.Count);
await OnResponseReceivedAsync(evArgs2).ConfigureAwait(false);
break;
}
Counters.IncrementTotalMessagesProccesed();
}
catch (Exception ex)
{
Counters.IncrementTotalExceptions();
Core.Log.Write(ex);
lock (_lock)
_exceptionSleep = true;
}
}
public void ResponseReceived(object sender, ResponseReceivedEventArgs e)
{
int i = Singleton.GetInstance().LastLightPointer;
int j = Singleton.GetInstance().LastTemperaturePointer;
//int arrayLength = Singleton.GetInstance().LightStorage.Length;
string line = "";
EnableAllButtons();
//label.text = "UiManager "+e.Resource + " : " + e.Data;
Debug.Log("La respuesta es: " + e.Resource + " : " + e.Data);
if (e.Resource == "light")
{
labelLight.text = e.Data;
Singleton.GetInstance().LightStorage[i] = int.Parse(e.Data);
i = (i + 1) % 10;
Singleton.GetInstance().LastLightPointer = i;
Singleton.GetInstance().isLightUpdated = true;
Debug.Log(Singleton.GetInstance().LastLightPointer);
foreach (var item in Singleton.GetInstance().LightStorage)
{
line += item.ToString() + ", ";
}
arrayLight.text = line;
}
else if (e.Resource == "temperature")
{
labelTemp.text = e.Data;
Singleton.GetInstance().TemperatureStorage[j] = int.Parse(e.Data);
j = (j + 1) % 10;
Singleton.GetInstance().LastTemperaturePointer = j;
Singleton.GetInstance().isTemperatureUpdated = true;
Debug.Log(Singleton.GetInstance().LastTemperaturePointer);
foreach (var item in Singleton.GetInstance().TemperatureStorage)
{
line += item.ToString() + ", ";
}
arrayTemp.text = line;
}
else
{
label.text = "UiManager " + e.Resource + " : " + e.Data;
}
//label.text = System.DateTime.Now.ToString();
}
private void OnGameResponseMessage(ResponseReceivedEventArgs args)
{
if (args.Message.GetType() != typeof(GameMoveMessageResponse))
{
return;
}
var response = (GameMoveMessageResponse)args.Message;
Application.Current.Dispatcher.Invoke(() => {
var disabledLines = Lines.Where(dic => dic.Value.Background == System.Windows.Media.Brushes.Black).Select(o => o.Value).ToList();
foreach (var line in disabledLines)
{
line.Background = new Button().Background;
line.IsHitTestVisible = true;
}
});
foreach (var line in response.Lines)
{
Application.Current.Dispatcher.Invoke(() => {
Lines[$"A{line.Item1.X}a{line.Item1.Y}b{line.Item2.X}a{line.Item2.Y}"].Background = System.Windows.Media.Brushes.Red;
});
}
foreach (var square in response.Squares)
{
Application.Current.Dispatcher.Invoke(() => {
Stackpanels[square.Id].Background = square.Player == Username ? System.Windows.Media.Brushes.Green : System.Windows.Media.Brushes.Red;
});
}
Application.Current.Dispatcher.Invoke(() => {
var notSelectedLines = Lines.Where(dic => dic.Value.Background != System.Windows.Media.Brushes.Red).Select(o => o.Value).ToList();
var amountOfLinesToDisable = notSelectedLines.Count * 10 / 100;
var random = new Random();
while (amountOfLinesToDisable > 0)
{
var i = random.Next(0, notSelectedLines.Count);
notSelectedLines[i].Background = System.Windows.Media.Brushes.Black;
notSelectedLines[i].IsHitTestVisible = false;
amountOfLinesToDisable--;
}
});
}
private async Task ResponseReceivedHandler(object sender, ResponseReceivedEventArgs e)
{
try
{
var sw = Stopwatch.StartNew();
if (MessageReceived != null)
{
await MessageReceived.InvokeAsync(this, new MessageEventArgs(e.Message)).ConfigureAwait(false);
}
if (e.Message?.Body is null)
{
return;
}
var body = e.Message.Body.GetValue();
if (EnableCompleteMessageCache)
{
ResponseMessageCache.Add(body, e.Message);
}
Status.IncrementCurrentMessagesBeingProcessed();
try
{
await Processor.ProcessAsync(body, _cTokenSource.Token).ConfigureAwait(false);
}
catch (Exception ex)
{
Core.Log.Write(ex);
Status.IncrementTotalExceptions();
}
sw.Stop();
Status.ReportProcessingTime(sw.Elapsed.TotalMilliseconds);
Status.DecrementCurrentMessagesBeingProcessed();
Status.IncrementTotalMessagesProccesed();
if (EnableCompleteMessageCache)
{
ResponseMessageCache.Remove(body);
}
}
catch (Exception ex)
{
Core.Log.Write(ex);
Status.IncrementTotalExceptions();
}
}
private void OnChallangeRequest(ResponseReceivedEventArgs args)
{
if (args.Message.GetType() != typeof(ChallangeRequest))
{
return;
}
var request = (ChallangeRequest)args.Message;
var dialogResult = MessageBox.Show($"{request.FromUser}", " has challanged you !! Do you accept?", MessageBoxButton.YesNo);
if (dialogResult == MessageBoxResult.Yes)
{
Client.Instance.SendMessage(new ChallangeResponse(request.FromUser, true));
}
else if (dialogResult == MessageBoxResult.No)
{
Client.Instance.SendMessage(new ChallangeResponse(request.FromUser, false));
}
}
/// <summary>
/// Gets a response from a CoAP request.
///
/// This method is called automatically by the CoAP library each
/// time a request is responded.
/// </summary>
/// <param name="response">The CoAP response (resource/value).</param>
public void GetResponse(string response)
{
ResponseReceivedEventArgs args = new ResponseReceivedEventArgs();
if (response != "Error")
{
string[] msg = response.Split('/');
args.Resource = msg[0];
args.Data = msg[1];
OnResponseReceived(args);
}
else
{
args.Resource = "Error";
args.Data = "Error";
OnResponseReceived(args);
}
}
private void reader_ResponseReceived(Reader sender, ResponseReceivedEventArgs e)
{
string MethodeName = MethodBase.GetCurrentMethod().ToString();
if (e.Message is VersionResponse)
{
VersionResponse r = (VersionResponse)e.Message;
Console.WriteLine("Hardware version = " + r.HardwareVersion);
Console.WriteLine("Firmware version = " + r.FirmwareVersion);
}
else if (e.Message is RegionResponse)
{
RegionResponse r = (RegionResponse)e.Message;
Console.WriteLine("Region " + r.Region.ToString() + " set. Regions supported by this reader:");
foreach (Region region in r.SupportedRegions)
{
Console.WriteLine("- " + region.ToString());
}
}
}
private void secure_OnResponseReceived(object sender, ResponseReceivedEventArgs e)
{
btnLogin.Enabled = true;
JToken credentials = JToken.Parse(e.Response);
bool success = (bool)credentials["success"];
if (success == false)
{
int errorCode = (int)credentials["code"];
if (errorCode == 1)
{
MessageBox.Show(credentials["description"].ToString(), "Ошибка");
}
else if (errorCode == 2)
{
string value = "";
if (InputBox.Show("Подтверждение авторизации", credentials["description"].ToString(), ref value) == DialogResult.OK)
{
string data = $"authorize,{txtLogin.Text},{txtPassword.Text},{value}";
if (secure.ReadyToSendData)
{
secure.SendDataSecureAsync(data);
btnLogin.Enabled = false;
}
}
}
}
else
{
string token = credentials["token"].ToString();
int uid = (int)credentials["uid"];
var MyIni = new IniFile();
MyIni.Write("Token", token);
MyIni.Write("UserID", uid.ToString());
MessageBox.Show("Авторизация прошла успешно", "Успешно");
this.Hide();
var mform = new MainForm();
mform.Closed += (s, args) => this.Close();
mform.Show();
}
}
public void ValidResponse()
{
Server.FileName = "MyFile.zip";
var file = GetDummyFile();
ResponseReceivedEventArgs responseReceivedEventArgs = null;
using (var fs = file.OpenWrite())
{
using (var connection = new DownloadConnection(GetDummyRequest(), fs))
{
connection.ResponseReceived += (sender, args) =>
{
args.Abort = true;
responseReceivedEventArgs = args;
};
try
{
Assert.IsNotNull(StartConnection(connection).Result);
}
catch (Exception ex)
{
if (!(ex.InnerException is OperationCanceledException))
{
throw;
}
}
}
fs.Close();
}
Assert.IsNotNull(responseReceivedEventArgs);
Assert.IsTrue((responseReceivedEventArgs.Response.StatusCode == HttpStatusCode.PartialContent) ||
(responseReceivedEventArgs.Response.StatusCode == HttpStatusCode.OK));
Assert.AreEqual(0, responseReceivedEventArgs.Response.Range.Start);
Assert.AreEqual(File.Size, responseReceivedEventArgs.Response.Range.Length);
Assert.AreEqual(File.Size, responseReceivedEventArgs.Response.FileSize);
Assert.AreEqual(File.Size, responseReceivedEventArgs.Response.ContentLength);
Assert.AreEqual(Server.FileName, responseReceivedEventArgs.Response.FileName);
Assert.AreEqual(Server.ContactType, responseReceivedEventArgs.Response.ContentType);
Assert.AreEqual(DummyUri, responseReceivedEventArgs.Response.Url);
file.Delete();
}
//
//
// Response handler. Proxy the message, then log to disk if it hasn't been
// logged on another server by an instance of this application.
//
// Responses to INVITE, ACK, MESSAGE, and BYE are handled here, as configured
// in Archiver.am.
//
public void OnResponse(object sender, ResponseReceivedEventArgs e)
{
//
// Proxy the response.
//
e.ClientTransaction.ServerTransaction.SendResponse(e.Response);
//
// If this response hasn't been marked as already archived, log it
// to file.
//
if (e.Response.Stamp != "Archived")
{
lock (LogFile)
{
LogFile.WriteLine("-----------------------------------------------------------");
LogFile.WriteLine(" Response: {0} {1}", e.Response.StatusCode, e.Response.ReasonPhrase);
foreach (Header h in e.Response.AllHeaders)
{
LogFile.WriteLine(" {0}: {1}", h.Type, h.Value);
}
LogFile.WriteLine();
LogFile.WriteLine(e.Response.Content);
LogFile.Flush();
}
//
// Stamp the message as having been archived.
//
e.Response.Stamp = "Archived";
}
else
{
//
// This message has a stamp, and has been logged by another instance
// of Archiver.
//
}
}
private void cd_ResponseReceived(object sender, ResponseReceivedEventArgs e)
{
var cd = (HttpRangeDownloader)sender;
if (Info == null)
{
Info = HttpDownloadInfo.GetFromResponse(e.Response, Url);
LastInfo = Info.Clone();
cd.Info = Info.Clone();
cd.Wait = Info.AcceptRanges;
var chunkedHeader = e.Response.Headers[HttpResponseHeader.TransferEncoding];
UseChunk = Info.AcceptRanges && chunkedHeader != null && chunkedHeader.ToLower() == "chunked";
Ranges.First().End = Info.ContentSize - 1;
//NofThread = Info.AcceptRanges ? NofThread : 1;
DownloadInfoReceived.Raise(this, EventArgs.Empty);
}
if (NofActiveThreads > 1 && Info.AcceptRanges && Info.ResumeCapability != Resumeability.Yes)
{
Info.ResumeCapability = Resumeability.Yes;
foreach (var a in cdList)
{
Info.AcceptRanges = true;
a.Info.AcceptRanges = true;
}
foreach (var item in cdList.Where(x => x.Wait))
{
item.Wait = false;
}
}
if (Info.ContentSize < 10 * 1024 + 1)
{
foreach (var item in cdList.Where(x => x.Wait))
{
item.Wait = false;
}
}
createNewThreadIfRequired();
}
private void OnConnectResponse(ResponseReceivedEventArgs args)
{
if (args.Message.GetType() != typeof(ConnectResponse))
{
return;
}
var connectResponse = (ConnectResponse)args.Message;
if (connectResponse.Status == false)
{
MessageBox.Show("Incorrect credentials");
}
else
{
Application.Current.Dispatcher.Invoke(() => {
var mainWindow = new MainWindow();
mainWindow.Show();
AttachedWindow.Close();
});
Client.Instance.OnResponseReceived -= OnConnectResponse;
}
}
private async void OnNetworkResponseReceived(object sender, Network.ResponseReceivedEventArgs e)
{
HttpResponseData responseData = new HttpResponseData()
{
StatusCode = e.Response.Status,
Url = e.Response.Url,
ResourceType = e.Type.ToString()
};
foreach (var header in e.Response.Headers)
{
responseData.Headers.Add(header.Key, header.Value);
}
var body = await network.GetResponseBody(new Network.GetResponseBodyCommandSettings()
{
RequestId = e.RequestId
});
if (body.Base64Encoded)
{
responseData.Body = Encoding.UTF8.GetString(Convert.FromBase64String(body.Body));
}
else
{
responseData.Body = body.Body;
}
ResponseReceivedEventArgs wrapped = new ResponseReceivedEventArgs()
{
RequestId = e.RequestId,
ResponseData = responseData
};
this.OnResponseReceived(wrapped);
}
public void ResponseReceived(object sender, ResponseReceivedEventArgs e)
{
if (Equals("led", e.Resource))
{
if (Equals(e.Data, "0"))
{
bLightState = false;
light_state.text = "Light: OFF";
button_light_state.text = "Switch Light ON";
}
else if (Equals(e.Data, "1"))
{
bLightState = true;
light_state.text = "Light: ON";
button_light_state.text = "Switch Light OFF";
}
}
else if (Equals("light", e.Resource))
{
inside_brightness.text = inside_brightness.text + e.Data;
}
else if (Equals("temperature", e.Resource))
{
inside_temp.text = inside_temp.text + e.Data;
}
if (iRequestCounter < 2)
{
iRequestCounter++;
}
else
{
iRequestCounter = 0;
}
//testText.text = testText.text + e.Resource + ":" + e.Data + " "; //REMOVE
}
private void secure_OnResponseReceived(object sender, ResponseReceivedEventArgs e)
{
MessageBox.Show(e.Response);
}
private void secure_OnResponseReceived(object sender, ResponseReceivedEventArgs e)
{
MessageBox.Show(e.Response);
}
void OnResponseReceived(object sender, ResponseReceivedEventArgs e)
{
view.Log += "Response: " + e.ResponseText;
}
private async Task ProcessingTaskAsync(RabbitMessage message)
{
if (message.Body is null)
{
RabbitMessage.Return(message);
return;
}
var oldContext = Core.ContextGroupName;
try
{
Counters.IncrementTotalReceivingBytes(message.Body.Length);
Core.Log.LibVerbose("Received {0} bytes from the Queue '{1}/{2}'", message.Body.Length, _receiver.Route, _receiver.Name);
var messageBody = ReceiverSerializer.Deserialize(message.Body, _messageType);
switch (messageBody)
{
case RequestMessage request when request.Header != null:
if (!string.IsNullOrEmpty(request.Header.ContextGroupName))
{
Core.ContextGroupName = request.Header.ContextGroupName;
}
request.Header.ApplicationReceivedTime = Core.Now;
Counters.IncrementReceivingTime(request.Header.TotalTime);
if (request.Header.ClientName != Config.Name)
{
Core.Log.Warning("The Message Client Name '{0}' is different from the Server Name '{1}'", request.Header.ClientName, Config.Name);
}
var evArgs = new RequestReceivedEventArgs(_name, _receiver, request, message.Body.Length, SenderSerializer, Config.RequestOptions.ServerReceiverOptions.CancellationBeforeClientResponseTimeoutInSec);
evArgs.Metadata["ReplyTo"] = message.Properties.ReplyTo;
evArgs.Metadata["MessageId"] = message.Properties.MessageId;
if (request.Header.ResponseQueue != null)
{
evArgs.ResponseQueues.Add(request.Header.ResponseQueue);
}
await OnRequestReceivedAsync(evArgs).ConfigureAwait(false);
break;
case ResponseMessage response when response.Header != null:
if (!string.IsNullOrEmpty(response.Header.Request.Header.ContextGroupName))
{
Core.ContextGroupName = response.Header.Request.Header.ContextGroupName;
}
response.Header.Response.ApplicationReceivedTime = Core.Now;
Counters.IncrementReceivingTime(response.Header.Response.TotalTime);
var evArgs2 = new ResponseReceivedEventArgs(_name, response, message.Body.Length);
evArgs2.Metadata["ReplyTo"] = message.Properties.ReplyTo;
evArgs2.Metadata["MessageId"] = message.Properties.MessageId;
await OnResponseReceivedAsync(evArgs2).ConfigureAwait(false);
break;
}
Counters.IncrementTotalMessagesProccesed();
}
catch (Exception ex)
{
Counters.IncrementTotalExceptions();
Core.Log.Write(ex);
Interlocked.Exchange(ref _exceptionSleep, 1);
}
finally
{
Core.ContextGroupName = oldContext;
RabbitMessage.Return(message);
}
}
static void ResponseReceived(Object sender, ResponseReceivedEventArgs e)
{
Console.Error.WriteLine(String.Format("> {0:s}", e.Line));
}
/*protected virtual*/ void OnResponseReceived(ResponseReceivedEventArgs e)
{
RequestEventHandler<ResponseReceivedEventArgs> handler = ResponseReceived;
if (handler != null)
{
handler(this, client, e);
}
}
