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();
}
