예제 #1
0
        public static void Main(string[] args)
        {
            AppDomain.CurrentDomain.UnhandledException += delegate(object sender, UnhandledExceptionEventArgs args2)
            {
                var filePath  = ClassUtilsNode.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + "\\error_remotenode.txt");
                var exception = (Exception)args2.ExceptionObject;
                using (var writer = new StreamWriter(filePath, true))
                {
                    writer.WriteLine("Message :" + exception.Message + "<br/>" + Environment.NewLine +
                                     "StackTrace :" +
                                     exception.StackTrace +
                                     "" + Environment.NewLine + "Date :" + DateTime.Now);
                    writer.WriteLine(Environment.NewLine +
                                     "-----------------------------------------------------------------------------" +
                                     Environment.NewLine);
                }

                Trace.TraceError(exception.StackTrace);

                Environment.Exit(1);
            };
            Thread.CurrentThread.Name = Path.GetFileName(Environment.GetCommandLineArgs()[0]);
            ClassRemoteNodeSave.InitializePath();
            if (ClassRemoteNodeSave.LoadBlockchainTransaction())
            {
                ClassRemoteNodeSave.LoadBlockchainBlock();
            }
            else
            {
                Console.WriteLine("Blockchain database corrupted, clean up..");
                ClassRemoteNodeSync.ListOfTransaction.Clear();
                ClassRemoteNodeSync.ListOfBlock.Clear();
                ClassRemoteNodeSync.ListTransactionPerWallet.Clear();
                Thread.Sleep(2000);
            }
            Console.WriteLine("Remote node Xiropht - " + Assembly.GetExecutingAssembly().GetName().Version + "R");


            if (File.Exists(ClassUtilsNode.ConvertPath(AppDomain.CurrentDomain.BaseDirectory + ConfigFilePath)))
            {
                ReadConfigFile();
                if (EnableWriteLog)
                {
                    ClassLog.EnableWriteLog();
                }
                if (EnableFilteringSystem)
                {
                    ClassApiBan.FilterAutoCheckObject();
                }
            }
            else
            {
                Console.WriteLine(
                    "Welcome, please write your wallet address, in a near future public remote nodes will get reward: ");
                RemoteNodeWalletAddress = Console.ReadLine();

                Console.WriteLine("Do you want load your node as a Public Remote Node? [Y/N]");
                var answer = Console.ReadLine();
                if (answer == "Y" || answer == "y")
                {
                    Console.WriteLine("Be carefull, you need to open the default port " +
                                      ClassConnectorSetting.RemoteNodePort + " of your remote node in your router.");
                    Console.WriteLine(
                        "Your port need to be opened for everyone and not only for Seed Nodes, for proceed test of your sync.");
                    Console.WriteLine("If everything is alright, your remote node will be listed in the public list.");
                    Console.WriteLine(
                        "If informations of your sync are not right, your remote node will be not listed.");
                    Console.WriteLine(
                        "Checking by Seed Nodes of your Remote Node work everytime for be sure your node is legit and can be rewarded.");
                    Console.WriteLine("");
                    Console.WriteLine("Are you sure to enable this mode? [Y/N]");
                    answer = Console.ReadLine();
                    if (answer == "Y" || answer == "y")
                    {
                        Console.WriteLine("Enabling public remote node system..");
                        ClassRemoteNodeSync.WantToBePublicNode = true;
                    }
                }

                Console.WriteLine("Do you to enable the HTTP API ? [Y/N]");
                answer = Console.ReadLine();
                if (answer == "Y" || answer == "y")
                {
                    EnableApiHttp = true;
                    Console.WriteLine("Do you want to select another port for your HTTP API? [Y/N]");
                    answer = Console.ReadLine();
                    if (answer == "Y" || answer == "y")
                    {
                        Console.WriteLine("Enter your port selected for your HTTP API: (By default: " + ClassConnectorSetting.RemoteNodeHttpPort + ")");
                        string portChoosed = Console.ReadLine();
                        while (!int.TryParse(portChoosed, out ClassApiHttp.PersonalRemoteNodeHttpPort))
                        {
                            Console.WriteLine("Invalid port, please try another one:");
                            portChoosed = Console.ReadLine();
                        }
                    }
                }
                SaveConfigFile();
            }



            Certificate = ClassUtils.GenerateCertificate();
            Console.WriteLine("Initialize Remote Node Sync Objects..");

            RemoteNodeObjectToBePublic              = new ClassRemoteNodeObject(SyncEnumerationObject.ObjectToBePublic);
            RemoteNodeObjectCoinMaxSupply           = new ClassRemoteNodeObject(SyncEnumerationObject.ObjectCoinSupply);
            RemoteNodeObjectTransaction             = new ClassRemoteNodeObject(SyncEnumerationObject.ObjectTransaction);
            RemoteNodeObjectCoinMaxSupply           = new ClassRemoteNodeObject(SyncEnumerationObject.ObjectCoinSupply);
            RemoteNodeObjectCoinCirculating         = new ClassRemoteNodeObject(SyncEnumerationObject.ObjectCoinCirculating);
            RemoteNodeObjectTotalBlockMined         = new ClassRemoteNodeObject(SyncEnumerationObject.ObjectBlockMined);
            RemoteNodeObjectTotalPendingTransaction = new ClassRemoteNodeObject(SyncEnumerationObject.ObjectPendingTransaction);
            RemoteNodeObjectCurrentDifficulty       = new ClassRemoteNodeObject(SyncEnumerationObject.ObjectCurrentDifficulty);
            RemoteNodeObjectCurrentRate             = new ClassRemoteNodeObject(SyncEnumerationObject.ObjectCurrentRate);
            RemoteNodeObjectTotalFee         = new ClassRemoteNodeObject(SyncEnumerationObject.ObjectTotalFee);
            RemoteNodeObjectTotalTransaction = new ClassRemoteNodeObject(SyncEnumerationObject.ObjectTotalTransaction);
            RemoteNodeObjectBlock            = new ClassRemoteNodeObject(SyncEnumerationObject.ObjectBlock);


            Task.Factory.StartNew(async delegate()
            {
                ClassCheckRemoteNodeSync.AutoCheckBlockchainNetwork();
                if (!ClassCheckRemoteNodeSync.BlockchainNetworkStatus)
                {
                    while (!ClassCheckRemoteNodeSync.BlockchainNetworkStatus)
                    {
                        Console.WriteLine("Blockchain network is not available. Check again after 1 seconds.");
                        await Task.Delay(1000);
                    }
                }
                var initializeConnection = false;
                while (!initializeConnection)
                {
                    Console.WriteLine("Start Remote Node Sync Objects Connection..");

                    await Task.Factory.StartNew(() => RemoteNodeObjectCoinMaxSupply.StartConnectionAsync(), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Current).ConfigureAwait(false);
                    await Task.Factory.StartNew(() => RemoteNodeObjectCoinCirculating.StartConnectionAsync(), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Current).ConfigureAwait(false);
                    await Task.Factory.StartNew(() => RemoteNodeObjectTotalPendingTransaction.StartConnectionAsync(), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Current).ConfigureAwait(false);
                    await Task.Factory.StartNew(() => RemoteNodeObjectTotalBlockMined.StartConnectionAsync(), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Current).ConfigureAwait(false);
                    await Task.Factory.StartNew(() => RemoteNodeObjectCurrentDifficulty.StartConnectionAsync(), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Current).ConfigureAwait(false);
                    await Task.Factory.StartNew(() => RemoteNodeObjectCurrentRate.StartConnectionAsync(), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Current).ConfigureAwait(false);
                    await Task.Factory.StartNew(() => RemoteNodeObjectTotalFee.StartConnectionAsync(), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Current).ConfigureAwait(false);
                    await Task.Factory.StartNew(() => RemoteNodeObjectTotalTransaction.StartConnectionAsync(), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Current).ConfigureAwait(false);
                    await Task.Factory.StartNew(() => RemoteNodeObjectTransaction.StartConnectionAsync(), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Current).ConfigureAwait(false);
                    await Task.Factory.StartNew(() => RemoteNodeObjectBlock.StartConnectionAsync(), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Current).ConfigureAwait(false);

                    if (ClassRemoteNodeSync.WantToBePublicNode)
                    {
                        await Task.Factory.StartNew(() => RemoteNodeObjectToBePublic.StartConnectionAsync(), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Current).ConfigureAwait(false);
                    }
                    initializeConnection = true;
                }

                if (initializeConnection)
                {
                    Console.WriteLine("Remote node objects successfully connected.");
                }
                else
                {
                    Console.WriteLine("Remote node objects can't connect to the network, retry in 10 seconds..");
                    ClassCheckRemoteNodeSync.DisableCheckRemoteNodeSync();
                    RemoteNodeObjectBlock.StopConnection();
                    RemoteNodeObjectToBePublic.StopConnection();
                    RemoteNodeObjectTransaction.StopConnection();
                    RemoteNodeObjectCoinCirculating.StopConnection();
                    RemoteNodeObjectCoinMaxSupply.StopConnection();
                    RemoteNodeObjectCurrentDifficulty.StopConnection();
                    RemoteNodeObjectCurrentRate.StopConnection();
                    RemoteNodeObjectTotalBlockMined.StopConnection();
                    RemoteNodeObjectTotalFee.StopConnection();
                    RemoteNodeObjectTotalPendingTransaction.StopConnection();
                    RemoteNodeObjectTotalTransaction.StopConnection();
                    await Task.Delay(10000);
                }



                Console.WriteLine("Enable Check Remote Node Objects connection..");
                ClassCheckRemoteNodeSync.EnableCheckRemoteNodeSync();
                Console.WriteLine("Enable System of Generating Trusted Key's of Remote Node..");
                ClassRemoteNodeKey.StartUpdateTrustedKey();

                Console.WriteLine("Enable Auto save system..");
                ClassRemoteNodeSave.SaveTransaction();
                ClassRemoteNodeSave.SaveBlock();

                Console.WriteLine("Enable API..");
                ClassApi.StartApiRemoteNode();
                if (EnableApiHttp)
                {
                    Console.WriteLine("Enable API HTTP..");
                    ClassApiHttp.StartApiHttpServer();
                }
            }, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Current).ConfigureAwait(true);


            _threadCommandLine = new Thread(delegate()
            {
                while (!ClassApi.ApiReceiveConnectionStatus)
                {
                    Thread.Sleep(100);
                }
                Console.WriteLine(
                    "Remote node successfully started, you can run command: help for get the list of commands.");
                while (!Closed)
                {
                    try
                    {
                        if (!ClassCommandLine.CommandLine(Console.ReadLine()))
                        {
                            break;
                        }
                    }
                    catch
                    {
                    }
                }
            });
            _threadCommandLine.Start();
        }
