Ejemplo n.º 1
0
        public static PatchData LoadAtPath(string path)
        {
            PatchData patchData = null;

            try
            {
                using (FileStream fs = File.Open(path, FileMode.Open, FileAccess.Read))
                {
                    XmlSerializer serializer = new XmlSerializer(typeof(PatchData));
                    patchData = serializer.Deserialize(fs) as PatchData;
                }
            }
            catch { }
            return(patchData);
        }
Ejemplo n.º 2
0
        private PatchData BuildBundles(BuildVersion buildVersion, int version)
        {
            if (Directory.Exists(m_outputFullPath))
            {
                Directory.Delete(m_outputFullPath, true);
            }
            Directory.CreateDirectory(m_outputFullPath);

            BuildPipeline.BuildAssetBundles(m_outputFullPath, CollectAssetBundleBuilds(), BuildAssetBundleOptions.None, buildVersion.buildTarget);

            //change name of AssetBundleManifest
            File.Move($"{m_outputFullPath}/{version}", $"{m_outputFullPath}/{FinalPatchConst.ASSET_BUNDLE_MANIFEST_NAME}");
            File.Move($"{m_outputFullPath}/{version}.manifest", $"{m_outputFullPath}/{FinalPatchConst.ASSET_BUNDLE_MANIFEST_NAME}.manifest");

            PatchData patchData = SavePatchData(buildVersion.name, version);

            //save build data
            buildVersion.version = version;
            m_managerWindow.FinalPatchEditorData.Save();

            return(patchData);
        }
Ejemplo n.º 3
0
        private void BuildIncrementalPackage(int version)
        {
            if (Directory.Exists(m_outputPackagePath))
            {
                Directory.Delete(m_outputPackagePath, true);
            }
            Directory.CreateDirectory(m_outputPackagePath);

            // copy current version bundle files
            foreach (var bundle in PatchData.LoadAtPath($"{FinalPatchUtility.GetFullPatchDataFilePath(m_outputPlatformPath, version)}").Bundles)
            {
                if (bundle.Version != version)
                {
                    continue;
                }

                string fromPath = $"{m_outputFullPath}/{bundle.Name}";
                string toPath   = $"{m_outputPackagePath}/{bundle.Name}";
                CopyBundle(fromPath, toPath);
            }

            // copy patch data
            File.Copy($"{m_outputFullPath}/{FinalPatchConst.PATCH_DATA_FILE_NAME}", $"{m_outputPackagePath}/{FinalPatchConst.PATCH_DATA_FILE_NAME}", true);
        }
