/// <inheritdoc /> public string GetCachedInfoFile(CacheEntry entry) { var guid = entry.Guid.ToString(); string finalHash = HashingMethods.Calculate(m_GlobalHash, entry.Hash).ToString(); return(string.Format("{0}/{1}/{2}/{2}_{3}.info", k_CachePath, guid.Substring(0, 2), guid, finalHash)); }
/// <inheritdoc /> public CacheEntry GetCacheEntry(GUID asset, int version = 1) { CacheEntry entry; KeyValuePair <GUID, int> key = new KeyValuePair <GUID, int>(asset, version); if (m_GuidToHash.TryGetValue(key, out entry)) { return(entry); } entry = new CacheEntry { Guid = asset, Version = version }; string path = AssetDatabase.GUIDToAssetPath(asset.ToString()); entry.Type = CacheEntry.EntryType.Asset; if (path.Equals(CommonStrings.UnityBuiltInExtraPath, StringComparison.OrdinalIgnoreCase) || path.Equals(CommonStrings.UnityDefaultResourcePath, StringComparison.OrdinalIgnoreCase)) { entry.Hash = HashingMethods.Calculate(Application.unityVersion, path).ToHash128(); } else { entry.Hash = AssetDatabase.GetAssetDependencyHash(path); if (!entry.Hash.isValid) { entry.Hash = HashingMethods.CalculateFile(path).ToHash128(); } } entry.Hash = HashingMethods.Calculate(entry.Hash, entry.Version).ToHash128(); m_GuidToHash[key] = entry; return(entry); }
/// <inheritdoc /> public string GetCachedArtifactsDirectory(CacheEntry entry) { var guid = entry.Guid.ToString(); string finalHash = HashingMethods.Calculate(m_GlobalHash, entry.Hash).ToString(); return(string.Format("{0}/{1}/{2}", k_CachePath, guid.Substring(0, 2), finalHash)); }
/// <inheritdoc /> public CacheEntry GetCacheEntry(string path, int version = 1) { CacheEntry entry; KeyValuePair <string, int> key = new KeyValuePair <string, int>(path, version); if (m_PathToHash.TryGetValue(key, out entry)) { return(entry); } var guid = AssetDatabase.AssetPathToGUID(path); if (!string.IsNullOrEmpty(guid)) { return(GetCacheEntry(new GUID(guid), version)); } entry = new CacheEntry { File = path, Version = version }; entry.Guid = HashingMethods.Calculate("FileHash", entry.File).ToGUID(); if (File.Exists(entry.File)) { entry.Hash = HashingMethods.Calculate(HashingMethods.CalculateFile(entry.File), entry.Version).ToHash128(); } entry.Type = CacheEntry.EntryType.File; m_PathToHash[key] = entry; return(entry); }
static Hash128 CalculateGlobalArtifactVersionHash() { #if UNITY_2019_3_OR_NEWER return(HashingMethods.Calculate(Application.unityVersion, k_Version).ToHash128()); #else return(HashingMethods.Calculate(PlayerSettings.scriptingRuntimeVersion, Application.unityVersion, k_Version).ToHash128()); #endif }
public static Hash128 GetHash128(this BuildSettings settings) { if (settings.typeDB == null) { return(HashingMethods.Calculate(settings.target, settings.group, settings.buildFlags).ToHash128()); } return(HashingMethods.Calculate(settings.target, settings.group, settings.buildFlags, settings.typeDB.GetHash128()).ToHash128()); }
// We return from this function before all uploads are complete. So we must wait to dispose until all uploads are finished. public void QueueUpload(CacheEntry entry, string artifactsPath, MemoryStream stream) { var item = new WorkItem(); string finalHash = HashingMethods.Calculate(entry.Hash, m_GlobalHash).ToString(); item.fileId = FileId.From(entry.Guid.ToString(), finalHash); item.artifactsPath = artifactsPath; item.stream = stream; ThreadingManager.QueueTask(ThreadingManager.ThreadQueues.UploadQueue, UploadItem, item); }
// We return from this function before all uploads are complete. So we must wait to dispose until all uploads are finished. public void QueueUpload(CacheEntry entry, string artifactsPath, MemoryStream stream) { var item = new WorkItem(); string finalHash = HashingMethods.Calculate(entry.Hash, m_GlobalHash).ToString(); item.fileId = FileId.From(entry.Guid.ToString(), finalHash); item.artifactsPath = artifactsPath; item.stream = stream; lock (m_WorkItems) m_WorkItems.Enqueue(item); m_Semaphore.Release(); }
/// <inheritdoc /> public CacheEntry GetCacheEntry(string path) { CacheEntry entry; if (m_PathToHash.TryGetValue(path, out entry)) { return(entry); } entry = new CacheEntry { File = path }; entry.Guid = HashingMethods.Calculate("FileHash", entry.File).ToGUID(); entry.Hash = HashingMethods.CalculateFile(entry.File).ToHash128(); entry.Type = CacheEntry.EntryType.File; m_PathToHash[entry.File] = entry; return(entry); }
/// <inheritdoc /> public CacheEntry GetCacheEntry(string path, int version = 1) { CacheEntry entry; KeyValuePair <string, int> key = new KeyValuePair <string, int>(path, version); if (m_PathToHash.TryGetValue(key, out entry)) { return(entry); } entry = new CacheEntry { File = path, Version = version }; entry.Guid = HashingMethods.Calculate("FileHash", entry.File).ToGUID(); entry.Hash = HashingMethods.Calculate(HashingMethods.CalculateFile(entry.File), entry.Version).ToHash128(); entry.Type = CacheEntry.EntryType.File; m_PathToHash[key] = entry; return(entry); }
internal void GatherCallbackVersions() { var versionedType = typeof(VersionedCallbackAttribute); var typeCollection = TypeCache.GetTypesWithAttribute(versionedType); List <Hash128> sceneInputs = new List <Hash128>(); List <Hash128> shaderInputs = new List <Hash128>(); foreach (var type in typeCollection) { var attribute = (VersionedCallbackAttribute)Attribute.GetCustomAttribute(type, versionedType); #if UNITY_2020_2_OR_NEWER if (typeof(IPreprocessShaders).IsAssignableFrom(type) || typeof(IPreprocessComputeShaders).IsAssignableFrom(type)) #else if (typeof(IPreprocessShaders).IsAssignableFrom(type)) #endif { shaderInputs.Add(HashingMethods.Calculate(type.AssemblyQualifiedName, attribute.version).ToHash128()); } #pragma warning disable CS0618 // Type or member is obsolete else if (typeof(IProcessScene).IsAssignableFrom(type) || typeof(IProcessSceneWithReport).IsAssignableFrom(type)) #pragma warning restore CS0618 // Type or member is obsolete { sceneInputs.Add(HashingMethods.Calculate(type.AssemblyQualifiedName, attribute.version).ToHash128()); } } SceneCallbackVersionHash = new Hash128(); if (sceneInputs.Count > 0) { sceneInputs.Sort(); SceneCallbackVersionHash = HashingMethods.Calculate(sceneInputs).ToHash128(); } ShaderCallbackVersionHash = new Hash128(); if (shaderInputs.Count > 0) { shaderInputs.Sort(); ShaderCallbackVersionHash = HashingMethods.Calculate(shaderInputs).ToHash128(); } }
static Hash128 CalculateGlobalArtifactVersionHash() { return(HashingMethods.Calculate(PlayerSettings.scriptingRuntimeVersion, Application.unityVersion).ToHash128()); }
// We don't return from this function until all downloads are processed. So it is safe to dispose immediately after. public void DownloadMissing(IList <CacheEntry> entries, IList <CachedInfo> cachedInfos) { Assert.AreEqual(entries.Count, cachedInfos.Count); Directory.CreateDirectory(k_CachePath); m_Semaphore = new Semaphore(0, entries.Count); m_Client.DownloadFinished += ThreadedDownloadFinished; // Queue up downloads for the missing or invalid local data for (var index = 0; index < entries.Count; index++) { // Only download data for cachedInfos that are invalid if (cachedInfos[index] != null) { continue; } var entry = entries[index]; string finalHash = HashingMethods.Calculate(entry.Hash, m_GlobalHash).ToHash128().ToString(); var fileId = FileId.From(entry.Guid.ToString(), finalHash); // Download artifacts before info to ensure both are available when download for info returns var downloadArtifact = new FileDownloadItem(fileId, FileType.Resource, GetCachedArtifactsFile(entry)); m_Client.QueueDownload(downloadArtifact); var downloadInfo = new FileDownloadItem(fileId, FileType.Info, GetCachedInfoFile(entry)); m_Client.QueueDownload(downloadInfo); } // Check downloads to see if it is usable data var formatter = new BinaryFormatter(); for (var index = 0; index < entries.Count; index++) { // find the next invalid cachedInfo while (index < entries.Count && cachedInfos[index] != null) { index++; } // make sure we didn't go out of bounds looking for invalid entries if (index >= entries.Count) { break; } // Wait for info download m_Semaphore.WaitOne(); string tempInfoFile = GetCachedInfoFile(entries[index]); if (!File.Exists(tempInfoFile)) { continue; } try { CachedInfo info; using (var fileStream = new FileStream(tempInfoFile, FileMode.Open, FileAccess.Read)) info = formatter.Deserialize(fileStream) as CachedInfo; if (m_Cache.HasAssetOrDependencyChanged(info)) { continue; } // Not every info file will have artifacts. So just check to see if we downloaded something. // TODO: May want to extend CachedInfo with Artifact knowledge if there is a performance benefit? string tempArtifactFile = GetCachedArtifactsFile(entries[index]); string tempArtifactDir = Path.ChangeExtension(tempArtifactFile, ""); if (File.Exists(tempArtifactFile) && !FileCompressor.Decompress(tempArtifactFile, tempArtifactDir)) { continue; } // All valid, move downloaded data into place cachedInfos[index] = info; string targetInfoFile = m_Cache.GetCachedInfoFile(info.Asset); if (File.Exists(targetInfoFile)) { File.Delete(targetInfoFile); } else { Directory.CreateDirectory(Path.GetDirectoryName(targetInfoFile)); } File.Move(tempInfoFile, targetInfoFile); if (Directory.Exists(tempArtifactDir)) { string targetArtifactDir = m_Cache.GetCachedArtifactsDirectory(info.Asset); if (Directory.Exists(targetArtifactDir)) { Directory.Delete(targetArtifactDir, true); } Directory.Move(tempArtifactDir, targetArtifactDir); } } catch (Exception e) { BuildLogger.LogException(e); } } m_Client.ResetDownloadFinishedEventHandler(); ((IDisposable)m_Semaphore).Dispose(); m_Semaphore = null; Directory.Delete(k_CachePath, true); }
string GetCachedArtifactsFile(CacheEntry entry) { string finalHash = HashingMethods.Calculate(entry.Hash, m_GlobalHash).ToString(); return(string.Format("{0}/{1}_{2}.sbpGz", k_CachePath, entry.Guid.ToString(), finalHash)); }