private static void ConnectServiceCallback(IAsyncResult ar)
{
try
{
ServiceSocket.EndConnect(ar);
MessageSocket.BeginConnect(IPAddress.Loopback, MessagePort, ConnectMessageCallback, null);
}
catch (SocketException)
{
Console.WriteLine("Connection was not established!");
}
Console.WriteLine("ServiceSocket Connected");
SocketCommands.Write(ServiceSocket, _client);
while (_client.Guid == Guid.Empty)
{
var socketModel = SocketCommands.Read(ServiceSocket);
_client.Guid = socketModel.Guid;
foreach (var message in socketModel.Message)
{
Console.WriteLine(message);
}
}
}
private void OnConnectMaster(IAsyncResult ar)
{
try
{
masterSocket.EndConnect(ar);
btn_Refresh.Load("base/misc/btn_refresh.png");
//btnOK.Enabled = false;
byte[] b = new byte[1];
b[0] = 102;
//Send the message to the server
masterSocket.BeginSend(b, 0, b.Length, SocketFlags.None, new AsyncCallback(OnSendMaster), null);
masterSocket.BeginReceive(byteData, 0, byteData.Length, SocketFlags.None, new AsyncCallback(OnReceiveServerList), null);
}
catch (Exception ex)
{
if (Program.debug)
{
MessageBox.Show("Unable to connect to the masterserver:\r\n" + ex.Message + "\r\n" + ex.StackTrace.ToString(), "AODXClient", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
private void ConnectComplete(IAsyncResult ar)
{
Socket tempSok = (Socket)(ar.AsyncState);
// See if connection complete
try
{
tempSok.EndConnect(ar);
_socketPass(tempSok);
DialogResult = DialogResult.OK;
}
catch (Exception err)
{
try
{
Invoke(new Action(FailedConnect));
}
catch (Exception er)
{
Console.WriteLine(er.Message);
}
Console.WriteLine(err.Message);
}
}
public static bool Connect()
{
m_ServerHost = NewConfig.ServerHost;
m_ServerPort = NewConfig.ServerPort;
try
{
Debug.Try("Parsing IP ( \"{0}\" )", m_ServerHost);
m_ServerIP = IPAddress.Parse(m_ServerHost);
m_ServerIPEP = new IPEndPoint(m_ServerIP, m_ServerPort);
Debug.EndTry("( {0} )", m_ServerIPEP);
}
catch
{
Debug.FailTry();
try
{
Debug.Try("Resolving");
IAsyncResult asyncResult = Dns.BeginResolve(m_ServerHost, null, null);
do
{
Engine.DrawNow();
}while (!asyncResult.AsyncWaitHandle.WaitOne(10, false));
IPHostEntry entry = Dns.EndResolve(asyncResult);
if (entry.AddressList.Length == 0)
{
Debug.FailTry("( AddressList is empty )");
return(false);
}
m_ServerIP = entry.AddressList[0];
m_ServerIPEP = new IPEndPoint(m_ServerIP, m_ServerPort);
Debug.EndTry("( {0} )", m_ServerIPEP);
}
catch (Exception exception)
{
Debug.FailTry();
Debug.Error(exception);
return(false);
}
}
Flush();
Engine.ValidateHandlers();
m_Server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Debug.Try("Connecting to login server '{0}'", m_ServerIPEP);
try
{
IAsyncResult result2 = m_Server.BeginConnect(m_ServerIPEP, null, null);
do
{
Engine.DrawNow();
}while (!result2.AsyncWaitHandle.WaitOne(10, false));
m_Server.EndConnect(result2);
}
catch (Exception exception2)
{
Debug.FailTry();
Debug.Error(exception2);
return(false);
}
Debug.EndTry();
return(true);
}
/// <summary>
/// Просим другого клиента выполнить часть работы
/// </summary>
/// <param name="ipAddress">ip адрес другого клиента</param>
/// <param name="port">Порт другого клиента</param>
/// <param name="messageData">Часть работы</param>
void SendPartWorkToClient(string ipAddress, int port, MessageData messageData)
{
Socket socket = null;
try
{
IPEndPoint ipPoint = new IPEndPoint(IPAddress.Parse(ipAddress), port);
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// подключаемся к другому клиенту
IAsyncResult result = socket.BeginConnect(ipAddress, port, null, null);
bool success = result.AsyncWaitHandle.WaitOne(1000, true);
if (socket.Connected)
{
socket.EndConnect(result);
//отправляем клиенту данные для решения задачи
socket.Send(HelperClass.ObjectToByteArray(
new Message
{
Command = Command.Work,
Data = messageData,
}));
//добавляем в список сокетов клиентов новый
clientsSockets.TryAdd(ipAddress, socket);
clientsWorks.TryAdd(ipAddress, messageData);
//ждем ответ на подзадачу
var answer = (Answer)HelperClass.ByteArrayToObject(HelperClass.RecieveMessage(socket));
if (answer.DoneWork)
{
answersValues.Add(answer.Value);
}
CurrentForm.output.BeginInvoke(new InvokeDelegate(
() =>
{
CurrentForm.output.Text += $"\nКлиент {ipAddress} решил подзадачу и получил ответ {answer.Value}";
}));
Console.WriteLine($"\nКлиент {ipAddress} решил подзадачу и получил ответ {answer.Value}");
}
else
{
//socket.Close();
//CurrentForm.output.BeginInvoke(new InvokeDelegate(
//() =>
//{
// CurrentForm.output.Text += $"\nКлиент {ipAddress} не смог решить свою часть задачи";
//}));
//Console.WriteLine($"\nКлиент {ipAddress} не смог решить свою часть задачи");
////надо переназначить часть работы кому-то другому
//MessageData messageData1 = null;
//if (clientsWorks.TryGetValue(ipAddress, out messageData1))
// RunPartOwnWork(messageData1);
}
}
catch
{
socket.Close();
CurrentForm.output.BeginInvoke(new InvokeDelegate(
() =>
{
CurrentForm.output.Text += $"\nКлиент {ipAddress} не смог решить свою часть задачи";
}));
Console.WriteLine($"\nКлиент {ipAddress} не смог решить свою часть задачи");
//если другой клиент не смог взять задачу на себя
MessageData messageData1 = null;
if (clientsWorks.TryGetValue(ipAddress, out messageData1))
{
//clientsWorks.TryRemove(ipAddress, out messageData1);
bool resendedToClient = false;
foreach (var otherClientIp in otherClients.Keys)
{
//если клиент не работает над задачей
if (!clientsWorks.ContainsKey(otherClientIp))
{
resendedToClient = true;
CurrentForm.output.BeginInvoke(new InvokeDelegate(
() =>
{
IPEndPoint endPoint = null;
otherClients.TryGetValue(otherClientIp, out endPoint);
CurrentForm.output.Text += $"\nКлиент {endPoint.Address} взял задачу клиента {ipAddress}";
}));
SendPartWorkToClient(otherClientIp, Configs.ClientPort, messageData1);
return;
}
}
if (!resendedToClient)
{
RunPartOwnWork(messageData1);
}
}
}
}
private static void Connected(IAsyncResult iar)
{
Socket client = (Socket)iar.AsyncState;
client.EndConnect(iar);
}
private void XuLyKetNoi(IAsyncResult ar)
{
client.EndConnect(ar);
labelStatusClient.Text = "Connect";
labelStatusClient.ForeColor = Color.Green;
}
public static void Main(string[] args)
{
// установка вывода и ввода звука
WaveOut.DesiredLatency = 1000 / SendingFrequency;
WaveOut.Init(BufferedWaveProvider);
WaveIn.DeviceNumber = 0;
WaveIn.BufferMilliseconds = 1000 / SendingFrequency;
WaveIn.WaveFormat = RecordingFormat;
WaveIn.DataAvailable += WaveIn_DataAvailable;
// установка подключения
string host; // хост подключения
int port; // порт подключения
if (true)
{
host = "127.0.0.1";
port = 11771;
}
else
{
Console.WriteLine("Please enter host ip:port - ");
string line = Console.ReadLine();
var tokens = line.Split(':');
host = tokens[0];
port = int.Parse(tokens[1]);
}
var hostIpAddress = IPAddress.Parse(host);
var connectResult = MainSocket.BeginConnect(hostIpAddress, port, ar => { }, null);
// Пробуем подключиться в течение 5 секунд
bool connectFinished = connectResult.AsyncWaitHandle.WaitOne(5000, true);
// если получилось подключиться
if (connectFinished && MainSocket.Connected)
{
MainSocket.EndConnect(connectResult);
Console.WriteLine("MainSocket Connected");
IsSocketConnected = true;
// начинаем приём от сервера
MainSocket.BeginReceive(MainSocketBuffer, 0, SendingBufferSize, SocketFlags.None,
OnSocketEndReceive,
null);
}
else
{
// если не получилось подключиться
MainSocket.Close();
Console.WriteLine("Unable to connect");
}
if (IsSocketConnected)
{
// запускаем потоки
Thread recordThread = new Thread(RecordThreadJob);
recordThread.Start();
RecordResetEvent.Set();
Thread playThread = new Thread(PlayThreadJob);
playThread.Start();
// запускаем воспроизведение
PlayResetEvent.Set();
Thread sendThread = new Thread(SendThreadJob);
sendThread.Start();
Console.ReadKey();
RecordResetEvent.Set();
playThread.Abort();
sendThread.Abort();
FlushBuffers();
}
else
{
Console.ReadKey();
}
}
