/// <summary> /// List structure /// </summary> /// <param name="client"></param> /// <param name="classApiRoot"></param> /// <param name="resource"></param> /// <returns></returns> public static string List(PveClient client, ClassApi classApiRoot, string resource) { var(Values, Error) = ListValues(client, classApiRoot, resource); return(string.Join(Environment.NewLine, Values.Select(a => $"{a.Attribute} {a.Value}")) + (string.IsNullOrWhiteSpace(Error) ? "" : Environment.NewLine + Error) + Environment.NewLine); }
public static ClassApi GetClassApiFromResource(string resource) { if (_classApiRoot == null) { _classApiRoot = GeneretorClassApi.Generate(Host, Port); } return(ClassApi.GetFromResource(_classApiRoot, resource)); }
// GET: api/ClassesData public IHttpActionResult GetClasses() { var list = db.Classes.ToList(); var wrapperClass = new ClassApi { Classes = list }; return(Ok(wrapperClass)); }
private static void CreateCommandFromAlias(TextWriter output, CommandLineApplication parent, PveClient client, ClassApi classApiRoot, AliasManager aliasManager, bool onlyResult) { foreach (var item in aliasManager.Alias) { parent.Command(item.Names[0], cmd => { foreach (var name in item.Names) { cmd.AddName(name); } cmd.Description = item.Description; cmd.ShowInHelpText = false; cmd.ExtendedHelpText = Environment.NewLine + "Alias command: " + item.Command; //create argument foreach (var arg in StringHelper.GetArgumentTags(item.Command)) { cmd.Argument(arg, arg, false).IsRequired(); } cmd.OnExecute(() => { var title = item.Description; var command = item.Command; //replace value into argument foreach (var arg in cmd.Arguments) { title += $" {arg.Name}: {arg.Value}"; command = command.Replace(StringHelper.CreateArgumentTag(arg.Name), arg.Value); } if (!onlyResult) { output.WriteLine(title); output.WriteLine("Command: " + command); } ParseLine(output, command, client, classApiRoot, aliasManager, onlyResult); }); }); } }
/// <summary> /// Sub commands /// </summary> /// <param name="parent"></param> /// <param name="client"></param> /// <param name="classApiRoot"></param> internal static void SumCommands(CommandLineApplication parent, PveClient client, ClassApi classApiRoot) { Execute(parent, MethodType.Get, "Get (GET) from resource", client, classApiRoot); Execute(parent, MethodType.Set, "Set (PUT) from resource", client, classApiRoot); Execute(parent, MethodType.Create, "Create (POST) from resource", client, classApiRoot); Execute(parent, MethodType.Delete, "Delete (DELETE) from resource", client, classApiRoot); Usage(parent, classApiRoot); List(parent, client, classApiRoot); }
private static void List(CommandLineApplication parent, PveClient client, ClassApi classApiRoot) { parent.Command("ls", cmd => { cmd.Description = "List child objects on <api_path>."; cmd.AddFullNameLogo(); var argResource = CreateResourceArgument(cmd); cmd.OnExecute(() => Console.Out.Write(ApiExplorer.List(client ?? cmd.ClientTryLogin(), classApiRoot ?? GetClassApiRoot(parent), argResource.Value))); }); }
public async Task <IHttpActionResult> GetClasses(int id) { var list = new List <Class> { await db.Classes.FindAsync(id) }; if (list == null) { return(NotFound()); } var wrapperClass = new ClassApi { Classes = list }; return(Ok(wrapperClass)); }
private static void Usage(CommandLineApplication parent, ClassApi classApiRoot) { parent.Command("usage", cmd => { cmd.Description = "Usage resource"; cmd.AddFullNameLogo(); var argResource = CreateResourceArgument(cmd); var optVerbose = cmd.VerboseOption(); var optCommand = cmd.OptionEnum <MethodType>("--command|-c", "API command"); var optResturns = cmd.Option("--returns|-r", "Including schema for returned data.", CommandOptionType.NoValue); cmd.OnExecute(() => { Console.Out.Write(ApiExplorer.Usage(classApiRoot ?? GetClassApiRoot(parent), argResource.Value, optResturns.HasValue(), optCommand.Value(), optVerbose.HasValue())); }); }); }
private static void Execute(CommandLineApplication parent, MethodType methodType, string description, PveClient client, ClassApi classApiRoot) { parent.Command(methodType.ToString().ToLower(), cmd => { cmd.Description = description; cmd.AddFullNameLogo(); var optVerbose = cmd.VerboseOption(); var argResource = CreateResourceArgument(cmd); var argParameters = cmd.Argument("parameters", "Parameter for resource format key:value (Multiple)." + " If value have space or special charapter using quote 'key:value'", true); var optOutput = cmd.OptionEnum <ApiExplorer.OutputType>("--output|-o", "Type output (default: unicode)"); var optWait = cmd.WaitOption(); cmd.OnExecute(() => { client = client ?? parent.ClientTryLogin(); classApiRoot = classApiRoot ?? GetClassApiRoot(client); var ret = ApiExplorer.Execute(client, classApiRoot, argResource.Value, methodType, ApiExplorer.CreateParameterResource(argParameters.Values), optWait.HasValue(), optOutput.GetEnumValue <ApiExplorer.OutputType>(), optVerbose.HasValue()); parent.Out.Write(ret.ResultText); return(ret.ResultCode); }); }); }
/// <summary> /// Initialization of the mining pool. /// </summary> /// <returns></returns> private static bool InitializeMiningPool() { ClassLog.ConsoleWriteLog("Initialize Log system..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true); if (ClassLog.LogInitialization()) { ClassLog.ConsoleWriteLog("Initialize pool settings..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true); if (MiningPoolSettingInitialization.InitializationPoolSettingFile()) { ClassLog.ConsoleWriteLog("Pool settings initialized.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleGreenLog, true); ClassLog.ConsoleWriteLog("Intialize pool databases..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true); if (ClassMiningPoolDatabase.InitializationMiningPoolDatabases()) { ClassMiningPoolDatabase.AutoSaveMiningPoolDatabases(); ClassLog.ConsoleWriteLog("Pool databases initialized.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleGreenLog, true); ClassLog.ConsoleWriteLog("Log System initialized.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleGreenLog, true); ThreadNetworkBlockchain = new Thread(async delegate() { ClassLog.ConsoleWriteLog("Connect Pool to the network for retrieve current blocktemplate..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true); bool notConnected = true; while (notConnected) { Certificate = ClassUtils.GenerateCertificate(); while (!await ClassNetworkBlockchain.ConnectToBlockchainAsync()) { Thread.Sleep(5000); ClassLog.ConsoleWriteLog("Can't connect Pool to the network, retry in 5 seconds.. (Press CTRL+C to cancel and close the pool.)", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true); } Certificate = ClassUtils.GenerateCertificate(); ClassLog.ConsoleWriteLog("Certificate generate, send to the network..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true); if (!await ClassNetworkBlockchain.SendPacketToNetworkBlockchain(Certificate, false)) { ClassLog.ConsoleWriteLog("Can't send certificate, reconnect now..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true); } else { ClassLog.ConsoleWriteLog("Certificate sent, start to login..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true); ClassNetworkBlockchain.ListenBlockchain(); Thread.Sleep(1000); if (!await ClassNetworkBlockchain.SendPacketToNetworkBlockchain(ClassConnectorSettingEnumeration.MinerLoginType + "|" + MiningPoolSetting.MiningPoolWalletAddress, true)) { ClassLog.ConsoleWriteLog("Can't login to the network, reconnect now.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true); } else { ClassLog.ConsoleWriteLog("Login successfully sent, waiting confirmation..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true); notConnected = false; } } if (notConnected) { ClassLog.ConsoleWriteLog("Can't long Pool to the network, retry in 5 seconds.. (Press CTRL+C to cancel and close the pool.)", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true); Thread.Sleep(5000); } else { break; } } }) { IsBackground = true }; ThreadNetworkBlockchain.Start(); if (MiningPoolSetting.MiningPoolEnableFiltering) { ClassLog.ConsoleWriteLog("Enable Filtering Miner System..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true); ClassFilteringMiner.EnableFilteringMiner(); } if (MiningPoolSetting.MiningPoolEnableCheckMinerStats) { ClassLog.ConsoleWriteLog("Enable Check Miner Stats System..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true); ClassMinerStats.EnableCheckMinerStats(); } if (MiningPoolSetting.MiningPoolEnableTrustedShare) { ClassLog.ConsoleWriteLog("Enable Trusted Share System..", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true); ClassMinerStats.EnableCheckTrustedMinerStats(); } if (MiningPoolSetting.MiningPoolEnablePayment) { ClassPayment.EnableAutoPaymentSystem(); } if (MiningPoolSetting.MiningPoolMiningPort.Count > 0) { foreach (var miningPoolPort in MiningPoolSetting.MiningPoolMiningPort) { var miningPoolObject = new ClassMiningPool(miningPoolPort.Key, miningPoolPort.Value); miningPoolObject.StartMiningPool(); ListMiningPool.Add(miningPoolPort.Key, miningPoolObject); } ClassApi.StartApiHttpServer(); EnableMiningPoolCommandLine(); } else { ClassLog.ConsoleWriteLog("Cannot start mining pool, their is any ports on the setting.", ClassLogEnumeration.IndexPoolGeneralErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true); return(false); } } else { return(false); } } else { return(false); } } else { return(false); } return(true); }
/// <summary> /// Enable mining pool command line. /// </summary> private static void EnableMiningPoolCommandLine() { ThreadMiningPoolCommandLines = new Thread(delegate() { while (!Exit) { string commandLine = Console.ReadLine(); try { var splitCommandLine = commandLine.Split(new char[0], StringSplitOptions.None); switch (splitCommandLine[0].ToLower()) { case MiningPoolCommandLinesEnumeration.MiningPoolCommandLineHelp: ClassLog.ConsoleWriteLog(MiningPoolCommandLinesEnumeration.MiningPoolCommandLineHelp + " - Command line to get list of commands details.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true); ClassLog.ConsoleWriteLog(MiningPoolCommandLinesEnumeration.MiningPoolCommandLineStats + " - Show mining pool stats.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true); ClassLog.ConsoleWriteLog(MiningPoolCommandLinesEnumeration.MiningPoolCommandLineBanMiner + " - ban a miner wallet address, syntax: " + MiningPoolCommandLinesEnumeration.MiningPoolCommandLineBanMiner + " wallet_address time", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true); ClassLog.ConsoleWriteLog(MiningPoolCommandLinesEnumeration.MiningPoolCommandLineBanMinerList + " - Show the list of miner wallet address banned.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true); ClassLog.ConsoleWriteLog(MiningPoolCommandLinesEnumeration.MiningPoolCommandLineUnBanMiner + " - Permit to unban a wallet address, syntax: " + MiningPoolCommandLinesEnumeration.MiningPoolCommandLineUnBanMiner + " wallet_address", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true); ClassLog.ConsoleWriteLog(MiningPoolCommandLinesEnumeration.MiningPoolCommandLineExit + " - Stop mining pool, save and exit.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true); break; case MiningPoolCommandLinesEnumeration.MiningPoolCommandLineStats: ClassLog.ConsoleWriteLog("Mining Pool Stats: ", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true); ClassLog.ConsoleWriteLog("Total miners connected: " + ClassMiningPoolGlobalStats.TotalWorkerConnected, ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true); ClassLog.ConsoleWriteLog("Total blocks found: " + ClassMiningPoolGlobalStats.TotalBlockFound, ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true); ClassLog.ConsoleWriteLog("Total miners hashrate: " + ClassMiningPoolGlobalStats.TotalMinerHashrate.ToString("F2"), ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true); ClassLog.ConsoleWriteLog("Pool Wallet Total Balance: " + ClassMiningPoolGlobalStats.PoolCurrentBalance + " " + ClassConnectorSetting.CoinNameMin, ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true); ClassLog.ConsoleWriteLog("Pool Wallet Total Balance in Pending: " + ClassMiningPoolGlobalStats.PoolPendingBalance + " " + ClassConnectorSetting.CoinNameMin, ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true); if (ClassNetworkBlockchain.IsConnected) { ClassLog.ConsoleWriteLog("Mining pool is connected to retrieve last blocktemplate.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleMagentaLog, true); } else { ClassLog.ConsoleWriteLog("Mining pool is not connected to retrieve last blocktemplate.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true); } break; case MiningPoolCommandLinesEnumeration.MiningPoolCommandLineBanMiner: string walletAddress = splitCommandLine[1]; if (!ClassMinerStats.ManualBanWalletAddress(walletAddress, int.Parse(splitCommandLine[2]))) { ClassLog.ConsoleWriteLog("Cannot ban wallet address: " + walletAddress + " because this one not exist.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true); } else { ClassLog.ConsoleWriteLog("Wallet address: " + walletAddress + " is banned successfully pending " + splitCommandLine[2] + " second(s).", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true); } break; case MiningPoolCommandLinesEnumeration.MiningPoolCommandLineBanMinerList: if (ClassMinerStats.DictionaryMinerStats.Count > 0) { int totalBanned = 0; foreach (var minerStats in ClassMinerStats.DictionaryMinerStats) { if (minerStats.Value.IsBanned) { long minerBanTime = minerStats.Value.DateOfBan - DateTimeOffset.Now.ToUnixTimeSeconds(); ClassLog.ConsoleWriteLog("Wallet address: " + minerStats.Key + " is banned pending: " + minerBanTime + " second(s).", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true); totalBanned++; } else { if (minerStats.Value.TotalBan > MiningPoolSetting.MiningPoolMaxTotalBanMiner) { ClassLog.ConsoleWriteLog("Wallet address: " + minerStats.Key + " is banned forever (until to restart the pool or manual unban).", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true); totalBanned++; } } } if (totalBanned == 0) { ClassLog.ConsoleWriteLog("Their is any miner(s) banned.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleGreenLog, true); } } break; case MiningPoolCommandLinesEnumeration.MiningPoolCommandLineUnBanMiner: if (ClassMinerStats.DictionaryMinerStats.Count > 0) { if (ClassMinerStats.DictionaryMinerStats.ContainsKey(splitCommandLine[1])) { ClassMinerStats.DictionaryMinerStats[splitCommandLine[1]].DateOfBan = 0; ClassMinerStats.DictionaryMinerStats[splitCommandLine[1]].IsBanned = false; ClassMinerStats.DictionaryMinerStats[splitCommandLine[1]].TotalBan = 0; ClassLog.ConsoleWriteLog("Miner wallet address: " + splitCommandLine[1] + " is unbanned.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleGreenLog, true); } else { ClassLog.ConsoleWriteLog("Miner wallet address: " + splitCommandLine[1] + " not exist.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true); } } else { ClassLog.ConsoleWriteLog("Miner wallet address: " + splitCommandLine[1] + " not exist.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleYellowLog, true); } break; case MiningPoolCommandLinesEnumeration.MiningPoolCommandLineExit: if (ClassPayment.PoolOnSendingTransaction) { ClassLog.ConsoleWriteLog("Can't close mining pool, the pool is currently on sending transaction(s).", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true); } else { if (ClassPayment.PoolOnProceedBlockReward) { ClassLog.ConsoleWriteLog("Can't close mining pool, the pool is currently on proceed block reward(s).", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true); } else { Exit = true; new Thread(delegate() { if (ListMiningPool.Count > 0) { foreach (var miningPool in ListMiningPool) { miningPool.Value.StopMiningPool(); } } ClassApi.StopApiHttpServer(); ClassMinerStats.StopCheckMinerStats(); ClassPayment.StopAutoPaymentSystem(); ClassFilteringMiner.StopFileringMiner(); ClassMiningPoolDatabase.StopAutoSaveMiningPoolDatabases(); ClassLog.ConsoleWriteLog("Mining pool stopped.", ClassLogEnumeration.IndexPoolGeneralLog, ClassLogConsoleEnumeration.IndexPoolConsoleBlueLog, true); ClassLog.StopLogSystem(); if (ThreadMiningPoolCommandLines != null && (ThreadMiningPoolCommandLines.IsAlive || ThreadMiningPoolCommandLines != null)) { ThreadMiningPoolCommandLines.Abort(); GC.SuppressFinalize(ThreadMiningPoolCommandLines); } }).Start(); } } break; } } catch (Exception error) { ClassLog.ConsoleWriteLog("Error on command line: " + commandLine + " exception: " + error.Message, ClassLogEnumeration.IndexPoolGeneralErrorLog, ClassLogConsoleEnumeration.IndexPoolConsoleRedLog, true); } } }); ThreadMiningPoolCommandLines.Start(); }
private static bool ParseLine(string input, PveClient client, ClassApi classApiRoot, AliasManager aliasManager, bool onlyResult) { if (string.IsNullOrWhiteSpace(input)) { return(false); } input = input.Trim(); //comment if (input.StartsWith("#")) { return(false); } using (var app = new CommandLineApplication()) { var exit = false; app.Name = ""; app.Description = "Corsinvest Interactive Shell API for Proxmox VE"; app.DebugOption(); app.DryRunOption(); app.UsePagerForHelpText = false; app.HelpOption(true); ShellCommands.SumCommands(app, client, classApiRoot); //fix help text foreach (var command in app.Commands) { command.FullName = app.Description; command.ExtendedHelpText = ""; command.UsePagerForHelpText = false; } //create command from alias CreateCommandFromAlias(app, client, classApiRoot, aliasManager, onlyResult); #region Commands base app.Command("quit", cmd => { cmd.AddName("exit"); cmd.Description = "Close application"; cmd.OnExecute(() => exit = true); }); app.Command("clear", cmd => { cmd.AddName("cls"); cmd.Description = "Clear screen"; cmd.OnExecute(() => Console.Clear()); }); app.Command("help", cmd => { cmd.Description = "Show help information"; cmd.OnExecute(() => app.ShowHelp()); }); CmdAlias(app, aliasManager); CmdHistory(app, onlyResult); #endregion app.OnExecute(() => app.ShowHint()); //execute command try { app.Execute(StringHelper.TokenizeCommandLineToList(input).ToArray()); } catch (CommandParsingException ex) { Console.Out.WriteLine(ex.Message); } catch (Exception) { } return(exit); } }
public static void Main(string[] args) { ProxyDateStart = DateTimeOffset.Now.ToUnixTimeSeconds(); Console.CancelKeyPress += Console_CancelKeyPress; ExceptionUnexpectedHandler(); Thread.CurrentThread.Name = Path.GetFileName(Environment.GetCommandLineArgs()[0]); ConsoleLog.WriteLine("Xiropht Proxy Solo Miner - " + Assembly.GetExecutingAssembly().GetName().Version + "R", ClassConsoleColorEnumeration.IndexConsoleMagentaLog); ReadConfig(); if (Config.WriteLog) { ConsoleLog.InitializeLog(); ConsoleLog.WriteLine("Write Log Enabled.", ClassConsoleColorEnumeration.IndexConsoleMagentaLog); } ConsoleLog.WriteLine("Wallet Address selected: " + Config.WalletAddress, ClassConsoleColorEnumeration.IndexConsoleMagentaLog); ConsoleLog.WriteLine("Proxy IP Selected: " + Config.ProxyIP, ClassConsoleColorEnumeration.IndexConsoleMagentaLog); ConsoleLog.WriteLine("Proxy Port Selected: " + Config.ProxyPort, ClassConsoleColorEnumeration.IndexConsoleMagentaLog); if (Config.EnableApi) { ConsoleLog.WriteLine("Start HTTP API..", ClassConsoleColorEnumeration.IndexConsoleMagentaLog); ClassApi.StartApiHttpServer(); ConsoleLog.WriteLine("HTTP API started.", ClassConsoleColorEnumeration.IndexConsoleMagentaLog); } ThreadCheckNetworkConnection = new Thread(async delegate() { bool connectSuccess = false; while (!connectSuccess) { while (!await NetworkBlockchain.ConnectToBlockchainAsync()) { ConsoleLog.WriteLine("Can't connect to the network, retry in 5 seconds..", ClassConsoleColorEnumeration.IndexConsoleMagentaLog); Thread.Sleep(5000); } ConsoleLog.WriteLine("Connection success, generate dynamic certificate for the network.", ClassConsoleColorEnumeration.IndexConsoleGreenLog); NetworkCertificate = ClassUtils.GenerateCertificate(); ConsoleLog.WriteLine("Certificate generate, send to the network..", ClassConsoleColorEnumeration.IndexConsoleYellowLog); if (!await NetworkBlockchain.SendPacketAsync(NetworkCertificate, false)) { ConsoleLog.WriteLine("Can't send certificate, reconnect now..", ClassConsoleColorEnumeration.IndexConsoleRedLog); } else { ConsoleLog.WriteLine("Certificate sent, start to login..", ClassConsoleColorEnumeration.IndexConsoleYellowLog); NetworkBlockchain.ListenBlockchain(); Thread.Sleep(1000); if (!await NetworkBlockchain.SendPacketAsync(ClassConnectorSettingEnumeration.MinerLoginType + "|" + Config.WalletAddress, true)) { ConsoleLog.WriteLine("Can't login to the network, reconnect now.", ClassConsoleColorEnumeration.IndexConsoleRedLog); } else { ConsoleLog.WriteLine("Login successfully sent, waiting confirmation..", ClassConsoleColorEnumeration.IndexConsoleYellowLog); connectSuccess = true; } } } }); ThreadCheckNetworkConnection.Start(); ThreadProxyCommandLine = new Thread(delegate() { while (true) { string commandLine = GetHiddenConsoleInput(); CommandLine(commandLine); } }); ThreadProxyCommandLine.Start(); }
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(); }
public void Init() { instance = new ClassApi(); }
static void Main(string[] args) { EnableCatchUnexpectedException(); Console.CancelKeyPress += Console_CancelKeyPress; Thread.CurrentThread.Name = Path.GetFileName(Environment.GetCommandLineArgs()[0]); GlobalCultureInfo = new CultureInfo("fr-FR"); ClassLog.LogInitialization(); ServicePointManager.DefaultConnectionLimit = 65535; ClassConsole.ConsoleWriteLine(ClassConnectorSetting.CoinName + " RPC Wallet - " + Assembly.GetExecutingAssembly().GetName().Version + "R", ClassConsoleColorEnumeration.IndexConsoleBlueLog, LogLevel); if (ClassRpcSetting.InitializeRpcWalletSetting()) { ClassConsole.ConsoleWriteLine("Please write your rpc wallet password for decrypt your databases of wallet (Input keys are hidden): ", ClassConsoleColorEnumeration.IndexConsoleYellowLog, LogLevel); ClassRpcDatabase.SetRpcDatabasePassword(ClassUtility.GetHiddenConsoleInput()); ClassConsole.ConsoleWriteLine("RPC Wallet Database loading..", ClassConsoleColorEnumeration.IndexConsoleYellowLog, LogLevel); if (ClassRpcDatabase.LoadRpcDatabaseFile()) { ClassConsole.ConsoleWriteLine("RPC Wallet Database successfully loaded.", ClassConsoleColorEnumeration.IndexConsoleGreenLog, LogLevel); ClassConsole.ConsoleWriteLine("RPC Sync Database loading..", ClassConsoleColorEnumeration.IndexConsoleYellowLog, LogLevel); if (ClassSyncDatabase.InitializeSyncDatabase()) { ClassConsole.ConsoleWriteLine("RPC Sync Database successfully loaded.", ClassConsoleColorEnumeration.IndexConsoleGreenLog, LogLevel); if (ClassRpcSetting.WalletEnableAutoUpdateWallet) { ClassConsole.ConsoleWriteLine("Enable Auto Update Wallet System..", ClassConsoleColorEnumeration.IndexConsoleYellowLog, LogLevel); ClassWalletUpdater.EnableAutoUpdateWallet(); ClassConsole.ConsoleWriteLine("Enable Auto Update Wallet System done.", ClassConsoleColorEnumeration.IndexConsoleGreenLog, LogLevel); } ClassConsole.ConsoleWriteLine("Start RPC Wallet API Server..", ClassConsoleColorEnumeration.IndexConsoleYellowLog, LogLevel); ClassApi.StartApiHttpServer(); ClassConsole.ConsoleWriteLine("Start RPC Wallet API Server sucessfully started.", ClassConsoleColorEnumeration.IndexConsoleGreenLog, LogLevel); if (ClassRpcSetting.RpcWalletEnableRemoteNodeSync && ClassRpcSetting.RpcWalletRemoteNodeHost != string.Empty && ClassRpcSetting.RpcWalletRemoteNodePort != 0) { ClassConsole.ConsoleWriteLine("RPC Remote Node Sync system loading..", ClassConsoleColorEnumeration.IndexConsoleYellowLog, LogLevel); ThreadRemoteNodeSync = new Thread(async() => await ClassRemoteSync.ConnectRpcWalletToRemoteNodeSyncAsync()); ThreadRemoteNodeSync.Start(); } ClassConsole.ConsoleWriteLine("Enable Command Line system.", ClassConsoleColorEnumeration.IndexConsoleGreenLog, LogLevel); ClassConsoleCommandLine.EnableConsoleCommandLine(); } else { ClassConsole.ConsoleWriteLine("Cannot read RPC Sync Database, the database is maybe corrupted.", ClassConsoleColorEnumeration.IndexConsoleRedLog, LogLevel); Console.WriteLine("Press ENTER to exit."); Console.ReadLine(); Environment.Exit(0); } } else { ClassConsole.ConsoleWriteLine("Cannot read RPC Wallet Database, the database is maybe corrupted.", ClassConsoleColorEnumeration.IndexConsoleRedLog, LogLevel); Console.WriteLine("Press ENTER to exit."); Console.ReadLine(); Environment.Exit(0); } } else { ClassConsole.ConsoleWriteLine("Cannot read RPC Wallet setting, the setting is maybe corrupted, you can delete your setting file to build another one.", ClassConsoleColorEnumeration.IndexConsoleRedLog, LogLevel); Console.WriteLine("Press ENTER to exit."); Console.ReadLine(); Environment.Exit(0); } }
public static ClassApi GetClassApiRoot() => _classApiRoot ?? (_classApiRoot = GeneretorClassApi.Generate(Host, Port));
/// <summary> /// Execute methods /// </summary> /// <param name="client"></param> /// <param name="classApiRoot"></param> /// <param name="resource"></param> /// <param name="methodType"></param> /// <param name="parameters"></param> /// <param name="wait"></param> /// <param name="outputType"></param> /// <param name="verbose"></param> public static (int ResultCode, string ResultText) Execute(PveClient client, ClassApi classApiRoot, string resource, MethodType methodType, Dictionary <string, object> parameters, bool wait = false, OutputType outputType = OutputType.Unicode, bool verbose = false) { var currResponseType = client.ResponseType; if (outputType == OutputType.Png) { client.ResponseType = ResponseType.Png; } //create result Result result = null; switch (methodType) { case MethodType.Get: result = client.Get(resource, parameters); break; case MethodType.Set: result = client.Set(resource, parameters); break; case MethodType.Create: result = client.Create(resource, parameters); break; case MethodType.Delete: result = client.Delete(resource, parameters); break; } //restore prev ResponseType currResponseType = client.ResponseType; var resultText = new StringBuilder(); if (result != null && !result.IsSuccessStatusCode) { resultText.AppendLine(result.ReasonPhrase); resultText.AppendLine(verbose ? PveClient.ObjectToJson((string)result.Response.errors) : result.GetError()); } else if (result.InError()) { resultText.AppendLine(result.ReasonPhrase); } else { //print result if (verbose) { //verbose full response json resultText.AppendLine(PveClient.ObjectToJson(result.Response)); } else { switch (outputType) { case OutputType.Png: resultText.AppendLine(result.Response); break; case OutputType.Json: resultText.AppendLine(PveClient.ObjectToJson(result.Response.data, false)); break; case OutputType.JsonPretty: resultText.AppendLine(PveClient.ObjectToJson(result.Response.data)); break; case OutputType.Text: case OutputType.Html: case OutputType.Unicode: case OutputType.UnicodeAlt: case OutputType.Markdown: var data = result.Response.data; var tableOutput = DecodeOutputType(outputType); var classApi = ClassApi.GetFromResource(classApiRoot, resource); if (classApi == null) { resultText.AppendLine($"no such resource '{resource}'"); } else { var returnParameters = classApi.Methods .Where(a => a.IsGet) .FirstOrDefault() .ReturnParameters; if (returnParameters.Count == 0) { //no return defined resultText.Append(TableHelper.Create(data, null, false, tableOutput, null)); } else { var keys = returnParameters.OrderBy(a => a.Optional) .ThenBy(a => a.Name) .Select(a => a.Name) .ToArray(); resultText.Append(TableHelper.Create(data, keys, false, tableOutput, returnParameters)); } } break; default: break; } } if (wait) { var task = (string)result.Response.data; client.WaitForTaskToFinish(task.Split(':')[1], task, 1000, 30000); } } return((int)result.StatusCode, resultText.ToString()); }
/// <summary> /// Usage resource /// </summary> /// <param name="classApiRoot"></param> /// <param name="resource"></param> /// <param name="outputType"></param> /// <param name="returnsType"></param> /// <param name="command"></param> /// <param name="verbose"></param> /// <returns></returns> public static string Usage(ClassApi classApiRoot, string resource, OutputType outputType, bool returnsType = false, string command = null, bool verbose = false) { var ret = new StringBuilder(); var classApi = ClassApi.GetFromResource(classApiRoot, resource); if (classApi == null) { ret.AppendLine($"no such resource '{resource}'"); } else { foreach (var method in classApi.Methods.OrderBy(a => a.MethodType)) { //exclude other command if (!string.IsNullOrWhiteSpace(command) && method.GetMethodTypeHumanized().ToLower() != command) { continue; } ret.Append($"USAGE: {method.GetMethodTypeHumanized()} {resource}"); //only parameters no keys var parameters = method.Parameters.Where(a => !classApi.Keys.Contains(a.Name)); var opts = string.Join("", parameters.Where(a => !a.Optional).Select(a => $" {a.Name}:<{a.Type}>")); if (!string.IsNullOrWhiteSpace(opts)) { ret.Append(opts); } //optional parameter if (parameters.Where(a => a.Optional).Count() > 0) { ret.Append(" [OPTIONS]"); } ret.AppendLine(); if (verbose) { ret.AppendLine().AppendLine(" " + method.Comment); CreateTable(parameters, ret, outputType); } if (returnsType) { //show returns ret.AppendLine("RETURNS:"); CreateTable(method.ReturnParameters, ret, outputType); } if (verbose) { ret.AppendLine(); } } } return(ret.ToString()); }
/// <summary> /// List values resource /// </summary> /// <param name="client"></param> /// <param name="classApiRoot"></param> /// <param name="resource"></param> /// <returns></returns> public static (IEnumerable <(string Attribute, string Value)> Values, string Error) ListValues(PveClient client, ClassApi classApiRoot, string resource) { var values = new List <(string Attribute, string Value)>(); var error = ""; var classApi = ClassApi.GetFromResource(classApiRoot, resource); if (classApi == null) { error = $"no such resource '{resource}'"; } else { if (classApi.SubClasses.Count == 0) { error = $"resource '{resource}' does not define child links"; } else { string key = null; foreach (var subClass in classApi.SubClasses.OrderBy(a => a.Name)) { var attribute = string.Join("", new[] { subClass.SubClasses.Count > 0 ? "D" : "-", "r--", subClass.Methods.Any(a => a.IsPost)? "c" : "-" }); if (subClass.IsIndexed) { var result = client.Get(resource); if (result.InError()) { error = result.GetError(); } else { if (key == null) { key = classApi.Methods.Where(a => a.IsGet) .FirstOrDefault() .ReturnLinkHRef .Replace("{", "") .Replace("}", ""); } if (result.Response.data != null) { var data = new List <object>(); foreach (IDictionary <string, object> item in result.Response.data) { data.Add(item[key]); } foreach (var item in data.OrderBy(a => a)) { values.Add((attribute, item + "")); } } } } else { values.Add((attribute, subClass.Name)); } } } } return(values, error); }
/// <summary> /// Enable console command line. /// </summary> public static void EnableConsoleCommandLine() { ThreadConsoleCommandLine = new Thread(async delegate() { while (!Program.Exit) { string commandLine = Console.ReadLine(); if (Program.Exit) { break; } try { var splitCommandLine = commandLine.Split(new char[0], StringSplitOptions.None); switch (splitCommandLine[0]) { case ClassConsoleCommandLineEnumeration.CommandLineHelp: ClassConsole.ConsoleWriteLine(ClassConsoleCommandLineEnumeration.CommandLineHelp + " -> show list of command lines.", ClassConsoleColorEnumeration.IndexConsoleMagentaLog, Program.LogLevel); ClassConsole.ConsoleWriteLine(ClassConsoleCommandLineEnumeration.CommandLineCreateWallet + " -> permit to create a new wallet manualy.", ClassConsoleColorEnumeration.IndexConsoleMagentaLog, Program.LogLevel); ClassConsole.ConsoleWriteLine(ClassConsoleCommandLineEnumeration.CommandLineRestoreWallet + " -> permit to restore a wallet manualy. Syntax: " + ClassConsoleCommandLineEnumeration.CommandLineRestoreWallet + " wallet_address", ClassConsoleColorEnumeration.IndexConsoleMagentaLog, Program.LogLevel); ClassConsole.ConsoleWriteLine(ClassConsoleCommandLineEnumeration.CommandLineSaveWallet + " -> permit to save manually the database of wallets.", ClassConsoleColorEnumeration.IndexConsoleMagentaLog, Program.LogLevel); ClassConsole.ConsoleWriteLine(ClassConsoleCommandLineEnumeration.CommandLineLogLevel + " -> change log level. Max log level: " + ClassConsole.MaxLogLevel, ClassConsoleColorEnumeration.IndexConsoleMagentaLog, Program.LogLevel); break; case ClassConsoleCommandLineEnumeration.CommandLineCreateWallet: using (var walletCreatorObject = new ClassWalletCreator()) { new Thread(async delegate() { if (!await walletCreatorObject.StartWalletConnectionAsync(ClassWalletPhase.Create, ClassUtility.MakeRandomWalletPassword())) { ClassConsole.ConsoleWriteLine("RPC Wallet cannot create a new wallet.", ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel); } }).Start(); while (walletCreatorObject.WalletCreateResult == ClassWalletCreatorEnumeration.WalletCreatorPending) { Thread.Sleep(100); } switch (walletCreatorObject.WalletCreateResult) { case ClassWalletCreatorEnumeration.WalletCreatorError: ClassConsole.ConsoleWriteLine("RPC Wallet cannot create a new wallet.", ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel); break; case ClassWalletCreatorEnumeration.WalletCreatorSuccess: ClassConsole.ConsoleWriteLine("RPC Wallet successfully create a new wallet.", ClassConsoleColorEnumeration.IndexConsoleGreenLog, Program.LogLevel); ClassConsole.ConsoleWriteLine("New wallet address generated: " + walletCreatorObject.WalletAddressResult, ClassConsoleColorEnumeration.IndexConsoleBlueLog, Program.LogLevel); break; } } break; case ClassConsoleCommandLineEnumeration.CommandLineRestoreWallet: if (splitCommandLine.Length < 2) { ClassConsole.ConsoleWriteLine("Please, put the wallet address to restore.", ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel); } else { if (ClassRpcDatabase.RpcDatabaseContent.ContainsKey(splitCommandLine[1])) { using (var walletCreatorObject = new ClassWalletCreator()) { new Thread(async delegate() { if (!await walletCreatorObject.StartWalletConnectionAsync(ClassWalletPhase.Restore, ClassUtility.MakeRandomWalletPassword(), ClassRpcDatabase.RpcDatabaseContent[splitCommandLine[1]].GetWalletPrivateKey(), splitCommandLine[1])) { ClassConsole.ConsoleWriteLine("RPC Wallet cannot restore your wallet: " + splitCommandLine[1], ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel); } }).Start(); while (walletCreatorObject.WalletCreateResult == ClassWalletCreatorEnumeration.WalletCreatorPending) { Thread.Sleep(100); } switch (walletCreatorObject.WalletCreateResult) { case ClassWalletCreatorEnumeration.WalletCreatorError: ClassConsole.ConsoleWriteLine("RPC Wallet cannot restore a wallet: " + splitCommandLine[1], ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel); break; case ClassWalletCreatorEnumeration.WalletCreatorSuccess: ClassConsole.ConsoleWriteLine("RPC Wallet successfully restore wallet: " + splitCommandLine[1], ClassConsoleColorEnumeration.IndexConsoleGreenLog, Program.LogLevel); ClassConsole.ConsoleWriteLine("RPC Wallet execute save the database of wallets..", ClassConsoleColorEnumeration.IndexConsoleYellowLog, Program.LogLevel); if (await ClassRpcDatabase.SaveWholeRpcWalletDatabaseFile()) { ClassConsole.ConsoleWriteLine("RPC Wallet save of the database of wallets done successfully.", ClassConsoleColorEnumeration.IndexConsoleGreenLog, Program.LogLevel); } else { ClassConsole.ConsoleWriteLine("RPC Wallet save of the database of wallets failed, please retry by command line: " + ClassConsoleCommandLineEnumeration.CommandLineSaveWallet, ClassConsoleColorEnumeration.IndexConsoleGreenLog, Program.LogLevel); } break; } } } else { ClassConsole.ConsoleWriteLine("Please, put a valid wallet address stored on the database of your rpc wallet to restore. " + splitCommandLine[1] + " not exist.", ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel); } } break; case ClassConsoleCommandLineEnumeration.CommandLineSaveWallet: if (await ClassRpcDatabase.SaveWholeRpcWalletDatabaseFile()) { ClassConsole.ConsoleWriteLine("RPC Wallet save of the database of wallets done successfully.", ClassConsoleColorEnumeration.IndexConsoleGreenLog, Program.LogLevel); } else { ClassConsole.ConsoleWriteLine("RPC Wallet save of the database of wallets failed, please retry by command line: " + ClassConsoleCommandLineEnumeration.CommandLineSaveWallet, ClassConsoleColorEnumeration.IndexConsoleGreenLog, Program.LogLevel); } break; case ClassConsoleCommandLineEnumeration.CommandLineLogLevel: if (splitCommandLine.Length > 1) { if (int.TryParse(splitCommandLine[1], out var logLevel)) { if (logLevel < 0) { logLevel = 0; } else { if (logLevel > ClassConsole.MaxLogLevel) { logLevel = ClassConsole.MaxLogLevel; } } ClassConsole.ConsoleWriteLine("New log level " + Program.LogLevel + " -> " + logLevel, ClassConsoleColorEnumeration.IndexConsoleMagentaLog, Program.LogLevel); Program.LogLevel = logLevel; } } else { ClassConsole.ConsoleWriteLine("Please select a log level.", ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel); } break; case ClassConsoleCommandLineEnumeration.CommandLineExit: Program.Exit = true; ClassConsole.ConsoleWriteLine("Closing RPC Wallet..", ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel); ClassApi.StopApiHttpServer(); if (ClassRpcSetting.RpcWalletEnableRemoteNodeSync) { ClassWalletUpdater.DisableAutoUpdateWallet(); } ClassRemoteSync.StopRpcWalletToSync(); if (Program.ThreadRemoteNodeSync != null && (Program.ThreadRemoteNodeSync.IsAlive || Program.ThreadRemoteNodeSync != null)) { Program.ThreadRemoteNodeSync.Abort(); GC.SuppressFinalize(Program.ThreadRemoteNodeSync); } ClassConsole.ConsoleWriteLine("Waiting end of save RPC Wallet Database..", ClassConsoleColorEnumeration.IndexConsoleYellowLog, Program.LogLevel); while (ClassRpcDatabase.InSave) { Thread.Sleep(100); } ClassConsole.ConsoleWriteLine("Waiting end of save RPC Wallet Sync Database..", ClassConsoleColorEnumeration.IndexConsoleYellowLog, Program.LogLevel); while (ClassSyncDatabase.InSave) { Thread.Sleep(100); } ClassLog.StopLogSystem(); ClassConsole.ConsoleWriteLine("RPC Wallet is successfully stopped, press ENTER to exit.", ClassConsoleColorEnumeration.IndexConsoleBlueLog, Program.LogLevel); Console.ReadLine(); Process.GetCurrentProcess().Kill(); break; } if (Program.Exit) { break; } } catch (Exception error) { ClassConsole.ConsoleWriteLine("Error command line exception: " + error.Message, ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel); ClassConsole.ConsoleWriteLine("For get help use command line " + ClassConsoleCommandLineEnumeration.CommandLineHelp, ClassConsoleColorEnumeration.IndexConsoleRedLog, Program.LogLevel); } } }); ThreadConsoleCommandLine.Start(); }
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); }