/// <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);
}
