src/Git/gitindex.h

   1 #include "GitHash.h"
   2 #include "gitdll.h"
   3 #include "gitstatus.h"
   4 #include "SharedMutex.h"
   5
   6 /* Copy from Git cache.h*/
   7 #define FLEX_ARRAY 4
   8
   9 #pragma pack(push)
  10 #pragma pack(1)
  11 //#pragma pack(show)
  12 #define CACHE_SIGNATURE 0x44495243      /* "DIRC" */
  13 struct cache_header {
  14         unsigned int hdr_signature;
  15         unsigned int hdr_version;
  16         unsigned int hdr_entries;
  17 };
  18
  19 /*
  20  * The "cache_time" is just the low 32 bits of the
  21  * time. It doesn't matter if it overflows - we only
  22  * check it for equality in the 32 bits we save.
  23  */
  24 struct cache_time {
  25         UINT32 sec;
  26         UINT32 nsec;
  27 };
  28
  29 /*
  30  * dev/ino/uid/gid/size are also just tracked to the low 32 bits
  31  * Again - this is just a (very strong in practice) heuristic that
  32  * the inode hasn't changed.
  33  *
  34  * We save the fields in big-endian order to allow using the
  35  * index file over NFS transparently.
  36  */
  37 struct ondisk_cache_entry {
  38         struct cache_time ctime;
  39         struct cache_time mtime;
  40         UINT32 dev;
  41         UINT32 ino;
  42         UINT32 mode;
  43         UINT32 uid;
  44         UINT32 gid;
  45         UINT32 size;
  46         BYTE sha1[20];
  47         UINT16 flags;
  48         char name[FLEX_ARRAY]; /* more */
  49 };
  50
  51 /*
  52  * This struct is used when CE_EXTENDED bit is 1
  53  * The struct must match ondisk_cache_entry exactly from
  54  * ctime till flags
  55  */
  56 struct ondisk_cache_entry_extended {
  57         struct cache_time ctime;
  58         struct cache_time mtime;
  59         UINT32 dev;
  60         UINT32 ino;
  61         UINT32 mode;
  62         UINT32 uid;
  63         UINT32 gid;
  64         UINT32 size;
  65         BYTE sha1[20];
  66         UINT16 flags;
  67         UINT16 flags2;
  68         char name[FLEX_ARRAY]; /* more */
  69 };
  70
  71 #pragma pack(pop)
  72
  73 #define CE_NAMEMASK  (0x0fff)
  74 #define CE_STAGEMASK (0x3000)
  75 #define CE_EXTENDED  (0x4000)
  76 #define CE_VALID     (0x8000)
  77 #define CE_STAGESHIFT 12
  78 /*
  79  * Range 0xFFFF0000 in ce_flags is divided into
  80  * two parts: in-memory flags and on-disk ones.
  81  * Flags in CE_EXTENDED_FLAGS will get saved on-disk
  82  * if you want to save a new flag, add it in
  83  * CE_EXTENDED_FLAGS
  84  *
  85  * In-memory only flags
  86  */
  87 #define CE_UPDATE    (0x10000)
  88 #define CE_REMOVE    (0x20000)
  89 #define CE_UPTODATE  (0x40000)
  90 #define CE_ADDED     (0x80000)
  91
  92 #define CE_HASHED    (0x100000)
  93 #define CE_UNHASHED  (0x200000)
  94
  95 /*
  96  * Extended on-disk flags
  97  */
  98 #define CE_INTENT_TO_ADD 0x20000000
  99 /* CE_EXTENDED2 is for future extension */
 100 #define CE_EXTENDED2 0x80000000
 101
 102 #define CE_EXTENDED_FLAGS (CE_INTENT_TO_ADD)
 103
 104 /*
 105  * Safeguard to avoid saving wrong flags:
 106  *  - CE_EXTENDED2 won't get saved until its semantic is known
 107  *  - Bits in 0x0000FFFF have been saved in ce_flags already
 108  *  - Bits in 0x003F0000 are currently in-memory flags
 109  */
 110 #if CE_EXTENDED_FLAGS & 0x803FFFFF
 111 #error "CE_EXTENDED_FLAGS out of range"
 112 #endif
 113
 114 /*
 115  * Copy the sha1 and stat state of a cache entry from one to
 116  * another. But we never change the name, or the hash state!
 117  */
 118 #define CE_STATE_MASK (CE_HASHED | CE_UNHASHED)
 119
 120 template<class T>
 121 T Big2lit(T data)
 122 {
 123         T ret;
 124         BYTE *p1=(BYTE*)&data;
 125         BYTE *p2=(BYTE*)&ret;
 126         for(int i=0;i<sizeof(T);i++)
 127         {
 128                 p2[sizeof(T)-i-1] = p1[i];
 129         }
 130         return ret;
 131 }
 132
 133 template<class T>
 134 static inline size_t ce_namelen(T *ce)
 135 {
 136         size_t len = Big2lit(ce->flags) & CE_NAMEMASK;
 137         if (len < CE_NAMEMASK)
 138                 return len;
 139         return strlen(ce->name + CE_NAMEMASK) + CE_NAMEMASK;
 140 }
 141
 142 #define flexible_size(STRUCT,len) ((offsetof(STRUCT,name) + (len) + 8) & ~7)
 143
 144 //#define ondisk_cache_entry_size(len) flexible_size(ondisk_cache_entry,len)
 145 //#define ondisk_cache_entry_extended_size(len) flexible_size(ondisk_cache_entry_extended,len)
 146
 147 //#define ondisk_ce_size(ce) (((ce)->flags & CE_EXTENDED) ? \
 148 //                          ondisk_cache_entry_extended_size(ce_namelen(ce)) : \
 149 //                          ondisk_cache_entry_size(ce_namelen(ce)))
 150
 151 template<class T>
 152 static inline size_t ondisk_ce_size(T *ce)
 153 {
 154         return flexible_size(T,ce_namelen(ce));
 155 }
 156
 157 class CGitIndex
 158 {
 159 public:
 160         CString    m_FileName;
 161         __time64_t      m_ModifyTime;
 162         int                     m_Flags;
 163         //int            m_Status;
 164         CGitHash        m_IndexHash;
 165
 166         int FillData(ondisk_cache_entry* entry);
 167         int FillData(ondisk_cache_entry_extended* entry);
 168         int Print();
 169
 170 };
 171
 172 class CAutoReadLock
 173 {
 174         SharedMutex *m_Lock;
 175 public:
 176         CAutoReadLock(SharedMutex * lock)
 177         {
 178                 m_Lock = lock;
 179                 lock->AcquireShared();
 180         }
 181         ~CAutoReadLock()
 182         {
 183                 m_Lock->ReleaseShared();
 184         }
 185 };
 186
 187 class CAutoWriteLock
 188 {
 189         SharedMutex *m_Lock;
 190 public:
 191         CAutoWriteLock(SharedMutex * lock)
 192         {
 193                 m_Lock = lock;
 194                 lock->AcquireExclusive();
 195         }
 196         ~CAutoWriteLock()
 197         {
 198                 m_Lock->ReleaseExclusive();
 199         }
 200 };
 201
 202 class CGitIndexList:public std::vector<CGitIndex>
 203 {
 204 protected:
 205
 206 public:
 207         __time64_t  m_LastModifyTime;
 208
 209 #ifdef DEBUG
 210         CString m_GitFile;
 211         ~CGitIndexList()
 212         {
 213                 TRACE(_T("Free Index List 0x%x %s"),this, m_GitFile);
 214         }
 215 #endif
 216
 217         CGitIndexList();
 218
 219         int ReadIndex(CString file);
 220         int GetStatus(const CString &gitdir,const CString &path,git_wc_status_kind * status,BOOL IsFull=false, BOOL IsRecursive=false,FIll_STATUS_CALLBACK callback=NULL,void *pData=NULL,CGitHash *pHash=NULL);
 221 protected:
 222         int GetFileStatus(const CString &gitdir,const CString &path, git_wc_status_kind * status,__int64 time,FIll_STATUS_CALLBACK callback=NULL,void *pData=NULL,CGitHash *pHash=NULL);
 223         int GetDirStatus(const CString &gitdir,const CString &path, git_wc_status_kind * status,__int64 time,FIll_STATUS_CALLBACK callback=NULL,void *pData=NULL,CGitHash *pHash=NULL);
 224 };
 225
 226 typedef std::tr1::shared_ptr<CGitIndexList> SHARED_INDEX_PTR;
 227 typedef CComCritSecLock<CComCriticalSection> CAutoLocker;
 228
 229 class CGitIndexFileMap:public std::map<CString, SHARED_INDEX_PTR>
 230 {
 231 public:
 232         CComCriticalSection                     m_critIndexSec;
 233
 234         CGitIndexFileMap() { m_critIndexSec.Init(); }
 235         ~CGitIndexFileMap() { m_critIndexSec.Term(); }
 236
 237         SHARED_INDEX_PTR SafeGet(const CString &path)
 238         {
 239                 CAutoLocker lock(m_critIndexSec);
 240                 if(this->find(path) == end())
 241                         return SHARED_INDEX_PTR();
 242                 else
 243                         return (*this)[path];
 244         }
 245
 246         void SafeSet(const CString &path, SHARED_INDEX_PTR ptr)
 247         {
 248                 CAutoLocker lock(m_critIndexSec);
 249                 (*this)[path] = ptr;
 250         }
 251
 252         int Check(const CString &gitdir, bool *isChanged);
 253         int LoadIndex(const CString &gitdir);
 254
 255         void CheckAndUpdate(const CString &gitdir,bool isLoadUpdatedIndex)
 256         {
 257                 bool isChanged=false;
 258                 if(isLoadUpdatedIndex && Check(gitdir,&isChanged))
 259                         return ;
 260
 261                 if(isChanged && isLoadUpdatedIndex)
 262                         LoadIndex(gitdir);
 263         }
 264         int GetFileStatus(const CString &gitdir,const CString &path,git_wc_status_kind * status,
 265                                                         BOOL IsFull=false, BOOL IsRecursive=false,
 266                                                         FIll_STATUS_CALLBACK callback=NULL,
 267                                                         void *pData=NULL,CGitHash *pHash=NULL,
 268                                                         bool isLoadUpdatedIndex=true);
 269
 270         int IsUnderVersionControl(const CString &gitdir,
 271                                                           const CString &path,
 272                                                           bool isDir,
 273                                                           bool *isVersion,
 274                                                           bool isLoadUpdateIndex=true);
 275 };
 276
 277
 278 class CGitTreeItem
 279 {
 280 public:
 281         CString m_FileName;
 282         CGitHash        m_Hash;
 283         int                     m_Flags;
 284 };
 285
 286 /* After object create, never change field agains
 287  * that needn't lock to get field
 288 */
 289 class CGitHeadFileList:public std::vector<CGitTreeItem>
 290 {
 291 private:
 292
 293         int GetPackRef(const CString &gitdir);
 294
 295 public:
 296         __time64_t  m_LastModifyTimeHead;
 297         __time64_t  m_LastModifyTimeRef;
 298         __time64_t      m_LastModifyTimePackRef;
 299
 300         CString         m_HeadRefFile;
 301         CGitHash        m_Head;
 302         CString         m_HeadFile;
 303         CString         m_Gitdir;
 304         CString         m_PackRefFile;
 305
 306         CGitHash        m_TreeHash; /* buffered tree hash value */
 307
 308         std::map<CString,CGitHash> m_PackRefMap;
 309
 310         CGitHeadFileList()
 311         {
 312                 m_LastModifyTimeHead=0;
 313                 m_LastModifyTimeRef=0;
 314                 m_LastModifyTimePackRef = 0;
 315         }
 316
 317 #ifdef DEBUG
 318         CString m_GitFile;
 319         ~CGitHeadFileList()
 320         {
 321                 TRACE(_T("Free Index List 0x%x %s"),this, m_GitFile);
 322         }
 323 #endif
 324
 325         int ReadTree();
 326         int ReadHeadHash(CString gitdir);
 327         bool CheckHeadUpdate();
 328         static int CallBack(const unsigned char *, const char *, int, const char *, unsigned int, int, void *);
 329         //int ReadTree();
 330 };
 331
 332 typedef std::tr1::shared_ptr<CGitHeadFileList> SHARED_TREE_PTR;
 333 class CGitHeadFileMap:public std::map<CString,SHARED_TREE_PTR>
 334 {
 335 public:
 336
 337         CComCriticalSection                     m_critTreeSec;
 338
 339         CGitHeadFileMap() { m_critTreeSec.Init(); }
 340         ~CGitHeadFileMap() { m_critTreeSec.Term(); }
 341
 342         SHARED_TREE_PTR SafeGet(const CString &path)
 343         {
 344                 CAutoLocker lock(m_critTreeSec);
 345                 if(this->find(path) == end())
 346                         return SHARED_TREE_PTR();
 347                 else
 348                         return (*this)[path];
 349         }
 350
 351         void SafeSet(const CString &path, SHARED_TREE_PTR ptr)
 352         {
 353                 CAutoLocker lock(m_critTreeSec);
 354                 (*this)[path] = ptr;
 355         }
 356
 357         int GetFileStatus(const CString &gitdir,const CString &path,git_wc_status_kind * status,BOOL IsFull=false, BOOL IsRecursive=false,
 358                                                 FIll_STATUS_CALLBACK callback=NULL,void *pData=NULL,
 359                                                 bool isLoaded=false);
 360         int CheckHeadUpdate(const CString &gitdir);
 361         int GetHeadHash(const CString &gitdir, CGitHash &hash);
 362
 363 #if 0
 364         bool IsHashChanged(const CString &gitdir)
 365         {
 366                 CAutoReadLock lock(&m_SharedMutex);
 367                 if( find(gitdir) == end())
 368                         return false;
 369
 370                 CAutoReadLock lock1(&(*this).m_SharedMutex);
 371                 return (*this)[gitdir].m_Head != (*this)[gitdir].m_TreeHash;
 372         }
 373 #endif
 374 };
 375
 376
 377
 378 class CGitIgnoreItem
 379 {
 380 public:
 381         SharedMutex  m_SharedMutex;
 382
 383         CGitIgnoreItem()
 384         {
 385                 m_LastModifyTime =0;
 386                 m_pExcludeList =NULL;
 387         }
 388         ~CGitIgnoreItem()
 389         {
 390                 if(m_pExcludeList)
 391                         git_free_exclude_list(m_pExcludeList);
 392                 m_pExcludeList=NULL;
 393         }
 394         __time64_t  m_LastModifyTime;
 395         CStringA m_BaseDir;
 396         EXCLUDE_LIST m_pExcludeList;
 397         int FetchIgnoreList(const CString &projectroot, const CString &file);
 398 };
 399
 400 class CGitIgnoreList
 401 {
 402 private:
 403         bool CheckFileChanged(const CString &path);
 404         int      FetchIgnoreFile(const CString &gitdir, const CString &gitignore);
 405
 406         int  CheckIgnore(const CString &path,const CString &root);
 407
 408 public:
 409         SharedMutex             m_SharedMutex;
 410
 411         CGitIgnoreList(){ m_SharedMutex.Init(); }
 412         ~CGitIgnoreList() { m_SharedMutex.Release(); }
 413
 414         std::map<CString, CGitIgnoreItem> m_Map;
 415
 416         int      GetIgnoreFileChangeTimeList(const CString &dir, std::vector<__int64> &timelist);
 417         bool CheckIgnoreChanged(const CString &gitdir,const CString &path);
 418         int  LoadAllIgnoreFile(const CString &gitdir,const CString &path);
 419         bool IsIgnore(const CString &path,const CString &root);
 420 };
 421
 422 template<class T>
 423 int GetRangeInSortVector(T &vector,LPTSTR pstr,int len, int *start, int *end, int pos)
 424 {
 425         if( pos < 0)
 426         {
 427                 return -1;
 428         }
 429         if(start == 0 || end == NULL)
 430                 return -1;
 431
 432         *start=*end=-1;
 433         if( _tcsnccmp(vector[pos].m_FileName, pstr,len) != 0)
 434         {
 435                 for(int i=0;i< vector.size();i++)
 436                 {
 437                         if( _tcsnccmp(vector[i].m_FileName, pstr,len) == 0 )
 438                         {
 439                                 if(*start<0)
 440                                         *start =i;
 441                                 *end =i;
 442                         }
 443                 }
 444                 return -1;
 445         }else
 446         {
 447                 *start =0;
 448                 *end = vector.size();
 449
 450                 for(int i=pos;i<vector.size();i++)
 451                 {
 452                         if( _tcsnccmp(vector[i].m_FileName, pstr,len) == 0 )
 453                         {
 454                                 *end=i;
 455                         }else
 456                         {
 457                                 break;
 458                         }
 459                 }
 460                 for(int i=pos;i>=0;i--)
 461                 {
 462                         if( _tcsnccmp(vector[i].m_FileName, pstr,len) == 0 )
 463                         {
 464                                 *start=i;
 465                         }else
 466                         {
 467                                 break;
 468                         }
 469                 }
 470         }
 471         return 0;
 472 }
 473
 474 template<class T>
 475 int SearchInSortVector(T &vector, LPTSTR pstr, int len)
 476 {
 477         int end=vector.size()-1;
 478         int start = 0;
 479         int mid = (start+end)/2;
 480
 481         if(vector.size() == 0)
 482                 return -1;
 483
 484         while(!( start == end && start==mid))
 485         {
 486                 int cmp;
 487                 cmp = _tcsnccmp( vector[mid].m_FileName,pstr,len );
 488
 489                 if(cmp ==0)
 490                         return mid;
 491
 492                 if(cmp < 0)
 493                 {
 494                         start = mid+1;
 495                 }
 496
 497                 if(cmp > 0)
 498                 {
 499                         end=mid;
 500                 }
 501                 mid=(start +end ) /2;
 502
 503         }
 504
 505         if(_tcsnccmp( vector[mid].m_FileName,pstr,len ) == 0)
 506                 return mid;
 507
 508         return -1;
 509 };
 510 #if 0
 511
 512 class CGitStatus
 513 {
 514 protected:
 515         int GetFileStatus(const CString &gitdir,const CString &path,git_wc_status_kind * status,BOOL IsFull=false, BOOL IsRecursive=false,FIll_STATUS_CALLBACK callback=NULL,void *pData=NULL);
 516 public:
 517         CGitIgnoreList m_IgnoreList;
 518         CGitHeadFileMap m_HeadFilesMap;
 519         CGitIndexFileMap m_IndexFilesMap;
 520
 521         int GetStatus(const CString &gitdir,const CString &path,git_wc_status_kind * status,BOOL IsFull=false, BOOL IsRecursive=false,FIll_STATUS_CALLBACK callback=NULL,void *pData=NULL);
 522 };
 523
 524 #endif