public ControllerMain(IModel modelMain, ViewMain viewMain, ViewAddProject viewAdd,
ViewEvaluation viewEvaluation)
{
mModelMain = modelMain;
mViewMain = viewMain;
mViewAddProject = viewAdd;
mViewEvaluation = viewEvaluation;
mViewMain.setController(this);
mViewAddProject.setController(this);
mViewEvaluation.setController(this);
ChangeStatus(ClientStati.NotConnected);
msgClass = new MyMessageClass(mModelMain.MyData.Number);
//CreateChannel();
CreateThreads();
#if TestList
mModelMain.mProjects = new List <Project>()
{
new Project("12345", new TimeSpan(1, 0, 0)),
new Project("23456", new TimeSpan(2, 0, 0)),
new Project("34567", new TimeSpan(3, 0, 0))
};
mViewMain.UpdateProjects(mModelMain.mProjects);
#endif
}
/// <summary>
/// Listens for calls from the clients.
/// </summary>
/// <param name="stateInfo"></param>
static void SocketThread(Object stateInfo)
{
Socket server_TcpSocket = null;
try
{
IPEndPoint server_Address = new IPEndPoint(IPAddress.Any, SERVER_PORT);
server_TcpSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
server_TcpSocket.Bind(server_Address);
byte[] receivedData;
int dataCount;
int index;
string receivedMsg;
typeMessage msgType;
string msgData;
string msgHeader;
MyMessageClass msgClass = new MyMessageClass(SERVER_ID); //-99... Server
byte[] response = new byte[MyMessageClass.BUFFER_SIZE_BYTE];
server_TcpSocket.Listen(10);
while (Run)
{
//Blocking call for accepting requests.
Socket client_TcpSocket = server_TcpSocket.Accept();
//Address of the client:
IPEndPoint client_Address = (IPEndPoint)client_TcpSocket.RemoteEndPoint;
receivedData = new byte[MyMessageClass.BUFFER_SIZE_BYTE];
dataCount = client_TcpSocket.Receive(receivedData);
if (dataCount != 0)
{
receivedMsg = Encoding.ASCII.GetString(receivedData, 0, dataCount);
msgHeader = msgClass.getMessageHeader(receivedMsg);
msgData = msgClass.getMessageData(receivedMsg);
msgType = msgClass.getMessageType(msgHeader);
ClientData client;
switch (msgType)
{
case typeMessage.MSG_CONNECT:
client = msgClass.ParseDataToClientData(msgType, msgData);
client.Number = mServer.ClientNumber;
client.Address = client_Address;
client.Status = ClientStati.Connected;
index = mServer.FindClientIndex(client);
if (index == -1)
{
mServer.AddClient(client);
}
else
{
client = mServer.GetClientList()[index];
}
client.LastHeartBeat = DateTime.Now;
response = msgClass.ConnectResponse(client, mServer.GetProjectListHash());
Console.WriteLine("Client added!");
break;
case typeMessage.MSG_NEWPROJECT:
mServer.AddProject(new Project(msgData));
response = msgClass.NewProjectResponse(mServer.GetProjectListHash());
ProjectListChanged = true;
Console.WriteLine("Project added!");
break;
case typeMessage.MSG_ADDTIME:
Project tmp = msgClass.ParseDataToProject(typeMessage.MSG_ADDTIME, msgData);
response = mServer.UpdateTime(tmp)
? msgClass.AddTimeResponse(mServer.GetProjectListHash())
: msgClass.AddTimeResponseError();
ProjectListChanged = true;
Console.WriteLine("Time added to project!");
break;
case typeMessage.MSG_HEARTBEAT:
client = msgClass.ParseDataToClientData(msgType, msgData);
index = mServer.FindClientIndex(client);
if (index == -1)
{
throw new ArgumentOutOfRangeException();
}
mServer.GetClientList()[index].LastHeartBeat = DateTime.Now;
response = msgClass.HeartBeatResponse(mServer.GetClientList()[index],
mServer.GetProjectListHash());
Console.WriteLine("HeartBeat to Client: " + index);
break;
default:
throw new ArgumentOutOfRangeException();
}
// send response
client_TcpSocket.Send(response, response.Length, SocketFlags.None);
}
client_TcpSocket.Close();
}
}
catch (Exception e)
{
Console.WriteLine("Error:\n" + e.Message);
}
finally
{
server_TcpSocket.Close();
}
}
/// <summary>
/// Thread for a Socket-Connection
/// </summary>
/// <param name="stateInfo"></param>
void SocketThread(Object stateInfo)
{
while (true)
{
string receivedMsg;
string msgHeader;
string msgData;
typeMessage msgType;
ClientData tmp;
switch (mModelMain.MyData.Status)
{
case ClientStati.Connected:
try
{
// if addTime or addProject message is waiting
if (Message != null)
{
receivedMsg = SendToReceiveFromServer(Message);
Message = null;
if (receivedMsg != "")
{
msgHeader = msgClass.getMessageHeader(receivedMsg);
msgData = msgClass.getMessageData(receivedMsg);
msgType = msgClass.getMessageType(msgHeader);
switch (msgType)
{
case typeMessage.MSG_NEWPROJECT:
CheckHashValue();
break;
case typeMessage.MSG_ADDTIME:
CheckHashValue();
break;
case typeMessage.MSG_ADDTIMEERROR:
// @Dominik: is da sunsd nu was zu tun? irgendwie drauf reagieren?
// @Neuwirt: Eventuell in des LOG-File schreibn? und später nochmal probieren?
throw new Exception("Adding time failed");
break;
default:
throw new Exception("Wrong message type received");
}
}
}
// message in file
else if (MessageWaiting)
{
if (File.Exists(FILEPATH))
{
try
{
if (new FileInfo(FILEPATH).Length != 0)
{
List <string> lines = File.ReadAllLines(FILEPATH).ToList();
if (lines.Count != 0)
{
Message = Encoding.ASCII.GetBytes(lines.First());
lines.RemoveAt(0);
File.WriteAllLines(FILEPATH, lines);
}
}
else
{
MessageWaiting = false;
}
}
catch
{
MessageWaiting = false;
throw new Exception("Command file corrupted");
}
}
else
{
MessageWaiting = false;
throw new Exception("Command file missing");
}
}
// else send heartbeat
else
{
byte[] thisData = msgClass.HeartBeatMessage(mModelMain.MyData);
receivedMsg = SendToReceiveFromServer(thisData);
msgHeader = msgClass.getMessageHeader(receivedMsg);
msgData = msgClass.getMessageData(receivedMsg);
msgType = msgClass.getMessageType(msgHeader);
if (msgType == typeMessage.MSG_HEARTBEATRESPONSE)
{
mModelMain.MyData.LastHeartBeat = DateTime.Now;
mModelMain.ServerProjectListHash = msgClass.ParseDataToHashValue(msgType, msgData);
CheckHashValue();
}
else
{
throw new Exception("Disconnected");
}
}
}
catch (Exception e)
{
ChangeStatus(ClientStati.NotConnected);
ShowError(e);
}
break;
default:
byte[] dataToSend = msgClass.ConnectMessage(mModelMain.MyData);
try
{
receivedMsg = SendToReceiveFromServer(dataToSend);
if (receivedMsg != "")
{
msgHeader = msgClass.getMessageHeader(receivedMsg);
msgData = msgClass.getMessageData(receivedMsg);
msgType = msgClass.getMessageType(msgHeader);
if (msgType != typeMessage.MSG_CONNECTRESPONSE)
{
throw new Exception("Wrong message type received");
}
tmp = msgClass.ParseDataToClientData(msgType, msgData);
if (tmp.Name.Equals(mModelMain.MyData.Name))
{
mModelMain.MyData = tmp;
ChangeStatus(ClientStati.Connected);
mModelMain.MyData.LastHeartBeat = DateTime.Now;
mModelMain.ServerProjectListHash = msgClass.ParseDataToHashValue(msgType, msgData);
msgClass = new MyMessageClass(mModelMain.MyData.Number);
CheckHashValue();
}
else
{
throw new Exception("Wrong client number/name!");
}
}
else
{
ChangeStatus(ClientStati.NotConnected);
}
}
catch (Exception e)
{
ChangeStatus(ClientStati.NotConnected);
ShowError(e);
}
break;
}
Thread.Sleep(TIMEOUT);
}
}
static void Main()
{
var msg = new MyMessageClass();
msg.AddMessageAsync("content", TimeSpan.MaxValue, TimeSpan.MaxValue, new CancellationToken());
}
