コード例 #1
0
        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);
        }
コード例 #2
0
 public GetRScriptStateHandler(CommandEndpoint endpoint, EventEndpoint eventEndpoint)
 {
     _endpoint      = endpoint;
     _eventEndpoint = eventEndpoint;
 }
コード例 #3
0
        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);
            }
        }
コード例 #4
0
 public WriteOutputHandler(EventEndpoint endpoint)
 {
     _endpoint = endpoint;
 }