internal void EnsurePackage(IPackageCacheRepository cacheRepository) { // OData caches instances of DataServicePackage while updating their property values. As a result, // the ZipPackage that we downloaded may no longer be valid (as indicated by a newer hash). // When using MachineCache, once we've verified that the hashes match (which happens the first time around), // we'll simply verify the file exists between successive calls. IPackageMetadata packageMetadata = this; bool refreshPackage = _package == null || (_package is OptimizedZipPackage && !((OptimizedZipPackage)_package).IsValid) || !String.Equals(OldHash, PackageHash, StringComparison.OrdinalIgnoreCase) || (_usingMachineCache && !cacheRepository.Exists(Id, packageMetadata.Version)); if (refreshPackage && TryGetPackage(cacheRepository, packageMetadata, out _package) && _package.GetHash(HashProvider).Equals(PackageHash, StringComparison.OrdinalIgnoreCase)) { OldHash = PackageHash; // Reset the flag so that we no longer need to download the package since it exists and is valid. refreshPackage = false; // Make a note that the backing store for the ZipPackage is the machine cache. _usingMachineCache = true; } if (refreshPackage) { // We either do not have a package available locally or they are invalid. Download the package from the server. _usingMachineCache = cacheRepository.InvokeOnPackage(packageMetadata.Id, packageMetadata.Version, (stream) => Downloader.DownloadPackage(DownloadUrl, this, stream) ); if (_usingMachineCache) { _package = cacheRepository.FindPackage(packageMetadata.Id, packageMetadata.Version); Debug.Assert(_package != null); } else { // this can happen when access to the %LocalAppData% directory is blocked, e.g. on Windows Azure Web Site build using (var targetStream = new MemoryStream()) { Downloader.DownloadPackage(DownloadUrl, this, targetStream); targetStream.Seek(0, SeekOrigin.Begin); _package = new ZipPackage(targetStream); } } OldHash = PackageHash; } }
internal void EnsurePackage(IPackageCacheRepository cacheRepository) { // OData caches instances of DataServicePackage while updating their property values. As a result, // the ZipPackage that we downloaded may no longer be valid (as indicated by a newer hash). // When using MachineCache, once we've verified that the hashes match (which happens the first time around), // we'll simply verify the file exists between successive calls. IPackageMetadata packageMetadata = this; bool refreshPackage = _package == null || (_package is OptimizedZipPackage && !((OptimizedZipPackage)_package).IsValid) || !String.Equals(OldHash, PackageHash, StringComparison.OrdinalIgnoreCase) || (_usingMachineCache && !cacheRepository.Exists(Id, packageMetadata.Version)); if (refreshPackage && TryGetPackage(cacheRepository, packageMetadata, out _package) && _package.GetHash(HashProvider).Equals(PackageHash, StringComparison.OrdinalIgnoreCase)) { OldHash = PackageHash; // Reset the flag so that we no longer need to download the package since it exists and is valid. refreshPackage = false; // Make a note that the backing store for the ZipPackage is the machine cache. _usingMachineCache = true; } if (refreshPackage) { using (Stream targetStream = cacheRepository.CreatePackageStream(packageMetadata.Id, packageMetadata.Version)) { // We either do not have a package available locally or they are invalid. Download the package from the server. Downloader.DownloadPackage(DownloadUrl, this, targetStream); } _package = cacheRepository.FindPackage(packageMetadata.Id, packageMetadata.Version); // Make a note that we are using an in-memory instance of the package. _usingMachineCache = false; OldHash = PackageHash; } }
internal void EnsurePackage(IPackageCacheRepository cacheRepository) { // OData caches instances of DataServicePackage while updating their property values. As a result, // the ZipPackage that we downloaded may no longer be valid (as indicated by a newer hash). // When using MachineCache, once we've verified that the hashes match (which happens the first time around), // we'll simply verify the file exists between successive calls. IPackageMetadata packageMetadata = this; if (_package == null || (_package is OptimizedZipPackage && !((OptimizedZipPackage)_package).IsValid) || !String.Equals(OldHash, PackageHash, StringComparison.OrdinalIgnoreCase) || (_usingMachineCache && !cacheRepository.Exists(Id, packageMetadata.Version))) { IPackage newPackage = null; bool inMemOnly = false; bool isValid = false; // If the package exists in the cache and has the correct hash then use it. Otherwise download it. if (TryGetPackage(cacheRepository, packageMetadata, out newPackage) && MatchPackageHash(newPackage)) { isValid = true; } else { // We either do not have a package available locally or they are invalid. Download the package from the server. if (cacheRepository.InvokeOnPackage(packageMetadata.Id, packageMetadata.Version, (stream) => Downloader.DownloadPackage(DownloadUrl, this, stream))) { newPackage = cacheRepository.FindPackage(packageMetadata.Id, packageMetadata.Version); Debug.Assert(newPackage != null); } else { // this can happen when access to the %LocalAppData% directory is blocked, e.g. on Windows Azure Web Site build using (var targetStream = new MemoryStream()) { Downloader.DownloadPackage(DownloadUrl, this, targetStream); targetStream.Seek(0, SeekOrigin.Begin); newPackage = new ZipPackage(targetStream); } inMemOnly = true; } // Because of CDN caching, the hash returned in odata feed // can be out of sync with the hash of the file itself. // So for now, we cannot call MatchPackageHash(newPackage) to // validate that the file downloaded has the right hash. isValid = true; } // apply the changes if the package hash was valid if (isValid) { _package = newPackage; // Make a note that the backing store for the ZipPackage is the machine cache. _usingMachineCache = !inMemOnly; OldHash = PackageHash; } else { // ensure package must end with a valid package, since we cannot load one we must throw. throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, NuGetResources.Error_InvalidPackage, Version, Id)); } } }
internal void EnsurePackage(IPackageCacheRepository cacheRepository) { // OData caches instances of DataServicePackage while updating their property values. As a result, // the ZipPackage that we downloaded may no longer be valid (as indicated by a newer hash). // When using MachineCache, once we've verified that the hashes match (which happens the first time around), // we'll simply verify the file exists between successive calls. IPackageMetadata packageMetadata = this; bool refreshPackage = _package == null || (_package is OptimizedZipPackage && !((OptimizedZipPackage)_package).IsValid) || !String.Equals(OldHash, PackageHash, StringComparison.OrdinalIgnoreCase) || (_usingMachineCache && !cacheRepository.Exists(Id, packageMetadata.Version)); if (refreshPackage && TryGetPackage(cacheRepository, packageMetadata, out _package) && _package.GetHash(HashProvider).Equals(PackageHash, StringComparison.OrdinalIgnoreCase)) { OldHash = PackageHash; // Reset the flag so that we no longer need to download the package since it exists and is valid. refreshPackage = false; // Make a note that the backing store for the ZipPackage is the machine cache. _usingMachineCache = true; } if (refreshPackage) { // We either do not have a package available locally or they are invalid. Download the package from the server. Stream targetStream = null; try { targetStream = cacheRepository.CreatePackageStream(packageMetadata.Id, packageMetadata.Version); // this can happen when access to the %LocalAppData% directory is blocked, e.g. on Windows Azure Web Site build if (targetStream != null) { _usingMachineCache = true; } else { // if we can't store the package into machine cache, store it in memory targetStream = new MemoryStream(); _usingMachineCache = false; } // download package into the stream Downloader.DownloadPackage(DownloadUrl, this, targetStream); } finally { if (targetStream != null && _usingMachineCache) { targetStream.Dispose(); } } if (_usingMachineCache) { _package = cacheRepository.FindPackage(packageMetadata.Id, packageMetadata.Version); Debug.Assert(_package != null); } else { targetStream.Seek(0, SeekOrigin.Begin); _package = new ZipPackage(targetStream); targetStream.Dispose(); } OldHash = PackageHash; } }
internal void EnsurePackage(IPackageCacheRepository cacheRepository) { IPackageMetadata packageMetadata = this; if ((((this._package == null) || ((this._package is OptimizedZipPackage) && !((OptimizedZipPackage)this._package).IsValid)) || !string.Equals(this.OldHash, this.PackageHash, StringComparison.OrdinalIgnoreCase)) || (this._usingMachineCache && !cacheRepository.Exists(this.Id, packageMetadata.Version))) { IPackage package = null; bool flag = false; bool flag2 = false; if (TryGetPackage(cacheRepository, packageMetadata, out package) && this.MatchPackageHash(package)) { flag2 = true; } else { if (cacheRepository.InvokeOnPackage(packageMetadata.Id, packageMetadata.Version, stream => this.Downloader.DownloadPackage(this.DownloadUrl, this, stream))) { package = cacheRepository.FindPackage(packageMetadata.Id, packageMetadata.Version); } else { using (MemoryStream stream = new MemoryStream()) { this.Downloader.DownloadPackage(this.DownloadUrl, this, stream); stream.Seek(0L, SeekOrigin.Begin); package = new ZipPackage(stream); } flag = true; } flag2 = true; } if (!flag2) { object[] args = new object[] { this.Version, this.Id }; throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, NuGetResources.Error_InvalidPackage, args)); } this._package = package; this.Id = this._package.Id; this.Version = this._package.Version.ToString(); this._usingMachineCache = !flag; this.OldHash = this.PackageHash; } }