예제 #2
0
        public static bool CommandLine(string command)
        {
            var splitCommand = command.Split(new char[0], StringSplitOptions.None);

            try
            {
                switch (splitCommand[0])
                {
                case ClassCommandLineEnumeration.CommandLineHelp:
                    Console.WriteLine("Command list: ");
                    Console.WriteLine(ClassCommandLineEnumeration.CommandLineStatus + " -> Get Network status of your node");
                    Console.WriteLine(ClassCommandLineEnumeration.CommandLineTransaction + " -> Get the number of transaction(s) sync.");
                    Console.WriteLine(ClassCommandLineEnumeration.CommandLineBlock + " -> Get the number of block(s) sync.");
                    Console.WriteLine(ClassCommandLineEnumeration.CommandLineLog + " -> Can set level of log to show: (default) log 0 max level 4");
                    Console.WriteLine(ClassCommandLineEnumeration.CommandLineClearSync + " -> Clear the sync of the remote node.");
                    Console.WriteLine(ClassCommandLineEnumeration.CommandLineFilterList + " -> show every incoming connections ip's and their status.");
                    Console.WriteLine(ClassCommandLineEnumeration.CommandLineBanList + " -> show every incoming connections ip's banned.");
                    Console.WriteLine(ClassCommandLineEnumeration.CommandLineSave + " -> Save sync.");
                    Console.WriteLine(ClassCommandLineEnumeration.CommandLineExit + " -> Save sync and Exit the node.");
                    break;

                case ClassCommandLineEnumeration.CommandLineStatus:
                    Console.WriteLine("Total Transaction Sync: " + (ClassRemoteNodeSync.ListOfTransaction.Count));
                    Console.WriteLine("Total Transaction in the Blockchain: " + ClassRemoteNodeSync.TotalTransaction);
                    long totalTransactionSortedPerWallet = ClassRemoteNodeSync.ListTransactionPerWallet.Count;

                    Console.WriteLine("Total Transaction Sorted for Wallet(s): " + totalTransactionSortedPerWallet);
                    Console.WriteLine("Total Block(s) Sync: " + (ClassRemoteNodeSync.ListOfBlock.Count));
                    Console.WriteLine("Total Block(s) mined in the Blockchain: " + ClassRemoteNodeSync.TotalBlockMined);
                    Console.WriteLine("Total Block(s) left to mining: " + ClassRemoteNodeSync.CurrentBlockLeft);
                    Console.WriteLine("Total pending transaction in the network: " + ClassRemoteNodeSync.TotalPendingTransaction);
                    Console.WriteLine("Total Fee in the network: " + ClassRemoteNodeSync.CurrentTotalFee, Program.GlobalCultureInfo);
                    Console.WriteLine("Current Mining Difficulty: " + ClassRemoteNodeSync.CurrentDifficulty);
                    if (ClassRemoteNodeSync.CurrentHashrate != null)
                    {
                        Console.WriteLine("Current Mining Hashrate: " + ClassUtils.GetTranslateHashrate(ClassRemoteNodeSync.CurrentHashrate.Replace(".", ","), 2).Replace(",", "."), Program.GlobalCultureInfo);
                    }
                    Console.WriteLine("Total Coin Max Supply: " + ClassRemoteNodeSync.CoinMaxSupply, Program.GlobalCultureInfo);

                    Console.WriteLine("Total Coin Circulating: " + ClassRemoteNodeSync.CoinCirculating, Program.GlobalCultureInfo);

                    if (ClassRemoteNodeSync.WantToBePublicNode)
                    {
                        string publicNodes = string.Empty;
                        for (int i = 0; i < ClassRemoteNodeSync.ListOfPublicNodes.Count; i++)
                        {
                            if (i < ClassRemoteNodeSync.ListOfPublicNodes.Count)
                            {
                                publicNodes += ClassRemoteNodeSync.ListOfPublicNodes[i] + " ";
                            }
                        }
                        Console.WriteLine("List of Public Remote Node: " + publicNodes);
                        string status = "NOT LISTED";
                        if (ClassRemoteNodeSync.ImPublicNode)
                        {
                            status = "LISTED";
                        }
                        Console.WriteLine("Public Status of the Remote Node: " + status);
                    }
                    Console.WriteLine("Trusted Key: " + ClassRemoteNodeSync.TrustedKey);
                    Console.WriteLine("Hash Transaction Key: " + ClassRemoteNodeSync.HashTransactionList);
                    Console.WriteLine("Hash Block Key: " + ClassRemoteNodeSync.HashBlockList);

                    break;

                case ClassCommandLineEnumeration.CommandLineTransaction:
                    Console.WriteLine("Total Transaction Sync: " + (ClassRemoteNodeSync.ListOfTransaction.Count));
                    Console.WriteLine("Total Transaction in the Blockchain: " + ClassRemoteNodeSync.TotalTransaction);
                    break;

                case ClassCommandLineEnumeration.CommandLineBlock:
                    Console.WriteLine("Total Block(s) Sync: " + (ClassRemoteNodeSync.ListOfBlock.Count));
                    Console.WriteLine("Total Block(s) mined in the Blockchain: " + ClassRemoteNodeSync.TotalBlockMined);
                    Console.WriteLine("Total Block(s) left to mining: " + ClassRemoteNodeSync.CurrentBlockLeft);
                    break;

                case ClassCommandLineEnumeration.CommandLineLog:
                    if (!string.IsNullOrEmpty(splitCommand[1]))
                    {
                        if (int.TryParse(splitCommand[1], out var logLevel))
                        {
                            if (logLevel < 0)
                            {
                                logLevel = 0;
                            }
                            if (logLevel > 7)
                            {
                                logLevel = 7;
                            }
                            Console.WriteLine("Log Level " + Program.LogLevel + " -> " + logLevel);
                            Program.LogLevel = logLevel;
                        }
                        else
                        {
                            Console.WriteLine("Wrong argument: " + splitCommand[1] + " should be a number.");
                        }
                    }
                    else
                    {
                        Console.WriteLine("Empty/Missing argument.");
                    }
                    break;

                case ClassCommandLineEnumeration.CommandLineClearSync:
                    if (Program.RemoteNodeObjectTransaction.RemoteNodeObjectInSyncTransaction || Program.RemoteNodeObjectBlock.RemoteNodeObjectInSyncBlock)
                    {
                        Console.WriteLine("Cannot clean remote node sync, your remote node is currently on sync.");
                        Console.WriteLine("If you absolutly want to clear your sync, close the remote node, remove the Blockchain folder and restart.");
                    }
                    else
                    {
                        ClassRemoteNodeSync.ListOfTransaction.Clear();
                        ClassRemoteNodeSync.ListOfTransactionHash.Clear();
                        ClassRemoteNodeSync.ListTransactionPerWallet.Clear();
                        ClassRemoteNodeSync.ListOfBlock.Clear();
                        ClassRemoteNodeSync.ListOfBlockHash.Clear();
                        ClassRemoteNodeSave.ClearBlockSyncSave();
                        ClassRemoteNodeSave.ClearTransactionSyncSave();
                        ClassRemoteNodeKey.DataBlockRead          = string.Empty;
                        ClassRemoteNodeKey.DataTransactionRead    = string.Empty;
                        ClassRemoteNodeSave.TotalBlockSaved       = 0;
                        ClassRemoteNodeSave.TotalTransactionSaved = 0;
                        ClassRemoteNodeSave.DataTransactionSaved  = string.Empty;
                        ClassRemoteNodeSave.DataBlockSaved        = string.Empty;


                        Console.WriteLine("Clear finish, restart sync..");
                        ClassRemoteNodeKey.StartUpdateHashTransactionList();
                        ClassRemoteNodeKey.StartUpdateHashBlockList();
                        ClassRemoteNodeKey.StartUpdateTrustedKey();
                    }
                    break;

                case ClassCommandLineEnumeration.CommandLineFilterList:
                    if (ClassApiBan.ListFilterObjects.Count > 0)
                    {
                        foreach (var objectBan in ClassApiBan.ListFilterObjects)
                        {
                            if (objectBan.Value.Banned)
                            {
                                long banDelay = objectBan.Value.LastBanDate - DateTimeOffset.Now.ToUnixTimeSeconds();
                                Console.WriteLine("IP: " + objectBan.Value.Ip + " Total Invalid Packet:" + objectBan.Value.TotalInvalidPacket + " banned pending: " + banDelay + " second(s).");
                            }
                            else
                            {
                                Console.WriteLine("IP: " + objectBan.Value.Ip + " Total Invalid Packet:" + objectBan.Value.TotalInvalidPacket + " not banned.");
                            }
                        }
                    }
                    else
                    {
                        Console.WriteLine("Their is any incoming ip on the list.");
                    }
                    break;

                case ClassCommandLineEnumeration.CommandLineBanList:
                    if (ClassApiBan.ListFilterObjects.Count > 0)
                    {
                        foreach (var objectBan in ClassApiBan.ListFilterObjects)
                        {
                            if (objectBan.Value.Banned)
                            {
                                long banDelay = objectBan.Value.LastBanDate - DateTimeOffset.Now.ToUnixTimeSeconds();
                                Console.WriteLine("IP: " + objectBan.Value.Ip + " Total Invalid Packet:" + objectBan.Value.TotalInvalidPacket + " banned pending: " + banDelay + " second(s).");
                            }
                        }
                    }
                    else
                    {
                        Console.WriteLine("Their is any incoming ip on the list.");
                    }
                    break;

                case ClassCommandLineEnumeration.CommandLineSave:
                    Console.WriteLine("Stop auto save system. Start manual save sync..");
                    while (ClassRemoteNodeSave.InSaveTransactionDatabase)
                    {
                        Thread.Sleep(1000);
                    }
                    ClassRemoteNodeSave.TotalTransactionSaved = 0;
                    ClassRemoteNodeSave.DataTransactionSaved  = string.Empty;
                    ClassRemoteNodeSave.SaveTransaction(false);
                    while (ClassRemoteNodeSave.InSaveBlockDatabase)
                    {
                        Thread.Sleep(1000);
                    }
                    ClassRemoteNodeSave.TotalBlockSaved = 0;
                    ClassRemoteNodeSave.DataBlockSaved  = string.Empty;
                    ClassRemoteNodeSave.SaveBlock(false);
                    Console.WriteLine("Sync saved.");
                    Console.WriteLine("Restart auto save system.");
                    ClassRemoteNodeSave.SaveTransaction();
                    ClassRemoteNodeSave.SaveBlock();
                    break;

                case ClassCommandLineEnumeration.CommandLineExit:
                    Program.Closed = true;
                    Console.WriteLine("Disable auto reconnect remote node..");
                    ClassCheckRemoteNodeSync.DisableCheckRemoteNodeSync();
                    Thread.Sleep(1000);
                    Console.WriteLine("Stop each connection of the remote node.");
                    Program.RemoteNodeObjectBlock.StopConnection();
                    Program.RemoteNodeObjectTransaction.StopConnection();
                    Program.RemoteNodeObjectTotalTransaction.StopConnection();
                    Program.RemoteNodeObjectCoinCirculating.StopConnection();
                    Program.RemoteNodeObjectCoinMaxSupply.StopConnection();
                    Program.RemoteNodeObjectCurrentDifficulty.StopConnection();
                    Program.RemoteNodeObjectCurrentRate.StopConnection();
                    Program.RemoteNodeObjectTotalBlockMined.StopConnection();
                    Program.RemoteNodeObjectTotalFee.StopConnection();
                    Program.RemoteNodeObjectTotalPendingTransaction.StopConnection();
                    ClassLog.StopWriteLog();

                    Thread.Sleep(1000);
                    Console.WriteLine("Stop api..");
                    ClassApi.StopApi();
                    Console.WriteLine("Starting save sync..");
                    while (ClassRemoteNodeSave.InSaveTransactionDatabase)
                    {
                        Thread.Sleep(1000);
                    }
                    ClassRemoteNodeSave.TotalTransactionSaved = 0;
                    ClassRemoteNodeSave.DataTransactionSaved  = string.Empty;
                    ClassRemoteNodeSave.SaveTransaction(false);
                    while (ClassRemoteNodeSave.InSaveBlockDatabase)
                    {
                        Thread.Sleep(1000);
                    }
                    ClassRemoteNodeSave.TotalBlockSaved = 0;
                    ClassRemoteNodeSave.DataBlockSaved  = string.Empty;
                    ClassRemoteNodeSave.SaveBlock(false);
                    Console.WriteLine("Sync saved.");
                    Process.GetCurrentProcess().Kill();
                    return(false);
                }
            }
            catch (Exception error)
            {
                Console.WriteLine("Command line error: " + error.Message);
            }
            return(true);
        }