@joebigelow / wix / commits / 941c47e5

Detect a package as cached if any of its payloads exist.

Detect is supposed to be fast, so it can't fully verify every payload for every package. The engine was wasting its time by trying to verify file sizes without the hash. Even worse, it was making decisions during planning based on that insufficient verification. Contributes to #3640

Sean Hall committed Apr 16, 2021 at 09:40 UTC 941c47e5a3f57ce9626b447a95740b1444e69343

23 files changed +111 -171

src/engine/apply.cpp

@@ -1910,6 +1910,8 @@ static HRESULT DoRollbackActions(

1910 ExitFunction1(hr = S_OK);

1911

1912 case BURN_EXECUTE_ACTION_TYPE_UNCACHE_PACKAGE:

1913 + // TODO: This used to be skipped if the package was already cached.

1914 + // Need to figure out new logic for when (if?) to skip it.

1915 hr = CleanPackage(pEngineState->companionConnection.hPipe, pRollbackAction->uncachePackage.pPackage);

1916 IgnoreRollbackError(hr, "Failed to uncache package for rollback.");

1917 break;

src/engine/cache.cpp

+18 -7

@@ -91,6 +91,7 @@ static HRESULT RemoveBundleOrPackage(

91 static HRESULT VerifyHash(

92 __in BYTE* pbHash,

93 __in DWORD cbHash,

94 + __in DWORD64 qwFileSize,

95 __in_z LPCWSTR wzUnverifiedPayloadPath,

96 __in HANDLE hFile

97 );

@@ -1288,7 +1289,7 @@ static HRESULT VerifyThenTransferContainer(

1289 // Container should have a hash we can use to verify with.

1290 if (pContainer->pbHash)

1291 {

1291 - hr = VerifyHash(pContainer->pbHash, pContainer->cbHash, wzUnverifiedContainerPath, hFile);

1292 + hr = VerifyHash(pContainer->pbHash, pContainer->cbHash, pContainer->qwFileSize, wzUnverifiedContainerPath, hFile);

1293 ExitOnFailure(hr, "Failed to verify container hash: %ls", wzCachedPath);

1294 }

1295

@@ -1330,7 +1331,7 @@ static HRESULT VerifyThenTransferPayload(

1331

1332 if (pPayload->pbHash) // the payload should have a hash we can use to verify it.

1333 {

1333 - hr = VerifyHash(pPayload->pbHash, pPayload->cbHash, wzUnverifiedPayloadPath, hFile);

1334 + hr = VerifyHash(pPayload->pbHash, pPayload->cbHash, pPayload->qwFileSize, wzUnverifiedPayloadPath, hFile);

1335 ExitOnFailure(hr, "Failed to verify payload hash: %ls", wzCachedPath);

1336 }

1337

@@ -1398,7 +1399,7 @@ static HRESULT VerifyFileAgainstPayload(

1399

1400 if (pPayload->pbHash) // the payload should have a hash we can use to verify it.

1401 {

1401 - hr = VerifyHash(pPayload->pbHash, pPayload->cbHash, wzVerifyPath, hFile);

1402 + hr = VerifyHash(pPayload->pbHash, pPayload->cbHash, pPayload->qwFileSize, wzVerifyPath, hFile);

1403 ExitOnFailure(hr, "Failed to verify hash of payload: %ls", pPayload->sczKey);

1404 }

1405

@@ -1712,7 +1713,7 @@ static HRESULT RemoveBundleOrPackage(

1713 }

1714 }

1715

1715 - if (FAILED(hr))

1716 + if (E_PATHNOTFOUND != hr && FAILED(hr))

1717 {

1718 LogId(REPORT_STANDARD, fBundle ? MSG_UNABLE_UNCACHE_BUNDLE : MSG_UNABLE_UNCACHE_PACKAGE, wzBundleOrPackageId, sczDirectory, hr);

1719 hr = S_OK;

@@ -1743,6 +1744,7 @@ LExit:

1744 static HRESULT VerifyHash(

1745 __in BYTE* pbHash,

1746 __in DWORD cbHash,

1747 + __in DWORD64 qwFileSize,

1748 __in_z LPCWSTR wzUnverifiedPayloadPath,

1749 __in HANDLE hFile

1750 )

@@ -1751,22 +1753,31 @@ static HRESULT VerifyHash(

1753

1754 HRESULT hr = S_OK;

1755 BYTE rgbActualHash[SHA512_HASH_LEN] = { };

1754 - DWORD64 qwHashedBytes;

1756 + DWORD64 qwHashedBytes = 0;

1757 + LONGLONG llSize = 0;

1758 LPWSTR pszExpected = NULL;

1759 LPWSTR pszActual = NULL;

1760

1761 + hr = FileSizeByHandle(hFile, &llSize);

1762 + ExitOnFailure(hr, "Failed to get file size for path: %ls", wzUnverifiedPayloadPath);

1763 +

1764 + if (static_cast<DWORD64>(llSize) != qwFileSize)

1765 + {

1766 + ExitOnFailure(hr = ERROR_FILE_CORRUPT, "File size mismatch for path: %ls, expected: %llu, actual: %lld", wzUnverifiedPayloadPath, qwFileSize, llSize);

1767 + }

1768 +

1769 // TODO: create a cryp hash file that sends progress.

1770 hr = CrypHashFileHandle(hFile, PROV_RSA_AES, CALG_SHA_512, rgbActualHash, sizeof(rgbActualHash), &qwHashedBytes);

1771 ExitOnFailure(hr, "Failed to calculate hash for path: %ls", wzUnverifiedPayloadPath);

1772

1773 // Compare hashes.

1763 - if (cbHash != sizeof(rgbActualHash) || 0 != memcmp(pbHash, rgbActualHash, SHA512_HASH_LEN))

1774 + if (cbHash != sizeof(rgbActualHash) || 0 != memcmp(pbHash, rgbActualHash, sizeof(rgbActualHash)))

1775 {

1776 hr = CRYPT_E_HASH_VALUE;

1777

1778 // Best effort to log the expected and actual hash value strings.

1779 if (SUCCEEDED(StrAllocHexEncode(pbHash, cbHash, &pszExpected)) &&

1769 - SUCCEEDED(StrAllocHexEncode(rgbActualHash, (SIZE_T)qwHashedBytes, &pszActual)))

1780 + SUCCEEDED(StrAllocHexEncode(rgbActualHash, sizeof(rgbActualHash), &pszActual)))

1781 {

1782 ExitOnFailure(hr, "Hash mismatch for path: %ls, expected: %ls, actual: %ls", wzUnverifiedPayloadPath, pszExpected, pszActual);

1783 }

src/engine/core.cpp

+15 -29

@@ -388,7 +388,7 @@ extern "C" HRESULT CoreDetect(

388 pEngineState->registration.fEligibleForCleanup = FALSE;

389 }

390

391 - LogId(REPORT_STANDARD, MSG_DETECTED_PACKAGE, pPackage->sczId, LoggingPackageStateToString(pPackage->currentState), LoggingCacheStateToString(pPackage->cache), LoggingPackageRegistrationStateToString(pPackage->fCanAffectRegistration, pPackage->installRegistrationState), LoggingPackageRegistrationStateToString(pPackage->fCanAffectRegistration, pPackage->cacheRegistrationState));

391 + LogId(REPORT_STANDARD, MSG_DETECTED_PACKAGE, pPackage->sczId, LoggingPackageStateToString(pPackage->currentState), LoggingBoolToString(pPackage->fCached), LoggingPackageRegistrationStateToString(pPackage->fCanAffectRegistration, pPackage->installRegistrationState), LoggingPackageRegistrationStateToString(pPackage->fCanAffectRegistration, pPackage->cacheRegistrationState));

392

393 if (BURN_PACKAGE_TYPE_MSI == pPackage->type)

394 {

@@ -439,7 +439,6 @@ extern "C" HRESULT CorePlan(

439 HRESULT hr = S_OK;

440 BOOL fPlanBegan = FALSE;

441 LPWSTR sczLayoutDirectory = NULL;

442 - HANDLE hSyncpointEvent = NULL;

442 BURN_PACKAGE* pUpgradeBundlePackage = NULL;

443 BURN_PACKAGE* pForwardCompatibleBundlePackage = NULL;

444 BOOL fContinuePlanning = TRUE; // assume we won't skip planning due to dependencies.

@@ -489,7 +488,7 @@ extern "C" HRESULT CorePlan(

488 ExitOnFailure(hr, "Failed to plan the layout of the bundle.");

489

490 // Plan the packages' layout.

492 - hr = PlanPackages(&pEngineState->userExperience, &pEngineState->packages, &pEngineState->plan, &pEngineState->log, &pEngineState->variables, pEngineState->command.display, pEngineState->command.relationType, sczLayoutDirectory, &hSyncpointEvent);

491 + hr = PlanPackages(&pEngineState->userExperience, &pEngineState->packages, &pEngineState->plan, &pEngineState->log, &pEngineState->variables, pEngineState->command.display, pEngineState->command.relationType, sczLayoutDirectory);

492 ExitOnFailure(hr, "Failed to plan packages.");

493 }

494 else if (BOOTSTRAPPER_ACTION_UPDATE_REPLACE == action || BOOTSTRAPPER_ACTION_UPDATE_REPLACE_EMBEDDED == action)

@@ -498,7 +497,7 @@ extern "C" HRESULT CorePlan(

497

498 pUpgradeBundlePackage = &pEngineState->update.package;

499

501 - hr = PlanUpdateBundle(&pEngineState->userExperience, pUpgradeBundlePackage, &pEngineState->plan, &pEngineState->log, &pEngineState->variables, pEngineState->command.display, pEngineState->command.relationType, &hSyncpointEvent);

500 + hr = PlanUpdateBundle(&pEngineState->userExperience, pUpgradeBundlePackage, &pEngineState->plan, &pEngineState->log, &pEngineState->variables, pEngineState->command.display, pEngineState->command.relationType);

501 ExitOnFailure(hr, "Failed to plan update.");

502 }

503 else

@@ -512,7 +511,7 @@ extern "C" HRESULT CorePlan(

511

512 pForwardCompatibleBundlePackage = &pEngineState->plan.forwardCompatibleBundle;

513

515 - hr = PlanPassThroughBundle(&pEngineState->userExperience, pForwardCompatibleBundlePackage, &pEngineState->plan, &pEngineState->log, &pEngineState->variables, pEngineState->command.display, pEngineState->command.relationType, &hSyncpointEvent);

514 + hr = PlanPassThroughBundle(&pEngineState->userExperience, pForwardCompatibleBundlePackage, &pEngineState->plan, &pEngineState->log, &pEngineState->variables, pEngineState->command.display, pEngineState->command.relationType);

515 ExitOnFailure(hr, "Failed to plan passthrough.");

516 }

517 else // doing an action that modifies the machine state.

@@ -533,11 +532,11 @@ extern "C" HRESULT CorePlan(

532 hr = PlanRelatedBundlesBegin(&pEngineState->userExperience, &pEngineState->registration, pEngineState->command.relationType, &pEngineState->plan);

533 ExitOnFailure(hr, "Failed to plan related bundles.");

534

536 - hr = PlanPackages(&pEngineState->userExperience, &pEngineState->packages, &pEngineState->plan, &pEngineState->log, &pEngineState->variables, pEngineState->command.display, pEngineState->command.relationType, NULL, &hSyncpointEvent);

535 + hr = PlanPackages(&pEngineState->userExperience, &pEngineState->packages, &pEngineState->plan, &pEngineState->log, &pEngineState->variables, pEngineState->command.display, pEngineState->command.relationType, NULL);

536 ExitOnFailure(hr, "Failed to plan packages.");

537

538 // Schedule the update of related bundles last.

540 - hr = PlanRelatedBundlesComplete(&pEngineState->registration, &pEngineState->plan, &pEngineState->log, &pEngineState->variables, &hSyncpointEvent, dwExecuteActionEarlyIndex);

539 + hr = PlanRelatedBundlesComplete(&pEngineState->registration, &pEngineState->plan, &pEngineState->log, &pEngineState->variables, dwExecuteActionEarlyIndex);

540 ExitOnFailure(hr, "Failed to schedule related bundles.");

541 }

542 }

@@ -1669,9 +1668,8 @@ static HRESULT DetectPackagePayloadsCached(

1668 {

1669 HRESULT hr = S_OK;

1670 LPWSTR sczCachePath = NULL;

1672 - BURN_CACHE_STATE cache = BURN_CACHE_STATE_NONE; // assume the package will not be cached.

1671 + BOOL fCached = FALSE; // assume the package is not cached.

1672 LPWSTR sczPayloadCachePath = NULL;

1674 - LONGLONG llSize = 0;

1673

1674 if (pPackage->sczCacheId && *pPackage->sczCacheId)

1675 {

@@ -1681,9 +1679,7 @@ static HRESULT DetectPackagePayloadsCached(

1679 // If the cached directory exists, we have something.

1680 if (DirExists(sczCachePath, NULL))

1681 {

1684 - cache = BURN_CACHE_STATE_COMPLETE; // assume all payloads are cached.

1685 -

1686 - // Check all payloads to see if any are missing or not the right size.

1682 + // Check all payloads to see if they exist.

1683 for (DWORD i = 0; i < pPackage->cPayloads; ++i)

1684 {

1685 BURN_PACKAGE_PAYLOAD* pPackagePayload = pPackage->rgPayloads + i;

@@ -1691,35 +1687,25 @@ static HRESULT DetectPackagePayloadsCached(

1687 hr = PathConcat(sczCachePath, pPackagePayload->pPayload->sczFilePath, &sczPayloadCachePath);

1688 ExitOnFailure(hr, "Failed to concat payload cache path.");

1689

1694 - hr = FileSize(sczPayloadCachePath, &llSize);

1695 - if (SUCCEEDED(hr) && static_cast<DWORD64>(llSize) != pPackagePayload->pPayload->qwFileSize)

1696 - {

1697 - hr = HRESULT_FROM_WIN32(ERROR_FILE_CORRUPT); // size did not match expectations, so cache must have the wrong file.

1698 - }

1699 -

1700 - if (SUCCEEDED(hr))

1690 + if (FileExistsEx(sczPayloadCachePath, NULL))

1691 {

1702 - // TODO: should we do a full on hash verification on the file to ensure

1703 - // the exact right file is cached?

1704 -

1692 + // TODO: We shouldn't track whether the payload was cached since all we did was check whether the file exists.

1693 pPackagePayload->fCached = TRUE;

1694 + fCached = TRUE;

1695 }

1696 else

1697 {

1709 - LogId(REPORT_STANDARD, MSG_DETECT_PACKAGE_NOT_FULLY_CACHED, pPackage->sczId, pPackagePayload->pPayload->sczKey, hr);

1710 -

1711 - cache = BURN_CACHE_STATE_PARTIAL; // found a payload that was not cached so we are partial.

1712 - hr = S_OK;

1698 + LogId(REPORT_STANDARD, MSG_DETECT_PACKAGE_NOT_FULLY_CACHED, pPackage->sczId, pPackagePayload->pPayload->sczKey);

1699 }

1700 }

1701 }

1702 }

1703

1718 - pPackage->cache = cache;

1704 + pPackage->fCached = fCached;

1705

1706 if (pPackage->fCanAffectRegistration)

1707 {

1722 - pPackage->cacheRegistrationState = BURN_CACHE_STATE_NONE < pPackage->cache ? BURN_PACKAGE_REGISTRATION_STATE_PRESENT : BURN_PACKAGE_REGISTRATION_STATE_ABSENT;

1708 + pPackage->cacheRegistrationState = pPackage->fCached ? BURN_PACKAGE_REGISTRATION_STATE_PRESENT : BURN_PACKAGE_REGISTRATION_STATE_ABSENT;

1709 }

1710

1711 LExit:

@@ -1808,7 +1794,7 @@ static void LogPackages(

1794 const DWORD iPackage = (BOOTSTRAPPER_ACTION_UNINSTALL == action) ? pPackages->cPackages - 1 - i : i;

1795 const BURN_PACKAGE* pPackage = &pPackages->rgPackages[iPackage];

1796

1811 - LogId(REPORT_STANDARD, MSG_PLANNED_PACKAGE, pPackage->sczId, LoggingPackageStateToString(pPackage->currentState), LoggingRequestStateToString(pPackage->defaultRequested), LoggingRequestStateToString(pPackage->requested), LoggingActionStateToString(pPackage->execute), LoggingActionStateToString(pPackage->rollback), LoggingBoolToString(pPackage->fAcquire), LoggingBoolToString(pPackage->fUncache), LoggingDependencyActionToString(pPackage->dependencyExecute), LoggingPackageRegistrationStateToString(pPackage->fCanAffectRegistration, pPackage->expectedInstallRegistrationState), LoggingPackageRegistrationStateToString(pPackage->fCanAffectRegistration, pPackage->expectedCacheRegistrationState));

1797 + LogId(REPORT_STANDARD, MSG_PLANNED_PACKAGE, pPackage->sczId, LoggingPackageStateToString(pPackage->currentState), LoggingRequestStateToString(pPackage->defaultRequested), LoggingRequestStateToString(pPackage->requested), LoggingActionStateToString(pPackage->execute), LoggingActionStateToString(pPackage->rollback), LoggingBoolToString(pPackage->fPlannedCache), LoggingBoolToString(pPackage->fPlannedUncache), LoggingDependencyActionToString(pPackage->dependencyExecute), LoggingPackageRegistrationStateToString(pPackage->fCanAffectRegistration, pPackage->expectedInstallRegistrationState), LoggingPackageRegistrationStateToString(pPackage->fCanAffectRegistration, pPackage->expectedCacheRegistrationState));

1798

1799 if (BURN_PACKAGE_TYPE_MSI == pPackage->type)

1800 {

src/engine/detect.cpp

+5 -5

@@ -67,7 +67,7 @@ extern "C" void DetectReset(

67 pPackage->cacheRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_UNKNOWN;

68 pPackage->installRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_UNKNOWN;

70 - pPackage->cache = BURN_CACHE_STATE_NONE;

70 + pPackage->fCached = FALSE;

71 for (DWORD iPayload = 0; iPayload < pPackage->cPayloads; ++iPayload)

72 {

73 BURN_PACKAGE_PAYLOAD* pPayload = pPackage->rgPayloads + iPayload;

@@ -149,10 +149,10 @@ extern "C" HRESULT DetectForwardCompatibleBundles(

149 pRegistration->fForwardCompatibleBundleExists = TRUE;

150 }

151

152 - hr = UserExperienceOnDetectForwardCompatibleBundle(pUX, pRelatedBundle->package.sczId, pRelatedBundle->relationType, pRelatedBundle->sczTag, pRelatedBundle->package.fPerMachine, pRelatedBundle->pVersion, BURN_CACHE_STATE_COMPLETE != pRelatedBundle->package.cache);

152 + hr = UserExperienceOnDetectForwardCompatibleBundle(pUX, pRelatedBundle->package.sczId, pRelatedBundle->relationType, pRelatedBundle->sczTag, pRelatedBundle->package.fPerMachine, pRelatedBundle->pVersion, !pRelatedBundle->package.fCached);

153 ExitOnRootFailure(hr, "BA aborted detect forward compatible bundle.");

154

155 - LogId(REPORT_STANDARD, MSG_DETECTED_FORWARD_COMPATIBLE_BUNDLE, pRelatedBundle->package.sczId, LoggingRelationTypeToString(pRelatedBundle->relationType), LoggingPerMachineToString(pRelatedBundle->package.fPerMachine), pRelatedBundle->pVersion->sczVersion, LoggingCacheStateToString(pRelatedBundle->package.cache));

155 + LogId(REPORT_STANDARD, MSG_DETECTED_FORWARD_COMPATIBLE_BUNDLE, pRelatedBundle->package.sczId, LoggingRelationTypeToString(pRelatedBundle->relationType), LoggingPerMachineToString(pRelatedBundle->package.fPerMachine), pRelatedBundle->pVersion->sczVersion, LoggingBoolToString(pRelatedBundle->package.fCached));

156 }

157 }

158 }

@@ -225,9 +225,9 @@ extern "C" HRESULT DetectReportRelatedBundles(

225 break;

226 }

227

228 - LogId(REPORT_STANDARD, MSG_DETECTED_RELATED_BUNDLE, pRelatedBundle->package.sczId, LoggingRelationTypeToString(pRelatedBundle->relationType), LoggingPerMachineToString(pRelatedBundle->package.fPerMachine), pRelatedBundle->pVersion->sczVersion, LoggingRelatedOperationToString(operation), LoggingCacheStateToString(pRelatedBundle->package.cache));

228 + LogId(REPORT_STANDARD, MSG_DETECTED_RELATED_BUNDLE, pRelatedBundle->package.sczId, LoggingRelationTypeToString(pRelatedBundle->relationType), LoggingPerMachineToString(pRelatedBundle->package.fPerMachine), pRelatedBundle->pVersion->sczVersion, LoggingRelatedOperationToString(operation), LoggingBoolToString(pRelatedBundle->package.fCached));

229

230 - hr = UserExperienceOnDetectRelatedBundle(pUX, pRelatedBundle->package.sczId, pRelatedBundle->relationType, pRelatedBundle->sczTag, pRelatedBundle->package.fPerMachine, pRelatedBundle->pVersion, operation, BURN_CACHE_STATE_COMPLETE != pRelatedBundle->package.cache);

230 + hr = UserExperienceOnDetectRelatedBundle(pUX, pRelatedBundle->package.sczId, pRelatedBundle->relationType, pRelatedBundle->sczTag, pRelatedBundle->package.fPerMachine, pRelatedBundle->pVersion, operation, !pRelatedBundle->package.fCached);

231 ExitOnRootFailure(hr, "BA aborted detect related bundle.");

232

233 // For now, if any related bundles will be executed during uninstall by default then never automatically clean up the bundle.

src/engine/engine.mc

+4 -4

@@ -242,16 +242,16 @@ Detected forward compatible bundle: %1!ls!, type: %2!hs!, scope: %3!hs!, version

242

243 MessageId=108

244 Severity=Warning

245 -SymbolicName=MSG_DETECT_RELATED_BUNDLE_NOT_FULLY_CACHED

245 +SymbolicName=MSG_DETECT_RELATED_BUNDLE_NOT_CACHED

246 Language=English

247 -Detected partially cached related bundle: %1!ls!, cache path: %2!ls!, reason: 0x%3!x!

247 +Detected related bundle missing from cache: %1!ls!, cache path: %2!ls!

248 .

249

250 MessageId=120

251 Severity=Warning

252 SymbolicName=MSG_DETECT_PACKAGE_NOT_FULLY_CACHED

253 Language=English

254 -Detected partially cached package: %1!ls!, invalid payload: %2!ls!, reason: 0x%3!x!

254 +Detected partially cached package: %1!ls!, missing payload: %2!ls!

255 .

256

257 MessageId=121

@@ -363,7 +363,7 @@ MessageId=208

363 Severity=Warning

364 SymbolicName=MSG_PLAN_DISABLING_ROLLBACK_NO_CACHE

365 Language=English

366 -Plan disabled rollback for package: %1!ls!, due to incomplete cache: %2!hs!, original rollback action: %3!hs!

366 +Plan disabled rollback due to incomplete cache for package: %1!ls!, original rollback action: %2!hs!

367 .

368

369 MessageId=209

src/engine/exeengine.cpp

+2 -3

@@ -269,8 +269,7 @@ extern "C" HRESULT ExeEnginePlanAddPackage(

269 __in BURN_PLAN* pPlan,

270 __in BURN_LOGGING* pLog,

271 __in BURN_VARIABLES* pVariables,

272 - __in_opt HANDLE hCacheEvent,

273 - __in BOOL fPlanPackageCacheRollback

272 + __in_opt HANDLE hCacheEvent

273 )

274 {

275 HRESULT hr = S_OK;

@@ -279,7 +278,7 @@ extern "C" HRESULT ExeEnginePlanAddPackage(

278 // add wait for cache

279 if (hCacheEvent)

280 {

282 - hr = PlanExecuteCacheSyncAndRollback(pPlan, pPackage, hCacheEvent, fPlanPackageCacheRollback);

281 + hr = PlanExecuteCacheSyncAndRollback(pPlan, pPackage, hCacheEvent);

282 ExitOnFailure(hr, "Failed to plan package cache syncpoint");

283 }

284

src/engine/exeengine.h

+1 -2

@@ -29,8 +29,7 @@ HRESULT ExeEnginePlanAddPackage(

29 __in BURN_PLAN* pPlan,

30 __in BURN_LOGGING* pLog,

31 __in BURN_VARIABLES* pVariables,

32 - __in_opt HANDLE hCacheEvent,

33 - __in BOOL fPlanPackageCacheRollback

32 + __in_opt HANDLE hCacheEvent

33 );

34 HRESULT ExeEngineExecutePackage(

35 __in BURN_EXECUTE_ACTION* pExecuteAction,

src/engine/externalengine.cpp

+1 -1

@@ -327,7 +327,7 @@ HRESULT ExternalEngineSetUpdate(

327 sczId = pEngineState->registration.sczId;

328 }

329

330 - hr = PseudoBundleInitialize(FILEMAKEVERSION(rmj, rmm, rup, rpr), &pEngineState->update.package, FALSE, sczId, BOOTSTRAPPER_RELATION_UPDATE, BOOTSTRAPPER_PACKAGE_STATE_ABSENT, BURN_CACHE_STATE_NONE, pEngineState->registration.sczExecutableName, sczLocalSource ? sczLocalSource : wzLocalSource, wzDownloadSource, qwSize, TRUE, sczCommandline, NULL, NULL, NULL, rgbHash, cbHash);

330 + hr = PseudoBundleInitialize(FILEMAKEVERSION(rmj, rmm, rup, rpr), &pEngineState->update.package, FALSE, sczId, BOOTSTRAPPER_RELATION_UPDATE, BOOTSTRAPPER_PACKAGE_STATE_ABSENT, FALSE, pEngineState->registration.sczExecutableName, sczLocalSource ? sczLocalSource : wzLocalSource, wzDownloadSource, qwSize, TRUE, sczCommandline, NULL, NULL, NULL, rgbHash, cbHash);

331 ExitOnFailure(hr, "Failed to set update bundle.");

332

333 pEngineState->update.fUpdateAvailable = TRUE;

src/engine/logging.cpp

-17

@@ -426,23 +426,6 @@ extern "C" LPCSTR LoggingPackageRegistrationStateToString(

426 }

427 }

428

429 -extern "C" LPCSTR LoggingCacheStateToString(

430 - __in BURN_CACHE_STATE cacheState

431 - )

432 -{

433 - switch (cacheState)

434 - {

435 - case BURN_CACHE_STATE_NONE:

436 - return "None";

437 - case BURN_CACHE_STATE_PARTIAL:

438 - return "Partial";

439 - case BURN_CACHE_STATE_COMPLETE:

440 - return "Complete";

441 - default:

442 - return "Invalid";

443 - }

444 -}

445 -

429 extern "C" LPCSTR LoggingMsiFeatureStateToString(

430 __in BOOTSTRAPPER_FEATURE_STATE featureState

431 )

src/engine/logging.h

-4

@@ -94,10 +94,6 @@ LPCSTR LoggingPackageRegistrationStateToString(

94 __in BURN_PACKAGE_REGISTRATION_STATE registrationState

95 );

97 -LPCSTR LoggingCacheStateToString(

98 - __in BURN_CACHE_STATE cacheState

99 - );

100 -

97 LPCSTR LoggingMsiFeatureStateToString(

98 __in BOOTSTRAPPER_FEATURE_STATE featureState

99 );

src/engine/msiengine.cpp

+2 -3

@@ -932,8 +932,7 @@ extern "C" HRESULT MsiEnginePlanAddPackage(

932 __in BURN_PLAN* pPlan,

933 __in BURN_LOGGING* pLog,

934 __in BURN_VARIABLES* pVariables,

935 - __in_opt HANDLE hCacheEvent,

936 - __in BOOL fPlanPackageCacheRollback

935 + __in_opt HANDLE hCacheEvent

936 )

937 {

938 HRESULT hr = S_OK;

@@ -963,7 +962,7 @@ extern "C" HRESULT MsiEnginePlanAddPackage(

962 // add wait for cache

963 if (hCacheEvent)

964 {

966 - hr = PlanExecuteCacheSyncAndRollback(pPlan, pPackage, hCacheEvent, fPlanPackageCacheRollback);

965 + hr = PlanExecuteCacheSyncAndRollback(pPlan, pPackage, hCacheEvent);

966 ExitOnFailure(hr, "Failed to plan package cache syncpoint");

967 }

968

src/engine/msiengine.h

+1 -2

@@ -50,8 +50,7 @@ HRESULT MsiEnginePlanAddPackage(

50 __in BURN_PLAN* pPlan,

51 __in BURN_LOGGING* pLog,

52 __in BURN_VARIABLES* pVariables,

53 - __in_opt HANDLE hCacheEvent,

54 - __in BOOL fPlanPackageCacheRollback

53 + __in_opt HANDLE hCacheEvent

54 );

55 HRESULT MsiEngineBeginTransaction(

56 __in BURN_ROLLBACK_BOUNDARY* pRollbackBoundary

src/engine/mspengine.cpp

+2 -3

@@ -506,8 +506,7 @@ extern "C" HRESULT MspEnginePlanAddPackage(

506 __in BURN_PLAN* pPlan,

507 __in BURN_LOGGING* pLog,

508 __in BURN_VARIABLES* pVariables,

509 - __in_opt HANDLE hCacheEvent,

510 - __in BOOL fPlanPackageCacheRollback

509 + __in_opt HANDLE hCacheEvent

510 )

511 {

512 HRESULT hr = S_OK;

@@ -517,7 +516,7 @@ extern "C" HRESULT MspEnginePlanAddPackage(

516 // add wait for cache

517 if (hCacheEvent)

518 {

520 - hr = PlanExecuteCacheSyncAndRollback(pPlan, pPackage, hCacheEvent, fPlanPackageCacheRollback);

519 + hr = PlanExecuteCacheSyncAndRollback(pPlan, pPackage, hCacheEvent);

520 ExitOnFailure(hr, "Failed to plan package cache syncpoint");

521 }

522

src/engine/mspengine.h

+1 -2

@@ -58,8 +58,7 @@ HRESULT MspEnginePlanAddPackage(

58 __in BURN_PLAN* pPlan,

59 __in BURN_LOGGING* pLog,

60 __in BURN_VARIABLES* pVariables,

61 - __in_opt HANDLE hCacheEvent,

62 - __in BOOL fPlanPackageCacheRollback

61 + __in_opt HANDLE hCacheEvent

62 );

63 HRESULT MspEngineExecutePackage(

64 __in_opt HWND hwndParent,

src/engine/msuengine.cpp

+2 -3

@@ -193,8 +193,7 @@ extern "C" HRESULT MsuEnginePlanAddPackage(

193 __in BURN_PLAN* pPlan,

194 __in BURN_LOGGING* pLog,

195 __in BURN_VARIABLES* pVariables,

196 - __in HANDLE hCacheEvent,

197 - __in BOOL fPlanPackageCacheRollback

196 + __in HANDLE hCacheEvent

197 )

198 {

199 HRESULT hr = S_OK;

@@ -203,7 +202,7 @@ extern "C" HRESULT MsuEnginePlanAddPackage(

202 // add wait for cache

203 if (hCacheEvent)

204 {

206 - hr = PlanExecuteCacheSyncAndRollback(pPlan, pPackage, hCacheEvent, fPlanPackageCacheRollback);

205 + hr = PlanExecuteCacheSyncAndRollback(pPlan, pPackage, hCacheEvent);

206 ExitOnFailure(hr, "Failed to plan package cache syncpoint");

207 }

208

src/engine/msuengine.h

+1 -2

@@ -28,8 +28,7 @@ HRESULT MsuEnginePlanAddPackage(

28 __in BURN_PLAN* pPlan,

29 __in BURN_LOGGING* pLog,

30 __in BURN_VARIABLES* pVariables,

31 - __in HANDLE hCacheEvent,

32 - __in BOOL fPlanPackageCacheRollback

31 + __in HANDLE hCacheEvent

32 );

33 HRESULT MsuEngineExecutePackage(

34 __in BURN_EXECUTE_ACTION* pExecuteAction,

src/engine/package.h

+3 -10

@@ -41,13 +41,6 @@ enum BURN_PACKAGE_TYPE

41 BURN_PACKAGE_TYPE_MSU,

42 };

44 -enum BURN_CACHE_STATE

45 -{

46 - BURN_CACHE_STATE_NONE,

47 - BURN_CACHE_STATE_PARTIAL,

48 - BURN_CACHE_STATE_COMPLETE,

49 -};

50 -

44 enum BURN_CACHE_TYPE

45 {

46 BURN_CACHE_TYPE_NO,

@@ -246,12 +239,12 @@ typedef struct _BURN_PACKAGE

239 BURN_ROLLBACK_BOUNDARY* pRollbackBoundaryBackward; // used during uninstall.

240

241 BOOTSTRAPPER_PACKAGE_STATE currentState; // only valid after Detect.

249 - BURN_CACHE_STATE cache; // only valid after Detect.

242 + BOOL fCached; // only valid after Detect.

243 BOOL fPackageProviderExists; // only valid after Detect.

244 BOOTSTRAPPER_REQUEST_STATE defaultRequested;// only valid during Plan.

245 BOOTSTRAPPER_REQUEST_STATE requested; // only valid during Plan.

253 - BOOL fAcquire; // only valid during Plan.

254 - BOOL fUncache; // only valid during Plan.

246 + BOOL fPlannedCache; // only valid during Plan.

247 + BOOL fPlannedUncache; // only valid during Plan.

248 BOOTSTRAPPER_ACTION_STATE execute; // only valid during Plan.

249 BOOTSTRAPPER_ACTION_STATE rollback; // only valid during Plan.

250 BURN_DEPENDENCY_ACTION providerExecute; // only valid during Plan.

src/engine/plan.cpp

+31 -45

@@ -31,8 +31,7 @@ static HRESULT PlanPackagesHelper(

31 __in BURN_VARIABLES* pVariables,

32 __in BOOTSTRAPPER_DISPLAY display,

33 __in BOOTSTRAPPER_RELATION_TYPE relationType,

34 - __in_z_opt LPCWSTR wzLayoutDirectory,

35 - __inout HANDLE* phSyncpointEvent

34 + __in_z_opt LPCWSTR wzLayoutDirectory

35 );

36 static HRESULT InitializePackage(

37 __in BURN_PLAN* pPlan,

@@ -564,13 +563,12 @@ extern "C" HRESULT PlanPackages(

563 __in BURN_VARIABLES* pVariables,

564 __in BOOTSTRAPPER_DISPLAY display,

565 __in BOOTSTRAPPER_RELATION_TYPE relationType,

567 - __in_z_opt LPCWSTR wzLayoutDirectory,

568 - __inout HANDLE* phSyncpointEvent

566 + __in_z_opt LPCWSTR wzLayoutDirectory

567 )

568 {

569 HRESULT hr = S_OK;

570

573 - hr = PlanPackagesHelper(pPackages->rgPackages, pPackages->cPackages, TRUE, pUX, pPlan, pLog, pVariables, display, relationType, wzLayoutDirectory, phSyncpointEvent);

571 + hr = PlanPackagesHelper(pPackages->rgPackages, pPackages->cPackages, TRUE, pUX, pPlan, pLog, pVariables, display, relationType, wzLayoutDirectory);

572

573 return hr;

574 }

@@ -776,8 +774,7 @@ extern "C" HRESULT PlanPassThroughBundle(

774 __in BURN_LOGGING* pLog,

775 __in BURN_VARIABLES* pVariables,

776 __in BOOTSTRAPPER_DISPLAY display,

779 - __in BOOTSTRAPPER_RELATION_TYPE relationType,

780 - __inout HANDLE* phSyncpointEvent

777 + __in BOOTSTRAPPER_RELATION_TYPE relationType

778 )

779 {

780 HRESULT hr = S_OK;

@@ -785,7 +782,7 @@ extern "C" HRESULT PlanPassThroughBundle(

782 // Plan passthrough package.

783 // Passthrough packages are never cleaned up by the calling bundle (they delete themselves when appropriate)

784 // so we don't need to plan clean up.

788 - hr = PlanPackagesHelper(pPackage, 1, FALSE, pUX, pPlan, pLog, pVariables, display, relationType, NULL, phSyncpointEvent);

785 + hr = PlanPackagesHelper(pPackage, 1, FALSE, pUX, pPlan, pLog, pVariables, display, relationType, NULL);

786 ExitOnFailure(hr, "Failed to process passthrough package.");

787

788 LExit:

@@ -799,14 +796,13 @@ extern "C" HRESULT PlanUpdateBundle(

796 __in BURN_LOGGING* pLog,

797 __in BURN_VARIABLES* pVariables,

798 __in BOOTSTRAPPER_DISPLAY display,

802 - __in BOOTSTRAPPER_RELATION_TYPE relationType,

803 - __inout HANDLE* phSyncpointEvent

799 + __in BOOTSTRAPPER_RELATION_TYPE relationType

800 )

801 {

802 HRESULT hr = S_OK;

803

804 // Plan update package.

809 - hr = PlanPackagesHelper(pPackage, 1, TRUE, pUX, pPlan, pLog, pVariables, display, relationType, NULL, phSyncpointEvent);

805 + hr = PlanPackagesHelper(pPackage, 1, TRUE, pUX, pPlan, pLog, pVariables, display, relationType, NULL);

806 ExitOnFailure(hr, "Failed to process update package.");

807

808 LExit:

@@ -823,13 +819,13 @@ static HRESULT PlanPackagesHelper(

819 __in BURN_VARIABLES* pVariables,

820 __in BOOTSTRAPPER_DISPLAY display,

821 __in BOOTSTRAPPER_RELATION_TYPE relationType,

826 - __in_z_opt LPCWSTR wzLayoutDirectory,

827 - __inout HANDLE* phSyncpointEvent

822 + __in_z_opt LPCWSTR wzLayoutDirectory

823 )

824 {

825 HRESULT hr = S_OK;

826 BOOL fBundlePerMachine = pPlan->fPerMachine; // bundle is per-machine if plan starts per-machine.

827 BURN_ROLLBACK_BOUNDARY* pRollbackBoundary = NULL;

828 + HANDLE hSyncpointEvent = NULL;

829

830 // Initialize the packages.

831 for (DWORD i = 0; i < cPackages; ++i)

@@ -860,7 +856,7 @@ static HRESULT PlanPackagesHelper(

856 DWORD iPackage = (BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action) ? cPackages - 1 - i : i;

857 BURN_PACKAGE* pPackage = rgPackages + iPackage;

858

863 - hr = ProcessPackage(fBundlePerMachine, pUX, pPlan, pPackage, pLog, pVariables, display, wzLayoutDirectory, phSyncpointEvent, &pRollbackBoundary);

859 + hr = ProcessPackage(fBundlePerMachine, pUX, pPlan, pPackage, pLog, pVariables, display, wzLayoutDirectory, &hSyncpointEvent, &pRollbackBoundary);

860 ExitOnFailure(hr, "Failed to process package.");

861 }

862

@@ -1126,10 +1122,11 @@ extern "C" HRESULT PlanExecutePackage(

1122 hr = AddCachePackage(pPlan, pPackage, phSyncpointEvent);

1123 ExitOnFailure(hr, "Failed to plan cache package.");

1124 }

1129 - else if (BURN_CACHE_STATE_COMPLETE != pPackage->cache && NeedsCache(pPackage, FALSE))

1125 + else if (!pPackage->fCached && NeedsCache(pPackage, FALSE))

1126 {

1127 + // TODO: this decision should be made during apply instead of plan based on whether the package is actually cached.

1128 // If the package is not in the cache, disable any rollback that would require the package from the cache.

1132 - LogId(REPORT_STANDARD, MSG_PLAN_DISABLING_ROLLBACK_NO_CACHE, pPackage->sczId, LoggingCacheStateToString(pPackage->cache), LoggingActionStateToString(pPackage->rollback));

1129 + LogId(REPORT_STANDARD, MSG_PLAN_DISABLING_ROLLBACK_NO_CACHE, pPackage->sczId, LoggingActionStateToString(pPackage->rollback));

1130 pPackage->rollback = BOOTSTRAPPER_ACTION_STATE_NONE;

1131 }

1132

@@ -1162,19 +1159,19 @@ extern "C" HRESULT PlanExecutePackage(

1159 switch (pPackage->type)

1160 {

1161 case BURN_PACKAGE_TYPE_EXE:

1165 - hr = ExeEnginePlanAddPackage(NULL, pPackage, pPlan, pLog, pVariables, *phSyncpointEvent, pPackage->fAcquire);

1162 + hr = ExeEnginePlanAddPackage(NULL, pPackage, pPlan, pLog, pVariables, *phSyncpointEvent);

1163 break;

1164

1165 case BURN_PACKAGE_TYPE_MSI:

1169 - hr = MsiEnginePlanAddPackage(display, pUserExperience, pPackage, pPlan, pLog, pVariables, *phSyncpointEvent, pPackage->fAcquire);

1166 + hr = MsiEnginePlanAddPackage(display, pUserExperience, pPackage, pPlan, pLog, pVariables, *phSyncpointEvent);

1167 break;

1168

1169 case BURN_PACKAGE_TYPE_MSP:

1173 - hr = MspEnginePlanAddPackage(display, pUserExperience, pPackage, pPlan, pLog, pVariables, *phSyncpointEvent, pPackage->fAcquire);

1170 + hr = MspEnginePlanAddPackage(display, pUserExperience, pPackage, pPlan, pLog, pVariables, *phSyncpointEvent);

1171 break;

1172

1173 case BURN_PACKAGE_TYPE_MSU:

1177 - hr = MsuEnginePlanAddPackage(pPackage, pPlan, pLog, pVariables, *phSyncpointEvent, pPackage->fAcquire);

1174 + hr = MsuEnginePlanAddPackage(pPackage, pPlan, pLog, pVariables, *phSyncpointEvent);

1175 break;

1176

1177 default:

@@ -1368,7 +1365,6 @@ extern "C" HRESULT PlanRelatedBundlesComplete(

1365 __in BURN_PLAN* pPlan,

1366 __in BURN_LOGGING* pLog,

1367 __in BURN_VARIABLES* pVariables,

1371 - __inout HANDLE* phSyncpointEvent,

1368 __in DWORD dwExecuteActionEarlyIndex

1369 )

1370 {

@@ -1488,7 +1484,7 @@ extern "C" HRESULT PlanRelatedBundlesComplete(

1484 }

1485 }

1486

1491 - hr = ExeEnginePlanAddPackage(pdwInsertIndex, &pRelatedBundle->package, pPlan, pLog, pVariables, *phSyncpointEvent, FALSE);

1487 + hr = ExeEnginePlanAddPackage(pdwInsertIndex, &pRelatedBundle->package, pPlan, pLog, pVariables, NULL);

1488 ExitOnFailure(hr, "Failed to add to plan related bundle: %ls", pRelatedBundle->package.sczId);

1489

1490 // Calculate package states based on reference count for addon and patch related bundles.

@@ -1560,11 +1556,8 @@ extern "C" HRESULT PlanCleanPackage(

1556 BOOL fPlanCleanPackage = FALSE;

1557 BURN_CLEAN_ACTION* pCleanAction = NULL;

1558

1563 - // The following is a complex set of logic that determines when a package should be cleaned

1564 - // from the cache. Start by noting that we only clean if the package is being acquired or

1565 - // already cached and the package is not supposed to always be cached.

1566 - if ((pPackage->fAcquire || BURN_CACHE_STATE_PARTIAL == pPackage->cache || BURN_CACHE_STATE_COMPLETE == pPackage->cache) &&

1567 - (BURN_CACHE_TYPE_ALWAYS > pPackage->cacheType || BOOTSTRAPPER_ACTION_CACHE > pPlan->action))

1559 + // The following is a complex set of logic that determines when a package should be cleaned from the cache.

1560 + if (BURN_CACHE_TYPE_ALWAYS > pPackage->cacheType || BOOTSTRAPPER_ACTION_CACHE > pPlan->action)

1561 {

1562 // The following are all different reasons why the package should be cleaned from the cache.

1563 // The else-ifs are used to make the conditions easier to see (rather than have them combined

@@ -1607,7 +1600,7 @@ extern "C" HRESULT PlanCleanPackage(

1600

1601 pCleanAction->pPackage = pPackage;

1602

1610 - pPackage->fUncache = TRUE;

1603 + pPackage->fPlannedUncache = TRUE;

1604

1605 if (pPackage->fCanAffectRegistration)

1606 {

@@ -1622,8 +1615,7 @@ LExit:

1615 extern "C" HRESULT PlanExecuteCacheSyncAndRollback(

1616 __in BURN_PLAN* pPlan,

1617 __in BURN_PACKAGE* pPackage,

1625 - __in HANDLE hCacheEvent,

1626 - __in BOOL fPlanPackageCacheRollback

1618 + __in HANDLE hCacheEvent

1619 )

1620 {

1621 HRESULT hr = S_OK;

@@ -1635,17 +1627,14 @@ extern "C" HRESULT PlanExecuteCacheSyncAndRollback(

1627 pAction->type = BURN_EXECUTE_ACTION_TYPE_WAIT_SYNCPOINT;

1628 pAction->syncpoint.hEvent = hCacheEvent;

1629

1638 - if (fPlanPackageCacheRollback)

1639 - {

1640 - hr = PlanAppendRollbackAction(pPlan, &pAction);

1641 - ExitOnFailure(hr, "Failed to append rollback action.");

1630 + hr = PlanAppendRollbackAction(pPlan, &pAction);

1631 + ExitOnFailure(hr, "Failed to append rollback action.");

1632

1643 - pAction->type = BURN_EXECUTE_ACTION_TYPE_UNCACHE_PACKAGE;

1644 - pAction->uncachePackage.pPackage = pPackage;

1633 + pAction->type = BURN_EXECUTE_ACTION_TYPE_UNCACHE_PACKAGE;

1634 + pAction->uncachePackage.pPackage = pPackage;

1635

1646 - hr = PlanExecuteCheckpoint(pPlan);

1647 - ExitOnFailure(hr, "Failed to append execute checkpoint for cache rollback.");

1648 - }

1636 + hr = PlanExecuteCheckpoint(pPlan);

1637 + ExitOnFailure(hr, "Failed to append execute checkpoint for cache rollback.");

1638

1639 LExit:

1640 return hr;

@@ -1895,8 +1884,8 @@ static void ResetPlannedPackageState(

1884 // Reset package state that is a result of planning.

1885 pPackage->defaultRequested = BOOTSTRAPPER_REQUEST_STATE_NONE;

1886 pPackage->requested = BOOTSTRAPPER_REQUEST_STATE_NONE;

1898 - pPackage->fAcquire = FALSE;

1899 - pPackage->fUncache = FALSE;

1887 + pPackage->fPlannedCache = FALSE;

1888 + pPackage->fPlannedUncache = FALSE;

1889 pPackage->execute = BOOTSTRAPPER_ACTION_STATE_NONE;

1890 pPackage->rollback = BOOTSTRAPPER_ACTION_STATE_NONE;

1891 pPackage->providerExecute = BURN_DEPENDENCY_ACTION_NONE;

@@ -2191,10 +2180,7 @@ static HRESULT AddCachePackageHelper(

2180

2181 ++pPlan->cOverallProgressTicksTotal;

2182

2194 - // If the package was not already fully cached then note that we planned the cache here. Otherwise, we only

2195 - // did cache operations to verify the cache is valid so we did not plan the acquisition of the package.

2196 - pPackage->fAcquire = (BURN_CACHE_STATE_COMPLETE != pPackage->cache);

2197 -

2183 + pPackage->fPlannedCache = TRUE;

2184 if (pPackage->fCanAffectRegistration)

2185 {

2186 pPackage->expectedCacheRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_PRESENT;

src/engine/plan.h

+4 -9

@@ -411,8 +411,7 @@ HRESULT PlanPackages(

411 __in BURN_VARIABLES* pVariables,

412 __in BOOTSTRAPPER_DISPLAY display,

413 __in BOOTSTRAPPER_RELATION_TYPE relationType,

414 - __in_z_opt LPCWSTR wzLayoutDirectory,

415 - __inout HANDLE* phSyncpointEvent

414 + __in_z_opt LPCWSTR wzLayoutDirectory

415 );

416 HRESULT PlanRegistration(

417 __in BURN_PLAN* pPlan,

@@ -428,8 +427,7 @@ HRESULT PlanPassThroughBundle(

427 __in BURN_LOGGING* pLog,

428 __in BURN_VARIABLES* pVariables,

429 __in BOOTSTRAPPER_DISPLAY display,

431 - __in BOOTSTRAPPER_RELATION_TYPE relationType,

432 - __inout HANDLE* phSyncpointEvent

430 + __in BOOTSTRAPPER_RELATION_TYPE relationType

431 );

432 HRESULT PlanUpdateBundle(

433 __in BURN_USER_EXPERIENCE* pUX,

@@ -438,8 +436,7 @@ HRESULT PlanUpdateBundle(

436 __in BURN_LOGGING* pLog,

437 __in BURN_VARIABLES* pVariables,

438 __in BOOTSTRAPPER_DISPLAY display,

441 - __in BOOTSTRAPPER_RELATION_TYPE relationType,

442 - __inout HANDLE* phSyncpointEvent

439 + __in BOOTSTRAPPER_RELATION_TYPE relationType

440 );

441 HRESULT PlanLayoutPackage(

442 __in BURN_PLAN* pPlan,

@@ -475,7 +472,6 @@ HRESULT PlanRelatedBundlesComplete(

472 __in BURN_PLAN* pPlan,

473 __in BURN_LOGGING* pLog,

474 __in BURN_VARIABLES* pVariables,

478 - __inout HANDLE* phSyncpointEvent,

475 __in DWORD dwExecuteActionEarlyIndex

476 );

477 HRESULT PlanFinalizeActions(

@@ -488,8 +484,7 @@ HRESULT PlanCleanPackage(

484 HRESULT PlanExecuteCacheSyncAndRollback(

485 __in BURN_PLAN* pPlan,

486 __in BURN_PACKAGE* pPackage,

491 - __in HANDLE hCacheEvent,

492 - __in BOOL fPlanPackageCacheRollback

487 + __in HANDLE hCacheEvent

488 );

489 HRESULT PlanExecuteCheckpoint(

490 __in BURN_PLAN* pPlan

src/engine/pseudobundle.cpp

+4 -4

@@ -10,7 +10,7 @@ extern "C" HRESULT PseudoBundleInitialize(

10 __in_z LPCWSTR wzId,

11 __in BOOTSTRAPPER_RELATION_TYPE relationType,

12 __in BOOTSTRAPPER_PACKAGE_STATE state,

13 - __in BURN_CACHE_STATE cacheState,

13 + __in BOOL fCached,

14 __in_z LPCWSTR wzFilePath,

15 __in_z LPCWSTR wzLocalSource,

16 __in_z_opt LPCWSTR wzDownloadSource,

@@ -67,14 +67,14 @@ extern "C" HRESULT PseudoBundleInitialize(

67 memcpy_s(pPackage->rgPayloads->pPayload->pbHash, pPackage->rgPayloads->pPayload->cbHash, pbHash, cbHash);

68 }

70 - pPackage->rgPayloads->fCached = BURN_CACHE_STATE_NONE < cacheState;

70 + pPackage->rgPayloads->fCached = fCached;

72 pPackage->Exe.fPseudoBundle = TRUE;

74 pPackage->type = BURN_PACKAGE_TYPE_EXE;

75 pPackage->fPerMachine = fPerMachine;

76 pPackage->currentState = state;

77 - pPackage->cache = cacheState;

77 + pPackage->fCached = fCached;

78 pPackage->qwInstallSize = qwSize;

79 pPackage->qwSize = qwSize;

80 pPackage->fVital = fVital;

@@ -216,7 +216,7 @@ extern "C" HRESULT PseudoBundleInitializePassthrough(

216 pPassthroughPackage->fPerMachine = FALSE; // passthrough bundles are always launched per-user.

217 pPassthroughPackage->type = pPackage->type;

218 pPassthroughPackage->currentState = pPackage->currentState;

219 - pPassthroughPackage->cache = pPackage->cache;

219 + pPassthroughPackage->fCached = pPackage->fCached;

220 pPassthroughPackage->qwInstallSize = pPackage->qwInstallSize;

221 pPassthroughPackage->qwSize = pPackage->qwSize;

222 pPassthroughPackage->fVital = pPackage->fVital;

src/engine/pseudobundle.h

+1 -1

@@ -13,7 +13,7 @@ HRESULT PseudoBundleInitialize(

13 __in_z LPCWSTR wzId,

14 __in BOOTSTRAPPER_RELATION_TYPE relationType,

15 __in BOOTSTRAPPER_PACKAGE_STATE state,

16 - __in BURN_CACHE_STATE cacheState,

16 + __in BOOL fCached,

17 __in_z LPCWSTR wzFilePath,

18 __in_z LPCWSTR wzLocalSource,

19 __in_z_opt LPCWSTR wzDownloadSource,

src/engine/relatedbundle.cpp

+8 -11

@@ -391,14 +391,14 @@ static HRESULT LoadRelatedBundleFromKey(

391 __in HKEY hkBundleId,

392 __in BOOL fPerMachine,

393 __in BOOTSTRAPPER_RELATION_TYPE relationType,

394 - __inout BURN_RELATED_BUNDLE *pRelatedBundle

394 + __inout BURN_RELATED_BUNDLE* pRelatedBundle

395 )

396 {

397 HRESULT hr = S_OK;

398 DWORD64 qwEngineVersion = 0;

399 LPWSTR sczBundleVersion = NULL;

400 LPWSTR sczCachePath = NULL;

401 - BURN_CACHE_STATE cacheState = BURN_CACHE_STATE_NONE;

401 + BOOL fCached = FALSE;

402 DWORD64 qwFileSize = 0;

403 BURN_DEPENDENCY_PROVIDER dependencyProvider = { };

404

@@ -423,19 +423,16 @@ static HRESULT LoadRelatedBundleFromKey(

423 hr = RegReadString(hkBundleId, BURN_REGISTRATION_REGISTRY_BUNDLE_CACHE_PATH, &sczCachePath);

424 ExitOnFailure(hr, "Failed to read cache path from registry for bundle: %ls", wzRelatedBundleId);

425

426 - hr = FileSize(sczCachePath, reinterpret_cast<LONGLONG *>(&qwFileSize));

427 - if (SUCCEEDED(hr))

426 + if (FileExistsEx(sczCachePath, NULL))

427 {

429 - cacheState = BURN_CACHE_STATE_COMPLETE;

428 + fCached = TRUE;

429 }

431 - else if (E_FILENOTFOUND != hr)

430 + else

431 {

433 - cacheState = BURN_CACHE_STATE_PARTIAL;

434 - LogId(REPORT_STANDARD, MSG_DETECT_RELATED_BUNDLE_NOT_FULLY_CACHED, wzRelatedBundleId, sczCachePath, hr);

432 + LogId(REPORT_STANDARD, MSG_DETECT_RELATED_BUNDLE_NOT_CACHED, wzRelatedBundleId, sczCachePath);

433 }

436 - hr = S_OK;

434

438 - pRelatedBundle->fPlannable = BURN_CACHE_STATE_COMPLETE == cacheState;

435 + pRelatedBundle->fPlannable = fCached;

436

437 hr = RegReadString(hkBundleId, BURN_REGISTRATION_REGISTRY_BUNDLE_PROVIDER_KEY, &dependencyProvider.sczKey);

438 if (E_FILENOTFOUND != hr)

@@ -464,7 +461,7 @@ static HRESULT LoadRelatedBundleFromKey(

461 pRelatedBundle->relationType = relationType;

462

463 hr = PseudoBundleInitialize(qwEngineVersion, &pRelatedBundle->package, fPerMachine, wzRelatedBundleId, pRelatedBundle->relationType,

467 - BOOTSTRAPPER_PACKAGE_STATE_PRESENT, cacheState, sczCachePath, sczCachePath, NULL, qwFileSize, FALSE,

464 + BOOTSTRAPPER_PACKAGE_STATE_PRESENT, fCached, sczCachePath, sczCachePath, NULL, qwFileSize, FALSE,

465 L"-quiet", L"-repair -quiet", L"-uninstall -quiet",

466 (dependencyProvider.sczKey && *dependencyProvider.sczKey) ? &dependencyProvider : NULL,

467 NULL, 0);

src/test/BurnUnitTest/PlanTest.cpp

+3 -4

@@ -127,7 +127,6 @@ namespace Bootstrapper

127 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);

128 ValidateExecuteCommitMsiTransaction(pPlan, fRollback, dwIndex++, L"rbaOCA08D8ky7uBOK71_6FWz1K3TuQ");

129 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);

130 - ValidateExecuteWaitSyncpoint(pPlan, fRollback, dwIndex++, pPlan->rgCacheActions[23].syncpoint.hEvent);

130 ValidateExecuteExePackage(pPlan, fRollback, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, NULL);

131 Assert::Equal(dwIndex, pPlan->cExecuteActions);

132

@@ -509,7 +508,6 @@ namespace Bootstrapper

508 ValidateExecutePackageDependency(pPlan, fRollback, dwIndex++, L"PackageA", L"{A6F0CBF7-1578-450C-B9D7-9CF2EEC40002}", BURN_DEPENDENCY_ACTION_REGISTER);

509 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);

510 ValidateExecuteCheckpoint(pPlan, fRollback, dwIndex++, dwExecuteCheckpointId++);

512 - ValidateExecuteWaitSyncpoint(pPlan, fRollback, dwIndex++, pPlan->rgCacheActions[6].syncpoint.hEvent);

511 ValidateExecuteExePackage(pPlan, fRollback, dwIndex++, L"{FD9920AD-DBCA-4C6C-8CD5-B47431CE8D21}", BOOTSTRAPPER_ACTION_STATE_UNINSTALL, NULL);

512 Assert::Equal(dwIndex, pPlan->cExecuteActions);

513

@@ -593,6 +591,7 @@ namespace Bootstrapper

591 Assert::Equal(0ul, pPlan->cOverallProgressTicksTotal);

592

593 dwIndex = 0;

594 + ValidateCleanAction(pPlan, dwIndex++, L"PackageA");

595 Assert::Equal(dwIndex, pPlan->cCleanActions);

596

597 UINT uIndex = 0;

@@ -1042,7 +1041,7 @@ namespace Bootstrapper

1041 void DetectPackageAsPresentAndCached(BURN_PACKAGE* pPackage)

1042 {

1043 pPackage->currentState = BOOTSTRAPPER_PACKAGE_STATE_PRESENT;

1045 - pPackage->cache = BURN_CACHE_STATE_COMPLETE;

1044 + pPackage->fCached = TRUE;

1045 if (pPackage->fCanAffectRegistration)

1046 {

1047 pPackage->cacheRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_PRESENT;

@@ -1158,7 +1157,7 @@ namespace Bootstrapper

1157 pRelatedBundle->fPlannable = TRUE;

1158 pRelatedBundle->relationType = BOOTSTRAPPER_RELATION_UPGRADE;

1159

1161 - hr = PseudoBundleInitialize(0, &pRelatedBundle->package, TRUE, wzId, pRelatedBundle->relationType, BOOTSTRAPPER_PACKAGE_STATE_PRESENT, BURN_CACHE_STATE_COMPLETE, NULL, NULL, NULL, 0, FALSE, L"-quiet", L"-repair -quiet", L"-uninstall -quiet", &dependencyProvider, NULL, 0);

1160 + hr = PseudoBundleInitialize(0, &pRelatedBundle->package, TRUE, wzId, pRelatedBundle->relationType, BOOTSTRAPPER_PACKAGE_STATE_PRESENT, TRUE, NULL, NULL, NULL, 0, FALSE, L"-quiet", L"-repair -quiet", L"-uninstall -quiet", &dependencyProvider, NULL, 0);

1161 NativeAssert::Succeeded(hr, "Failed to initialize related bundle to represent bundle: %ls", wzId);

1162

1163 ++pRelatedBundles->cRelatedBundles;