public async void CreateConnect2(string addressConnectIP, string key,
CancellationToken cancellationToken = default(CancellationToken))
{
Socket socketClient = null;
Socket listener = null;
Socket socketSender = null;
//Znajac dlugosc slowa "Sending" pobieram z calej nazwy klucza tylko index, ktory wykorzystam aby dopasowac do socketu IN
///1-Router
///2-Client
///3-NMS
string typeOfSocket = key.Substring(8, key.Length - 8);
string numberOfRouter = key.Substring(0, 1);
//Sklejenie czesci wspolnej klucza dla socketu OUT oraz indeksu
string settingsString = numberOfRouter + "Listener" + typeOfSocket;
IPAddress ipAddress =
ipAddress = IPAddress.Parse(OperationConfiguration.getSetting(settingsString, mySettings));
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);
// Create a TCP/IP socket.
listener = new Socket(ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
if (!listener.IsBound)
{
//zabindowanie na sokecie punktu koncowego
listener.Bind(localEndPoint);
listener.Listen(100);
}
//Dodanie socketu do listy socketow OUT
socketSendingList.Add(sS.ConnectToEndPoint(addressConnectIP));
//oczekiwanie na polaczenie
socketClient = listener.Accept();
//dodanie do listy sluchaczy po przez delegata
socketListenerList.Add(socketClient);
Listening = true;
string tmp = string.Empty;
//wyznaczenie socketu przez ktory wyslana zostanie wiadomosc
if (numberOfRouter == "1")
{
tmp = "127.0.0.12";
}
else if (numberOfRouter == "2")
{
tmp = "127.0.0.10";
}
else if (numberOfRouter == "3")
{
tmp = "127.0.0.8";
}
//Ustalenie socketa wysylajacego
foreach (var socket in socketSendingList)
{
//zwracamy socket jeśli host z ktorym sie laczy spelnia warunek zgodnosci adresow z wynikiem kierowania lacza
if (takingAddresSendingSocket(socket) == tmp)
{
//Socket wysylajacy
socketSender = socket;
}
}
//Uruchomienie timera
Task.Run(async() => await timer());
//Uruchomienie sluchania i wypelniania bufora
Task.Run(async() => await receiveMessage(socketClient)).Wait();
//Uruchomione zdejmowanie z bufora wejsciowego, podmiana naglowkow, wrzucenie do bufora wyjsciowego
// Task.Run(async () =>await commutePackets());
//Uruchomione oproznianie bufora wyjsciowego (po timeoucie lub wypelnieniu bufora) i wysylanie pakietow
// Task.Run(async () =>await sendPackage(socketSender)).Wait();
}
/// <summary>
/// </summary>
/// <param name="adresIPListener">Parametrem jest adres IP na ktorym nasluchujemy </param>
/// /// <param name="key">Parametrem jest warotsc klucza wlasnosci z pliku config </param>
public void CreateConnect(string addressConnectIP, string key, CancellationToken cancellationToken = default(CancellationToken))
{
Socket socketClient = null;
Socket listener = null;
try
{
byte[] bytes = new Byte[128];
Task.Run(async() =>
{
Stopwatch sw = Stopwatch.StartNew();
while (true)
{
if (zeroTimer == true)
{
sw = Stopwatch.StartNew();
canIClearMyBuffers = false;
zeroTimer = false;
}
var wait = await Task.Run(async() =>
{
await Task.Delay(500);
sw.Stop();
return(sw.ElapsedMilliseconds);
});
canIClearMyBuffers = true;
}
});
//Znajac dlugosc slowa "Sending" pobieram z calej nazwy klucza tylko index, ktory wykorzystam aby dopasowac do socketu IN
///1-Router
///2-Client
///3-NMS
string typeOfSocket = key.Substring(8, key.Length - 8);
string numberOfRouter = key.Substring(0, 1);
//Sklejenie czesci wspolnej klucza dla socketu OUT oraz indeksu
string settingsString = numberOfRouter + "Listener" + typeOfSocket;
IPAddress ipAddress =
ipAddress = IPAddress.Parse(OperationConfiguration.getSetting(settingsString, mySettings));
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);
// Create a TCP/IP socket.
listener = new Socket(ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
if (!listener.IsBound)
{
//zabindowanie na sokecie punktu koncowego
listener.Bind(localEndPoint);
listener.Listen(100);
}
//Nasluchujemy bez przerwy
while (Last)
{
if (Listening)
{
//Dodanie socketu do listy socketow OUT
socketSendingList.Add(sS.ConnectToEndPoint(addressConnectIP));
//oczekiwanie na polaczenie
socketClient = listener.Accept();
//dodanie do listy sluchaczy po przez delegata
socketListenerList.Add(socketClient);
Socket send = null;
Listening = false;
string tmp = string.Empty;
//wyznaczenie socketu przez ktory wyslana zostanie wiadomosc
if (numberOfRouter == "1")
{
tmp = "127.0.0.12";
}
else if (numberOfRouter == "2")
{
tmp = "127.0.0.10";
}
else if (numberOfRouter == "3")
{
tmp = "127.0.0.8";
}
//Oczekiwanie w petli na przyjscie danych
while (true)
{
byte[] msg;
string from = string.Empty;
//Odebranie tablicy bajtow na obslugiwanym w watku sluchaczu
msg = sl.ProcessRecivedBytes(socketClient);
stateReceivedMessageFromCableCloud(msg, socketClient);
// Package.extractHowManyPackages(msg);
// listByte.Add(msg);
//Wykonuje jezeli nadal zestawione jest polaczenie
if (socketClient.Connected)
{
//Uzyskanie czestotliwosci zawartej w naglowku- potrzebna do okreslenia ktorym laczem idzie wiadomosc
portNumber = Package.extractPortNumber(msg);
from = takingAddresListenerSocket(socketClient) + " " + portNumber;
Package p = new Package(msg);
foreach (var socket in socketSendingList)
{
//zwracamy socket jeśli host z ktorym sie laczy spelnia warunek zgodnosci adresow z wynikiem kierowania lacza
if (takingAddresSendingSocket(socket) == tmp)
{
send = socket;
}
}
List <Queue <byte[]> > listOfQueue = new List <Queue <byte[]> >();
List <Queue <byte[]> > listOfQueues = commutationField.processPackage(msg);
//Jak zwrocila null to jeszcze bufor nie jest pelny
if (listOfQueues == null)
{
/* if (canIClearMyBuffers == true)
* {
* byte[] tempBufferIn;
* for (int z = 0; z < commutationField.bufferIn.queue.Count; z++)
* {
* while (commutationField.bufferIn.queue.Count > 0)
* {
* tempBufferIn = commutationField.bufferIn.queue.Dequeue();
* byte[] obytes = commutationField.borderNodeCommutationTable.changePackageHeader2(tempBufferIn, ref commutationField);
*
* stateSendingMessageToCableCloud(obytes, send);
* sS.SendingPackageBytes(send, obytes);
* }
* }
* canIClearMyBuffers = false;
* zeroTimer = true;
*
* }*/
continue;
}//w przeciwnym razie zwraca nam liste kolejek
else
{
for (int i = 0; i < listOfQueues.Count; i++)
{
//Dopoki cos jest w podkolejce
while (listOfQueues[i].Count != 0)
{
//Element z listy kolejek moze byc nullem
if (listOfQueues[i].Count != 0)
{
stateSendingMessageToCableCloud(listOfQueues[i].Peek(), send);
//Zdjecie z kolejki pakietu i wyslanie go
sS.SendingPackageBytes(send, listOfQueues[i].Dequeue());
}
//A jak jest nullem to nic nie robimy
}
}
}
}
else
{
//Jezeli host zerwie polaczneie to usuwamy go z listy przetrzymywanych socketow, aby rozpoczac proces nowego polaczenia
int numberRemove = socketListenerList.IndexOf(socketClient);
socketListenerList.RemoveAt(numberRemove);
socketSendingList.RemoveAt(numberRemove);
break;
}
}
Listening = true;
}
}
}
catch (SocketException se)
{
Console.WriteLine($"Socket Exception: {se}");
}
finally
{
// StopListening();
}
if (socketClient == null)
{
}
}
/// <summary>
/// Funkcja sluży do
/// Zwraca socket
/// </summary>
/// <param name="adresIPListener">Parametrem jest adres IP na ktorym nasluchujemy </param>
/// /// <param name="key">Parametrem jest warotsc klucza wlasnosci z pliku config </param>
private static Socket ListenAsync(string adresIPListener, string key, CancellationToken cancellationToken = default(CancellationToken))
{
Socket socketClient = null;
Socket listener = null;
IPAddress ipAddress =
ipAddress = IPAddress.Parse(adresIPListener);
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);
cancellationToken.ThrowIfCancellationRequested();
try
{
byte[] bytes = new Byte[1024];
// Create a TCP/IP socket.
listener = new Socket(ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
if (!listener.IsBound)
{
//zabindowanie na sokecie punktu koncowego
listener.Bind(localEndPoint);
listener.Listen(100);
}
cancellationToken.ThrowIfCancellationRequested();
//Nasluchujemy bez przerwy
while (Last)
{
if (Listening)
{
//oczekiwanie na polaczenie
socketClient = listener.Accept();
//dodanie do listy sluchaczy po przez delegata
sd(socketClient);
Socket send = null;
//Znajac dlugosc slowa "Listener" pobieram z calej nazwy klucza tylko index, ktory wykorzystam aby dopasowac do socketu OUT
string str = key.Substring(8, key.Length - 8);
//Sklejenie czesci wspolnej klucza dla socketu OUT oraz indeksu
string settingsString = "Sending" + str;
//Dodanie socketu do listy socketow OUT
socketSendingList.Add(sS.ConnectToEndPoint(OperationConfiguration.getSetting(settingsString, readSettings)));
Listening = false;
LingerOption myOpts = new LingerOption(true, 1);
socketClient.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, myOpts);
socketClient.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, false);
socketClient.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
Console.WriteLine("Polaczenie na " + takingAddresListenerSocket(socketClient));
string fromAndFrequency;
//Oczekiwanie w petli na przyjscie danych
while (true)
{
//Odebranie tablicy bajtow na obslugiwanym w watku sluchaczu
msg = sl.ProcessRecivedBytes(socketClient);
// Package.extractHowManyPackages(msg);
// listByte.Add(msg);
//Wykonuje jezeli nadal zestawione jest polaczenie
if (socketClient.Connected)
{
stateReceivedMessage(msg, socketClient);
//Uzyskanie czestotliwosci zawartej w naglowku- potrzebna do okreslenia ktorym laczem idzie wiadomosc
frequency = Package.extractPortNumber(msg);
fromAndFrequency = takingAddresListenerSocket(socketClient) + " " + frequency;
//wyznaczenie socketu przez ktory wyslana zostanie wiadomosc
send = sendingThroughSocket(fromAndFrequency);
stateSendingMessage(msg, send, fromAndFrequency);
//wyslanei tablicy bajtow
sS.SendingPackageBytes(send, msg);
}
else
{
//Jezeli host zerwie polaczneie to usuwamy go z listy przetrzymywanych socketow, aby rozpoczac proces nowego polaczenia
int numberRemove = socketListenerList.IndexOf(socketClient);
socketListenerList.RemoveAt(numberRemove);
socketSendingList.RemoveAt(numberRemove);
break;
}
}
Listening = true;
}
}
}
catch (SocketException se)
{
Console.WriteLine($"Socket Exception: {se}");
}
finally
{
// StopListening();
}
if (socketClient == null)
{
return(new Socket(ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp));
}
return(socketClient);
}
/// <summary>
/// Funkcja uruchamiana w momencie naciśnięcia przycisku połączenie z chmura
/// </summary>
/// <param name="sender">Obiekt, który odpowiedzialny jest za wysłanie eventu</param>
/// <param name="e">Otrzymany event po naciśnięciu przycisku</param>
private void buttonConnectToCloud_Click(object sender, EventArgs e)
{
if (buttonConnectToCloudClicked == false)
{
buttonConnectToCloud.Enabled = false;
buttonConnectToCloudClicked = true;
//Pobranie indeksu na którym w liście znajduje się IP naszej klienckiej aplikacji
int cloudipindex = clientsiplist.IndexOf(_ClientApplication.ClientIP);
//Pobranie IP chmury z listy
string cloudIP = cloudsiplist[cloudipindex];
try
{
//Próba połączenia się z IP chmury, z którego bedziemy nasłuchiwali wiadomości
send = sS.ConnectToEndPoint(cloudIP);
if (send.Connected)
{
//Uruchomienie nasłuchiwania w aplikacji klienckiej
socket = sl.ListenAsync(_ClientApplication.ClientIP);
Task.Run(() =>
{
while (true)
{
byte[] messagebytes;
List <byte[]> packages = new List <byte[]>();
//Zamienienie odebranej wiadomości na tablicę bajtów
messagebytes = sl.ProcessRecivedBytes(socket);
//Utowrzenie znacznika czasowego
int numberOfPackages = 1;
string timestamp2 = Timestamp.generateTimestamp();
string message = null;
short howManyPackages = Package.extractHowManyPackages(messagebytes);
short frameID = Package.extractID(messagebytes);
packages.Add(messagebytes);
if (howManyPackages >= 2)
{
for (int i = 1; i < howManyPackages; i++)
{
messagebytes = null;
messagebytes = sl.ProcessRecivedBytes2(socket);
if (messagebytes == null)
{
break;
}
packages.Add(messagebytes);
numberOfPackages++;
}
//Utowrzenie znacznika czasowego
string timestamp = Timestamp.generateTimestamp();
//Sortowanie paczek, jakby przy odbiorze paczki zamieniły się miejscami
for (int i = 0; i < packages.Count - 1; i++)
{
if (Package.extractPackageNumber(packages[i]) > Package.extractPackageNumber(packages[i + 1]))
{
byte[] tmp = packages[i];
packages[i] = packages[i + 1];
packages[i + 1] = tmp;
}
}
for (int i = 0; i < packages.Count(); i++)
{
message = message + Package.extractUsableMessage(packages[i], Package.extractUsableInfoLength(packages[i]));
}
//Odpakowanie adresy nadawcy z otrzymanej wiadomości
string sourceIp = Package.exctractSourceIP(messagebytes).ToString();
_ClientApplication.updateReceivedMessageTextBox(sourceIp + ": " + message);
_ClientApplication.updateReceivedMessageTextBox("\r\n");
_ClientApplication.updateLogTextBox("[" + timestamp + "] == RECEIVED MESSAGE in " + numberOfPackages + " packages from " + howManyPackages + " == S_ClientIP: " + sourceIp);
message = null;
messagebytes = null;
packages = null;
}
else
{
//Odpakowanie adresy nadawcy z otrzymanej wiadomości
string sourceIp = Package.exctractSourceIP(messagebytes).ToString();
//Stworzenie wiadomości, która zostanie wyświetlona na ekranie - odpakowanie treści wiadomości z paczki
string message2 = sourceIp + ": " + Package.extractUsableMessage(messagebytes, Package.extractUsableInfoLength(messagebytes));
//Pojawienie się informacji o otrzymaniu wiadomości
_ClientApplication.updateLogTextBox("[" + timestamp2 + "] == RECEIVED MESSAGE == S_ClientIP: " + sourceIp);
//Zauktualizowanie wiadomości w polu ReceivedMessage
_ClientApplication.updateReceivedMessageTextBox(message2);
_ClientApplication.updateReceivedMessageTextBox("\r\n");
message2 = null;
messagebytes = null;
}
}
});
}
else
{
throw new NullReferenceException();
buttonConnectToCloud.Enabled = true;
buttonConnectToCloudClicked = false;
}
}
catch (Exception err)
{
MessageBox.Show("Unable to connect to the Network Host!", "Attention!");
}
}
}
public void CreateConnect(string addressConnectIP, string key, CancellationToken cancellationToken = default(CancellationToken))
{
Socket socket = null;
Socket listenerAgent = null;
Socket agentSending = null;
try
{
byte[] bytes = new Byte[128];
string numberOfRouter = key.Substring(0, 1);
//Sklejenie czesci wspolnej klucza dla socketu OUT oraz indeksu
string settingsString = numberOfRouter + "Agent";
IPAddress ipAddress =
ipAddress = IPAddress.Parse(OperationConfiguration.getSetting(settingsString, mySettings));
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);
// Create a TCP/IP socket.
listenerAgent = new Socket(ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
if (!listenerAgent.IsBound)
{
//zabindowanie na sokecie punktu koncowego
listenerAgent.Bind(localEndPoint);
listenerAgent.Listen(100);
}
int milliseconds = 100;
//Nasluchujemy bez przerwy
while (Last)
{
if (Listening)
{
//Dodanie socketu do listy socketow OUT
agentSending = sS.ConnectToEndPoint(addressConnectIP);
Thread.Sleep(milliseconds);
SendingNodeIsUpMessage(agentSending, OperationConfiguration.getSetting(settingsString, mySettings), Int16.Parse(numberOfRouter));
//oczekiwanie na polaczenie
socket = listenerAgent.Accept();
SendingKeepAliveMessage(OperationConfiguration.getSetting(settingsString, mySettings), agentSending);
Listening = false;
/* LingerOption myOpts = new LingerOption(true, 1);
* socketClient.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, myOpts);
* socketClient.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, false);
* socketClient.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);*/
Console.WriteLine("Connect on port " + NetworkNode.takingAddresListenerSocket(socket));
byte[] msg;
if (socket.Connected)
{
//Oczekiwanie w petli na przyjscie danych
while (true)
{
string from = string.Empty;
//Odebranie tablicy bajtow na obslugiwanym w watku sluchaczu
msg = sl.ProcessRecivedBytes3(socket);
NMSPackage package = new NMSPackage();
string usableMessage = NMSPackage.extractUsableMessage(msg, NMSPackage.extractUsableInfoLength(msg));
Console.WriteLine(usableMessage);
fillingTable(usableMessage, agentSending, settingsString);
// Package.extractHowManyPackages(msg);
// listByte.Add(msg);
//Wykonuje jezeli nadal zestawione jest polaczenie
if (msg == null)
{
//Rozpoczynamy proces nowego polaczenia
break;
}
}
}
}
ConsoleKeyInfo cki;
while (true)
{
cki = Console.ReadKey();
if (cki.Key == ConsoleKey.Escape)
{
break;
}
}
}
}
catch (SocketException se)
{
Console.WriteLine($"Socket Exception: {se}");
}
finally
{
// StopListening();
}
if (socket == null)
{
}
}
/// <summary>
/// funkcja obsługująca przychodzącą wiadomość
/// </summary>
/// <param name="listener"></param>
private void ReceivedMessage(Socket listener)
{
string usableMessage = "";
while (true)
{
// wyczyszczenie paczki przed jej wysłaniem oraz przed ponownym wysyłaniem
usableMessage = string.Empty;
//przypisywanie do paczki wiadomości przesłanej przez klienta, w tym przypadku przez agenta
byte[] nmspackage = new byte[64];
// tylko jeden wątek moze wykonywac ten kod w danym czasie
// lock (_syncRoot)
// {
nmspackage = ls.ProcessRecivedByteMessage(listener);
// }
// wykonuje się tylko wtedy jeśli agent nie jest podłączony
if (!listener.Connected)
{
// pobranie indeksu socketu z listy soecketów
int index = listening_socket.IndexOf(listener);
UpdateListBoxReceived("Network Node" + getIPAddressRemote(sends_socket.ElementAt(index)) + " is disconnected");
// rozłączanie obu socketów
listener.Disconnect(true);
//send.Disconnect(true);
//usuwanie socketów, adresów z list by przy ponownym połączeniu dodawać je na ponownie
listening_socket.RemoveAt(index);
sends_socket.RemoveAt(index);
routers_IP.RemoveAt(index);
// wyświetlanie pobranego adresu IP z list podłączonych agentów
_Application.comboBoxRouters.Invoke(new Action(delegate()
{
comboBoxRouters.Items.RemoveAt(index);
}));
break;
}
// wykonuje się tylko wtedy jeśli agent jest podłączony
else
{
string sourceip;
//tylko jesli paczka nie jest nullem
if (nmspackage != null)
{
usableMessage = NMSPackage.extractUsableMessage(nmspackage, NMSPackage.extractUsableInfoLength(nmspackage));
//tylko w przypadku pierwszej wiadomości od danego agenta
if (usableMessage == "Network node is up")
{
sourceip = NMSPackage.exctractSourceIP(nmspackage).ToString();
//jesli lista z adresami IP routerów nie zawiera danego IP to je dodaje a następnie wyśwuietlam komunikat
if (!routers_IP.Contains(sourceip))
{
routers_IP.Add(sourceip);
UpdateListBoxReceived("Network Node: " + sourceip + " is up");
UpdateListBoxReceived(listening_socket.Count.ToString());
}
//tworze połączenie z socketem routera, który wysłał do mnie wiadomość
send = sS.ConnectToEndPoint(NMSPackage.exctractSourceIP(nmspackage).ToString());
// a następnie dodaje ten socket do listy socketów, by potem móc z nich korzystać
sends_socket.Add(send);
short numberOfRouter = NMSPackage.extractNumberOfRouterNumber(nmspackage);
List <string> configurationRouter = ReadingFromFile(paths.ElementAt(numberOfRouter - 1));
foreach (var line in configurationRouter)
{
short length = (Int16)line.Length;
NMSPackage tablePackage = new NMSPackage(interfaces.ElementAt(numberOfRouter - 1), line, length);
byte[] tablePackageInBytes = tablePackage.toBytes();
send.Send(tablePackageInBytes);
Task.Delay(10);
}
/* z kazdą wiadomością "Network node is up" dodaje IP routera do checkboca w celu mozliwości wybrania
* docelwoego punktu komunikacji */
_Application.comboBoxRouters.Invoke(new Action(delegate()
{
_Application.comboBoxRouters.Items.Add(sourceip);
}));
}
//jesli wiadmośc keep alive
else if (usableMessage == "Keep Alive")
{
// UpdateListBoxReceived(usableMessage);
}
else if (usableMessage == "ERROR")
{
UpdateListBoxReceived("Cannot send EON Table to the node agent");
}
else if (usableMessage.StartsWith("TOPOLOGY"))
{
UpdateListBoxReceived(usableMessage);
}
}
//jesli paczka jest nullem
else
{
int index = listening_socket.IndexOf(listener);
// stwierdzam, że agent nie odpowiada, a potem go rozłączam
UpdateListBoxReceived("Network Node" + getIPAddressRemote(sends_socket.ElementAt(index)) + " is not responding");
UpdateListBoxReceived("Network Node" + getIPAddressRemote(sends_socket.ElementAt(index)) + " is disconnected");
listening_socket.RemoveAt(index);
sends_socket.RemoveAt(index);
routers_IP.RemoveAt(index);
_Application.comboBoxRouters.Invoke(new Action(delegate()
{
comboBoxRouters.Items.RemoveAt(index);
}));
//odłączanie
listener.Disconnect(true);
//send.Disconnect(true);
//usuwanie socketów, adresów z list by przy ponownym połączeniu dodawać je na ponownie
break;
}
}
}
}
/// <summary>
/// Funkcja uruchamiana w momencie naciśnięcia przycisku połączenie z chmura
/// </summary>
/// <param name="sender">Obiekt, który odpowiedzialny jest za wysłanie eventu</param>
/// <param name="e">Otrzymany event po naciśnięciu przycisku</param>
private void buttonConnectToCloud_Click(object sender, EventArgs e)
{
if (buttonConnectToCloudClicked == false)
{
buttonConnectToCloud.Enabled = false;
buttonConnectToCloudClicked = true;
string sourceIp;
//Pobranie indeksu na którym w liście znajduje się IP naszej klienckiej aplikacji
int cloudipindex = clientsiplist.IndexOf(_ClientApplication.ClientIP);
//Pobranie IP chmury z listy
string cloudIP = cloudsiplist[cloudipindex];
try
{
//Wiadomość która będzie otrzymywana
string message2 = null;
//Inicjalizacja ilości paczek
int numberOfPackages = 0;
//Inicjalizacja ID paczki
short frameID;
//Próba połączenia się z IP chmury, z którego bedziemy nasłuchiwali wiadomości
send = sS.ConnectToEndPoint(cloudIP);
if (send.Connected)
{
//Uruchomienie nasłuchiwania w aplikacji klienckiej
socket = sl.ListenAsync(_ClientApplication.ClientIP);
Task.Run(() =>
{
while (true)
{
//Odebrana wiadomość w postaci bytes
byte[] messagebytes;
//Zamienienie odebranej wiadomości na tablicę bajtów
messagebytes = sl.ProcessRecivedBytes(socket);
//Stworzenie timestampa
string timestamp2 = Timestamp.generateTimestamp();
//Zwiększenie liczby paczek - po odebraniu paczki
numberOfPackages++;
//Wydobycie ID paczki z otrzymanej wiadomości
frameID = Package.extractID(messagebytes);
//Odpakowanie adresy nadawcy z otrzymanej wiadomości
sourceIp = Package.exctractSourceIP(messagebytes).ToString();
//Stworzenie wiadomości, która zostanie wyświetlona na ekranie - odpakowanie treści wiadomości z paczki
string DestinationID = null;
int index = _CPCC.establishedConnections.FindIndex(x => x.Equals(sourceIp)) - 1;
DestinationID = _CPCC.establishedConnections[index];
message2 = DestinationID + ": " + Package.extractUsableMessage(messagebytes, Package.extractUsableInfoLength(messagebytes));
//Pojawienie się informacji o otrzymaniu wiadomości
_ClientApplication.updateLogTextBox("[" + timestamp2 + "] == RECEIVED MESSAGE number " + numberOfPackages +
" == S_ClientID: " + DestinationID + " with FrameID=" + frameID);
//Zauktualizowanie wiadomości w polu ReceivedMessage
_ClientApplication.updateReceivedMessageTextBox(message2);
_ClientApplication.updateReceivedMessageTextBox("\r\n");
message2 = null;
messagebytes = null;
frameID = 0;
}
});
}
else
{
throw new NullReferenceException();
}
}
catch (Exception err)
{
MessageBox.Show("Unable to connect to the Network Host!", "Attention!");
buttonConnectToCloud.Enabled = true;
buttonConnectToCloudClicked = false;
}
}
}
