src/TGitCache/GITStatusCache.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // External Cache Copyright (C) 2005-2006,2008,2010 - TortoiseSVN
   4 // Copyright (C) 2008-2011 - TortoiseGit
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20
  21 #include "StdAfx.h"
  22 #include "GitStatus.h"
  23 #include "GitStatuscache.h"
  24 #include "CacheInterface.h"
  25 #include "shlobj.h"
  26
  27 //////////////////////////////////////////////////////////////////////////
  28
  29 #define BLOCK_PATH_DEFAULT_TIMEOUT      600             // 10 minutes
  30 #define BLOCK_PATH_MAX_TIMEOUT          1200    // 20 minutes
  31
  32 CGitStatusCache* CGitStatusCache::m_pInstance;
  33
  34 CGitStatusCache& CGitStatusCache::Instance()
  35 {
  36         ATLASSERT(m_pInstance != NULL);
  37         return *m_pInstance;
  38 }
  39
  40 void CGitStatusCache::Create()
  41 {
  42         ATLASSERT(m_pInstance == NULL);
  43         m_pInstance = new CGitStatusCache;
  44
  45         m_pInstance->watcher.SetFolderCrawler(&m_pInstance->m_folderCrawler);
  46 #define LOADVALUEFROMFILE(x) if (fread(&x, sizeof(x), 1, pFile)!=1) goto exit;
  47 #define LOADVALUEFROMFILE2(x) if (fread(&x, sizeof(x), 1, pFile)!=1) goto error;
  48         unsigned int value = (unsigned int)-1;
  49         FILE * pFile = NULL;
  50         // find the location of the cache
  51         TCHAR path[MAX_PATH];           //MAX_PATH ok here.
  52         TCHAR path2[MAX_PATH];
  53         if (SHGetFolderPath(NULL, CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, path)==S_OK)
  54         {
  55                 _tcscat_s(path, MAX_PATH, _T("\\TGitCache"));
  56                 if (!PathIsDirectory(path))
  57                 {
  58                         if (CreateDirectory(path, NULL)==0)
  59                                 goto error;
  60                 }
  61                 _tcscat_s(path, MAX_PATH, _T("\\cache"));
  62                 // in case the cache file is corrupt, we could crash while
  63                 // reading it! To prevent crashing every time once that happens,
  64                 // we make a copy of the cache file and use that copy to read from.
  65                 // if that copy is corrupt, the original file won't exist anymore
  66                 // and the second time we start up and try to read the file,
  67                 // it's not there anymore and we start from scratch without a crash.
  68                 _tcscpy_s(path2, MAX_PATH, path);
  69                 _tcscat_s(path2, MAX_PATH, _T("2"));
  70                 DeleteFile(path2);
  71                 CopyFile(path, path2, FALSE);
  72                 DeleteFile(path);
  73                 pFile = _tfsopen(path2, _T("rb"), _SH_DENYNO);
  74                 if (pFile)
  75                 {
  76                         try
  77                         {
  78                                 LOADVALUEFROMFILE(value);
  79                                 if (value != 2)
  80                                 {
  81                                         goto error;
  82                                 }
  83                                 int mapsize = 0;
  84                                 LOADVALUEFROMFILE(mapsize);
  85                                 for (int i=0; i<mapsize; ++i)
  86                                 {
  87                                         LOADVALUEFROMFILE2(value);
  88                                         if (value > MAX_PATH)
  89                                                 goto error;
  90                                         if (value)
  91                                         {
  92                                                 CString sKey;
  93                                                 if (fread(sKey.GetBuffer(value+1), sizeof(TCHAR), value, pFile)!=value)
  94                                                 {
  95                                                         sKey.ReleaseBuffer(0);
  96                                                         goto error;
  97                                                 }
  98                                                 sKey.ReleaseBuffer(value);
  99                                                 CCachedDirectory * cacheddir = new CCachedDirectory();
 100                                                 if (cacheddir == NULL)
 101                                                         goto error;
 102                                                 if (!cacheddir->LoadFromDisk(pFile))
 103                                                         goto error;
 104                                                 CTGitPath KeyPath = CTGitPath(sKey);
 105                                                 if (m_pInstance->IsPathAllowed(KeyPath))
 106                                                 {
 107                                                         m_pInstance->m_directoryCache[KeyPath] = cacheddir;
 108                                                         // only add the path to the watch list if it is versioned
 109                                                         if ((cacheddir->GetCurrentFullStatus() != git_wc_status_unversioned)&&(cacheddir->GetCurrentFullStatus() != git_wc_status_none))
 110                                                                 m_pInstance->watcher.AddPath(KeyPath);
 111                                                         // do *not* add the paths for crawling!
 112                                                         // because crawled paths will trigger a shell
 113                                                         // notification, which makes the desktop flash constantly
 114                                                         // until the whole first time crawling is over
 115                                                         // m_pInstance->AddFolderForCrawling(KeyPath);
 116                                                 }
 117                                         }
 118                                 }
 119                         }
 120                         catch (CAtlException)
 121                         {
 122                                 goto error;
 123                         }
 124                 }
 125         }
 126 exit:
 127         if (pFile)
 128                 fclose(pFile);
 129         DeleteFile(path2);
 130         ATLTRACE("cache loaded from disk successfully!\n");
 131         return;
 132 error:
 133         fclose(pFile);
 134         DeleteFile(path2);
 135         if (m_pInstance)
 136         {
 137                 m_pInstance->Stop();
 138                 Sleep(100);
 139         }
 140         delete m_pInstance;
 141         m_pInstance = new CGitStatusCache;
 142         ATLTRACE("cache not loaded from disk\n");
 143 }
 144
 145 bool CGitStatusCache::SaveCache()
 146 {
 147 #define WRITEVALUETOFILE(x) if (fwrite(&x, sizeof(x), 1, pFile)!=1) goto error;
 148         unsigned int value = 0;
 149         // save the cache to disk
 150         FILE * pFile = NULL;
 151         // find a location to write the cache to
 152         TCHAR path[MAX_PATH];           //MAX_PATH ok here.
 153         if (SHGetFolderPath(NULL, CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, path)==S_OK)
 154         {
 155                 _tcscat_s(path, MAX_PATH, _T("\\TGitCache"));
 156                 if (!PathIsDirectory(path))
 157                         CreateDirectory(path, NULL);
 158                 _tcscat_s(path, MAX_PATH, _T("\\cache"));
 159                 _tfopen_s(&pFile, path, _T("wb"));
 160                 if (pFile)
 161                 {
 162                         value = 2;              // 'version'
 163                         WRITEVALUETOFILE(value);
 164                         value = (int)m_pInstance->m_directoryCache.size();
 165                         WRITEVALUETOFILE(value);
 166                         for (CCachedDirectory::CachedDirMap::iterator I = m_pInstance->m_directoryCache.begin(); I != m_pInstance->m_directoryCache.end(); ++I)
 167                         {
 168                                 if (I->second == NULL)
 169                                 {
 170                                         value = 0;
 171                                         WRITEVALUETOFILE(value);
 172                                         continue;
 173                                 }
 174                                 const CString& key = I->first.GetWinPathString();
 175                                 value = key.GetLength();
 176                                 WRITEVALUETOFILE(value);
 177                                 if (value)
 178                                 {
 179                                         if (fwrite((LPCTSTR)key, sizeof(TCHAR), value, pFile)!=value)
 180                                                 goto error;
 181                                         if (!I->second->SaveToDisk(pFile))
 182                                                 goto error;
 183                                 }
 184                         }
 185                         fclose(pFile);
 186                 }
 187         }
 188         ATLTRACE(_T("cache saved to disk at %s\n"), path);
 189         return true;
 190 error:
 191         fclose(pFile);
 192         if (m_pInstance)
 193         {
 194                 m_pInstance->Stop();
 195                 Sleep(100);
 196         }
 197         delete m_pInstance;
 198         m_pInstance = NULL;
 199         DeleteFile(path);
 200         return false;
 201 }
 202
 203 void CGitStatusCache::Destroy()
 204 {
 205         if (m_pInstance)
 206         {
 207                 m_pInstance->Stop();
 208                 Sleep(100);
 209         }
 210         delete m_pInstance;
 211         m_pInstance = NULL;
 212 }
 213
 214 void CGitStatusCache::Stop()
 215 {
 216 //      m_svnHelp.Cancel(true);
 217         watcher.Stop();
 218         m_folderCrawler.Stop();
 219         m_shellUpdater.Stop();
 220 }
 221
 222 void CGitStatusCache::Init()
 223 {
 224         m_folderCrawler.Initialise();
 225         m_shellUpdater.Initialise();
 226 }
 227
 228 CGitStatusCache::CGitStatusCache(void)
 229 {
 230         #define forever DWORD(-1)
 231         AutoLocker lock(m_NoWatchPathCritSec);
 232         TCHAR path[MAX_PATH];
 233         SHGetFolderPath(NULL, CSIDL_COOKIES, NULL, 0, path);
 234         m_NoWatchPaths[CTGitPath(CString(path))] = forever;
 235         SHGetFolderPath(NULL, CSIDL_HISTORY, NULL, 0, path);
 236         m_NoWatchPaths[CTGitPath(CString(path))] = forever;
 237         SHGetFolderPath(NULL, CSIDL_INTERNET_CACHE, NULL, 0, path);
 238         m_NoWatchPaths[CTGitPath(CString(path))] = forever;
 239         SHGetFolderPath(NULL, CSIDL_SYSTEM, NULL, 0, path);
 240         m_NoWatchPaths[CTGitPath(CString(path))] = forever;
 241         SHGetFolderPath(NULL, CSIDL_WINDOWS, NULL, 0, path);
 242         m_NoWatchPaths[CTGitPath(CString(path))] = forever;
 243         m_bClearMemory = false;
 244         m_mostRecentExpiresAt = 0;
 245 }
 246
 247 CGitStatusCache::~CGitStatusCache(void)
 248 {
 249         for (CCachedDirectory::CachedDirMap::iterator I = m_pInstance->m_directoryCache.begin(); I != m_pInstance->m_directoryCache.end(); ++I)
 250         {
 251                 delete I->second;
 252                 I->second = NULL;
 253         }
 254         m_directoryCache.clear();
 255 }
 256
 257 void CGitStatusCache::Refresh()
 258 {
 259         m_shellCache.ForceRefresh();
 260 //      m_pInstance->m_svnHelp.ReloadConfig();
 261         if (m_pInstance->m_directoryCache.size())
 262         {
 263                 CCachedDirectory::CachedDirMap::iterator I = m_pInstance->m_directoryCache.begin();
 264                 for (/* no init */; I != m_pInstance->m_directoryCache.end(); ++I)
 265                 {
 266                         if (m_shellCache.IsPathAllowed(I->first.GetWinPath()))
 267                                 I->second->RefreshMostImportant();
 268                         else
 269                         {
 270                                 CGitStatusCache::Instance().RemoveCacheForPath(I->first);
 271                                 I = m_pInstance->m_directoryCache.begin();
 272                                 if (I == m_pInstance->m_directoryCache.end())
 273                                         break;
 274                         }
 275                 }
 276         }
 277 }
 278
 279 bool CGitStatusCache::IsPathGood(const CTGitPath& path)
 280 {
 281         AutoLocker lock(m_NoWatchPathCritSec);
 282         for (std::map<CTGitPath, DWORD>::const_iterator it = m_NoWatchPaths.begin(); it != m_NoWatchPaths.end(); ++it)
 283         {
 284                 // the ticks check is necessary here, because RemoveTimedoutBlocks is only called within the FolderCrawler loop
 285                 // and we might miss update calls
 286                 // TODO: maybe we also need to check if index.lock and HEAD.lock still exists after a specific timeout (if we miss update notifications for these files too often)
 287                 if (GetTickCount() < it->second && it->first.IsAncestorOf(path))
 288                 {
 289                         ATLTRACE(_T("path not good: %s\n"), it->first.GetWinPath());
 290                         return false;
 291                 }
 292         }
 293         return true;
 294 }
 295
 296 bool CGitStatusCache::BlockPath(const CTGitPath& path, DWORD timeout /* = 0 */)
 297 {
 298         if (timeout == 0)
 299                 timeout = BLOCK_PATH_DEFAULT_TIMEOUT;
 300
 301         if (timeout > BLOCK_PATH_MAX_TIMEOUT)
 302                 timeout = BLOCK_PATH_MAX_TIMEOUT;
 303
 304         timeout = GetTickCount() + (timeout * 1000);    // timeout is in seconds, but we need the milliseconds
 305
 306         AutoLocker lock(m_NoWatchPathCritSec);
 307         m_NoWatchPaths[path.GetDirectory()] = timeout;
 308
 309         return true;
 310 }
 311
 312 bool CGitStatusCache::UnBlockPath(const CTGitPath& path)
 313 {
 314         bool ret = false;
 315         AutoLocker lock(m_NoWatchPathCritSec);
 316         std::map<CTGitPath, DWORD>::iterator it = m_NoWatchPaths.find(path.GetDirectory());
 317         if (it != m_NoWatchPaths.end())
 318         {
 319                 ATLTRACE(_T("path removed from no good: %s\n"), it->first.GetWinPath());
 320                 m_NoWatchPaths.erase(it);
 321                 ret = true;
 322         }
 323         AddFolderForCrawling(path.GetDirectory());
 324
 325         return ret;
 326 }
 327
 328 bool CGitStatusCache::RemoveTimedoutBlocks()
 329 {
 330         bool ret = false;
 331         DWORD currentTicks = GetTickCount();
 332         AutoLocker lock(m_NoWatchPathCritSec);
 333         std::vector<CTGitPath> toRemove;
 334         for (std::map<CTGitPath, DWORD>::const_iterator it = m_NoWatchPaths.begin(); it != m_NoWatchPaths.end(); ++it)
 335         {
 336                 if (currentTicks > it->second)
 337                 {
 338                         toRemove.push_back(it->first);
 339                 }
 340         }
 341         if (toRemove.size())
 342         {
 343                 for (std::vector<CTGitPath>::const_iterator it = toRemove.begin(); it != toRemove.end(); ++it)
 344                 {
 345                         ret = ret || UnBlockPath(*it);
 346                 }
 347         }
 348
 349         return ret;
 350 }
 351
 352 void CGitStatusCache::UpdateShell(const CTGitPath& path)
 353 {
 354         m_shellUpdater.AddPathForUpdate(path);
 355 }
 356
 357 void CGitStatusCache::ClearCache()
 358 {
 359         for (CCachedDirectory::CachedDirMap::iterator I = m_directoryCache.begin(); I != m_directoryCache.end(); ++I)
 360         {
 361                 delete I->second;
 362                 I->second = NULL;
 363         }
 364         m_directoryCache.clear();
 365 }
 366
 367 bool CGitStatusCache::RemoveCacheForDirectory(CCachedDirectory * cdir)
 368 {
 369         if (cdir == NULL)
 370                 return false;
 371
 372         typedef std::map<CTGitPath, git_wc_status_kind>  ChildDirStatus;
 373         if (cdir->m_childDirectories.size())
 374         {
 375                 ChildDirStatus::iterator it = cdir->m_childDirectories.begin();
 376                 for (; it != cdir->m_childDirectories.end(); )
 377                 {
 378                         CCachedDirectory * childdir = CGitStatusCache::Instance().GetDirectoryCacheEntryNoCreate(it->first);
 379                         if ((childdir) && (!cdir->m_directoryPath.IsEquivalentTo(childdir->m_directoryPath)) && (cdir->m_directoryPath.GetFileOrDirectoryName() != L".."))
 380                                 RemoveCacheForDirectory(childdir);
 381                         cdir->m_childDirectories.erase(it->first);
 382                         it = cdir->m_childDirectories.begin();
 383                 }
 384         }
 385         cdir->m_childDirectories.clear();
 386         m_directoryCache.erase(cdir->m_directoryPath);
 387         ATLTRACE(_T("removed path %s from cache\n"), cdir->m_directoryPath.GetWinPathString());
 388         delete cdir;
 389         cdir = NULL;
 390         return true;
 391 }
 392
 393 void CGitStatusCache::RemoveCacheForPath(const CTGitPath& path)
 394 {
 395         // Stop the crawler starting on a new folder
 396         CCrawlInhibitor crawlInhibit(&m_folderCrawler);
 397         CCachedDirectory::ItDir itMap;
 398         CCachedDirectory * dirtoremove = NULL;
 399
 400         itMap = m_directoryCache.find(path);
 401         if ((itMap != m_directoryCache.end())&&(itMap->second))
 402                 dirtoremove = itMap->second;
 403         if (dirtoremove == NULL)
 404                 return;
 405         ATLASSERT(path.IsEquivalentToWithoutCase(dirtoremove->m_directoryPath));
 406         RemoveCacheForDirectory(dirtoremove);
 407 }
 408
 409 CCachedDirectory * CGitStatusCache::GetDirectoryCacheEntry(const CTGitPath& path, bool isAddToWatch)
 410 {
 411         ATLASSERT(path.IsDirectory() || !PathFileExists(path.GetWinPath()));
 412
 413
 414         CCachedDirectory::ItDir itMap;
 415         itMap = m_directoryCache.find(path);
 416         if ((itMap != m_directoryCache.end())&&(itMap->second))
 417         {
 418                 // We've found this directory in the cache
 419                 return itMap->second;
 420         }
 421         else
 422         {
 423                 // if the CCachedDirectory is NULL but the path is in our cache,
 424                 // that means that path got invalidated and needs to be treated
 425                 // as if it never was in our cache. So we remove the last remains
 426                 // from the cache and start from scratch.
 427
 428                 CAutoWriteLock writeLock(m_guard);
 429                 // Since above there's a small chance that before we can upgrade to
 430                 // writer state some other thread gained writer state and changed
 431                 // the data, we have to recreate the iterator here again.
 432                 itMap = m_directoryCache.find(path);
 433                 if (itMap!=m_directoryCache.end())
 434                         m_directoryCache.erase(itMap);
 435                 // We don't know anything about this directory yet - lets add it to our cache
 436                 // but only if it exists!
 437                 if (path.Exists() && m_shellCache.IsPathAllowed(path.GetWinPath()) && !g_GitAdminDir.IsAdminDirPath(path.GetWinPath()))
 438                 {
 439                         // some notifications are for files which got removed/moved around.
 440                         // In such cases, the CTGitPath::IsDirectory() will return true (it assumes a directory if
 441                         // the path doesn't exist). Which means we can get here with a path to a file
 442                         // instead of a directory.
 443                         // Since we're here most likely called from the crawler thread, the file could exist
 444                         // again. If that's the case, just do nothing
 445                         if (path.IsDirectory()||(!path.Exists()))
 446                         {
 447                                 ATLTRACE(_T("adding %s to our cache\n"), path.GetWinPath());
 448                                 CCachedDirectory * newcdir = new CCachedDirectory(path);
 449                                 if (newcdir)
 450                                 {
 451                                         CCachedDirectory * cdir = m_directoryCache.insert(m_directoryCache.lower_bound(path), std::make_pair(path, newcdir))->second;
 452                                         CString gitdir;
 453                                         if ((!path.IsEmpty())&&(path.HasAdminDir(&gitdir))&&isAddToWatch)
 454                                         {
 455                                                 bool isVersion = true;
 456                                                 CString subpaths;
 457                                                 if(subpaths.GetLength() > gitdir.GetLength())
 458                                                 {
 459                                                         if(subpaths[gitdir.GetLength()] == _T('\\'))
 460                                                                 subpaths=subpaths.Right(subpaths.GetLength() - gitdir.GetLength()-1);
 461                                                         else
 462                                                                 subpaths=subpaths.Right(subpaths.GetLength() - gitdir.GetLength());
 463                                                 }
 464                                                 CGitStatusCache::Instance().m_GitStatus.IsUnderVersionControl(gitdir, subpaths, true, &isVersion);
 465
 466                                                 /* Just watch version path */
 467                                                 if(isVersion)
 468                                                 {
 469                                                         watcher.AddPath(gitdir);
 470                                                         watcher.AddPath(path);
 471                                                 }
 472                                         }
 473                                         return cdir;
 474                                 }
 475                                 m_bClearMemory = true;
 476                         }
 477                 }
 478                 return NULL;
 479         }
 480 }
 481
 482 CCachedDirectory * CGitStatusCache::GetDirectoryCacheEntryNoCreate(const CTGitPath& path)
 483 {
 484         ATLASSERT(path.IsDirectory() || !PathFileExists(path.GetWinPath()));
 485
 486         CCachedDirectory::ItDir itMap;
 487         itMap = m_directoryCache.find(path);
 488         if(itMap != m_directoryCache.end())
 489         {
 490                 // We've found this directory in the cache
 491                 return itMap->second;
 492         }
 493         return NULL;
 494 }
 495
 496 /* Fetch is true, means fetch status from */
 497 /* Fetch is false, means fetch status from cache */
 498 CStatusCacheEntry CGitStatusCache::GetStatusForPath(const CTGitPath& path, DWORD flags,  bool bFetch /* = true */)
 499 {
 500         bool bRecursive = !!(flags & TGITCACHE_FLAGS_RECUSIVE_STATUS);
 501
 502         // Check a very short-lived 'mini-cache' of the last thing we were asked for.
 503         long now = (long)GetTickCount();
 504         if(now-m_mostRecentExpiresAt < 0)
 505         {
 506                 if(path.IsEquivalentToWithoutCase(m_mostRecentPath))
 507                 {
 508                         return m_mostRecentStatus;
 509                 }
 510         }
 511         {
 512                 AutoLocker lock(m_critSec);
 513                 m_mostRecentPath = path;
 514                 m_mostRecentExpiresAt = now + 1000;
 515         }
 516
 517         if (IsPathGood(path))
 518         {
 519                 // Stop the crawler starting on a new folder while we're doing this much more important task...
 520                 // Please note, that this may be a second "lock" used concurrently to the one in RemoveCacheForPath().
 521                 CCrawlInhibitor crawlInhibit(&m_folderCrawler);
 522
 523                 CTGitPath dirpath = path.GetContainingDirectory();
 524                 if ((dirpath.IsEmpty()) || (!m_shellCache.IsPathAllowed(dirpath.GetWinPath())))
 525                         dirpath = path.GetDirectory();
 526                 CCachedDirectory * cachedDir = GetDirectoryCacheEntry(dirpath);
 527                 if (cachedDir != NULL)
 528                 {
 529                         //ATLTRACE(_T("GetStatusForMember %d\n"), bFetch);
 530                         CStatusCacheEntry entry = cachedDir->GetStatusForMember(path, bRecursive, bFetch);
 531                         {
 532                                 AutoLocker lock(m_critSec);
 533                                 m_mostRecentStatus = entry;
 534                                 return m_mostRecentStatus;
 535                         }
 536                 }
 537         }
 538         else
 539         {
 540                 // path is blocked for some reason: return the cached status if we have one
 541                 // we do here only a cache search, absolutely no disk access is allowed!
 542                 CCachedDirectory::ItDir itMap = m_directoryCache.find(path.GetDirectory());
 543                 if ((itMap != m_directoryCache.end())&&(itMap->second))
 544                 {
 545                         if (path.IsDirectory())
 546                         {
 547                                 CStatusCacheEntry entry = itMap->second->GetOwnStatus(false);
 548                                 AutoLocker lock(m_critSec);
 549                                 m_mostRecentStatus = entry;
 550                                 return m_mostRecentStatus;
 551                         }
 552                         else
 553                         {
 554                                 // We've found this directory in the cache
 555                                 CCachedDirectory * cachedDir = itMap->second;
 556                                 CStatusCacheEntry entry = cachedDir->GetCacheStatusForMember(path);
 557                                 {
 558                                         AutoLocker lock(m_critSec);
 559                                         m_mostRecentStatus = entry;
 560                                         return m_mostRecentStatus;
 561                                 }
 562                         }
 563                 }
 564         }
 565         AutoLocker lock(m_critSec);
 566         ATLTRACE(_T("ignored no good path %s\n"), path.GetWinPath());
 567         m_mostRecentStatus = CStatusCacheEntry();
 568         if (m_shellCache.ShowExcludedAsNormal() && path.IsDirectory() && m_shellCache.HasGITAdminDir(path.GetWinPath(), true))
 569         {
 570                 ATLTRACE(_T("force status %s\n"), path.GetWinPath());
 571                 m_mostRecentStatus.ForceStatus(git_wc_status_normal);
 572         }
 573         return m_mostRecentStatus;
 574 }
 575
 576 void CGitStatusCache::AddFolderForCrawling(const CTGitPath& path)
 577 {
 578         m_folderCrawler.AddDirectoryForUpdate(path);
 579 }
 580
 581 void CGitStatusCache::CloseWatcherHandles(HDEVNOTIFY hdev)
 582 {
 583         CTGitPath path = watcher.CloseInfoMap(hdev);
 584         m_folderCrawler.BlockPath(path);
 585 }
 586
 587 void CGitStatusCache::CloseWatcherHandles(const CTGitPath& path)
 588 {
 589         watcher.CloseHandlesForPath(path);
 590         m_folderCrawler.BlockPath(path);
 591 }