Esempio n. 1
0
 void FMOpenTimerExpired()
 {
     IdeApp.Workspace.FirstWorkspaceItemOpened -= CompleteTimeToCode;
     timeToCodeTimer.Stop();
     timeToCodeTimer = null;
     ttcMetadata     = null;
 }
Esempio n. 2
0
        void FMOpenTimerExpired()
        {
            IdeApp.Workspace.FirstWorkspaceItemOpened -= CompleteSolutionTimeToCode;
            IdeApp.Workbench.DocumentOpened           -= CompleteFileTimeToCode;

            timeToCodeTimer.Stop();
            timeToCodeTimer = null;

            ttcMetadata = null;
        }
Esempio n. 3
0
        static long ttcDuration = 3 * TimeSpan.TicksPerSecond;         // Wait 3 seconds before ignoring TTC events

        internal static void OnStartupCompleted(StartupMetadata startupMetadata, Stopwatch ttcTimer)
        {
            ttcMetadata = new TimeToCodeMetadata {
                StartupTime = startupMetadata.CorrectedStartupTime
            };
            ttcMetadata.AddProperties(startupMetadata);

            ttcStopwatch          = ttcTimer;
            startupCompletedTicks = ttcStopwatch.ElapsedTicks;
            LoggingService.LogDebug("TTC starting");

            startupCompleted?.Invoke(null, EventArgs.Empty);
        }
Esempio n. 4
0
        internal void StartupCompleted(StartupInfo startupInfo, IPlatformTelemetryDetails platformTelemetryDetails)
        {
            var startupMetadata = GetStartupMetadata(startupInfo, platformTelemetryDetails);

            Counters.Startup.Inc(startupMetadata);

            // Start TTC timer
            ttcMetadata = new TimeToCodeMetadata {
                StartupTime = startupMetadata.CorrectedStartupTime
            };
            ttcMetadata.AddProperties(startupMetadata);

            LoggingService.LogDebug("TTC starting");
        }
Esempio n. 5
0
        internal void StartupCompleted(StartupInfo startupInfo, IPlatformTelemetryDetails platformTelemetryDetails)
        {
            var startupMetadata = GetStartupMetadata(startupInfo, platformTelemetryDetails);

            Counters.Startup.Inc(startupMetadata);

            // Start TTC timer
            ttcMetadata = new TimeToCodeMetadata {
                StartupTime = startupMetadata.CorrectedStartupTime
            };
            ttcMetadata.AddProperties(startupMetadata);

            LoggingService.LogDebug("TTC starting");

            foreach (var kvp in sectionTimings)
            {
                LoggingService.LogInfo("Startup section {0} {1} ms", kvp.Key, kvp.Value);
            }
            LoggingService.LogInfo("Startup sections {0} ms", startupTimer.ElapsedMilliseconds);
        }