Ejemplo n.º 4
0
        public static async Task <PatchReport> Collect()
        {
            PatchReport patchReport = new PatchReport();

            if (s_data.applyEditorMode)
            {
                Debug.Log("Patched in Editor Mode");
                patchReport.Result = PatchResult.Success;
                return(patchReport);
            }

            DeployData deployData = await DownloadDeployData();

            if (deployData == null)
            {
                Debug.LogErrorFormat("Deploy Data Not Found");
                patchReport.Result = PatchResult.Failure_NotFoundDeployData;
                return(patchReport);
            }

            ChannelData channelData = deployData.Channels.Find(c => c.Name == s_channel);

            if (channelData == null)
            {
                Debug.LogErrorFormat("Channel Not Found:'{0}'", s_channel);
                patchReport.Result = PatchResult.Failure_NotFoundChannel;
                return(patchReport);
            }

            if (channelData.Version == 0)
            {
                Debug.Log("No patch released");
                patchReport.Result = PatchResult.Success;
                return(patchReport);
            }

            string    patchDataUrl    = $"{channelData.URL}/{channelData.Build}/{channelData.Version}/{FinalPatchConst.PATCH_DATA_FILE_NAME}";
            PatchData serverPatchData = await PatchData.DownloadFromUrl(patchDataUrl);

            if (serverPatchData == null)
            {
                Debug.LogErrorFormat("Patch Data Not Found:'{0}'", patchDataUrl);
                patchReport.Result = PatchResult.Failure_NotFoundServerPatchData;
                return(patchReport);
            }

            PatchData persistentPatchData = PatchData.LoadAtPath(FinalPatchUtility.GetPersistentPatchDataPath());
            PatchData packagePatchData    = PatchData.LoadAtPath(FinalPatchUtility.GetStreamingAssetsPatchDataPath());

            if (packagePatchData?.Hash == serverPatchData.Hash)
            {
                // use package bundles
                Debug.LogFormat("Newest Package Version:'{0}[{1}]'", channelData.Build, channelData.Version);
                if (persistentPatchData != null)
                {
                    // reset build
                    persistentPatchData.Build = null;
                    persistentPatchData.SaveToPersistent();

                    // set client data obsolete
                    ClientData persistentClientData = ClientData.LoadAtPath(FinalPatchUtility.GetPersistentClientDataPath());
                    persistentClientData.IsObsolete = true;
                    persistentClientData.SaveToPersistent();
                }
                patchReport.Result = PatchResult.Success;
                return(patchReport);
            }

            if (persistentPatchData != null)
            {
                if (persistentPatchData.Build == null)
                {
                    persistentPatchData.Build = channelData.Build;
                }

                if (persistentPatchData.Build != channelData.Build)
                {
                    Debug.LogErrorFormat("Current Build Is Out Of Date:'{0}[{1}]'", persistentPatchData.Build, channelData.Version);
                    patchReport.Result = PatchResult.Failure_OutOfDate;
                    return(patchReport);
                }
            }

            ClientData clientData = ClientData.GetOrCreate(true);

            if (persistentPatchData?.Hash == serverPatchData.Hash)
            {
                Debug.LogFormat("Newest Version:'{0}[{1}]'", channelData.Build, channelData.Version);
                if (clientData.IsObsolete)
                {
                    clientData.IsObsolete = false;
                    clientData.SaveToPersistent();
                }
                patchReport.Result = PatchResult.Success;
                return(patchReport);
            }

            patchReport.PatchBundles = new List <BundleData>();
            foreach (var serverBundle in serverPatchData.Bundles)
            {
                BundleData packageBundle = packagePatchData?.Bundles?.Find((bundle) => bundle.Name == serverBundle.Name);

                if (packageBundle?.Hash == serverBundle.Hash)
                {
                    continue;
                }

                BundleData persistentBundle = persistentPatchData?.Bundles?.Find((bundle) => bundle.Name == serverBundle.Name);
                if (persistentBundle?.Hash != serverBundle.Hash)
                {
                    patchReport.PatchBundles.Add(serverBundle);
                    patchReport.TotalSize += serverBundle.Size;
                }
                persistentPatchData?.Bundles?.Remove(persistentBundle);
            }

            patchReport.DeleteBundles = new List <BundleData>();
            if (persistentPatchData != null)
            {
                foreach (var persistentBundle in persistentPatchData.Bundles)
                {
                    patchReport.DeleteBundles.Add(persistentBundle);
                }
            }

            patchReport.ServerPatchData = serverPatchData;
            patchReport.ClientData      = clientData;
            patchReport.ChannelData     = channelData;
            patchReport.Result          = PatchResult.Collected;
            return(patchReport);
        }
Ejemplo n.º 5
0
        private PatchData SavePatchData(string build, int version)
        {
            var bundleFiles = Directory.GetFiles(m_outputFullPath, "*", SearchOption.AllDirectories);

            PatchData currentPatchData = new PatchData
            {
                Build   = build,
                Bundles = new List <BundleData>()
            };

            SHA1 hashAlgorithm = SHA1.Create();

            foreach (var file in bundleFiles)
            {
                string generalFile = file.Replace('\\', '/');
                string bundleName  = generalFile.Remove(0, m_outputFullPath.Length + 1);
                string hash        = null;
                long   size        = 0;
                try
                {
                    using (FileStream fs = File.Open(generalFile, FileMode.Open, FileAccess.Read))
                    {
                        hash = BitConverter.ToString(hashAlgorithm.ComputeHash(fs)).Replace("-", string.Empty);
                        size = fs.Length;
                    }
                }
                catch (Exception e)
                {
                    Debug.LogException(e);
                    continue;
                }

                BundleData bundleData = new BundleData()
                {
                    Name    = bundleName,
                    Hash    = hash.ToString(),
                    Size    = size,
                    Version = version,
                };
                currentPatchData.Bundles.Add(bundleData);
            }

            // calc bundle version
            PatchData prevPatchData = PatchData.LoadAtPath($"{FinalPatchUtility.GetFullPatchDataFilePath(m_outputPlatformPath, version - 1)}");

            if (prevPatchData != null)
            {
                foreach (var currentBundle in currentPatchData.Bundles)
                {
                    BundleData prevBundle = prevPatchData.Bundles.Find((bundle) => bundle.Name == currentBundle.Name);
                    if (prevBundle == null)
                    {
                        continue;
                    }

                    if (currentBundle.Hash == prevBundle.Hash)
                    {
                        currentBundle.Version = prevBundle.Version;
                    }
                }
            }

            using (MemoryStream ms = new MemoryStream())
            {
                BinaryFormatter binaryFormatter = new BinaryFormatter();
                binaryFormatter.Serialize(ms, currentPatchData);
                ms.Seek(0, SeekOrigin.Begin);
                currentPatchData.Hash = BitConverter.ToString(hashAlgorithm.ComputeHash(ms)).Replace("-", string.Empty);
            }
            currentPatchData.Save($"{FinalPatchUtility.GetFullPatchDataFilePath(m_outputPlatformPath, version)}");
            return(currentPatchData);
        }