src/TGitCache/SVNStatusCache.cpp

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