static void Main(string[] args) { try { var converter = new MessageConverter(); Console.WriteLine("Alexandria Echo"); var input = Console.In.ReadToEnd(); var message = converter.DeserializeFromJson<Message>(input); Console.WriteLine("Message Received"); Console.WriteLine("Type: {0}", message.Type); Console.WriteLine("Header: {0}", message.Header); Console.WriteLine("Body: {0}", message.Body); //Console.WriteLine("Press Enter to close"); //Console.ReadLine(); } catch (Exception ex) { Console.WriteLine("Message Error: " + ex.Message); } }
public async Task<Response> ExecuteRequest(Request request) { if (!_tcpClient.Connected) { throw new InvalidOperationException("Connect first."); } var converter = new MessageConverter(); var requestBuffer = new MemoryStream(); var streamWriter = new HmBinaryMessageWriter(requestBuffer); var requestReader = new MessageReader(request); converter.Convert(requestReader, streamWriter); var networkStream = _tcpClient.GetStream(); requestBuffer.Position = 0; await requestBuffer.CopyToAsync(networkStream); await Task.Delay(100); //todo: implement buffered reader var streamReader = new HmBinaryMessageReader(networkStream); var responseBuilder = new MessageBuilder(); converter.Convert(streamReader, responseBuilder); var response = (Response)responseBuilder.Result; return response; }
public void ConvertNullSDKToSDK() { sdkMessage1 = null; converter = new MessageConverter(sdkMessage1); Assert.IsNull(converter.ToSDKMessage()); }
public void ConvertNullAPIToAPI() { apiMessage1 = null; converter = new MessageConverter(apiMessage1); Assert.IsNull(converter.ToAPIMessage()); }
static void Main(string[] args) { var converter = new MessageConverter(); var body = "Hello Alexandria"; if (args != null && args.Length > 0) { if (!string.IsNullOrEmpty(args[0])) { body = args[0]; } } var message = new Message() { Type = MessageType.Json, Header = "Test Message", Body = body }; var output = converter.SeralizeToJson(message); Console.WriteLine(output); }
public Task HandleRequest(IRequestContext requestContext) { var converter = new MessageConverter(); var messageBuilder = new MessageBuilder(); converter.Convert(requestContext.Request, messageBuilder); var request = (Request)messageBuilder.Result; var response = HandleRequest(request); #if DEBUG System.Diagnostics.Debug.WriteLine(messageBuilder.Debug); Console.WriteLine(request); #endif var responseReader = new MessageReader(response); converter.Convert(responseReader, requestContext.Response); return Task.FromResult(0); }
public async Task <List <MessageDto> > SearchMessagesAsync( string query, ConversationType?conversationType, long?conversationId, ConversationType?navConversationType, long?navConversationId, Guid?navMessageId, long?userId, int limit = 30) { using (MessengerDbContext context = contextFactory.Create()) { var messagesCondition = PredicateBuilder.New <Message>(); var messagesQuery = context.Messages.AsNoTracking(); ExpressionsHelper expressionsHelper = new ExpressionsHelper(); var messageExpression = expressionsHelper.GetMessageExpression(query); if (conversationType != null && conversationId != null) { if (userId != null && !await conversationsService.IsUserInConversationAsync(conversationType.Value, conversationId.Value, userId.Value).ConfigureAwait(false)) { return(new List <MessageDto>()); } switch (conversationType.Value) { case ConversationType.Dialog: messagesQuery = messagesQuery.Where(message => message.DialogId == conversationId); break; case ConversationType.Chat: messagesQuery = messagesQuery.Where(message => message.ChatId == conversationId); break; case ConversationType.Channel: messagesQuery = messagesQuery.Where(message => message.ChannelId == conversationId); break; } } else { if (userId != null) { var dialogsIds = await loadDialogsService.GetUserDialogsIdAsync(userId.Value).ConfigureAwait(false); var chatsIds = await loadChatsService.GetUserChatsIdAsync(userId.Value).ConfigureAwait(false); var channelsIds = await loadChannelsService.GetUserChannelsIdAsync(userId.Value).ConfigureAwait(false); messagesCondition = dialogsIds.Aggregate(messagesCondition, (current, value) => current.Or(option => option.DialogId == value).Expand()); messagesCondition = chatsIds.Aggregate(messagesCondition, (current, value) => current.Or(option => option.ChatId == value).Expand()); messagesCondition = channelsIds.Aggregate(messagesCondition, (current, value) => current.Or(option => option.ChannelId == value).Expand()); messagesQuery = messagesQuery.Where(messagesCondition); } } if (navConversationId != null && navConversationType != null && navMessageId != null) { var navMessage = (await GetMessagesByIdAsync( new List <Guid> { navMessageId.Value }, navConversationType.Value, navConversationId.Value, userId).ConfigureAwait(false)).FirstOrDefault(); if (navMessage != null) { messagesQuery = messagesQuery .Where(message => message.SendingTime <= navMessage.SendingTime && message.GlobalId != navMessage.GlobalId); } } var messages = await messagesQuery .Where(messageExpression) .Where(message => !message.Deleted && (message.ExpiredAt == null || message.ExpiredAt > DateTime.UtcNow.ToUnixTime())) .OrderByDescending(message => message.SendingTime) .Take(limit) .Include(message => message.Attachments) .ToListAsync() .ConfigureAwait(false); return(MessageConverter.GetMessagesDto(messages)); } }
/// <summary> /// Receives a batch of <see cref="EventData" /> from the Event Hub partition. /// </summary> /// /// <param name="maximumMessageCount">The maximum number of messages to receive in this batch.</param> /// <param name="maximumWaitTime">The maximum amount of time to wait to build up the requested message count for the batch; if not specified, the per-try timeout specified by the retry policy will be used.</param> /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param> /// /// <returns>The batch of <see cref="EventData" /> from the Event Hub partition this consumer is associated with. If no events are present, an empty set is returned.</returns> /// public override async Task <IReadOnlyList <EventData> > ReceiveAsync(int maximumMessageCount, TimeSpan?maximumWaitTime, CancellationToken cancellationToken) { Argument.AssertNotClosed(_closed, nameof(AmqpConsumer)); Argument.AssertAtLeast(maximumMessageCount, 1, nameof(maximumMessageCount)); var receivedEventCount = 0; var failedAttemptCount = 0; var tryTimeout = RetryPolicy.CalculateTryTimeout(0); var waitTime = (maximumWaitTime ?? tryTimeout); var link = default(ReceivingAmqpLink); var retryDelay = default(TimeSpan?); var amqpMessages = default(IEnumerable <AmqpMessage>); var receivedEvents = default(List <EventData>); var lastReceivedEvent = default(EventData); var stopWatch = Stopwatch.StartNew(); try { while ((!cancellationToken.IsCancellationRequested) && (!_closed)) { try { EventHubsEventSource.Log.EventReceiveStart(EventHubName, ConsumerGroup, PartitionId); link = await ReceiveLink.GetOrCreateAsync(UseMinimum(ConnectionScope.SessionTimeout, tryTimeout)).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>(); var messagesReceived = await Task.Factory.FromAsync ( (callback, state) => link.BeginReceiveMessages(maximumMessageCount, waitTime, callback, state), (asyncResult) => link.EndReceiveMessages(asyncResult, out amqpMessages), TaskCreationOptions.RunContinuationsAsynchronously ).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>(); // If event messages were received, then package them for consumption and // return them. if ((messagesReceived) && (amqpMessages != null)) { receivedEvents ??= new List <EventData>(); foreach (AmqpMessage message in amqpMessages) { link.DisposeDelivery(message, true, AmqpConstants.AcceptedOutcome); receivedEvents.Add(MessageConverter.CreateEventFromMessage(message)); message.Dispose(); } receivedEventCount = receivedEvents.Count; if (receivedEventCount > 0) { lastReceivedEvent = receivedEvents[receivedEventCount - 1]; if (lastReceivedEvent.Offset > long.MinValue) { CurrentEventPosition = EventPosition.FromOffset(lastReceivedEvent.Offset, false); } if (TrackLastEnqueuedEventProperties) { LastReceivedEvent = lastReceivedEvent; } } return(receivedEvents); } // No events were available. return(new List <EventData>(0)); } catch (EventHubsException ex) when(ex.Reason == EventHubsException.FailureReason.ServiceTimeout) { // Because the timeout specified with the request is intended to be the maximum // amount of time to wait for events, a timeout isn't considered an error condition, // rather a sign that no events were available in the requested period. return(new List <EventData>(0)); } catch (Exception ex) { Exception activeEx = ex.TranslateServiceException(EventHubName); // Determine if there should be a retry for the next attempt; if so enforce the delay but do not quit the loop. // Otherwise, bubble the exception. ++failedAttemptCount; retryDelay = RetryPolicy.CalculateRetryDelay(activeEx, failedAttemptCount); if ((retryDelay.HasValue) && (!ConnectionScope.IsDisposed) && (!cancellationToken.IsCancellationRequested)) { EventHubsEventSource.Log.EventReceiveError(EventHubName, ConsumerGroup, PartitionId, activeEx.Message); await Task.Delay(UseMinimum(retryDelay.Value, waitTime.CalculateRemaining(stopWatch.Elapsed)), cancellationToken).ConfigureAwait(false); tryTimeout = RetryPolicy.CalculateTryTimeout(failedAttemptCount); } else if (ex is AmqpException) { ExceptionDispatchInfo.Capture(activeEx).Throw(); } else { throw; } } } // If no value has been returned nor exception thrown by this point, // then cancellation has been requested. throw new TaskCanceledException(); } catch (Exception ex) { EventHubsEventSource.Log.EventReceiveError(EventHubName, ConsumerGroup, PartitionId, ex.Message); throw; } finally { stopWatch.Stop(); EventHubsEventSource.Log.EventReceiveComplete(EventHubName, ConsumerGroup, PartitionId, receivedEventCount); } }
/// <summary> /// /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void _u3dPlayerControl_UnityCall(object sender, AxUnityWebPlayerAXLib._DUnityWebPlayerAXEvents_OnExternalCallEvent e) { try { string message = e.value; string[] list = message.Split('"'); for (int i = 0; i < list.Length; i++) { if (list[i].StartsWith("@")) { iS3UnityMessage myMessage = MessageConverter.DeSerializeMessage(list[i]); switch (myMessage.type) { case MessageType.SendUnityLayer: SendUnityLayerMessage _message0 = myMessage as SendUnityLayerMessage; if (UnityLayerHandler != null) { UnityLayerHandler(this, _message0.MyUnityLayer); } break; case MessageType.SetObjSelectState: SetObjSelectStateMessage _message = myMessage as SetObjSelectStateMessage; string _path = _message.path; int id = int.Parse(_path.Split('/')[_path.Split('/').Length - 1]); bool isSelected = _message.iSSelected; DGObject obj = null; foreach (string key in prj.objsLayerIndex.Keys) { DGObjects objs = prj.objsLayerIndex[key]; if ((objs.definition.Has3D) && (_path.StartsWith(objs.definition.Layer3DName))) { foreach (DGObject _obj in objs.values) { if (_obj.fullName == id.ToString()) { obj = _obj; break; } } } } if (obj != null && objSelectionChangedTrigger != null) { ObjSelectionChangedEventArgs args = new ObjSelectionChangedEventArgs(); if (isSelected) { args.addedObjs = new Dictionary <string, IEnumerable <DGObject> >(); List <DGObject> objs = new List <DGObject>() { obj }; args.addedObjs.Add(obj.parent.definition.GISLayerName, objs); } else { args.removedObjs = new Dictionary <string, IEnumerable <DGObject> >(); List <DGObject> objs = new List <DGObject>() { obj }; args.removedObjs.Add(obj.parent.definition.GISLayerName, objs); } objSelectionChangedTrigger(this, args); } break; case MessageType.SetObjShowState: break; default: break; } } } } catch { } }
private async Task <List <MessageDto> > DeleteChannelMessagesInfoAsync(long channelId, IEnumerable <Guid> messagesIds, long userId) { try { using (MessengerDbContext context = contextFactory.Create()) { var messagesCondition = PredicateBuilder.New <Message>(); messagesCondition = messagesIds.Aggregate(messagesCondition, (current, value) => current.Or(opt => opt.GlobalId == value).Expand()); var channelUser = await context.ChannelUsers .Include(opt => opt.Channel) .FirstOrDefaultAsync(opt => opt.ChannelId == channelId && opt.UserId == userId && opt.ChannelUserRole >= ChannelUserRole.Administrator) .ConfigureAwait(false); if (channelUser == null) { throw new PermissionDeniedException(); } var messages = await context.Messages .Include(opt => opt.Attachments) .Where(messagesCondition) .Where(opt => opt.ChannelId == channelId) .ToListAsync() .ConfigureAwait(false); if (!messages.Any()) { return(new List <MessageDto>()); } var deletedMessagesIds = messages.Select(message => message.GlobalId).ToList(); var usersCondition = PredicateBuilder.New <ChannelUser>(); usersCondition = deletedMessagesIds.Aggregate(usersCondition, (current, value) => current.Or(opt => opt.LastReadedGlobalMessageId == value).Expand()); var channelUsers = await context.ChannelUsers.Where(usersCondition).ToListAsync().ConfigureAwait(false); var groupedChannelUsers = channelUsers.GroupBy(opt => opt.LastReadedGlobalMessageId); foreach (var group in groupedChannelUsers) { var message = await context.Messages .OrderByDescending(opt => opt.SendingTime) .ThenBy(opt => opt.GlobalId) .Where(opt => !deletedMessagesIds.Contains(opt.GlobalId) && opt.ChannelId == channelId && !opt.Deleted) .FirstOrDefaultAsync() .ConfigureAwait(false); foreach (var user in group) { user.LastReadedGlobalMessageId = message?.GlobalId; } context.ChannelUsers.UpdateRange(group); } var deletedMessages = MessageConverter.GetMessagesDto(messages); messages.ForEach(message => { message.Deleted = true; message.UpdatedAt = DateTime.UtcNow.ToUnixTime(); if (NodeSettings.Configs.Node.PermanentlyDeleting) { message.Attachments = null; message.Replyto = null; message.SendingTime = 0; message.Text = null; message.SenderId = null; } }); context.UpdateRange(messages); await context.SaveChangesAsync().ConfigureAwait(false); Message lastValidMessage = await _loadMessagesService.GetLastValidChannelMessageAsync(channelId).ConfigureAwait(false); channelUser.Channel.LastMessageId = lastValidMessage?.Id ?? null; channelUser.Channel.LastMessageGlobalId = lastValidMessage?.GlobalId; context.Update(channelUser); await context.SaveChangesAsync().ConfigureAwait(false); return(deletedMessages); } } catch (Exception ex) { throw new DeleteMessagesException("An error ocurred while deleting the messages.", ex); } }
/// <summary> /// Retrieves information about a specific partition for an Event Hub, including elements that describe the available /// events in the partition event stream. /// </summary> /// /// <param name="partitionId">The unique identifier of a partition associated with the Event Hub.</param> /// <param name="retryPolicy">The retry policy to use as the basis for retrieving the information.</param> /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param> /// /// <returns>The set of information for the requested partition under the Event Hub this client is associated with.</returns> /// public override async Task <PartitionProperties> GetPartitionPropertiesAsync(string partitionId, EventHubsRetryPolicy retryPolicy, CancellationToken cancellationToken) { Argument.AssertNotClosed(_closed, nameof(AmqpClient)); Argument.AssertNotNullOrEmpty(partitionId, nameof(partitionId)); Argument.AssertNotNull(retryPolicy, nameof(retryPolicy)); var failedAttemptCount = 0; var retryDelay = default(TimeSpan?); var token = default(string); var link = default(RequestResponseAmqpLink); var stopWatch = ValueStopwatch.StartNew(); try { var tryTimeout = retryPolicy.CalculateTryTimeout(0); while (!cancellationToken.IsCancellationRequested) { try { EventHubsEventSource.Log.GetPartitionPropertiesStart(EventHubName, partitionId); // Create the request message and the management link. token = await AcquireAccessTokenAsync(cancellationToken).ConfigureAwait(false); using AmqpMessage request = MessageConverter.CreatePartitionPropertiesRequest(EventHubName, partitionId, token); cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>(); link = await ManagementLink.GetOrCreateAsync(UseMinimum(ConnectionScope.SessionTimeout, tryTimeout.CalculateRemaining(stopWatch.GetElapsedTime()))).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>(); // Send the request and wait for the response. using AmqpMessage response = await link.RequestAsync(request, tryTimeout.CalculateRemaining(stopWatch.GetElapsedTime())).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>(); // Process the response. AmqpError.ThrowIfErrorResponse(response, EventHubName); return(MessageConverter.CreatePartitionPropertiesFromResponse(response)); } catch (Exception ex) { Exception activeEx = ex.TranslateServiceException(EventHubName); // Determine if there should be a retry for the next attempt; if so enforce the delay but do not quit the loop. // Otherwise, mark the exception as active and break out of the loop. ++failedAttemptCount; retryDelay = retryPolicy.CalculateRetryDelay(activeEx, failedAttemptCount); if ((retryDelay.HasValue) && (!ConnectionScope.IsDisposed) && (!cancellationToken.IsCancellationRequested)) { EventHubsEventSource.Log.GetPartitionPropertiesError(EventHubName, partitionId, activeEx.Message); await Task.Delay(retryDelay.Value, cancellationToken).ConfigureAwait(false); tryTimeout = retryPolicy.CalculateTryTimeout(failedAttemptCount); stopWatch = ValueStopwatch.StartNew(); } else if (ex is AmqpException) { ExceptionDispatchInfo.Capture(activeEx).Throw(); } else { throw; } } } // If no value has been returned nor exception thrown by this point, // then cancellation has been requested. throw new TaskCanceledException(); } catch (Exception ex) { EventHubsEventSource.Log.GetPartitionPropertiesError(EventHubName, partitionId, ex.Message); throw; } finally { EventHubsEventSource.Log.GetPartitionPropertiesComplete(EventHubName, partitionId); } }
public async Task <List <MessageDto> > GetDialogMessagesAsync(long dialogId, long userId, Guid?lastId = null, List <AttachmentType> attachmentsTypes = null, bool direction = true, short limit = 30) { try { using (MessengerDbContext context = contextFactory.Create()) { IQueryable <Message> queryPart = context.Messages .Include(message => message.Dialog) .Include(message => message.Attachments); if (lastId != null) { MessageDto messageQueryResult = (await GetMessagesByIdAsync( new List <Guid> { lastId.Value }, ConversationType.Dialog, dialogId, userId).ConfigureAwait(false)).FirstOrDefault(); if (messageQueryResult != null) { if (direction) { queryPart = queryPart .Where(opt => opt.SendingTime < messageQueryResult.SendingTime); } else { queryPart = queryPart .Where(opt => opt.SendingTime > messageQueryResult.SendingTime); } } } if (direction) { queryPart = queryPart.OrderByDescending(message => message.SendingTime) .ThenByDescending(message => message.Id) .ThenByDescending(message => message.GlobalId); } else { queryPart = queryPart.OrderBy(message => message.SendingTime) .ThenBy(message => message.Id) .ThenBy(message => message.GlobalId); } if (!attachmentsTypes.IsNullOrEmpty()) { List <short> types = attachmentsTypes.Select(type => (short)type).ToList(); queryPart = queryPart.Where(opt => opt.Attachments.Any(attach => types.Contains(attach.Type))); } queryPart = queryPart.Where(message => message.DialogId == dialogId && message.Dialog.FirstUID == userId && message.Deleted == false); queryPart = queryPart.Take(limit); var messages = await queryPart.ToListAsync().ConfigureAwait(false); return(MessageConverter.GetMessagesDto(messages)); } } catch (Exception ex) { throw new GetMessagesException(null, ex); } }
public async Task <List <MessageDto> > GetChatMessagesAsync(long chatId, long userId, Guid?navMessageId, List <AttachmentType> attachmentsTypes = null, bool direction = true, byte messagesLimit = 30) { if (!await loadChatsService.IsUserJoinedToChatAsync(chatId, userId).ConfigureAwait(false)) { throw new GetMessagesException("User does not have access to chat."); } using (MessengerDbContext context = contextFactory.Create()) { var messagesQuery = from message in context.Messages where message.ChatId == chatId && message.Deleted == false select message; if (!attachmentsTypes.IsNullOrEmpty()) { List <short> types = attachmentsTypes.Select(type => (short)type).ToList(); messagesQuery = messagesQuery.Where(opt => opt.Attachments.Any(attach => types.Contains(attach.Type))); } if (navMessageId != null) { MessageDto navigationMessage = (await GetMessagesByIdAsync( new List <Guid> { navMessageId.Value }, ConversationType.Chat, chatId, userId).ConfigureAwait(false)).FirstOrDefault(); if (navigationMessage != null) { if (direction) { messagesQuery = messagesQuery.Where(opt => opt.SendingTime < navigationMessage.SendingTime); } else { messagesQuery = messagesQuery.Where(opt => opt.SendingTime > navigationMessage.SendingTime); } } } if (direction) { messagesQuery = messagesQuery .OrderByDescending(message => message.SendingTime) .ThenByDescending(message => message.Id) .ThenByDescending(message => message.GlobalId); } else { messagesQuery = messagesQuery .OrderBy(message => message.SendingTime) .ThenBy(message => message.Id) .ThenBy(message => message.GlobalId); } var messages = await messagesQuery .AsNoTracking() .Include(message => message.Attachments) .Take(messagesLimit) .ToListAsync() .ConfigureAwait(false); return(MessageConverter.GetMessagesDto(messages)); } }
public void SendMessages(HttpResponse response, IEnumerable <Message> messages) { response.ContentType = "text/json"; response.WriteAsync(MessageConverter.ToJson(messages)); }
protected override void Configure(FeatureConfigurationContext context, string connectionString) { var useCallbackReceiver = context.Settings.Get <bool>(UseCallbackReceiverSettingKey); var maxConcurrencyForCallbackReceiver = context.Settings.Get <int>(MaxConcurrencyForCallbackReceiver); var queueName = GetLocalAddress(context.Settings); var callbackQueue = string.Format("{0}.{1}", queueName, RuntimeEnvironment.MachineName); var connectionConfiguration = new ConnectionStringParser(context.Settings).Parse(connectionString); MessageConverter messageConverter; if (context.Settings.HasSetting(CustomMessageIdStrategy)) { messageConverter = new MessageConverter(context.Settings.Get <Func <BasicDeliverEventArgs, string> >(CustomMessageIdStrategy)); } else { messageConverter = new MessageConverter(); } string hostDisplayName; if (!context.Settings.TryGet("NServiceBus.HostInformation.DisplayName", out hostDisplayName))//this was added in 5.1.2 of the core { hostDisplayName = RuntimeEnvironment.MachineName; } var consumerTag = string.Format("{0} - {1}", hostDisplayName, context.Settings.EndpointName()); var receiveOptions = new ReceiveOptions(workQueue => { //if this isn't the main queue we shouldn't use callback receiver if (!useCallbackReceiver || workQueue != queueName) { return(SecondaryReceiveSettings.Disabled()); } return(SecondaryReceiveSettings.Enabled(callbackQueue, maxConcurrencyForCallbackReceiver)); }, messageConverter, connectionConfiguration.PrefetchCount, connectionConfiguration.DequeueTimeout * 1000, context.Settings.GetOrDefault <bool>("Transport.PurgeOnStartup"), consumerTag); context.Container.RegisterSingleton(connectionConfiguration); context.Container.ConfigureComponent(builder => new RabbitMqDequeueStrategy( builder.Build <IManageRabbitMqConnections>(), SetupCircuitBreaker(builder.Build <CriticalError>()), receiveOptions), DependencyLifecycle.InstancePerCall); context.Container.ConfigureComponent <OpenPublishChannelBehavior>(DependencyLifecycle.InstancePerCall); context.Pipeline.Register <OpenPublishChannelBehavior.Registration>(); context.Pipeline.Register <ReadIncomingCallbackAddressBehavior.Registration>(); context.Container.ConfigureComponent(b => new RabbitMqMessageSender(b.Build <IRoutingTopology>(), b.Build <IChannelProvider>(), b.Build <PipelineExecutor>().CurrentContext), DependencyLifecycle.InstancePerCall); if (useCallbackReceiver) { context.Container.ConfigureComponent <CallbackQueueCreator>(DependencyLifecycle.InstancePerCall) .ConfigureProperty(p => p.Enabled, true) .ConfigureProperty(p => p.CallbackQueueAddress, Address.Parse(callbackQueue)); //context.Pipeline.Register<ForwardCallbackQueueHeaderBehavior.Registration>(); context.Pipeline.Register <SetOutgoingCallbackAddressBehavior.Registration>(); context.Container.ConfigureComponent <SetOutgoingCallbackAddressBehavior>(DependencyLifecycle.SingleInstance) .ConfigureProperty(p => p.CallbackQueue, callbackQueue); } context.Container.ConfigureComponent <ChannelProvider>(DependencyLifecycle.InstancePerCall) .ConfigureProperty(p => p.UsePublisherConfirms, connectionConfiguration.UsePublisherConfirms) .ConfigureProperty(p => p.MaxWaitTimeForConfirms, connectionConfiguration.MaxWaitTimeForConfirms); context.Container.ConfigureComponent <RabbitMqDequeueStrategy>(DependencyLifecycle.InstancePerCall); context.Container.ConfigureComponent <RabbitMqMessagePublisher>(DependencyLifecycle.InstancePerCall); context.Container.ConfigureComponent <RabbitMqSubscriptionManager>(DependencyLifecycle.SingleInstance) .ConfigureProperty(p => p.EndpointQueueName, queueName); context.Container.ConfigureComponent <RabbitMqQueueCreator>(DependencyLifecycle.InstancePerCall); if (context.Settings.HasSetting <IRoutingTopology>()) { context.Container.RegisterSingleton(context.Settings.Get <IRoutingTopology>()); } else { var durable = GetDurableMessagesEnabled(context.Settings); IRoutingTopology topology; DirectRoutingTopology.Conventions conventions; if (context.Settings.TryGet(out conventions)) { topology = new DirectRoutingTopology(conventions, durable); } else { topology = new ConventionalRoutingTopology(durable); } context.Container.RegisterSingleton(topology); } if (context.Settings.HasSetting("IManageRabbitMqConnections")) { context.Container.ConfigureComponent(context.Settings.Get <Type>("IManageRabbitMqConnections"), DependencyLifecycle.SingleInstance); } else { context.Container.ConfigureComponent <RabbitMqConnectionManager>(DependencyLifecycle.SingleInstance); context.Container.ConfigureComponent(builder => new RabbitMqConnectionFactory(builder.Build <ConnectionConfiguration>()), DependencyLifecycle.InstancePerCall); } }
public override VisualLineElement ConstructElement(int offset) { var result = this.FindMatch(offset); if (result != null) { if (result.Type == "State") { var size = (double)new FontSizeConverter().ConvertFromString(Settings.Instance.Global_Fonts_Message_FontSize + "pt"); var image = new Image() { Height = (size - 3), Width = (size - 3), Margin = new Thickness(1.5, 1.5, 0, 0) }; if (result.Value == "#") { image.Source = StatesIconManager.Instance.Green; } else if (result.Value == "!") { image.Source = StatesIconManager.Instance.Red; } else if (result.Value == "@") { image.Source = StatesIconManager.Instance.Yello; } var element = new CustomObjectElement(result.Value, image); element.ClickEvent += (string text) => { this.OnSelectEvent(new CustomElementRange(offset, offset + result.Value.Length)); }; return(element); } else if (result.Type == "Signature") { Brush brush; if (Inspect.ContainTrustSignature(result.Value)) { brush = new SolidColorBrush(_serviceManager.Config.Colors.Message_Trust); } else { brush = new SolidColorBrush(_serviceManager.Config.Colors.Message_Untrust); } var element = new CustomTextElement(result.Value); element.Foreground = brush; element.ClickEvent += (string text) => { this.OnSelectEvent(new CustomElementRange(offset, offset + result.Value.Length)); }; return(element); } else if (result.Type == "Uri") { var uri = result.Value; CustomObjectElement element = null; if (uri.StartsWith("http:") | uri.StartsWith("https:")) { var textBlock = new TextBlock(); textBlock.Text = uri.Substring(0, Math.Min(64, uri.Length)) + ((uri.Length > 64) ? "..." : ""); textBlock.ToolTip = HttpUtility.UrlDecode(uri); if (Settings.Instance.Global_UrlHistorys.Contains(uri)) { textBlock.Foreground = new SolidColorBrush(_serviceManager.Config.Colors.Link); } else { textBlock.Foreground = new SolidColorBrush(_serviceManager.Config.Colors.Link_New); } element = new CustomObjectElement(uri, textBlock); } else if (uri.StartsWith("Tag:")) { var tag = AmoebaConverter.FromTagString(uri); var textBlock = new TextBlock(); textBlock.Text = uri.Substring(0, Math.Min(64, uri.Length)) + ((uri.Length > 64) ? "..." : ""); textBlock.ToolTip = MessageConverter.ToInfoMessage(tag); if (Settings.Instance.Global_TagHistorys.Contains(tag)) { textBlock.Foreground = new SolidColorBrush(_serviceManager.Config.Colors.Link); } else { textBlock.Foreground = new SolidColorBrush(_serviceManager.Config.Colors.Link_New); } element = new CustomObjectElement(uri, textBlock); } else if (uri.StartsWith("Seed:")) { var seed = AmoebaConverter.FromSeedString(uri); var textBlock = new TextBlock(); textBlock.Text = uri.Substring(0, Math.Min(64, uri.Length)) + ((uri.Length > 64) ? "..." : ""); textBlock.ToolTip = MessageConverter.ToInfoMessage(seed); if (Settings.Instance.Global_SeedHistorys.Contains(seed)) { textBlock.Foreground = new SolidColorBrush(_serviceManager.Config.Colors.Link); } else { textBlock.Foreground = new SolidColorBrush(_serviceManager.Config.Colors.Link_New); } element = new CustomObjectElement(uri, textBlock); } if (element != null) { element.ClickEvent += (string text) => { this.OnSelectEvent(new CustomElementRange(offset, offset + result.Value.Length)); this.OnClickEvent(text); }; return(element); } } } return(null); }
public async Task <Response> CreateResponseAsync() { List <MessageDto> updatedMessages = await loadMessagesService.GetUserUpdatedMessagesAsync( clientConnection.UserId.GetValueOrDefault(), request.Start.GetValueOrDefault(), request.ConversationId, request.ConversationType, request.MessageId) .ConfigureAwait(false); if (!updatedMessages.Any()) { return(new UpdatedMessagesResponse(request.RequestId, null, null, null, null, null, Array.Empty <MessageInfo>(), null)); } IEnumerable <IGrouping <ConversationType, MessageDto> > groupingMessages; List <MessageInfo> messageInfo = new List <MessageInfo>(); List <MessageVm> editedMessages = new List <MessageVm>(); long startUpdatedTime = updatedMessages.FirstOrDefault().UpdatedAt.GetValueOrDefault(); long? endUpdatedTime = null; long? endConversationId = null; Guid? endMessageId = null; ConversationType?endConversationType = null; if (updatedMessages.Count() < UPDATES_LIMIT) { groupingMessages = updatedMessages.GroupBy(opt => opt.ConversationType); } else { List <MessageDto> partOfMessages = updatedMessages.Take(UPDATES_LIMIT).ToList(); MessageDto lastMessage = partOfMessages.LastOrDefault(); groupingMessages = partOfMessages.GroupBy(opt => opt.ConversationType); endUpdatedTime = lastMessage.UpdatedAt; endConversationId = lastMessage.ConversationId; endConversationType = lastMessage.ConversationType; endMessageId = lastMessage.GlobalId; } foreach (var group in groupingMessages) { var conversationGroupingMessages = group.GroupBy(opt => opt.ConversationId); foreach (var messages in conversationGroupingMessages) { var deletedMessagesId = messages.Where(opt => opt.Deleted)?.Select(opt => opt.GlobalId); if (deletedMessagesId != null && deletedMessagesId.Any()) { messageInfo.Add( new MessageInfo( messages.Key, group.Key, deletedMessagesId)); } var edited = MessageConverter.GetMessagesVm( messages.Where(opt => !opt.Deleted), clientConnection.UserId.GetValueOrDefault()); if (edited != null && edited.Any()) { editedMessages.AddRange(edited); } } } return(new UpdatedMessagesResponse(request.RequestId, startUpdatedTime, endUpdatedTime, endConversationId, endConversationType, endMessageId, messageInfo, editedMessages)); }
private async Task <List <MessageDto> > DeleteChatMessagesInfoAsync(long chatId, IEnumerable <Guid> messagesIds, long userId) { try { using (MessengerDbContext context = contextFactory.Create()) { var messagesCondition = PredicateBuilder.New <Message>(); messagesCondition = messagesIds.Aggregate(messagesCondition, (current, value) => current.Or(opt => opt.GlobalId == value && opt.ChatId == chatId && opt.Deleted == false)); var query = from conversation in context.Chats join chatUser in context.ChatUsers on conversation.Id equals chatUser.ChatId where chatUser.Banned == false && chatUser.Deleted == false && conversation.Deleted == false && chatUser.UserId == userId && conversation.Id == chatId select new { Chat = conversation, User = chatUser }; var result = await query.FirstOrDefaultAsync().ConfigureAwait(false); if (result == null || result.User == null) { return(new List <MessageDto>()); } List <Message> messages = await context.Messages .Include(opt => opt.Attachments) .Where(messagesCondition) .ToListAsync() .ConfigureAwait(false); if (!messages.Any()) { return(new List <MessageDto>()); } var deletedMessagesIds = messages.Select(message => message.GlobalId).ToList(); var usersCondition = PredicateBuilder.New <ChatUser>(); usersCondition = deletedMessagesIds.Aggregate(usersCondition, (current, value) => current.Or(opt => opt.LastReadedGlobalMessageId == value).Expand()); var chatUsers = await context.ChatUsers.Where(usersCondition).ToListAsync().ConfigureAwait(false); var groupedChatUsers = chatUsers.GroupBy(opt => opt.LastReadedGlobalMessageId); foreach (var group in groupedChatUsers) { var message = await context.Messages .OrderByDescending(opt => opt.SendingTime) .ThenBy(opt => opt.GlobalId) .Where(opt => !deletedMessagesIds.Contains(opt.GlobalId) && opt.ChatId == chatId && !opt.Deleted) .FirstOrDefaultAsync() .ConfigureAwait(false); foreach (var chatUser in group) { chatUser.LastReadedGlobalMessageId = message?.GlobalId; } context.ChatUsers.UpdateRange(group); } List <MessageDto> deletedMessages = MessageConverter.GetMessagesDto(messages); foreach (var message in messages) { if (message.SenderId != result.User.UserId && result.User.UserRole == UserRole.User) { continue; } message.Deleted = true; message.UpdatedAt = DateTime.UtcNow.ToUnixTime(); if (NodeSettings.Configs.Node.PermanentlyDeleting) { message.Attachments = null; message.Replyto = null; message.SendingTime = 0; message.Text = null; message.SenderId = null; } } context.UpdateRange(messages); await context.SaveChangesAsync().ConfigureAwait(false); Message lastMessage = await _loadMessagesService.GetLastValidChatMessageAsync(chatId).ConfigureAwait(false); result.Chat.LastMessageId = lastMessage?.Id ?? null; result.Chat.LastMessageGlobalId = lastMessage?.GlobalId; context.Update(result.Chat); await context.SaveChangesAsync().ConfigureAwait(false); return(deletedMessages); } } catch (Exception ex) { throw new DeleteMessagesException("An error occurred while deleting messages.", ex); } }
public void ExcuteCommand(iS3UnityMessage message) { ExcuteCommand(MessageConverter.SerializeMessage(message)); }
public async Task <List <MessageDto> > GetMessagesAsync(long conversationId, ConversationType conversationType, bool direction, Guid?messageId, List <AttachmentType> attachmentsTypes, int limit) { using (MessengerDbContext context = contextFactory.Create()) { IQueryable <Message> query = context.Messages .Where(message => message.ExpiredAt > DateTime.UtcNow.ToUnixTime() || message.ExpiredAt == null) .Where(message => !message.Deleted); Message navigationMessage = null; switch (conversationType) { case ConversationType.Dialog: { navigationMessage = await context.Messages.FirstOrDefaultAsync(opt => opt.GlobalId == messageId && opt.DialogId == conversationId).ConfigureAwait(false); query = query.Where(opt => opt.DialogId == conversationId); } break; case ConversationType.Chat: { navigationMessage = await context.Messages.FirstOrDefaultAsync(opt => opt.GlobalId == messageId && opt.ChatId == conversationId).ConfigureAwait(false); query = query.Where(opt => opt.ChatId == conversationId); } break; case ConversationType.Channel: { navigationMessage = await context.Messages.FirstOrDefaultAsync(opt => opt.GlobalId == messageId && opt.ChannelId == conversationId).ConfigureAwait(false); query = query.Where(opt => opt.ChannelId == conversationId); } break; } if (navigationMessage != null) { query = direction ? query.Where(opt => opt.Id < navigationMessage.Id) : query.Where(opt => opt.Id > navigationMessage.Id); } if (!attachmentsTypes.IsNullOrEmpty()) { List <short> types = attachmentsTypes.Select(type => (short)type).ToList(); query = query.Where(opt => opt.Attachments.Any(attach => types.Contains(attach.Type))); } query = direction ? query.OrderByDescending(message => message.SendingTime) .ThenByDescending(message => message.Id) .ThenByDescending(message => message.GlobalId) : query.OrderBy(message => message.SendingTime) .ThenBy(message => message.Id) .ThenBy(message => message.GlobalId); var messages = await query .AsNoTracking() .Include(message => message.Attachments) .Take(limit) .ToListAsync() .ConfigureAwait(false); return(MessageConverter.GetMessagesDto(messages)); } }
public async Task <List <MessageDto> > GetUserUpdatedMessagesAsync(long userId, long updatedTime, long?conversationId, ConversationType?conversationType, Guid?messageId, int limit = 1000) { IEnumerable <long> userDialogsIds = await loadDialogsService.GetUserDialogsIdAsync(userId).ConfigureAwait(false); IEnumerable <long> userChatsIds = await loadChatsService.GetUserChatsIdAsync(userId).ConfigureAwait(false); IEnumerable <long> userChannelsIds = await loadChannelsService.GetUserChannelsIdAsync(userId).ConfigureAwait(false); var messagesCondition = PredicateBuilder.New <Message>(); messagesCondition = userDialogsIds.Aggregate(messagesCondition, (current, value) => current.Or(opt => opt.DialogId == value)); messagesCondition = messagesCondition.Or(opt => userChatsIds.Contains(opt.ChatId.GetValueOrDefault())); messagesCondition = messagesCondition.Or(opt => userChannelsIds.Contains(opt.ChannelId.GetValueOrDefault())).Expand(); List <Message> updatedMessages = new List <Message>(); Message navigationMessage = null; using (MessengerDbContext context = contextFactory.Create()) { switch (conversationType.GetValueOrDefault()) { case ConversationType.Dialog: { navigationMessage = await context.Messages .FirstOrDefaultAsync(message => message.DialogId == conversationId && message.GlobalId == messageId) .ConfigureAwait(false); } break; case ConversationType.Chat: { navigationMessage = await context.Messages .FirstOrDefaultAsync(message => message.ChatId == conversationId && message.GlobalId == messageId) .ConfigureAwait(false); } break; case ConversationType.Channel: { navigationMessage = await context.Messages .FirstOrDefaultAsync(message => message.ChannelId == conversationId && message.GlobalId == messageId) .ConfigureAwait(false); } break; } if (navigationMessage == null) { navigationMessage = new Message { Id = 0 }; } updatedMessages = await context.Messages .Where(messagesCondition) .Where(opt => opt.UpdatedAt >= updatedTime) .Where(opt => opt.ExpiredAt > DateTime.UtcNow.ToUnixTime() || opt.ExpiredAt == null) .Take(limit) .ToListAsync() .ConfigureAwait(false); updatedMessages = updatedMessages .OrderBy(opt => opt.UpdatedAt) .ThenBy(opt => opt.Id) .ThenBy(opt => opt.GlobalId) .Where(opt => opt.Id > navigationMessage.Id) .ToList(); return(MessageConverter.GetMessagesDto(updatedMessages)); } }
/// <summary> /// Receives a batch of <see cref="EventData" /> from the Event Hub partition. /// </summary> /// /// <param name="maximumEventCount">The maximum number of messages to receive in this batch.</param> /// <param name="maximumWaitTime">The maximum amount of time to wait for events to become available, if no events can be read from the prefetch queue. If not specified, the per-try timeout specified by the retry policy will be used.</param> /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param> /// /// <returns>The batch of <see cref="EventData" /> from the Event Hub partition this consumer is associated with. If no events are present, an empty set is returned.</returns> /// /// <remarks> /// When events are available in the prefetch queue, they will be used to form the batch as quickly as possible without waiting for additional events from the /// Event Hubs service to try and meet the requested <paramref name="maximumEventCount" />. When no events are available in prefetch, the receiver will wait up /// to the <paramref name="maximumWaitTime"/> for events to be read from the service. Once any events are available, they will be used to form the batch immediately. /// </remarks> /// public override async Task <IReadOnlyList <EventData> > ReceiveAsync(int maximumEventCount, TimeSpan?maximumWaitTime, CancellationToken cancellationToken) { Argument.AssertNotClosed(_closed, nameof(AmqpConsumer)); Argument.AssertNotClosed(ConnectionScope.IsDisposed, nameof(EventHubConnection)); Argument.AssertAtLeast(maximumEventCount, 1, nameof(maximumEventCount)); var receivedEventCount = 0; var failedAttemptCount = 0; var tryTimeout = RetryPolicy.CalculateTryTimeout(0); var waitTime = (maximumWaitTime ?? tryTimeout); var operationId = Guid.NewGuid().ToString("D", CultureInfo.InvariantCulture); var link = default(ReceivingAmqpLink); var retryDelay = default(TimeSpan?); var receivedEvents = default(List <EventData>); var lastReceivedEvent = default(EventData); var stopWatch = ValueStopwatch.StartNew(); try { while ((!cancellationToken.IsCancellationRequested) && (!_closed)) { try { // Creation of the link happens without explicit knowledge of the cancellation token // used for this operation; validate the token state before attempting link creation and // again after the operation completes to provide best efforts in respecting it. EventHubsEventSource.Log.EventReceiveStart(EventHubName, ConsumerGroup, PartitionId, operationId); if (!ReceiveLink.TryGetOpenedObject(out link)) { link = await ReceiveLink.GetOrCreateAsync(UseMinimum(ConnectionScope.SessionTimeout, tryTimeout), cancellationToken).ConfigureAwait(false); } cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>(); var messagesReceived = await link.ReceiveMessagesAsync(maximumEventCount, ReceiveBuildBatchInterval, waitTime, cancellationToken).ConfigureAwait(false); // If no messages were received, then just return the empty set. if (messagesReceived == null) { return(EmptyEventSet); } // If event messages were received, then package them for consumption and // return them. foreach (AmqpMessage message in messagesReceived) { receivedEvents ??= new List <EventData>(); link.DisposeDelivery(message, true, AmqpConstants.AcceptedOutcome); receivedEvents.Add(MessageConverter.CreateEventFromMessage(message)); message.Dispose(); receivedEventCount = receivedEvents.Count; } if (receivedEventCount > 0) { lastReceivedEvent = receivedEvents[receivedEventCount - 1]; if (lastReceivedEvent.Offset > long.MinValue) { CurrentEventPosition = EventPosition.FromOffset(lastReceivedEvent.Offset, false); } if (TrackLastEnqueuedEventProperties) { LastReceivedEvent = lastReceivedEvent; } } return(receivedEvents ?? EmptyEventSet); } catch (EventHubsException ex) when(ex.Reason == EventHubsException.FailureReason.ServiceTimeout) { // Because the timeout specified with the request is intended to be the maximum // amount of time to wait for events, a timeout isn't considered an error condition, // rather a sign that no events were available in the requested period. return(EmptyEventSet); } catch (Exception ex) { Exception activeEx = ex.TranslateServiceException(EventHubName); // If the partition was stolen determine the correct action to take for // capturing it with respect to whether the consumer should be invalidated. // // In either case, it is a terminal exception and will not trigger a retry; // allow the normal error handling flow to surface the exception. if (ex.IsConsumerPartitionStolenException()) { // If the consumer should be invalidated, capture the exception // and force-close the link. This will ensure that the next operation // will surface it. if (InvalidateConsumerWhenPartitionStolen) { _activePartitionStolenException = ex; CloseConsumerLink(link); } else { // If the consumer should not be invalidated, clear any previously captured exception to avoid // surfacing the failure multiple times. If the link is stolen after this operation, it will // be intercepted and handled as needed. _activePartitionStolenException = null; } } // Determine if there should be a retry for the next attempt; if so enforce the delay but do not quit the loop. // Otherwise, bubble the exception. ++failedAttemptCount; retryDelay = RetryPolicy.CalculateRetryDelay(activeEx, failedAttemptCount); if ((retryDelay.HasValue) && (!ConnectionScope.IsDisposed) && (!_closed) && (!cancellationToken.IsCancellationRequested)) { EventHubsEventSource.Log.EventReceiveError(EventHubName, ConsumerGroup, PartitionId, operationId, activeEx.Message); await Task.Delay(UseMinimum(retryDelay.Value, waitTime.CalculateRemaining(stopWatch.GetElapsedTime())), cancellationToken).ConfigureAwait(false); tryTimeout = RetryPolicy.CalculateTryTimeout(failedAttemptCount); } else if (ex is AmqpException) { ExceptionDispatchInfo.Capture(activeEx).Throw(); } else { throw; } } } // If no value has been returned nor exception thrown by this point, // then cancellation has been requested. throw new TaskCanceledException(); } catch (TaskCanceledException) { throw; } catch (Exception ex) { EventHubsEventSource.Log.EventReceiveError(EventHubName, ConsumerGroup, PartitionId, operationId, ex.Message); throw; } finally { EventHubsEventSource.Log.EventReceiveComplete(EventHubName, ConsumerGroup, PartitionId, operationId, failedAttemptCount, receivedEventCount); } }
public async Task <List <MessageDto> > GetChannelMessagesAsync(long channelId, long userId, Guid?navigationMessageId, List <AttachmentType> attachmentsTypes = null, bool direction = true, byte limit = 30) { using (MessengerDbContext context = contextFactory.Create()) { var query = context.Messages.Where(opt => opt.ChannelId == channelId && opt.Deleted == false); if (navigationMessageId != null) { var navigationMessage = await context.Messages.FirstOrDefaultAsync(opt => opt.GlobalId == navigationMessageId && opt.ChannelId == channelId).ConfigureAwait(false); if (navigationMessage != null) { if (direction) { query = query.Where(opt => opt.Id < navigationMessage.Id); } else { query = query.Where(opt => opt.Id > navigationMessage.Id); } } } if (direction) { query = query .OrderByDescending(message => message.SendingTime) .ThenByDescending(message => message.Id) .ThenByDescending(message => message.GlobalId); } else { query = query .OrderBy(message => message.SendingTime) .ThenBy(message => message.Id) .ThenBy(message => message.GlobalId); } if (!attachmentsTypes.IsNullOrEmpty()) { List <short> types = attachmentsTypes.Select(type => (short)type).ToList(); query = query.Where(opt => opt.Attachments.Any(attach => types.Contains(attach.Type))); } var messages = await query .AsNoTracking() .Include(message => message.Attachments) .Take(limit) .ToListAsync() .ConfigureAwait(false); var channelUser = await context.ChannelUsers.FirstOrDefaultAsync(opt => opt.ChannelId == channelId && opt.UserId == userId).ConfigureAwait(false); if (channelUser != null) { var lastReadedMessage = await context.Messages .FirstOrDefaultAsync(opt => opt.GlobalId == channelUser.LastReadedGlobalMessageId && opt.ChannelId == channelId).ConfigureAwait(false); if (lastReadedMessage != null) { messages.ForEach(message => { if (message.Id > lastReadedMessage.Id && message.SenderId != userId) { message.Read = false; } else { message.Read = true; } }); } } return(MessageConverter.GetMessagesDto(messages)); } }
private async Task HandleChannelMessagesAsync(IEnumerable <MessageVm> messages) { foreach (var message in messages) { bool hasException = true; MessageDto sentMessage = null; while (hasException) { try { if (NodeData.Instance.RoutedMessagesId.Contains(message.GlobalId.GetValueOrDefault())) { hasException = false; continue; } if (message.Attachments != null) { foreach (var attachment in message.Attachments) { attachment.MessageId = 0; } await attachmentsService.DownloadAttachmentsPayloadAsync(message.Attachments, current).ConfigureAwait(false); await attachmentsService.ThrowIfAttachmentsInvalidAsync(message, true).ConfigureAwait(false); } sentMessage = await createMessagesService.CreateChannelMessageAsync(MessageConverter.GetMessageDto(message)).ConfigureAwait(false); hasException = false; } catch (ConversationNotFoundException ex) { var channel = await nodeRequestSender.GetChannelInformationAsync(ex.ConversationId, current).ConfigureAwait(false); await createChannelsService.CreateOrUpdateUserChannelsAsync(new List <ChannelDto> { channel }).ConfigureAwait(false); hasException = true; } catch (UserNotFoundException ex) { List <UserVm> users = new List <UserVm>(await nodeRequestSender.GetUsersInfoAsync(ex.UsersId.ToList(), null, current).ConfigureAwait(false)); await crossNodeService.CreateNewUsersAsync(users).ConfigureAwait(false); hasException = true; } catch (Exception ex) { Logger.WriteLog(ex); hasException = false; } } SendChannelNotificationsAsync(sentMessage); } }
public async Task <List <MessageDto> > DialogMessagesReadAsync(IEnumerable <Guid> messagesId, long dialogId, long userId) { var messagesCondition = PredicateBuilder.New <Message>(); messagesCondition = messagesId.Aggregate(messagesCondition, (current, value) => current.Or(message => message.GlobalId == value).Expand()); using (MessengerDbContext context = contextFactory.Create()) { var messages = await context.Messages .Where(messagesCondition) .Where(message => (message.Dialog.Id == dialogId) && !message.Read) .ToListAsync() .ConfigureAwait(false); if (!messages.Any()) { throw new WrongArgumentException(); } var earlierMessage = messages.OrderBy(message => message.SendingTime).FirstOrDefault(); if (earlierMessage != null) { var unreadedMessages = await context.Messages .Where(message => message.SendingTime < earlierMessage.SendingTime && !message.Read && message.DialogId == dialogId) .ToListAsync() .ConfigureAwait(false); List <Message> earlierUnreadedMessages = new List <Message>(); foreach (var readedMessage in unreadedMessages) { if (readedMessage.SenderId != userId) { readedMessage.Read = true; var sameMessage = await context.Messages .FirstOrDefaultAsync(message => message.Id == readedMessage.SameMessageId) .ConfigureAwait(false); sameMessage.Read = true; earlierUnreadedMessages.Add(sameMessage); } } } List <Message> sameMessages = new List <Message>(); foreach (var readedMessage in messages) { if (readedMessage.SenderId != userId) { readedMessage.Read = true; var sameMessage = await context.Messages .FirstOrDefaultAsync(message => message.Id == readedMessage.SameMessageId).ConfigureAwait(false); if (sameMessage == null) { sameMessages.Add(readedMessage); } else { sameMessage.Read = true; sameMessages.Add(sameMessage); } } } await context.SaveChangesAsync().ConfigureAwait(false); return(MessageConverter.GetMessagesDto(sameMessages)); } }
protected override void Configure(FeatureConfigurationContext context, string connectionString) { var useCallbackReceiver = context.Settings.Get<bool>(UseCallbackReceiverSettingKey); var maxConcurrencyForCallbackReceiver = context.Settings.Get<int>(MaxConcurrencyForCallbackReceiver); var queueName = GetLocalAddress(context.Settings); var callbackQueue = string.Format("{0}.{1}", queueName, RuntimeEnvironment.MachineName); var connectionConfiguration = new ConnectionStringParser(context.Settings).Parse(connectionString); MessageConverter messageConverter; if (context.Settings.HasSetting(CustomMessageIdStrategy)) { messageConverter = new MessageConverter(context.Settings.Get<Func<BasicDeliverEventArgs, string>>(CustomMessageIdStrategy)); } else { messageConverter = new MessageConverter(); } string hostDisplayName; if (!context.Settings.TryGet("NServiceBus.HostInformation.DisplayName", out hostDisplayName))//this was added in 5.1.2 of the core { hostDisplayName = RuntimeEnvironment.MachineName; } var consumerTag = string.Format("{0} - {1}", hostDisplayName, context.Settings.EndpointName()); var receiveOptions = new ReceiveOptions(workQueue => { //if this isn't the main queue we shouldn't use callback receiver if (!useCallbackReceiver || workQueue != queueName) { return SecondaryReceiveSettings.Disabled(); } return SecondaryReceiveSettings.Enabled(callbackQueue, maxConcurrencyForCallbackReceiver); }, messageConverter, connectionConfiguration.PrefetchCount, connectionConfiguration.DequeueTimeout * 1000, context.Settings.GetOrDefault<bool>("Transport.PurgeOnStartup"), consumerTag); context.Container.RegisterSingleton(connectionConfiguration); context.Container.ConfigureComponent(builder => new RabbitMqDequeueStrategy( builder.Build<IManageRabbitMqConnections>(), SetupCircuitBreaker(builder.Build<CriticalError>()), receiveOptions), DependencyLifecycle.InstancePerCall); context.Container.ConfigureComponent<OpenPublishChannelBehavior>(DependencyLifecycle.InstancePerCall); context.Pipeline.Register<OpenPublishChannelBehavior.Registration>(); context.Container.ConfigureComponent<RabbitMqMessageSender>(DependencyLifecycle.InstancePerCall); if (useCallbackReceiver) { context.Container.ConfigureProperty<RabbitMqMessageSender>(p => p.CallbackQueue, callbackQueue); context.Container.ConfigureComponent<CallbackQueueCreator>(DependencyLifecycle.InstancePerCall) .ConfigureProperty(p => p.Enabled, true) .ConfigureProperty(p => p.CallbackQueueAddress, Address.Parse(callbackQueue)); context.Pipeline.Register<ForwardCallbackQueueHeaderBehavior.Registration>(); } context.Container.ConfigureComponent<ChannelProvider>(DependencyLifecycle.InstancePerCall) .ConfigureProperty(p => p.UsePublisherConfirms, connectionConfiguration.UsePublisherConfirms) .ConfigureProperty(p => p.MaxWaitTimeForConfirms, connectionConfiguration.MaxWaitTimeForConfirms); context.Container.ConfigureComponent<RabbitMqDequeueStrategy>(DependencyLifecycle.InstancePerCall); context.Container.ConfigureComponent<RabbitMqMessagePublisher>(DependencyLifecycle.InstancePerCall); context.Container.ConfigureComponent<RabbitMqSubscriptionManager>(DependencyLifecycle.SingleInstance) .ConfigureProperty(p => p.EndpointQueueName, queueName); context.Container.ConfigureComponent<RabbitMqQueueCreator>(DependencyLifecycle.InstancePerCall); if (context.Settings.HasSetting<IRoutingTopology>()) { context.Container.RegisterSingleton(context.Settings.Get<IRoutingTopology>()); } else { var durable = GetDurableMessagesEnabled(context.Settings); IRoutingTopology topology; DirectRoutingTopology.Conventions conventions; if (context.Settings.TryGet(out conventions)) { topology = new DirectRoutingTopology(conventions, durable); } else { topology = new ConventionalRoutingTopology(durable); } context.Container.RegisterSingleton(topology); } if (context.Settings.HasSetting("IManageRabbitMqConnections")) { context.Container.ConfigureComponent(context.Settings.Get<Type>("IManageRabbitMqConnections"), DependencyLifecycle.SingleInstance); } else { context.Container.ConfigureComponent<RabbitMqConnectionManager>(DependencyLifecycle.SingleInstance); context.Container.ConfigureComponent(builder => new RabbitMqConnectionFactory(builder.Build<ConnectionConfiguration>()), DependencyLifecycle.InstancePerCall); } }
private async Task <List <MessageDto> > DeleteDialogMessagesInfoAsync(long dialogId, IEnumerable <Guid> messagesIds, long userId) { try { using (MessengerDbContext context = contextFactory.Create()) { long mirrorDialogId = await _loadDialogsService.GetMirrorDialogIdAsync(dialogId).ConfigureAwait(false); var messagesCondition = PredicateBuilder.New <Message>(); messagesCondition = messagesIds.Aggregate(messagesCondition, (current, value) => current.Or(opt => opt.GlobalId == value && (opt.DialogId == dialogId || opt.DialogId == mirrorDialogId) && (opt.SenderId == userId || opt.ReceiverId == userId)).Expand()); List <MessageDto> deletedMessages; List <Message> messages = await context.Messages .Include(opt => opt.Attachments) .Where(messagesCondition) .ToListAsync() .ConfigureAwait(false); if (!messages.Any()) { return(new List <MessageDto>()); } deletedMessages = MessageConverter.GetMessagesDto(messages); Dialog firstDialog = await context.Dialogs.FirstOrDefaultAsync(opt => opt.Id == dialogId).ConfigureAwait(false); Dialog mirrorDialog = await context.Dialogs.FirstOrDefaultAsync(opt => opt.Id == mirrorDialogId).ConfigureAwait(false); foreach (var message in messages) { message.Deleted = true; message.UpdatedAt = DateTime.UtcNow.ToUnixTime(); if (NodeSettings.Configs.Node.PermanentlyDeleting) { message.Attachments = null; message.Replyto = null; message.SendingTime = 0; message.Text = null; message.SenderId = null; message.ReceiverId = null; } } context.UpdateRange(messages); await context.SaveChangesAsync().ConfigureAwait(false); Message lastMessageFirstDialog = await _loadMessagesService.GetLastValidDialogMessageAsync(dialogId).ConfigureAwait(false); Message lastMessageSecondDialog = await _loadMessagesService.GetLastValidDialogMessageAsync(mirrorDialogId).ConfigureAwait(false); firstDialog.LastMessageId = lastMessageFirstDialog?.Id ?? null; mirrorDialog.LastMessageId = lastMessageSecondDialog?.Id ?? null; firstDialog.LastMessageGlobalId = lastMessageFirstDialog?.GlobalId; mirrorDialog.LastMessageGlobalId = lastMessageSecondDialog?.GlobalId; context.Dialogs.UpdateRange(firstDialog, mirrorDialog); await context.SaveChangesAsync().ConfigureAwait(false); return(deletedMessages); } } catch (Exception ex) { throw new DeleteMessagesException("An error occurred while deleting messages.", ex); } }
public T Get <T>(string key) { if (CacheProvider.srmList != null && CacheProvider.srmList.Count > 0) { ServiceRequest request = new ServiceRequest(); request.ServiceName = "CacheServer"; request.MethodName = "GetObject"; request.Parameters = new object[] { key }; List <int> indexlist = new List <int>(CacheProvider.srmList.Count); for (int i = 0; i < CacheProvider.srmList.Count; i++) { indexlist.Add(i); } Random rnd = new Random(); string errMsg = ""; while (indexlist.Count > 0) { int srmindex = rnd.Next(indexlist.Count); var srm = CacheProvider.srmList[srmindex]; CacheProvider.ServiceProxy.ServiceBaseUri = srm.GetUri(); try { if (CacheProvider.ServiceProxy.Connect()) { CacheProvider.ServiceProxy.ServiceSubscriber.TimeOut = 30000;//30秒 MessageConverter <T> converter = CacheProvider.ServiceProxy.GetServiceMessage <T>(request, DataType.Json); CacheProvider.ServiceProxy.Close(); if (converter != null && converter.Succeed && !(converter.Result == null || converter.Result.Equals(default(T)))) { return(converter.Result); } else { indexlist.RemoveAt(srmindex); // //此处应该记录日志,以分析缓存命中率 // string.Format("\r\n;获取缓存数据失败,Host:{0},Key:{1},ErrorMessage:{2}",srm.GetUri(), key,converter.ErrorMessage); } } else { indexlist.RemoveAt(srmindex); errMsg += string.Format("\r\n;获取缓存数据失败,Host:{0},Key:{1},ErrorMessage:{2}", srm.GetUri(), key, "服务器连接失败"); } } catch (Exception ex) { indexlist.RemoveAt(srmindex); //当其中一个缓存服务宕机时不应该被终止,在此应该写日志 errMsg += string.Format("\r\n;访问缓存服务器失败,Host:{0},Key:{1},ErrorMessage:{2}", srm.GetUri(), key, ex.Message); } } if (errMsg != "") { throw new Exception("获取缓存失败:" + errMsg); } else { return(default(T)); } } else { throw new Exception("缓存服务器列表为空"); } }
private async Task HandleDialogMessagesAsync(IEnumerable <MessageVm> messages) { foreach (var message in messages) { bool saveMessageFlag = true; try { if (NodeData.Instance.RoutedMessagesId.Contains(message.GlobalId.GetValueOrDefault())) { continue; } if (!message.Attachments.IsNullOrEmpty()) { foreach (var attachment in message.Attachments) { attachment.MessageId = 0; } await attachmentsService.DownloadAttachmentsPayloadAsync(message.Attachments, current).ConfigureAwait(false); await attachmentsService.ThrowIfAttachmentsInvalidAsync(message, true).ConfigureAwait(false); } if (!message.Attachments.IsNullOrEmpty()) { var attachment = message.Attachments.FirstOrDefault(opt => opt.Type == AttachmentType.EncryptedMessage); if (attachment != null) { var ecnryptedMessage = (EncryptedMessage)attachment.Payload; saveMessageFlag = ecnryptedMessage.SaveFlag > 0; } } List <MessageDto> newMessages = null; if (saveMessageFlag) { newMessages = await createMessagesService.CreateDialogMessageAsync(MessageConverter.GetMessageDto(message)).ConfigureAwait(false); } else { var dialogs = await loadDialogsService.GetUsersDialogsAsync(message.SenderId.Value, message.ReceiverId.Value); var senderMessage = MessageConverter.GetMessageDto(message); senderMessage.ConversationId = dialogs.FirstOrDefault(dialog => dialog.FirstUserId == message.SenderId).Id; var receiverMessage = MessageConverter.GetMessageDto(message); receiverMessage.ConversationId = dialogs.FirstOrDefault(dialog => dialog.FirstUserId == message.ReceiverId).Id; newMessages = new List <MessageDto> { senderMessage, receiverMessage }; } newMessages.Reverse(); SendDialogNotificationsAsync(newMessages, saveMessageFlag); } catch (UserNotFoundException ex) { if (ex.UsersId != null) { var user = (await nodeRequestSender.GetUsersInfoAsync( new List <long>(ex.UsersId), null, current).ConfigureAwait(false)).FirstOrDefault(); if (user != null) { await crossNodeService.NewOrEditUserAsync(new ShortUser { UserId = user.Id.GetValueOrDefault(), }, current.Node.Id).ConfigureAwait(false); } List <MessageDto> newMessages = await createMessagesService.CreateDialogMessageAsync(MessageConverter.GetMessageDto(message)).ConfigureAwait(false); newMessages.Reverse(); SendDialogNotificationsAsync(newMessages, saveMessageFlag); } } } }
public ConvertChannel(Fiber fiber, Channel <TOutput> output, MessageConverter <TInput, TOutput> converter) { _fiber = fiber; Output = output; Converter = converter; }
public async Task <List <MessageDto> > GetByItem(Guid id) { var messages = _context.Messages.AsNoTracking().ToList().FindAll(x => x.ItemId == id); return(MessageConverter.Convert(messages)); }
public void StringResponsesAreWrittenCorrectly() { var input = new MemoryStream(); var writer = new HmBinaryMessageWriter(input); writer.BeginMessage(MessageType.Request); writer.BeginContent(); writer.SetMethod("newDevices"); writer.BeginArray(1); writer.BeginItem(); //parameter 1 writer.BeginArray(2); writer.BeginItem(); writer.BeginStruct(2); writer.BeginItem(); writer.WritePropertyName("CHILDREN"); var items = 3; writer.BeginArray(items); for (; items > 0; items--) { writer.BeginItem(); writer.WriteStringValue("value " + items); writer.EndItem(); } writer.EndArray(); writer.EndItem(); writer.BeginItem(); writer.WritePropertyName("FIRMWARE"); writer.WriteStringValue("1.505"); writer.EndItem(); writer.EndStruct(); writer.EndItem(); writer.BeginItem(); writer.BeginStruct(3); writer.BeginItem(); writer.WritePropertyName("ADDRESS"); writer.WriteStringValue("BidCoS-RF"); writer.EndItem(); writer.BeginItem(); writer.WritePropertyName("CHILDREN"); var items2 = 5; writer.BeginArray(items2); for (; items2 > 0; items2--) { writer.BeginItem(); writer.WriteStringValue("value " + items2); writer.EndItem(); } writer.EndArray(); writer.EndItem(); writer.BeginItem(); writer.WritePropertyName("FIRMWARE"); writer.WriteStringValue("1.505"); writer.EndItem(); writer.EndStruct(); writer.EndItem(); //end parameter 1 writer.EndArray(); writer.EndItem(); //end params writer.EndArray(); writer.EndContent(); writer.EndMessage(); var result = BinaryUtils.FormatMemoryStream(input); input.Seek(0, SeekOrigin.Begin); var converter = new MessageConverter(); var outputReader = new JsonMessageBuilder(); converter.Convert(new HmBinaryMessageReader(input), outputReader); result.ShouldBe("42696E00000001180000000A6E6577446576696365730000000100000100000000020000010100000002000000084348494C4452454E0000010000000003000000030000000776616C75652033000000030000000776616C75652032000000030000000776616C75652031000000084649524D574152450000000300000005312E353035000001010000000300000007414444524553530000000300000009426964436F532D5246000000084348494C4452454E0000010000000005000000030000000776616C75652035000000030000000776616C75652034000000030000000776616C75652033000000030000000776616C75652032000000030000000776616C75652031000000084649524D574152450000000300000005312E353035"); }