private void initTask(PowerTaskArgs taskArgs, NetworkStream stream, User user)
{
if (!AvailableTasks.ContainsKey(taskArgs.taskName))
{
new PowerMessage(MessageType.TaskInitResult, taskArgs.taskId, Details.NoSuchTask).Serialize(stream);
return;
}
Action <PowerTaskProgress> progressCallback = (taskpower) =>
{
new PowerMessage(MessageType.TaskProgress, taskpower).Serialize(stream);
};
Action <PowerTaskResult> resultCallback = (taskpower) =>
{
//runningTasks.Remove(taskpower.taskId);
new PowerMessage(MessageType.TaskResult, taskpower).Serialize(stream);
};
Action <PowerTaskResult> completeCallback = (taskpower) =>
{
runningTasks.Remove(taskpower.taskId);
usersTasks[user.publicKey].Remove(taskpower.taskId);
new PowerMessage(MessageType.TaskComplete, taskpower).Serialize(stream);
};
Action <PowerTaskError> errorCallback = (taskpower) =>
{
if (taskpower.fatal)
{
runningTasks.Remove(taskpower.taskId);
usersTasks[user.publicKey].Remove(taskpower.taskId);
}
new PowerMessage(MessageType.TaskError, taskpower).Serialize(stream);
};
int id = 0;
while (runningTasks.ContainsKey(id))
{
id++;
}
PowerTaskThread powerThread = new PowerTaskThread(id, taskArgs.taskName, new Thread(() =>
{
PowerTaskFunc powerTaskFunc = AvailableTasks[taskArgs.taskName];
try
{
powerTaskFunc.func(taskArgs, progressCallback, resultCallback, completeCallback, errorCallback);
}
catch (Exception e)
{
errorCallback(new PowerTaskError(id, taskArgs.taskName, true, e));
}
}));
runningTasks[id] = powerThread;
usersTasks[user.publicKey][powerThread.taskId] = powerThread;
powerThread.thread.Start();
//new int[] {task.taskId, id} - here we put 1st is ClientTaskId and 2nd is ServerTaskId
new PowerMessage(MessageType.TaskInitResult, new PowerTaskIds(id, taskArgs.taskName, taskArgs.taskId), Details.Accepted).Serialize(stream);
}
private void clientProccessing(TcpClient client)
{
Byte[] bytes = new Byte[256];
Console.WriteLine("Connected!");
// Get a stream object for reading and writing
NetworkStream stream = client.GetStream();
bool sessionActive = true;
bool authorized = false;
IPEndPoint clientIp = (IPEndPoint)client.Client.RemoteEndPoint;
User user = null;
RSACryptoServiceProvider provider = new RSACryptoServiceProvider(512);
byte[] token = new byte[0];
while (sessionActive)
{
try
{
PowerMessage mess;
try
{
mess = PowerMessage.Deserialize(stream);
}
catch (Exception e)
{
Console.WriteLine("Message deserialize error. Connection was shut down");
client.Close();
stream.Close();
return;
}
switch (mess.messType)
{
case MessageType.Greeting:
new PowerMessage(MessageType.Greeting).Serialize(stream);
break;
case MessageType.EndSession:
Console.WriteLine(clientIp.ToString() + " disconnected");
sessionActive = false;
break;
case MessageType.AuthInit:
//checking if user registered
string publicKeyXML = (string)mess.value;
PowerMessage resMess = new PowerMessage(MessageType.AuthInitResult, Details.NoSuchUser);
if (users.ContainsKey(publicKeyXML))
{
provider.FromXmlString(publicKeyXML);
user = users[publicKeyXML];
resMess.details = Details.UserExists;
//sending token
token = Guid.NewGuid().ToByteArray();
new PowerMessage(MessageType.AuthToken, token).Serialize(stream);
}
resMess.Serialize(stream);
break;
case MessageType.AuthToken:
//verify token
byte[] sign = (byte[])mess.value;
bool success = authorized = provider.VerifyData(token, "SHA256", sign);
Details details = (success) ? Details.Authorised : Details.AuthFailed;
new PowerMessage(MessageType.AuthTokenResult, 0, details).Serialize(stream);
break;
case MessageType.RegistrationRequest:
string pkey = (string)mess.value;
if (users.ContainsKey(pkey))
{
new PowerMessage(MessageType.RegistrationResult, Details.AlreadyRegistered).Serialize(stream);
break;
}
bool toRegistrate = registrate(pkey, clientIp.ToString());
if (toRegistrate)
{
provider.FromXmlString(pkey);
users[pkey] = new User(pkey);
usersTasks[pkey] = new Dictionary <int, PowerTaskThread>();
new PowerMessage(MessageType.RegistrationResult, Details.Success).Serialize(stream);
OnUserRegisteredFinished(this, users[pkey]);
saveConfiguration();
}
else
{
new PowerMessage(MessageType.RegistrationResult, Details.AccessDenied).Serialize(stream);
}
break;
case MessageType.TaskInit:
//task searching
PowerTaskArgs taskArgs = (PowerTaskArgs)mess.value;
initTask(taskArgs, stream, user);
break;
case MessageType.TasksList:
if (!authorized)
{
new PowerMessage(MessageType.TasksList, Details.AccessDenied).Serialize(stream);
break;
}
new PowerMessage(MessageType.TasksList, AvailableTasks, Details.OK).Serialize(stream);
break;
}
}
catch (Exception e)
{
new PowerMessage(MessageType.Error, e).Serialize(stream);
continue;
}
}
client.Close();
}
