public void FileReceiver_ReceivingCompletedEvent(ReceiveResult result, string message, string title) { if (result == ReceiveResult.Completed) { MessageBox.Show(message, title, MessageBoxButtons.OK, MessageBoxIcon.Information); } else if (result == ReceiveResult.FileIgnoredByUser) { MessageBox.Show(message, title, MessageBoxButtons.OK, MessageBoxIcon.Warning); } else if (result == ReceiveResult.Cancelled) { MessageBox.Show(message, title, MessageBoxButtons.OK, MessageBoxIcon.Warning); } else if (result == ReceiveResult.CannotReceived) { MessageBox.Show(message, title, MessageBoxButtons.OK, MessageBoxIcon.Error); } progressBarReceiveFile.Value = 0; btnReceiveFile.Text = Translator.GetStringFromResource("btnReceiveFile"); labelReceivedProgress.Text = string.Empty; progressBarReceiveFile.Visible = false; btnSelectSaveLocation.Enabled = true; txtReceiveIpAdress.Enabled = true; txtReceivePort.Enabled = true; txtSaveLocation.Enabled = true; }
private void CollectLocks(MsmqQueue lockQueue) { ReceiveResult result = ReceiveResult.MessageReceived; while (result == ReceiveResult.MessageReceived) { using (MsmqMessageLookupId message = new MsmqMessageLookupId()) { try { result = lockQueue.TryPeek(message, TimeSpan.FromSeconds(0)); if (result == ReceiveResult.MessageReceived) { lockQueue.TryMoveMessage(message.lookupId.Value, this.mainQueueForMove, MsmqTransactionMode.None); } } catch (MsmqException ex) { // we will retry the collection in the next cleanup round MsmqDiagnostics.ExpectedException(ex); result = ReceiveResult.Unknown; } } } }
public override IResult Execute() { #region Code for sending command to remote system PacketElements CommandPacketElems = new PacketElements(); CommandPacketElems.ActualCommand = Command; long HeaderValue = long.Parse(ConfigurationSettings.AppSettings["CommandHeader"]); CommandPacketElems.Header = HeaderValue; PackCommand CommandPckt = new PackCommand(); CommandPckt.PacketElements = CommandPacketElems; TransmitCommand SendCmd = new TransmitCommand(); SendCmd.DataPacket = CommandPckt.CommandPack; SendCmd.RemoteSystemName = NetParams.RemoteSystemName; SendCmd.SendCommand(); #endregion #region Code for receiving result from remote system ReceiveResult ReceiveData = new ReceiveResult(); ResultPacketElement ResultElements = ReceiveData.GetResultPacket(); IResult Result = new ExecutionResult(); if (ResultElements.Header == int.Parse(ConfigurationSettings.AppSettings["ResultHeader"])) { Result = ResultElements.ActualResult; } else { throw(new ApplicationException("Corrupted Result")); } #endregion return(Result); }
private void Action(object obj) { var cancellationToken = (CancellationToken)obj; while (!cancellationToken.IsCancellationRequested) { var result = new ReceiveResult(); try { using (var connection = new OracleConnection(this.ConnectionString)) { using (var queue = new OracleAQQueue(this.workQueue, connection, OracleAQMessageType.Xml)) { connection.Open(); this.SetupClientInfo(connection); queue.Listen(null); result = this.TryReceive(queue); } } } finally { if (result.Message != null) { this.endProcessMessage(result.Message, result.Exception); } } this.circuitBreaker.Success(); } }
private ReceiveResult TryReceive(OracleAQQueue queue) { var result = new ReceiveResult(); using (var ts = new TransactionScope(TransactionScopeOption.Required, this.transactionOptions)) { queue.Connection.EnlistTransaction(Transaction.Current); result.Message = this.Receive(queue); try { if (result.Message == null || this.tryProcessMessage(result.Message)) { // NOTE: We explicitly calling Dispose so that we force any exception to not bubble, // eg Concurrency/Deadlock exception. ts.Complete(); ts.Dispose(); } } catch (Exception ex) { result.Exception = ex; } return(result); } }
public void OnFinalResult(string result) { resultText.text = result; // clickBttn(); if (this.modelkey.Equals("q")) { MyInteractionManager im = GameObject.Find("GameManager").GetComponent <MyInteractionManager> (); bool correct = im.questionManager(this.question, result); if (correct) { im.globalScore += 5; Destroy(this.target); } return; } ReceiveResult r = new ReceiveResult(); r.setModel(this.modelkey); r.setVoiceType(this.voiceType); r.Start(); r.setAnswer(result); //Button btn = GameObject.Find("apibtn").GetComponent<Button>(); //btn.onClick.Invoke(); r.active(); }
private void Update() { diceVelocity = rb.velocity; if (rolled && rb.angularVelocity == Vector3.zero && rb.velocity == Vector3.zero) { Vector3 smallestAngleVector = new Vector3(); float smallestAngle = 180; foreach (var vector in ListCrossVectors) { var rotation = transform.rotation; var csna = rotation * vector; var dg = Vector3.Angle(new Vector3(0, 1, 0), rotation * vector); if (Vector3.Angle(new Vector3(0, 1, 0), rotation * vector) < smallestAngle) { smallestAngle = Vector3.Angle(new Vector3(0, 1, 0), rotation * vector); smallestAngleVector = vector; } } inactiveDuration += Time.deltaTime; if (inactiveDuration > inactiveConfirmDelay) { rolled = false; Debug.Log("Roll result: " + (ListCrossVectors.IndexOf(smallestAngleVector) + 1).ToString()); ReceiveResult.Invoke(this, ListCrossVectors.IndexOf(smallestAngleVector) + 1); } } else { inactiveDuration = 0; } }
// This is only called when the scene loads. void Start() { result = GameObject.Find("Main Camera").GetComponent <ReceiveResult>(); // Strictly for debugging to test a few words! if (isDebug) { StartCoroutine(Process("fr", "en", "Bonsoir")); } }
/// <summary> /// Consumes a message on a daemon thread using a blocking receive call /// (traced with the <see cref="IIncomingMessageReceiveTracer"/> and <see cref="IIncomingMessageProcessTracer"/>) /// The Dynatrace tag is transported along with the message /// </summary> public static void ConsumerDaemonExample() { string serverEndpoint = "messageserver.example.com:1234"; string topic = "my-topic"; IMessagingSystemInfo messagingSystemInfo = SampleApplication.OneAgentSdk .CreateMessagingSystemInfo(MessageSystemVendor.KAFKA, topic, MessageDestinationType.TOPIC, ChannelType.TCP_IP, serverEndpoint); IIncomingMessageReceiveTracer receiveTracer = SampleApplication.OneAgentSdk.TraceIncomingMessageReceive(messagingSystemInfo); receiveTracer.Start(); try { // blocking call until message is available: ReceiveResult receiveResult = MyMessagingSystem.ReceiveMessage(); Message message = receiveResult.Message; IIncomingMessageProcessTracer processTracer = SampleApplication.OneAgentSdk.TraceIncomingMessageProcess(messagingSystemInfo); // retrieve Dynatrace tag created using the outgoing message tracer to link both sides together: if (message.Headers.ContainsKey(OneAgentSdkConstants.DYNATRACE_MESSAGE_PROPERTYNAME)) { processTracer.SetDynatraceByteTag(message.Headers[OneAgentSdkConstants.DYNATRACE_MESSAGE_PROPERTYNAME]); } // start processing: processTracer.Start(); processTracer.SetCorrelationId(message.CorrelationId); // optional processTracer.SetVendorMessageId(receiveResult.VendorMessageId); // optional try { ProcessMessage(message); // do the work ... } catch (Exception e) { processTracer.Error(e); // handle or rethrow throw e; } finally { processTracer.End(); } } catch (Exception e) { receiveTracer.Error(e); // handle or rethrow throw e; } finally { receiveTracer.End(); } }
/// <summary> /// /// </summary> /// <exception cref="IOException"/> /// <exception cref="SocketException"/> //[DebuggerStepThrough] public static Exception ToException(this ReceiveResult receiveResult) { if (receiveResult.SocketError != SocketError.Success) { return(new SocketException((int)receiveResult.SocketError)); } else { return(new IOException("Unexpected connection closed during read.")); } }
public void Shutdown() { ReceiveResult result = RequestAndReceive(new Request { Kind = RequestKind.Shutdown }, TimeSpan.FromSeconds(1)); if (result.Timeout) { Kill(); } _process.Dispose(); }
public override bool Receive(int suggestedBufferLength, TimeSpan timeout, out ReceiveResult receiveResult) { if (m_RecvMemoryOwner == null) { m_RecvMemoryOwner = MemoryPool.Rent(suggestedBufferLength); m_RecvSAEA.SetBuffer(m_RecvMemoryOwner.Memory); m_RecvSAEA.RemoteEndPoint = s_AnyEndPoint; var pending = false; try { pending = Socket.ReceiveFromAsync(m_RecvSAEA); } catch (SocketException ex) { WrapAndThrowSocketException(ex); } if (pending && !m_RecvSAEA.Wait(timeout)) { receiveResult = default; return(false); } } else { if (!m_RecvSAEA.Wait(timeout) == false) { receiveResult = default; return(false); } } try { CheckSocketError(m_RecvSAEA.SocketError); var remoteEndPoint = m_RecvSAEA.RemoteEndPoint as IPEndPoint ?? throw new InvalidOperationException(); receiveResult = new(remoteEndPoint, packetMemoryOwner : m_RecvMemoryOwner, packetLength : m_RecvSAEA.BytesTransferred); return(true); } finally { m_RecvMemoryOwner = null; m_RecvSAEA.Reset(); } }
private void ReceivingFileFinished(ReceiveResult result, string message, string title) { IsFileReceiving = false; ElapsedTime.Stop(); ProgressChangedInvoker.Enabled = false; totalReceived = 0; fileSize = 0; IsListening = false; ReceivingCompletedEvent?.Invoke(this, new ReceivingCompletedEventArgs(result, message, title)); }
void OnCompletion(int error, bool completedSynchronously) { Exception completionException = null; this.receiveResult = ReceiveResult.MessageReceived; try { if (error != 0) { if (error == UnsafeNativeMethods.MQ_ERROR_IO_TIMEOUT) { this.receiveResult = ReceiveResult.Timeout; } else if (error == UnsafeNativeMethods.MQ_ERROR_OPERATION_CANCELLED) { this.receiveResult = ReceiveResult.OperationCancelled; } else { if (IsReceiveErrorDueToInsufficientBuffer(error)) { this.message.Unpin(); message.GrowBuffers(); StartReceive(completedSynchronously); return; } else if (IsErrorDueToStaleHandle(error)) { this.msmqQueue.HandleIsStale(this.handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqReceiveError, MsmqError.GetErrorString(error)), error)); } } } catch (Exception e) { if (e is NullReferenceException || e is SEHException) { throw; } completionException = e; } this.message.Unpin(); Complete(completedSynchronously, completionException); }
public ActionResult <ReceiveResult> Receive([FromHeader] string requestToken) { var result = new ReceiveResult(); try { result.Addresses = _walletService.Receive(requestToken); result.Message = "Valid receive addresses"; result.Success = true; } catch (Exception e) { result.Message = e.Message; result.Success = false; } return(result); }
public void FileReceiver_ListenCompletedEvent(ReceiveResult result) { if (result == ReceiveResult.RequestAccepted) { labelReceivedProgress.Text = Translator.GetStringFromResource("FileRequestHasCame"); } else if (result == ReceiveResult.ListeningCancelled) { //Controller.FileReceiver = null; btnReceiveFile.Text = Translator.GetStringFromResource("btnReceiveFile"); labelReceivedProgress.Text = Translator.GetStringFromResource("FileWaitingWasCancelled"); btnSelectSaveLocation.Enabled = true; txtReceiveIpAdress.Enabled = true; txtReceivePort.Enabled = true; txtSaveLocation.Enabled = true; } }
public RunSeparatelyResults RunPair(ProgramPair pair, TimeSpan timeout) { ReceiveResult result = RequestAndReceive(new Request { Kind = RequestKind.RunPair, Pair = pair, }, timeout); if (result.Ended) { return(new RunSeparatelyResults(RunSeparatelyResultsKind.Crash, null, result.Stderr)); } if (result.Timeout) { return(new RunSeparatelyResults(RunSeparatelyResultsKind.Timeout, null, null)); } return(new RunSeparatelyResults(RunSeparatelyResultsKind.Success, result.Response.RunPairResult, null)); }
public int parsePacket(out uint remoteIpAddress, out ushort remotePort) { Thread.Yield(); int packetLength = 0; remoteIpAddress = 0; remotePort = 0; ReceiveResult result = new ReceiveResult(); lock (_receivedPackets) { if (_receivedPackets.Count > 0) { result = _receivedPackets.Dequeue(); } else { return(packetLength); } } if (result.RemoteEndPoint != null) { var ep = result.RemoteEndPoint; var bytes = ep.Address.GetAddressBytes(); remoteIpAddress = BitConverter.ToUInt32(bytes, 0); remotePort = (ushort)ep.Port; } if (result.Buffer != null) { packetLength = result.Buffer.Length; } _receiveQueue.Clear(); _receiveQueue.Enqueue(result.Buffer, 0, packetLength); return(packetLength); }
private void handleClient(object obj) { try { var client = obj as UdpClient; int count; while (_treadActive) { if (client.Available > 0) { // int length = buffer.Length - _receiveQueue.Length; IPEndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0); byte[] buffer = client.Receive(ref remoteEP); count = buffer.Length; if (count > 0) { ReceiveResult result = new ReceiveResult(buffer, remoteEP); lock (_receivedPackets) { _receivedPackets.Enqueue(result); } } } // prevent high CPU usage Thread.Sleep(10); } } catch (Exception e) { setExceptionMessage(e); } finally { _mreHandleClient.Set(); } }
private ReceiveResult TryReceive(OracleAQQueue queue) { var result = new ReceiveResult(); using (var ts = new TransactionScope(TransactionScopeOption.Required, this.transactionOptions)) { queue.Connection.EnlistTransaction(Transaction.Current); result.Message = this.Receive(queue); try { if (result.Message == null || this.tryProcessMessage(result.Message)) { // NOTE: We explicitly calling Dispose so that we force any exception to not bubble, // eg Concurrency/Deadlock exception. ts.Complete(); ts.Dispose(); } } catch (Exception ex) { result.Exception = ex; } return result; } }
private async void ReceiveFile() { try { ReceiveResult returnReceiveResult = ReceiveResult.CannotReceived; string returnMessage = string.Empty; string returnMessageTitle = string.Empty; byte[] fileInfoByte = new byte[INFO_BUFFER]; await Task.Run(async() => { await NetworkStream.ReadAsync(fileInfoByte, 0, (int)INFO_BUFFER); }); ReceivedFileInfo FileInfo = ReadFileInfoFromByte(fileInfoByte); fileSize = FileInfo.FileSize; string questionMessageBody = Translator.GetStringFromResource(MessageCodes.ReceiverAskForReceiveFile.ToString(), FileInfo.FileName, FileInfo.FileSize.formatSize()); string questionMessageTitle = Translator.GetStringFromResource(MessageCodes.ReceiverAskForReceiveFileTitle.ToString()); if (MessageBox.Show(questionMessageBody, questionMessageTitle, MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No) { returnReceiveResult = ReceiveResult.FileIgnoredByUser; returnMessage = Translator.GetStringFromResource(MessageCodes.ReceiverFileRejectedByUser.ToString()); returnMessageTitle = Translator.GetStringFromResource(MessageCodes.ReceiverFileRejectedByUserTitle.ToString()); ReceivingFileFinished(returnReceiveResult, returnMessage, returnMessageTitle); return; } using (FileStream fstream = new FileStream(ReceiveSaveLocation + @"\" + FileInfo.FileName, FileMode.Create, FileAccess.ReadWrite)) { byte[] buff = new byte[RECEIVE_BUFFER]; int buffered = 0; ReceivingFileStarted(); await Task.Run(async() => { if (!NetworkStream.CanRead) { returnReceiveResult = ReceiveResult.CannotReceived; returnMessage = Translator.GetStringFromResource(MessageCodes.ReceiverCouldntReadStream.ToString()); returnMessageTitle = Translator.GetStringFromResource(MessageCodes.ReceiverCouldntReadStreamTitle.ToString()); return; } while ((buffered = await NetworkStream.ReadAsync(buff, 0, buff.Length)) > 0) { if (CancelFileReceiving) { returnReceiveResult = ReceiveResult.Cancelled; returnMessage = Translator.GetStringFromResource(MessageCodes.ReceiverCancelledByUser.ToString()); returnMessageTitle = Translator.GetStringFromResource(MessageCodes.ReceiverCancelledByUserTitle.ToString()); return; } await fstream.WriteAsync(buff, 0, buffered); totalReceived += buffered; } if (totalReceived < FileInfo.FileSize) { returnReceiveResult = ReceiveResult.CannotReceived; returnMessage = Translator.GetStringFromResource(MessageCodes.ReceiverFailed.ToString()); returnMessageTitle = Translator.GetStringFromResource(MessageCodes.ReceiverFailedTitle.ToString()); return; } returnReceiveResult = ReceiveResult.Completed; returnMessage = Translator.GetStringFromResource(MessageCodes.ReceiverCompleted.ToString()); returnMessageTitle = Translator.GetStringFromResource(MessageCodes.ReceiverCompletedTitle.ToString()); }); ReceivingFileFinished(returnReceiveResult, returnMessage, returnMessageTitle); } } catch (IOException ex) { var errcode = ex.InnerException as Win32Exception; if (errcode != null && errcode.ErrorCode == 10054) { ReceivingFileFinished(ReceiveResult.CannotReceived, Translator.GetStringFromResource(MessageCodes.ReceiverIOException10054.ToString()), Translator.GetStringFromResource(MessageCodes.ReceiverIOException10054Title.ToString())); } else { ReceivingFileFinished(ReceiveResult.CannotReceived, Translator.GetStringFromResource(MessageCodes.ReceiverIOException.ToString()), Translator.GetStringFromResource(MessageCodes.ReceiverIOExceptionTitle.ToString())); } } catch (Exception exception) { ReceivingFileFinished(ReceiveResult.CannotReceived, Translator.GetStringFromResource(MessageCodes.ReceiverException.ToString(), exception.Message), Translator.GetStringFromResource(MessageCodes.ReceiverExceptionTitle.ToString())); } finally { Dispose(); } }
private void ListenFinished(ReceiveResult result) { ListenCompletedEvent.Invoke(result); }
/// <summary> /// Produces a message (traced with the <see cref="IOutgoingMessageTracer"/>) and consumes it /// (traced with the <see cref="IIncomingMessageReceiveTracer"/> and <see cref="IIncomingMessageProcessTracer"/>) /// The Dynatrace tag is transported along with the message /// </summary> public static void ProducerConsumerExample() { string serverEndpoint = "messageserver.example.com:1234"; string topic = "my-topic"; IMessagingSystemInfo messagingSystemInfo = SampleApplication.OneAgentSdk .CreateMessagingSystemInfo(MessageSystemVendor.KAFKA, topic, MessageDestinationType.TOPIC, ChannelType.TCP_IP, serverEndpoint); IOutgoingMessageTracer outgoingTracer = SampleApplication.OneAgentSdk.TraceOutgoingMessage(messagingSystemInfo); outgoingTracer.Start(); try { Message message = new Message { CorrelationId = "my-correlation-id-1234" // optional, determined by application }; // transport the Dynatrace tag along with the message to allow the outgoing message tracer to be linked // together with the message processing tracer on the receiving side message.Headers[OneAgentSdkConstants.DYNATRACE_MESSAGE_PROPERTYNAME] = outgoingTracer.GetDynatraceByteTag(); SendResult result = MyMessagingSystem.SendMessage(message); outgoingTracer.SetCorrelationId(message.CorrelationId); // optional outgoingTracer.SetVendorMessageId(result.VendorMessageId); // optional } catch (Exception e) { outgoingTracer.Error(e); // handle or rethrow throw e; } finally { outgoingTracer.End(); } // represents server side processing Thread server = new Thread(() => { IIncomingMessageReceiveTracer receiveTracer = SampleApplication.OneAgentSdk.TraceIncomingMessageReceive(messagingSystemInfo); receiveTracer.Start(); try { // blocking call until message is available: ReceiveResult receiveResult = MyMessagingSystem.ReceiveMessage(); Message message = receiveResult.Message; IIncomingMessageProcessTracer processTracer = SampleApplication.OneAgentSdk.TraceIncomingMessageProcess(messagingSystemInfo); // retrieve Dynatrace tag created using the outgoing message tracer to link both sides together: if (message.Headers.ContainsKey(OneAgentSdkConstants.DYNATRACE_MESSAGE_PROPERTYNAME)) { processTracer.SetDynatraceByteTag(message.Headers[OneAgentSdkConstants.DYNATRACE_MESSAGE_PROPERTYNAME]); } // start processing: processTracer.Start(); processTracer.SetCorrelationId(message.CorrelationId); // optional processTracer.SetVendorMessageId(receiveResult.VendorMessageId); // optional try { ProcessMessage(message); // do the work ... } catch (Exception e) { processTracer.Error(e); // handle or rethrow throw e; } finally { processTracer.End(); } } catch (Exception e) { receiveTracer.Error(e); // handle or rethrow throw e; } finally { receiveTracer.End(); } }); server.Start(); server.Join(); }
public abstract bool Receive(int suggestedBufferLength, TimeSpan timeout, out ReceiveResult receiveResult);
/// <summary> /// Starts an asynchronous socket read operation /// </summary> /// <param name="buffer"> /// The socket receive buffer /// </param> /// <param name="callback"> /// Asynchronous completion delegate /// </param> /// <param name="state"> /// Asynchronous completion delegate parameter /// </param> /// <returns> /// The asynchronous completion token /// </returns> public IAsyncResult BeginReceive( ArraySegment<Byte> buffer, AsyncCallback callback, Object state) { try { AsyncResult result = new AsyncResult(callback, state); ReceiveResult recvResult = new ReceiveResult() { Buffer = buffer, Endpoint = GetReceiveEndpoint(), AsyncResult = result }; this.socket.BeginReceiveFrom( buffer.Array, buffer.Offset, buffer.Count, SocketFlags.None, ref recvResult.Endpoint, this.OnReceiveFrom, recvResult ); return result; } catch (SocketException e) { throw MapException(e); } }
void OnCompletion(int error, bool completedSynchronously) { Exception completionException = null; this.receiveResult = ReceiveResult.MessageReceived; try { if (error != 0) { if (error == UnsafeNativeMethods.MQ_ERROR_IO_TIMEOUT) { this.receiveResult = ReceiveResult.Timeout; } else if (error == UnsafeNativeMethods.MQ_ERROR_OPERATION_CANCELLED) { this.receiveResult = ReceiveResult.OperationCancelled; } else { if (IsReceiveErrorDueToInsufficientBuffer(error)) { this.message.Unpin(); message.GrowBuffers(); StartReceive(completedSynchronously); return; } else if (IsErrorDueToStaleHandle(error)) { this.msmqQueue.HandleIsStale(this.handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqReceiveError, MsmqError.GetErrorString(error)), error)); } } } catch (Exception e) { if (e is NullReferenceException || e is SEHException) throw; completionException = e; } this.message.Unpin(); Complete(completedSynchronously, completionException); }