public bool CanHandleTestFor(string assembly) { if (!_configuration.UseAutoTestTestRunner) { return(false); } if (!File.Exists(assembly)) { return(false); } var plugins = new PluginLocator().Locate(); foreach (var plugin in plugins) { var instance = plugin.New(); if (instance == null) { continue; } if (instance.ContainsTestsFor(assembly)) { return(true); } } return(false); }
private IGenerator CreateGenerator(IContext context) { PluginLocator pluginLocator = context.Kernel.Get <PluginLocator>(); Type roslynPluginType = pluginLocator.Locate <IGenerator>(); return((IGenerator)context.Kernel.Get(roslynPluginType ?? typeof(HelloWorldGenerator))); }
private static void initPlugins(PluginLocator locator) { var plugins = locator.Locate(); foreach (var plugin in plugins) { try { plugin.Initialize(_path); plugin.GetCrawlFileTypes(); ThreadPool.QueueUserWorkItem( (o) => { try { var currentPlugin = (LanguagePlugin)o; var handler = new CrawlHandler(_cache, (s) => Logger.Write(s)); handler.SetLanguage(currentPlugin.GetLanguage()); currentPlugin.Crawl(new string[] { _path }, (line) => handler.Handle(line)); } catch (Exception ex) { Logger.Write(ex.ToString()); } }, plugin); } catch (Exception ex) { Logger.Write(ex.ToString()); } } Logger.Write("Plugins initialized"); }
public Installer(string token, string[] sourcePrioritization, Action <string> dispatch, PluginLocator locator) { _token = token; _dispatch = dispatch; _locator = locator; _packageFetcher = new PackageFetcher(_token, sourcePrioritization, _dispatch); }
public EventEndpoint(string keyPath, PluginLocator locator, OpenIDE.CodeEngine.Core.Endpoints.OutputEndpoint outputEndpoint) { _keyPath = keyPath; _outputEndpoint = outputEndpoint; _server = new TcpServer(); _server.IncomingMessage += Handle_serverIncomingMessage; _server.Start(); _reactiveEngine = new ReactiveScriptEngine(_keyPath, locator, (publisher, msg) => _outputEndpoint.Send(publisher, msg), dispatch); }
public void Should_create_instance() { var path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); var locator = new PluginLocator(path); var plugins = locator.Locate(); var plugin = plugins.Where(x => x.Assembly.Equals(Path.Combine(path, "AutoTest.TestRunners.Tests.dll")) && x.Type.Equals("AutoTest.TestRunners.Tests.Plugins.Plugin1")).First(); Assert.That(plugin.New(), Is.InstanceOf <IAutoTestNetTestRunner>()); }
public void Should_locate_plugins() { var path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); var locator = new PluginLocator(path); var plugins = locator.Locate(); Assert.IsTrue(plugins.Count() > 0); Assert.That(plugins.Where(x => x.Assembly.Equals(Path.Combine(path, "AutoTest.TestRunners.Tests.dll")) && x.Type.Equals("AutoTest.TestRunners.Tests.Plugins.Plugin1")).Count(), Is.EqualTo(1)); Assert.That(plugins.Where(x => x.Assembly.Equals(Path.Combine(path, "AutoTest.TestRunners.Tests.dll")) && x.Type.Equals("AutoTest.TestRunners.Tests.Plugins.Plugin2")).Count(), Is.EqualTo(1)); }
private void Init() { if (PluginLocator == null) { throw new Exception("PlugEngine needs a ILocator to work"); } Constructor = new CompactConstructor(PluginLocator.ObjectDefinitions, "default"); PlugsRegistry = new CompactPlugsRegistry(Constructor); PluginLocator.SearchPlugins(); PlugsRegistry.Add(PluginLocator.Plugins); }
public PluginLocator PluginLocator() { if (_pluginLocator == null) { _pluginLocator = new PluginLocator( _settings.EnabledLanguages, new ProfileLocator(_settings.RootPath), (command) => dispatchMessage(command)); } return(_pluginLocator); }
private static IEnumerable <Plugin> allPlugins() { var currentDir = Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath); var dir = Path.Combine(currentDir, "TestRunners"); if (!Directory.Exists(dir)) { return new Plugin[] { } } ; var locator = new PluginLocator(dir); return(locator.Locate()); }
private static void shutdownPlugins(PluginLocator locator) { try { var plugins = locator.Locate(); foreach (var plugin in plugins) { try { Logger.Write("Shutting down plugin " + plugin.GetLanguage()); plugin.Shutdown(); } catch (Exception ex) { Logger.Write(ex.ToString()); } } } catch { } }
private IEnumerable <IAutoTestNetTestRunner> getIdentifiers() { if (_identifiers == null) { var locator = new PluginLocator(Path.GetFullPath("TestRunners")); var plugins = locator.Locate(); _identifiers = plugins .Select(x => { var instance = x.New(); if (instance == null) { Logger.WriteDebug(string.Format("Could not create plugin for {0} using {1}", x.Type, x.Assembly)); } return(instance); }) .Where(x => x != null); } return(_identifiers); }
private RunOptions generateOptions(TestRunInfo[] runInfos) { var options = new RunOptions(); var plugins = new PluginLocator().Locate(); foreach (var plugin in plugins) { var testRun = getTests(plugin, runInfos); if (testRun != null) { options.AddTestRun(testRun); } } if (options.TestRuns.Count() == 0) { return(null); } return(options); }
public ReactiveScriptEngine(string path, PluginLocator locator, Action <string, string> outputDispatcher, Action <string> dispatch) { _keyPath = path; _outputDispatcher = outputDispatcher; _dispatch = dispatch; _pausedScripts = new List <string>(); _reader = new ReactiveScriptReader( _keyPath, () => { return(locator); }, _outputDispatcher, (m) => _dispatch(m)); _touchHandler = new ScriptTouchHandler(_reader.GetPaths()); _scripts = _reader.Read(); foreach (var script in _scripts) { if (script.IsService) { script.StartService(); } } }
private string getTestRunner(string testRunner, string assembly, string test) { if (testRunner.ToLower() != "any") { return(testRunner); } var currentDirectory = Environment.CurrentDirectory; try { Environment.CurrentDirectory = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location); var plugins = new PluginLocator().Locate(); foreach (var plugin in plugins) { var instance = plugin.New(); if (instance == null) { continue; } if (instance.IsTest(assembly, test)) { return(instance.Identifier); } } } catch (Exception ex) { AutoTest.Core.DebugLog.Debug.WriteException(ex); } finally { Environment.CurrentDirectory = currentDirectory; } return(testRunner); }
public void Start( string path, ICacheBuilder cache, ICrawlResult crawlReader, PluginLocator pluginLocator, EventEndpoint eventDispatcher, string[] ignoreDirectories) { _cache = cache; _crawlReader = crawlReader; _eventDispatcher = eventDispatcher; Logger.Write("Setting up file trackers"); Logger.Write("Setting up token file trackers"); _tracker = new FileChangeTracker((x) => { if (x.Path.StartsWith(Path.Combine(path, ".OpenIDE"))) { return; } _eventDispatcher.Send( "codemodel raw-filesystem-change-" + x.Type.ToString().ToLower() + " \"" + x.Path + "\""); }); Logger.Write("Setting up local file trackers"); _localTracker = new FileChangeTracker((x) => { _eventDispatcher.Send( "codemodel raw-filesystem-change-" + x.Type.ToString().ToLower() + " \"" + x.Path + "\""); }); Logger.Write("Setting up global file trackers"); _globalTracker = new FileChangeTracker((x) => { _eventDispatcher.Send( "codemodel raw-filesystem-change-" + x.Type.ToString().ToLower() + " \"" + x.Path + "\""); }); Logger.Write("Adding plugins to cache"); var plugins = pluginLocator.Locate().ToList(); foreach (var x in plugins) { var plugin = new PluginPattern(x); _plugins.Add(plugin); _cache.Plugins.Add( new CachedPlugin(x.GetLanguage(), plugin.Patterns)); Logger.Write("Added plugin " + x.GetLanguage()); } var locator = new ProfileLocator(path); var profilePath = locator.GetLocalProfilePath(locator.GetActiveLocalProfile()); if (Directory.Exists(profilePath)) { Logger.Write("Starting tracker for {0}", path); _tracker.Start(path, getFilter(), handleChanges, ignoreDirectories); } else { Logger.Write("No local configuration point so not starting file tracker"); } if (Environment.OSVersion.Platform == PlatformID.Unix || Environment.OSVersion.Platform == PlatformID.MacOSX) { if (Directory.Exists(profilePath)) { Logger.Write("Starting tracker for {0}", profilePath); _localTracker.Start(profilePath, getFilter(), handleChanges, ignoreDirectories); } } var globalPath = locator.GetGlobalProfilePath(locator.GetActiveGlobalProfile()); if (Directory.Exists(globalPath)) { Logger.Write("Starting tracker for {0}", globalPath); _globalTracker.Start(globalPath, getFilter(), handleChanges, ignoreDirectories); } }
public static CommandEndpoint GetEndpoint(string path, string[] enabledLanguages) { _path = path; var reader = new ConfigReader(_path); _interpreters = new Interpreters(_path); ProcessExtensions.GetInterpreter = (file) => { var interpreters = _interpreters .GetInterpreterFor(Path.GetExtension(file)); return(interpreters); }; _cache = new TypeCache(); _outputEndpoint = new OutputEndpoint(_path); Logger.Write("Event endpoint serving on port: {0}", _outputEndpoint.Port); var responseDispatcher = new ResponseDispatcher( _path, false, "language-output ", (p, m) => _outputEndpoint.Send(p, m), (m) => _endpoint.Handle(m), (m) => {} ); responseDispatcher.OnlyCommands(); _pluginLocator = new PluginLocator( enabledLanguages, new ProfileLocator(_path), (msg) => { responseDispatcher.Handle(false, msg); } ); initPlugins(_pluginLocator); _eventEndpoint = new EventEndpoint(_path, _pluginLocator, _outputEndpoint); _eventEndpoint.Start(); Logger.Write("Event endpoint listening on port: {0}", _eventEndpoint.Port); Logger.Write("Creating plugin file tracker"); _tracker = new PluginFileTracker(); Logger.Write("Starting plugin file tracker"); var ignoreDirSetting = reader.Get("oi.ignore.directories"); var ignoreDirectories = new string[] {}; if (ignoreDirSetting != null) { ignoreDirectories = ignoreDirSetting .Split(new[] { ',' }) .Select(x => { if (Path.IsPathRooted(x)) { return(x); } return(Path.Combine(_path, x)); }) .ToArray(); } _tracker.Start( _path, _cache, _cache, _pluginLocator, _eventEndpoint, ignoreDirectories); Logger.Write("Plugin file tracker started"); _endpoint = new CommandEndpoint(_path, _cache, _eventEndpoint); _endpoint.AddHandler(messageHandler); _handlers.AddRange(new IHandler[] { new GetProjectsHandler(_endpoint, _cache), new GetFilesHandler(_endpoint, _cache), new GetCodeRefsHandler(_endpoint, _cache), new GetSignatureRefsHandler(_endpoint, _cache), new GoToDefinitionHandler(_endpoint, _cache, _pluginLocator), new FindTypeHandler(_endpoint, _cache), new SnippetEditHandler(_endpoint, _cache, _path), new SnippetDeleteHandler(_cache, _path), new GetRScriptStateHandler(_endpoint, _eventEndpoint), new CompleteSnippetHandler(_cache, _path, _endpoint), new WriteOutputHandler(_eventEndpoint), // Make sure this handler is the last one since the command can be file extension or language name new LanguageCommandHandler(_endpoint, _cache, _pluginLocator) }); Logger.Write("Command endpoint started"); return(_endpoint); }
public LanguageCommandHandler(CommandEndpoint endpoint, ICacheBuilder cache, PluginLocator pluginLocator) { _endpoint = endpoint; _cache = cache; _pluginLocator = pluginLocator; }
public void Init() { var fileCache = new Dictionary <string, Content <Stream> > (); Func <string, Content <Stream> > file2Content = (path) => { Content <Stream> result = null; if (!fileCache.TryGetValue(path, out result)) { var s = File.OpenRead(path); s.Position = 0; result = new Content <Stream> (s, CompressionType.None, ContentTypes.Unknown); fileCache.Add(path, result); } return(result); }; var pdfResponse = new WebResponse { AbsoluteUri = WebServer.Uri + "pdf", ClearContentAfterServing = false, IsStreamOwner = false }; var viewerDir = new PluginLocator().PluginDir(PdjJsDirectory) + Path.DirectorySeparatorChar; var viewerServerPath = WebServer.Uri + PdjJsDirectory + "/"; this.ContentGetter = (uri) => { if (pdfResponse.AbsoluteUri == uri) { return(pdfResponse.GetContentFromContent( new Content <Stream> ( this.Pdf, CompressionType.None, PdfContentSpot.PdfContentType))); } if (uri.StartsWith(viewerServerPath)) { if (WebServer.HasContent(uri)) { return(WebServer.GetContent(uri)); } else { var fileName = uri.Replace(viewerServerPath, viewerDir); if (fileName.Contains('?')) { fileName = fileName.Substring(0, fileName.IndexOf('?')); } var c = file2Content(fileName); var r = new WebResponse { AbsoluteUri = uri, ClearContentAfterServing = false, IsStreamOwner = false }; var fileGetter = r.Getter(c); WebServer.AddContent(r.AbsoluteUri, fileGetter); return(fileGetter(uri)); } } else { Trace.WriteLine("Request not answered: " + uri); } return(null); }; WebServer.ContentGetter = this.ContentGetter; WebServer.Closed += (s, e) => { fileCache.Values.ForEach(c => c.Data.Dispose()); fileCache.Clear(); }; ViewerUri = viewerServerPath + ViewerFileName + "?file=" + System.Net.WebUtility.HtmlEncode(pdfResponse.AbsoluteUri); }
public GoToDefinitionHandler(CommandEndpoint endpoint, TypeCache cache, PluginLocator locator) { _endpoint = endpoint; _cache = cache; _pluginLocator = locator; }
public ConfigurationHandler(string token, PluginLocator locator, Action <string> eventDispatcher) { _token = token; _pluginLocator = locator; _eventDispatcher = eventDispatcher; }