protected override bool UpdateTarget(ReceiveContext context) { DeckModel deck = (this.Parent != null && this.Parent.Parent != null) ? this.Parent.Parent.Target as DeckModel : null; ImageSheetModel sheet = this.Target as ImageSheetModel; if(sheet == null) { ///create our imagesheet based on what type of image it is if (image_ != null) { // ImageIt image // RJA - added disposition setting (previously, this was the default) this.Target = sheet = new ImageSheetModel((Guid)this.TargetId, this.image_, this.Disposition | SheetDisposition.Remote, false, this.Bounds.Location, this.Bounds.Size, this.Height); ///make the image visible sheet.Visible = true; } else { // Background image this.Target = sheet = new ImageSheetModel(deck, ((Guid)this.TargetId), this.Disposition | SheetDisposition.Remote, this.Bounds, this.MD5, this.Height); } } if (image_ != null) { using (Synchronizer.Lock(sheet.SyncRoot)) { sheet.Image = this.image_; } } base.UpdateTarget(context); return true; }
public RescueExceptionReceiveContext(ReceiveContext context, Exception exception) : base(context) { _exception = exception; _exceptionTimestamp = DateTime.UtcNow; }
/// <summary> /// Handle this messsage being received and add this sheet to the appropriate place. /// </summary> /// <param name="context">The receiving context</param> /// <returns>True if handled, false otherwise</returns> protected override bool UpdateTarget( ReceiveContext context ) { QuickPollSheetModel sheet = this.Target as QuickPollSheetModel; if( sheet == null ) { // Create a new sheet using( context.Model.Workspace.Lock() ) { if( (~context.Model.Workspace.CurrentPresentation) != null ) { using( Synchronizer.Lock( (~context.Model.Workspace.CurrentPresentation).SyncRoot ) ) { this.Target = sheet = new QuickPollSheetModel( ((Guid)this.TargetId), (~context.Model.Workspace.CurrentPresentation).QuickPoll ); } } else { using( Synchronizer.Lock( context.Participant.SyncRoot ) ) { if( context.Participant.Role is Model.Network.InstructorModel ) { using( Synchronizer.Lock( context.Participant.Role.SyncRoot ) ) { using( Synchronizer.Lock( ((Model.Network.InstructorModel)context.Participant.Role).CurrentPresentation.SyncRoot ) ) { this.Target = sheet = new QuickPollSheetModel( ((Guid)this.TargetId), ((Model.Network.InstructorModel)context.Participant.Role).CurrentPresentation.QuickPoll ); } } } } } } } // Update the parameters of the sheet using( Synchronizer.Lock( sheet.SyncRoot ) ) { sheet.QuickPollId = this.Id; } base.UpdateTarget( context ); return true; }
protected override bool UpdateTarget(ReceiveContext context) { DeckTraversalModel traversal = this.Target as DeckTraversalModel; if(traversal == null) return false; PresentationModel presentation = (this.Parent != null && this.Parent.Parent != null) ? this.Parent.Parent.Target as PresentationModel : null; if(presentation == null) return false; using(Synchronizer.Lock(presentation.SyncRoot)) { if(!presentation.DeckTraversals.Contains(traversal)) presentation.DeckTraversals.Add((DeckTraversalModel) this.Target); } TableOfContentsModel.Entry current = (this.Predecessor != null && this.Predecessor.Child != null) ? this.Predecessor.Child.Target as TableOfContentsModel.Entry: null; if(current != null) { using(Synchronizer.Lock(traversal.SyncRoot)) { traversal.Current = current; } } return false; }
public ConsumeContext Deserialize(ReceiveContext receiveContext) { try { MessageEnvelope envelope; using (Stream body = receiveContext.GetBody()) using (Stream cryptoStream = _provider.GetDecryptStream(body, receiveContext)) using (var jsonReader = new BsonReader(cryptoStream)) { envelope = _deserializer.Deserialize<MessageEnvelope>(jsonReader); } return new JsonConsumeContext(_deserializer, _objectTypeDeserializer, _sendEndpointProvider, _publishEndpoint, receiveContext, envelope); } catch (JsonSerializationException ex) { throw new SerializationException("A JSON serialization exception occurred while deserializing the message envelope", ex); } catch (SerializationException) { throw; } catch (Exception ex) { throw new SerializationException("An exception occurred while deserializing the message envelope", ex); } }
ConsumeContext IMessageDeserializer.Deserialize(ReceiveContext receiveContext) { try { var messageEncoding = GetMessageEncoding(receiveContext); MessageEnvelope envelope; using (var body = receiveContext.GetBody()) using (var reader = new StreamReader(body, messageEncoding, false, 1024, true)) using (var jsonReader = new JsonTextReader(reader)) { envelope = _deserializer.Deserialize<MessageEnvelope>(jsonReader); } return new JsonConsumeContext(_deserializer, _objectTypeDeserializer, _sendEndpointProvider, _publishEndpointProvider, receiveContext, envelope); } catch (JsonSerializationException ex) { throw new SerializationException("A JSON serialization exception occurred while deserializing the message envelope", ex); } catch (SerializationException) { throw; } catch (Exception ex) { throw new SerializationException("An exception occurred while deserializing the message envelope", ex); } }
protected override bool UpdateTarget(ReceiveContext context) { if (SubmissionStatusModel.GetInstance().Role == "student" && sender_.Role == "instructor") { Guid id1; Guid id2; using(Synchronizer.Lock(SubmissionStatusModel.GetInstance().SyncRoot)){ id1 = SubmissionStatusModel.GetInstance().Id; } using (Synchronizer.Lock(sender_.SyncRoot)) { id2 = sender_.Id; } if (id1 == id2) { using (Synchronizer.Lock(SubmissionStatusModel.GetInstance().SyncRoot)) { SubmissionStatusModel.GetInstance().SubmissionStatus = SubmissionStatusModel.Status.Received; } } } else if (SubmissionStatusModel.GetInstance().Role == "instructor" && sender_.Role == "student") { Guid id1; using (Synchronizer.Lock(sender_.SyncRoot)) { id1 = sender_.Id; } using (Synchronizer.Lock(SubmissionStatusModel.GetInstance().SyncRoot)) { ///we need to toggle the Id in order for the listener to recognize the event. SubmissionStatusModel.GetInstance().Id = Guid.Empty; SubmissionStatusModel.GetInstance().Id = id1; } } return true; }
ConsumeContext IMessageDeserializer.Deserialize(ReceiveContext receiveContext) { try { MessageEnvelope envelope; using (Stream body = receiveContext.GetBody()) using (var jsonReader = new BsonReader(body)) { envelope = _deserializer.Deserialize<MessageEnvelope>(jsonReader); } return new JsonConsumeContext(_deserializer, _objectTypeDeserializer, receiveContext, envelope); } catch (JsonSerializationException ex) { throw new SerializationException("A JSON serialization exception occurred while deserializing the message envelope", ex); } catch (SerializationException) { throw; } catch (Exception ex) { throw new SerializationException("An exception occurred while deserializing the message envelope", ex); } }
string GetBodyString(ReceiveContext context) { using (var stream = context.GetBody()) using (var ms = new MemoryStream()) { stream.CopyTo(ms); return Encoding.UTF8.GetString(ms.ToArray()); } }
ConsumeContext IMessageDeserializer.Deserialize(ReceiveContext receiveContext) { object obj; var headers = new Header[0]; using (Stream body = receiveContext.GetBody()) { obj = _formatter.Deserialize(body, x => headers = x); } return new StaticConsumeContext(_sendEndpointProvider, _publishEndpoint, receiveContext, obj, headers); }
public ConsumeContext Deserialize(ReceiveContext receiveContext) { IMessageDeserializer deserializer; if (!TryGetSerializer(receiveContext.ContentType, out deserializer)) { throw new SerializationException( $"No deserializer was registered for the message content type: {receiveContext.ContentType}. Supported content types include {string.Join(", ", _deserializers.Values.Select(x => x.ContentType))}"); } return deserializer.Deserialize(receiveContext); }
/// <summary> /// Returns a stream for decrypting the message /// </summary> /// <param name="provider">The crypto stream provider</param> /// <param name="stream">The original stream to which the encrypted message content is written</param> /// <param name="context">The second context of the message</param> /// <returns>A stream for serializing the message which will be encrypted</returns> public static Stream GetDecryptStream(this ICryptoStreamProvider provider, Stream stream, ReceiveContext context) { if (context == null) throw new ArgumentNullException(nameof(context)); object keyIdObj; string keyId = context.TransportHeaders.TryGetHeader(EncryptedMessageSerializer.EncryptionKeyHeader, out keyIdObj) ? keyIdObj.ToString() : default(string); return provider.GetDecryptStream(stream, keyId, CryptoStreamMode.Read); }
protected override bool UpdateTarget(ReceiveContext context) { PresentationModel presentation = this.Target as PresentationModel; if(presentation != null) { using(Synchronizer.Lock(context.Classroom.SyncRoot)) { if(context.Classroom.Presentations.Contains(presentation)) context.Classroom.Presentations.Remove(presentation); } } return true; }
protected override bool UpdateTarget(ReceiveContext context) { bool update = base.UpdateTarget(context); InstructorModel instructor = this.Parent != null ? this.Parent.Target as InstructorModel : null; if(instructor != null) { using(Synchronizer.Lock(instructor.SyncRoot)) { instructor.CurrentPresentation = this.Target as PresentationModel; } } return update; }
protected override bool UpdateTarget(ReceiveContext context) { DeckModel deck = this.Target as DeckModel; if(deck == null) { this.Target = deck = new DeckModel(((Guid) this.TargetId), this.Disposition | DeckDisposition.Remote, this.HumanName); } else { using(Synchronizer.Lock(deck.SyncRoot)) { deck.HumanName = this.HumanName; } } using (Synchronizer.Lock(deck.SyncRoot)) { deck.DeckBackgroundColor = this.DeckBackgroundColor; } return true; }
protected override bool UpdateTarget(ReceiveContext context) { DeckModel deck = (this.Parent != null && this.Parent.Parent != null) ? this.Parent.Parent.Target as DeckModel : null; XPSPageSheetModel sheet = this.Target as XPSPageSheetModel; if (sheet == null) { if (this.m_DocumentPageWrapper != null) { this.Target = sheet = new XPSPageSheetModel(this.m_DocumentPageWrapper, (Guid)this.TargetId, this.Disposition | SheetDisposition.Remote, new Rectangle(0, 0, this.Width, this.Height), this.Height); } } base.UpdateTarget(context); return true; }
protected override bool UpdateTarget(ReceiveContext context) { Debug.Assert(this.Content != null); if(this.Content.image == null) throw new ArgumentException("The deserialized content image is null.", "Content"); this.Target = this.Content; DeckModel deck = this.Parent != null ? this.Parent.Target as DeckModel : null; if(deck != null) { using(Synchronizer.Lock(deck.SyncRoot)) { // Note: If the deck already has content with this hash, nothing will happen. deck.AddSlideContent(this.Content.key, this.Content.image); } } return true; }
ConsumeContext IMessageDeserializer.Deserialize(ReceiveContext receiveContext) { try { XDocument document; using (Stream body = receiveContext.GetBody()) using (var xmlReader = new XmlTextReader(body)) document = XDocument.Load(xmlReader); var json = new StringBuilder(1024); using (var stringWriter = new StringWriter(json, CultureInfo.InvariantCulture)) using (var jsonWriter = new JsonTextWriter(stringWriter)) { jsonWriter.Formatting = Newtonsoft.Json.Formatting.None; XmlMessageSerializer.XmlSerializer.Serialize(jsonWriter, document.Root); } MessageEnvelope envelope; using (var stringReader = new StringReader(json.ToString())) using (var jsonReader = new JsonTextReader(stringReader)) { envelope = _deserializer.Deserialize<MessageEnvelope>(jsonReader); } return new JsonConsumeContext(_deserializer, _objectTypeDeserializer, _sendEndpointProvider, _publishEndpoint, receiveContext, envelope); } catch (JsonSerializationException ex) { throw new SerializationException("A JSON serialization exception occurred while deserializing the message envelope", ex); } catch (SerializationException) { throw; } catch (Exception ex) { throw new SerializationException("An exception occurred while deserializing the message envelope", ex); } }
protected override bool UpdateTarget(ReceiveContext context) { TextSheetModel sheet = this.Target as TextSheetModel; if (sheet == null) { ///if we sent it, this means that by definition the sheet is public ///edit: made is_editable true so that instructors can copy and paste student code this.Target = sheet = new TextSheetModel(((Guid)this.TargetId), this.Text, true, true, this.Bounds, this.color_, this.font_); } using (Synchronizer.Lock(sheet.SyncRoot)) { sheet.Text = this.Text; sheet.Font = this.font_; sheet.IsEditable = false; ///if we sent it, this means that by definition the sheet is public sheet.IsPublic = true; sheet.Color = this.color_; } base.UpdateTarget(context); return true; }
public static Error ProcessOnReceive( ILayerStack layerStack, MessageType messageType, ReceiveContext receiveContext, IBonded layerData, Logger logger) { Error error = null; if (layerStack != null) { if (layerData == null) { logger.Site().Warning("Layer stack present but no layer data received."); } error = layerStack.OnReceive(messageType, receiveContext, layerData); if (error != null) { logger.Site().Warning("Layer error occurred receiving message of type {0} (Code: {1} Message: {2}).", messageType, error.error_code, error.message); } } return error; }
/// <summary> /// Handle the receipt of this message /// </summary> /// <param name="context">The context of the receiver from which the message was sent</param> protected override bool UpdateTarget( ReceiveContext context ) { QuickPollModel poll = this.Target as QuickPollModel; // Update Target and poll if( poll == null ) { if( this.m_Model == null ) { this.Target = poll = null; return false; } else { // Create a new model using( Synchronizer.Lock( this.m_Model.SyncRoot ) ) { this.Target = poll = new QuickPollModel( ((Guid)this.TargetId), this.m_Model ); } // Find a parent PresentationModel message PresentationModel presentation = null; Message parent = this.Parent; while( parent != null && presentation == null ) { if( parent.Target is PresentationModel ) { presentation = parent.Target as PresentationModel; } else { parent = parent.Parent; } } if( presentation == null ) return false; using( Synchronizer.Lock( presentation.SyncRoot ) ) { if( presentation.QuickPoll == null || !presentation.QuickPoll.Equals( poll ) ) presentation.QuickPoll = poll; } } } else { // No properties can get updated } return true; }
ConsumeContext IMessageDeserializer.Deserialize(ReceiveContext receiveContext) { try { ProtocolBuffersMessageEnvelope envelope; long offset; using (var body = receiveContext.GetBody()) { envelope = Serializer.DeserializeWithLengthPrefix<ProtocolBuffersMessageEnvelope>(body, PrefixStyle.Fixed32); offset = body.Position; } return new ProtocolBuffersConsumeContext(receiveContext, envelope, offset); } catch (SerializationException) { throw; } catch (Exception ex) { throw new SerializationException("An exception occurred while deserializing the message envelope", ex); } }
protected override bool UpdateTarget(ReceiveContext context) { //Update model, intiate response context.Model.VersionExchange.ReceiveVersionRequest(context.Participant,this); return false; }
public static void LogTransportFaulted(this ReceiveContext context, Exception exception) { _logFault(context.InputAddress, GetMessageId(context), exception); }
public Task Consume(ReceiveContext <TCommand> messageContext) { Guard.NotNull(messageContext, nameof(messageContext)); return(this.channel.Send(messageContext.CreateSendContext())); }
/// <summary> /// Returns a stream for decrypting the message /// </summary> /// <param name="provider">The crypto stream provider</param> /// <param name="stream">The original stream to which the encrypted message content is written</param> /// <param name="context">The second context of the message</param> /// <returns>A stream for serializing the message which will be encrypted</returns> public static Stream GetDecryptStream(this ICryptoStreamProvider provider, Stream stream, ReceiveContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var keyId = context.TransportHeaders.TryGetHeader(EncryptedMessageSerializer.EncryptionKeyHeader, out var keyIdObj) ? keyIdObj.ToString() : default; return(provider.GetDecryptStream(stream, keyId, CryptoStreamMode.Read)); }
public Task Consume(ReceiveContext <TEvent> messageContext) { Guard.NotNull(messageContext, nameof(messageContext)); return(this.channel.Publish(messageContext.CreateSendContext())); }
public Task PostReceive(ReceiveContext context) { // called after the message has been received and processed return(Task.CompletedTask); }
public async Task PreReceive(ReceiveContext context) { await Task.Run(() => Console.WriteLine($"[{DateTime.Now}] Message pre received")); }
public async Task ReceiveFault(ReceiveContext context, Exception exception) { await Task.Run(() => Console.WriteLine($"[{DateTime.Now}] Message receive faulted. Exception: {exception.Message}")); }
public async Task PostReceive(ReceiveContext context) { await Task.Run(() => Console.WriteLine($"[{DateTime.Now}] Post received observer")); }
string GetBodyString(ReceiveContext context) { return(Encoding.UTF8.GetString(context.GetBody())); }
protected override bool UpdateTarget(ReceiveContext context) { //Update model context.Model.VersionExchange.ReceiveVersionResponse(context.Participant, this); return(false); }
public Task Handle(ReceiveContext <TestBaseCommand> context, CancellationToken cancellationToken) { Console.WriteLine(context.Message.Id); RubishBox.Rublish.Add(nameof(TestBaseCommandHandler)); return(Task.FromResult(0)); }
public async Task ReceiveFault(ReceiveContext context, Exception exception) { _receiveFault.TrySetResult(Tuple.Create(context, exception)); }
Task IPipe <ReceiveContext> .Send(ReceiveContext context) { return(_receivePipe.Send(context)); }
public Task ReceiveFault(ReceiveContext context, Exception exception) { // called when an exception occurs early in the message processing, such as deserialization, etc. Console.Error.WriteLineAsync($"MASSTRANSIT ReceiveFault! Exception: " + exception.Message); return(Task.CompletedTask); }
public Task PreReceive(ReceiveContext context) { return(Task.Run(() => { counterAll += 1; })); }
static Guid GetMessageId(ReceiveContext context) { return(context.TransportHeaders.TryGetHeader("MessageId", out var messageIdValue) ? new Guid(messageIdValue.ToString()) : NewId.NextGuid()); }
static void TraceMessage(ReceiveContext context) { using (var ms = new MemoryStream()) { context.CopyBodyTo(ms); var msg = Encoding.UTF8.GetString(ms.ToArray()); _logger.Debug(string.Format("{0} body:\n {1}", DateTime.UtcNow, msg)); } }
public void Receive(Func <IReceiveContext, Action <IReceiveContext> > callback, TimeSpan timeout) { int messageCount = Count; bool waited = false; if (messageCount == 0) { if (!_messageReady.WaitOne(timeout, true)) { return; } waited = true; } bool monitorExitNeeded = true; if (!Monitor.TryEnter(_messageLock, timeout)) { return; } try { for (LinkedListNode <LoopbackMessage> iterator = _messages.First; iterator != null; iterator = iterator.Next) { if (iterator.Value != null) { LoopbackMessage message = iterator.Value; if (message.ExpirationTime.HasValue && message.ExpirationTime <= DateTime.UtcNow) { _messages.Remove(iterator); return; } ReceiveContext context = ReceiveContext.FromBodyStream(message.Body); context.SetMessageId(message.MessageId); context.SetContentType(message.ContentType); if (message.ExpirationTime.HasValue) { context.SetExpirationTime(message.ExpirationTime.Value); } Action <IReceiveContext> receive = callback(context); if (receive == null) { continue; } _messages.Remove(iterator); using (message) { Monitor.Exit(_messageLock); monitorExitNeeded = false; receive(context); return; } } } if (waited) { return; } // we read to the end and none were accepted, so we are going to wait until we get another in the queue _messageReady.WaitOne(timeout, true); } finally { if (monitorExitNeeded) { Monitor.Exit(_messageLock); } } }
protected override bool UpdateTarget(ReceiveContext context) { DeckModel deck = this.Target as DeckModel; if(deck == null) { this.Target = deck = new DeckModel(((Guid) this.TargetId), this.Disposition | DeckDisposition.Remote, this.HumanName); } else { using(Synchronizer.Lock(deck.SyncRoot)) { deck.HumanName = this.HumanName; } } if ((this.Disposition & DeckDisposition.Remote) == 0) { using (Synchronizer.Lock(deck.SyncRoot)) { deck.DeckBackgroundColor = this.DeckBackgroundColor; deck.DeckBackgroundTemplate = this.DeckBackgroundTemplate; } //if the background template is not exist in BackgroundTemplate.xml, then save it to the xml file if (this.DeckBackgroundTemplate != null) { BackgroundTemplateXmlService xmlservice = new BackgroundTemplateXmlService(); if (!xmlservice.IsTemplateExist(this.DeckBackgroundTemplate.Name)) xmlservice.SaveTemplate(this.DeckBackgroundTemplate); } } return true; }
public CopyBodySerializer(ReceiveContext context) { _context = context; ContentType = context.ContentType; }
protected override bool UpdateTarget(ReceiveContext context) { using(Synchronizer.Lock(context.Participant.SyncRoot)) { context.Participant.Role = this.Target as RoleModel; } return false; }
public Task <TResponse> Consume(ReceiveContext <TRequest> messageContext) { Guard.NotNull(messageContext, nameof(messageContext)); return(this.channel.Request <TRequest, TResponse>(messageContext.CreateSendContext())); }
public Task Move(ReceiveContext context, IPipe <SendContext> pipe) { return(TaskUtil.Completed); }
async Task ISendTransport.Move(ReceiveContext context, IPipe <SendContext> pipe) { IPipe <ModelContext> modelPipe = Pipe.New <ModelContext>(p => { p.UseFilter(_filter); p.UseExecuteAsync(async modelContext => { Guid?messageId = context.TransportHeaders.Get("MessageId", default(Guid?)); try { IBasicProperties properties; RabbitMqBasicConsumeContext basicConsumeContext; if (context.TryGetPayload(out basicConsumeContext)) { properties = basicConsumeContext.Properties; } else { properties = modelContext.Model.CreateBasicProperties(); properties.Headers = new Dictionary <string, object>(); } var moveContext = new RabbitMqMoveContext(context, properties); await pipe.Send(moveContext).ConfigureAwait(false); // properties.Headers["Content-Type"] = context.ContentType.MediaType; // if (messageId.HasValue) // properties.MessageId = messageId.ToString(); byte[] body; using (var memoryStream = new MemoryStream()) { using (var bodyStream = context.GetBody()) { bodyStream.CopyTo(memoryStream); } body = memoryStream.ToArray(); } var task = modelContext.BasicPublishAsync(_sendSettings.ExchangeName, "", true, properties, body, true); context.AddPendingTask(task); if (_log.IsDebugEnabled) { context.InputAddress.LogMoved(modelContext.ConnectionContext.HostSettings.GetSendAddress(_sendSettings), messageId?.ToString() ?? "N/A", "Moved"); } } catch (Exception ex) { if (_log.IsErrorEnabled) { _log.Error("Move To Error Queue Fault: " + _sendSettings.ExchangeName, ex); } throw; } }); }); await _modelCache.Send(modelPipe, context.CancellationToken).ConfigureAwait(false); }
static Encoding GetMessageEncoding(ReceiveContext receiveContext) { var contentEncoding = receiveContext.TransportHeaders.Get("Content-Encoding", default(string)); return string.IsNullOrWhiteSpace(contentEncoding) ? Encoding.UTF8 : Encoding.GetEncoding(contentEncoding); }
public Error OnReceive(MessageType messageType, ReceiveContext context, Dummy layerData) { layerData.string_value += value; list.Add(layerData.string_value); return(null); }
public async Task <IMessage> DispatchRequest(string serviceName, string methodName, ReceiveContext context, IMessage message) { string qualifiedName = serviceName + "." + methodName; Stopwatch serviceTime = null; logger.Site().Information("Got request [{0}] from {1}.", qualifiedName, context.Connection); try { ServiceMethodInfo methodInfo; lock (dispatchTableLock) { if (!dispatchTable.TryGetValue(qualifiedName, out methodInfo)) { var errorMessage = "Got request for unknown method [" + qualifiedName + "]."; logger.Site().Error(errorMessage); var error = new Error { message = errorMessage, error_code = (int)ErrorCode.METHOD_NOT_FOUND }; return(Message.FromError(error)); } } if (methodInfo.CallbackType != ServiceCallbackType.RequestResponse) { var errorMessage = "Method [" + qualifiedName + "] invoked as if it were " + ServiceCallbackType.RequestResponse + ", but it was registered as " + methodInfo.CallbackType + "."; logger.Site().Error(errorMessage); var error = new Error { message = errorMessage, error_code = (int)ErrorCode.INVALID_INVOCATION }; return(Message.FromError(error)); } IMessage result; try { serviceTime = Stopwatch.StartNew(); // Cast to appropriate return type which we validated when registering the service result = await(Task <IMessage>) methodInfo.Callback(message, context, CancellationToken.None); serviceTime.Stop(); } catch (Exception ex) { logger.Site() .Error(ex, "Failed to complete method [{0}]. With exception: {1}", qualifiedName, ex.Message); result = Message.FromError( Errors.MakeInternalServerError(ex, context.RequestMetrics.request_id, includeDetails: false)); } return(result); } finally { Update(context.RequestMetrics, serviceName, methodName, serviceTime); } }
protected override bool UpdateTarget(ReceiveContext context) { InstructorModel role = this.Target as InstructorModel; if(role == null) this.Target = role = new InstructorModel(((Guid) this.TargetId)); using(Synchronizer.Lock(role.SyncRoot)) { role.AcceptingStudentSubmissions = this.AcceptingStudentSubmissions; // Deserialize the extension ExtensionWrapper extension = this.Extension as ExtensionWrapper; if (extension != null) { if( extension.ExtensionType.Equals( new Guid( "{65A946F4-D1C5-426b-96DB-7AF4863CE296}" ) ) ) { bool acceptingQuickPollSubmissions = (bool)extension.ExtensionObject; role.AcceptingQuickPollSubmissions = acceptingQuickPollSubmissions; } else { Trace.WriteLine("Unknown Extension id=" + extension.ExtensionType.ToString()); } } role.ForcingStudentNavigationLock = this.ForcingStudentNavigationLock; } // Update the clock skew from our current value. using( Synchronizer.Lock( context.Model.ViewerState.Diagnostic.SyncRoot ) ) { context.Model.ViewerState.Diagnostic.AddSkewEntry( this.InstructorClockTicks ); } base.UpdateTarget(context); return true; }
public Error OnReceive(MessageType messageType, ReceiveContext context, Dummy layerData) { throw new LayerStackException(); }
protected override bool UpdateTarget(ReceiveContext context) { StudentModel role = this.Target as StudentModel; if(role == null) this.Target = role = new StudentModel(((Guid) this.TargetId)); base.UpdateTarget(context); return true; }
static Encoding GetMessageEncoding(ReceiveContext receiveContext) { var contentEncoding = receiveContext.TransportHeaders.Get("Content-Encoding", default(string)); return(string.IsNullOrWhiteSpace(contentEncoding) ? Encoding.UTF8 : Encoding.GetEncoding(contentEncoding)); }
public static void LogFaulted(this ReceiveContext context, Exception exception) { _logReceiveFault(context.InputAddress, GetMessageId(context), context.ElapsedTime, exception); }
public Task PreReceive(ReceiveContext context) { // called immediately after the message was delivery by the transport Console.Out.WriteLineAsync($"MASSTRANSIT PreReceive: On Address: {context.InputAddress}"); return(Task.CompletedTask); }
public Task PostReceive(ReceiveContext context) { return(Task.Run(() => { })); }
public async Task PostReceive(ReceiveContext context) { _postReceive.TrySetResult(context); }
public Task ProcessWebSocketRequestAsync(WebSocket webSocket, CancellationToken disconnectToken) { if (webSocket == null) { throw new ArgumentNullException("webSocket"); } var receiveContext = new ReceiveContext(webSocket, disconnectToken, MaxIncomingMessageSize, _receiveLoopBufferSize); return ProcessWebSocketRequestAsync(webSocket, disconnectToken, state => { var context = (ReceiveContext)state; return WebSocketMessageReader.ReadMessageAsync(context.WebSocket, context.BufferSize, context.MaxIncomingMessageSize, context.DisconnectToken); }, receiveContext); }
public Task ReceiveFault(ReceiveContext context, Exception exception) { return(Task.Run(() => { })); }