void PersistMessage(MessagePayload toInput)
{
Logger.Debug("Caching message payload {0}", toInput.Id);
toInput.SetPersistenceId(messageCache.Address, messageCache.UseType);
messageCache.AddMessageAndIncrementSequence(toInput);
}
public void ReceiveAcknowledgementFor(MessagePayload messagePayload)
{
ReceiveMessage(
new MessagePayload()
.AsAcknowlegement(messagePayload.GetPersistenceId())
.SetToChannel(messagePayload.GetFromAddress().Channel));
}
void PerformLogging(MessagePayload toInput)
{
Logger.Debug(
"Attaching session {0} for message: {0}",
cache.GetCurrentSessionFor(GetServer()).Id,
toInput.Id);
}
public void HandleMessage(MessagePayload toHandle, List<MessagePayload> outgoingMessages)
{
if (!toHandle.IsLongPollRequest())
return;
outgoingMessages.AddRange(outgoingQueue.DequeueAll(toHandle.GetLongPollRequestServerPath()));
}
public override void InputMessage(MessagePayload toInput)
{
if (messageCache.ResetOn < toInput.GetSequenceOriginSetOn())
messageCache.Reset(toInput.GetFirstSequence(), toInput.GetSequenceOriginSetOn());
OnMessageProcessed(toInput);
}
public override void InputMessage(MessagePayload toInput)
{
Logger.Debug("Recording the last time sent on message payload {0}", toInput.Id);
SetTimeOnMessage(toInput);
OnMessageProcessed(toInput);
}
static void LogWithAddress(MessagePayload toHandle)
{
Logger.Debug("Handling sent message {0} for {1} from {2}",
toHandle.Id,
toHandle.GetToAddress().Channel,
toHandle.GetToAddress().Server.Address);
}
public override void InputMessage(MessagePayload toInput)
{
Logger.Debug("Recording message persistence source on payload {0}", toInput.Id);
toInput.SetSourcePersistenceId(toInput.GetPersistenceId());
OnMessageProcessed(toInput);
}
void CacheMessage(MessagePayload toInput)
{
if(messageCache.ContainsMessage(toInput))
messageCache.UpdateMessage(toInput);
else
messageCache.AddMessage(toInput);
}
public void Should_support_delivery()
{
Vane<Message> vane = VaneFactory.New<Message>(x =>
{
x.Consumer(() => new TestConsumer(), xc =>
{
xc.Consume<A>(c => c.Consume);
xc.Consume<B>(c => c.Consume);
});
});
var a = new A {Value = "Hello"};
Payload<Message> payload = new MessagePayload<A>(a);
vane.Execute(payload, CancellationToken.None);
var b = new B {Value = "World"};
payload = new MessagePayload<B>(b);
vane.Execute(payload, CancellationToken.None);
var visitor = new StringVaneVisitor();
visitor.Visit(vane);
Console.WriteLine(visitor.ToString());
}
MessagePayload CreateLongPollPayload(MessageServer toListenFor)
{
var payload = new MessagePayload();
payload.SetLongPollRequest(toListenFor);
return payload;
}
public override void InputMessage(MessagePayload toInput)
{
if(!toInput.HasBody()) return;
if(toInput.GetToAddress() != address) return;
OnMessageProcessed(toInput);
}
public override void InputMessage(MessagePayload toInput)
{
SetCurentSenderAddress(toInput);
SetCurrentReceiverAddress(toInput);
SetCurrentCorrelationId(toInput);
OnMessageProcessed(toInput);
}
int GetDelay(MessagePayload toGetDelayFor)
{
int unlimitedDelay = GetUnlimitedDelay(toGetDelayFor);
return unlimitedDelay < Peak
? unlimitedDelay
: Peak;
}
public override void InputMessage(MessagePayload toInput)
{
Logger.Debug("Recording message sequence origin on payload {0}", toInput.Id);
toInput.SetFirstSequence(messageCache.GetFirstSequenceInCache());
toInput.SetSequenceOriginSetOn(messageCache.FirstItemCachedOn);
OnMessageProcessed(toInput);
}
public override void InputMessage(MessagePayload toInput)
{
Logger.Debug("Addressing message payload {0} to {1}", toInput.Id, DirectReplyContext.GetCurrentClientAddress());
toInput.SetFromAddress(fromAddress);
toInput.SetToAddress(DirectReplyContext.GetCurrentClientAddress());
OnMessageProcessed(toInput);
}
protected static void LogMessage(MessagePayload toInput)
{
Logger.Debug(
"Repeating message: {0} on {1} with sequence {2}",
toInput.Id,
toInput.HasHeader<FromAddressHeader>() ? toInput.GetFromAddress().Channel : "n/a",
toInput.HasSequence() ? toInput.GetSequence().ToString() : "n/a");
}
public void Enqueue(MessagePayload toEnqueue)
{
Contract.Requires(toEnqueue != null);
CreateQueueIfNonExistant(toEnqueue.GetToAddress().Server);
queues[toEnqueue.GetToAddress().Server].Enqueue(toEnqueue);
}
public override void InputMessage(MessagePayload toInput)
{
Logger.Debug("Addressing message payload {0} to {1}", toInput.Id, toAddress);
toInput.SetFromAddress(fromAddress);
toInput.SetToAddress(toAddress);
OnMessageProcessed(toInput);
}
void NotifyMessageLoadedToCache(MessagePayload m)
{
Messenger.Send(new MessageLoadedToCache
{
CacheAddress = Address,
UseType = UseType,
Message = m
});
}
public void Should_properly_generate_the_output_types()
{
var a = new A {Value = "Hello"};
Payload<Message<A>> payload = new MessagePayload<A>(a);
_vane.Execute(payload);
Assert.IsTrue(WorkingConsumer.Called, "Was not called");
}
public void HandleMessage(MessagePayload toHandle, List<MessagePayload> outgoingMessages)
{
if (toHandle.IsLongPollRequest())
return;
LogMessage(toHandle);
this.outgoingQueue.Enqueue(toHandle);
}
public void HandleMessage(MessagePayload toHandle, List<MessagePayload> outgoingMessages)
{
if (!toHandle.IsDirectChannelMessage()) return;
using (var context = new DirectReplyContext(toHandle.GetToAddress(), toHandle.GetFromAddress()))
{
messageReceiver.InputMessage(toHandle);
outgoingMessages.AddRange(context.GetCurrentReplies());
}
}
public override void InputMessage(MessagePayload toInput)
{
if (ServerRequiresAuthentication())
{
if (!IsCurrentSessionAvailable()) return;
SetCurrentAuthenticationSessionOnPayload(toInput);
}
OnMessageProcessed(toInput);
}
private void OnTriggerEnter2D(Collider2D other)
{
MessagePayload payload = new MessagePayload()
{
powerUpObject = this.gameObject,
type = this.data.type,
id = this.GetInstanceID()
};
other.SendMessage("GrabbedPowerUp", payload, SendMessageOptions.DontRequireReceiver);
}
private static void SendPM(MessagePayload message)
{
if (Properties.Settings.Default.Plugin.ToUpper() == "HIPCHAT")
{
//Hipchat.SendPM(message, Properties.Settings.Default.HipchatToken, "Clyde en Marland");
}
else if (Properties.Settings.Default.Plugin.ToUpper() == "SLACK")
{
Slack.SendPM(message, "ClydeenMarland", Properties.Settings.Default.SlackWebhook);
}
}
public async Task Throws_Exception_When_Pmode_Doesnt_Exist()
{
var payload = new MessagePayload
{
SendingPmode = "IDONTEXIST"
};
var error = await Assert.ThrowsAsync <BusinessException>(() => Setup().SubmitMessageCreator.CreateSubmitMessages(payload));
Assert.Contains("Could not find PMode", error.Message);
}
/// <summary>
/// Send message, fire and forget
/// </summary>
/// <param name="messagePayload">payload for message</param>
/// <returns></returns>
public async Task Send(MessagePayload messagePayload)
{
if (_messageSender == null || _messageSender?.IsClosedOrClosing == true)
{
return;
}
_logger.LogTrace($"Sending message: contentType={messagePayload.ContentType}, data.Length {messagePayload.Data?.Length}");
await _messageSender !.SendAsync(messagePayload.ToMessage());
}
private string GetObjectWithName(MessagePayload payload)
{
var message = JsonConvert.SerializeObject(payload);
if (Context?.User?.Identity?.Name != null)
{
return($"{Context.User.Identity.Name} said: {message}");
}
return(message);
}
static void MessageCallBack(object sender, agsXMPP.protocol.client.Message msg, object data)
{
if ((msg.Body != null) && (msg.Body.Contains(Properties.Settings.Default.AllianceGroup) ||
msg.Body.Contains(Properties.Settings.Default.CorpGroup)
||
msg.Body.Contains(Properties.Settings.Default.FCGroup)))
{
var lines = msg.Body.Split(new[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
var senderLines = lines[0].Replace("**** This was broadcast by ", "").Replace(" EVE ****", "").Replace("@everyone", "").Split(new[] { " at " }, StringSplitOptions.RemoveEmptyEntries);
var recipient = lines[lines.Length - 1].Replace("**** Message sent to the ", "").Replace(" Group ****", "");
var sendLines = new List <string>();
//sendLines.Add(string.Format("Timestamp: {0}", senderLines[1]));
sendLines.Add(string.Format("From: {0}", senderLines[0]));
sendLines.Add(string.Format("To: {0}", recipient));
for (var i = 1; i < lines.Length - 1; i++)
{
sendLines.Add(lines[i]);
}
ConsoleWriteLine(string.Format("{0}>> {1}", msg.From.User, msg.Body), ConsoleColor.Red);
var payload = new MessagePayload();
payload.Text = "@channel: Alliance Broadcast";
payload.Attachments = new List <MessagePayloadAttachment>();
//if (!msg.Body.Contains("@everyone"))
//{
// sendLines.Insert(0, "@everyone");
//}
payload.Attachments.Add(new MessagePayloadAttachment()
{
Text = new Censor().CensorText(string.Join("\n", sendLines)),
Title = string.Format("{0}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")),
Colour = "#ff0066"
});
if (msg.Body.Contains(Properties.Settings.Default.CorpGroup) || msg.Body.Contains(Properties.Settings.Default.AllianceGroup))
{
Plugin.SendToRoom(payload, Properties.Settings.Default.Room, Properties.Settings.Default.SlackWebhook, Properties.Settings.Default.BroadcastName);
if (msg.Body.Contains(Properties.Settings.Default.AllianceGroup))
{
foreach (var webhook in Properties.Settings.Default.SharedWebhooks)
{
Plugin.SendToRoom(payload, Properties.Settings.Default.Room, webhook, Properties.Settings.Default.BroadcastName);
}
}
}
else if (msg.Body.Contains(Properties.Settings.Default.FCGroup))
{
Plugin.SendToRoom(payload, Properties.Settings.Default.FCRoom, Properties.Settings.Default.SlackWebhook, Properties.Settings.Default.BroadcastName);
}
}
}
public void GivenDatetimeStringInWellKnownFormats_WhenParseInvoked_ThenReturnDatetimeWithValidOffset(
string datetime,
string text,
string separator)
{
var expectedDatetime = DateTimeOffset.UtcNow;
var result = MessagePayload.TryParse($"{text}{separator}{datetime}", out var message);
Assert.IsTrue(result);
Assert.GreaterOrEqual(message.DateTime - expectedDatetime, TimeSpan.FromSeconds(10));
}
public void GivenStringInValidFormat_WhenParseInvoked_ThenReturnMessageWithComponents(
string datetime,
string text,
char separator)
{
var result = MessagePayload.TryParse($"{text}{separator}{datetime}", out var message);
Assert.IsTrue(result);
Assert.AreEqual(DateTimeOffset.Parse(datetime), message.DateTime);
Assert.AreEqual(text, message.Text);
}
private static void SendMessage(MessagePayload message, string room)
{
if (Properties.Settings.Default.Plugin.ToUpper() == "HIPCHAT")
{
//Hipchat.SendToRoom(message, Properties.Settings.Default.RoomName, Properties.Settings.Default.HipchatToken);
}
else if (Properties.Settings.Default.Plugin.ToUpper() == "SLACK")
{
//message = Linkify(message);
Slack.SendToRoom(message, room, Properties.Settings.Default.SlackWebhook);
}
}
public static bool SendSurveyDataToSQL(MessagePayload messagePayload)
{
//Convert to FormResponseDetails
FormResponseDetail formResponseDetail = JsonConvert.DeserializeObject <FormResponseDetail>(messagePayload.Body);
PageDigest[][] pagedigest = GetPageDigest();
//Send to SQL Server
Epi.Cloud.SqlServer.PersistToSqlServer objPersistResponse = new Cloud.SqlServer.PersistToSqlServer();
objPersistResponse.PersistToSQLServerDB(formResponseDetail, pagedigest);
return(true);
}
public void MovesMessageToOutgoingHistoryAfterMaxAttempts()
{
Directory.Delete("test.esent", true);
using (var qf = new QueueStorage("test.esent", new QueueManagerConfiguration()))
{
qf.Initialize();
qf.Global(actions =>
{
actions.CreateQueueIfDoesNotExists("test");
actions.Commit();
});
var testMessage = new MessagePayload
{
Data = new byte[0],
DeliverBy = null,
Headers = new NameValueCollection(),
MaxAttempts = 1
};
Guid messageId = Guid.Empty;
qf.Global(actions =>
{
Guid transactionId = Guid.NewGuid();
messageId = actions.RegisterToSend(new Endpoint("localhost", 0),
"test",
null,
testMessage,
transactionId);
actions.MarkAsReadyToSend(transactionId);
actions.Commit();
});
qf.Send(actions =>
{
Endpoint endpoint;
var msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, out endpoint);
actions.MarkOutgoingMessageAsFailedTransmission(msgs.First().Bookmark, false);
msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, out endpoint);
Assert.Empty(msgs);
actions.Commit();
});
qf.Global(actions =>
{
PersistentMessageToSend message = actions.GetSentMessages().FirstOrDefault(x => x.Id.MessageIdentifier == messageId);
Assert.NotNull(message);
Assert.Equal(OutgoingMessageStatus.Failed, message.OutgoingStatus);
actions.Commit();
});
}
}
private static void SendLossMessage(MessagePayload message)
{
if (Properties.Settings.Default.Plugin.ToUpper() == "HIPCHAT")
{
//Hipchat.SendToRoom(message, Properties.Settings.Default.RoomName, Properties.Settings.Default.HipchatToken);
}
else if (Properties.Settings.Default.Plugin.ToUpper() == "SLACK")
{
//message = Linkify(message);
Plugin.SendToRoom(message, Properties.Settings.Default.LossRoomName, Properties.Settings.Default.SlackWebhook, Properties.Settings.Default.BotName);
}
}
public BroadcastRec()
{
m_parent = null;
m_PresenceVector = 0;
m_DestinationID = new DestinationID();
m_DestinationID.setParent(this);
m_SourceID = new SourceID();
m_SourceID.setParent(this);
m_Priority = 0;
m_MessagePayload = new MessagePayload();
m_MessagePayload.setParent(this);
}
public static void Verify(this MessagePayload subject)
{
subject.VerifyNotNull(nameof(subject));
subject.ContentType.VerifyNotEmpty(nameof(subject.ContentType));
subject.MessageId.VerifyNotNull(nameof(subject.MessageId));
subject.CorrelationId.VerifyNotNull(nameof(subject.CorrelationId));
subject.Data
.VerifyNotNull(nameof(subject.Data))
.VerifyAssert(x => x.Length > 0, "data is empty");
}
/*
*
*/
public SendRec()
{
m_PresenceVector = new BitArray(DEFAULT_BIT_ARRAY_LEN);
m_DestSubsystemID = 0;
m_DestNodeID = 0;
m_DestComponentID = 0;
m_SrcSubsystemID = 0;
m_SrcNodeID = 0;
m_SrcComponentID = 0;
m_Priority = 0;
m_MessagePayload = new MessagePayload();
}
public void MovesMessageToOutgoingHistoryAfterMaxAttempts()
{
Directory.Delete("test.esent", true);
using (var qf = new QueueStorage("test.esent", new QueueManagerConfiguration()))
{
qf.Initialize();
qf.Global(actions =>
{
actions.CreateQueueIfDoesNotExists("test");
actions.Commit();
});
var testMessage = new MessagePayload
{
Data = new byte[0],
DeliverBy = null,
Headers = new NameValueCollection(),
MaxAttempts = 1
};
Guid messageId = Guid.Empty;
qf.Global(actions =>
{
Guid transactionId = Guid.NewGuid();
messageId = actions.RegisterToSend(new Endpoint("localhost", 0),
"test",
null,
testMessage,
transactionId);
actions.MarkAsReadyToSend(transactionId);
actions.Commit();
});
qf.Send(actions =>
{
Endpoint endpoint;
var msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, out endpoint);
actions.MarkOutgoingMessageAsFailedTransmission(msgs.First().Bookmark, false);
msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, out endpoint);
Assert.Empty(msgs);
actions.Commit();
});
qf.Global(actions =>
{
PersistentMessageToSend message = actions.GetSentMessages().FirstOrDefault(x => x.Id.MessageIdentifier == messageId);
Assert.NotNull(message);
Assert.Equal(OutgoingMessageStatus.Failed, message.OutgoingStatus);
actions.Commit();
});
}
}
public void MoveToErrors(ErrorReport report)
{
var messagePayload = new MessagePayload
{
Data = report.Serialize(),
Headers = report.Headers
};
messagePayload.Headers.Add("ExceptionType", report.ExceptionType);
_transaction.EnqueueDirectlyTo(LightningQueuesTransport.ErrorQueueName, messagePayload, _message.Id);
MarkSuccessful();
}
public void TransportMessage(
MessagePayload toTransport,
Action<Exception> onException,
Action onCompletion,
Action<IEnumerable<MessagePayload>> onReceiveMessages)
{
requestor.SendPut(
toTransport.GetToAddress().Server.GetUrl(),
requestStream => formatter.Serialise(requestStream, toTransport),
s => RecieveResponse(s, onReceiveMessages),
onException,
onCompletion);
}
private void OnMessage(object sender, MessageEventArgs args)
{
if (!MessagePayload.TryParse(args.Message.Text, out var message))
{
_client.SendTextMessageAsync(args.Message.Chat.Id, ErrorMessage);
return;
}
var contactId = args.Message.Chat.Id;
var eventArgs = new MessageReceivedEventArgs(message, contactId.ToString());
MessageReceived?.Invoke(this, eventArgs);
}
public void SendSurveyDataToSql()
{
MessagePayload messagePayload = new MessagePayload();
messagePayload.Body = JsonConvert.SerializeObject(GetFormResponDetails(), Formatting.None, new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore
});
var sqlConsistencyHandler = new SqlConsistencyHandler();
var DBResponse = SqlConsistencyHandler.SendSurveyDataToSQL(messagePayload);
Assert.IsTrue(DBResponse);
}
public SendRec(SendRec value)
{
m_DestinationID = new DestinationID();
m_SourceID = new SourceID();
m_MessagePayload = new MessagePayload();
// Copy the values
m_PresenceVector = value.getPresenceVector();
m_ReliableDelivery = value.getReliableDelivery();
m_DestinationID = value.getDestinationID();
m_SourceID = value.getSourceID();
m_Priority = value.getPriority();
m_MessagePayload = value.getMessagePayload();
}
public static HttpResponseMessage Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] MessagePayload post,
[DocumentDB("%CosmosDBDatabase%", "%CosmosDBCollection%", Id = "id", ConnectionStringSetting = "AzureCosmosDBConnectionString")] out dynamic document)
{
string newId = Guid.NewGuid().ToString();
document = new { id = newId, message = post.message };
string result = JsonConvert.SerializeObject(new { id = newId });
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(result, Encoding.UTF8, "application/json")
});
}
public override void InputMessage(MessagePayload toInput)
{
PerformVerifyingLogging(toInput);
if (ServerRequiresAuthentication(toInput))
{
RegisterFromServerAsAuthenticated(toInput);
if (!PayloadHasExpectedSession(toInput)) return;
}
PerformVerifiedLogging(toInput);
OnMessageProcessed(toInput);
}
private void MessageCallBack(object sender,
agsXMPP.protocol.client.Message msg,
object data)
{
if (msg.Body != null)
{
var lines = msg.Body.Split(new[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
var senderLines = lines[0].Replace("**** This was broadcast by ", "").Replace(" EVE ****", "").Split(new[] { " at " }, StringSplitOptions.RemoveEmptyEntries);
var recipient = lines[lines.Length - 1].Replace("**** Message sent to the ", "").Replace(" Group ****", "");
var sendLines = new List <string>();
sendLines.Add(string.Format("Timestamp: {0}", senderLines[1]));
sendLines.Add(string.Format("From: {0}", senderLines[0]));
sendLines.Add(string.Format("To: {0}", recipient));
//sendLines.Add(lines[1]);
for (var i = 1; i < lines.Length - 1; i++)
{
sendLines.Add(lines[i]);
}
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("{0}>> {1}", msg.From.User, msg.Body);
Console.ForegroundColor = ConsoleColor.Green;
var payload = new MessagePayload();
payload.Attachments = new List <MessagePayloadAttachment>();
if (!sendLines[0].Contains("@everyone"))
{
//sendLines.Insert(0, "@everyone");
sendLines[0] = string.Concat("@everyone: ", sendLines[0]);
}
payload.Attachments.Add(new MessagePayloadAttachment()
{
Text = string.Join("\n", sendLines).Replace("@everyone", "@channel"),
Title = string.Format("{0}: Message from {1}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), "Marvin"),
Colour = "#ff0066"
});
Plugin.SendToRoom(payload, Properties.Settings.Default.SlackRoom, Properties.Settings.Default.SlackCorpWebhook, Properties.Settings.Default.BotName);
if (msg.Body.Contains(Properties.Settings.Default.XMPPGroupName))
{
foreach (var wHook in Properties.Settings.Default.SlackSharedWebhooks)
{
Plugin.SendToRoom(payload, Properties.Settings.Default.SlackRoom, wHook, Properties.Settings.Default.BotName);
}
}
}
}
public static void SendPM(MessagePayload payload, string username, string token)
{
try
{
payload.Channel = string.Concat("@", username);
payload.Username = "******";
SlackClient client = new SlackClient(token);
client.PostMessage(payload);
}
catch (Exception ex)
{
}
}
public void Send(MessagePayload payload)
{
throw new InvalidOperationException("Symulowany błąd podczas wysyłki wiadomości email.");
var smtpClient = new SmtpClient("smtp.gmail.com")
{
Port = 587,
Credentials = new NetworkCredential("*****@*****.**", "C2%~8SAcmW)*QsXC"),
EnableSsl = true,
};
smtpClient.Send("*****@*****.**", payload.EmailAddress, payload.Title, payload.Message);
}
static async void SendQueue(MessagePayload payload)
{
string json = JsonConvert.SerializeObject(payload);
SendMessageResponse response = await _sqsClient.SendMessageAsync(new SendMessageRequest
{
QueueUrl = _queueUrl,
MessageBody = json,
//MessageGroupId = Guid.NewGuid().ToString() //this is fifo session id
MessageGroupId = "MyGroup"
});
Console.WriteLine($"MessageId: {response.MessageId}");
Console.WriteLine($"StatusCode: {(int)response.HttpStatusCode}");
}
public static void TranslateHeaders(this MessagePayload messagePayload)
{
var headerValue = messagePayload.Headers[LightningQueuesChannel.MaxAttemptsHeader];
if (headerValue.IsNotEmpty())
{
messagePayload.MaxAttempts = int.Parse(headerValue);
}
headerValue = messagePayload.Headers[LightningQueuesChannel.DeliverByHeader];
if (headerValue.IsNotEmpty())
{
messagePayload.DeliverBy = DateTime.Parse(headerValue);
}
}
public Worker()
{
try {
try
{
while (user == string.Empty)
{
var split = GetLoggedInUser().Split(new string[] { "\\" }, StringSplitOptions.RemoveEmptyEntries);
user = split[split.Length - 1];
}
}
catch (Exception ex)
{
user = "******";
}
Logger = string.Empty;
if ((LastWriteTime == DateTime.MinValue) && (Properties.Settings.Default.LastWriteTime != string.Empty))
{
LastWriteTime = Convert.ToDateTime(Properties.Settings.Default.LastWriteTime);
}
else if (LastWriteTime == DateTime.MinValue)
{
LastWriteTime = DateTime.Now.ToUniversalTime();
LastUserPingTime = DateTime.MinValue;
}
path = string.Format(path, user);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
var payload = new MessagePayload()
{
Text = "R3MUS Intel Logger Error",
Username = "******",
Channel = "it_testing"
};
payload.Attachments.Add(new MessagePayloadAttachment()
{
AuthorName = user,
Title = ex.Message,
Colour = "#ff0000"
});
if (ex.InnerException != null)
{
payload.Attachments.FirstOrDefault().Text = ex.InnerException.Message;
}
Slack.Plugin.SendToRoom(payload, "it_testing", Properties.Settings.Default.SlackWebHook, "IntelLoggerBot");
}
}
public void MovesMessageToOutgoingFromHistory()
{
using (var qf = new QueueStorage("test.esent"))
{
qf.Initialize();
qf.Global(actions =>
{
actions.CreateQueueIfDoesNotExists("test");
actions.Commit();
});
var testMessage = new MessagePayload
{
Data = new byte[0],
Headers = new NameValueCollection(),
};
qf.Global(actions =>
{
Guid transactionId = Guid.NewGuid();
actions.RegisterToSend(new Endpoint("localhost", 0),
"test",
null,
testMessage,
transactionId);
actions.MarkAsReadyToSend(transactionId);
actions.Commit();
});
qf.Send(actions =>
{
Endpoint endpoint;
var msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, out endpoint);
var bookmark = actions.MarkOutgoingMessageAsSuccessfullySent(msgs[0].Bookmark);
actions.RevertBackToSend(new[] { bookmark });
msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, out endpoint);
Assert.NotEmpty(msgs);
actions.Commit();
});
qf.Global(actions =>
{
var messages = actions.GetSentMessages();
Assert.Empty(messages);
actions.Commit();
});
}
}
public void MovesMessageToOutgoingFromHistory()
{
using (var qf = new QueueStorage("test.esent", new QueueManagerConfiguration()))
{
qf.Initialize();
qf.Global(actions =>
{
actions.CreateQueueIfDoesNotExists("test");
actions.Commit();
});
var testMessage = new MessagePayload
{
Data = new byte[0],
Headers = new NameValueCollection(),
};
qf.Global(actions =>
{
Guid transactionId = Guid.NewGuid();
actions.RegisterToSend(new Endpoint("localhost", 0),
"test",
null,
testMessage,
transactionId);
actions.MarkAsReadyToSend(transactionId);
actions.Commit();
});
qf.Send(actions =>
{
Endpoint endpoint;
var msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, out endpoint);
var bookmark = actions.MarkOutgoingMessageAsSuccessfullySent(msgs[0].Bookmark);
actions.RevertBackToSend(new[] { bookmark });
msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, out endpoint);
Assert.NotEmpty(msgs);
actions.Commit();
});
qf.Global(actions =>
{
var messages = actions.GetSentMessages();
Assert.Empty(messages);
actions.Commit();
});
}
}
public static MessagePayload ToMessagePayload(this Message subject)
{
subject.VerifyNotNull(nameof(subject));
subject.ContentType.VerifyAssert(x => x == nameof(MessagePayload), "Invalid content type");
string json = Encoding.UTF8.GetString(subject.Body);
json.VerifyNotEmpty(nameof(json));
MessagePayload messagePayload = Json.Default.Deserialize <MessagePayload>(json) !;
messagePayload.Verify();
return(messagePayload);
}
public override void InputMessage(MessagePayload toInput)
{
try
{
OnMessageProcessed(toInput);
}
catch (Exception e)
{
OnException(e);
if (!shouldContinueOnException) throw;
Logger.Error(e);
}
}
public override void Decode(MessagePayload payload)
{
string json = Encoding.UTF8.GetString(payload.BinaryContent);
JObject jo = (JObject)JsonConvert.DeserializeObject(json);
if (jo["o"] != null)
{
OperateUser = jo["o"].Value <string>();
}
if (jo["g"] != null)
{
GroupId = jo["g"].Value <string>();
}
}
private void Poll(List <LogLine> messages, IHubProxy hub)
{
try
{
messages.ForEach(message => {
try
{
Console.WriteLine(string.Format("{0}: {1} > {2}", message.LogDateTime.ToString("yyyy-MM-dd HH:mm:ss"), message.UserName, message.Message));
hub.Invoke <LogLine>("reportIntel", message);
Thread.Sleep(500);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
var payload = new MessagePayload()
{
Text = "R3MUS Intel Logger Error",
Username = "******",
Channel = "it_testing"
};
payload.Attachments.Add(new MessagePayloadAttachment()
{
AuthorName = message.UserName, Title = message.LogDateTime.ToString("yyyy-MM-dd HH:mm:ss"), Text = message.Message,
Colour = "#ff0000"
});
payload.Attachments.Add(new MessagePayloadAttachment()
{
AuthorName = message.UserName,
Title = message.Message,
Text = ex.Message,
Colour = "#ff0000"
});
if (ex.InnerException != null)
{
payload.Attachments.Add(new MessagePayloadAttachment()
{
AuthorName = message.UserName,
Title = message.Message,
Text = ex.InnerException.Message,
Colour = "#ff0000"
});
}
Slack.Plugin.SendToRoom(payload, "it_testing", Properties.Settings.Default.SlackWebHook, "IntelLoggerBot");
}
});
}
catch (Exception ex) { }
}
public void TransportMessage(
MessagePayload toTransport,
Action<Exception> onException,
Action onCompletion,
Action<IEnumerable<MessagePayload>> onReceiveMessages)
{
try
{
onReceiveMessages(messageServer.InputMessage(CopyMessage(toTransport)));
onCompletion();
}
catch (Exception e)
{
onException(e);
throw;
}
}
