src/Git/GitFolderStatus.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2008,2011 - TortoiseSVN
   4 // Copyright (C) 2008-2012 - TortoiseGit
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19
  20 #include "stdafx.h"
  21 #include "ShellExt.h"
  22 #include "GitFolderStatus.h"
  23 #include "UnicodeUtils.h"
  24 #include "..\TGitCache\CacheInterface.h"
  25 #include "Git.h"
  26 #include "gitindex.h"
  27
  28 extern ShellCache g_ShellCache;
  29
  30 //extern CGitIndexFileMap g_IndexFileMap;
  31
  32 // get / auto-alloc a string "copy"
  33
  34 const char* StringPool::GetString (const char* value)
  35 {
  36         // special case: NULL pointer
  37
  38         if (value == NULL)
  39         {
  40                 return emptyString;
  41         }
  42
  43         // do we already have a string with the desired value?
  44
  45         pool_type::const_iterator iter = pool.find (value);
  46         if (iter != pool.end())
  47         {
  48                 // yes -> return it
  49                 return *iter;
  50         }
  51
  52         // no -> add one
  53
  54         const char* newString =  _strdup (value);
  55         if (newString)
  56         {
  57                 pool.insert (newString);
  58         }
  59         else
  60                 return emptyString;
  61
  62         // .. and return it
  63
  64         return newString;
  65 }
  66
  67 // clear internal pool
  68
  69 void StringPool::clear()
  70 {
  71         // delete all strings
  72
  73         for (pool_type::iterator iter = pool.begin(), end = pool.end(); iter != end; ++iter)
  74         {
  75                 free((void*)*iter);
  76         }
  77
  78         // remove pointers from pool
  79
  80         pool.clear();
  81 }
  82
  83 GitFolderStatus::GitFolderStatus(void)
  84 {
  85         m_TimeStamp = 0;
  86         emptyString[0] = 0;
  87         invalidstatus.author = emptyString;
  88         invalidstatus.askedcounter = -1;
  89         invalidstatus.status = git_wc_status_none;
  90         invalidstatus.url = emptyString;
  91         invalidstatus.assumeValid = FALSE;
  92         invalidstatus.skipWorktree = FALSE;
  93 //      invalidstatus.rev = -1;
  94         m_nCounter = 0;
  95         dirstatus = NULL;
  96         sCacheKey.reserve(MAX_PATH);
  97
  98         g_Git.SetCurrentDir(_T(""));
  99         m_hInvalidationEvent = CreateEvent(NULL, FALSE, FALSE, _T("TortoiseGitCacheInvalidationEvent"));
 100 }
 101
 102 GitFolderStatus::~GitFolderStatus(void)
 103 {
 104 }
 105
 106 const FileStatusCacheEntry * GitFolderStatus::BuildCache(const CTGitPath& filepath, const CString& /*sProjectRoot*/, BOOL bIsFolder, BOOL bDirectFolder)
 107 {
 108         //dont' build the cache if an instance of TortoiseProc is running
 109         //since this could interfere with svn commands running (concurrent
 110         //access of the .git directory).
 111         if (g_ShellCache.BlockStatus())
 112         {
 113                 CAutoGeneralHandle TGitMutex = ::CreateMutex(NULL, FALSE, _T("TortoiseGitProc.exe"));
 114                 if (TGitMutex != NULL)
 115                 {
 116                         if (::GetLastError() == ERROR_ALREADY_EXISTS)
 117                         {
 118                                 return &invalidstatus;
 119                         }
 120                 }
 121         }
 122
 123         ClearCache();
 124         authors.clear();
 125         urls.clear();
 126
 127         if (bIsFolder)
 128         {
 129                 if (bDirectFolder)
 130                 {
 131                         // NOTE: see not in GetFullStatus about project inside another project, we should only get here when
 132                         //       that occurs, and this is not correctly handled yet
 133
 134                         // initialize record members
 135 //                      dirstat.rev = -1;
 136                         dirstat.status = git_wc_status_none;
 137                         dirstat.author = authors.GetString(NULL);
 138                         dirstat.url = urls.GetString(NULL);
 139                         dirstat.askedcounter = GITFOLDERSTATUS_CACHETIMES;
 140                         dirstat.assumeValid = FALSE;
 141                         dirstat.skipWorktree = FALSE;
 142
 143                         dirstatus = NULL;
 144 //                      git_revnum_t youngest = GIT_INVALID_REVNUM;
 145 //                      git_opt_revision_t rev;
 146 //                      rev.kind = git_opt_revision_unspecified;
 147
 148
 149                         if (dirstatus)
 150                         {
 151 /*                              if (dirstatus->entry)
 152                                 {
 153                                         dirstat.author = authors.GetString (dirstatus->entry->cmt_author);
 154                                         dirstat.url = authors.GetString (dirstatus->entry->url);
 155                                         dirstat.rev = dirstatus->entry->cmt_rev;
 156                                 }*/
 157                                 dirstat.status = GitStatus::GetMoreImportant(dirstatus->text_status, dirstatus->prop_status);
 158                         }
 159                         m_cache[filepath.GetWinPath()] = dirstat;
 160                         m_TimeStamp = GetTickCount();
 161                         return &dirstat;
 162                 }
 163         } // if (bIsFolder)
 164
 165         m_nCounter = 0;
 166
 167         git_wc_status_kind status;
 168         bool assumeValid = false;
 169         bool skipWorktree = false;
 170         int t1,t2;
 171         t2=t1=0;
 172         try
 173         {
 174                 git_depth_t depth = git_depth_infinity;
 175
 176                 if (g_ShellCache.GetCacheType() == ShellCache::dll)
 177                 {
 178                         depth = git_depth_empty;
 179                 }
 180
 181                 t1 = ::GetCurrentTime();
 182                 status = m_GitStatus.GetAllStatus(filepath, depth, &assumeValid, &skipWorktree);
 183                 t2 = ::GetCurrentTime();
 184         }
 185         catch ( ... )
 186         {
 187                 status = git_wc_status_unknown;
 188         }
 189
 190         ATLTRACE2(_T("building cache for %s - time %d\n"), filepath.GetWinPath(), t2 -t1);
 191
 192         m_TimeStamp = GetTickCount();
 193         FileStatusCacheEntry * ret = NULL;
 194
 195         if (_tcslen(filepath.GetWinPath())==3)
 196                 ret = &m_cache[(LPCTSTR)filepath.GetWinPathString().Left(2)];
 197         else
 198                 ret = &m_cache[filepath.GetWinPath()];
 199
 200         ret->status = status;
 201         ret->assumeValid = assumeValid;
 202         ret->skipWorktree = skipWorktree;
 203
 204         m_mostRecentPath = filepath;
 205         m_mostRecentStatus = ret;
 206
 207         if (ret)
 208                 return ret;
 209         return &invalidstatus;
 210 }
 211
 212 DWORD GitFolderStatus::GetTimeoutValue()
 213 {
 214         DWORD timeout = GITFOLDERSTATUS_CACHETIMEOUT;
 215         DWORD factor = (DWORD)m_cache.size() / 200;
 216         if (factor==0)
 217                 factor = 1;
 218         return factor*timeout;
 219 }
 220
 221 const FileStatusCacheEntry * GitFolderStatus::GetFullStatus(const CTGitPath& filepath, BOOL bIsFolder, BOOL bColumnProvider)
 222 {
 223         const FileStatusCacheEntry * ret = NULL;
 224
 225         CString sProjectRoot;
 226         BOOL bHasAdminDir = g_ShellCache.HasGITAdminDir(filepath.GetWinPath(), bIsFolder, &sProjectRoot);
 227
 228         //no overlay for unversioned folders
 229         if ((!bColumnProvider)&&(!bHasAdminDir))
 230                 return &invalidstatus;
 231         //for the SVNStatus column, we have to check the cache to see
 232         //if it's not just unversioned but ignored
 233         ret = GetCachedItem(filepath);
 234         if ((ret)&&(ret->status == git_wc_status_unversioned)&&(bIsFolder)&&(bHasAdminDir))
 235         {
 236                 // an 'unversioned' folder, but with an ADMIN dir --> nested layout!
 237                 // NOTE: this could be a sub-project in git, or just some standalone project inside of another, either way a TODO
 238                 ret = BuildCache(filepath, sProjectRoot, bIsFolder, TRUE);
 239                 if (ret)
 240                         return ret;
 241                 else
 242                         return &invalidstatus;
 243         }
 244         if (ret)
 245                 return ret;
 246
 247         //if it's not in the cache and has no admin dir, then we assume
 248         //it's not ignored too
 249         if ((bColumnProvider)&&(!bHasAdminDir))
 250                 return &invalidstatus;
 251         ret = BuildCache(filepath, sProjectRoot, bIsFolder);
 252         if (ret)
 253                 return ret;
 254         else
 255                 return &invalidstatus;
 256 }
 257
 258 const FileStatusCacheEntry * GitFolderStatus::GetCachedItem(const CTGitPath& filepath)
 259 {
 260         sCacheKey.assign(filepath.GetWinPath());
 261         FileStatusMap::const_iterator iter;
 262         const FileStatusCacheEntry *retVal;
 263
 264         if(m_mostRecentPath.IsEquivalentTo(CTGitPath(sCacheKey.c_str())))
 265         {
 266                 // We've hit the same result as we were asked for last time
 267                 ATLTRACE2(_T("fast cache hit for %s\n"), filepath);
 268                 retVal = m_mostRecentStatus;
 269         }
 270         else if ((iter = m_cache.find(sCacheKey)) != m_cache.end())
 271         {
 272                 ATLTRACE2(_T("cache found for %s\n"), filepath);
 273                 retVal = &iter->second;
 274                 m_mostRecentStatus = retVal;
 275                 m_mostRecentPath = CTGitPath(sCacheKey.c_str());
 276         }
 277         else
 278         {
 279                 retVal = NULL;
 280         }
 281
 282         if(retVal != NULL)
 283         {
 284                 // We found something in a cache - check that the cache is not timed-out or force-invalidated
 285                 DWORD now = GetTickCount();
 286
 287                 if ((now >= m_TimeStamp)&&((now - m_TimeStamp) > GetTimeoutValue()))
 288                 {
 289                         // Cache is timed-out
 290                         ATLTRACE("Cache timed-out\n");
 291                         ClearCache();
 292                         retVal = NULL;
 293                 }
 294                 else if(WaitForSingleObject(m_hInvalidationEvent, 0) == WAIT_OBJECT_0)
 295                 {
 296                         // TortoiseProc has just done something which has invalidated the cache
 297                         ATLTRACE("Cache invalidated\n");
 298                         ClearCache();
 299                         retVal = NULL;
 300                 }
 301                 return retVal;
 302         }
 303         return NULL;
 304 }
 305
 306 void GitFolderStatus::ClearCache()
 307 {
 308         m_cache.clear();
 309         m_mostRecentStatus = NULL;
 310         m_mostRecentPath.Reset();
 311         // If we're about to rebuild the cache, there's no point hanging on to
 312         // an event which tells us that it's invalid
 313         ResetEvent(m_hInvalidationEvent);
 314 }