public BlockChainVotings()
{
NetworkComms.DisableLogging();
LiteLogger logger = new LiteLogger(LiteLogger.LogMode.ConsoleOnly);
NetworkComms.EnableLogging(logger);
db = new VotingsDB();
net = new Network();
db.ConnectToDBAsync();
t = new Timer(CommonHelpers.PeersCheckInterval * 10);
pendingBlocks = new Dictionary <Block, DateTime>();
pendingTransactions = new Dictionary <Transaction, DateTime>();
net.OnBlocksMessage += OnBlockMessage;
net.OnRequestBlocksMessage += OnRequestBlocksMessage;
net.OnRequestTransactionsMessage += OnRequestTransactionsMessage;
net.OnTransactionsMessage += OnTransactionsMessage;
t.Elapsed += CheckDeleteOldPendingItems;
}
public Logger(string logFile)
{
string logFileName = logFile + "_" + NetworkComms.NetworkIdentifier + ".txt";
logger = new LiteLogger(LiteLogger.LogMode.ConsoleAndLogFile, logFileName);
NetworkComms.EnableLogging(logger);
}
// private static bool Emulator;
public static void Start()
{
if (_started)
{
return;
}
_started = true;
NetworkComms.EnableLogging(new LiteLogger(LiteLogger.LogMode.ConsoleOnly));
NetworkComms.IgnoreUnknownPacketTypes = true;
var serializer = DPSManager.GetDataSerializer <NetworkCommsDotNet.DPSBase.ProtobufSerializer>();
NetworkComms.DefaultSendReceiveOptions = new SendReceiveOptions(serializer,
NetworkComms.DefaultSendReceiveOptions.DataProcessors, NetworkComms.DefaultSendReceiveOptions.Options);
NetworkComms.AppendGlobalIncomingPacketHandler <ServerInfo>(ServerInfo.GetHeader(), ServerInfoReceived);
PeerDiscovery.EnableDiscoverable(PeerDiscovery.DiscoveryMethod.UDPBroadcast);
PeerDiscovery.OnPeerDiscovered += OnPeerDiscovered;
Connection.StartListening(ConnectionType.UDP, new IPEndPoint(IPAddress.Any, 0));
PeerDiscovery.DiscoverPeersAsync(PeerDiscovery.DiscoveryMethod.UDPBroadcast);
}
/// <summary>
/// Start the TCP listener
/// </summary>
public static void Listen()
{
if (Net.ENABLE_DISCOVERY)
{
Net.ConfigurePeerDiscovery();
PeerDiscovery.EnableDiscoverable(Net.PEER_DISCOVERY_METHOD);
}
NetworkComms.EnableLogging(new LiteLoggerDebug(LiteLoggerDebug.LogMode.ConsoleOnly));
Connection.StartListening(Listener = new TCPConnectionListener(Net.SEND_RECEIVE_OPTIONS, ApplicationLayerProtocolStatus.Enabled, true), new IPEndPoint(IPAddress.Any, Net.DEFAULT_PORT));
}
/// <summary>
/// Enable logging, useful for debugging applications.
/// </summary>
private void EnableLogging()
{
//We will create the log file in the local documents directory
string logFileName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "NetworkCommsLog.txt");
ChatApplication.AppendLineToChatHistory("Logging enabled to " + logFileName);
ILogger logger = new LiteLogger(LiteLogger.LogMode.LogFileOnly, logFileName);
NetworkComms.EnableLogging(logger);
}
public Tracker()
{
this.Peers = new List <Peer>();
this.Status = TrackerStatus.Stopped;
t = new Timer(CommonHelpers.CheckAliveInterval);
NetworkComms.DisableLogging();
if (File.Exists("BlockChainVotingsTracker_log.txt"))
{
File.Delete("BlockChainVotingsTracker_log.txt");
}
LiteLogger logger = new LiteLogger(LiteLogger.LogMode.ConsoleAndLogFile, "BlockChainVotingsTracker_log.txt");
NetworkComms.EnableLogging(logger);
NetworkComms.AppendGlobalConnectionEstablishHandler(OnConnectPeer);
}
static void Main(string[] args)
{
try
{
Console.SetBufferSize(160, 500);
Console.SetWindowSize(160, 25);
}
catch (Exception) { }
Thread.CurrentThread.Name = "MainThread";
if (false)
{
ILogger logger = new LiteLogger(LiteLogger.LogMode.ConsoleAndLogFile, "DebugTests_" + NetworkComms.NetworkIdentifier + ".txt");
NetworkComms.EnableLogging(logger);
//Incase we run the DFS test we will also enable logging for that
DistributedFileSystem.DFS.EnableLogging(logger);
}
//NetworkComms.EnablePacketCheckSumValidation = true;
DebugTest.RunExample(args);
//BasicSend.RunExample();
//AliveTest.RunExample();
//DebugTest.RunExample();
//DFSTest.RunExample();
//BandwidthLoadTest.RunExample();
//BluetoothTest.RunExample();
//NumConnectionLoadTest.RunExample();
//ThreadPoolTest.RunExample();
//SSLTest.RunExample();
//NestedPacketTest.RunExample();
//PeerDiscoveryTest.RunExample();
//SelfConnectTest.RunExample();
//SymEncryptionTest.RunExample();
//UnmanagedUDPBroadcast.RunExample();
//LogAnalyser log = new LogAnalyser(@"C:\Users\Karnifexx\Documents\Visual Studio 2010\Projects\networkcomms.net\DebugTests\bin\Debug\DebugTests_e-P76M-6LkSFyUFFlnU0qA.txt");
//log.LinesWithMatch(new string[] { "Received packet of type 'ConnectionSetup'" }, "matchLog4.txt");
//log.ThreadPoolInfo("threadPool.csv");
//log.DataSendReceive(10, "sendReceiveStats.csv");
}
public void TestMethodClientPeer()
{
NetworkComms.EnableLogging();
NetworkComms.Shutdown();
int theirPort = CommonHelpers.PeerPort + 2;
string hash = "hash1";
VotingsUser.PeerDiscovery = true;
Peer peer1 = null;
TCPConnection our = null;
List <Peer> allPeers = null;
int reqHash = 0;
int reqPeers = 0;
int reqBlocks = 0;
int respPeers = 0;
int blocksEvent = 0;
int trsEvent = 0;
int blocksReqEvent = 0;
int trsReqEvent = 0;
//============
//прослушиваем 2 порта
TCPConnection.StartListening(CommonHelpers.GetLocalEndPoint(CommonHelpers.PeerPort, true)); //мы
TCPConnection.StartListening(CommonHelpers.GetLocalEndPoint(theirPort, true)); //они
allPeers = new List <Peer>();
peer1 = new Peer(CommonHelpers.GetLocalEndPoint(theirPort, true), allPeers);
allPeers.Add(peer1);
//получаем подключение пира к нам
NetworkComms.AppendGlobalConnectionEstablishHandler((c) =>
{
our = c as TCPConnection;
});
//определяем, что сообщения пришли
NetworkComms.AppendGlobalIncomingPacketHandler <PeerHashMessage>(typeof(PeerHashMessage).Name, (p, c, i) =>
{
reqHash++;
});
NetworkComms.AppendGlobalIncomingPacketHandler <RequestPeersMessage>(typeof(RequestPeersMessage).Name, (p, c, i) =>
{
reqPeers++;
});
NetworkComms.AppendGlobalIncomingPacketHandler <RequestBlocksMessage>(typeof(RequestBlocksMessage).Name, (p, c, i) =>
{
reqBlocks++;
});
NetworkComms.AppendGlobalIncomingPacketHandler <PeersMessage>(typeof(PeersMessage).Name, (p, c, i) =>
{
respPeers++;
});
peer1.OnBlocksMessage += (s, e) =>
{
blocksEvent++;
};
peer1.OnTransactionsMessage += (s, e) =>
{
trsEvent++;
};
peer1.OnRequestBlocksMessage += (s, e) =>
{
blocksReqEvent++;
};
peer1.OnRequestTransactionsMessage += (s, e) =>
{
trsReqEvent++;
};
//============
//подключаемся к пиру
peer1.Connect();
w();
Assert.IsTrue(peer1.Status == PeerStatus.NoHashRecieved);
Assert.IsTrue(reqHash == 1);
//отправляем хеш пиру
our.SendObject <PeerHashMessage>(typeof(PeerHashMessage).Name, new PeerHashMessage(hash, false));
w();
Assert.IsTrue(peer1.Hash == hash);
Assert.IsTrue(peer1.Status == PeerStatus.Connected);
//отправляем сообщение нам
peer1.SendMessage(new RequestBlocksMessage(new List <string>()));
w();
Assert.IsTrue(reqBlocks == 1);
//проверяем подключение
peer1.CheckConnection();
w();
Assert.IsTrue(peer1.ErrorsCount == 0);
//запрашиваем пиры у нас
peer1.RequestPeers(10);
w();
Assert.IsTrue(reqPeers == 1);
//запрашиваем пиры у пира
our.SendObject <RequestPeersMessage>(typeof(RequestPeersMessage).Name, new RequestPeersMessage(10));
w();
Assert.IsTrue(reqPeers == 2);
Assert.IsTrue(respPeers == 1);
//отправляем блоки пиру
our.SendObject <BlocksMessage>(typeof(BlocksMessage).Name, new BlocksMessage());
w();
Assert.IsTrue(blocksEvent == 1);
//отправляем транзакции пиру
our.SendObject <TransactionsMessage>(typeof(TransactionsMessage).Name, new TransactionsMessage());
w();
Assert.IsTrue(trsEvent == 1);
//запрашиваем транзакции у пира
our.SendObject <RequestTransactionsMessage>(typeof(RequestTransactionsMessage).Name, new RequestTransactionsMessage());
w();
Assert.IsTrue(trsReqEvent == 1);
//запрашиваем транзакции у пира
our.SendObject <RequestBlocksMessage>(typeof(RequestBlocksMessage).Name, new RequestBlocksMessage());
w();
Assert.IsTrue(blocksReqEvent == 1);
//отключаемся от пира
peer1.DisconnectAny();
w();
Assert.IsTrue(allPeers.Count == 0);
}
private static void SelectLogging()
{
//If the user wants to enable logging
Console.WriteLine("To enable comms logging press 'y'. To leave logging disabled and continue press any other key.\n");
if (Console.ReadKey(true).Key == ConsoleKey.Y)
{
//Select the logger to use
Console.WriteLine("Please select the logger to use:\n1 - NetworkComms.Net LiteLogger\n2 - External NLog Logger");
//Parse the user input for the selected logger
int selectedLogger;
while (true)
{
bool parseSucces = int.TryParse(Console.ReadKey(true).KeyChar.ToString(), out selectedLogger);
if (parseSucces && selectedLogger <= 2 && selectedLogger > 0)
{
break;
}
Console.WriteLine("Invalid logger choice. Please try again.");
}
//Set the desired logger
ILogger logger;
if (selectedLogger == 1)
{
Console.WriteLine(" ... selected NetworkComms.Net LiteLogger.\n");
//////////////////////////////////////////////////////////////////////
//// SIMPLE CONSOLE ONLY LOGGING
//////////////////////////////////////////////////////////////////////
//ILogger logger = new LiteLogger(LiteLogger.LogMode.ConsoleOnly);
//NetworkComms.EnableLogging(logConfig);
//////////////////////////////////////////////////////////////////////
//// THE FOLLOWING CONFIG LOGS TO BOTH A FILE AND CONSOLE
//////////////////////////////////////////////////////////////////////
string logFileName = "ExamplesConsoleLog_" + NetworkComms.NetworkIdentifier + ".txt";
logger = new LiteLogger(LiteLogger.LogMode.ConsoleAndLogFile, logFileName);
}
else if (selectedLogger == 2)
{
Console.WriteLine(" ... selected external NLog logger.\n");
//We create an instance of the NLogLogger class which uses a default implementation of
//the ILogger interface provided with NetworkComms.Net
logger = new NLogLogger();
}
else
{
throw new Exception("Unable to determine selected connection type.");
}
//Enable logging using the selected logger
NetworkComms.EnableLogging(logger);
//In case we run the DFS test we will also enable logging for that
DistributedFileSystem.DFS.EnableLogging(logger);
//We can write to our logger from an external application as well
NetworkComms.Logger.Info("NetworkComms.Net logging enabled.");
}
}
public void TestMethodClientTracker()
{
NetworkComms.EnableLogging();
NetworkComms.Shutdown();
int myPort = CommonHelpers.PeerPort + 2;
VotingsUser.PeerDiscovery = true;
Tracker tracker1 = null;
TCPConnection our = null;
List <Tracker> allTrackers = null;
int connToPeer = 0;
int toPeer = 0;
int reqPeers = 0;
int peersEvent = 0;
int blocksEvent = 0;
//============
//прослушиваем 2 порта
TCPConnection.StartListening(CommonHelpers.GetLocalEndPoint(myPort, true)); //мы
TCPConnection.StartListening(CommonHelpers.GetLocalEndPoint(CommonHelpers.PeerPort, true)); //они
allTrackers = new List <Tracker>();
tracker1 = new Tracker(CommonHelpers.GetLocalEndPoint(myPort), allTrackers);
allTrackers.Add(tracker1);
//получаем подключение пира к нам
NetworkComms.AppendGlobalConnectionEstablishHandler((c) =>
{
our = c as TCPConnection;
});
//определяем, что сообщения пришли
NetworkComms.AppendGlobalIncomingPacketHandler <ConnectToPeerWithTrackerMessage>(typeof(ConnectToPeerWithTrackerMessage).Name, (p, c, i) =>
{
connToPeer++;
});
NetworkComms.AppendGlobalIncomingPacketHandler <ToPeerMessage>(typeof(ToPeerMessage).Name, (p, c, i) =>
{
toPeer++;
});
NetworkComms.AppendGlobalIncomingPacketHandler <RequestPeersMessage>(typeof(RequestPeersMessage).Name, (p, c, i) =>
{
reqPeers++;
});
tracker1.OnBlocksMessage += (s, e) =>
{
blocksEvent++;
};
tracker1.OnRequestPeersMessage += (s, e) =>
{
peersEvent++;
};
//============
//подключаемся к пиру
tracker1.Connect();
w();
Assert.IsTrue(tracker1.Status == TrackerStatus.Connected);
//запрашиваем пиры у нас
tracker1.RequestPeersFromTracker(10);
w();
Assert.IsTrue(reqPeers == 1);
//отправляем сообщение нам
tracker1.SendMessageToPeer(
new RequestBlocksMessage(new List <string>()),
new Peer(new IPEndPoint(0, 0),
new List <Peer>()));
w();
Assert.IsTrue(toPeer == 1);
//запрашиваем пиры у пира
our.SendObject <ToPeerMessage>(
typeof(ToPeerMessage).Name,
new ToPeerMessage(new IPEndPoint(0, 0),
CommonHelpers.GetLocalEndPoint(CommonHelpers.PeerPort, true), new RequestPeersMessage(10)));
w();
Assert.IsTrue(peersEvent == 1);
//отправляем блоки пиру
our.SendObject <ToPeerMessage>(
typeof(ToPeerMessage).Name,
new ToPeerMessage(new IPEndPoint(0, 0),
CommonHelpers.GetLocalEndPoint(CommonHelpers.PeerPort, true), new BlocksMessage()));
w();
Assert.IsTrue(blocksEvent == 1);
//отправляем подключение к пиру нам
tracker1.ConnectPeerToPeer(new Peer(new IPEndPoint(0, 0), new List <Peer>()));
w();
Assert.IsTrue(connToPeer == 1);
//дисконнект от трекера
tracker1.Disconnect();
w();
Assert.IsTrue(allTrackers.Count == 0);
}
