public void TestUnknownClientExceptionFinishCommunication()
{
//testing only the acks
SimulatedActorSystem system = new SimulatedActorSystem();
Dispatcher dispatcher = new Dispatcher(system, 2);
system.Spawn(dispatcher);
TestClient client = new TestClient();
system.Spawn(client);
dispatcher.Tell(new InitCommunication(client, 10));
while (client.ReceivedMessages.Count == 0)
{
system.RunFor(1);
}
Message initAckMessage = client.ReceivedMessages.Dequeue();
Assert.AreEqual(typeof(InitAck), initAckMessage.GetType());
InitAck initAck = (InitAck)initAckMessage;
Assert.AreEqual(10, initAck.CommunicationId);
SimulatedActor worker = initAck.Worker;
worker.Tell(new FinishCommunication(11));
while (client.ReceivedMessages.Count == 0)
{
system.RunFor(1);
}
}
/// <summary>
/// Constructs a new Worker object
/// </summary>
/// <param name="disp">the dispatcher</param>
/// <param name="messageStore">the message store responsible for persistence</param>
/// <param name="system">the actor system simulation</param>
public Worker(SimulatedActor disp, SimulatedActor messageStore, SimulatedActorSystem system)
{
this.dispatcher = disp;
this.messageStore = messageStore;
this.ongoingCommunications = new Dictionary <long, SimulatedActor>();
this.system = system;
this.stopping = false;
}
/// <summary>
/// Finishes communication with a client and sends a FinishAck message to it.
/// After that other ClientMessage messages, using the communication ID given
/// in the received message, cannot be sent to this worker anymore.
/// </summary>
///
/// <param name="m">non-null message of type FinishCommunication</param>
protected void processFinishCommunication(Message m)
{
FinishCommunication finC = (FinishCommunication)m;
if (!ongoingCommunications.ContainsKey(finC.CommunicationId))
{
throw new UnknownClientException("Unknown communication ID");
}
SimulatedActor client = ongoingCommunications[finC.CommunicationId];
ongoingCommunications.Remove(finC.CommunicationId);
client.Tell(new FinishAck(finC.CommunicationId));
}
/// <summary>
/// Spawns a worker helper which communicates with the message store to add a dislike
/// to a user message given in the message passed as parameter.
/// </summary>
/// <param name="m">non-null message of type Dislike</param>
protected void processDislike(Message m)
{
Dislike like = (Dislike)m;
if (!ongoingCommunications.ContainsKey(like.CommunicationId))
{
throw new UnknownClientException("Unknown communication ID");
}
SimulatedActor client = ongoingCommunications[like.CommunicationId];
MessageStoreMessage message = new AddDislike(like.ClientName, like.MessageId, like.CommunicationId);
WorkerHelper helper = new WorkerHelper(messageStore, client, message, system);
system.Spawn(helper);
}
/// <summary>
/// Constructs a new WorkerHelper object.
/// </summary>
/// <param name="messageStore">message store which receives messages from helper</param>
/// <param name="client">client to which the message from the store gets forwarded</param>
/// <param name="message">the message to be sent to the message store</param>
/// <param name="system">actor system used to stop the helper</param>
public WorkerHelper(SimulatedActor messageStore, SimulatedActor client, MessageStoreMessage message, SimulatedActorSystem system)
{
this.message = message;
this.message.StoreClient = this;
this.messageStore = messageStore;
this.client = client;
this.system = system;
this.timeSinceLastSent = 0;
this.stopping = false;
this.retries = 0;
// good connection between WorkerHelper and MessageStore -> no delay
this.channel = new DeterministicChannel(0);
}
/// <summary>
/// Spawns a worker helper which communicates with the message store to retrieve
/// messages of the author given in the message passed as parameter.
/// </summary>
/// <param name="m">non-null message of type RetrieveMessages</param>
protected void processRetrieveMessages(Message m)
{
RetrieveMessages retrMessages = (RetrieveMessages)m;
if (!ongoingCommunications.ContainsKey(retrMessages.CommunicationId))
{
throw new UnknownClientException("Unknown communication ID");
}
SimulatedActor client = ongoingCommunications[retrMessages.CommunicationId];
MessageStoreMessage message = new RetrieveFromStore(retrMessages.Author, retrMessages.CommunicationId);
WorkerHelper helper = new WorkerHelper(messageStore, client, message, system);
system.Spawn(helper);
}
public void TestCommunication()
{
//testing only the acks
SimulatedActorSystem system = new SimulatedActorSystem();
Dispatcher dispatcher = new Dispatcher(system, 2);
system.Spawn(dispatcher);
TestClient client = new TestClient();
system.Spawn(client);
// send request and run system until a response is received
// communication id is chosen by clients
dispatcher.Tell(new InitCommunication(client, 10));
while (client.ReceivedMessages.Count == 0)
{
system.RunFor(1);
}
Message initAckMessage = client.ReceivedMessages.Dequeue();
Assert.AreEqual(typeof(InitAck), initAckMessage.GetType());
InitAck initAck = (InitAck)initAckMessage;
Assert.AreEqual(10, initAck.CommunicationId);
SimulatedActor worker = initAck.Worker;
initAck.Worker.Tell(new FinishCommunication(10));
while (client.ReceivedMessages.Count == 0)
{
system.RunFor(1);
}
Message finAckMessage = client.ReceivedMessages.Dequeue();
Assert.AreEqual(typeof(FinishAck), finAckMessage.GetType());
FinishAck finAck = (FinishAck)finAckMessage;
Assert.AreEqual(10, finAck.CommunicationId);
dispatcher.Tell(new Stop());
// TODO run system until workers and dispatcher are stopped
int endtime = system.currentTime + 20;
system.RunUntil(endtime);
Assert.AreEqual(system.currentTime, endtime + 1);
}
public void test_setup()
{
//Testclient 1
testclient_ = new TestClient();
system_.Spawn(testclient_);
dispatcher_.Tell(new InitCommunication(testclient_, 10));
while (testclient_.ReceivedMessages.Count == 0)
{
system_.RunFor(1);
}
Message initAckMessage = testclient_.ReceivedMessages.Dequeue();
InitAck initAck = (InitAck)initAckMessage;
worker_ = initAck.Worker;
}
public void TestMessageDrop()
{
SimulatedActor[] workers = new SimulatedActor[10];
TestClient[] clients = new TestClient[10];
for (int i = 0; i < 10; i++)
{
clients[i] = new TestClient();
system_.Spawn(clients[i]);
dispatcher_.Tell(new InitCommunication(clients[i], i + 12));
while (clients[i].ReceivedMessages.Count == 0)
{
system_.RunFor(1);
}
Message initAckMessage = clients[i].ReceivedMessages.Dequeue();
Assert.AreEqual(typeof(InitAck), initAckMessage.GetType());
InitAck initAck = (InitAck)initAckMessage;
Assert.AreEqual(i + 12, initAck.CommunicationId);
workers[i] = initAck.Worker;
}
int j = 0;
foreach (SimulatedActor worker in workers)
{
worker.Tell(new Like("group-16", 12 + j, 1));
j++;
}
for (int i = 0; i < 10; i++)
{
while (clients[i].ReceivedMessages.Count == 0)
{
system_.RunFor(1);
}
Message failedMessage = clients[i].ReceivedMessages.Dequeue();
if (failedMessage.GetType() != typeof(OperationAck))
{
Assert.AreEqual(typeof(OperationFailed), failedMessage.GetType());
}
}
}
/// <summary>
/// In stopping mode, InitCommunication always fail, which is signal
/// using an OperationFailed message sent to the client.
/// In this mode, only StopAck-messages are expected and if all stop acknowledgements
/// have been collected, the Dispatcher stop itself.
/// </summary>
/// <param name="m">non-null message received</param>
private void Stopping(Message m)
{
if (m is InitCommunication)
{
InitCommunication initM = ((InitCommunication)m);
initM.Client.Tell(new OperationFailed(initM.CommunicationId));
}
else if (m is StopAck)
{
SimulatedActor actor = ((StopAck)m).Sender;
acksToCollect.Remove(actor.Id);
system.Stop(actor);
if (acksToCollect.Count == 0)
{
system.Stop(messageStore);
system.Stop(this);
}
}
}
/// <summary>
/// Performs checks on a user message, which should be published. If the
/// checks are passed, a worker helper is spawned, which communicates with
/// the message store to store the new user message.
/// New messages must have zero likes, must not have a message ID assigned
/// and must not be (strictly) longer than 10 characters.
/// Only 10 characters are allowed to to alleviate exercise 4.
/// </summary>
/// <param name="m">non-null message of type Publish</param>
protected void processPublish(Message m)
{
Publish publish = (Publish)m;
if (!ongoingCommunications.ContainsKey(publish.CommunicationId))
{
throw new UnknownClientException("Unknown communication ID");
}
SimulatedActor client = ongoingCommunications[publish.CommunicationId];
UserMessage userMessage = publish.Message;
if (userMessage.Likes.Count > 0 || userMessage.Dislikes.Count > 0 || userMessage.MessageId != UserMessage.NEW ||
userMessage.Message.Length > 10)
{
client.Tell(new OperationFailed(publish.CommunicationId));
}
else
{
MessageStoreMessage message = new UpdateMessageStore(userMessage, publish.CommunicationId);
WorkerHelper helper = new WorkerHelper(messageStore, client, message, system);
system.Spawn(helper);
}
}
public StopAck(SimulatedActor sender)
{
Sender = sender;
}
public InitAck(SimulatedActor worker, long communicationId)
{
this.Worker = worker;
this.CommunicationId = communicationId;
}
public InitCommunication(SimulatedActor client, long communicationId)
{
this.Client = client;
this.CommunicationId = communicationId;
}