src/TGitCache/CachedDirectory.cpp

   1 // TortoiseSVN - a Windows shell extension for easy version control
   2
   3 // External Cache Copyright (C) 2005-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 #include "StdAfx.h"
  20 #include ".\cacheddirectory.h"
  21 //#include "SVNHelpers.h"
  22 #include "GitStatusCache.h"
  23 #include "GitStatus.h"
  24 #include <set>
  25
  26 CCachedDirectory::CCachedDirectory(void)
  27 {
  28         m_currentStatusFetchingPathTicks = 0;
  29         m_bCurrentFullStatusValid = false;
  30         m_currentFullStatus = m_mostImportantFileStatus = git_wc_status_none;
  31         m_bRecursive = true;
  32         m_indexFileTime = 0;
  33         m_FullStatusFetched = false;
  34 }
  35
  36 CCachedDirectory::~CCachedDirectory(void)
  37 {
  38 }
  39
  40 CCachedDirectory::CCachedDirectory(const CTGitPath& directoryPath)
  41 {
  42         ATLASSERT(directoryPath.IsDirectory() || !PathFileExists(directoryPath.GetWinPath()));
  43
  44         m_directoryPath = directoryPath;
  45
  46         m_currentStatusFetchingPathTicks = 0;
  47         m_bCurrentFullStatusValid = false;
  48         m_currentFullStatus = m_mostImportantFileStatus = git_wc_status_none;
  49         m_bRecursive = true;
  50 }
  51
  52 BOOL CCachedDirectory::SaveToDisk(FILE * pFile)
  53 {
  54         AutoLocker lock(m_critSec);
  55 #define WRITEVALUETOFILE(x) if (fwrite(&x, sizeof(x), 1, pFile)!=1) return false;
  56
  57         unsigned int value = GIT_CACHE_VERSION;
  58         WRITEVALUETOFILE(value);        // 'version' of this save-format
  59         value = (int)m_entryCache.size();
  60         WRITEVALUETOFILE(value);        // size of the cache map
  61         // now iterate through the maps and save every entry.
  62         for (CacheEntryMap::iterator I = m_entryCache.begin(); I != m_entryCache.end(); ++I)
  63         {
  64                 const CString& key = I->first;
  65                 value = key.GetLength();
  66                 WRITEVALUETOFILE(value);
  67                 if (value)
  68                 {
  69                         if (fwrite((LPCTSTR)key, sizeof(TCHAR), value, pFile)!=value)
  70                                 return false;
  71                         if (!I->second.SaveToDisk(pFile))
  72                                 return false;
  73                 }
  74         }
  75         value = (int)m_childDirectories.size();
  76         WRITEVALUETOFILE(value);
  77         for (ChildDirStatus::iterator I = m_childDirectories.begin(); I != m_childDirectories.end(); ++I)
  78         {
  79                 const CString& path = I->first.GetWinPathString();
  80                 value = path.GetLength();
  81                 WRITEVALUETOFILE(value);
  82                 if (value)
  83                 {
  84                         if (fwrite((LPCTSTR)path, sizeof(TCHAR), value, pFile)!=value)
  85                                 return false;
  86                         git_wc_status_kind status = I->second;
  87                         WRITEVALUETOFILE(status);
  88                 }
  89         }
  90         WRITEVALUETOFILE(m_indexFileTime);
  91         WRITEVALUETOFILE(m_Head.m_hash);
  92 //      WRITEVALUETOFILE(m_propsFileTime);
  93         value = m_directoryPath.GetWinPathString().GetLength();
  94         WRITEVALUETOFILE(value);
  95         if (value)
  96         {
  97                 if (fwrite(m_directoryPath.GetWinPath(), sizeof(TCHAR), value, pFile)!=value)
  98                         return false;
  99         }
 100         if (!m_ownStatus.SaveToDisk(pFile))
 101                 return false;
 102         WRITEVALUETOFILE(m_currentFullStatus);
 103         WRITEVALUETOFILE(m_mostImportantFileStatus);
 104         return true;
 105 }
 106
 107 BOOL CCachedDirectory::LoadFromDisk(FILE * pFile)
 108 {
 109         AutoLocker lock(m_critSec);
 110 #define LOADVALUEFROMFILE(x) if (fread(&x, sizeof(x), 1, pFile)!=1) return false;
 111         try
 112         {
 113                 unsigned int value = 0;
 114                 LOADVALUEFROMFILE(value);
 115                 if (value != GIT_CACHE_VERSION)
 116                         return false;           // not the correct version
 117                 int mapsize = 0;
 118                 LOADVALUEFROMFILE(mapsize);
 119                 for (int i=0; i<mapsize; ++i)
 120                 {
 121                         LOADVALUEFROMFILE(value);
 122                         if (value > MAX_PATH)
 123                                 return false;
 124                         if (value)
 125                         {
 126                                 CString sKey;
 127                                 if (fread(sKey.GetBuffer(value+1), sizeof(TCHAR), value, pFile)!=value)
 128                                 {
 129                                         sKey.ReleaseBuffer(0);
 130                                         return false;
 131                                 }
 132                                 sKey.ReleaseBuffer(value);
 133                                 CStatusCacheEntry entry;
 134                                 if (!entry.LoadFromDisk(pFile))
 135                                         return false;
 136                                 m_entryCache[sKey] = entry;
 137                         }
 138                 }
 139                 LOADVALUEFROMFILE(mapsize);
 140                 for (int i=0; i<mapsize; ++i)
 141                 {
 142                         LOADVALUEFROMFILE(value);
 143                         if (value > MAX_PATH)
 144                                 return false;
 145                         if (value)
 146                         {
 147                                 CString sPath;
 148                                 if (fread(sPath.GetBuffer(value), sizeof(TCHAR), value, pFile)!=value)
 149                                 {
 150                                         sPath.ReleaseBuffer(0);
 151                                         return false;
 152                                 }
 153                                 sPath.ReleaseBuffer(value);
 154                                 git_wc_status_kind status;
 155                                 LOADVALUEFROMFILE(status);
 156                                 m_childDirectories[CTGitPath(sPath)] = status;
 157                         }
 158                 }
 159                 LOADVALUEFROMFILE(m_indexFileTime);
 160                 LOADVALUEFROMFILE(m_Head.m_hash);
 161 //              LOADVALUEFROMFILE(m_propsFileTime);
 162                 LOADVALUEFROMFILE(value);
 163                 if (value > MAX_PATH)
 164                         return false;
 165                 if (value)
 166                 {
 167                         CString sPath;
 168                         if (fread(sPath.GetBuffer(value+1), sizeof(TCHAR), value, pFile)!=value)
 169                         {
 170                                 sPath.ReleaseBuffer(0);
 171                                 return false;
 172                         }
 173                         sPath.ReleaseBuffer(value);
 174                         m_directoryPath.SetFromWin(sPath);
 175                 }
 176                 if (!m_ownStatus.LoadFromDisk(pFile))
 177                         return false;
 178
 179                 LOADVALUEFROMFILE(m_currentFullStatus);
 180                 LOADVALUEFROMFILE(m_mostImportantFileStatus);
 181         }
 182         catch ( CAtlException )
 183         {
 184                 return false;
 185         }
 186         return true;
 187
 188 }
 189 /// bFetch is true, fetch all status, call by crawl.
 190 /// bFetch is false, get cache status, return quickly.
 191
 192 CStatusCacheEntry CCachedDirectory::GetStatusForMember(const CTGitPath& path, bool bRecursive,  bool bFetch /* = true */)
 193 {
 194         CString strCacheKey;
 195         bool bThisDirectoryIsUnversioned = false;
 196         bool bRequestForSelf = false;
 197         if(path.IsEquivalentToWithoutCase(m_directoryPath))
 198         {
 199                 bRequestForSelf = true;
 200         }
 201 //OutputDebugStringA("GetStatusForMember: ");OutputDebugStringW(path.GetWinPathString());OutputDebugStringA("\r\n");
 202         // In all most circumstances, we ask for the status of a member of this directory.
 203         ATLASSERT(m_directoryPath.IsEquivalentToWithoutCase(path.GetContainingDirectory()) || bRequestForSelf);
 204
 205         CString sProjectRoot;
 206         const BOOL bIsVersionedPath = path.HasAdminDir(&sProjectRoot);
 207
 208         ATLTRACE(_T("%d GetStatusForMember for %s\n"),bFetch, path.GetWinPath());
 209
 210         //If is not version control path
 211         if( !bIsVersionedPath)
 212         {
 213                 ATLTRACE(_T("%s is not underversion control\n"), path.GetWinPath());
 214                 return CStatusCacheEntry();
 215         }
 216
 217         // We've not got this item in the cache - let's add it
 218         // We never bother asking SVN for the status of just one file, always for its containing directory
 219
 220         if (g_GitAdminDir.IsAdminDirPath(path.GetWinPathString()))
 221         {
 222                 // We're being asked for the status of an .git directory
 223                 // It's not worth asking for this
 224                 return CStatusCacheEntry();
 225         }
 226
 227         CString subpaths = path.GetGitPathString();
 228         if(subpaths.GetLength() >= sProjectRoot.GetLength())
 229         {
 230                 if(subpaths[sProjectRoot.GetLength()] == _T('/'))
 231                         subpaths=subpaths.Right(subpaths.GetLength() - sProjectRoot.GetLength()-1);
 232                 else
 233                         subpaths=subpaths.Right(subpaths.GetLength() - sProjectRoot.GetLength());
 234         }
 235
 236
 237         GitStatus *pGitStatus = &CGitStatusCache::Instance().m_GitStatus;
 238         bool IsIndexHeadChanged = pGitStatus->IsGitReposChanged(sProjectRoot, subpaths, GIT_MODE_INDEX);
 239
 240         CGitHash head;
 241
 242         pGitStatus->GetHeadHash(sProjectRoot,head);
 243
 244         bool isVersion =true;
 245         pGitStatus->IsUnderVersionControl(sProjectRoot, subpaths, path.IsDirectory(), &isVersion);
 246
 247 // Handle Untrack file and directory
 248 //===================================
 249         if(!isVersion)
 250         {
 251                 /* if path is not under version control */
 252                 /* Just need check if it is ignore, it is very quick */
 253                 bool isIgnoreFileChanged=false;
 254
 255                 isIgnoreFileChanged = pGitStatus->IsGitReposChanged(sProjectRoot, subpaths, GIT_MODE_IGNORE);
 256
 257                 if( isIgnoreFileChanged)
 258                 {
 259                         pGitStatus->LoadIgnoreFile(sProjectRoot, subpaths);
 260                 }
 261
 262                 std::vector<__int64> timelist;
 263                 pGitStatus->GetIgnoreFileChangeTimeList((CString &)this->m_directoryPath.GetWinPathString(), timelist);
 264
 265                 if(timelist.size() != this->m_IgnoreFileTimeList.size())
 266                         isIgnoreFileChanged =true;
 267
 268                 if(!isIgnoreFileChanged)
 269                         for(int i=0;i<timelist.size();i++)
 270                                 if(timelist[i] != m_IgnoreFileTimeList[i])
 271                                 {
 272                                         isIgnoreFileChanged =true;
 273                                         break;
 274                                 }
 275
 276                 m_IgnoreFileTimeList = timelist;
 277
 278                 if(isIgnoreFileChanged)
 279                         m_entryCache.clear();
 280
 281                 ATLTRACE(_T("Ignore Changed %d for %s\n"), isIgnoreFileChanged, path.GetWinPath());
 282
 283                 if(path.IsDirectory())
 284                 {
 285
 286                         CCachedDirectory * dirEntry = CGitStatusCache::Instance().GetDirectoryCacheEntry(path,
 287                                                                                         false); /* we needn't watch untracked directory*/
 288
 289                         if(dirEntry)
 290                         {
 291                                 AutoLocker lock(dirEntry->m_critSec);
 292
 293                                 git_wc_status_kind dirstatus = dirEntry->GetCurrentFullStatus() ;
 294                                 if( dirstatus == git_wc_status_none || dirstatus >= git_wc_status_normal || isIgnoreFileChanged )
 295                                 {/* status have not initialized*/
 296                                         git_wc_status2_t status2;
 297                                         bool isignore = false;
 298                                         pGitStatus->IsIgnore(sProjectRoot,subpaths,&isignore);
 299                                         status2.text_status = status2.prop_status =
 300                                                 (isignore? git_wc_status_ignored:git_wc_status_unversioned);
 301
 302                                         dirEntry->m_ownStatus.SetStatus(&status2);
 303
 304                                 }
 305                                 return dirEntry->m_ownStatus;
 306                         }
 307
 308                 }else /* path is file */
 309                 {
 310                         AutoLocker lock(m_critSec);
 311                         strCacheKey = GetCacheKey(path);
 312
 313                         CacheEntryMap::iterator itMap = m_entryCache.find(strCacheKey);
 314                         if(itMap == m_entryCache.end() || isIgnoreFileChanged)
 315                         {
 316                                 git_wc_status2_t status2;
 317                                 bool isignore = false;
 318                                 pGitStatus->IsIgnore(sProjectRoot,subpaths,&isignore);
 319                                 status2.text_status = status2.prop_status =
 320                                         (isignore? git_wc_status_ignored:git_wc_status_unversioned);
 321                                 AddEntry(path, &status2);
 322                                 return m_entryCache[strCacheKey];
 323                         }else
 324                         {
 325                                 return itMap->second;
 326                         }
 327                 }
 328                 return CStatusCacheEntry();
 329
 330         }
 331
 332 /// Handle track file and directory
 333 //==================================
 334         /* Get Status from git */
 335         if( (head == m_Head) && (m_indexFileTime==pGitStatus->GetIndexFileTime(sProjectRoot)))
 336         {
 337                 if(bFetch && !m_FullStatusFetched)
 338                 {
 339                         /* If crawl, fetch new updated status any way*/
 340                         EnumFiles();
 341                         m_FullStatusFetched = true;
 342                 }
 343
 344                 if(path.IsDirectory())
 345                 {
 346                         // We don't have directory status in our cache
 347                         // Ask the directory if it knows its own status
 348
 349                         CCachedDirectory * dirEntry = CGitStatusCache::Instance().GetDirectoryCacheEntry(path);
 350                         if( dirEntry)
 351                         {
 352                                 if (dirEntry->IsOwnStatusValid())
 353                                         return dirEntry->GetOwnStatus(bRecursive);
 354                                 else
 355                                 {
 356                                         /* cache have outof date, need crawl again*/
 357                                         AutoLocker lock(dirEntry->m_critSec);
 358                                         ChildDirStatus::const_iterator it;
 359                                         for(it = dirEntry->m_childDirectories.begin(); it != dirEntry->m_childDirectories.end(); ++it)
 360                                         {
 361                                                 CGitStatusCache::Instance().AddFolderForCrawling(it->first);
 362                                         }
 363                                 }
 364
 365                         }
 366                         if(bFetch)
 367                         {
 368                                 ATLTRACE(_T("Clear Dir %s mostImportantFileStatus\n"), path.GetWinPath());
 369                                 AutoLocker lock(m_critSec);
 370                                 m_mostImportantFileStatus = git_wc_status_normal; /* unverstion file have handle at begin */
 371                                 m_childDirectories.clear();
 372                                 m_entryCache.clear();
 373                                 m_ownStatus.SetStatus(NULL);
 374                                 m_bRecursive = bRecursive;
 375
 376                                 EnumFiles();
 377                                 m_FullStatusFetched = true;
 378                         }else
 379                         {
 380                                 CGitStatusCache::Instance().AddFolderForCrawling(path);
 381                         }
 382                         return CStatusCacheEntry(this->m_ownStatus);
 383                 }
 384                 else
 385                 {
 386                         // Get File status;
 387                         // because all untrack file have handle at first, only tracked file status got to here
 388                         git_wc_status_kind status = git_wc_status_normal;
 389                         {
 390                                 // if we currently are fetching the status of the directory
 391                                 // we want the status for, we just return an empty entry here
 392                                 // and don't wait for that fetching to finish.
 393                                 // That's because fetching the status can take a *really* long
 394                                 // time (e.g. if a commit is also in progress on that same
 395                                 // directory), and we don't want to make the explorer appear
 396                                 // to hang.
 397                                 AutoLocker pathlock(m_critSecPath);
 398                                 if ((!bFetch)&&(!m_currentStatusFetchingPath.IsEmpty()))
 399                                 {
 400                                         if ((m_currentStatusFetchingPath.IsAncestorOf(path))&&((m_currentStatusFetchingPathTicks + 1000)<GetTickCount()))
 401                                         {
 402                                                 ATLTRACE(_T("returning empty status (status fetch in progress) for %s\n"), path.GetWinPath());
 403                                                 m_currentFullStatus = m_mostImportantFileStatus = git_wc_status_normal;
 404                                                 return CStatusCacheEntry(git_wc_status_normal);
 405                                         }
 406                                 }
 407                         }
 408                         // Look up a file in our own cache
 409                         AutoLocker lock(m_critSec);
 410                         strCacheKey = GetCacheKey(path);
 411                         CacheEntryMap::iterator itMap = m_entryCache.find(strCacheKey);
 412                         if(itMap != m_entryCache.end())
 413                         {
 414                                 // We've hit the cache - check for timeout
 415                                 if(!itMap->second.HasExpired((long)GetTickCount()))
 416                                 {
 417                                         if(itMap->second.DoesFileTimeMatch(path.GetLastWriteTime()))
 418                                         {
 419                                                 if ((itMap->second.GetEffectiveStatus()!=git_wc_status_missing)||(!PathFileExists(path.GetWinPath())))
 420                                                 {
 421                                                         // Note: the filetime matches after a modified has been committed too.
 422                                                         // So in that case, we would return a wrong status (e.g. 'modified' instead
 423                                                         // of 'normal') here.
 424                                                         return itMap->second;
 425                                                 }
 426                                         }
 427                                 }
 428                         }
 429
 430                         if(bFetch)
 431                         {
 432                                 //update single full file status
 433                                 ATLTRACE(_T("Fetch file status %s\n"), path.GetWinPathString());
 434                                 pGitStatus->GetFileStatus(sProjectRoot, subpaths, &status, true, false,true, GetStatusCallback,this);
 435                         }else
 436                         {
 437                                 /* get status very quickly
 438                                    Full status may load Head Tree.
 439                                 */
 440                                 pGitStatus->GetFileStatus(sProjectRoot, subpaths, &status, false, false,true, NULL,NULL);
 441                                 CGitStatusCache::Instance().AddFolderForCrawling(path.GetContainingDirectory());
 442                                 m_FullStatusFetched = false;
 443                         }
 444                         return CStatusCacheEntry(status);
 445                 }
 446         }
 447         else /* Index or Head file changed*/
 448         {
 449                 /* Clear all cache status */
 450
 451                 AutoLocker pathlock(m_critSecPath);
 452                 if ((!bFetch)&&(!m_currentStatusFetchingPath.IsEmpty()))
 453                 {
 454                         if ((m_currentStatusFetchingPath.IsAncestorOf(path))&&((m_currentStatusFetchingPathTicks + 1000)<GetTickCount()))
 455                         {
 456                                 ATLTRACE(_T("returning empty status (status fetch in progress) for %s\n"), path.GetWinPath());
 457                                 m_currentFullStatus = m_mostImportantFileStatus = git_wc_status_normal;
 458                                 return CStatusCacheEntry(git_wc_status_normal);
 459                         }
 460                 }
 461
 462                 // if we're fetching the status for the explorer,
 463                 // we don't refresh the status but use the one
 464                 // we already have (to save time and make the explorer
 465                 // more responsive in stress conditions).
 466                 // We leave the refreshing to the crawler.
 467                 if ((!bFetch))
 468                 {
 469                         CGitStatusCache::Instance().AddFolderForCrawling(path.GetDirectory());
 470
 471                 }
 472
 473                 m_indexFileTime = pGitStatus->GetIndexFileTime(sProjectRoot);
 474                 m_Head = head;
 475                 m_FullStatusFetched  = false;
 476
 477                 AutoLocker lock(m_critSec);
 478 //              m_indexFileTime = indexFilePath.GetLastWriteTime();
 479 //              m_propsFileTime = propsDirPath.GetLastWriteTime();
 480                 m_entryCache.clear();
 481                 strCacheKey = GetCacheKey(path);
 482
 483                 git_wc_status2_t status2;
 484                 status2.prop_status = status2.text_status = git_wc_status_normal;
 485                 this->m_mostImportantFileStatus = this->m_currentFullStatus = git_wc_status_normal;
 486                 m_ownStatus.SetStatus(&status2);
 487
 488
 489         }
 490
 491 //  Cache status have been invalidate, head or index changed.
 492 // =====================================================
 493         {
 494                 {
 495                         AutoLocker pathlock(m_critSecPath);
 496                         if ((!bFetch)&&(!m_currentStatusFetchingPath.IsEmpty()))
 497                         {
 498                                 if ((m_currentStatusFetchingPath.IsAncestorOf(path))&&((m_currentStatusFetchingPathTicks + 1000)<GetTickCount()))
 499                                 {
 500                                         ATLTRACE(_T("returning empty status (status fetch in progress) for %s\n"), path.GetWinPath());
 501                                         m_currentFullStatus = m_mostImportantFileStatus = git_wc_status_normal;
 502                                         return CStatusCacheEntry(git_wc_status_normal);
 503                                 }
 504                         }
 505                 }
 506
 507
 508                 /* If bFetch false, means get basic status as soon as possible.
 509                            If bFetch false, means get full status from crawl thread
 510                            when bfetch false, just fetch status according to index file.
 511                            can't fetch HEAD tree. fetch HEAD tree will take some long time
 512                 */
 513                 BOOL pErr = EnumFiles(NULL, bFetch);
 514
 515                 {
 516                         AutoLocker pathlock(m_critSecPath);
 517                         m_currentStatusFetchingPath.Reset();
 518                 }
 519
 520                 ATLTRACE(_T("git_enum_files finished for '%s'\n"), m_directoryPath.GetWinPath(), path.GetWinPath());
 521
 522         }
 523         // Now that we've refreshed our SVN status, we can see if it's
 524         // changed the 'most important' status value for this directory.
 525         // If it has, then we should tell our parent
 526         if(bFetch)
 527                 UpdateCurrentStatus();
 528
 529         if (path.IsDirectory())
 530         {
 531                 CCachedDirectory * dirEntry = CGitStatusCache::Instance().GetDirectoryCacheEntry(path);
 532                 if ((dirEntry)&&(dirEntry->IsOwnStatusValid()))
 533                 {
 534                         /// status should be valid, needn't add to crawl.
 535                 //      CGitStatusCache::Instance().AddFolderForCrawling(path);
 536                         return dirEntry->GetOwnStatus(bRecursive);
 537                 }
 538
 539                 // If the status *still* isn't valid here, it means that
 540                 // the current directory is unversioned, and we shall need to ask its children for info about themselves
 541                 //if (dirEntry)
 542                 //      return dirEntry->GetStatusForMember(path,bRecursive);
 543
 544                 CGitStatusCache::Instance().AddFolderForCrawling(path);
 545                 return CStatusCacheEntry(git_wc_status_normal);;
 546         }
 547         else
 548         {
 549                 CacheEntryMap::iterator itMap = m_entryCache.find(strCacheKey);
 550                 if(itMap != m_entryCache.end())
 551                 {
 552                         return itMap->second;
 553                 }
 554         }
 555
 556         return CStatusCacheEntry(git_wc_status_normal);
 557 }
 558
 559 int CCachedDirectory::EnumFiles(CTGitPath *path , bool IsFull)
 560 {
 561         CString sProjectRoot;
 562         if(path)
 563                 path->HasAdminDir(&sProjectRoot);
 564         else
 565                 m_directoryPath.HasAdminDir(&sProjectRoot);
 566
 567         ATLASSERT( !m_directoryPath.IsEmpty() );
 568
 569         LPCTSTR lpszSubPath = NULL;
 570         CString sSubPath;
 571
 572         CString s;
 573         if(path)
 574                 s=path->GetWinPath();
 575         else
 576                 s=m_directoryPath.GetDirectory().GetWinPathString();
 577
 578         if (s.GetLength() > sProjectRoot.GetLength())
 579         {
 580                 // skip initial slash if necessary
 581                 if(s[sProjectRoot.GetLength()] == _T('\\'))
 582                         sSubPath = s.Right(s.GetLength() - sProjectRoot.GetLength() -1);
 583                 else
 584                         sSubPath = s.Right(s.GetLength() - sProjectRoot.GetLength() );
 585         }
 586
 587         GitStatus *pStatus = &CGitStatusCache::Instance().m_GitStatus;
 588         git_wc_status_kind status;
 589
 590         if(path)
 591                 pStatus->GetFileStatus(sProjectRoot, sSubPath, &status, IsFull, false,true, GetStatusCallback,this);
 592         else
 593                 pStatus->EnumDirStatus(sProjectRoot, sSubPath, &status, IsFull, false, true, GetStatusCallback,this);
 594
 595         m_mostImportantFileStatus = GitStatus::GetMoreImportant(m_mostImportantFileStatus, status);
 596
 597         return 0;
 598 }
 599 void
 600 CCachedDirectory::AddEntry(const CTGitPath& path, const git_wc_status2_t* pGitStatus, DWORD validuntil /* = 0*/)
 601 {
 602         AutoLocker lock(m_critSec);
 603         if(path.IsDirectory())
 604         {
 605                 CCachedDirectory * childDir = CGitStatusCache::Instance().GetDirectoryCacheEntry(path);
 606                 if (childDir)
 607                 {
 608                         if ((childDir->GetCurrentFullStatus() != git_wc_status_missing)||(pGitStatus==NULL)||(pGitStatus->text_status != git_wc_status_unversioned))
 609                         {
 610                                 if(pGitStatus)
 611                                 {
 612                                         if(childDir->GetCurrentFullStatus() != GitStatus::GetMoreImportant(pGitStatus->prop_status, pGitStatus->text_status))
 613                                         {
 614                                                 CGitStatusCache::Instance().UpdateShell(path);
 615                                                 ATLTRACE(_T("shell update for %s\n"), path.GetWinPath());
 616                                         }
 617                                 }
 618                                 childDir->m_ownStatus.SetStatus(pGitStatus);
 619                         }
 620                         childDir->m_ownStatus.SetKind(git_node_dir);
 621
 622
 623                 }
 624         }
 625         else
 626         {
 627                 if(!(this->m_directoryPath == path.GetContainingDirectory()))
 628                 {
 629                         ATLTRACE(_T("parent path miss\n"));
 630                 }
 631                 CString cachekey = GetCacheKey(path);
 632                 CacheEntryMap::iterator entry_it = m_entryCache.lower_bound(cachekey);
 633                 if (entry_it != m_entryCache.end() && entry_it->first == cachekey)
 634                 {
 635                         if (pGitStatus)
 636                         {
 637                                 if (entry_it->second.GetEffectiveStatus() > git_wc_status_none &&
 638                                         entry_it->second.GetEffectiveStatus() != GitStatus::GetMoreImportant(pGitStatus->prop_status, pGitStatus->text_status))
 639                                 {
 640                                         CGitStatusCache::Instance().UpdateShell(path);
 641                                         ATLTRACE(_T("shell update for %s\n"), path.GetWinPath());
 642                                 }
 643                         }
 644                 }
 645                 else
 646                 {
 647                         entry_it = m_entryCache.insert(entry_it, std::make_pair(cachekey, CStatusCacheEntry()));
 648                 }
 649                 entry_it->second = CStatusCacheEntry(pGitStatus, path.GetLastWriteTime(), path.IsReadOnly(), validuntil);
 650                 // TEMP(?): git status doesn't not have "entry" that contains node type, so manually set as file
 651                 entry_it->second.SetKind(git_node_file);
 652
 653                 ATLTRACE(_T("Path Entry Add %s %s %s %d\n"), path.GetWinPath(), cachekey, m_directoryPath.GetWinPath(), pGitStatus->text_status);
 654         }
 655 }
 656
 657
 658 CString
 659 CCachedDirectory::GetCacheKey(const CTGitPath& path)
 660 {
 661         // All we put into the cache as a key is just the end portion of the pathname
 662         // There's no point storing the path of the containing directory for every item
 663         return path.GetWinPathString().Mid(m_directoryPath.GetWinPathString().GetLength());
 664 }
 665
 666 CString
 667 CCachedDirectory::GetFullPathString(const CString& cacheKey)
 668 {
 669         return m_directoryPath.GetWinPathString() + _T("\\") + cacheKey;
 670 }
 671
 672 BOOL CCachedDirectory::GetStatusCallback(CString & path, git_wc_status_kind status,bool isDir, void *pUserData)
 673 {
 674         CCachedDirectory* pThis = (CCachedDirectory*)pUserData;
 675
 676         git_wc_status2_t _status;
 677         git_wc_status2_t *status2 = &_status;
 678
 679         status2->prop_status = status2->text_status = status;
 680
 681         CTGitPath gitPath;
 682
 683
 684 //      if(status->entry)
 685         {
 686                 //if ((status->text_status != git_wc_status_none)&&(status->text_status != git_wc_status_missing))
 687                 gitPath.SetFromUnknown(path);
 688                 //status.SetFromGit(path, pFile->nFlags & WGFF_Directory);
 689                 /*else
 690                         svnPath.SetFromGit(path);*/
 691
 692                 if (isDir)
 693                 {       /*gitpath is directory*/
 694                         if ( !gitPath.IsEquivalentToWithoutCase(pThis->m_directoryPath) )
 695                         {
 696                                 if (!gitPath.Exists())
 697                                 {
 698                                         ATLTRACE(_T("Miss dir %s \n"), gitPath.GetWinPath());
 699                                         pThis->m_mostImportantFileStatus = GitStatus::GetMoreImportant(pThis->m_mostImportantFileStatus, git_wc_status_deleted);
 700                                 }
 701
 702                                 if (pThis->m_bRecursive)
 703                                 {
 704                                         // Add any versioned directory, which is not our 'self' entry, to the list for having its status updated
 705 //OutputDebugStringA("AddFolderCrawl: ");OutputDebugStringW(svnPath.GetWinPathString());OutputDebugStringA("\r\n");
 706                                         if(status >= git_wc_status_normal)
 707                                                 if(status != git_wc_status_missing)
 708                                                         if(status != git_wc_status_deleted)
 709                                                                 CGitStatusCache::Instance().AddFolderForCrawling(gitPath);
 710                                 }
 711
 712                                 // Make sure we know about this child directory
 713                                 // This initial status value is likely to be overwritten from below at some point
 714                                 git_wc_status_kind s = GitStatus::GetMoreImportant(status2->text_status, status2->prop_status);
 715                                 CCachedDirectory * cdir = CGitStatusCache::Instance().GetDirectoryCacheEntryNoCreate(gitPath);
 716                                 if (cdir)
 717                                 {
 718                                         // This child directory is already in our cache!
 719                                         // So ask this dir about its recursive status
 720                                         git_wc_status_kind st = GitStatus::GetMoreImportant(s, cdir->GetCurrentFullStatus());
 721                                         AutoLocker lock(pThis->m_critSec);
 722                                         pThis->m_childDirectories[gitPath] = st;
 723                                         ATLTRACE(_T("call 1 Update dir %s %d\n"), gitPath.GetWinPath(), st);
 724                                 }
 725                                 else
 726                                 {
 727                                         AutoLocker lock(pThis->m_critSec);
 728                                         // the child directory is not in the cache. Create a new entry for it in the cache which is
 729                                         // initially 'unversioned'. But we added that directory to the crawling list above, which
 730                                         // means the cache will be updated soon.
 731                                         CGitStatusCache::Instance().GetDirectoryCacheEntry(gitPath);
 732
 733                                         pThis->m_childDirectories[gitPath] = s;
 734                                         ATLTRACE(_T("call 2 Update dir %s %d\n"), gitPath.GetWinPath(), s);
 735                                 }
 736                         }
 737                 }
 738                 else /* gitpath is file*/
 739                 {
 740                         // Keep track of the most important status of all the files in this directory
 741                         // Don't include subdirectories in this figure, because they need to provide their
 742                         // own 'most important' value
 743                         pThis->m_mostImportantFileStatus = GitStatus::GetMoreImportant(pThis->m_mostImportantFileStatus, status2->text_status);
 744                         pThis->m_mostImportantFileStatus = GitStatus::GetMoreImportant(pThis->m_mostImportantFileStatus, status2->prop_status);
 745                         if (((status2->text_status == git_wc_status_unversioned)||(status2->text_status == git_wc_status_none))
 746                                 &&(CGitStatusCache::Instance().IsUnversionedAsModified()))
 747                         {
 748                                 // treat unversioned files as modified
 749                                 if (pThis->m_mostImportantFileStatus != git_wc_status_added)
 750                                         pThis->m_mostImportantFileStatus = GitStatus::GetMoreImportant(pThis->m_mostImportantFileStatus, git_wc_status_modified);
 751                         }
 752                 }
 753         }
 754
 755         pThis->AddEntry(gitPath, status2);
 756
 757         return FALSE;
 758 }
 759
 760 #if 0
 761 git_error_t * CCachedDirectory::GetStatusCallback(void *baton, const char *path, git_wc_status2_t *status)
 762 {
 763         CCachedDirectory* pThis = (CCachedDirectory*)baton;
 764
 765         if (path == NULL)
 766                 return 0;
 767
 768         CTGitPath svnPath;
 769
 770         if(status->entry)
 771         {
 772                 if ((status->text_status != git_wc_status_none)&&(status->text_status != git_wc_status_missing))
 773                         svnPath.SetFromSVN(path, (status->entry->kind == svn_node_dir));
 774                 else
 775                         svnPath.SetFromSVN(path);
 776
 777                 if(svnPath.IsDirectory())
 778                 {
 779                         if(!svnPath.IsEquivalentToWithoutCase(pThis->m_directoryPath))
 780                         {
 781                                 if (pThis->m_bRecursive)
 782                                 {
 783                                         // Add any versioned directory, which is not our 'self' entry, to the list for having its status updated
 784                                         CGitStatusCache::Instance().AddFolderForCrawling(svnPath);
 785                                 }
 786
 787                                 // Make sure we know about this child directory
 788                                 // This initial status value is likely to be overwritten from below at some point
 789                                 git_wc_status_kind s = GitStatus::GetMoreImportant(status->text_status, status->prop_status);
 790                                 CCachedDirectory * cdir = CGitStatusCache::Instance().GetDirectoryCacheEntryNoCreate(svnPath);
 791                                 if (cdir)
 792                                 {
 793                                         // This child directory is already in our cache!
 794                                         // So ask this dir about its recursive status
 795                                         git_wc_status_kind st = GitStatus::GetMoreImportant(s, cdir->GetCurrentFullStatus());
 796                                         AutoLocker lock(pThis->m_critSec);
 797                                         pThis->m_childDirectories[svnPath] = st;
 798                                 }
 799                                 else
 800                                 {
 801                                         // the child directory is not in the cache. Create a new entry for it in the cache which is
 802                                         // initially 'unversioned'. But we added that directory to the crawling list above, which
 803                                         // means the cache will be updated soon.
 804                                         CGitStatusCache::Instance().GetDirectoryCacheEntry(svnPath);
 805                                         AutoLocker lock(pThis->m_critSec);
 806                                         pThis->m_childDirectories[svnPath] = s;
 807                                 }
 808                         }
 809                 }
 810                 else
 811                 {
 812                         // Keep track of the most important status of all the files in this directory
 813                         // Don't include subdirectories in this figure, because they need to provide their
 814                         // own 'most important' value
 815                         pThis->m_mostImportantFileStatus = GitStatus::GetMoreImportant(pThis->m_mostImportantFileStatus, status->text_status);
 816                         pThis->m_mostImportantFileStatus = GitStatus::GetMoreImportant(pThis->m_mostImportantFileStatus, status->prop_status);
 817                         if (((status->text_status == git_wc_status_unversioned)||(status->text_status == git_wc_status_none))
 818                                 &&(CGitStatusCache::Instance().IsUnversionedAsModified()))
 819                         {
 820                                 // treat unversioned files as modified
 821                                 if (pThis->m_mostImportantFileStatus != git_wc_status_added)
 822                                         pThis->m_mostImportantFileStatus = GitStatus::GetMoreImportant(pThis->m_mostImportantFileStatus, git_wc_status_modified);
 823                         }
 824                 }
 825         }
 826         else
 827         {
 828                 svnPath.SetFromSVN(path);
 829                 // Subversion returns no 'entry' field for versioned folders if they're
 830                 // part of another working copy (nested layouts).
 831                 // So we have to make sure that such an 'unversioned' folder really
 832                 // is unversioned.
 833                 if (((status->text_status == git_wc_status_unversioned)||(status->text_status == git_wc_status_missing))&&(!svnPath.IsEquivalentToWithoutCase(pThis->m_directoryPath))&&(svnPath.IsDirectory()))
 834                 {
 835                         if (svnPath.HasAdminDir())
 836                         {
 837                                 CGitStatusCache::Instance().AddFolderForCrawling(svnPath);
 838                                 // Mark the directory as 'versioned' (status 'normal' for now).
 839                                 // This initial value will be overwritten from below some time later
 840                                 {
 841                                         AutoLocker lock(pThis->m_critSec);
 842                                         pThis->m_childDirectories[svnPath] = git_wc_status_normal;
 843                                 }
 844                                 // Make sure the entry is also in the cache
 845                                 CGitStatusCache::Instance().GetDirectoryCacheEntry(svnPath);
 846                                 // also mark the status in the status object as normal
 847                                 status->text_status = git_wc_status_normal;
 848                         }
 849                 }
 850                 else if (status->text_status == git_wc_status_external)
 851                 {
 852                         CGitStatusCache::Instance().AddFolderForCrawling(svnPath);
 853                         // Mark the directory as 'versioned' (status 'normal' for now).
 854                         // This initial value will be overwritten from below some time later
 855                         {
 856                                 AutoLocker lock(pThis->m_critSec);
 857                                 pThis->m_childDirectories[svnPath] = git_wc_status_normal;
 858                         }
 859                         // we have added a directory to the child-directory list of this
 860                         // directory. We now must make sure that this directory also has
 861                         // an entry in the cache.
 862                         CGitStatusCache::Instance().GetDirectoryCacheEntry(svnPath);
 863                         // also mark the status in the status object as normal
 864                         status->text_status = git_wc_status_normal;
 865                 }
 866                 else
 867                 {
 868                         if (svnPath.IsDirectory())
 869                         {
 870                                 AutoLocker lock(pThis->m_critSec);
 871                                 pThis->m_childDirectories[svnPath] = GitStatus::GetMoreImportant(status->text_status, status->prop_status);
 872                         }
 873                         else if ((CGitStatusCache::Instance().IsUnversionedAsModified())&&(status->text_status != git_wc_status_missing))
 874                         {
 875                                 // make this unversioned item change the most important status of this
 876                                 // folder to modified if it doesn't already have another status
 877                                 if (pThis->m_mostImportantFileStatus != git_wc_status_added)
 878                                         pThis->m_mostImportantFileStatus = GitStatus::GetMoreImportant(pThis->m_mostImportantFileStatus, git_wc_status_modified);
 879                         }
 880                 }
 881         }
 882
 883         pThis->AddEntry(svnPath, status);
 884
 885         return 0;
 886 }
 887 #endif
 888
 889 bool
 890 CCachedDirectory::IsOwnStatusValid() const
 891 {
 892         return m_ownStatus.HasBeenSet() &&
 893                    !m_ownStatus.HasExpired(GetTickCount()) &&
 894                    // 'external' isn't a valid status. That just
 895                    // means the folder is not part of the current working
 896                    // copy but it still has its own 'real' status
 897                    m_ownStatus.GetEffectiveStatus()!=git_wc_status_external &&
 898                    m_ownStatus.IsKindKnown();
 899 }
 900
 901 void CCachedDirectory::Invalidate()
 902 {
 903         m_ownStatus.Invalidate();
 904 }
 905
 906 git_wc_status_kind CCachedDirectory::CalculateRecursiveStatus()
 907 {
 908         // Combine our OWN folder status with the most important of our *FILES'* status.
 909         git_wc_status_kind retVal = GitStatus::GetMoreImportant(m_mostImportantFileStatus, m_ownStatus.GetEffectiveStatus());
 910
 911         // NOTE: TSVN marks dir as modified if it contains added/deleted/missing files, but we prefer the most important
 912         //       status to propagate upward in its original state
 913         /*if ((retVal != git_wc_status_modified)&&(retVal != m_ownStatus.GetEffectiveStatus()))
 914         {
 915                 if ((retVal == git_wc_status_added)||(retVal == git_wc_status_deleted)||(retVal == git_wc_status_missing))
 916                         retVal = git_wc_status_modified;
 917         }*/
 918
 919         // Now combine all our child-directorie's status
 920
 921         AutoLocker lock(m_critSec);
 922         ChildDirStatus::const_iterator it;
 923         for(it = m_childDirectories.begin(); it != m_childDirectories.end(); ++it)
 924         {
 925                 retVal = GitStatus::GetMoreImportant(retVal, it->second);
 926                 /*if ((retVal != git_wc_status_modified)&&(retVal != m_ownStatus.GetEffectiveStatus()))
 927                 {
 928                         if ((retVal == git_wc_status_added)||(retVal == git_wc_status_deleted)||(retVal == git_wc_status_missing))
 929                                 retVal = git_wc_status_modified;
 930                 }*/
 931         }
 932
 933         return retVal;
 934 }
 935
 936 // Update our composite status and deal with things if it's changed
 937 void CCachedDirectory::UpdateCurrentStatus()
 938 {
 939         git_wc_status_kind newStatus = CalculateRecursiveStatus();
 940         ATLTRACE(_T("UpdateCurrentStatus %s new:%d old: %d\n"),
 941                 m_directoryPath.GetWinPath(),
 942                 newStatus, m_currentFullStatus);
 943         if ((newStatus != m_currentFullStatus)&&(m_ownStatus.IsVersioned()))
 944         {
 945                 if ((m_currentFullStatus != git_wc_status_none)&&(m_ownStatus.GetEffectiveStatus() != git_wc_status_missing))
 946                 {
 947                         // Our status has changed - tell the shell
 948                         ATLTRACE(_T("Dir %s, status change from %d to %d, send shell notification\n"), m_directoryPath.GetWinPath(), m_currentFullStatus, newStatus);
 949                         CGitStatusCache::Instance().UpdateShell(m_directoryPath);
 950                 }
 951                 if (m_ownStatus.GetEffectiveStatus() != git_wc_status_missing)
 952                         m_currentFullStatus = newStatus;
 953                 else
 954                         m_currentFullStatus = git_wc_status_missing;
 955         }
 956         // And tell our parent, if we've got one...
 957         // we tell our parent *always* about our status, even if it hasn't
 958         // changed. This is to make sure that the parent has really our current
 959         // status - the parent can decide itself if our status has changed
 960         // or not.
 961         CTGitPath parentPath = m_directoryPath.GetContainingDirectory();
 962         if(!parentPath.IsEmpty())
 963         {
 964                 // We have a parent
 965                 // just version controled directory need to cache.
 966                 if(parentPath.HasAdminDir())
 967                 {
 968                         CCachedDirectory * cachedDir = CGitStatusCache::Instance().GetDirectoryCacheEntry(parentPath);
 969                         if (cachedDir)
 970                                 cachedDir->UpdateChildDirectoryStatus(m_directoryPath, m_currentFullStatus);
 971                 }
 972         }
 973 }
 974
 975
 976 // Receive a notification from a child that its status has changed
 977 void CCachedDirectory::UpdateChildDirectoryStatus(const CTGitPath& childDir, git_wc_status_kind childStatus)
 978 {
 979         git_wc_status_kind currentStatus = git_wc_status_none;
 980         {
 981                 AutoLocker lock(m_critSec);
 982                 currentStatus = m_childDirectories[childDir];
 983         }
 984         if ((currentStatus != childStatus)||(!IsOwnStatusValid()))
 985         {
 986                 {
 987                         AutoLocker lock(m_critSec);
 988                         m_childDirectories[childDir] = childStatus;
 989                 }
 990                 UpdateCurrentStatus();
 991         }
 992 }
 993
 994 CStatusCacheEntry CCachedDirectory::GetOwnStatus(bool bRecursive)
 995 {
 996         // Don't return recursive status if we're unversioned ourselves.
 997         if(bRecursive && m_ownStatus.GetEffectiveStatus() > git_wc_status_unversioned)
 998         {
 999                 CStatusCacheEntry recursiveStatus(m_ownStatus);
1000                 UpdateCurrentStatus();
1001                 recursiveStatus.ForceStatus(m_currentFullStatus);
1002                 return recursiveStatus;
1003         }
1004         else
1005         {
1006                 return m_ownStatus;
1007         }
1008 }
1009
1010 void CCachedDirectory::RefreshStatus(bool bRecursive)
1011 {
1012         // Make sure that our own status is up-to-date
1013         GetStatusForMember(m_directoryPath,bRecursive);
1014
1015         AutoLocker lock(m_critSec);
1016         // We also need to check if all our file members have the right date on them
1017         CacheEntryMap::iterator itMembers;
1018         std::set<CTGitPath> refreshedpaths;
1019         DWORD now = GetTickCount();
1020         if (m_entryCache.size() == 0)
1021                 return;
1022         for (itMembers = m_entryCache.begin(); itMembers != m_entryCache.end(); ++itMembers)
1023         {
1024                 if (itMembers->first)
1025                 {
1026                         CTGitPath filePath(m_directoryPath);
1027                         filePath.AppendPathString(itMembers->first);
1028                         std::set<CTGitPath>::iterator refr_it;
1029                         if ((!filePath.IsEquivalentToWithoutCase(m_directoryPath))&&
1030                                 (((refr_it = refreshedpaths.lower_bound(filePath)) == refreshedpaths.end()) || !filePath.IsEquivalentToWithoutCase(*refr_it)))
1031                         {
1032                                 if ((itMembers->second.HasExpired(now))||(!itMembers->second.DoesFileTimeMatch(filePath.GetLastWriteTime())))
1033                                 {
1034                                         lock.Unlock();
1035                                         // We need to request this item as well
1036                                         GetStatusForMember(filePath,bRecursive);
1037                                         // GetStatusForMember now has recreated the m_entryCache map.
1038                                         // So start the loop again, but add this path to the refreshed paths set
1039                                         // to make sure we don't refresh this path again. This is to make sure
1040                                         // that we don't end up in an endless loop.
1041                                         lock.Lock();
1042                                         refreshedpaths.insert(refr_it, filePath);
1043                                         itMembers = m_entryCache.begin();
1044                                         if (m_entryCache.size()==0)
1045                                                 return;
1046                                         continue;
1047                                 }
1048                                 else if ((bRecursive)&&(itMembers->second.IsDirectory()))
1049                                 {
1050                                         // crawl all sub folders too! Otherwise a change deep inside the
1051                                         // tree which has changed won't get propagated up the tree.
1052                                         CGitStatusCache::Instance().AddFolderForCrawling(filePath);
1053                                 }
1054                         }
1055                 }
1056         }
1057 }
1058
1059 void CCachedDirectory::RefreshMostImportant()
1060 {
1061         CacheEntryMap::iterator itMembers;
1062         git_wc_status_kind newStatus = m_ownStatus.GetEffectiveStatus();
1063         for (itMembers = m_entryCache.begin(); itMembers != m_entryCache.end(); ++itMembers)
1064         {
1065                 newStatus = GitStatus::GetMoreImportant(newStatus, itMembers->second.GetEffectiveStatus());
1066                 if (((itMembers->second.GetEffectiveStatus() == git_wc_status_unversioned)||(itMembers->second.GetEffectiveStatus() == git_wc_status_none))
1067                         &&(CGitStatusCache::Instance().IsUnversionedAsModified()))
1068                 {
1069                         // treat unversioned files as modified
1070                         if (newStatus != git_wc_status_added)
1071                                 newStatus = GitStatus::GetMoreImportant(newStatus, git_wc_status_modified);
1072                 }
1073         }
1074         if (newStatus != m_mostImportantFileStatus)
1075         {
1076                 ATLTRACE(_T("status change of path %s\n"), m_directoryPath.GetWinPath());
1077                 CGitStatusCache::Instance().UpdateShell(m_directoryPath);
1078         }
1079         m_mostImportantFileStatus = newStatus;
1080 }