src/Git/GitFolderStatus.cpp

   1 // TortoiseSVN - a Windows shell extension for easy version control\r
   2 \r
   3 // Copyright (C) 2003-2008 - TortoiseSVN\r
   4 \r
   5 // This program is free software; you can redistribute it and/or\r
   6 // modify it under the terms of the GNU General Public License\r
   7 // as published by the Free Software Foundation; either version 2\r
   8 // of the License, or (at your option) any later version.\r
   9 \r
  10 // This program is distributed in the hope that it will be useful,\r
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13 // GNU General Public License for more details.\r
  14 \r
  15 // You should have received a copy of the GNU General Public License\r
  16 // along with this program; if not, write to the Free Software Foundation,\r
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\r
  18 \r
  19 #include "stdafx.h"\r
  20 #include "ShellExt.h"\r
  21 #include "GitFolderStatus.h"\r
  22 #include "UnicodeUtils.h"\r
  23 #include "..\TGitCache\CacheInterface.h"\r
  24 //#include "GitGlobal.h"\r
  25 \r
  26 extern ShellCache g_ShellCache;\r
  27 \r
  28 \r
  29 // get / auto-alloc a string "copy"\r
  30 \r
  31 const char* StringPool::GetString (const char* value)\r
  32 {\r
  33         // special case: NULL pointer\r
  34         \r
  35         if (value == NULL)\r
  36         {\r
  37                 return emptyString;\r
  38         }\r
  39 \r
  40         // do we already have a string with the desired value?\r
  41 \r
  42         pool_type::const_iterator iter = pool.find (value);\r
  43         if (iter != pool.end())\r
  44         {\r
  45                 // yes -> return it\r
  46                 return *iter;\r
  47         }\r
  48         \r
  49         // no -> add one        \r
  50         \r
  51         const char* newString =  _strdup (value);\r
  52         if (newString)\r
  53         {\r
  54                 pool.insert (newString);\r
  55         }\r
  56         else\r
  57                 return emptyString;\r
  58         \r
  59         // .. and return it\r
  60         \r
  61         return newString;\r
  62 }\r
  63 \r
  64 // clear internal pool\r
  65 \r
  66 void StringPool::clear()\r
  67 {\r
  68         // delete all strings\r
  69 \r
  70         for (pool_type::iterator iter = pool.begin(), end = pool.end(); iter != end; ++iter)\r
  71         {\r
  72                 free((void*)*iter);\r
  73         }\r
  74                 \r
  75         // remove pointers from pool\r
  76                 \r
  77         pool.clear();\r
  78 }\r
  79 \r
  80 CTGitPath       GitFolderStatus::folderpath;\r
  81 \r
  82 \r
  83 GitFolderStatus::GitFolderStatus(void)\r
  84 {\r
  85         m_TimeStamp = 0;\r
  86         emptyString[0] = 0;\r
  87         invalidstatus.author = emptyString;\r
  88         invalidstatus.askedcounter = -1;\r
  89         invalidstatus.status = git_wc_status_none;\r
  90         invalidstatus.url = emptyString;\r
  91 //      invalidstatus.rev = -1;\r
  92         invalidstatus.owner = emptyString;\r
  93         invalidstatus.needslock = false;\r
  94         invalidstatus.tree_conflict = false;\r
  95         m_nCounter = 0;\r
  96         dirstatus = NULL;\r
  97         sCacheKey.reserve(MAX_PATH);\r
  98 \r
  99         //rootpool = svn_pool_create (NULL);\r
 100 \r
 101         m_hInvalidationEvent = CreateEvent(NULL, FALSE, FALSE, _T("TortoiseGitCacheInvalidationEvent"));\r
 102 }\r
 103 \r
 104 GitFolderStatus::~GitFolderStatus(void)\r
 105 {\r
 106         //svn_pool_destroy(rootpool);\r
 107         CloseHandle(m_hInvalidationEvent);\r
 108 }\r
 109 \r
 110 const FileStatusCacheEntry * GitFolderStatus::BuildCache(const CTGitPath& filepath, const CString& sProjectRoot, BOOL bIsFolder, BOOL bDirectFolder)\r
 111 {\r
 112 //      svn_client_ctx_t *                      localctx;\r
 113 //      apr_hash_t *                            statushash;\r
 114 //      apr_pool_t *                            pool;\r
 115         //git_error_t *                         err = NULL; // If svn_client_status comes out through catch(...), err would else be unassigned\r
 116         BOOL err = FALSE;\r
 117 \r
 118         //dont' build the cache if an instance of TortoiseProc is running\r
 119         //since this could interfere with svn commands running (concurrent\r
 120         //access of the .git directory).\r
 121         if (g_ShellCache.BlockStatus())\r
 122         {\r
 123                 HANDLE TGitMutex = ::CreateMutex(NULL, FALSE, _T("TortoiseGitProc.exe"));       \r
 124                 if (TGitMutex != NULL)\r
 125                 {\r
 126                         if (::GetLastError() == ERROR_ALREADY_EXISTS)\r
 127                         {\r
 128                                 ::CloseHandle(TGitMutex);\r
 129                                 return &invalidstatus;\r
 130                         }\r
 131                 }\r
 132                 ::CloseHandle(TGitMutex);\r
 133         }\r
 134 \r
 135 //      pool = svn_pool_create (rootpool);                              // create the memory pool\r
 136 \r
 137         ClearCache();\r
 138 //      svn_error_clear(svn_client_create_context(&localctx, pool));\r
 139         // set up the configuration\r
 140         // Note: I know this is an 'expensive' call, but without this, ignores\r
 141         // done in the global ignore pattern won't show up.\r
 142         if (g_ShellCache.ShowIgnoredOverlay())\r
 143 ;//             svn_error_clear(svn_config_get_config (&(localctx->config), g_pConfigDir, pool));\r
 144 \r
 145         // strings pools are unused, now -> we may clear them\r
 146         \r
 147         authors.clear();\r
 148         urls.clear();\r
 149         owners.clear();\r
 150         \r
 151         ATLTRACE2(_T("building cache for %s\n"), filepath);\r
 152         if (bIsFolder)\r
 153         {\r
 154                 if (bDirectFolder)\r
 155                 {\r
 156                         // NOTE: see not in GetFullStatus about project inside another project, we should only get here when\r
 157                         //       that occurs, and this is not correctly handled yet\r
 158 \r
 159                         // initialize record members\r
 160 //                      dirstat.rev = -1;\r
 161                         dirstat.status = git_wc_status_none;\r
 162                         dirstat.author = authors.GetString(NULL);\r
 163                         dirstat.url = urls.GetString(NULL);\r
 164                         dirstat.owner = owners.GetString(NULL);\r
 165                         dirstat.askedcounter = GITFOLDERSTATUS_CACHETIMES;\r
 166                         dirstat.needslock = false;\r
 167                         dirstat.tree_conflict = false;\r
 168 \r
 169                         dirstatus = NULL;\r
 170 //                      statushash = apr_hash_make(pool);\r
 171 //                      git_revnum_t youngest = GIT_INVALID_REVNUM;\r
 172 //                      git_opt_revision_t rev;\r
 173 //                      rev.kind = git_opt_revision_unspecified;\r
 174                         try\r
 175                         {\r
 176                                 folderpath = filepath;\r
 177 \r
 178                                 /*err = svn_client_status4 (&youngest,\r
 179                                         filepath.GetDirectory().GetSVNApiPath(pool),\r
 180                                         &rev,\r
 181                                         findfolderstatus,\r
 182                                         this,\r
 183                                         svn_depth_empty,//depth\r
 184                                         TRUE,           //getall\r
 185                                         FALSE,          //update\r
 186                                         TRUE,           //noignore\r
 187                                         FALSE,          //ignore externals\r
 188                                         NULL,\r
 189                                         localctx,\r
 190                                         pool);*/\r
 191                         }\r
 192                         catch ( ... )\r
 193                         {\r
 194                                 dirstatus = NULL;\r
 195                         }\r
 196 \r
 197 \r
 198                         if (dirstatus)\r
 199                         {\r
 200 /*                              if (dirstatus->entry)\r
 201                                 {\r
 202                                         dirstat.author = authors.GetString (dirstatus->entry->cmt_author);\r
 203                                         dirstat.url = authors.GetString (dirstatus->entry->url);\r
 204                                         dirstat.rev = dirstatus->entry->cmt_rev;\r
 205                                         dirstat.owner = owners.GetString(dirstatus->entry->lock_owner);\r
 206                                 }*/\r
 207                                 dirstat.status = GitStatus::GetMoreImportant(dirstatus->text_status, dirstatus->prop_status);\r
 208 //                              dirstat.tree_conflict = dirstatus->tree_conflict != NULL;\r
 209                         }\r
 210                         m_cache[filepath.GetWinPath()] = dirstat;\r
 211                         m_TimeStamp = GetTickCount();\r
 212 //                      svn_error_clear(err);\r
 213 //                      svn_pool_destroy (pool);                                //free allocated memory\r
 214                         return &dirstat;\r
 215                 }\r
 216         } // if (bIsFolder) \r
 217         \r
 218         m_nCounter = 0;\r
 219         \r
 220         //Fill in the cache with\r
 221         //all files inside the same folder as the asked file/folder is\r
 222         //since subversion can do this in one step\r
 223 //      localctx->auth_baton = NULL;\r
 224 \r
 225 //      statushash = apr_hash_make(pool);\r
 226 //      git_revnum_t youngest = GIT_INVALID_REVNUM;\r
 227 //      git_opt_revision_t rev;\r
 228 //      rev.kind = git_opt_revision_unspecified;\r
 229         try\r
 230         {\r
 231                 // extract the sub-path (relative to project root)\r
 232 //MessageBox(NULL, filepath.GetDirectory().GetWinPathString(), sProjectRoot, MB_OK);\r
 233                 LPCSTR lpszSubPath = NULL;\r
 234                 CStringA sSubPath;\r
 235                 CString s = filepath.GetDirectory().GetWinPathString();\r
 236                 if (s.GetLength() > sProjectRoot.GetLength())\r
 237                 {\r
 238                         sSubPath = CStringA(s.Right(s.GetLength() - sProjectRoot.GetLength() - 1/*otherwise it gets initial slash*/));\r
 239                         lpszSubPath = sSubPath;\r
 240                 }\r
 241 \r
 242 //if (lpszSubPath) MessageBoxA(NULL, lpszSubPath, "BuildCache", MB_OK);\r
 243 //MessageBoxA(NULL, CStringA(sProjectRoot), sSubPath, MB_OK);\r
 244                 err = !wgEnumFiles(CStringA(sProjectRoot), lpszSubPath, WGEFF_NoRecurse|WGEFF_FullPath|WGEFF_DirStatusDelta, &fillstatusmap, this);\r
 245 \r
 246                 /*err = svn_client_status4 (&youngest,\r
 247                         filepath.GetDirectory().GetSVNApiPath(pool),\r
 248                         &rev,\r
 249                         fillstatusmap,\r
 250                         this,\r
 251                         svn_depth_immediates,           //depth\r
 252                         TRUE,           //getall\r
 253                         FALSE,          //update\r
 254                         TRUE,           //noignore\r
 255                         FALSE,          //ignore externals\r
 256                         NULL,\r
 257                         localctx,\r
 258                         pool);*/\r
 259         }\r
 260         catch ( ... )\r
 261         {\r
 262         }\r
 263 \r
 264         // Error present if function is not under version control\r
 265         if (err != NULL)\r
 266         {\r
 267 //              svn_error_clear(err);\r
 268 //              svn_pool_destroy (pool);                                //free allocated memory\r
 269                 return &invalidstatus;  \r
 270         }\r
 271 \r
 272 //      svn_error_clear(err);\r
 273 //      svn_pool_destroy (pool);                                //free allocated memory\r
 274         m_TimeStamp = GetTickCount();\r
 275         const FileStatusCacheEntry * ret = NULL;\r
 276         FileStatusMap::const_iterator iter;\r
 277         if ((iter = m_cache.find(filepath.GetWinPath())) != m_cache.end())\r
 278         {\r
 279                 ret = &iter->second;\r
 280                 m_mostRecentPath = filepath;\r
 281                 m_mostRecentStatus = ret;\r
 282         }\r
 283         else\r
 284         {\r
 285                 // for SUBST'ed drives, Subversion doesn't return a path with a backslash\r
 286                 // e.g. G:\ but only G: when fetching the status. So search for that\r
 287                 // path too before giving up.\r
 288                 // This is especially true when right-clicking directly on a SUBST'ed\r
 289                 // drive to get the context menu\r
 290                 if (_tcslen(filepath.GetWinPath())==3)\r
 291                 {\r
 292                         if ((iter = m_cache.find((LPCTSTR)filepath.GetWinPathString().Left(2))) != m_cache.end())\r
 293                         {\r
 294                                 ret = &iter->second;\r
 295                                 m_mostRecentPath = filepath;\r
 296                                 m_mostRecentStatus = ret;\r
 297                         }\r
 298                 }               \r
 299         }\r
 300         if (ret)\r
 301                 return ret;\r
 302         return &invalidstatus;\r
 303 }\r
 304 \r
 305 DWORD GitFolderStatus::GetTimeoutValue()\r
 306 {\r
 307         DWORD timeout = GITFOLDERSTATUS_CACHETIMEOUT;\r
 308         DWORD factor = m_cache.size()/200;\r
 309         if (factor==0)\r
 310                 factor = 1;\r
 311         return factor*timeout;\r
 312 }\r
 313 \r
 314 const FileStatusCacheEntry * GitFolderStatus::GetFullStatus(const CTGitPath& filepath, BOOL bIsFolder, BOOL bColumnProvider)\r
 315 {\r
 316         const FileStatusCacheEntry * ret = NULL;\r
 317 \r
 318         CString sProjectRoot;\r
 319         BOOL bHasAdminDir = g_ShellCache.HasSVNAdminDir(filepath.GetWinPath(), bIsFolder, &sProjectRoot);\r
 320         \r
 321         //no overlay for unversioned folders\r
 322         if ((!bColumnProvider)&&(!bHasAdminDir))\r
 323                 return &invalidstatus;\r
 324         //for the SVNStatus column, we have to check the cache to see\r
 325         //if it's not just unversioned but ignored\r
 326         ret = GetCachedItem(filepath);\r
 327         if ((ret)&&(ret->status == git_wc_status_unversioned)&&(bIsFolder)&&(bHasAdminDir))\r
 328         {\r
 329                 // an 'unversioned' folder, but with an ADMIN dir --> nested layout!\r
 330                 // NOTE: this could be a sub-project in git, or just some standalone project inside of another, either way a TODO\r
 331                 ret = BuildCache(filepath, sProjectRoot, bIsFolder, TRUE);\r
 332                 if (ret)\r
 333                         return ret;\r
 334                 else\r
 335                         return &invalidstatus;\r
 336         }\r
 337         if (ret)\r
 338                 return ret;\r
 339 \r
 340         //if it's not in the cache and has no admin dir, then we assume\r
 341         //it's not ignored too\r
 342         if ((bColumnProvider)&&(!bHasAdminDir))\r
 343                 return &invalidstatus;\r
 344         ret = BuildCache(filepath, sProjectRoot, bIsFolder);\r
 345         if (ret)\r
 346                 return ret;\r
 347         else\r
 348                 return &invalidstatus;\r
 349 }\r
 350 \r
 351 const FileStatusCacheEntry * GitFolderStatus::GetCachedItem(const CTGitPath& filepath)\r
 352 {\r
 353         sCacheKey.assign(filepath.GetWinPath());\r
 354         FileStatusMap::const_iterator iter;\r
 355         const FileStatusCacheEntry *retVal;\r
 356 \r
 357         if(m_mostRecentPath.IsEquivalentTo(CTGitPath(sCacheKey.c_str())))\r
 358         {\r
 359                 // We've hit the same result as we were asked for last time\r
 360                 ATLTRACE2(_T("fast cache hit for %s\n"), filepath);\r
 361                 retVal = m_mostRecentStatus;\r
 362         }\r
 363         else if ((iter = m_cache.find(sCacheKey)) != m_cache.end())\r
 364         {\r
 365                 ATLTRACE2(_T("cache found for %s\n"), filepath);\r
 366                 retVal = &iter->second;\r
 367                 m_mostRecentStatus = retVal;\r
 368                 m_mostRecentPath = CTGitPath(sCacheKey.c_str());\r
 369         }\r
 370         else\r
 371         {\r
 372                 retVal = NULL;\r
 373         }\r
 374 \r
 375         if(retVal != NULL)\r
 376         {\r
 377                 // We found something in a cache - check that the cache is not timed-out or force-invalidated\r
 378                 DWORD now = GetTickCount();\r
 379 \r
 380                 if ((now >= m_TimeStamp)&&((now - m_TimeStamp) > GetTimeoutValue()))\r
 381                 {\r
 382                         // Cache is timed-out\r
 383                         ATLTRACE("Cache timed-out\n");\r
 384                         ClearCache();\r
 385                         retVal = NULL;\r
 386                 }\r
 387                 else if(WaitForSingleObject(m_hInvalidationEvent, 0) == WAIT_OBJECT_0)\r
 388                 {\r
 389                         // TortoiseProc has just done something which has invalidated the cache\r
 390                         ATLTRACE("Cache invalidated\n");\r
 391                         ClearCache();\r
 392                         retVal = NULL;\r
 393                 }\r
 394                 return retVal;\r
 395         }\r
 396         return NULL;\r
 397 }\r
 398 \r
 399 BOOL GitFolderStatus::fillstatusmap(const struct wgFile_s *pFile, void *pUserData)\r
 400 {\r
 401         GitFolderStatus *Stat = (GitFolderStatus*)pUserData;\r
 402 \r
 403         FileStatusMap &cache = Stat->m_cache;\r
 404         FileStatusCacheEntry s;\r
 405         s.needslock = false;\r
 406         s.tree_conflict = false;\r
 407 \r
 408         s.author = Stat->authors.GetString(NULL);\r
 409         s.url = Stat->urls.GetString(NULL);\r
 410 //      s.rev = -1;\r
 411         s.owner = Stat->owners.GetString(NULL);\r
 412 \r
 413         s.status = git_wc_status_none;\r
 414 \r
 415         //s.status = GitStatus::GetMoreImportant(s.status, status->text_status);\r
 416         //s.status = GitStatus::GetMoreImportant(s.status, status->prop_status);\r
 417         s.status = GitStatusFromWingit(pFile->nStatus);\r
 418 \r
 419         // TODO ?: s.blaha = pFile->nStage\r
 420 \r
 421         //s.lock = status->repos_lock;\r
 422         //s.tree_conflict = (status->tree_conflict != NULL);\r
 423 \r
 424         s.askedcounter = GITFOLDERSTATUS_CACHETIMES;\r
 425         stdstring str;\r
 426         if (pFile->sFileName)\r
 427         {\r
 428                 str = CUnicodeUtils::StdGetUnicode(pFile->sFileName);\r
 429                 std::replace(str.begin(), str.end(), '/', '\\');\r
 430 //MessageBox(NULL, str.c_str(), _T(""), MB_OK);\r
 431         }\r
 432         else\r
 433                 str = _T(" ");\r
 434         cache[str] = s;\r
 435 \r
 436         return FALSE;\r
 437 }\r
 438 \r
 439 #if 0\r
 440 git_error_t* GitFolderStatus::fillstatusmap(void * baton, const char * path, git_wc_status2_t * status, apr_pool_t * /*pool*/)\r
 441 {\r
 442         GitFolderStatus * Stat = (GitFolderStatus *)baton;\r
 443         FileStatusMap * cache = &Stat->m_cache;\r
 444         FileStatusCacheEntry s;\r
 445         s.needslock = false;\r
 446         s.tree_conflict = false;\r
 447         if ((status)&&(status->entry))\r
 448         {\r
 449                 s.author = Stat->authors.GetString(status->entry->cmt_author);\r
 450                 s.url = Stat->urls.GetString(status->entry->url);\r
 451                 s.rev = status->entry->cmt_rev;\r
 452                 s.owner = Stat->owners.GetString(status->entry->lock_owner);\r
 453                 if (status->entry->present_props)\r
 454                         s.needslock = strstr(status->entry->present_props, "svn:needs-lock") ? true : false;\r
 455         }\r
 456         else\r
 457         {\r
 458                 s.author = Stat->authors.GetString(NULL);\r
 459                 s.url = Stat->urls.GetString(NULL);\r
 460                 s.rev = -1;\r
 461                 s.owner = Stat->owners.GetString(NULL);\r
 462         }\r
 463         s.status = git_wc_status_none;\r
 464         if (status)\r
 465         {\r
 466                 s.status = GitStatus::GetMoreImportant(s.status, status->text_status);\r
 467                 s.status = GitStatus::GetMoreImportant(s.status, status->prop_status);\r
 468                 s.lock = status->repos_lock;\r
 469                 s.tree_conflict = (status->tree_conflict != NULL);\r
 470         }\r
 471         s.askedcounter = GITFOLDERSTATUS_CACHETIMES;\r
 472         stdstring str;\r
 473         if (path)\r
 474         {\r
 475                 str = CUnicodeUtils::StdGetUnicode(path);\r
 476                 std::replace(str.begin(), str.end(), '/', '\\');\r
 477         }\r
 478         else\r
 479                 str = _T(" ");\r
 480         (*cache)[str] = s;\r
 481 \r
 482         return GIT_NO_ERROR;\r
 483 }\r
 484 \r
 485 git_error_t* GitFolderStatus::findfolderstatus(void * baton, const char * path, git_wc_status2_t * status, apr_pool_t * /*pool*/)\r
 486 {\r
 487         GitFolderStatus * Stat = (GitFolderStatus *)baton;\r
 488         if ((Stat)&&(Stat->folderpath.IsEquivalentTo(CTGitPath(CString(path)))))\r
 489         {\r
 490                 Stat->dirstatus = status;\r
 491         }\r
 492 \r
 493         return GIT_NO_ERROR;\r
 494 }\r
 495 #endif\r
 496 \r
 497 void GitFolderStatus::ClearCache()\r
 498 {\r
 499         m_cache.clear();\r
 500         m_mostRecentStatus = NULL;\r
 501         m_mostRecentPath.Reset();\r
 502         // If we're about to rebuild the cache, there's no point hanging on to \r
 503         // an event which tells us that it's invalid\r
 504         ResetEvent(m_hInvalidationEvent);\r
 505 }\r