/// <summary> /// Launches a Lean Engine using a parameter /// </summary> /// <param name="val">The paramater to use when launching lean. </param> private void LaunchLean(string val) { Config.Set("environment", "backtesting"); string algorithm = val; // Set the algorithm in Config. Here is where you can customize Config settings Config.Set("algorithm-type-name", algorithm); _jobQueue = new JobQueue(); _notify = new Messaging(); _api = new Api(); /************ Comment one of the two following lines to select which ResultHandler to use ***********/ _resultshandler = new OptimizationResultHandler(); //_resultshandler = new ConsoleResultHandler(); _dataFeed = new FileSystemDataFeed(); _setup = new ConsoleSetupHandler(); _realTime = new BacktestingRealTimeHandler(); _historyProvider = new SubscriptionDataReaderHistoryProvider(); _transactions = new BacktestingTransactionHandler(); // Set the Log.LogHandler to only write to the log.txt file. // This setting avoids writing Log messages to the console. Log.LogHandler = (ILogHandler) new FileLogHandler(); Log.DebuggingEnabled = false; // Set this property to true for lots of messages Log.DebuggingLevel = 1; // A reminder that the default level for Log.Debug message is 1 var systemHandlers = new LeanEngineSystemHandlers(_jobQueue, _api, _notify); systemHandlers.Initialize(); var algorithmHandlers = new LeanEngineAlgorithmHandlers(_resultshandler, _setup, _dataFeed, _transactions, _realTime, _historyProvider); string algorithmPath; AlgorithmNodePacket job = systemHandlers.JobQueue.NextJob(out algorithmPath); try { var _engine = new Engine(systemHandlers, algorithmHandlers, Config.GetBool("live-mode")); _engine.Run(job, algorithmPath); } finally { /* The JobQueue.AcknowledgeJob only asks for any key to close the window. * We do not want that behavior, so we comment out this line so that multiple Leans will run * * The alternative is to comment out Console.Read(); the line in JobQueue class. */ //systemHandlers.JobQueue.AcknowledgeJob(job); Log.Trace("Engine.Main(): Packet removed from queue: " + job.AlgorithmId); // clean up resources systemHandlers.Dispose(); algorithmHandlers.Dispose(); Log.LogHandler.Dispose(); } }
private void LaunchLean() { Config.Set("environment", "backtesting"); string algorithm = "EMATest"; Config.Set("algorithm-type-name", algorithm); _jobQueue = new JobQueue(); _notify = new Messaging(); _api = new Api(); _resultshandler = new DesktopResultHandler(); _dataFeed = new FileSystemDataFeed(); _setup = new ConsoleSetupHandler(); _realTime = new BacktestingRealTimeHandler(); _historyProvider = new SubscriptionDataReaderHistoryProvider(); _transactions = new BacktestingTransactionHandler(); var systemHandlers = new LeanEngineSystemHandlers(_jobQueue, _api, _notify); systemHandlers.Initialize(); // var algorithmHandlers = new LeanEngineAlgorithmHandlers (_resultshandler, _setup, _dataFeed, _transactions, _realTime, _historyProvider); Log.LogHandler = Composer.Instance.GetExportedValueByTypeName <ILogHandler>(Config.Get("log-handler", "CompositeLogHandler")); LeanEngineAlgorithmHandlers leanEngineAlgorithmHandlers; try { leanEngineAlgorithmHandlers = LeanEngineAlgorithmHandlers.FromConfiguration(Composer.Instance); _resultshandler = leanEngineAlgorithmHandlers.Results; } catch (CompositionException compositionException) { Log.Error("Engine.Main(): Failed to load library: " + compositionException); throw; } string algorithmPath; AlgorithmNodePacket job = systemHandlers.JobQueue.NextJob(out algorithmPath); try { var _engine = new Engine(systemHandlers, leanEngineAlgorithmHandlers, Config.GetBool("live-mode")); _engine.Run(job, algorithmPath); } finally { //Delete the message from the job queue: //systemHandlers.JobQueue.AcknowledgeJob(job); Log.Trace("Engine.Main(): Packet removed from queue: " + job.AlgorithmId); // clean up resources systemHandlers.Dispose(); leanEngineAlgorithmHandlers.Dispose(); Log.LogHandler.Dispose(); } }
private void LaunchLean() { ConfigMerger.Merge(_config, _id, this.GetType()); var systemHandlers = new LeanEngineSystemHandlers( new JobQueue(), new EmptyApiHandler(), new Messaging(), new LocalLeanManager()); systemHandlers.Initialize(); //separate log uniquely named var logFileName = "log" + DateTime.Now.ToString("yyyyMMddssfffffff") + "_" + _id + ".txt"; using (Log.LogHandler = new FileLogHandler(logFileName, true)) { var map = new LocalDiskMapFileProvider(); var leanEngineAlgorithmHandlers = new LeanEngineAlgorithmHandlers( new OptimizerResultHandler(), new ConsoleSetupHandler(), new FileSystemDataFeed(), new BacktestingTransactionHandler(), new BacktestingRealTimeHandler(), map, new LocalDiskFactorFileProvider(map), new DefaultDataProvider(), new OptimizerAlphaHandler(), new EmptyObjectStore(), new DataPermissionManager()); _resultsHandler = (OptimizerResultHandler)leanEngineAlgorithmHandlers.Results; var job = (BacktestNodePacket)systemHandlers.JobQueue.NextJob(out var algorithmPath); //todo: pass period through job //job.PeriodStart = _config.StartDate; //job.PeriodFinish = _config.EndDate; try { var algorithmManager = new AlgorithmManager(false); systemHandlers.LeanManager.Initialize(systemHandlers, leanEngineAlgorithmHandlers, job, algorithmManager); var engine = new Engine(systemHandlers, leanEngineAlgorithmHandlers, false); engine.Run(job, algorithmManager, algorithmPath, WorkerThread.Instance); } finally { // clean up resources systemHandlers.Dispose(); leanEngineAlgorithmHandlers.Dispose(); } } }
static void Main(string[] args) { //Initialize: var mode = "RELEASE"; #if DEBUG mode = "DEBUG"; #endif if (OS.IsWindows) { Console.OutputEncoding = System.Text.Encoding.UTF8; } // expect first argument to be config file name if (args.Length > 0) { Config.MergeCommandLineArgumentsWithConfiguration(LeanArgumentParser.ParseArguments(args)); } var liveMode = Config.GetBool("live-mode"); Log.DebuggingEnabled = Config.GetBool("debug-mode"); Log.FilePath = Path.Combine(Config.Get("results-destination-folder"), "log.txt"); Log.LogHandler = Composer.Instance.GetExportedValueByTypeName <ILogHandler>(Config.Get("log-handler", "CompositeLogHandler")); //Name thread for the profiler: Thread.CurrentThread.Name = "Algorithm Analysis Thread"; Log.Trace($"Engine.Main(): LEAN ALGORITHMIC TRADING ENGINE v{Globals.Version} Mode: {mode} ({(Environment.Is64BitProcess ? "64" : "32")}bit) Host: {Environment.MachineName}"); Log.Trace("Engine.Main(): Started " + DateTime.Now.ToShortTimeString()); //Import external libraries specific to physical server location (cloud/local) try { leanEngineSystemHandlers = LeanEngineSystemHandlers.FromConfiguration(Composer.Instance); } catch (CompositionException compositionException) { Log.Error("Engine.Main(): Failed to load library: " + compositionException); throw; } //Setup packeting, queue and controls system: These don't do much locally. leanEngineSystemHandlers.Initialize(); //-> Pull job from QuantConnect job queue, or, pull local build: string assemblyPath; job = leanEngineSystemHandlers.JobQueue.NextJob(out assemblyPath); if (job == null) { const string jobNullMessage = "Engine.Main(): Sorry we could not process this algorithm request."; Log.Error(jobNullMessage); throw new ArgumentException(jobNullMessage); } try { leanEngineAlgorithmHandlers = LeanEngineAlgorithmHandlers.FromConfiguration(Composer.Instance); } catch (CompositionException compositionException) { Log.Error("Engine.Main(): Failed to load library: " + compositionException); throw; } // if the job version doesn't match this instance version then we can't process it // we also don't want to reprocess redelivered jobs if (job.Redelivered) { Log.Error("Engine.Run(): Job Version: " + job.Version + " Deployed Version: " + Globals.Version + " Redelivered: " + job.Redelivered); //Tiny chance there was an uncontrolled collapse of a server, resulting in an old user task circulating. //In this event kill the old algorithm and leave a message so the user can later review. leanEngineSystemHandlers.Api.SetAlgorithmStatus(job.AlgorithmId, AlgorithmStatus.RuntimeError, _collapseMessage); leanEngineSystemHandlers.Notify.SetAuthentication(job); leanEngineSystemHandlers.Notify.Send(new RuntimeErrorPacket(job.UserId, job.AlgorithmId, _collapseMessage)); leanEngineSystemHandlers.JobQueue.AcknowledgeJob(job); Exit(1); } try { // Set our exit handler for the algorithm Console.CancelKeyPress += new ConsoleCancelEventHandler(ExitKeyPress); // Create the algorithm manager and start our engine algorithmManager = new AlgorithmManager(liveMode, job); leanEngineSystemHandlers.LeanManager.Initialize(leanEngineSystemHandlers, leanEngineAlgorithmHandlers, job, algorithmManager); var engine = new Engine.Engine(leanEngineSystemHandlers, leanEngineAlgorithmHandlers, liveMode); engine.Run(job, algorithmManager, assemblyPath, WorkerThread.Instance); } finally { var algorithmStatus = algorithmManager?.State ?? AlgorithmStatus.DeployError; Exit(algorithmStatus != AlgorithmStatus.Completed ? 1 : 0); } }
private void LaunchLean() { Config.Set("environment", "backtesting"); if (!string.IsNullOrEmpty(_config.AlgorithmTypeName)) { Config.Set("algorithm-type-name", _config.AlgorithmTypeName); } if (!string.IsNullOrEmpty(_config.AlgorithmLocation)) { Config.Set("algorithm-location", Path.GetFileName(_config.AlgorithmLocation)); } if (!string.IsNullOrEmpty(_config.DataFolder)) { Config.Set("data-folder", _config.DataFolder); } if (!string.IsNullOrEmpty(_config.TransactionLog)) { var filename = _config.TransactionLog; filename = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Path.GetFileNameWithoutExtension(filename) + _id + Path.GetExtension(filename)); Config.Set("transaction-log", filename); } var systemHandlers = new LeanEngineSystemHandlers( new JobQueue(), new EmptyApiHandler(), new Messaging(), new LocalLeanManager()); systemHandlers.Initialize(); //separate log uniquely named var logFileName = "log" + DateTime.Now.ToString("yyyyMMddssfffffff") + "_" + _id + ".txt"; using (Log.LogHandler = new FileLogHandler(logFileName, true)) { //override config to use custom result handler Config.Set("backtesting.result-handler", nameof(OptimizerResultHandler)); var map = new LocalDiskMapFileProvider(); var leanEngineAlgorithmHandlers = new LeanEngineAlgorithmHandlers( new OptimizerResultHandler(), new ConsoleSetupHandler(), new FileSystemDataFeed(), new BacktestingTransactionHandler(), new BacktestingRealTimeHandler(), map, new LocalDiskFactorFileProvider(map), new DefaultDataProvider(), new OptimizerAlphaHandler(), new EmptyObjectStore()); _resultsHandler = (OptimizerResultHandler)leanEngineAlgorithmHandlers.Results; var job = (BacktestNodePacket)systemHandlers.JobQueue.NextJob(out var algorithmPath); //todo: pass period through job //job.PeriodStart = _config.StartDate; //job.PeriodFinish = _config.EndDate; try { var algorithmManager = new AlgorithmManager(false); systemHandlers.LeanManager.Initialize(systemHandlers, leanEngineAlgorithmHandlers, job, algorithmManager); var engine = new Engine(systemHandlers, leanEngineAlgorithmHandlers, false); engine.Run(job, algorithmManager, algorithmPath, WorkerThread.Instance); } finally { // clean up resources systemHandlers.Dispose(); leanEngineAlgorithmHandlers.Dispose(); } } }
private void LaunchLean(string id) { ConfigMerger.Merge(_config, id); Config.Set("api-handler", nameof(EmptyApiHandler)); //todo: instance logging //var logFileName = "log" + DateTime.Now.ToString("yyyyMMddssfffffff") + "_" + id + ".txt"; Log.LogHandler = LogSingleton.Instance; var jobQueue = new JobQueue(); var manager = new LocalLeanManager(); var systemHandlers = new LeanEngineSystemHandlers( jobQueue, new EmptyApiHandler(), new QuantConnect.Messaging.Messaging(), manager); systemHandlers.Initialize(); var map = new LocalDiskMapFileProvider(); var results = new OptimizerResultHandler(); var transactions = new BacktestingTransactionHandler(); var dataFeed = new FileSystemDataFeed(); var realTime = new BacktestingRealTimeHandler(); var data = new DefaultDataProvider(); var leanEngineAlgorithmHandlers = new LeanEngineAlgorithmHandlers( results, new ConsoleSetupHandler(), dataFeed, transactions, realTime, map, new LocalDiskFactorFileProvider(map), data, new OptimizerAlphaHandler(), new EmptyObjectStore()); _resultsHandler = (OptimizerResultHandler)leanEngineAlgorithmHandlers.Results; var job = (BacktestNodePacket)systemHandlers.JobQueue.NextJob(out var algorithmPath); //mark job with id. Is set on algorithm in OptimizerAlphaHandler job.BacktestId = id; //todo: pass period through job //job.PeriodStart = _config.StartDate; //job.PeriodFinish = _config.EndDate; Engine engine; AlgorithmManager algorithmManager; try { algorithmManager = new AlgorithmManager(false); systemHandlers.LeanManager.Initialize(systemHandlers, leanEngineAlgorithmHandlers, job, algorithmManager); engine = new Engine(systemHandlers, leanEngineAlgorithmHandlers, false); using (var workerThread = new MultipleWorkerThread()) { engine.Run(job, algorithmManager, algorithmPath, workerThread); } } finally { // clean up resources Composer.Instance.Reset(); results.Charts.Clear(); results.Messages.Clear(); if (results.Algorithm != null) { results.Algorithm.Transactions.TransactionRecord.Clear(); results.Algorithm.SubscriptionManager.Subscriptions.SelectMany(s => s.Consolidators)?.ToList().ForEach(f => { results.Algorithm.SubscriptionManager.RemoveConsolidator(f.WorkingData?.Symbol, f); UnregisterAllEvents(f); }); if (results.Algorithm is QCAlgorithm) { ((QCAlgorithm)results.Algorithm).SubscriptionManager.Subscriptions.ToList().Clear(); } if (_config.AlgorithmLanguage != "Python") { results.Algorithm.HistoryProvider = null; } var closedTrades = (List <Trade>) typeof(TradeBuilder).GetField("_closedTrades", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(results.Algorithm.TradeBuilder); closedTrades.Clear(); results.Algorithm = null; } transactions.Orders.Clear(); transactions.OrderTickets.Clear(); manager.Dispose(); systemHandlers.Dispose(); leanEngineAlgorithmHandlers.Dispose(); results = null; dataFeed = null; transactions = null; realTime = null; data = null; map = null; systemHandlers = null; leanEngineAlgorithmHandlers = null; algorithmManager = null; engine = null; job = null; jobQueue = null; manager = null; } }
private void LaunchLean(string id) { Config.Set("environment", "backtesting"); if (!string.IsNullOrEmpty(_config.AlgorithmTypeName)) { Config.Set("algorithm-type-name", _config.AlgorithmTypeName); } if (!string.IsNullOrEmpty(_config.AlgorithmLocation)) { Config.Set("algorithm-location", Path.GetFileName(_config.AlgorithmLocation)); } if (!string.IsNullOrEmpty(_config.DataFolder)) { Config.Set("data-folder", _config.DataFolder); } if (!string.IsNullOrEmpty(_config.TransactionLog)) { var filename = _config.TransactionLog; filename = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Path.GetFileNameWithoutExtension(filename) + id + Path.GetExtension(filename)); Config.Set("transaction-log", filename); } Config.Set("api-handler", nameof(EmptyApiHandler)); Config.Set("backtesting.result-handler", nameof(OptimizerResultHandler)); //Composer.Instance.Reset(); //todo: instance logging //var logFileName = "log" + DateTime.Now.ToString("yyyyMMddssfffffff") + "_" + id + ".txt"; Log.LogHandler = LogSingleton.Instance; var jobQueue = new JobQueue(); var manager = new LocalLeanManager(); var systemHandlers = new LeanEngineSystemHandlers( jobQueue, new EmptyApiHandler(), new QuantConnect.Messaging.Messaging(), manager); systemHandlers.Initialize(); var map = new LocalDiskMapFileProvider(); var results = new OptimizerResultHandler(); var transactions = new BacktestingTransactionHandler(); var dataFeed = new FileSystemDataFeed(); var realTime = new BacktestingRealTimeHandler(); var data = new DefaultDataProvider(); var leanEngineAlgorithmHandlers = new LeanEngineAlgorithmHandlers( results, new ConsoleSetupHandler(), dataFeed, transactions, realTime, map, new LocalDiskFactorFileProvider(map), data, new OptimizerAlphaHandler(), new EmptyObjectStore()); _resultsHandler = (OptimizerResultHandler)leanEngineAlgorithmHandlers.Results; var job = (BacktestNodePacket)systemHandlers.JobQueue.NextJob(out var algorithmPath); //mark job with id. Is set on algorithm in OptimizerAlphaHandler job.BacktestId = id; //todo: pass period through job //job.PeriodStart = _config.StartDate; //job.PeriodFinish = _config.EndDate; Engine engine; AlgorithmManager algorithmManager; try { algorithmManager = new AlgorithmManager(false); systemHandlers.LeanManager.Initialize(systemHandlers, leanEngineAlgorithmHandlers, job, algorithmManager); engine = new Engine(systemHandlers, leanEngineAlgorithmHandlers, false); using (var workerThread = new MultipleWorkerThread()) { engine.Run(job, algorithmManager, algorithmPath, workerThread); } } finally { // clean up resources Composer.Instance.Reset(); results.Charts.Clear(); results.Messages.Clear(); results.Algorithm.Transactions.TransactionRecord.Clear(); var closedTrades = (List <Trade>) typeof(TradeBuilder).GetField("_closedTrades", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(results.Algorithm.TradeBuilder); closedTrades.Clear(); results.Algorithm.HistoryProvider = null; results.Algorithm = null; transactions.Orders.Clear(); transactions.OrderTickets.Clear(); manager.Dispose(); systemHandlers.Dispose(); leanEngineAlgorithmHandlers.Dispose(); results = null; dataFeed = null; transactions = null; realTime = null; data = null; map = null; systemHandlers = null; leanEngineAlgorithmHandlers = null; algorithmManager = null; engine = null; job = null; jobQueue = null; manager = null; } }
private void LaunchLean(string id) { Config.Set("environment", "backtesting"); if (!string.IsNullOrEmpty(_config.AlgorithmTypeName)) { Config.Set("algorithm-type-name", _config.AlgorithmTypeName); } if (!string.IsNullOrEmpty(_config.AlgorithmLocation)) { Config.Set("algorithm-location", Path.GetFileName(_config.AlgorithmLocation)); } if (!string.IsNullOrEmpty(_config.DataFolder)) { Config.Set("data-folder", _config.DataFolder); } if (!string.IsNullOrEmpty(_config.TransactionLog)) { var filename = _config.TransactionLog; filename = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Path.GetFileNameWithoutExtension(filename) + id + Path.GetExtension(filename)); Config.Set("transaction-log", filename); } Config.Set("api-handler", nameof(EmptyApiHandler)); Config.Set("alpha-handler", nameof(OptimizerAlphaHandler)); Config.Set("backtesting.result-handler", nameof(OptimizerResultHandler)); Composer.Instance.Reset(); //todo: instance logging //var logFileName = "log" + DateTime.Now.ToString("yyyyMMddssfffffff") + "_" + id + ".txt"; Log.LogHandler = LogSingleton.Instance; var systemHandlers = new LeanEngineSystemHandlers( new JobQueue(), new EmptyApiHandler(), new QuantConnect.Messaging.Messaging(), new LocalLeanManager()); systemHandlers.Initialize(); var map = new LocalDiskMapFileProvider(); var leanEngineAlgorithmHandlers = new LeanEngineAlgorithmHandlers( new OptimizerResultHandler(), new ConsoleSetupHandler(), new FileSystemDataFeed(), new BacktestingTransactionHandler(), new BacktestingRealTimeHandler(), map, new LocalDiskFactorFileProvider(map), new DefaultDataProvider(), new OptimizerAlphaHandler()); _resultsHandler = (OptimizerResultHandler)leanEngineAlgorithmHandlers.Results; var job = (BacktestNodePacket)systemHandlers.JobQueue.NextJob(out var algorithmPath); //mark job with id. Is set on algorithm in OptimizerAlphaHandler job.BacktestId = id; try { var algorithmManager = new AlgorithmManager(false); systemHandlers.LeanManager.Initialize(systemHandlers, leanEngineAlgorithmHandlers, job, algorithmManager); var engine = new Engine(systemHandlers, leanEngineAlgorithmHandlers, false); engine.Run(job, algorithmManager, algorithmPath); } finally { // clean up resources systemHandlers.Dispose(); leanEngineAlgorithmHandlers.Dispose(); } }