test/Cache/CacheDlg.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2012, 2014-2017 - TortoiseGit
   4 // Copyright (C) 2003-2006, 2009, 2015 - TortoiseSVN
   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 "Cache.h"
  22 #include "DirFileEnum.h"
  23 #include "CacheInterface.h"
  24 #include <WinInet.h>
  25 #include "CacheDlg.h"
  26 #include <random>
  27
  28 #ifdef _DEBUG
  29 #define new DEBUG_NEW
  30 #endif
  31
  32
  33 CCacheDlg::CCacheDlg(CWnd* pParent /*=nullptr*/)
  34 : CDialog(CCacheDlg::IDD, pParent)
  35 , m_hPipe(INVALID_HANDLE_VALUE)
  36 {
  37         m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
  38 }
  39
  40 void CCacheDlg::DoDataExchange(CDataExchange* pDX)
  41 {
  42         CDialog::DoDataExchange(pDX);
  43         DDX_Text(pDX, IDC_ROOTPATH, m_sRootPath);
  44 }
  45
  46 BEGIN_MESSAGE_MAP(CCacheDlg, CDialog)
  47         ON_WM_PAINT()
  48         ON_WM_QUERYDRAGICON()
  49         //}}AFX_MSG_MAP
  50         ON_BN_CLICKED(IDOK, OnBnClickedOk)
  51         ON_BN_CLICKED(IDC_WATCHTESTBUTTON, OnBnClickedWatchtestbutton)
  52 END_MESSAGE_MAP()
  53
  54
  55 // CCacheDlg message handlers
  56
  57 BOOL CCacheDlg::OnInitDialog()
  58 {
  59         CDialog::OnInitDialog();
  60
  61         // Set the icon for this dialog.  The framework does this automatically
  62         //  when the application's main window is not a dialog
  63         SetIcon(m_hIcon, TRUE);                 // Set big icon
  64         SetIcon(m_hIcon, FALSE);                // Set small icon
  65
  66         return TRUE;  // return TRUE  unless you set the focus to a control
  67 }
  68
  69 // If you add a minimize button to your dialog, you will need the code below
  70 //  to draw the icon.  For MFC applications using the document/view model,
  71 //  this is automatically done for you by the framework.
  72
  73 void CCacheDlg::OnPaint()
  74 {
  75         if (IsIconic())
  76         {
  77                 CPaintDC dc(this); // device context for painting
  78
  79                 SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);
  80
  81                 // Center icon in client rectangle
  82                 int cxIcon = GetSystemMetrics(SM_CXICON);
  83                 int cyIcon = GetSystemMetrics(SM_CYICON);
  84                 CRect rect;
  85                 GetClientRect(&rect);
  86                 int x = (rect.Width() - cxIcon + 1) / 2;
  87                 int y = (rect.Height() - cyIcon + 1) / 2;
  88
  89                 // Draw the icon
  90                 dc.DrawIcon(x, y, m_hIcon);
  91         }
  92         else
  93         {
  94                 CDialog::OnPaint();
  95         }
  96 }
  97
  98 // The system calls this function to obtain the cursor to display while the user drags
  99 //  the minimized window.
 100 HCURSOR CCacheDlg::OnQueryDragIcon()
 101 {
 102         return static_cast<HCURSOR>(m_hIcon);
 103 }
 104
 105 void CCacheDlg::OnBnClickedOk()
 106 {
 107         UpdateData();
 108         AfxBeginThread(TestThreadEntry, this);
 109 }
 110 UINT CCacheDlg::TestThreadEntry(LPVOID pVoid)
 111 {
 112         return ((CCacheDlg*)pVoid)->TestThread();
 113 }
 114
 115 //this is the thread function which calls the subversion function
 116 UINT CCacheDlg::TestThread()
 117 {
 118         CDirFileEnum direnum(m_sRootPath);
 119         m_filelist.RemoveAll();
 120         CString filepath;
 121         bool bIsDir = false;
 122         while (direnum.NextFile(filepath, &bIsDir))
 123                 if (filepath.Find(L".git") < 0)
 124                         m_filelist.Add(filepath);
 125
 126         CTime starttime = CTime::GetCurrentTime();
 127         GetDlgItem(IDC_STARTTIME)->SetWindowText(starttime.Format(L"%H:%M:%S"));
 128
 129         ULONGLONG startticks = GetTickCount64();
 130
 131         CString sNumber;
 132         std::random_device rd;
 133         std::mt19937 mt(rd());
 134         std::uniform_int_distribution<INT_PTR> dist(0, max(0, m_filelist.GetCount() - 1));
 135         std::uniform_int_distribution<INT_PTR> dist2(0, 9);
 136         for (int i=0; i < 1; ++i)
 137         {
 138                 CString filepath2;
 139                 //do {
 140                         filepath2 = m_filelist.GetAt(dist(mt));
 141                 //}while(filepath.Find(L".git") >= 0);
 142                 GetDlgItem(IDC_FILEPATH)->SetWindowText(filepath2);
 143                 GetStatusFromRemoteCache(CTGitPath(filepath2), true);
 144                 sNumber.Format(L"%d", i);
 145                 GetDlgItem(IDC_DONE)->SetWindowText(sNumber);
 146                 if ((GetTickCount64()%10)==1)
 147                         Sleep(10);
 148                 if (dist2(mt) == 3)
 149                         RemoveFromCache(filepath2);
 150         }
 151         CTime endtime = CTime::GetCurrentTime();
 152         CString sEnd = endtime.Format(L"%H:%M:%S");
 153
 154         ULONGLONG endticks = GetTickCount64();
 155
 156         CString sEndText;
 157         sEndText.Format(L"%s  - %I64u ms", (LPCTSTR)sEnd, endticks - startticks);
 158
 159         GetDlgItem(IDC_ENDTIME)->SetWindowText(sEndText);
 160
 161         return 0;
 162 }
 163
 164
 165 bool CCacheDlg::EnsurePipeOpen()
 166 {
 167         if(m_hPipe != INVALID_HANDLE_VALUE)
 168         {
 169                 return true;
 170         }
 171
 172         m_hPipe = CreateFile(
 173                 GetCachePipeName(),   // pipe name
 174                 GENERIC_READ |                                  // read and write access
 175                 GENERIC_WRITE,
 176                 0,                                                              // no sharing
 177                 nullptr,                                                // default security attributes
 178                 OPEN_EXISTING,                          // opens existing pipe
 179                 FILE_FLAG_OVERLAPPED,                   // default attributes
 180                 nullptr);                                               // no template file
 181
 182         if (m_hPipe == INVALID_HANDLE_VALUE && GetLastError() == ERROR_PIPE_BUSY)
 183         {
 184                 // TSVNCache is running but is busy connecting a different client.
 185                 // Do not give up immediately but wait for a few milliseconds until
 186                 // the server has created the next pipe instance
 187                 if (WaitNamedPipe(GetCachePipeName(), 50))
 188                 {
 189                         m_hPipe = CreateFile(
 190                                 GetCachePipeName(),   // pipe name
 191                                 GENERIC_READ |                                  // read and write access
 192                                 GENERIC_WRITE,
 193                                 0,                                                              // no sharing
 194                                 nullptr,                                                // default security attributes
 195                                 OPEN_EXISTING,                          // opens existing pipe
 196                                 FILE_FLAG_OVERLAPPED,                   // default attributes
 197                                 nullptr);                                               // no template file
 198                 }
 199         }
 200
 201
 202         if (m_hPipe != INVALID_HANDLE_VALUE)
 203         {
 204                 // The pipe connected; change to message-read mode.
 205                 DWORD dwMode;
 206
 207                 dwMode = PIPE_READMODE_MESSAGE;
 208                 if(!SetNamedPipeHandleState(
 209                         m_hPipe,    // pipe handle
 210                         &dwMode,  // new pipe mode
 211                         nullptr,  // don't set maximum bytes
 212                         nullptr)) // don't set maximum time
 213                 {
 214                         ATLTRACE("SetNamedPipeHandleState failed");
 215                         CloseHandle(m_hPipe);
 216                         m_hPipe = INVALID_HANDLE_VALUE;
 217                         return false;
 218                 }
 219                 // create an unnamed (=local) manual reset event for use in the overlapped structure
 220                 m_hEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
 221                 if (m_hEvent)
 222                         return true;
 223                 ATLTRACE("CreateEvent failed");
 224                 ClosePipe();
 225                 return false;
 226         }
 227
 228         return false;
 229 }
 230
 231
 232 void CCacheDlg::ClosePipe()
 233 {
 234         if(m_hPipe != INVALID_HANDLE_VALUE)
 235         {
 236                 CloseHandle(m_hPipe);
 237                 CloseHandle(m_hEvent);
 238                 m_hPipe = INVALID_HANDLE_VALUE;
 239                 m_hEvent = INVALID_HANDLE_VALUE;
 240         }
 241 }
 242
 243 bool CCacheDlg::GetStatusFromRemoteCache(const CTGitPath& Path, bool bRecursive)
 244 {
 245         if(!EnsurePipeOpen())
 246         {
 247                 STARTUPINFO startup = { 0 };
 248                 PROCESS_INFORMATION process = { 0 };
 249                 startup.cb = sizeof(startup);
 250
 251                 CString sCachePath = L"TGitCache.exe";
 252                 if (CreateProcess(sCachePath.GetBuffer(sCachePath.GetLength() + 1), L"", nullptr, nullptr, FALSE, 0, nullptr, nullptr, &startup, &process) == 0)
 253                 {
 254                         // It's not appropriate to do a message box here, because there may be hundreds of calls
 255                         sCachePath.ReleaseBuffer();
 256                         ATLTRACE("Failed to start cache\n");
 257                         return false;
 258                 }
 259                 sCachePath.ReleaseBuffer();
 260
 261                 // Wait for the cache to open
 262                 ULONGLONG endTime = GetTickCount64()+1000;
 263                 while(!EnsurePipeOpen())
 264                 {
 265                         if((GetTickCount64() - endTime) > 0)
 266                         {
 267                                 return false;
 268                         }
 269                 }
 270         }
 271
 272
 273         DWORD nBytesRead;
 274         TGITCacheRequest request;
 275         request.flags = TGITCACHE_FLAGS_NONOTIFICATIONS;
 276         if(bRecursive)
 277         {
 278                 request.flags |= TGITCACHE_FLAGS_RECUSIVE_STATUS;
 279         }
 280         wcsncpy_s(request.path, Path.GetWinPath(), MAX_PATH);
 281         SecureZeroMemory(&m_Overlapped, sizeof(OVERLAPPED));
 282         m_Overlapped.hEvent = m_hEvent;
 283         // Do the transaction in overlapped mode.
 284         // That way, if anything happens which might block this call
 285         // we still can get out of it. We NEVER MUST BLOCK THE SHELL!
 286         // A blocked shell is a very bad user impression, because users
 287         // who don't know why it's blocked might find the only solution
 288         // to such a problem is a reboot and therefore they might loose
 289         // valuable data.
 290         // Sure, it would be better to have no situations where the shell
 291         // even can get blocked, but the timeout of 5 seconds is long enough
 292         // so that users still recognize that something might be wrong and
 293         // report back to us so we can investigate further.
 294
 295         TGITCacheResponse ReturnedStatus;
 296         BOOL fSuccess = TransactNamedPipe(m_hPipe,
 297                 &request, sizeof(request),
 298                 &ReturnedStatus, sizeof(ReturnedStatus),
 299                 &nBytesRead, &m_Overlapped);
 300
 301         if (!fSuccess)
 302         {
 303                 if (GetLastError()!=ERROR_IO_PENDING)
 304                 {
 305                         ClosePipe();
 306                         return false;
 307                 }
 308
 309                 // TransactNamedPipe is working in an overlapped operation.
 310                 // Wait for it to finish
 311                 DWORD dwWait = WaitForSingleObject(m_hEvent, INFINITE);
 312                 if (dwWait == WAIT_OBJECT_0)
 313                 {
 314                         fSuccess = GetOverlappedResult(m_hPipe, &m_Overlapped, &nBytesRead, FALSE);
 315                         return TRUE;
 316                 }
 317                 else
 318                         fSuccess = FALSE;
 319         }
 320
 321         ClosePipe();
 322         return false;
 323 }
 324
 325 void CCacheDlg::RemoveFromCache(const CString& path)
 326 {
 327         // if we use the external cache, we tell the cache directly that something
 328         // has changed, without the detour via the shell.
 329         HANDLE hPipe = CreateFile(
 330                 GetCacheCommandPipeName(),      // pipe name
 331                 GENERIC_READ |                                  // read and write access
 332                 GENERIC_WRITE,
 333                 0,                                                              // no sharing
 334                 nullptr,                                                // default security attributes
 335                 OPEN_EXISTING,                                  // opens existing pipe
 336                 FILE_FLAG_OVERLAPPED,                   // default attributes
 337                 nullptr);                                               // no template file
 338
 339
 340         if (hPipe != INVALID_HANDLE_VALUE)
 341         {
 342                 // The pipe connected; change to message-read mode.
 343                 DWORD dwMode;
 344
 345                 dwMode = PIPE_READMODE_MESSAGE;
 346                 if(SetNamedPipeHandleState(
 347                         hPipe,    // pipe handle
 348                         &dwMode,  // new pipe mode
 349                         NULL,     // don't set maximum bytes
 350                         NULL))    // don't set maximum time
 351                 {
 352                         DWORD cbWritten;
 353                         TGITCacheCommand cmd;
 354                         cmd.command = TGITCACHECOMMAND_CRAWL;
 355                         wcsncpy_s(cmd.path, path, MAX_PATH);
 356                         BOOL fSuccess = WriteFile(
 357                                 hPipe,                  // handle to pipe
 358                                 &cmd,                   // buffer to write from
 359                                 sizeof(cmd),    // number of bytes to write
 360                                 &cbWritten,             // number of bytes written
 361                                 NULL);                  // not overlapped I/O
 362
 363                         if (! fSuccess || sizeof(cmd) != cbWritten)
 364                         {
 365                                 DisconnectNamedPipe(hPipe);
 366                                 CloseHandle(hPipe);
 367                                 hPipe = INVALID_HANDLE_VALUE;
 368                         }
 369                         if (hPipe != INVALID_HANDLE_VALUE)
 370                         {
 371                                 // now tell the cache we don't need it's command thread anymore
 372                                 DWORD cbWritten2;
 373                                 TGITCacheCommand cmd2;
 374                                 cmd2.command = TGITCACHECOMMAND_END;
 375                                 WriteFile(
 376                                         hPipe,                  // handle to pipe
 377                                         &cmd2,                  // buffer to write from
 378                                         sizeof(cmd2),   // number of bytes to write
 379                                         &cbWritten2,            // number of bytes written
 380                                         NULL);                  // not overlapped I/O
 381                                 DisconnectNamedPipe(hPipe);
 382                                 CloseHandle(hPipe);
 383                                 hPipe = INVALID_HANDLE_VALUE;
 384                         }
 385                 }
 386                 else
 387                 {
 388                         ATLTRACE("SetNamedPipeHandleState failed");
 389                         CloseHandle(hPipe);
 390                 }
 391         }
 392 }
 393 void CCacheDlg::OnBnClickedWatchtestbutton()
 394 {
 395         UpdateData();
 396         AfxBeginThread(WatchTestThreadEntry, this);
 397 }
 398
 399 UINT CCacheDlg::WatchTestThreadEntry(LPVOID pVoid)
 400 {
 401         return ((CCacheDlg*)pVoid)->WatchTestThread();
 402 }
 403
 404 //this is the thread function which calls the subversion function
 405 UINT CCacheDlg::WatchTestThread()
 406 {
 407         CDirFileEnum direnum(m_sRootPath);
 408         m_filelist.RemoveAll();
 409         CString filepath;
 410         bool bIsDir = false;
 411         while (direnum.NextFile(filepath, &bIsDir))
 412                 m_filelist.Add(filepath);
 413
 414         CTime starttime = CTime::GetCurrentTime();
 415         GetDlgItem(IDC_STARTTIME)->SetWindowText(starttime.Format(L"%H:%M:%S"));
 416
 417         ULONGLONG startticks = GetTickCount64();
 418
 419         CString sNumber;
 420         std::random_device rd;
 421         std::mt19937 mt(rd());
 422         std::uniform_int_distribution<INT_PTR> dist(0, max(0, m_filelist.GetCount() - 1));
 423         filepath = m_filelist.GetAt(dist(mt));
 424         GetStatusFromRemoteCache(CTGitPath(m_sRootPath), false);
 425         for (int i=0; i < 10000; ++i)
 426         {
 427                 filepath = m_filelist.GetAt(dist(mt));
 428                 GetDlgItem(IDC_FILEPATH)->SetWindowText(filepath);
 429                 TouchFile(filepath);
 430                 CopyRemoveCopy(filepath);
 431                 sNumber.Format(L"%d", i);
 432                 GetDlgItem(IDC_DONE)->SetWindowText(sNumber);
 433         }
 434
 435         // create dummy directories and remove them again several times
 436         for (int outer = 0; outer<100; ++outer)
 437         {
 438                 for (int i=0; i<10; ++i)
 439                 {
 440                         filepath.Format(L"__MyDummyFolder%d", i);
 441                         CreateDirectory(m_sRootPath + L'\\' + filepath, nullptr);
 442                         HANDLE hFile = CreateFile(m_sRootPath + L'\\' + filepath + L"\\file", GENERIC_READ, FILE_SHARE_READ, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
 443                         CloseHandle(hFile);
 444                         SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATH | SHCNF_FLUSHNOWAIT, m_sRootPath + L'\\' + filepath + L"\\file", NULL);
 445                 }
 446                 Sleep(500);
 447                 for (int i=0; i<10; ++i)
 448                 {
 449                         filepath.Format(L"__MyDummyFolder%d", i);
 450                         DeleteFile(m_sRootPath + L'\\' + filepath + L"\\file");
 451                         RemoveDirectory(m_sRootPath + L'\\' + filepath);
 452                 }
 453                 sNumber.Format(L"%d", outer);
 454                 GetDlgItem(IDC_DONE)->SetWindowText(sNumber);
 455         }
 456
 457         CTime endtime = CTime::GetCurrentTime();
 458         CString sEnd = endtime.Format(L"%H:%M:%S");
 459
 460         ULONGLONG endticks = GetTickCount64();
 461
 462         CString sEndText;
 463         sEndText.Format(L"%s  - %I64u ms", (LPCTSTR)sEnd, endticks - startticks);
 464
 465         GetDlgItem(IDC_ENDTIME)->SetWindowText(sEndText);
 466
 467         return 0;
 468 }
 469
 470 void CCacheDlg::TouchFile(const CString& path)
 471 {
 472         SetFileAttributes(path, FILE_ATTRIBUTE_NORMAL);
 473         HANDLE hFile = CreateFile(path, GENERIC_WRITE, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
 474         if (hFile == INVALID_HANDLE_VALUE)
 475                 return;
 476
 477         FILETIME ft;
 478         SYSTEMTIME st;
 479
 480         GetSystemTime(&st);              // gets current time
 481         SystemTimeToFileTime(&st, &ft);  // converts to file time format
 482         SetFileTime(hFile,           // sets last-write time for file
 483                 (LPFILETIME) NULL, (LPFILETIME) NULL, &ft);
 484
 485         CloseHandle(hFile);
 486 }
 487
 488 void CCacheDlg::CopyRemoveCopy(const CString& path)
 489 {
 490         if (PathIsDirectory(path))
 491                 return;
 492         if (path.Find(L".git") >= 0)
 493                 return;
 494         if (CopyFile(path, path+L".tmp", FALSE))
 495         {
 496                 if (DeleteFile(path))
 497                 {
 498                         if (MoveFile(path+L".tmp", path))
 499                                 return;
 500                         else
 501                                 MessageBox(L"could not move file!", path);
 502                 }
 503                 else
 504                         MessageBox(L"could not delete file!", path);
 505         }
 506         else
 507                 MessageBox(L"could not copy file!", path);
 508 }