Esempio n. 6
0
        int Run(MonoDevelopOptions options)
        {
            LoggingService.LogInfo("Starting {0} {1}", BrandingService.ApplicationLongName, IdeVersionInfo.MonoDevelopVersion);
            LoggingService.LogInfo("Build Information{0}{1}", Environment.NewLine, SystemInformation.GetBuildInformation());
            LoggingService.LogInfo("Running on {0}", RuntimeVersionInfo.GetRuntimeInfo());

            //ensure native libs initialized before we hit anything that p/invokes
            Platform.Initialize();
            sectionTimings ["PlatformInitialization"] = startupSectionTimer.ElapsedMilliseconds;
            startupSectionTimer.Restart();

            GettextCatalog.Initialize();
            sectionTimings ["GettextInitialization"] = startupSectionTimer.ElapsedMilliseconds;
            startupSectionTimer.Restart();

            LoggingService.LogInfo("Operating System: {0}", SystemInformation.GetOperatingSystemDescription());

            if (!Platform.IsWindows)
            {
                // The assembly resolver for MSBuild 15 assemblies needs to be defined early on.
                // Whilst Runtime.Initialize loads the MSBuild 15 assemblies from Mono this seems
                // to be too late to prevent the MEF composition and the static registrar from
                // failing to load the MonoDevelop.Ide assembly which now uses MSBuild 15 assemblies.
                ResolveMSBuildAssemblies();
            }

            Counters.Initialization.BeginTiming();

            if (options.PerfLog)
            {
                string logFile = Path.Combine(Environment.CurrentDirectory, "monodevelop.perf-log");
                LoggingService.LogInfo("Logging instrumentation service data to file: " + logFile);
                InstrumentationService.StartAutoSave(logFile, 1000);
            }

            Counters.Initialization.Trace("Initializing GTK");
            if (Platform.IsWindows && !CheckWindowsGtk())
            {
                return(1);
            }
            SetupExceptionManager();

            // explicit GLib type system initialization for GLib < 2.36 before any other type system access
            GLib.GType.Init();

            IdeApp.Customizer = options.IdeCustomizer ?? new IdeCustomizer();
            try {
                IdeApp.Customizer.Initialize();
            } catch (UnauthorizedAccessException ua) {
                LoggingService.LogError("Unauthorized access: " + ua.Message);
                return(1);
            }

            try {
                GLibLogging.Enabled = true;
            } catch (Exception ex) {
                LoggingService.LogError("Error initialising GLib logging.", ex);
            }

            var args = options.RemainingArgs.ToArray();

            IdeTheme.InitializeGtk(BrandingService.ApplicationName, ref args);

            sectionTimings["GtkInitialization"] = startupSectionTimer.ElapsedMilliseconds;
            startupSectionTimer.Restart();
            LoggingService.LogInfo("Using GTK+ {0}", IdeVersionInfo.GetGtkVersion());

            // XWT initialization
            FilePath p = typeof(IdeStartup).Assembly.Location;

            Runtime.LoadAssemblyFrom(p.ParentDirectory.Combine("Xwt.Gtk.dll"));
            Xwt.Application.InitializeAsGuest(Xwt.ToolkitType.Gtk);
            Xwt.Toolkit.CurrentEngine.RegisterBackend <IExtendedTitleBarWindowBackend, GtkExtendedTitleBarWindowBackend> ();
            Xwt.Toolkit.CurrentEngine.RegisterBackend <IExtendedTitleBarDialogBackend, GtkExtendedTitleBarDialogBackend> ();
            IdeTheme.SetupXwtTheme();

            sectionTimings["XwtInitialization"] = startupSectionTimer.ElapsedMilliseconds;
            startupSectionTimer.Restart();

            //default to Windows IME on Windows
            if (Platform.IsWindows && GtkWorkarounds.GtkMinorVersion >= 16)
            {
                var settings = Gtk.Settings.Default;
                var val      = GtkWorkarounds.GetProperty(settings, "gtk-im-module");
                if (string.IsNullOrEmpty(val.Val as string))
                {
                    GtkWorkarounds.SetProperty(settings, "gtk-im-module", new GLib.Value("ime"));
                }
            }

            string   socket_filename = null;
            EndPoint ep = null;

            DispatchService.Initialize();

            // Set a synchronization context for the main gtk thread
            SynchronizationContext.SetSynchronizationContext(DispatchService.SynchronizationContext);
            Runtime.MainSynchronizationContext = SynchronizationContext.Current;

            sectionTimings["DispatchInitialization"] = startupSectionTimer.ElapsedMilliseconds;
            startupSectionTimer.Restart();

            // Initialize Roslyn's synchronization context
            RoslynServices.RoslynService.Initialize();

            sectionTimings["RoslynInitialization"] = startupSectionTimer.ElapsedMilliseconds;
            startupSectionTimer.Restart();

            AddinManager.AddinLoadError += OnAddinError;

            var startupInfo = new StartupInfo(args);

            // If a combine was specified, force --newwindow.

            if (!options.NewWindow && startupInfo.HasFiles)
            {
                Counters.Initialization.Trace("Pre-Initializing Runtime to load files in existing window");
                Runtime.Initialize(true);
                foreach (var file in startupInfo.RequestedFileList)
                {
                    if (MonoDevelop.Projects.Services.ProjectService.IsWorkspaceItemFile(file.FileName))
                    {
                        options.NewWindow = true;
                        break;
                    }
                }
            }

            Counters.Initialization.Trace("Initializing Runtime");
            Runtime.Initialize(true);

            sectionTimings ["RuntimeInitialization"] = startupSectionTimer.ElapsedMilliseconds;
            startupSectionTimer.Restart();

            bool restartRequested = PropertyService.Get("MonoDevelop.Core.RestartRequested", false);

            startupInfo.Restarted = restartRequested;
            PropertyService.Set("MonoDevelop.Core.RestartRequested", false);

            IdeApp.Customizer.OnCoreInitialized();

            Counters.Initialization.Trace("Initializing theme");

            IdeTheme.SetupGtkTheme();

            sectionTimings["ThemeInitialized"] = startupSectionTimer.ElapsedMilliseconds;
            startupSectionTimer.Restart();

            ProgressMonitor monitor = new MonoDevelop.Core.ProgressMonitoring.ConsoleProgressMonitor();

            monitor.BeginTask(GettextCatalog.GetString("Starting {0}", BrandingService.ApplicationName), 2);

            //make sure that the platform service is initialised so that the Mac platform can subscribe to open-document events
            Counters.Initialization.Trace("Initializing Platform Service");
            DesktopService.Initialize();

            sectionTimings["PlatformInitialization"] = startupSectionTimer.ElapsedMilliseconds;
            startupSectionTimer.Restart();

            monitor.Step(1);

            if (options.IpcTcp)
            {
                listen_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
                ep            = new IPEndPoint(IPAddress.Loopback, ipcBasePort + HashSdbmBounded(Environment.UserName));
            }
            else
            {
                socket_filename = "/tmp/md-" + Environment.GetEnvironmentVariable("USER") + "-socket";
                listen_socket   = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.IP);
                ep = new UnixEndPoint(socket_filename);
            }

            // If not opening a combine, connect to existing monodevelop and pass filename(s) and exit
            if (!options.NewWindow && startupInfo.HasFiles)
            {
                try {
                    StringBuilder builder = new StringBuilder();
                    foreach (var file in startupInfo.RequestedFileList)
                    {
                        builder.AppendFormat("{0};{1};{2}\n", file.FileName, file.Line, file.Column);
                    }
                    listen_socket.Connect(ep);
                    listen_socket.Send(Encoding.UTF8.GetBytes(builder.ToString()));
                    return(0);
                } catch {
                    // Reset the socket
                    if (null != socket_filename && File.Exists(socket_filename))
                    {
                        File.Delete(socket_filename);
                    }
                }
            }

            Counters.Initialization.Trace("Checking System");

            CheckFileWatcher();

            sectionTimings["FileWatcherInitialization"] = startupSectionTimer.ElapsedMilliseconds;
            startupSectionTimer.Restart();

            Exception error            = null;
            int       reportedFailures = 0;

            try {
                Counters.Initialization.Trace("Loading Icons");
                //force initialisation before the workbench so that it can register stock icons for GTK before they get requested
                ImageService.Initialize();

                sectionTimings ["ImageInitialization"] = startupSectionTimer.ElapsedMilliseconds;
                startupSectionTimer.Restart();

                // If we display an error dialog before the main workbench window on OS X then a second application menu is created
                // which is then replaced with a second empty Apple menu.
                // XBC #33699
                Counters.Initialization.Trace("Initializing IdeApp");

                hideWelcomePage = startupInfo.HasFiles;
                IdeApp.Initialize(monitor, hideWelcomePage);
                sectionTimings ["AppInitialization"] = startupSectionTimer.ElapsedMilliseconds;
                startupSectionTimer.Restart();

                if (errorsList.Count > 0)
                {
                    using (AddinLoadErrorDialog dlg = new AddinLoadErrorDialog(errorsList.ToArray(), false)) {
                        if (!dlg.Run())
                        {
                            return(1);
                        }
                    }
                    reportedFailures = errorsList.Count;
                }

                if (!CheckSCPlugin())
                {
                    return(1);
                }

                // Load requested files
                Counters.Initialization.Trace("Opening Files");

                // load previous combine
                RecentFile openedProject = null;
                if (IdeApp.Preferences.LoadPrevSolutionOnStartup && !startupInfo.HasSolutionFile && !IdeApp.Workspace.WorkspaceItemIsOpening && !IdeApp.Workspace.IsOpen)
                {
                    openedProject = DesktopService.RecentFiles.MostRecentlyUsedProject;
                    if (openedProject != null)
                    {
                        var metadata = GetOpenWorkspaceOnStartupMetadata();
                        IdeApp.Workspace.OpenWorkspaceItem(openedProject.FileName, true, true, metadata).ContinueWith(t => IdeApp.OpenFiles(startupInfo.RequestedFileList, metadata), TaskScheduler.FromCurrentSynchronizationContext());
                        startupInfo.OpenedRecentProject = true;
                    }
                }
                if (openedProject == null)
                {
                    IdeApp.OpenFiles(startupInfo.RequestedFileList, GetOpenWorkspaceOnStartupMetadata());
                    startupInfo.OpenedFiles = startupInfo.HasFiles;
                }

                monitor.Step(1);
            } catch (Exception e) {
                error = e;
            } finally {
                monitor.Dispose();
            }

            if (error != null)
            {
                string message = BrandingService.BrandApplicationName(GettextCatalog.GetString("MonoDevelop failed to start"));
                MessageService.ShowFatalError(message, null, error);

                return(1);
            }

            if (errorsList.Count > reportedFailures)
            {
                using (AddinLoadErrorDialog dlg = new AddinLoadErrorDialog(errorsList.ToArray(), true))
                    dlg.Run();
            }

            errorsList = null;
            AddinManager.AddinLoadError -= OnAddinError;

            sectionTimings["BasicInitializationCompleted"] = startupSectionTimer.ElapsedMilliseconds;
            startupSectionTimer.Restart();

            // FIXME: we should probably track the last 'selected' one
            // and do this more cleanly
            try {
                listen_socket.Bind(ep);
                listen_socket.Listen(5);
                listen_socket.BeginAccept(new AsyncCallback(ListenCallback), listen_socket);
            } catch {
                // Socket already in use
            }

            sectionTimings["SocketInitialization"] = startupSectionTimer.ElapsedMilliseconds;
            startupSectionTimer.Restart();

            initialized = true;
            MessageService.RootWindow    = IdeApp.Workbench.RootWindow;
            Xwt.MessageDialog.RootWindow = Xwt.Toolkit.CurrentEngine.WrapWindow(IdeApp.Workbench.RootWindow);

            sectionTimings["WindowOpened"] = startupSectionTimer.ElapsedMilliseconds;
            startupSectionTimer.Restart();

            Thread.CurrentThread.Name = "GUI Thread";
            Counters.Initialization.Trace("Running IdeApp");
            Counters.Initialization.EndTiming();

            AddinManager.AddExtensionNodeHandler("/MonoDevelop/Ide/InitCompleteHandlers", OnExtensionChanged);
            StartLockupTracker();

            // This call is important so the current event loop is run before we run the main loop.
            // On Mac, the OpenDocuments event gets handled here, so we need to get the timeout
            // it queues before the OnIdle event so we can start opening a solution before
            // we show the main window.
            DispatchService.RunPendingEvents();

            sectionTimings ["PumpEventLoop"] = startupSectionTimer.ElapsedMilliseconds;
            startupTimer.Stop();
            startupSectionTimer.Stop();

            // Need to start this timer because we don't know yet if we've been asked to open a solution from the file manager.
            timeToCodeTimer.Start();
            ttcMetadata = new TimeToCodeMetadata {
                StartupTime = startupTimer.ElapsedMilliseconds
            };

            // Start this timer to limit the time to decide if the app was opened by a file manager
            IdeApp.StartFMOpenTimer(FMOpenTimerExpired);
            IdeApp.Workspace.FirstWorkspaceItemOpened += CompleteSolutionTimeToCode;
            IdeApp.Workbench.DocumentOpened           += CompleteFileTimeToCode;

            CreateStartupMetadata(startupInfo, sectionTimings);

            GLib.Idle.Add(OnIdle);
            IdeApp.Run();

            IdeApp.Customizer.OnIdeShutdown();

            // unloading services
            if (null != socket_filename)
            {
                File.Delete(socket_filename);
            }
            lockupCheckRunning = false;
            Runtime.Shutdown();

            IdeApp.Customizer.OnCoreShutdown();

            InstrumentationService.Stop();

            MonoDevelop.Components.GtkWorkarounds.Terminate();

            return(0);
        }