public void DelayedElement()
{
var senderId = "A";
var receiverId = "B";
var senderSorter = new MessageSorter();
var message1 = Send(senderId, receiverId, "1", senderSorter, DateTime.UtcNow);
var message2 = Send(senderId, receiverId, "2", senderSorter, DateTime.UtcNow);
var message3 = Send(senderId, receiverId, "3", senderSorter, DateTime.UtcNow);
List <RequestMessage> batch;
MessageSorter receiverSorter;
// delivering first message last delays all messages until getting the first one
receiverSorter = new MessageSorter();
batch = receiverSorter.ReceiveInOrder(message2, ReorderWindow).ToList();
Assert.Empty(batch);
batch = receiverSorter.ReceiveInOrder(message3, ReorderWindow).ToList();
Assert.Empty(batch);
batch = receiverSorter.ReceiveInOrder(message1, ReorderWindow).ToList();
Assert.Collection(
batch,
first => first.Input.Equals("1"),
second => second.Input.Equals("2"),
third => third.Input.Equals("3"));
Assert.Equal(0, receiverSorter.NumberBufferedRequests);
}
public void NoFilteringOrSortingPastReorderWindow()
{
var senderId = "A";
var receiverId = "B";
var senderSorter = new MessageSorter();
var now = DateTime.UtcNow;
// last message is sent after an interval exceeding the reorder window
var message1 = Send(senderId, receiverId, "1", senderSorter, now);
var message2 = Send(senderId, receiverId, "2", senderSorter, now + TimeSpan.FromTicks(1));
var message3 = Send(senderId, receiverId, "3", senderSorter, now + TimeSpan.FromTicks(2) + ReorderWindow);
List <RequestMessage> batch;
MessageSorter receiverSorter = new MessageSorter();
// delivering the sequence in order produces 1 message each time
receiverSorter = new MessageSorter();
batch = receiverSorter.ReceiveInOrder(message1, ReorderWindow).ToList();
Assert.Single(batch).Input.Equals("1");
batch = receiverSorter.ReceiveInOrder(message2, ReorderWindow).ToList();
Assert.Single(batch).Input.Equals("2");
batch = receiverSorter.ReceiveInOrder(message3, ReorderWindow).ToList();
Assert.Single(batch).Input.Equals("3");
// duplicates are not filtered or sorted, but simply passed through, because we are past the reorder window
batch = receiverSorter.ReceiveInOrder(message2, ReorderWindow).ToList();
Assert.Single(batch).Input.Equals("2");
batch = receiverSorter.ReceiveInOrder(message1, ReorderWindow).ToList();
Assert.Single(batch).Input.Equals("1");
Assert.Equal(0, receiverSorter.NumberBufferedRequests);
}
public void WackySystemClock()
{
var senderId = "A";
var receiverId = "B";
var senderSorter = new MessageSorter();
// simulate system clock that goes backwards - mechanism should still guarantee monotonicitty
var message1 = Send(senderId, receiverId, "1", senderSorter, DateTime.UtcNow);
var message2 = Send(senderId, receiverId, "2", senderSorter, DateTime.UtcNow - TimeSpan.FromSeconds(1));
var message3 = Send(senderId, receiverId, "3", senderSorter, DateTime.UtcNow - TimeSpan.FromSeconds(2));
List <RequestMessage> batch;
MessageSorter receiverSorter = new MessageSorter();
// delivering the sequence in order produces 1 message each time
receiverSorter = new MessageSorter();
batch = receiverSorter.ReceiveInOrder(message1, ReorderWindow).ToList();
Assert.Single(batch).Input.Equals("1");
batch = receiverSorter.ReceiveInOrder(message2, ReorderWindow).ToList();
Assert.Single(batch).Input.Equals("2");
batch = receiverSorter.ReceiveInOrder(message3, ReorderWindow).ToList();
Assert.Single(batch).Input.Equals("3");
Assert.Equal(0, receiverSorter.NumberBufferedRequests);
}
public void SimpleInOrder()
{
var senderId = "A";
var receiverId = "B";
var senderSorter = new MessageSorter();
var message1 = Send(senderId, receiverId, "1", senderSorter, DateTime.UtcNow);
var message2 = Send(senderId, receiverId, "2", senderSorter, DateTime.UtcNow);
var message3 = Send(senderId, receiverId, "3", senderSorter, DateTime.UtcNow);
List <RequestMessage> batch;
MessageSorter receiverSorter = new MessageSorter();
// delivering the sequence in order produces 1 message each time
receiverSorter = new MessageSorter();
batch = receiverSorter.ReceiveInOrder(message1, ReorderWindow).ToList();
Assert.Single(batch).Input.Equals("1");
batch = receiverSorter.ReceiveInOrder(message2, ReorderWindow).ToList();
Assert.Single(batch).Input.Equals("2");
batch = receiverSorter.ReceiveInOrder(message3, ReorderWindow).ToList();
Assert.Single(batch).Input.Equals("3");
Assert.Equal(0, receiverSorter.NumberBufferedRequests);
}
public override void DistanceUpdatingHandler(DistanceUpdatingMessageReader request)
{
List <DistanceUpdatingMessage> DistanceUpdatingMessageList = new List <DistanceUpdatingMessage>();
request.recipients.ForEach((cellId) =>
{
using (var cell = Global.LocalStorage.UseSSSPCell(cellId))
{
if (cell.distance > request.distance + 1)
{
cell.distance = request.distance + 1;
cell.parent = request.senderId;
Console.Write(cell.distance + " ");
MessageSorter sorter = new MessageSorter(cell.neighbors);
for (int i = 0; i < Global.ServerCount; i++)
{
DistanceUpdatingMessageWriter msg = new DistanceUpdatingMessageWriter(cell.CellID.Value,
cell.distance, sorter.GetCellRecipientList(i));
Global.CloudStorage.DistanceUpdatingToSSSPServer(i, msg);
}
}
}
});
}
private void performAction(long cellId)
{
using (var rootCell = Global.LocalStorage.UseSSSPCell(cellId))
{
//Console.WriteLine("PerformAction: " + cellId);
//update rankValue && storedRankValue
//rootCell.rankValue = rootCell.storedRankValue - rootCell.oldStoredRankValue;
//rootCell.oldStoredRankValue = rootCell.storedRankValue;
//long rankValueP = (rootCell.rankValue - rootCell.oldRankValue) / rootCell.neighbors.Count;
double rankValueP = (rootCell.storedRankValue - rootCell.rankValue) / rootCell.neighbors.Count;
MessageSorter sorter = new MessageSorter(rootCell.neighbors);
for (int i = 0; i < Global.SlaveCount; i++)
{
//Console.WriteLine(3);
RankUpdatingMessageWriter msg = new RankUpdatingMessageWriter(rootCell.CellID.Value, rankValueP, sorter.GetCellRecipientList(i));
//Console.WriteLine(4);
Global.CloudStorage.RankUpdatingToSlave(i, msg);
//Console.WriteLine(5);
}
//update
//Console.WriteLine(6);
//rootCell.oldRankValue = rootCell.rankValue;
rootCell.rankValue = rootCell.storedRankValue;
}
}
public override void BFSUpdateHandler(BFSUpdateMessageReader request)
{
request.recipients.ForEach((cellId) => {
using (var cell = Global.LocalStorage.UseBFSCell(cellId)) {
if (cell.level > request.level + 1)
{
cell.level = request.level + 1;
cell.parent = request.senderId;
List <long> aliveNeighbors = new List <long>();
for (int i = 0; i < cell.neighbors.Count; i++)
{
if (Global.CloudStorage.Contains(cell.neighbors[i]))
{
aliveNeighbors.Add(cell.neighbors[i]);
}
}
//MessageSorter sorter = new MessageSorter(cell.neighbors);
MessageSorter sorter = new MessageSorter(aliveNeighbors);
for (int i = 0; i < Global.ServerCount; i++)
{
BFSUpdateMessageWriter msg = new BFSUpdateMessageWriter(cell.CellId, cell.level, sorter.GetCellRecipientList(i));
Global.CloudStorage.BFSUpdateToBFSServer(i, msg);
}
}
}
});
}
internal void HandleMessage(Guid clientId, Container container)
{
if (!_connections.TryGetValue(clientId, out WsConnection connection))
{
return;
}
_connections.RefreshLifeClient(clientId);
switch (container.Identifier)
{
case DispatchType.Login:
if (((JObject)container.Payload).ToObject(typeof(LoginRequestContainer)) is LoginRequestContainer loginRequest)
{
LoginResponseContainer loginResponse;
bool isEnter = true;
DispatchType stage;
if (UserOnlineList.Contains(loginRequest.Content))
{
loginResponse = new LoginResponseContainer(
new Response(ResponseType.Failure, $"Client with name '{loginRequest.Content}' yet connect."),
null,
null,
null,
null);
connection.Send(loginResponse.GetContainer());
connection.Login = $"pseudo-{loginRequest.Content}";
stage = DispatchType.Connection;
}
else
{
isEnter = UserOfflineList.Contains(loginRequest.Content);
loginResponse = new LoginResponseContainer(new Response(ResponseType.Ok, "Connected"), null, null, null, null);
connection.Login = loginRequest.Content;
stage = DispatchType.Login;
}
var eventLogMessage = new EventLogMessage
{
IsSuccessfully = loginResponse.Content.Result == ResponseType.Ok == isEnter,
SenderName = _name,
Text = loginResponse.Content.Reason,
Time = DateTime.Now,
Type = stage
};
ConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(connection.Login, true, eventLogMessage));
}
break;
case DispatchType.Message:
MessageReceivedEventArgs message = MessageSorter.GetSortedMessage((JObject)container.Payload);
MessageReceived?.Invoke(this, message);
Send(MessageSorter.GetSortedMessage(message.Author, message.Message, InterfaceType.WebSocket, message.Agenda), message.Agenda);
break;
}
}
private void OnMessage(object sender, MessageEventArgs eventArgs)
{
if (!eventArgs.IsText)
{
return;
}
var container = JsonConvert.DeserializeObject <Container>(eventArgs.Data);
switch (container.Identifier)
{
case DispatchType.Login:
if (((JObject)container.Payload).ToObject(typeof(LoginResponseContainer)) is LoginResponseContainer loginResponse)
{
var eventLog = new EventLogMessage()
{
IsSuccessfully = true,
SenderName = _login,
Text = "Login",
Time = DateTime.Now,
Type = DispatchType.Login
};
if (loginResponse.Content.Result == ResponseType.Failure)
{
eventLog.IsSuccessfully = false;
eventLog.Text = loginResponse.Content.Reason;
}
LoginEvent?.Invoke(
this,
new LoginEventArgs(
_login,
eventLog.IsSuccessfully,
eventLog,
loginResponse.General,
loginResponse.OnlineList,
loginResponse.OfflineList,
loginResponse.EventLogMessageList));
}
break;
case DispatchType.Message:
MessageReceived?.Invoke(this, MessageSorter.GetSortedMessage((JObject)container.Payload));
break;
case DispatchType.Channel:
UpdateChannel?.Invoke(this, MessageSorter.GetSortedChannel((JObject)container.Payload));
break;
case DispatchType.EventLog:
LogEvent?.Invoke(this, MessageSorter.GetSortedEventMessage((JObject)container.Payload));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Prepares the report body as byte array by report body details.
/// </summary>
/// <param name="details">The details.</param>
/// <returns></returns>
public byte[] PrepareDocument(IReportBodyDetails details)
{
var threads = MessageSorter.ProcessMessages(details.Messages);
var report = new StringBuilder();
var header = PrepareHeaderPart(details);
report.AppendLine(header).AppendLine(string.Empty);
threads.ForEach(c => report.AppendLine(PrepareContentPart(c, details.Since, details.IsChannel)));
return(Encoding.UTF8.GetBytes(report.ToString()));
}
public List <MessageVO> GetChat(UserVO from, UserVO to)
{
List <MessageVO> m = GetMessages(to, from);
m.AddRange(GetMessages(from, to));
MessageSorter sorter = new MessageSorter();
m.Sort(sorter);
SetMessagesSeen(from, to);
DeleteOldMessages(from, to);
return(m);
}
public void RandomCollection()
{
var senderId = "A";
var receiverId = "B";
var senderSorter = new MessageSorter();
var receiverSorter = new MessageSorter();
var messageCount = 100;
var random = new Random(0);
var now = DateTime.UtcNow;
// create a ordered sequence of messages
var messages = new List <RequestMessage>();
for (int i = 0; i < messageCount; i++)
{
messages.Add(Send(senderId, receiverId, i.ToString(), senderSorter, now + TimeSpan.FromSeconds(random.Next(5)), TimeSpan.FromSeconds(10)));
}
// shuffle the messages
Shuffle(messages, random);
// add a final message
messages.Add(Send(senderId, receiverId, (messageCount + 1).ToString(), senderSorter, now + TimeSpan.FromSeconds(1000), TimeSpan.FromSeconds(10)));
// deliver all the messages
var deliveredMessages = new List <RequestMessage>();
for (int i = 0; i < messageCount; i++)
{
foreach (var deliveredMessage in receiverSorter.ReceiveInOrder(messages[i], TimeSpan.FromSeconds(10)))
{
deliveredMessages.Add(deliveredMessage);
}
Assert.Equal(i + 1, deliveredMessages.Count + receiverSorter.NumberBufferedRequests);
}
// receive the final messages
foreach (var deliveredMessage in receiverSorter.ReceiveInOrder(messages[messageCount], TimeSpan.FromSeconds(10)))
{
deliveredMessages.Add(deliveredMessage);
}
// check that all messages were delivered
Assert.Equal(messageCount + 1, deliveredMessages.Count());
Assert.Equal(0, receiverSorter.NumberBufferedRequests);
}
public void RandomShuffleAndDuplication()
{
var senderId = "A";
var receiverId = "B";
var senderSorter = new MessageSorter();
var receiverSorter = new MessageSorter();
var messageCount = 100;
var duplicateCount = 100;
// create a ordered sequence of messages
var messages = new List <RequestMessage>();
for (int i = 0; i < messageCount; i++)
{
messages.Add(Send(senderId, receiverId, i.ToString(), senderSorter, DateTime.UtcNow));
}
// add some random duplicates
var random = new Random(0);
for (int i = 0; i < duplicateCount; i++)
{
messages.Add(messages[random.Next(messageCount)]);
}
// shuffle the messages
Shuffle(messages, random);
// deliver all the messages
var deliveredMessages = new List <RequestMessage>();
foreach (var msg in messages)
{
foreach (var deliveredMessage in receiverSorter.ReceiveInOrder(msg, ReorderWindow))
{
deliveredMessages.Add(deliveredMessage);
}
}
// check that the delivered messages are the original sequence
Assert.Equal(messageCount, deliveredMessages.Count());
for (int i = 0; i < messageCount; i++)
{
Assert.Equal(i.ToString(), deliveredMessages[i].Input);
}
Assert.Equal(0, receiverSorter.NumberBufferedRequests);
}
private void HandlePacket(byte[] packet)
{
string serializedMessages = GetStringPacket(packet);
var container = JsonConvert.DeserializeObject <Container>(serializedMessages);
switch (container.Identifier)
{
case DispatchType.Login:
if (((JObject)container.Payload).ToObject(typeof(LoginResponseContainer)) is LoginResponseContainer loginResponse)
{
var eventLog = new EventLogMessage
{
IsSuccessfully = loginResponse.Content.Result == ResponseType.Ok,
SenderName = _login,
Text = loginResponse.Content.Reason,
Time = DateTime.Now,
Type = DispatchType.Login
};
_isLogin = eventLog.IsSuccessfully;
LoginEvent?.Invoke(
this,
new LoginEventArgs(
_login,
eventLog.IsSuccessfully,
eventLog,
loginResponse.General,
loginResponse.OnlineList,
loginResponse.OfflineList,
loginResponse.EventLogMessageList));
}
break;
case DispatchType.Message:
MessageReceived?.Invoke(this, MessageSorter.GetSortedMessage((JObject)container.Payload));
break;
case DispatchType.Channel:
UpdateChannel?.Invoke(this, MessageSorter.GetSortedChannel((JObject)container.Payload));
break;
case DispatchType.EventLog:
LogEvent?.Invoke(this, MessageSorter.GetSortedEventMessage((JObject)container.Payload));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private void initialSend(SSSPCell rootCell)
{
//Console.WriteLine(value);
addCount();
double v = 1 / rootCell.outNeighbors.Count;
MessageSorter sorter = new MessageSorter(rootCell.outNeighbors);
for (int i = 0; i < Global.SlaveCount; i++)
{
RankUpdatingMessageWriter msg =
new RankUpdatingMessageWriter(rootCell.CellID, v, sorter.GetCellRecipientList(i));
Global.CloudStorage.RankUpdatingToSlave(i, msg);
}
}
private void HandleMessageReceived(object sender, MessageReceivedEventArgs eventArgs)
{
string messageServer = $"{eventArgs.Agenda.Type}:{eventArgs.Author}:{eventArgs.Message}";
var eventLogMessage = new EventLogMessage
{
IsSuccessfully = true,
SenderName = eventArgs.Author,
Text = messageServer,
Time = DateTime.Now,
Type = DispatchType.Message
};
switch (eventArgs.Agenda.Type)
{
case ChannelType.General:
SendCurrentServer(eventArgs.Type, MessageSorter.GetSortedMessage(eventArgs), eventArgs.Agenda);
User user = _dataBaseManager.UserList.Find(u => u.Name == eventArgs.Author);
var generalMessage = new GeneralMessage
{
Message = eventArgs.Message,
Time = eventArgs.Time,
User_Id = user.Id
};
_dataBaseManager.CreateGeneralMessageAsync(generalMessage);
break;
case ChannelType.Private:
SendCurrentServer(eventArgs.Type, MessageSorter.GetSortedMessage(eventArgs), eventArgs.Agenda);
var privateMessage = new PrivateMessage
{
Message = eventArgs.Message,
Time = eventArgs.Time,
SenderId = _dataBaseManager.UserList.Find(u => u.Name == eventArgs.Author).Id,
TargetId = _dataBaseManager.UserList.Find(u => u.Name == ((PrivateAgenda)eventArgs.Agenda).Target).Id
};
_dataBaseManager.CreatePrivateMessageAsync(privateMessage);
break;
case ChannelType.Group:
break;
default:
throw new ArgumentOutOfRangeException();
}
EventSaveAsync(new MessageEventLogContainer(eventLogMessage), eventArgs.Agenda);
}
public override void StartSSSPHandler(StartSSSPMessageReader request)
{
if (Global.CloudStorage.IsLocalCell(request.root))
{
using (var rootCell = Global.LocalStorage.UseSSSPCell(request.root)) {
rootCell.distance = 0;
rootCell.parent = -1;
MessageSorter sorter = new MessageSorter(rootCell.neighbors);
for (int i = 0; i < Global.ServerCount; i++)
{
DistanceUpdatingMessageWriter msg = new DistanceUpdatingMessageWriter(rootCell.CellId, 0, sorter.GetCellRecipientList(i));
Global.CloudStorage.DistanceUpdatingToSSSPServer(i, msg);
}
}
}
}
public override void StartBFSHandler(StartBFSMessageReader request)
{
if (Global.CloudStorage.IsLocalCell(request.root))
{
using (var rootCell = Global.LocalStorage.UseBFSCell(request.root)) {
rootCell.level = 0;
rootCell.parent = request.root;
MessageSorter sorter = new MessageSorter(rootCell.neighbors);
for (int i = 0; i < Global.ServerCount; i++)
{
BFSUpdateMessageWriter msg = new BFSUpdateMessageWriter(rootCell.CellId, 0, sorter.GetCellRecipientList(i));
Global.CloudStorage.BFSUpdateToBFSServer(i, msg);
}
}
}
}
public void TestArgumentExceptions()
{
var messages = new List <MessageSummary> {
new MessageSummary(0)
};
var orderBy = new OrderBy[] { OrderBy.Arrival };
var emptyOrderBy = new OrderBy[0];
Assert.Throws <ArgumentNullException> (() => MessageSorter.Sort((List <MessageSummary>)null, orderBy));
Assert.Throws <ArgumentNullException> (() => MessageSorter.Sort(messages, null));
Assert.Throws <ArgumentException> (() => MessageSorter.Sort(messages, emptyOrderBy));
Assert.Throws <ArgumentException> (() => MessageSorter.Sort(messages, orderBy));
Assert.Throws <ArgumentNullException> (() => MessageSorter.Sort((IEnumerable <MessageSummary>)null, orderBy));
Assert.Throws <ArgumentNullException> (() => MessageSorter.Sort((IEnumerable <MessageSummary>)messages, null));
Assert.Throws <ArgumentException> (() => MessageSorter.Sort((IEnumerable <MessageSummary>)messages, emptyOrderBy));
Assert.Throws <ArgumentException> (() => MessageSorter.Sort((IEnumerable <MessageSummary>)messages, orderBy));
}
public List <MessageVO> GetUnseenMessages(UserVO from, UserVO to)
{
SqlParameter[] parameters =
{
MakeSqlParameter(messageFrom, from.Id),
MakeSqlParameter(messageTo, to.Id),
MakeSqlParameter(messageIsSeen, false, SqlDbType.Bit)
};
List <MessageVO> result = IdenticalMatch(parameters);
MessageSorter sorter = new MessageSorter();
result.Sort(sorter);
SetMessagesSeen(from, to);
DeleteOldMessages(from, to);
return(result);
}
private void initialPropagate(SSSPCell cell, bool isActive)
{
//clear
for (int i = 0; i < cell.inNeighborsReceivedStatus.Count; i++)
{
cell.inNeighborsReceivedStatus[i] = false;
}
//cell.receivedNeighborCount = 0;
//send-out
double v = 1.0 / cell.outNeighbors.Count;
MessageSorter sorter = new MessageSorter(cell.outNeighbors);
for (int i = 0; i < Global.SlaveCount; i++)
{
//Console.WriteLine(sorter.GetCellRecipientList(i).Count);
RankUpdatingMessageWriter msg = new RankUpdatingMessageWriter(cell.CellID, isActive, v, sorter.GetCellRecipientList(i));
Global.CloudStorage.RankUpdatingToSlave(i, msg);
}
}
/// <summary>
/// Prepares the body.
/// </summary>
/// <param name="details">The details.</param>
/// <param name="doc">The document.</param>
/// <param name="messageTemplate">The message template.</param>
protected void PrepareBody(IReportBodyDetails details, HtmlDocument doc, string messageTemplate)
{
var threadsNode = doc.GetElementbyId("history");
var threads = MessageSorter.ProcessMessages(details.Messages);
foreach (var thread in threads)
{
threadsNode.SetAttributeValue("class", "threads-container");
if (details.IsChannel)
{
if (thread.IsFull)
{
threadsNode.AppendChild(PrepareMessageDetails(thread.Messages.First(), true, messageTemplate, details.IsChannel));
}
else
{
if (details.Since.HasValue)
{
threadsNode.AppendChild(CreateConversationWarning(details.Since.Value));
}
threadsNode.AppendChild(PrepareMessageDetails(thread.Messages.First(), false, messageTemplate, details.IsChannel));
}
thread.Messages.Skip(1).ToList().ForEach(c => threadsNode.AppendChild(PrepareMessageDetails(c, false, messageTemplate, details.IsChannel)));
}
else
{
if (!thread.IsFull && details.Since.HasValue)
{
threadsNode.AppendChild(CreateConversationWarning(details.Since.Value));
}
thread.Messages.ForEach(c => threadsNode.AppendChild(PrepareMessageDetails(c, false, messageTemplate, details.IsChannel)));
}
}
}
private void step_one(long node_count)
{
for (int k = 0; k < node_count; k++)
{
if (Global.CloudStorage.Contains(k) && Global.CloudStorage.IsLocalCell(k))
{
using (var rootCell = Global.LocalStorage.UseSSSPCell(k))
{
if (rootCell.neighbors.Count == 0)
{
continue;
}
double rankValueP = rootCell.rankValue / rootCell.neighbors.Count;
MessageSorter sorter = new MessageSorter(rootCell.neighbors);
for (int i = 0; i < Global.SlaveCount; i++)
{
DistanceUpdatingMessageWriter msg = new DistanceUpdatingMessageWriter(rootCell.CellID.Value, rankValueP, sorter.GetCellRecipientList(i));
Global.CloudStorage.DistanceUpdatingToSlave(i, msg);
}
}
}
}
}
private void performActionOne(long cellId)
{
using (var rootCell = Global.LocalStorage.UseSSSPCell(cellId))
{
double rankValueP = rootCell.rankValue / rootCell.neighbors.Count;
MessageSorter sorter = new MessageSorter(rootCell.neighbors);
for (int i = 0; i < Global.SlaveCount; i++)
{
//Console.WriteLine(3);
RankUpdatingMessageWriter msg = new RankUpdatingMessageWriter(rootCell.CellID.Value, rankValueP, sorter.GetCellRecipientList(i));
//Console.WriteLine(4);
Global.CloudStorage.RankUpdatingToSlave(i, msg);
//Console.WriteLine(5);
}
//update
//Console.WriteLine(6);
//rootCell.oldRankValue = rootCell.rankValue;
}
}
private void performAction(long cellId)
{
//Console.WriteLine(0);
using (var rootCell = Global.LocalStorage.UseSSSPCell(cellId))
{
//activated cell should satisfy storedRankValue > rankValue
rootCell.rankValue = rootCell.storedRankValue;
/*
if (rootCell.status == false) return;
if (rootCell.neighbors.Count == 0)
{
rootCell.status = false;
return;
}
*/
//Console.WriteLine(1);
//compute current rankValueP
long rankValueP = rootCell.rankValue / rootCell.neighbors.Count;
//if (rootCell.oldRankValueP < rankValueP)
//{
//send the rank difference
MessageSorter sorter = new MessageSorter(rootCell.neighbors);
//Console.WriteLine(2);
for (int i = 0; i < Global.SlaveCount; i++)
{
//Console.WriteLine(3);
RankUpdatingMessageWriter msg = new RankUpdatingMessageWriter(rootCell.CellID.Value, rankValueP - rootCell.oldRankValueP, sorter.GetCellRecipientList(i));
//Console.WriteLine(4);
Global.CloudStorage.RankUpdatingToSlave(i, msg);
//Console.WriteLine(5);
}
//update
//Console.WriteLine(6);
rootCell.oldRankValueP = rankValueP;
//}
}
}
/// <summary>
/// Gets mail headers
/// </summary>
/// <param name="searchTerm"></param>
/// <returns></returns>
public static ObservableCollection <MailHeader> GetMailHeaders(string searchTerm)
{
ObservableCollection <MailHeader> headerList = new ObservableCollection <MailHeader>();
if (LoggedIn)
{
var inbox = client.Inbox;
inbox.Open(FolderAccess.ReadWrite);
//Debug.WriteLine("Total messages: {0}", inbox.Count);
var orderBy = new[] { OrderBy.ReverseArrival };
List <IMessageSummary> msgList = null;
//If the searchTerm isnt null or empty, search for messages matching the searchterm and sort them
//in reverse arrival order
if (!string.IsNullOrEmpty(searchTerm))
{
//Search query
var query = (SearchQuery.SubjectContains(searchTerm)).Or(SearchQuery.BodyContains(searchTerm));
//Searches the mail folder using the query
var uidList = inbox.Search(query);
if (uidList.Count != 0)
{
//Fetches the messagesummaries of uidList
msgList = inbox.Fetch(uidList, MessageSummaryItems.Envelope | MessageSummaryItems.UniqueId).ToList();
//Sorts msgList in reverse arrival sort order
MessageSorter.Sort(msgList, orderBy);
isMailSearchSuccess = true;
}
else
{
isMailSearchSuccess = false;
return(null);
}
}
//If the searchTerm is null or empty, fetch all messagesummaries and sort them in
//reverse arrival order
else
{
//Fetches all messagesummaries
msgList = inbox.Fetch(0, -1, MessageSummaryItems.Envelope | MessageSummaryItems.UniqueId).ToList();
if (msgList.Count != 0)
{
//Sorts msgList in reverse arrival sort order
MessageSorter.Sort(msgList, orderBy);
}
else
{
return(null);
}
}
foreach (MessageSummary summary in msgList)
{
MailHeader mailHeader = ConvertMessageSummary(summary);
headerList.Add(mailHeader);
}
}
else
{
if (Login())
{
GetMailHeaders(searchTerm);
}
}
return(headerList);
}
private void send(long fromCellId, double value)
{
//Console.WriteLine(value);
addCount();
double v = 0;
using (var rootCell = Global.LocalStorage.UseSSSPCell(fromCellId))
{
try
{
v = value / rootCell.outNeighbors.Count;
MessageSorter sorter = new MessageSorter(rootCell.outNeighbors);
for (int i = 0; i < Global.SlaveCount; i++)
{
RankUpdatingMessageWriter msg = new RankUpdatingMessageWriter(rootCell.CellID.Value, v, sorter.GetCellRecipientList(i));
Global.CloudStorage.RankUpdatingToSlave(i, msg);
}
}
catch (Exception e)
{
//Console.Error.WriteLine(e);
Console.WriteLine(fromCellId);
}
}
}
private void step_one(long node_count)
{
for (int k = 0; k < node_count; k++)
{
if (Global.CloudStorage.Contains(k) && Global.CloudStorage.IsLocalCell(k))
{
using (var rootCell = Global.LocalStorage.UseSSSPCell(k))
{
if (rootCell.neighbors.Count == 0) continue;
double rankValueP = rootCell.rankValue / rootCell.neighbors.Count;
MessageSorter sorter = new MessageSorter(rootCell.neighbors);
for (int i = 0; i < Global.SlaveCount; i++)
{
DistanceUpdatingMessageWriter msg = new DistanceUpdatingMessageWriter(rootCell.CellID.Value, rankValueP, sorter.GetCellRecipientList(i));
Global.CloudStorage.DistanceUpdatingToSlave(i, msg);
}
}
}
}
}
private static RequestMessage Send(string senderId, string receiverId, string input, MessageSorter sorter, DateTime now, TimeSpan?reorderWindow = null)
{
var msg = new RequestMessage()
{
Id = Guid.NewGuid(),
ParentInstanceId = senderId,
Input = input,
};
sorter.LabelOutgoingMessage(msg, receiverId, now, reorderWindow.HasValue ? reorderWindow.Value : ReorderWindow);
return(msg);
}
private void send(SSSPCell rootCell)
{
//Console.WriteLine(value);
addCount();
double v = rootCell.sum / rootCell.outNeighbors.Count;
MessageSorter sorter = new MessageSorter(rootCell.outNeighbors);
for (int i = 0; i < Global.SlaveCount; i++)
{
RankUpdatingMessageWriter msg =
new RankUpdatingMessageWriter(rootCell.CellID, v, sorter.GetCellRecipientList(i));
Global.CloudStorage.RankUpdatingToSlave(i, msg);
}
}
public void TestSorting()
{
var messages = new List <MessageSummary> ();
IList <MessageSummary> sorted;
MessageSummary summary;
summary = new MessageSummary(0);
summary.Envelope = new Envelope();
summary.Envelope.Date = DateTimeOffset.Now;
summary.Envelope.Subject = "aaaa";
summary.Envelope.From = InternetAddressList.Parse("Jeffrey Stedfast <*****@*****.**>");
summary.Envelope.To = InternetAddressList.Parse("Jeffrey Stedfast <*****@*****.**>");
summary.Envelope.Cc = new InternetAddressList();
summary.MessageSize = 520;
messages.Add(summary);
summary = new MessageSummary(1);
summary.Envelope = new Envelope();
summary.Envelope.Date = DateTimeOffset.Now;
summary.Envelope.Subject = "bbbb";
summary.Envelope.From = InternetAddressList.Parse("Jeffrey Stedfast <*****@*****.**>");
summary.Envelope.To = InternetAddressList.Parse("Jeffrey Stedfast <*****@*****.**>");
summary.Envelope.Cc = new InternetAddressList();
summary.MessageSize = 265;
messages.Add(summary);
summary = new MessageSummary(2);
summary.Envelope = new Envelope();
summary.Envelope.Date = DateTimeOffset.Now;
summary.Envelope.Subject = "cccc";
summary.Envelope.From = InternetAddressList.Parse("Jeffrey Stedfast <*****@*****.**>");
summary.Envelope.To = InternetAddressList.Parse("Jeffrey Stedfast <*****@*****.**>");
summary.Envelope.Cc = new InternetAddressList();
summary.MessageSize = 520;
messages.Add(summary);
sorted = MessageSorter.Sort(messages, new [] { OrderBy.Arrival });
Assert.AreEqual(0, sorted[0].Index, "Sorting by arrival failed.");
Assert.AreEqual(1, sorted[1].Index, "Sorting by arrival failed.");
Assert.AreEqual(2, sorted[2].Index, "Sorting by arrival failed.");
sorted = MessageSorter.Sort(messages, new [] { OrderBy.ReverseArrival });
Assert.AreEqual(2, sorted[0].Index, "Sorting by reverse arrival failed.");
Assert.AreEqual(1, sorted[1].Index, "Sorting by reverse arrival failed.");
Assert.AreEqual(0, sorted[2].Index, "Sorting by reverse arrival failed.");
sorted = MessageSorter.Sort(messages, new [] { OrderBy.Subject });
Assert.AreEqual(0, sorted[0].Index, "Sorting by subject failed.");
Assert.AreEqual(1, sorted[1].Index, "Sorting by subject failed.");
Assert.AreEqual(2, sorted[2].Index, "Sorting by subject failed.");
sorted = MessageSorter.Sort(messages, new [] { OrderBy.ReverseSubject });
Assert.AreEqual(2, sorted[0].Index, "Sorting by reverse subject failed.");
Assert.AreEqual(1, sorted[1].Index, "Sorting by reverse subject failed.");
Assert.AreEqual(0, sorted[2].Index, "Sorting by reverse subject failed.");
sorted = MessageSorter.Sort(messages, new [] { OrderBy.Size });
Assert.AreEqual(1, sorted[0].Index, "Sorting by size failed.");
sorted = MessageSorter.Sort(messages, new [] { OrderBy.Size, OrderBy.Subject });
Assert.AreEqual(1, sorted[0].Index, "Sorting by size+subject failed.");
Assert.AreEqual(0, sorted[1].Index, "Sorting by size+subject failed.");
Assert.AreEqual(2, sorted[2].Index, "Sorting by size+subject failed.");
sorted = MessageSorter.Sort(messages, new [] { OrderBy.ReverseSize, OrderBy.ReverseSubject });
Assert.AreEqual(2, sorted[0].Index, "Sorting by size+subject failed.");
Assert.AreEqual(0, sorted[1].Index, "Sorting by size+subject failed.");
Assert.AreEqual(1, sorted[2].Index, "Sorting by size+subject failed.");
}
private void propagate(SSSPCell cell, bool isActive)
{
//clear
for (int i = 0; i < cell.inNeighborsReceivedStatus.Count; i++)
{
cell.inNeighborsReceivedStatus[i] = false;
}
//cell.receivedNeighborCount = 0;
//send-out
double v = cell.sum / cell.outNeighbors.Count;
MessageSorter sorter = new MessageSorter(cell.outNeighbors);
for (int i = 0; i < Global.SlaveCount; i++)
{
//Console.WriteLine(sorter.GetCellRecipientList(i).Count);
RankUpdatingMessageWriter msg = new RankUpdatingMessageWriter(cell.CellID, isActive, v, sorter.GetCellRecipientList(i));
Global.CloudStorage.RankUpdatingToSlave(i, msg);
}
}
internal void HandlePacket(IPEndPoint remoteEndpoint, byte[] packet)
{
string serializedMessages = GetStringPacket(packet);
var container = JsonConvert.DeserializeObject <Container>(serializedMessages);
if (!_connections.TryGetValue(remoteEndpoint, out TcpConnection connection))
{
return;
}
_connections.RefreshLifeClient(remoteEndpoint);
switch (container.Identifier)
{
case DispatchType.Login:
if (((JObject)container.Payload).ToObject(typeof(LoginRequestContainer)) is LoginRequestContainer loginRequest)
{
LoginResponseContainer loginResponse;
bool isEnter = true;
DispatchType stage;
if (UserOnlineList.Contains(loginRequest.Content))
{
loginResponse = new LoginResponseContainer(
new Response(ResponseType.Failure, $"Client with name '{loginRequest.Content}' yet connect."),
null,
null,
null,
null);
connection.Send(ConvertToBytes(loginResponse.GetContainer()));
connection.Login = $"pseudo-{loginRequest.Content}";
stage = DispatchType.Connection;
}
else
{
isEnter = UserOfflineList.Contains(loginRequest.Content);
loginResponse = new LoginResponseContainer(new Response(ResponseType.Ok, "Connected"), null, null, null, null);
connection.Login = loginRequest.Content;
stage = DispatchType.Login;
}
var eventLogMessage = new EventLogMessage
{
IsSuccessfully = loginResponse.Content.Result == ResponseType.Ok == isEnter,
SenderName = _name,
Text = loginResponse.Content.Reason,
Time = DateTime.Now,
Type = stage
};
ConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(connection.Login, true, eventLogMessage));
}
break;
case DispatchType.Message:
MessageReceivedEventArgs message = MessageSorter.GetSortedMessage((JObject)container.Payload);
MessageReceived?.Invoke(this, message);
Send(MessageSorter.GetSortedMessage(message.Author, message.Message, InterfaceType.Tcp, message.Agenda), message.Agenda);
break;
}
}
