public SubscriberSendChannelBuilder( MessageSender messageSender, MessageCacheFactory messageCacheFactory, ISystemTime systemTime, ITaskRepeater taskRepeater, MessageAcknowledgementHandler acknowledgementHandler, ISerialiser serialiser, ITaskScheduler taskScheduler, SenderAuthenticationSessionAttacherFactory authenticationSessionAttacherFactory) { Contract.Requires(messageSender != null); Contract.Requires(messageCacheFactory != null); Contract.Requires(systemTime != null); Contract.Requires(taskRepeater != null); Contract.Requires(acknowledgementHandler != null); Contract.Requires(serialiser != null); Contract.Requires(taskScheduler != null); Contract.Requires(authenticationSessionAttacherFactory != null); this.messageSender = messageSender; this.messageCacheFactory = messageCacheFactory; this.systemTime = systemTime; this.taskRepeater = taskRepeater; this.acknowledgementHandler = acknowledgementHandler; this.serialiser = serialiser; this.taskScheduler = taskScheduler; this.authenticationSessionAttacherFactory = authenticationSessionAttacherFactory; }
public void Execute(MessageSender source, IrcMessage message, CommandParameters parameters) { if (parameters.Count == 0 || parameters.Count > 1) throw new ParameterException(); bot.PartChannel(parameters[0]); }
private MessageSender GetMessageSender() { if (_messageSender != null) return _messageSender; _messageSender = _queueManager.CreateMessageSender(_queuePath).Result; return _messageSender; }
private async Task<MessageSender> GetMessageSender() { if (_messageSender != null) return _messageSender; _messageSender = await _queueManager.CreateMessageSender(_queuePath); return _messageSender; }
public DurableMessageSender(MessagingFactory messagingFactory, string serviceBusQueueOrTopicName) { this.messagingFactory = messagingFactory; this.sbusEntityName = serviceBusQueueOrTopicName; // Create a Service Bus queue client to send messages to the Service Bus queue. this.messageSender = this.messagingFactory.CreateMessageSender(this.sbusEntityName); // Create MSMQ queue if it doesn't exit. If it does, open the existing MSMQ queue. this.msmqQueueName = MsmqHelper.CreateMsmqQueueName(this.sbusEntityName, "SEND"); this.msmqQueue = MsmqHelper.GetMsmqQueue(this.msmqQueueName); // Create MSMQ deadletter queue if it doesn't exit. If it does, open the existing MSMQ deadletter queue. this.msmqDeadletterQueueName = MsmqHelper.CreateMsmqQueueName(this.sbusEntityName, "SEND_DEADLETTER"); this.msmqDeadletterQueue = MsmqHelper.GetMsmqQueue(this.msmqDeadletterQueueName); // Initialize wait time after durable client experienced a transient error. timerWaitTimeInMilliseconds = minTimerWaitTimeInMilliseconds; // FOR TESTING PURPOSE ONLY. this.faultInjector = new FaultInjector(enableFaultInjection); // Start receiving messages from the MSMQ queue. MsmqPeekBegin(); }
public void Setup() { // // observers SystemObserver.Setup(new IObserver<ISystemEvent>[] { new ConsoleObserver() }); // // message router Router = new MemoryMessageRouter(); Router.RegisterHandler<CreateAccount>(new CreateAccountHandler().Handle); Router.RegisterHandler<AccountCreated>(new AccountCreatedHandler().Handle); // // message bus var bus = new NullBus(); CommandBus = bus; EventBus = bus; // // Queue Writer var queueWriter = new QueueWriterToBus(bus); // // Misc Sender = new MessageSender(new IQueueWriter[] { queueWriter }); Identifier = new AccountID(Guid.NewGuid()); }
public RequestReplySender(MessageSender sender, MessageReceiver receiver) { this.sender = sender; this.receiver = receiver; receiver.OnMessageAsync(this.DispatchReply, new OnMessageOptions {AutoComplete = false}); }
public ReplySendChannelBuilder( MessageSender messageSender, ISerialiser serialiser, ISystemTime systemTime, ITaskRepeater taskRepeater, MessageCacheFactory messageCacheFactory, MessageAcknowledgementHandler acknowledgementHandler, ITaskScheduler taskScheduler, ReplyAuthenticationSessionAttacherFactory authenticationSessionAttacherFactory, ReplyCorrelationLookup correlationLookup) { Contract.Requires(messageSender != null); Contract.Requires(serialiser != null); Contract.Requires(systemTime != null); Contract.Requires(taskRepeater != null); Contract.Requires(messageCacheFactory != null); Contract.Requires(acknowledgementHandler != null); Contract.Requires(taskScheduler != null); Contract.Requires(authenticationSessionAttacherFactory != null); Contract.Requires(correlationLookup != null); this.messageSender = messageSender; this.serialiser = serialiser; this.systemTime = systemTime; this.taskRepeater = taskRepeater; this.messageCacheFactory = messageCacheFactory; this.acknowledgementHandler = acknowledgementHandler; this.taskScheduler = taskScheduler; this.authenticationSessionAttacherFactory = authenticationSessionAttacherFactory; this.correlationLookup = correlationLookup; }
internal AcknowledgementSendChannelBuilder(AcknowledgementSender acknowledgementSender, MessageSender sender) { Contract.Requires(acknowledgementSender != null); Contract.Requires(sender != null); this.acknowledgementSender = acknowledgementSender; this.sender = sender; }
public void TesSendMessageSuccess() { const string userName = "******"; const string password = "******"; var messageSender = new MessageSender(userName, password); var result = messageSender.SendMessage("13825634085", "This is a message from server.【恒锐咨询】"); Assert.AreEqual("成功", result); }
public void Execute(MessageSender executor, IrcMessage message, CommandParameters parameters) { if (parameters.Count == 0) return; var sendToServerMessage = GetParametersInOneSentence(parameters); bot.SendToServer(sendToServerMessage); }
public void Execute(MessageSender executor, IrcMessage message, CommandParameters parameters) { var commands = bot.GetAllCommands(); foreach (var command in commands) { bot.SayTo(executor.Channel, command.GetKeyWord()); } }
public void Execute(MessageSender source, IrcMessage message, CommandParameters parameters) { if (parameters == null || parameters.Count == 0) return; var sayToMessage = GetMessageFromParameters(parameters); bot.SayTo(source.Channel, sayToMessage); }
public void Send_Should_ThrowException_When_NameRepositoryCannotLoadNames() { // Arrange _mockNameRepository.Setup(x => x.Load()).Throws(new Exception("Test exception to simulate failure loading names")); // Act var sender = new MessageSender(_mockNameRepository.Object, _mockWriter.Object); sender.Send(ValidMessage); }
async Task<long> SendAndReceiveMessages(MessageSender sender, MessageReceiver receiver, int messageCount) { // Now we can start sending messages. var rnd = new Random(); var mockPayload = new byte[100]; // 100 random-byte payload rnd.NextBytes(mockPayload); Console.WriteLine("\nSending {0} messages to the queue", messageCount); var sendOps = new List<Task>(); for (var i = 0; i < messageCount; i++) { sendOps.Add( sender.SendAsync( new BrokeredMessage(new MemoryStream(mockPayload)) { TimeToLive = TimeSpan.FromMinutes(5) })); } Task.WaitAll(sendOps.ToArray()); Console.WriteLine("Send completed"); // Receive the messages Console.WriteLine("Receiving messages..."); // Start stopwatch var stopWatch = new Stopwatch(); stopWatch.Start(); var receivedMessage = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5)); while (receivedMessage != null ) { // here's where you'd do any work // complete (roundtrips) await receivedMessage.CompleteAsync(); if (--messageCount <= 0) break; // now get the next message receivedMessage = await receiver.ReceiveAsync(TimeSpan.FromSeconds(5)); } // Stop the stopwatch stopWatch.Stop(); Console.WriteLine("Receive completed"); var timeTaken = stopWatch.ElapsedMilliseconds; Console.WriteLine("Time to receive and complete all messages = {0} milliseconds", timeTaken); return timeTaken; }
public void Execute(Command command, MessageSender executor, IrcMessage message, CommandParameters parameters) { var isExecutionAllowed = securityLevelChecker.IsCommandExecutionAllowed(command, bot, executor.HostMask); if (!isExecutionAllowed) { bot.SayTo(executor.Channel, "You don't have required permission for this command"); return; } command.Execute(executor, message, parameters); }
public AssembledComponents AssembleComponents() { var documents = CreateNuclear(new DocumentStrategy()); var streamer = Streamer; var tapes = Tapes; var streaming = Streaming; var routerQueue = CreateQueueWriter(Topology.RouterQueue); var aggregates = new AggregateFactory(tapes, streamer, routerQueue); var sender = new SimpleMessageSender(streamer, routerQueue); var flow = new MessageSender(sender); var builder = new CqrsEngineBuilder(streamer); var log = tapes.GetOrCreateStream(Topology.DomainLogName); var dispatcher = new SimpleDispatcher(aggregates, streamer, log); builder.Handle(CreateInbox(Topology.RouterQueue), Topology.Route(CreateQueueWriter, streamer, tapes), "router"); builder.Handle(CreateInbox(Topology.EntityQueue), aggregates.Dispatch); var functions = new RedirectToDynamicEvent(); // documents //functions.WireToWhen(new RegistrationUniquenessProjection(atomic.Factory.GetEntityWriter<unit, RegistrationUniquenessDocument>())); // UI projections var projectionStore = CreateNuclear(new ProjectionStrategy()); foreach (var projection in BootstrapProjections.BuildProjectionsWithWhenConvention(projectionStore.Factory)) { functions.WireToWhen(projection); } // processes //functions.WireToWhen(new Domain.RecipeProcess(flow)); builder.Handle(CreateInbox(Topology.EventsQueue), aem => CallHandlers(functions, aem)); var timer = new StreamingTimerService(CreateQueueWriter(Topology.RouterQueue), streaming.GetContainer(Topology.FutureMessagesContainer), streamer); builder.Handle(CreateInbox(Topology.TimerQueue), timer.PutMessage); builder.AddProcess(timer); // GNS: just for this simple sample. In reality one would have some command handlers involved Bus.SetBus(new SimpleBus(sender, dispatcher)); return new AssembledComponents { Builder = builder, Sender = sender, Dispatcher = dispatcher, ProjectionFactory = projectionStore.Factory, Setup = this }; }
private static void RunExample() { var filePath = Path.Combine(Directory.GetCurrentDirectory(), @"Data\names.txt"); var nameRespository = new NameFileRepository(filePath); var writer = new ConsoleWriter(); // Dependencies created above are now being injected into the MessageSender // ConsoleMessageSender now called MessageSender var emailSender = new MessageSender(nameRespository, writer); emailSender.Send("Hello {0}"); }
public MessageReceiverObservableExtensionsTests() { this.azureServiceBusTestUtilities = AzureServiceBusTestUtilities.Create(); string queueName = "MessageReceiverExtensionTests-" + Guid.NewGuid(); this.queueDescription = this.azureServiceBusTestUtilities.NamespaceManager.CreateQueue(queueName); MessagingFactory messagingFactory = this.azureServiceBusTestUtilities.MessagingFactory; this.messageSender = messagingFactory.CreateMessageSender(this.queueDescription.Path); this.messageReceiver = messagingFactory.CreateMessageReceiver(this.queueDescription.Path); }
public void Execute(MessageSender executor, IrcMessage message, CommandParameters parameters) { if (parameters.Count == 0 || parameters.Count > 2) { var invalidParametersMessage = string.Format("Invalid amount of parameters. Usage: {0} {1} [{2}]", GetKeyWord(), "#channel", "password"); bot.SayTo(executor.Channel, invalidParametersMessage); return; } var channel = parameters[0]; var password = GetPassword(parameters); bot.JoinChannel(channel, password); }
public void Send_Should_WriteMessages_When_NameRespositoryReturnsMultipleNames() { // Arrange _mockNameRepository.Setup(x => x.Load()).Returns(new[] { "Bob", "Sally" }); _mockWriter.Setup(x => x.WriteLine("Hello Bob")); _mockWriter.Setup(x => x.WriteLine("Hello Sally")); // Act var sender = new MessageSender(_mockNameRepository.Object, _mockWriter.Object); sender.Send("Hello {0}"); // Assert _mockNameRepository.VerifyAll(); _mockWriter.VerifyAll(); }
public Bus() { connectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString"); namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString); // Configure Topic Settings var td = new TopicDescription(topicName); td.MaxSizeInMegabytes = 5120; td.DefaultMessageTimeToLive = new TimeSpan(0, 1, 0); if (!namespaceManager.TopicExists(topicName)) { namespaceManager.CreateTopic(topicName); } factory = MessagingFactory.CreateFromConnectionString(connectionString); sender = factory.CreateMessageSender(topicName); }
//[Test] not hangs the unit tests due to threads //note the ability for this to function internally depends on what type of connection is created public void RoundTrip() { var transmitter = new MessageSender(m_Context); var receiver = new MessageReceiver(m_Context); receiver.CreateReceiveSocket(); string message = "Hello world"; //transmitter.Connect(); transmitter.Send(message); string recieved = receiver.Receive(); Assert.AreEqual(message, recieved); receiver.Dispose(); transmitter.Dispose(); }
private void DiscardMessageSender() { var messageSender = _messageSender; _messageSender = null; if (messageSender == null) return; if (messageSender.IsClosed) return; try { messageSender.Close(); } catch (Exception exc) { _logger.Error(exc, "Failed to close MessageSender instance before discarding it."); } }
public void Handle(MessageSender sender, Message message) { if (message.Text.IndexOf("youtube") == -1) return; var clipId = GetClipId(message.Text); if (clipId == null) return; var url = String.Format("https://www.youtube.com/watch?v={0}", clipId); var content = GetPageContents(url); if (content == null) return; var title = GetTitle(content); if (title == null) return; sender.SendMessage(message.ChatName, title); }
public void Execute(MessageSender source, IrcMessage message, CommandParameters parameters) { var users = bot.GetAuthenticatedUsers(); if (users.Count == 0) { bot.SayTo(source.Channel, "No authenticated users"); return; } bot.SayTo(source.Channel, "Authenticated users:"); bot.SayTo(source.Channel, "----"); foreach (var user in users.GetLoggedInUsers()) { var userInformationMessage = string.Format("{0}({1}) - {2}", user.Name, user.HostMask, user.SecurityLevelInformation.SecurityLevelDescription); bot.SayTo(source.Channel, userInformationMessage); } }
public void Execute(MessageSender executor, IrcMessage message, CommandParameters parameters) { if (parameters.Count != 2) { bot.SayTo(executor.Channel, "You must give username and password when authenticating"); return; } var users = bot.GetAuthenticatedUsers(); // First we check that the user who tries to log in isn't already logged in if (users.IsLoggedInHostMask(message.Sender.HostMask)) { bot.SayTo(executor.Channel, "You have already authenticated"); return; } // Lets continue by checking the login-information. var user = dataSource.LogInUser(parameters[0], parameters[1]); if (!user.Name.Equals("")) { // Lets check that user isn't already logged in if (users.IsLoggedInUserName(user.Name)) { var alreadyAuthenticatedMessage = string.Format("User {0} has already authenticated", user.Name); bot.SayTo(executor.Channel, alreadyAuthenticatedMessage); } else { user.HostMask = message.Sender.HostMask; user.NickName = message.Sender.Name; // We get user's permissions to different channels user.ChannelSecurityLevelCollection = dataSource.GetChannelSecurityLevelsForUser(user.Id); users.AddUser(user); bot.SayTo(executor.Channel, "Authenticated succesfully"); } } else bot.SayTo(executor.Channel, "Wrong username or password"); }
public void Execute(MessageSender executor, IrcMessage message, CommandParameters parameters) { if (parameters.Count == 0) { bot.SayTo(executor.Channel, "Usage: help commandname"); return; } var commands = bot.GetAllCommands(); foreach (var command in commands) { if (command.GetKeyWord() != parameters[0]) continue; var help = command.GetHelp(); this.ShowHelpTo(help, executor.Channel); return; } var unknownCommandMessage = string.Format("Unknown command {0}", parameters[0]); bot.SayTo(executor.Channel, unknownCommandMessage); }
async Task SendMessagesAsync(MessageSender sender) { dynamic data = new[] { new {name = "Einstein", firstName = "Albert"}, new {name = "Heisenberg", firstName = "Werner"}, new {name = "Curie", firstName = "Marie"}, new {name = "Hawking", firstName = "Steven"}, new {name = "Newton", firstName = "Isaac"}, new {name = "Bohr", firstName = "Niels"}, new {name = "Faraday", firstName = "Michael"}, new {name = "Galilei", firstName = "Galileo"}, new {name = "Kepler", firstName = "Johannes"}, new {name = "Kopernikus", firstName = "Nikolaus"} }; for (int i = 0; i < data.Length; i++) { var message = new BrokeredMessage(new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(data[i])))) { ContentType = "application/json", Label = i % 2 == 0 ? "Scientist" : "Physicist", MessageId = i.ToString(), TimeToLive = TimeSpan.FromSeconds(15) }; await sender.SendAsync(message); lock (Console.Out) { Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("Message sent: Id = {0}", message.MessageId); Console.ResetColor(); } } await Task.Delay(15); // let all messages expire }
public async Task Capture_Transaction_When_Receive_From_Queue() { await using var scope = await QueueScope.CreateWithQueue(_adminClient); var sender = new MessageSender(_environment.ServiceBusConnectionString, scope.QueueName); var receiver = new MessageReceiver(_environment.ServiceBusConnectionString, scope.QueueName, ReceiveMode.PeekLock); await sender.SendAsync( new Message(Encoding.UTF8.GetBytes("test message"))).ConfigureAwait(false); await receiver.ReceiveAsync(TimeSpan.FromSeconds(30)).ConfigureAwait(false); if (!_sender.WaitForTransactions(TimeSpan.FromMinutes(2))) { throw new Exception("No transaction received in timeout"); } _sender.Transactions.Should().HaveCount(1); var transaction = _sender.FirstTransaction; transaction.Name.Should().Be($"{ServiceBus.SegmentName} RECEIVE from {scope.QueueName}"); transaction.Type.Should().Be(ApiConstants.TypeMessaging); }
/// <param name="ChannelID">The numeric ID of the Discord Channel from which commands will be accepted and processed</param> /// <param name="CommandExecuter">The Discord.Net library service that handles command processing</param> /// <param name="Client">Discord.Net library object required for interacting with <paramref name="CommandExecuter"/></param> /// <param name="CommandPrefix">The string prefix that all commands issued to this Channel must begin with to be treated as commands</param> /// <param name="MessageSender">Object shared with <see cref="DiscordInterfacerMain"/> for sending messages to Discord Text Channels</param> public CommandChannel( ulong ChannelID, CommandService CommandExecuter, DiscordSocketClient Client, string CommandPrefix, MessageSender MessageSender ) { if (CommandExecuter is null) { throw new ArgumentNullException(nameof(CommandExecuter)); } if (Client is null) { throw new ArgumentNullException(nameof(Client)); } //this.GuildID=GuildID; this.ChannelID = ChannelID; this.CommandExecuter = CommandExecuter; this.Client = Client; this.CommandPrefix = CommandPrefix ?? string.Empty; this.MessageSender = MessageSender; }
public void RemoveMember(string groupName, string username) { if (Groups.TryGetValue(groupName, out var existingVal) && existingVal.Owner == SettingsSystem.CurrentSettings.PlayerName) { //TODO: remove this clone and do as with flags to avoid garbage var expectedGroup = existingVal.Clone(); var newMembers = new List <string>(expectedGroup.Members.Except(new[] { username })) { username }; expectedGroup.Members = newMembers.ToArray(); var newInvited = new List <string>(expectedGroup.Invited.Except(new[] { username })); expectedGroup.Invited = newInvited.ToArray(); var msgData = NetworkMain.CliMsgFactory.CreateNewMessageData <GroupUpdateMsgData>(); msgData.Group = expectedGroup; MessageSender.SendMessage(msgData); } }
public void Run(long time, long tries) { MessageSender.CacheAssemblieMessages(typeof(MessA).Assembly); MessA messa = new MessA(); ScriptMethod del = new ScriptMethod("Method2"); del.TrackInstance(messa); long dC = 0, mC = 0, sM = 0; for (int i = 0; i < tries; i++) { dC += Take_Time(time, (num, m) => m.Method2()); mC += Take_Time(time, (num, m) => MessageSender.SendMessage(m, "Method2", null, MessageOptions.DontRequireReceiver)); sM += Take_Time(time, (num, m) => del.Method.Invoke()); } Console.WriteLine("Direct_Call mean: " + ((decimal)dC / (decimal)tries)); Console.WriteLine("Message_Call mean: " + ((decimal)mC / (decimal)tries)); Console.WriteLine("ScripMethod_Call mean: " + ((decimal)sM / (decimal)tries)); Console.WriteLine("The ratio of calls is: " + ((decimal)mC / (decimal)dC)); }
/// <summary> /// Saves or updates the parameter T with the givenn values. /// </summary> protected override void OnSave() { EditObject.Consumidor = txtConsumidor.Text; EditObject.Descripcion = txtDescripcion.Text; EditObject.DispositivoTipo = DAOFactory.TipoDispositivoDAO.FindById(ddlTipoDispositivo.Selected); EditObject.Editable = chbEditable.Checked; EditObject.Nombre = txtNombre.Text; EditObject.TipoDato = txtTipoDato.Text; EditObject.ValorInicial = txtValorInicial.Text; EditObject.RequiereReset = chkReset.Checked; var reset = !EditMode && EditObject.RequiereReset; DAOFactory.TipoParametroDispositivoDAO.SaveOrUpdate(EditObject); if (reset) { var devices = DAOFactory.DispositivoDAO.GetByTipo(EditObject.DispositivoTipo); foreach (var dispositivo in devices) { MessageSender.CreateReboot(dispositivo, null).Send(); } } }
public void MessageDurabilityTest() { // timers double seconds = 3; double waitTime = TimeSpan.FromSeconds(seconds).TotalMilliseconds; // sent MessageSender sender = new MessageSender(GggUtilities.QueueDurable, null, autoDelete: false, exclusive: false, isDurable: true, routingKey: GggUtilities.QueueDurable); sender.SendMulti(10); // wait GggUtilities.WriteLog(this, "Waiting {0} seconds before receiver.".Replace("{0}", seconds.ToString())); System.Threading.Thread.Sleep((int)waitTime); // receiver MessageReceiver receiver = new MessageReceiver("receiver1", GggUtilities.QueueDurable, null, autoDelete: false, exclusive: false, isDurable: true); receiver.Receive(); // wait GggUtilities.WriteLog(this, "Waiting {0} seconds for thread to finish.".Replace("{0}", seconds.ToString())); System.Threading.Thread.Sleep((int)waitTime); GggUtilities.ShowLog(); }
public ProcessResult <string> SendManyToManyMessageTest() { ApiUser apiUser = new ApiUser("test", "test"); MessageSender smsSender = new MessageSender(); List <PhoneAndMessagePair> phonesAndMessages = new List <PhoneAndMessagePair>() { new PhoneAndMessagePair("0555 555 5555", "TEST 1"), new PhoneAndMessagePair("0555 555 5555", "TEST 2"), new PhoneAndMessagePair("0555 555 5555", "TEST 3") }; ManyToManyMessage message = new ManyToManyMessage().Builder .SetHeader("BASLIK") .SetPhonesAndMessages(phonesAndMessages) .SetValidity(2880) //.SetSendDateTime("22.9.2018 13:00") .Build(); ProcessResult <string> response = smsSender.SendMessage(apiUser, message); return(response); }
///<summary> /// Called when the client successfully connects Network Behaviours. Involves switching pending Network Behaviours to active and sending the server a success message. /// Client only. ///</summary> private void OnObjectConnectSuccess(NetworkBehaviourReference behaviourReference, ulong networkID, ulong ownerID, bool ownerCanUnspawn, bool destroyOnUnspawn, Stream spawnPayload) { m_NetworkBehaviours.Add(behaviourReference); m_NetworkBehaviourDictionary.Add(networkID, behaviourReference); //Send confirm connection using (PooledBitStream stream = PooledBitStream.Get()) { using (PooledBitWriter writer = PooledBitWriter.Get(stream)) { writer.WriteUInt64Packed(networkID); if (networkManager.enableLogging) { Debug.Log("Sending success of add object with Network ID: " + networkID); } } MessageSender.Send(networkManager.serverID, objectSuccessMessageType, networkManager.networkInternalChannel, stream); } //Let our local behaviour know behaviourReference.connectedClientCallback.Invoke(networkID, ownerID, ownerCanUnspawn, destroyOnUnspawn, spawnPayload); }
/// <summary> /// Send specified location to user that requested the action /// </summary> /// <param name="sender"></param> /// <param name="latitude">latitude positon of location</param> /// <param name="longitude">longitude position of location</param> /// <returns>Sent message</returns> public Message SendLocation(MessageSender sender, string latitude, string longitude) { if (sender == null) { throw new ArgumentNullException(nameof(sender)); } var request = Utils.GenerateRestRequest(Resources.Method_SendLocation, Method.POST, new Dictionary <string, string> { { Resources.HttpContentType, Resources.HttpMultiPartFormData } } , new Dictionary <string, object> { { Resources.Param_ChatId, sender.Id }, { Resources.Param_Latitude, latitude }, { Resources.Param_Longitude, longitude } }); return(_botClient.Execute <Message>(request).Data); }
static void Main(string[] args) { var sender = new MessageSender(Environment.GetEnvironmentVariable("QueueConnectionString"), Environment.GetEnvironmentVariable("QueueName")); var rnd = new Random(); while (true) { byte[] bufffer = new byte[100]; rnd.NextBytes(bufffer); var msgId = Guid.NewGuid().ToString(); Console.WriteLine($"Sending message with id {msgId}"); var message = new Message(bufffer) { ContentType = "application/json", Label = "Scientist", MessageId = Guid.NewGuid().ToString(), }; sender.SendAsync(message).GetAwaiter().GetResult(); Console.WriteLine($"Sent. Kill the program before it sends another."); } }
private static async Task SendToOrderTopic() { var orderTopicSender = new MessageSender(SBConnectionString, OrderTopic.TopicName); // 1. Text var txtMsg = $"Azure Riyadh Meetup :: Test Message #{DateTime.Now.Ticks}"; //txtMsg = new StringBuilder().Append('M', 1500000).ToString(); await Send(orderTopicSender, txtMsg); // 2. Serialize Object dynamic address = new { Country = "SA", City = "Riyadh", Street = "Olaya St" }; await Send(orderTopicSender, Json.SerializeD(address)); // 3. Image //await SendBlob(q1Sender, Blob01); // 4. Object await SendAttendee(orderTopicSender); await orderTopicSender.CloseAsync(); }
private static void GetLocationContactFromMessage(Message message, MessageSender sender) { if (message.Location != null) { Console.WriteLine($"Location :({message.Location.Latitude},{message.Location.Longitude})"); Bot.SendMessage(new SendMessageParams { ChatId = sender.Id.ToString(), Text = $"You Send location", ReplyToMessage = message }); } else if (message.Contact != null) { Console.WriteLine($"Contact :({message.Contact.FirstName},{message.Contact.LastName},{message.Contact.PhoneNumber})"); Bot.SendMessage(new SendMessageParams { ChatId = sender.Id.ToString(), Text = $"You Send Contact", ReplyToMessage = message }); } }
public async Task SendMessages() { messageSender = factory.CreateMessageSender(queuename); stopwatch.Start(); for (int i = 0; i < numberOfMessages; i++) { string message = _loader.GetClaim(); await messageSender.SendAsync(new BrokeredMessage(message)); } stopwatch.Stop(); var elapsedMilliseconds = stopwatch.ElapsedMilliseconds; Console.WriteLine("Sent {0} messages in {1} ms", numberOfMessages, elapsedMilliseconds); Console.WriteLine("{0} per second", elapsedMilliseconds == 0 ? 0L : (1000 * numberOfMessages) / elapsedMilliseconds); Console.WriteLine("Sleeping for 10 seconds before receiving..."); Thread.Sleep(20000); }
public async Task ClientThrowsUnauthorizedExceptionWhenUserDoesntHaveAccess() { var csb = new ServiceBusConnectionStringBuilder(TestUtility.NamespaceConnectionString); csb.SasKeyName = "nonExistingKey"; csb.EntityPath = TestConstants.NonPartitionedQueueName; var sender = new MessageSender(csb); try { await Assert.ThrowsAsync <UnauthorizedException>( async() => await sender.SendAsync(new Message())); long nonExistingSequenceNumber = 1000; await Assert.ThrowsAsync <UnauthorizedException>( async() => await sender.CancelScheduledMessageAsync(nonExistingSequenceNumber)); } finally { await sender.CloseAsync().ConfigureAwait(false); } }
async Task TryCreateRequestSenderAsync() { try { await _requestSenderCreateLock.WaitAsync(); if (_requestSender != null) { return; } await CreateNewCompleteQueueAsync(); var sender = new MessageSender(_serviceBusConnectionString, _scrapeQueueName); var receiver = new MessageReceiver(_serviceBusConnectionString, _completeQueueName); _requestSender = new RequestReplySender(sender, receiver); } finally { _requestSenderCreateLock.Release(); } }
public async Task <ServiceBusEntity> ConvertAsync(string input, CancellationToken cancellationToken) { string queueOrTopicName; // For convenience, treat an an empty string as a request for the default value. if (String.IsNullOrEmpty(input) && _defaultPath.IsBound) { queueOrTopicName = _defaultPath.Bind(null); } else { queueOrTopicName = input; } cancellationToken.ThrowIfCancellationRequested(); MessageSender messageSender = await _account.MessagingFactory.CreateMessageSenderAsync(queueOrTopicName); return(new ServiceBusEntity { Account = _account, MessageSender = messageSender }); }
async Task Plugin_with_ShouldContinueOnException_should_continue() { var messageSender = new MessageSender(TestUtility.NamespaceConnectionString, TestConstants.NonPartitionedQueueName); try { var plugin = new ShouldCompleteAnywayExceptionPlugin(); messageSender.RegisterPlugin(plugin); var sendMessage = new Message(Encoding.UTF8.GetBytes("Test message")); await messageSender.SendAsync(sendMessage); } finally { await messageSender.CloseAsync(); var messageReceiver = new MessageReceiver(TestUtility.NamespaceConnectionString, TestConstants.NonPartitionedQueueName, ReceiveMode.ReceiveAndDelete); await messageReceiver.ReceiveAsync(); await messageReceiver.CloseAsync(); } }
public void SendMessages(List <BusMessage> appMessages) { Task[] arrayTaskMessages = new Task[appMessages.Count]; Action <object> delegeteSendMessage = (messageInformation) => { IMessageSender messageSender; BusMessage messageInfo = (BusMessage)messageInformation; messageSender = new MessageSender(appOptions.BusConnectionString, messageInfo.TopicName); var messagesToSend = new List <Message>(); var message = new Message(messageInfo.MessageBody); message.SessionId = messageInfo.TokenID; message.UserProperties.Add(appOptions.RuleName, messageInfo.SubscriptionName); messagesToSend.Add(message); messageSender.SendAsync(messagesToSend).GetAwaiter().GetResult(); messageSender.CloseAsync().GetAwaiter().GetResult(); }; for (int i = 0; i < arrayTaskMessages.Length; i++) { arrayTaskMessages[i] = Task.Factory.StartNew(delegeteSendMessage, appMessages[i]); } Task.WaitAll(arrayTaskMessages); }
public async Task <ISendEndpoint> GetSendEndpoint(Uri address) { IServiceBusHost host = _hosts.FirstOrDefault(x => x.Settings.ServiceUri.Host.Equals(address.Host, StringComparison.OrdinalIgnoreCase)); if (host == null) { throw new EndpointNotFoundException("The endpoint address specified an unknown host: " + address); } TopicDescription topicDescription = await(await host.RootNamespaceManager.ConfigureAwait(false)).CreateTopicSafeAsync(address.GetTopicDescription()).ConfigureAwait(false); MessagingFactory messagingFactory = await host.MessagingFactory.ConfigureAwait(false); MessageSender messageSender = await messagingFactory.CreateMessageSenderAsync(topicDescription.Path).ConfigureAwait(false); var sendTransport = new ServiceBusSendTransport(messageSender); sendTransport.ConnectSendObserver(_sendObservable); return(new SendEndpoint(sendTransport, _serializer, address, _sourceAddress)); }
public async Task <IActionResult> Post(BillCreationInputModel model) { var now = DateTime.Now; var expires = now.AddMilliseconds(Configuration.GetValue <int>("TransactionTimeout")); var id = Generator.Generate(); var result = await DbContext.Database.GetDbConnection() .QueryFirstOrDefaultAsync <BillCreatingResult>(@"select create_bill(@id, @uid, @amount, @tid, @now, @expires);", new { id, uid = model.UserId, amount = model.Amount, tid = model.TransactionId, now, expires }); if (result == BillCreatingResult.Ok) { var uri = $"{Request.Scheme}://{Request.Host}/transactions/{model.TransactionId}"; await MessageSender.SendAsync(new CancellationItem { Uri = uri }); Logger.LogInformation("账单创建成功: {id}, {uri}", model.TransactionId, uri); return(Created(uri, new TransactionObjectCreatedOutputModel <long>(model.TransactionId, uri, expires))); } if (result == BillCreatingResult.InsufficientBalance) { return(BadRequest(new ApiErrorResult <ApiError>(new ApiError("InsufficientBalance", "InsufficientBalance")))); } throw new NotImplementedException(); }
private async Task PerformSendAndReceiveOperation(string topicName, string subscriptionName, ServiceBusConnectionStringBuilder csBuilder) { var connection = new ServiceBusConnection(csBuilder); var sender = new MessageSender(connection, topicName); var receiver = new MessageReceiver(connection, EntityNameHelper.FormatSubscriptionPath(topicName, subscriptionName)); try { await sender.SendAsync(new Message() { MessageId = "1" }); Console.WriteLine("Sent message successfully"); } catch (UnauthorizedException) { Console.WriteLine($"Could not send message due to authorization failure"); } try { var msg = await receiver.ReceiveAsync(); Console.WriteLine("Received message successfully"); } catch (UnauthorizedException) { Console.WriteLine($"Could not receive message due to authorization failure"); } await sender.CloseAsync(); await receiver.CloseAsync(); await connection.CloseAsync(); }
private bool Validatation() { // validate empty path if (string.IsNullOrEmpty(targetVideoPathTextBox.Text)) { MessageSender.ErrorMessage("Provide target video path"); return(false); } if (string.IsNullOrEmpty(reactionVideoPathTextBox.Text)) { MessageSender.ErrorMessage("Provide reaction video path"); return(false); } // validate expected result input var lastRow = videoIntervalGrid.Rows[videoIntervalGrid.Rows.Count - 1]; var inputFile = new MediaFile { Filename = targetVideoPathTextBox.Text }; using (var engine = new Engine()) { engine.GetMetadata(inputFile); } var totalSec = inputFile.Metadata.Duration.TotalSeconds; if (string.IsNullOrEmpty(lastRow.Cells[1].Value.ToString())) { lastRow.Cells[1].Value = totalSec; } return(true); }
public void Connect() { Disconnect(); _log.DebugFormat("Connecting '{0}'", _endpointAddress); if (_messagingFactory == null) { _messagingFactory = _endpointAddress.MessagingFactoryFactory(); } // check if it's a queue or a subscription to subscribe either the queue or the subscription? if (_endpointAddress.QueueDescription != null) { _messageSender = _endpointAddress.CreateQueue() .ContinueWith(t => { t.Wait(); return (_messagingFactory.TryCreateMessageSender( _endpointAddress.QueueDescription, _prefetchCount) .Result); }) .Result; } else { _messageSender = _messagingFactory.TryCreateMessageSender(_endpointAddress.TopicDescription) .Result; } if (_messageSender == null) { throw new TransportException(_endpointAddress.Uri, "The create message sender on messaging factory returned null."); } }
public async Task ClientsUseGlobalConnectionCloseFirstClientSecoundClientShouldSendMessage() { var csb = new ServiceBusConnectionStringBuilder(TestUtility.NamespaceConnectionString); var connection = new ServiceBusConnection(csb); var sender = new MessageSender(connection, TestConstants.PartitionedQueueName); var receiver = new MessageReceiver(TestUtility.NamespaceConnectionString, TestConstants.PartitionedQueueName, receiveMode: ReceiveMode.ReceiveAndDelete); try { var messageBody = Encoding.UTF8.GetBytes("Message"); var message = new Message(messageBody); await sender.SendAsync(message); await sender.CloseAsync(); var recivedMessage = await receiver.ReceiveAsync().ConfigureAwait(false); Assert.True(Encoding.UTF8.GetString(recivedMessage.Body) == Encoding.UTF8.GetString(messageBody)); connection = sender.ServiceBusConnection; sender = new MessageSender(connection, TestConstants.PartitionedQueueName); messageBody = Encoding.UTF8.GetBytes("Message 2"); message = new Message(messageBody); await sender.SendAsync(message); recivedMessage = await receiver.ReceiveAsync().ConfigureAwait(false); Assert.True(Encoding.UTF8.GetString(recivedMessage.Body) == Encoding.UTF8.GetString(messageBody)); } finally { await sender.CloseAsync().ConfigureAwait(false); await receiver.CloseAsync().ConfigureAwait(false); } }
public async Task Capture_Transaction_When_ReceiveDeferred_From_Queue() { await using var scope = await QueueScope.CreateWithQueue(_adminClient); var sender = new MessageSender(_environment.ServiceBusConnectionString, scope.QueueName); var receiver = new MessageReceiver(_environment.ServiceBusConnectionString, scope.QueueName, ReceiveMode.PeekLock); await sender.SendAsync( new Message(Encoding.UTF8.GetBytes("test message"))).ConfigureAwait(false); var message = await receiver.ReceiveAsync(TimeSpan.FromSeconds(30)).ConfigureAwait(false); await receiver.DeferAsync(message.SystemProperties.LockToken).ConfigureAwait(false); await receiver.ReceiveDeferredMessageAsync(message.SystemProperties.SequenceNumber).ConfigureAwait(false); if (!_sender.WaitForTransactions(TimeSpan.FromMinutes(2), count: 2)) { throw new Exception("No transaction received in timeout"); } _sender.Transactions.Should().HaveCount(2); var transaction = _sender.FirstTransaction; transaction.Name.Should().Be($"{ServiceBus.SegmentName} RECEIVE from {scope.QueueName}"); transaction.Type.Should().Be(ApiConstants.TypeMessaging); transaction.Context.Message.Should().NotBeNull(); transaction.Context.Message.Queue.Should().NotBeNull(); transaction.Context.Message.Queue.Name.Should().Be(scope.QueueName); var secondTransaction = _sender.Transactions[1]; secondTransaction.Name.Should().Be($"{ServiceBus.SegmentName} RECEIVEDEFERRED from {scope.QueueName}"); secondTransaction.Type.Should().Be(ApiConstants.TypeMessaging); }
static async Task SendMessagesAsync() { var sender = new MessageSender(ServiceBusConnectionString, QueueName); dynamic data = new[] { new { name = "Einstein", firstName = "Albert" }, new { name = "Heisenberg", firstName = "Werner" }, new { name = "Curie", firstName = "Marie" }, new { name = "Hawking", firstName = "Steven" }, new { name = "Newton", firstName = "Isaac" }, new { name = "Bohr", firstName = "Niels" }, new { name = "Faraday", firstName = "Michael" }, new { name = "Galilei", firstName = "Galileo" }, new { name = "Kepler", firstName = "Johannes" }, new { name = "Kopernikus", firstName = "Nikolaus" } }; for (int i = 0; i < data.Length; i++) { var message = new Message(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(data[i]))) { ContentType = "application/json", Label = "Scientist", MessageId = i.ToString(), //TimeToLive = TimeSpan.FromMinutes(2) UserProperties = { { "Priority", i + 1 }, { "Importance", "High" } } }; await sender.SendAsync(message); } }
/// <summary> /// Sends a set of brokered messages (for batch processing). /// If the batch size is greater than the maximum batch size, /// the method partitions the original batch into multiple batches, /// each smaller in size than the maximum batch size. /// </summary> /// <param name="messageSender">The current MessageSender object.</param> /// <param name="brokeredMessageEnumerable">The collection of brokered messages to send.</param> /// <param name="trace">true to cause a message to be written; otherwise, false.</param> public static void SendPartitionedBatch(this MessageSender messageSender, IEnumerable <BrokeredMessage> brokeredMessageEnumerable, bool trace = false) { var brokeredMessageList = brokeredMessageEnumerable as IList <BrokeredMessage> ?? brokeredMessageEnumerable.ToList(); if (brokeredMessageEnumerable == null || !brokeredMessageList.Any()) { throw new ArgumentNullException(BrokeredMessageListCannotBeNullOrEmpty); } var batchList = new List <BrokeredMessage>(); long batchSize = 0; foreach (var brokeredMessage in brokeredMessageList) { if ((batchSize + brokeredMessage.Size) > Constants.MaxBathSizeInBytes) { // Send current batch messageSender.SendBatch(batchList); Trace.WriteLineIf(trace, string.Format(SendPartitionedBatchFormat, batchSize, batchList.Count)); // Initialize a new batch batchList = new List <BrokeredMessage> { brokeredMessage }; batchSize = brokeredMessage.Size; } else { // Add the BrokeredMessage to the current batch batchList.Add(brokeredMessage); batchSize += brokeredMessage.Size; } } // The final batch is sent outside of the loop messageSender.SendBatch(batchList); Trace.WriteLineIf(trace, string.Format(SendPartitionedBatchFormat, batchSize, batchList.Count)); }
public GIVEN_store_and_event_bus_with_a_Saga_in_memory() { DbConfiguration.SetConfiguration(new TransientFaultHandlingDbConfiguration()); this.serializer = CreateSerializer(); this.dbName = typeof(EventStoreFixture).Name; var connectionFactory = System.Data.Entity.Database.DefaultConnectionFactory; this.commandSender = new MessageSender(connectionFactory, this.dbName, "Bus.Commands"); this.eventSender = new MessageSender(connectionFactory, this.dbName, "Bus.Events"); this.connectionString = connectionFactory.CreateConnection(this.dbName).ConnectionString; /** FECOPROD **/ this.connectionString = string.Format("server=(local);Database={0};User Id=sa;pwd =123456", dbName); using (var context = new EventStoreDbContext(this.connectionString)) { if (context.Database.Exists()) { context.Database.Delete(); } context.Database.Create(); } MessagingDbInitializer.CreateDatabaseObjects(this.connectionString, "Bus"); this.eventBus = new EventBus(this.eventSender, this.serializer); this.commandBus = new CommandBus(this.commandSender, this.serializer, new LocalDateTime()); this.sut = new EventStore <FakeItemsSaga>(this.eventBus, this.commandBus, this.serializer, () => (new EventStoreDbContext(this.connectionString)), new ConsoleTracer(), new LocalDateTime(), new InMemorySnapshotProvider("Test", new LocalDateTime()), new StandardMetadataProvider()); }
async Task SendMessagesAsync(MessageSender sender, int maxMessages) { dynamic data = new[] { new { name = "Einstein", firstName = "Albert" }, new { name = "Heisenberg", firstName = "Werner" }, new { name = "Curie", firstName = "Marie" }, new { name = "Hawking", firstName = "Steven" }, new { name = "Newton", firstName = "Isaac" }, new { name = "Bohr", firstName = "Niels" }, new { name = "Faraday", firstName = "Michael" }, new { name = "Galilei", firstName = "Galileo" }, new { name = "Kepler", firstName = "Johannes" }, new { name = "Kopernikus", firstName = "Nikolaus" } }; for (int i = 0; i < Math.Min(data.Length, maxMessages); i++) { var message = new BrokeredMessage(new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(data[i])))) { ContentType = "application/json", Label = i % 2 == 0 ? "Scientist" : "Physicist", MessageId = i.ToString(), TimeToLive = TimeSpan.FromMinutes(2) }; await sender.SendAsync(message); lock (Console.Out) { Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("Message sent: Id = {0}", message.MessageId); Console.ResetColor(); } } }
public async Task MessageLockLostExceptionTest() { await ServiceBusScope.UsingQueueAsync(partitioned : false, sessionEnabled : false, async queueName => { const int messageCount = 2; var sender = new MessageSender(TestUtility.NamespaceConnectionString, queueName); var receiver = new MessageReceiver(TestUtility.NamespaceConnectionString, queueName, receiveMode: ReceiveMode.PeekLock); try { await TestUtility.SendMessagesAsync(sender, messageCount); var receivedMessages = await TestUtility.ReceiveMessagesAsync(receiver, messageCount); Assert.True(receivedMessages.Count == messageCount); // Let the messages expire await Task.Delay(TimeSpan.FromMinutes(1)); // Complete should throw await Assert.ThrowsAsync <MessageLockLostException>( async() => await TestUtility.CompleteMessagesAsync(receiver, receivedMessages)); receivedMessages = await TestUtility.ReceiveMessagesAsync(receiver, messageCount); Assert.True(receivedMessages.Count == messageCount); await TestUtility.CompleteMessagesAsync(receiver, receivedMessages); } finally { await sender.CloseAsync(); await receiver.CloseAsync(); } }); }
public void DisposesCleanly() { var transmitter = new MessageSender(m_Context); transmitter.Dispose(); }