Пример #1
0
        void RunQueries(object ob)
        {
            //	DateTime t = DateTime.Now;
            //	Console.WriteLine ("RunQueries started");
            try {
                lock (queryLock) {
                    var groups = fileQueryQueue.GroupBy(q => (q.QueryFlags & VersionInfoQueryFlags.IncludeRemoteStatus) != 0);
                    foreach (var group in groups)
                    {
                        var status = OnGetVersionInfo(group.SelectMany(q => q.Paths), group.Key);
                        infoCache.SetStatus(status);
                    }
                    filesInQueryQueue.Clear();

                    foreach (var item in directoryQueryQueue)
                    {
                        var status = OnGetDirectoryVersionInfo(item.Directory, item.GetRemoteStatus, false);
                        infoCache.SetDirectoryStatus(item.Directory, status, item.GetRemoteStatus);
                    }
                    directoriesInQueryQueue.Clear();

                    fileQueryQueue.Clear();
                    directoryQueryQueue.Clear();
                    queryRunning = false;
                }
            } catch (Exception ex) {
                LoggingService.LogError("Version control status query failed", ex);
            }
            //Console.WriteLine ("RunQueries finished - " + (DateTime.Now - t).TotalMilliseconds);
        }
Пример #2
0
        void RunQueries(object ob)
        {
            //	DateTime t = DateTime.Now;
            //	Console.WriteLine ("RunQueries started");
            try {
                while (true)
                {
                    VersionInfoQuery []   fileQueryQueueClone;
                    DirectoryInfoQuery [] directoryQueryQueueClone;

                    lock (queryLock) {
                        if (fileQueryQueue.Count == 0 && directoryQueryQueue.Count == 0)
                        {
                            queryRunning = false;
                            return;
                        }

                        fileQueryQueueClone = fileQueryQueue.ToArray();
                        fileQueryQueue.Clear();
                        filesInQueryQueue.Clear();

                        directoryQueryQueueClone = directoryQueryQueue.ToArray();
                        directoriesInQueryQueue.Clear();
                        directoryQueryQueue.Clear();
                    }

                    // Ensure we do not execute this with the query lock held, otherwise the IDE can hang while trying to add
                    // new queries to the queue while long-running VCS operations are being performed
                    var groups = fileQueryQueueClone.GroupBy(q => (q.QueryFlags & VersionInfoQueryFlags.IncludeRemoteStatus) != 0);
                    foreach (var group in groups)
                    {
                        var status = OnGetVersionInfo(group.SelectMany(q => q.Paths), group.Key);
                        infoCache.SetStatus(status);
                    }

                    foreach (var item in directoryQueryQueueClone)
                    {
                        var status = OnGetDirectoryVersionInfo(item.Directory, item.GetRemoteStatus, false);
                        infoCache.SetDirectoryStatus(item.Directory, status, item.GetRemoteStatus);
                    }
                }
            } catch (Exception ex) {
                LoggingService.LogError("Version control status query failed", ex);
            }
            //Console.WriteLine ("RunQueries finished - " + (DateTime.Now - t).TotalMilliseconds);
        }
Пример #3
0
 void RunQueries(object ob)
 {
     //	DateTime t = DateTime.Now;
     //	Console.WriteLine ("RunQueries started");
     do
     {
         object query = null;
         lock (queryQueue) {
             if (queryQueue.Count == 0)
             {
                 queryRunning = false;
                 break;
             }
             query = queryQueue.Dequeue();
             if (query is VersionInfoQuery)
             {
                 VersionInfoQuery q = (VersionInfoQuery)query;
                 filesInQueryQueue.ExceptWith(q.Paths);
             }
             else if (query is DirectoryInfoQuery)
             {
                 var q = (DirectoryInfoQuery)query;
                 directoriesInQueryQueue.Remove(q.Directory);
             }
         }
         try {
             if (query is VersionInfoQuery)
             {
                 VersionInfoQuery q = (VersionInfoQuery)query;
                 var status         = OnGetVersionInfo(q.Paths, (q.QueryFlags & VersionInfoQueryFlags.IncludeRemoteStatus) != 0);
                 infoCache.SetStatus(status);
             }
             else if (query is DirectoryInfoQuery)
             {
                 var q      = (DirectoryInfoQuery)query;
                 var status = OnGetDirectoryVersionInfo(q.Directory, q.GetRemoteStatus, false);
                 infoCache.SetDirectoryStatus(q.Directory, status, q.GetRemoteStatus);
             }
         } catch (Exception ex) {
             LoggingService.LogError("Version control status query failed", ex);
         }
     } while (true);
     //Console.WriteLine ("RunQueries finished - " + (DateTime.Now - t).TotalMilliseconds);
 }
