public void Run(Guid currentUserId, Guid currentTaskId, Guid currentViewId, Kanban kanban, IWin32Window owner)
{
if (PersonalKanban == null)
{
// is kanba thread safe... Time will tell!
PersonalKanban = kanban;
}
if (restServer == null && server == null)
{
server = new RESTServer();
restServer = new BackgroundWorker();
restServer.WorkerSupportsCancellation = true;
restServer.DoWork += (sender, args) =>
{
BackgroundWorker worker = sender as BackgroundWorker;
// Server Code.
AutoClosingMessageBox.Show("Server Started...", "Personal Kanban REST Service", MessageBoxButtons.OK, MessageBoxIcon.Information, 1000);
server.Start();
while (server.IsListening && !worker.CancellationPending)
{
Thread.Sleep(300);
}
server.Stop();
};
restServer.RunWorkerCompleted += (sender, args) =>
{
if (args.Cancelled)
{
// Nice Cleanup.
AutoClosingMessageBox.Show("Server Shutdown...", "Personal Kanban REST Service", MessageBoxButtons.OK, MessageBoxIcon.Information, 1000);
}
else if (args.Error != null)
{
// We broke :(
AutoClosingMessageBox.Show("Server Crashed...", "Personal Kanban REST Service", MessageBoxButtons.OK, MessageBoxIcon.Error, 1000);
}
else
{
// Who knows!
AutoClosingMessageBox.Show("Server Shutdown...", "Personal Kanban REST Service", MessageBoxButtons.OK, MessageBoxIcon.Question, 1000);
}
};
}
if (restServer.IsBusy)
{
restServer.CancelAsync();
}
else
{
restServer.RunWorkerAsync(kanban);
}
}
public static void Main(string[] args)
{
var requestHandler = new CeDomain.RequestHandler(new CeWeighting.Weighting());
using (var server = new RESTServer(args[0], requestHandler)) {
server.WaitForConsole();
}
}
public void Start()
{
server = new RESTServer(port: "12358");
server.Start();
if (!server.IsListening)
{
throw new InvalidOperationException("Server cannot be started");
}
}
/// <summary>
/// Empty implementation of the ILeanManager interface
/// </summary>
/// <param name="systemHandlers">Exposes lean engine system handlers running LEAN</param>
/// <param name="algorithmHandlers">Exposes the lean algorithm handlers running lean</param>
/// <param name="job">The job packet representing either a live or backtest Lean instance</param>
/// <param name="algorithmManager">The Algorithm manager</param>
public void Initialize(LeanEngineSystemHandlers systemHandlers, LeanEngineAlgorithmHandlers algorithmHandlers, AlgorithmNodePacket job, AlgorithmManager algorithmManager)
{
// NOP
var server = new RESTServer();
//var server = new RESTServer("*");
Console.WriteLine(String.Format("Core Router REST Server Listening On {0}:{1} @ {2}", server.Host, server.Port, server.BaseUrl));
server.Start();
Console.WriteLine("RaysLeanManager Initialized!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
}
public static void Main(String[] args)
{
Console.OutputEncoding = Encoding.Unicode;
// At first idea was to pass folder like "./Indexers" and "./Parsers"
// Load all assemblies from that folders and find implementation of interfaces
// After that we could load another implementations in runtime
// And choose required implementation per request
// But this produced several problems that are not required to solve
// But would take more to implement
IQueryParser parser = null;
IFileIndexer indexer = null;
var port = 1234;
var options = new Options();
if (Parser.Default.ParseArguments(args, options))
{
// -l "../../../AdvancedQueryParser/bin/{Debug/Release}/AdvancedQueryParser.dll" -p "TextIndexing.AdvancedQueryParser.IntersectionParser"
parser = LoadImplementation <IQueryParser>(options.ParserLibrary, options.ParserType);
indexer = LoadImplementation <IFileIndexer>(options.IndexerLibrary, options.IndexerType);
port = options.Port;
}
if (parser == null)
{
parser = new SimpleParser();
}
if (indexer == null)
{
indexer = new SimpleIndexer();
}
Console.WriteLine("IFileIndexer implementation loaded: {0}", indexer.GetType());
Console.WriteLine("IQueryParser implementation loaded: {0}", parser.GetType());
Index.Instance.Init(parser, indexer);
using (var server = new RESTServer(port: port.ToString()))
{
server.Start();
if (server.IsListening)
{
Console.WriteLine("Service started on port: {0}", server.Port);
}
else
{
Console.WriteLine("Failed to start service");
}
Console.ReadKey(true);
}
}
public void StartServer()
{
LOG.Write("Starting HTTP.");
var server = new RESTServer();
server.Start();
while (server.IsListening)
{
System.Threading.Thread.Sleep(300);
}
}
static async Task Main(string[] args)
{
RESTClient client;
string result;
Book book;
RESTServer server;
IRouteManager routeManager;
routeManager = new RouteManager(new RouteParser(), new ResponseSerializer());
routeManager.AddRouteHandler(new BooksRouteHandlers());
server = new RESTServer(new ConsoleLogger(new DefaultLogFormatter()), routeManager, "http://localhost:8734/");
server.Start();
Thread.Sleep(1000);
client = new RESTClient(new HttpConnector(), new ResponseDeserializer());
/*Console.WriteLine("Trying to query URL");
* result = await client.GetAsync("http://localhost:8734/root/books/500");
* Console.WriteLine("Result:");
* Console.WriteLine(result);*/
Console.WriteLine("Trying to query URL");
book = await client.GetAsync <Book>("http://localhost:8734/root/books/500");
Console.WriteLine("Result:");
Console.WriteLine(book);
Console.WriteLine("Trying to query URL");
book = await client.GetAsync <Book>("http://localhost:8734/root/books?year=2020&author=stephenking");
Console.WriteLine("Result:");
Console.WriteLine(book);
Console.WriteLine("Trying to query URL");
try
{
book = await client.GetAsync <Book>("http://localhost:8734/root/book/500");
}
catch (Exception ex)
{
Console.WriteLine("Result:");
Console.WriteLine(ex);
}
Console.ReadLine();
server.Stop();
Console.ReadLine();
}
private NexusAPI SetupNexusApi()
{
var apiCache = Settings.Node.ApiCache;
var apiLog = Settings.Node.ApiLog;
var apiProxyURL = Settings.Node.ApiProxyUrl;
var readOnlyMode = Settings.Node.Readonly;
var hasRPC = Settings.Node.HasRpc;
var hasREST = Settings.Node.HasRest;
NexusAPI nexusApi = new NexusAPI(_nexus, apiCache, apiLog ? Logger : null);
if (apiProxyURL != null)
{
nexusApi.ProxyURL = apiProxyURL;
// TEMP Normal node needs a proxy url set to relay transactions to the BPs
nexusApi.Node = _node;
Logger.Message($"API will be acting as proxy for {apiProxyURL}");
}
else
{
nexusApi.Node = _node;
}
if (readOnlyMode)
{
Logger.Warning($"Node will be running in read-only mode.");
}
else
{
nexusApi.Mempool = _mempool;
}
// RPC setup
if (hasRPC)
{
var rpcPort = Settings.Node.RpcPort;
Logger.Message($"RPC server listening on port {rpcPort}...");
var rpcServer = new RPCServer(nexusApi, "/rpc", rpcPort, (level, text) => WebLogMapper("rpc", level, text));
rpcServer.StartInThread(ThreadPriority.AboveNormal);
}
// REST setup
if (hasREST)
{
var restPort = Settings.Node.RestPort;
Logger.Message($"REST server listening on port {restPort}...");
var restServer = new RESTServer(nexusApi, "/api", restPort, (level, text) => WebLogMapper("rest", level, text));
restServer.StartInThread(ThreadPriority.AboveNormal);
}
return(nexusApi);
}
private DLLObjectWrapper()
{
mqlExperts = new Dictionary <Int64, MQLExpert>();
mqlCommandManagers = new Dictionary <Int64, MQLCommandManager>();
mqlThreadPools = new Dictionary <Int64, MQLThreadPool>();
mqlExpertsLock = new object();
restServer = new RESTServer();
restServer.Start();
// create the default command manager for REST
// Only need to use chart specific one for ChartObjects
mqlCommandManagers[DEFAULT_CHART_ID] = new MQLCommandManager(DEFAULT_CHART_ID, 0);
}
static void Main(string[] args)
{
Console.WriteLine($"Starting {ProductNameString}");
AppDomain.CurrentDomain.ProcessExit += new EventHandler(HandleExternalExit);
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(HandleUnhandledException);
//portable mode handling
CheckPortableMode(args);
SetupFolders();
LoadUserConfig();
//port override arg handling
CheckPortOverride(args);
MediaDB mediaDatabase = new MediaDB();
APIController apiController = new APIController(new APISurface(mediaDatabase));
RESTServer restServer = new RESTServer(apiController);
IsRunning = true;
//argument commands handling
if (args.Contains("-rebuild"))
{
mediaDatabase.StartRebuild();
}
if (args.Contains("-flushcache"))
{
MediaTranscoder.FlushCache();
}
while (IsRunning)
{
Thread.Sleep(10);
//TODO poll components?
}
Console.WriteLine("Ending XSMP");
restServer.Dispose();
mediaDatabase.Dispose();
}
public static void Start()
{
var exitEvent = new ManualResetEvent(false);
var options = new RestOptions();
if (CommandLine.Parser.Default.ParseArgumentsStrict(new string[0], options, () => { Environment.Exit(-2); }))
{
options.RunAsServer = true;
if (options.RunAsServer)
{
//
// As server
//
Console.CancelKeyPress += (sender, eventArgs) =>
{
eventArgs.Cancel = true;
exitEvent.Set();
};
Console.WriteLine("Run server on " + options.Host + ":" + options.Port);
Console.WriteLine("Press CTRL+C to terminate server.\n");
Console.WriteLine("Host: {0}:{1}", options.Host, options.Port);
try
{
var server = new RESTServer();
server.Host = options.Host;
server.Port = options.Port;
server.Start();
exitEvent.WaitOne();
server.Stop();
}
catch (Exception e)
{
Console.WriteLine(e.Message + "\n" + e.StackTrace);
}
}
}
}
public static void Main(string[] args)
{
var server = new RESTServer(Config.Get("server_host"))
{
Port = Config.Get("server_port")
};
bool isRunning = true;
Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e)
{
e.Cancel = true;
isRunning = false;
};
server.Start();
while (server.IsListening && isRunning)
{
Thread.Sleep(300);
}
server.Stop();
}
static void Main(string[] args)
{
ILogger logger;
VersionControlModule versionControlModule;
//ServiceHostModule serviceHostModule;
//IBotsService service;
RESTServer server;
IRouteManager routeManager;
IDatabase database;
IConnectionFactory connectionFactory;
ICommandBuilder commandBuilder;
IDatabaseCreator databaseCreator;
IBotModule botModule;
IOrderModule orderModule;
IOrderManagerModule orderManagerModule;
IProduceOrderModule produceOrderModule;
IHarvestOrderModule harvestOrderModule;
IBuildOrderModule buildOrderModule;
IBotSchedulerModule botSchedulerModule;
PIOServiceClient client;
quitEvent = new AutoResetEvent(false);
Console.CancelKeyPress += new ConsoleCancelEventHandler(Console_CancelKeyPress);
//logger = new ConsoleLogger(new DefaultLogFormatter());
logger = new UnicastLogger(IPAddress.Loopback, Properties.Settings.Default.UnicastPort);
//logger = new FileLogger(new DefaultLogFormatter(), "PIO.Bots.ServerHost.Log");
databaseCreator = new SqlDatabaseCreator(Properties.Settings.Default.Server, Properties.Settings.Default.DatabaseName);
connectionFactory = new SqlConnectionFactory(Properties.Settings.Default.Server, Properties.Settings.Default.DatabaseName);
commandBuilder = new SqlCommandBuilder();
database = new Database(connectionFactory, commandBuilder);
versionControlModule = new VersionControlModule(logger, databaseCreator, new BotsVersionControl(database));
if (!versionControlModule.InitializeDatabase(Properties.Settings.Default.DropDatabase))
{
Console.ReadLine();
return;
}
client = new PIOServiceClient(new BasicHttpBinding(), new EndpointAddress($@"http://127.0.0.1:8733/PIO/Service/"));
client.Open();
botModule = new BotModule(logger, database);
orderModule = new OrderModule(logger, database);
produceOrderModule = new ProduceOrderModule(logger, database);
harvestOrderModule = new HarvestOrderModule(logger, database);
buildOrderModule = new BuildOrderModule(logger, database);
orderManagerModule = new OrderManagerModule(logger, client, orderModule, produceOrderModule, harvestOrderModule, buildOrderModule, 10);
botSchedulerModule = new BotSchedulerModule(logger, client, botModule, orderManagerModule, 5);
botSchedulerModule.Start();
routeManager = new RouteManager(new RouteParser(), new ResponseSerializer());
routeManager.AddRouteHandler(new BotRouteHandler(botModule));
routeManager.AddRouteHandler(new ProduceOrderRouteHandler(produceOrderModule));
routeManager.AddRouteHandler(new HarvestOrderRouteHandler(harvestOrderModule));
routeManager.AddRouteHandler(new BuildOrderRouteHandler(buildOrderModule));
server = new RESTServer(logger, routeManager, "http://127.0.0.1:8734/");
server.Start();
WaitHandle.WaitAny(new WaitHandle[] { quitEvent }, -1);
server.Stop();
//serviceHostModule.Stop();
botSchedulerModule.Stop();
client.Close();
logger.Dispose();
Console.CancelKeyPress -= new ConsoleCancelEventHandler(Console_CancelKeyPress);
}
public static void Begin()
{
var server = new RESTServer(host: "*");
server.Start();
}
public void SetUp()
{
_host = new RESTServer(config);
_host.AddResource(new TestResource());
_host.Start();
}
public CLI(string[] args)
{
var seeds = new List <string>();
var settings = new Arguments(args);
var useGUI = settings.GetBool("gui.enabled", true);
if (useGUI)
{
gui = new ConsoleGUI();
logger = gui;
}
else
{
gui = null;
logger = new ConsoleLogger();
}
string mode = settings.GetString("node.mode", "validator");
bool hasRPC = settings.GetBool("rpc.enabled", false);
bool hasREST = settings.GetBool("rest.enabled", false);
string wif = settings.GetString("node.wif");
var nexusName = settings.GetString("nexus.name", "simnet");
var genesisAddress = Address.FromText(settings.GetString("nexus.genesis", KeyPair.FromWIF(validatorWIFs[0]).Address.Text));
switch (mode)
{
case "sender":
string host = settings.GetString("sender.host");
int threadCount = settings.GetInt("sender.threads", 8);
int addressesPerSender = settings.GetInt("sender.addressCount", 100);
RunSender(wif, host, threadCount, addressesPerSender);
Console.WriteLine("Sender finished operations.");
return;
case "validator": break;
default:
{
logger.Error("Unknown mode: " + mode);
return;
}
}
int defaultPort = 0;
for (int i = 0; i < validatorWIFs.Length; i++)
{
if (validatorWIFs[i] == wif)
{
defaultPort = (7073 + i);
}
}
if (defaultPort == 0)
{
defaultPort = (7073 + validatorWIFs.Length);
}
int port = settings.GetInt("node.port", defaultPort);
var node_keys = KeyPair.FromWIF(wif);
// TODO increase this later
int cacheSize = 32;
nexus = new Nexus(logger);
if (wif != validatorWIFs[0])
{
seeds.Add("127.0.0.1:7073");
}
// TODO this should be later optional to enable
nexus.AddPlugin(new ChainAddressesPlugin());
nexus.AddPlugin(new TokenTransactionsPlugin());
nexus.AddPlugin(new AddressTransactionsPlugin());
nexus.AddPlugin(new UnclaimedTransactionsPlugin());
/*if (simulator != null)
* {
* for (int i = 0; i < 100; i++)
* {
* simulator.GenerateRandomBlock();
* }
* }*/
running = true;
// mempool setup
int blockTime = settings.GetInt("node.blocktime", Mempool.MinimumBlockTime);
this.mempool = new Mempool(node_keys, nexus, blockTime);
mempool.Start(ThreadPriority.AboveNormal);
mempool.OnTransactionFailed += Mempool_OnTransactionFailed;
api = new NexusAPI(nexus, mempool);
// RPC setup
if (hasRPC)
{
int rpcPort = settings.GetInt("rpc.port", 7077);
logger.Message($"RPC server listening on port {rpcPort}...");
var rpcServer = new RPCServer(api, "/rpc", rpcPort, (level, text) => WebLogMapper("rpc", level, text));
rpcServer.Start(ThreadPriority.AboveNormal);
}
// REST setup
if (hasREST)
{
int restPort = settings.GetInt("rest.port", 7078);
logger.Message($"REST server listening on port {restPort}...");
var restServer = new RESTServer(api, "/api", restPort, (level, text) => WebLogMapper("rest", level, text));
restServer.Start(ThreadPriority.AboveNormal);
}
/*if (simulator != null && settings.GetBool("simulator", false))
* {
* new Thread(() =>
* {
* Thread.CurrentThread.IsBackground = true;
* while (running)
* {
* Thread.Sleep(Mempool.MinimumBlockTime + 1000);
* simulator.CurrentTime = Timestamp.Now;
* simulator.GenerateRandomBlock(mempool);
* }
* }).Start();
* }*/
// node setup
this.node = new Node(nexus, mempool, node_keys, port, seeds, logger);
node.Start();
int pluginPeriod = settings.GetInt("plugin.refresh", 1); // in seconds
RegisterPlugin(new TPSPlugin(logger, pluginPeriod));
RegisterPlugin(new RAMPlugin(logger, pluginPeriod));
RegisterPlugin(new MempoolPlugin(mempool, logger, pluginPeriod));
Console.CancelKeyPress += delegate {
Terminate();
};
logger.Success("Node is ready");
var dispatcher = new CommandDispatcher();
SetupCommands(dispatcher);
if (gui != null)
{
gui.MakeReady(dispatcher);
}
this.Run();
}
public CLI(string[] args)
{
var culture = new CultureInfo("en-US");
Thread.CurrentThread.CurrentCulture = culture;
CultureInfo.DefaultThreadCurrentCulture = culture;
var seeds = new List <string>();
var settings = new Arguments(args);
var useGUI = settings.GetBool("gui.enabled", true);
if (useGUI)
{
gui = new ConsoleGUI();
logger = gui;
}
else
{
gui = null;
logger = new ConsoleLogger();
}
string mode = settings.GetString("node.mode", "default");
restartTime = settings.GetInt("node.reboot", 0);
showWebLogs = settings.GetBool("web.log", false);
bool apiLog = settings.GetBool("api.log", true);
string apiProxyURL = settings.GetString("api.proxy", "");
if (string.IsNullOrEmpty(apiProxyURL))
{
apiProxyURL = null;
}
bool hasSync = settings.GetBool("sync.enabled", true);
bool hasMempool = settings.GetBool("mempool.enabled", true);
bool hasEvents = settings.GetBool("events.enabled", true);
bool hasRelay = settings.GetBool("relay.enabled", true);
bool hasArchive = settings.GetBool("archive.enabled", true);
bool hasRPC = settings.GetBool("rpc.enabled", false);
bool hasREST = settings.GetBool("rest.enabled", false);
var nexusName = settings.GetString("nexus.name", "simnet");
string profilePath = settings.GetString("mempool.profile", "");
if (string.IsNullOrEmpty(profilePath))
{
profilePath = null;
}
bool isValidator = false;
switch (mode)
{
case "sender":
{
string host = settings.GetString("sender.host");
int threadCount = settings.GetInt("sender.threads", 8);
int addressesPerSender = settings.GetInt("sender.addressCount", 100);
string wif = settings.GetString("node.wif");
RunSender(wif, nexusName, host, threadCount, addressesPerSender);
Console.WriteLine("Sender finished operations.");
return;
}
case "validator": isValidator = true; break;
case "default": break;
default:
{
logger.Error("Unknown mode: " + mode);
return;
}
}
int port = settings.GetInt("node.port", 7073);
var defaultStoragePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "/Storage";
var defaultOraclePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "/Oracle";
var storagePath = FixPath(settings.GetString("storage.path", defaultStoragePath));
var oraclePath = FixPath(settings.GetString("storage.oracle", defaultOraclePath));
var storageBackend = settings.GetString("storage.backend", "file");
logger.Message("Storage backend: " + storageBackend);
var storageFix = settings.GetBool("storage.fix", false);
// TODO remove this later
if (storageFix)
{
if (Directory.Exists(storagePath))
{
logger.Warning("Storage fix enabled... Cleaning up all storage...");
var di = new DirectoryInfo(storagePath);
foreach (FileInfo file in di.EnumerateFiles())
{
file.Delete();
}
}
}
logger.Message("Storage path: " + storagePath);
logger.Message("Oracle path: " + oraclePath);
switch (storageBackend)
{
case "file":
nexus = new Nexus(logger,
(name) => new BasicDiskStore(storagePath + name + ".csv"),
(n) => new SpookOracle(this, n, oraclePath)
);
break;
case "db":
nexus = new Nexus(logger,
(name) => new DBPartition(storagePath + name),
(n) => new SpookOracle(this, n, oraclePath)
);
break;
default:
throw new Exception("Backend has to be set to either \"db\" or \"file\"");
}
running = true;
// mempool setup
int blockTime = settings.GetInt("node.blocktime", Mempool.MinimumBlockTime);
int minimumFee;
try
{
minimumFee = settings.GetInt("mempool.fee", 100000);
if (minimumFee < 1)
{
logger.Error("Invalid mempool fee value. Expected a positive value.");
}
}
catch (Exception e)
{
logger.Error("Invalid mempool fee value. Expected something in fixed point format.");
return;
}
int minimumPow;
try
{
minimumPow = settings.GetInt("mempool.pow", 0);
int maxPow = 5;
if (minimumPow < 0 || minimumPow > maxPow)
{
logger.Error($"Invalid mempool pow value. Expected a value between 0 and {maxPow}.");
}
}
catch (Exception e)
{
logger.Error("Invalid mempool fee value. Expected something in fixed point format.");
return;
}
if (apiProxyURL != null)
{
hasMempool = false;
isValidator = false;
hasSync = false;
hasEvents = false;
hasRelay = false;
hasArchive = false;
if (!hasRPC && !hasREST)
{
logger.Error("API proxy must have REST or RPC enabled.");
return;
}
}
if (hasMempool)
{
this.mempool = new Mempool(nexus, blockTime, minimumFee, System.Text.Encoding.UTF8.GetBytes(Identifier), 0, logger, profilePath);
var mempoolLogging = settings.GetBool("mempool.log", true);
if (mempoolLogging)
{
mempool.OnTransactionFailed += Mempool_OnTransactionFailed;
mempool.OnTransactionAdded += (hash) => logger.Message($"Received transaction {hash}");
mempool.OnTransactionCommitted += (hash) => logger.Message($"Commited transaction {hash}");
mempool.OnTransactionDiscarded += (hash) => logger.Message($"Discarded transaction {hash}");
}
mempool.Start(ThreadPriority.AboveNormal);
}
else
{
this.mempool = null;
}
if (!isValidator && !hasSync && apiProxyURL == null)
{
logger.Warning("Non-validator nodes require sync feature to be enabled, auto enabled now");
hasSync = true;
}
PeerCaps caps = PeerCaps.None;
if (hasSync)
{
caps |= PeerCaps.Sync;
}
if (hasMempool)
{
caps |= PeerCaps.Mempool;
}
if (hasEvents)
{
caps |= PeerCaps.Events;
}
if (hasRelay)
{
caps |= PeerCaps.Relay;
}
if (hasArchive)
{
caps |= PeerCaps.Archive;
}
if (hasRPC)
{
caps |= PeerCaps.RPC;
}
if (hasREST)
{
caps |= PeerCaps.REST;
}
var possibleCaps = Enum.GetValues(typeof(PeerCaps)).Cast <PeerCaps>().ToArray();
foreach (var cap in possibleCaps)
{
if (cap != PeerCaps.None && caps.HasFlag(cap))
{
logger.Message("Feature enabled: " + cap);
}
}
PhantasmaKeys node_keys = null;
bool bootstrap = false;
if (hasSync)
{
string wif = settings.GetString("node.wif");
node_keys = PhantasmaKeys.FromWIF(wif);
WalletModule.Keys = PhantasmaKeys.FromWIF(wif);
try
{
if (this.mempool != null)
{
this.mempool.SetKeys(node_keys);
}
this.node = new Node("Spook v" + SpookVersion, nexus, mempool, node_keys, port, caps, seeds, logger);
}
catch (Exception e)
{
logger.Error(e.Message);
return;
}
if (!nexus.HasGenesis)
{
if (isValidator)
{
if (settings.GetBool("nexus.bootstrap"))
{
if (!ValidationUtils.IsValidIdentifier(nexusName))
{
logger.Error("Invalid nexus name: " + nexusName);
this.Terminate();
return;
}
logger.Debug($"Boostraping {nexusName} nexus using {node_keys.Address}...");
var genesisTimestamp = new Timestamp(settings.GetUInt("genesis.timestamp", Timestamp.Now.Value));
bootstrap = true;
if (!nexus.CreateGenesisBlock(nexusName, node_keys, genesisTimestamp))
{
throw new ChainException("Genesis block failure");
}
logger.Debug("Genesis block created: " + nexus.GetGenesisHash(nexus.RootStorage));
}
else
{
logger.Error("No Nexus found.");
this.Terminate();
}
}
}
else
{
var genesisAddress = nexus.GetGenesisAddress(nexus.RootStorage);
if (isValidator && node_keys.Address != genesisAddress)
{
logger.Error("Specified node key does not match genesis address " + genesisAddress.Text);
return;
}
else
{
logger.Success("Loaded Nexus with genesis " + nexus.GetGenesisHash(nexus.RootStorage));
//seeds.Add("127.0.0.1:7073");
}
}
}
else
{
this.node = null;
}
if (mempool != null)
{
if (isValidator)
{
this.mempool.SetKeys(node_keys);
}
else
{
this.mempool.SubmissionCallback = (tx, chain) =>
{
logger.Message($"Relaying tx {tx.Hash} to other node");
//this.node.
};
}
}
var useAPICache = settings.GetBool("api.cache", true);
if (apiProxyURL != null)
{
useAPICache = true;
}
logger.Message($"API cache is {(useAPICache ? "enabled" : "disabled")}.");
nexusApi = new NexusAPI(nexus, useAPICache, apiLog ? logger : null);
nexusApi.Mempool = mempool;
if (!string.IsNullOrEmpty(apiProxyURL))
{
nexusApi.ProxyURL = apiProxyURL;
logger.Message($"API will be acting as proxy for {apiProxyURL}");
}
else
{
nexusApi.Node = node;
}
var readOnlyMode = settings.GetBool("readonly", false);
if (apiProxyURL != null)
{
readOnlyMode = true;
}
if (readOnlyMode)
{
logger.Warning($"Node will be running in read-only mode.");
nexusApi.acceptTransactions = false;
}
// RPC setup
if (hasRPC)
{
rpcPort = settings.GetInt("rpc.port", 7077);
logger.Message($"RPC server listening on port {rpcPort}...");
var rpcServer = new RPCServer(nexusApi, "/rpc", rpcPort, (level, text) => WebLogMapper("rpc", level, text));
rpcServer.Start(ThreadPriority.AboveNormal);
}
else
{
rpcPort = 0;
}
// REST setup
if (hasREST)
{
restPort = settings.GetInt("rest.port", 7078);
logger.Message($"REST server listening on port {restPort}...");
var restServer = new RESTServer(nexusApi, "/api", restPort, (level, text) => WebLogMapper("rest", level, text));
restServer.Start(ThreadPriority.AboveNormal);
}
else
{
restPort = 0;
}
if (node != null)
{
var neoScanURL = settings.GetString("neoscan.url", "https://api.neoscan.io");
var rpcList = settings.GetString("neo.rpc", "http://seed6.ngd.network:10332,http://seed.neoeconomy.io:10332");
var neoRpcURLs = rpcList.Split(',');
this.neoAPI = new Neo.Core.RemoteRPCNode(neoScanURL, neoRpcURLs);
this.neoAPI.SetLogger((s) => logger.Message(s));
this.neoScanAPI = new NeoScanAPI(neoScanURL, logger, nexus, node_keys);
cryptoCompareAPIKey = settings.GetString("cryptocompare.apikey", "");
if (!string.IsNullOrEmpty(cryptoCompareAPIKey))
{
logger.Message($"CryptoCompare API enabled...");
}
node.Start();
}
if (gui != null)
{
int pluginPeriod = settings.GetInt("plugin.refresh", 1); // in seconds
if (settings.GetBool("plugin.tps", false))
{
RegisterPlugin(new TPSPlugin(logger, pluginPeriod));
}
if (settings.GetBool("plugin.ram", false))
{
RegisterPlugin(new RAMPlugin(logger, pluginPeriod));
}
if (settings.GetBool("plugin.mempool", false))
{
RegisterPlugin(new MempoolPlugin(mempool, logger, pluginPeriod));
}
}
Console.CancelKeyPress += delegate
{
Terminate();
};
useSimulator = settings.GetBool("simulator.enabled", false);
var dispatcher = new CommandDispatcher();
SetupCommands(dispatcher);
if (settings.GetBool("swaps.enabled"))
{
var tokenSwapper = new TokenSwapper(node_keys, nexusApi, neoScanAPI, neoAPI, minimumFee, logger, settings);
nexusApi.TokenSwapper = tokenSwapper;
new Thread(() =>
{
logger.Message("Running token swapping service...");
while (running)
{
Thread.Sleep(5000);
if (nodeReady)
{
tokenSwapper.Update();
}
}
}).Start();
}
if (useSimulator && bootstrap)
{
new Thread(() =>
{
logger.Message("Initializing simulator...");
simulator = new NexusSimulator(this.nexus, node_keys, 1234);
simulator.MinimumFee = minimumFee;
/*
* logger.Message("Bootstrapping validators");
* simulator.BeginBlock();
* for (int i = 1; i < validatorWIFs.Length; i++)
* {
* simulator.GenerateTransfer(node_keys, Address.FromWIF(validatorWIFs[i]), this.nexus.RootChain, DomainSettings.StakingTokenSymbol, UnitConversion.ToBigInteger(50000, DomainSettings.StakingTokenDecimals));
* }
* simulator.EndBlock();*/
string[] dapps = settings.GetString("dapps", "").Split(',');
DappServer.InitDapps(nexus, simulator, node_keys, dapps, minimumFee, logger);
bool genBlocks = settings.GetBool("simulator.blocks", false);
if (genBlocks)
{
int blockNumber = 0;
while (running)
{
Thread.Sleep(5000);
blockNumber++;
logger.Message("Generating sim block #" + blockNumber);
try
{
simulator.CurrentTime = DateTime.UtcNow;
simulator.GenerateRandomBlock();
}
catch (Exception e)
{
logger.Error("Fatal error: " + e.ToString());
Environment.Exit(-1);
}
}
}
MakeReady(dispatcher);
}).Start();
}
else
{
MakeReady(dispatcher);
}
this.Run();
}
public CLI(string[] args)
{
var culture = new CultureInfo("en-US");
CultureInfo.DefaultThreadCurrentCulture = culture;
var seeds = new List <string>();
var settings = new Arguments(args);
/*
* for (int i = 0; i < 20; i++)
* {
* var k = KeyPair.Generate();
* Console.WriteLine(k.ToWIF() + " => " + k.Address.Text);
* }*/
var useGUI = settings.GetBool("gui.enabled", true);
if (useGUI)
{
gui = new ConsoleGUI();
logger = gui;
}
else
{
gui = null;
logger = new ConsoleLogger();
}
string mode = settings.GetString("node.mode", "validator");
bool hasRPC = settings.GetBool("rpc.enabled", false);
bool hasREST = settings.GetBool("rest.enabled", false);
string wif = settings.GetString("node.wif");
var nexusName = settings.GetString("nexus.name", "simnet");
switch (mode)
{
case "sender":
string host = settings.GetString("sender.host");
int threadCount = settings.GetInt("sender.threads", 8);
int addressesPerSender = settings.GetInt("sender.addressCount", 100);
RunSender(wif, host, threadCount, addressesPerSender);
Console.WriteLine("Sender finished operations.");
return;
case "validator": break;
default:
{
logger.Error("Unknown mode: " + mode);
return;
}
}
int defaultPort = 0;
for (int i = 0; i < validatorWIFs.Length; i++)
{
if (validatorWIFs[i] == wif)
{
defaultPort = (7073 + i);
}
}
if (defaultPort == 0)
{
defaultPort = (7073 + validatorWIFs.Length);
}
int port = settings.GetInt("node.port", defaultPort);
var defaultStoragePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "/Storage";
var storagePath = settings.GetString("storage.path", defaultStoragePath);
storagePath = storagePath.Replace("\\", "/");
if (!storagePath.EndsWith('/'))
{
storagePath += '/';
}
var storageFix = settings.GetBool("storage.fix", false);
// TODO remove this later
if (storageFix)
{
if (Directory.Exists(storagePath))
{
logger.Warning("Storage fix enabled... Cleaning up all storage...");
var di = new DirectoryInfo(storagePath);
foreach (FileInfo file in di.EnumerateFiles())
{
file.Delete();
}
}
}
logger.Message("Storage path: " + storagePath);
var node_keys = KeyPair.FromWIF(wif);
nexus = new Nexus(logger, (name) => new BasicDiskStore(storagePath + name + ".txt"));
bool bootstrap = false;
if (wif == validatorWIFs[0])
{
if (!nexus.Ready)
{
logger.Debug("Boostraping nexus...");
bootstrap = true;
if (!nexus.CreateGenesisBlock(nexusName, node_keys, Timestamp.Now))
{
throw new ChainException("Genesis block failure");
}
logger.Debug("Genesis block created: " + nexus.GenesisHash);
}
}
else
{
//nexus = new Nexus(nexusName, genesisAddress, logger);
nexus = new Nexus(logger);
seeds.Add("127.0.0.1:7073");
}
// TODO this should be later optional to enable
nexus.AddPlugin(new ChainAddressesPlugin());
nexus.AddPlugin(new TokenTransactionsPlugin());
nexus.AddPlugin(new AddressTransactionsPlugin());
nexus.AddPlugin(new UnclaimedTransactionsPlugin());
running = true;
// mempool setup
int blockTime = settings.GetInt("node.blocktime", Mempool.MinimumBlockTime);
this.mempool = new Mempool(node_keys, nexus, blockTime, ReadFromOracle);
mempool.Start(ThreadPriority.AboveNormal);
mempool.OnTransactionFailed += Mempool_OnTransactionFailed;
api = new NexusAPI(nexus, mempool);
// RPC setup
if (hasRPC)
{
int rpcPort = settings.GetInt("rpc.port", 7077);
logger.Message($"RPC server listening on port {rpcPort}...");
var rpcServer = new RPCServer(api, "/rpc", rpcPort, (level, text) => WebLogMapper("rpc", level, text));
rpcServer.Start(ThreadPriority.AboveNormal);
}
// REST setup
if (hasREST)
{
int restPort = settings.GetInt("rest.port", 7078);
logger.Message($"REST server listening on port {restPort}...");
var restServer = new RESTServer(api, "/api", restPort, (level, text) => WebLogMapper("rest", level, text));
restServer.Start(ThreadPriority.AboveNormal);
}
cryptoCompareAPIKey = settings.GetString("cryptocompare.apikey", "");
if (!string.IsNullOrEmpty(cryptoCompareAPIKey))
{
logger.Message($"CryptoCompare API enabled...");
}
// node setup
this.node = new Node(nexus, mempool, node_keys, port, seeds, logger);
node.Start();
if (gui != null)
{
int pluginPeriod = settings.GetInt("plugin.refresh", 1); // in seconds
RegisterPlugin(new TPSPlugin(logger, pluginPeriod));
RegisterPlugin(new RAMPlugin(logger, pluginPeriod));
RegisterPlugin(new MempoolPlugin(mempool, logger, pluginPeriod));
}
Console.CancelKeyPress += delegate {
Terminate();
};
var dispatcher = new CommandDispatcher();
SetupCommands(dispatcher);
bool useSimulator = settings.GetBool("simulator.enabled", false);
if (useSimulator && bootstrap)
{
new Thread(() =>
{
logger.Message("Initializing simulator...");
var simulator = new ChainSimulator(this.nexus, node_keys, 1234);
logger.Message("Bootstrapping validators");
simulator.BeginBlock();
for (int i = 1; i < validatorWIFs.Length; i++)
{
simulator.GenerateTransfer(node_keys, Address.FromWIF(validatorWIFs[i]), this.nexus.RootChain, Nexus.StakingTokenSymbol, UnitConversion.ToBigInteger(50000, Nexus.StakingTokenDecimals));
}
simulator.EndBlock();
for (int i = 0; i < 3; i++)
{
logger.Message("Generating sim block #" + i);
simulator.GenerateRandomBlock();
}
NachoServer.InitNachoServer(nexus, simulator, node_keys, logger);
MakeReady(dispatcher);
}).Start();
}
else
{
MakeReady(dispatcher);
}
this.Run();
}
static void Main(string[] args)
{
var exitEvent = new ManualResetEvent(false);
var options = new Options();
if (CommandLine.Parser.Default.ParseArgumentsStrict(args, options, () => { Environment.Exit(-2); }))
{
if (options.RunAsServer)
{
//
// As server
//
Console.CancelKeyPress += (sender, eventArgs) => {
eventArgs.Cancel = true;
exitEvent.Set();
};
Console.WriteLine("Run server on " + options.Host + ":" + options.Port);
Console.WriteLine("Press CTRL+C to terminate server.\n");
Console.WriteLine("Host: {0}:{1}", options.Host, options.Port);
try
{
LogManager.InstantiateLogManager();
DamIssuer.Init();
var server = new RESTServer();
server.Host = options.Host;
server.Port = options.Port;
server.Start();
exitEvent.WaitOne();
server.Stop();
}
catch (Exception e)
{
Console.WriteLine(e.Message + "\n" + e.StackTrace);
}
}
else
{
Dictionary <string, HttpMethod> method = new Dictionary <string, HttpMethod>()
{
{ "GET", HttpMethod.GET },
{ "POST", HttpMethod.POST }
};
//
// As client
//
try
{
LogManager.InstantiateLogManager();
RESTClient client = new RESTClient("http://" + options.Host + ":" + options.Port);
RESTRequest request = new RESTRequest(options.Url);
request.Method = method[options.Method];
request.ContentType = ContentType.JSON;
request.Payload = string.Format("{{\"file\":\"{0}\"}}", options.Json);
Console.WriteLine("Payload: " + request.Payload);
var response = client.Execute(request);
Console.WriteLine("Response: " + response.Content);
}
catch (Exception e)
{
Console.WriteLine(e.Message + "\n" + e.StackTrace);
}
}
}
}