Пример #4
0
        void RunQueries(object ob)
        {
            //	DateTime t = DateTime.Now;
            //	Console.WriteLine ("RunQueries started");
            VersionInfoQuery []            fileQueryQueueClone;
            DirectoryInfoQuery []          directoryQueryQueueClone;
            RecursiveDirectoryInfoQuery [] recursiveDirectoryQueryQueueClone = new RecursiveDirectoryInfoQuery[0];
            try {
                while (true)
                {
                    lock (queryLock) {
                        if (fileQueryQueue.Count == 0 &&
                            directoryQueryQueue.Count == 0 &&
                            recursiveDirectoryQueryQueue.Count == 0)
                        {
                            queryRunning = false;
                            return;
                        }

                        fileQueryQueueClone = fileQueryQueue.ToArray();
                        fileQueryQueue.Clear();
                        filesInQueryQueue.Clear();

                        directoryQueryQueueClone = directoryQueryQueue.ToArray();
                        directoriesInQueryQueue.Clear();
                        directoryQueryQueue.Clear();

                        recursiveDirectoryQueryQueueClone = recursiveDirectoryQueryQueue.ToArray();
                        recursiveDirectoriesInQueryQueue.Clear();
                        recursiveDirectoryQueryQueue.Clear();
                    }

                    // Ensure we do not execute this with the query lock held, otherwise the IDE can hang while trying to add
                    // new queries to the queue while long-running VCS operations are being performed
                    var groups = fileQueryQueueClone.GroupBy(q => (q.QueryFlags & VersionInfoQueryFlags.IncludeRemoteStatus) != 0);
                    foreach (var group in groups)
                    {
                        if (IsDisposed)
                        {
                            break;
                        }
                        var status = OnGetVersionInfo(group.SelectMany(q => q.Paths), group.Key).ToList();
                        foreach (var vi in status)
                        {
                            if (!vi.IsInitialized)
                            {
                                vi.Init(this);
                            }
                        }
                        infoCache.SetStatus(status);
                    }

                    foreach (var item in directoryQueryQueueClone)
                    {
                        if (IsDisposed)
                        {
                            break;
                        }
                        var status = OnGetDirectoryVersionInfo(item.Directory, item.GetRemoteStatus, false);
                        foreach (var vi in status)
                        {
                            if (!vi.IsInitialized)
                            {
                                vi.Init(this);
                            }
                        }
                        infoCache.SetDirectoryStatus(item.Directory, status, item.GetRemoteStatus);
                    }

                    foreach (var item in recursiveDirectoryQueryQueueClone)
                    {
                        try {
                            if (IsDisposed)
                            {
                                continue;
                            }
                            item.Result = OnGetDirectoryVersionInfo(item.Directory, item.GetRemoteStatus, true);
                            foreach (var vi in item.Result)
                            {
                                if (!vi.IsInitialized)
                                {
                                    vi.Init(this);
                                }
                            }
                        } finally {
                            item.ResetEvent.Set();
                        }
                    }
                }
            } catch (Exception ex) {
                LoggingService.LogError("Version control status query failed", ex);

                //Release all items in current batch
                foreach (var item in recursiveDirectoryQueryQueueClone)
                {
                    item.ResetEvent.Set();
                }

                lock (queryLock) {
                    queryRunning = false;

                    fileQueryQueue.Clear();
                    filesInQueryQueue.Clear();

                    directoriesInQueryQueue.Clear();
                    directoryQueryQueue.Clear();

                    recursiveDirectoryQueryQueueClone = recursiveDirectoryQueryQueue.ToArray();
                    recursiveDirectoriesInQueryQueue.Clear();
                    recursiveDirectoryQueryQueue.Clear();
                }

                //Release newly pending
                foreach (var item in recursiveDirectoryQueryQueueClone)
                {
                    item.ResetEvent.Set();
                }
            }
            //Console.WriteLine ("RunQueries finished - " + (DateTime.Now - t).TotalMilliseconds);
        }