private static void AddDependencies(FileDownloader downloader, AssemblyManifest deployManifest, AssemblyManifest appManifest, Uri sourceUriBase, string targetDirectory, string group) { Uri uri; long total = 0L; System.Deployment.Application.Manifest.File[] filesInGroup = appManifest.GetFilesInGroup(group, true); ReorderFilesForIconFile(appManifest, filesInGroup); foreach (System.Deployment.Application.Manifest.File file in filesInGroup) { uri = MapFileSourceUri(deployManifest, sourceUriBase, file.Name); AddFileToDownloader(downloader, deployManifest, appManifest, file, uri, targetDirectory, file.NameFS, file.HashCollection); total += (long) file.Size; } DependentAssembly[] privateAssembliesInGroup = appManifest.GetPrivateAssembliesInGroup(group, true); foreach (DependentAssembly assembly in privateAssembliesInGroup) { uri = MapFileSourceUri(deployManifest, sourceUriBase, assembly.Codebase); AddFileToDownloader(downloader, deployManifest, appManifest, assembly, uri, targetDirectory, assembly.CodebaseFS, assembly.HashCollection); total += (long) assembly.Size; } downloader.SetExpectedBytesTotal(total); if ((filesInGroup.Length == 0) && (privateAssembliesInGroup.Length == 0)) { throw new InvalidDeploymentException(string.Format(CultureInfo.CurrentUICulture, Resources.GetString("Ex_NoSuchDownloadGroup"), new object[] { group })); } }
private static void AddShellExtensions(DefinitionIdentity subId, Uri deploymentProviderUri, AssemblyManifest appManifest) { foreach (FileAssociation association in appManifest.FileAssociations) { AddFileAssociation(association, subId, deploymentProviderUri); } }
private void Activate(DefinitionAppId appId, AssemblyManifest appManifest, string activationParameter, bool useActivationParameter) { using (ActivationContext context = ActivationContext.CreatePartialActivationContext(appId.ToApplicationIdentity())) { InternalActivationContextHelper.PrepareForExecution(context); this._subStore.ActivateApplication(appId, activationParameter, useActivationParameter); } }
internal static AssemblyManifest FromDocument(string localPath, AssemblyManifest.ManifestType manifestType, Uri sourceUri) { AssemblyManifest manifest; CodeMarker_Singleton.Instance.CodeMarker(CodeMarkerEvent.perfParseBegin); Logger.AddMethodCall("ManifestReader.FromDocument(" + localPath + ") called."); FileInfo info = new FileInfo(localPath); if (info.Length > 0x1000000L) { throw new DeploymentException(Resources.GetString("Ex_ManifestFileTooLarge")); } FileStream input = new FileStream(localPath, FileMode.Open, FileAccess.Read); try { XmlReader reader = PolicyKeys.SkipSchemaValidation() ? XmlReader.Create(input) : ManifestValidatingReader.Create(input); while (reader.Read()) { } Logger.AddInternalState("Schema validation passed."); manifest = new AssemblyManifest(input); Logger.AddInternalState("Manifest is parsed successfully."); if (!PolicyKeys.SkipSemanticValidation()) { manifest.ValidateSemantics(manifestType); } Logger.AddInternalState("Semantic validation passed."); if (!PolicyKeys.SkipSignatureValidation()) { input.Position = 0L; manifest.ValidateSignature(input); } Logger.AddInternalState("Signature validation passed."); } catch (XmlException exception) { string message = string.Format(CultureInfo.CurrentUICulture, Resources.GetString("Ex_ManifestFromDocument"), new object[] { (sourceUri != null) ? sourceUri.AbsoluteUri : Path.GetFileName(localPath) }); throw new InvalidDeploymentException(ExceptionTypes.ManifestParse, message, exception); } catch (XmlSchemaValidationException exception2) { string str2 = string.Format(CultureInfo.CurrentUICulture, Resources.GetString("Ex_ManifestFromDocument"), new object[] { (sourceUri != null) ? sourceUri.AbsoluteUri : Path.GetFileName(localPath) }); throw new InvalidDeploymentException(ExceptionTypes.ManifestParse, str2, exception2); } catch (InvalidDeploymentException exception3) { string str3 = string.Format(CultureInfo.CurrentUICulture, Resources.GetString("Ex_ManifestFromDocument"), new object[] { (sourceUri != null) ? sourceUri.AbsoluteUri : Path.GetFileName(localPath) }); throw new InvalidDeploymentException(ExceptionTypes.ManifestParse, str3, exception3); } finally { if (input != null) { input.Dispose(); } } CodeMarker_Singleton.Instance.CodeMarker(CodeMarkerEvent.perfParseEnd); return manifest; }
public static AssemblyManifest DownloadApplicationManifest(AssemblyManifest deploymentManifest, string targetDir, Uri deploymentUri, IDownloadNotification notification, DownloadOptions options, out Uri appSourceUri, out string appManifestPath) { ServerInformation information; Logger.AddMethodCall("DownloadApplicationManifest called."); DependentAssembly mainDependentAssembly = deploymentManifest.MainDependentAssembly; if ((mainDependentAssembly == null) || (mainDependentAssembly.Codebase == null)) { throw new InvalidDeploymentException(ExceptionTypes.ManifestSemanticValidation, Resources.GetString("Ex_NoAppInDeploymentManifest")); } appSourceUri = new Uri(deploymentUri, mainDependentAssembly.Codebase); Zone zone = Zone.CreateFromUrl(deploymentUri.AbsoluteUri); Zone zone2 = Zone.CreateFromUrl(appSourceUri.AbsoluteUri); if (!zone.Equals(zone2)) { Logger.AddInternalState(string.Concat(new object[] { "Deployment and application does not have matching security zones. deploymentZone=", zone, ",applicationZone=", zone2 })); throw new InvalidDeploymentException(ExceptionTypes.Zone, Resources.GetString("Ex_DeployAppZoneMismatch")); } appManifestPath = Path.Combine(targetDir, mainDependentAssembly.Identity.Name + ".manifest"); AssemblyManifest manifest = DownloadManifest(ref appSourceUri, appManifestPath, notification, options, AssemblyManifest.ManifestType.Application, out information); Logger.SetApplicationUrl(appSourceUri); Logger.SetApplicationServerInformation(information); zone2 = Zone.CreateFromUrl(appSourceUri.AbsoluteUri); if (!zone.Equals(zone2)) { Logger.AddInternalState(string.Concat(new object[] { "Deployment and application does not have matching security zones. deploymentZone=", zone, ",applicationZone=", zone2 })); throw new InvalidDeploymentException(ExceptionTypes.Zone, Resources.GetString("Ex_DeployAppZoneMismatch")); } if (manifest.Identity.Equals(deploymentManifest.Identity)) { throw new InvalidDeploymentException(ExceptionTypes.ManifestSemanticValidation, string.Format(CultureInfo.CurrentUICulture, Resources.GetString("Ex_DepSameDeploymentAndApplicationIdentity"), new object[] { manifest.Identity.ToString() })); } if (!manifest.Identity.Matches(mainDependentAssembly.Identity, manifest.Application)) { throw new InvalidDeploymentException(ExceptionTypes.SubscriptionSemanticValidation, Resources.GetString("Ex_RefDefMismatch")); } if (!PolicyKeys.SkipApplicationDependencyHashCheck()) { try { ComponentVerifier.VerifyFileHash(appManifestPath, mainDependentAssembly.HashCollection); } catch (InvalidDeploymentException exception) { if (exception.SubType == ExceptionTypes.HashValidation) { throw new InvalidDeploymentException(ExceptionTypes.HashValidation, Resources.GetString("Ex_AppManInvalidHash"), exception); } throw; } } if (manifest.RequestedExecutionLevel != null) { Logger.AddInternalState("Application manifest has RequestedExecutionLevel specified. Check requested privileges."); VerifyRequestedPrivilegesSupport(manifest.RequestedExecutionLevel); } return manifest; }
public void SetApplicationManifest(AssemblyManifest manifest, Uri manifestUri, string manifestPath) { base.AppManifest = manifest; base.AppSourceUri = manifestUri; base.AppManifestPath = manifestPath; if (base.AppManifest.EntryPoints[0].CustomHostSpecified) { base.appType = AppType.CustomHostSpecified; } if (base.AppManifest.EntryPoints[0].CustomUX) { base.appType = AppType.CustomUX; } }
private static void AddFilesInHashtable(Hashtable hashtable, AssemblyManifest applicationManifest, string applicationFolder) { Logger.AddMethodCall("AddFilesInHashtable called."); Logger.AddInternalState("applicationFolder=" + applicationFolder); string location = null; foreach (System.Deployment.Application.Manifest.File file in applicationManifest.Files) { location = Path.Combine(applicationFolder, file.NameFS); try { AddSingleFileInHashtable(hashtable, file.HashCollection, location); } catch (IOException exception) { Logger.AddErrorInformation(exception, Resources.GetString("Ex_PatchDependencyFailed"), new object[] { Path.GetFileName(location) }); Logger.AddInternalState("Exception thrown : " + exception.GetType().ToString() + ":" + exception.Message); } } foreach (DependentAssembly assembly in applicationManifest.DependentAssemblies) { if (!assembly.IsPreRequisite) { location = Path.Combine(applicationFolder, assembly.Codebase); try { if (AddSingleFileInHashtable(hashtable, assembly.HashCollection, location)) { AssemblyManifest manifest = new AssemblyManifest(location); System.Deployment.Application.Manifest.File[] files = manifest.Files; for (int i = 0; i < files.Length; i++) { string str2 = Path.Combine(Path.GetDirectoryName(location), files[i].NameFS); AddSingleFileInHashtable(hashtable, files[i].HashCollection, str2); } } } catch (InvalidDeploymentException exception2) { Logger.AddErrorInformation(exception2, Resources.GetString("Ex_PatchDependencyFailed"), new object[] { Path.GetFileName(location) }); Logger.AddInternalState("Exception thrown : " + exception2.GetType().ToString() + ":" + exception2.Message); } catch (IOException exception3) { Logger.AddErrorInformation(exception3, Resources.GetString("Ex_PatchDependencyFailed"), new object[] { Path.GetFileName(location) }); Logger.AddInternalState("Exception thrown : " + exception3.GetType().ToString() + ":" + exception3.Message); } } } }
internal static AssemblyManifest FromDocumentNoValidation(string localPath) { AssemblyManifest manifest; CodeMarker_Singleton.Instance.CodeMarker(CodeMarkerEvent.perfParseBegin); Logger.AddMethodCall("ManifestReader.FromDocumentNoValidation(" + localPath + ") called."); FileInfo info = new FileInfo(localPath); if (info.Length > 0x1000000L) { throw new DeploymentException(Resources.GetString("Ex_ManifestFileTooLarge")); } using (FileStream stream = new FileStream(localPath, FileMode.Open, FileAccess.Read)) { manifest = new AssemblyManifest(stream); } CodeMarker_Singleton.Instance.CodeMarker(CodeMarkerEvent.perfParseEnd); return manifest; }
public EntryPoint(System.Deployment.Internal.Isolation.Manifest.EntryPointEntry entryPointEntry, AssemblyManifest manifest) { this._name = entryPointEntry.Name; this._commandLineFile = entryPointEntry.CommandLine_File; this._commandLineParamater = entryPointEntry.CommandLine_Parameters; this._hostInBrowser = (entryPointEntry.Flags & 1) != 0; this._customHostSpecified = (entryPointEntry.Flags & 2) != 0; this._customUX = (entryPointEntry.Flags & 4) != 0; if (!this._customHostSpecified) { if (entryPointEntry.Identity != null) { this._dependentAssembly = manifest.GetDependentAssemblyByIdentity(entryPointEntry.Identity); } if (this._dependentAssembly == null) { throw new InvalidDeploymentException(ExceptionTypes.ManifestParse, Resources.GetString("Ex_NoMatchingAssemblyForEntryPoint")); } } }
public void Reset() { this.IsInstalled = this.IsShellVisible = false; this.CurrentBind = this.PreviousBind = (DefinitionAppId) (this.PendingBind = null); this.ExcludedDeployment = (DefinitionIdentity) (this.PendingDeployment = null); this.DeploymentProviderUri = null; this.MinimumRequiredVersion = null; this.LastCheckTime = DateTime.MinValue; this.UpdateSkippedDeployment = null; this.UpdateSkipTime = DateTime.MinValue; this.CurrentDeployment = null; this.RollbackDeployment = null; this.CurrentDeploymentManifest = null; this.CurrentDeploymentSourceUri = null; this.CurrentApplication = null; this.CurrentApplicationManifest = null; this.CurrentApplicationSourceUri = null; this.PreviousApplication = null; this.PreviousApplicationManifest = null; this.appType = AppType.None; }
public CommitApplicationParams(CommitApplicationParams src) { this.TimeStamp = DateTime.MinValue; this.AppId = src.AppId; this.CommitApp = src.CommitApp; this.AppManifest = src.AppManifest; this.AppSourceUri = src.AppSourceUri; this.AppManifestPath = src.AppManifestPath; this.AppPayloadPath = src.AppPayloadPath; this.AppGroup = src.AppGroup; this.CommitDeploy = src.CommitDeploy; this.DeployManifest = src.DeployManifest; this.DeploySourceUri = src.DeploySourceUri; this.DeployManifestPath = src.DeployManifestPath; this.TimeStamp = src.TimeStamp; this.IsConfirmed = src.IsConfirmed; this.IsUpdate = src.IsUpdate; this.IsRequiredUpdate = src.IsRequiredUpdate; this.IsUpdateInPKTGroup = src.IsUpdateInPKTGroup; this.IsFullTrustRequested = src.IsFullTrustRequested; this.appType = src.appType; this.Trust = src.Trust; }
public DependencyDownloadCookie(object manifestElement, AssemblyManifest deployManifest, AssemblyManifest appManifest) { this.ManifestElement = manifestElement; this.DeployManifest = deployManifest; this.AppManifest = appManifest; }
private static void VerifyRequestedPrivilegesSupport(AssemblyManifest appManifest, string targetDirectory) { if (!appManifest.EntryPoints[0].CustomHostSpecified) { string path = Path.Combine(targetDirectory, appManifest.EntryPoints[0].Assembly.Codebase); if (System.IO.File.Exists(path)) { AssemblyManifest manifest = new AssemblyManifest(path); if (manifest.Id1ManifestPresent && (manifest.Id1RequestedExecutionLevel != null)) { VerifyRequestedPrivilegesSupport(manifest.Id1RequestedExecutionLevel); } } else { Logger.AddInternalState("Main exe=" + path + " does not exist. No Requested Priviliges Verification done."); } } }
public void SetDeploymentManifest(AssemblyManifest manifest, Uri manifestUri, string manifestPath) { base.DeploySourceUri = manifestUri; base.DeployManifest = manifest; base.DeployManifestPath = manifestPath; }
public static void RemoveShellExtensions(DefinitionIdentity subId, AssemblyManifest appManifest, string productName) { foreach (FileAssociation association in appManifest.FileAssociations) { RemoveFileAssociation(association, subId, productName); } System.Deployment.Application.NativeMethods.SHChangeNotify(0x8000000, 0, IntPtr.Zero, IntPtr.Zero); }
internal static void SetDeploymentManifest(AssemblyManifest deploymentManifest) { Logger currentThreadLogger = GetCurrentThreadLogger(); if (currentThreadLogger != null) { lock (currentThreadLogger) { if (deploymentManifest.Identity != null) { currentThreadLogger.Identities.DeploymentIdentity = deploymentManifest.Identity; } currentThreadLogger.Summary.DeploymentManifest = deploymentManifest; } } }
private static void AddFileToDownloader(FileDownloader downloader, AssemblyManifest deployManifest, AssemblyManifest appManifest, object manifestElement, Uri fileSourceUri, string targetDirectory, string targetFileName, HashCollection hashCollection) { string targetFilePath = Path.Combine(targetDirectory, targetFileName); DependencyDownloadCookie cookie = new DependencyDownloadCookie(manifestElement, deployManifest, appManifest); downloader.AddFile(fileSourceUri, targetFilePath, cookie, hashCollection); }
public static bool FollowDeploymentProviderUri(SubscriptionStore subStore, ref AssemblyManifest deployment, ref Uri sourceUri, out TempFile tempFile, IDownloadNotification notification, DownloadOptions options) { Logger.AddMethodCall("FollowDeploymentProviderUri called."); tempFile = null; bool flag = false; Zone zone = Zone.CreateFromUrl(sourceUri.AbsoluteUri); bool flag2 = false; if (zone.SecurityZone != SecurityZone.MyComputer) { Logger.AddInternalState("Deployment manifest zone is not local machine. Zone = " + zone.SecurityZone); flag2 = true; } else { Logger.AddInternalState("Deployment manifest zone is local machine. Zone = " + zone.SecurityZone); DependentAssembly mainDependentAssembly = deployment.MainDependentAssembly; if ((mainDependentAssembly == null) || (mainDependentAssembly.Codebase == null)) { throw new InvalidDeploymentException(ExceptionTypes.ManifestSemanticValidation, Resources.GetString("Ex_NoAppInDeploymentManifest")); } Uri uri = new Uri(sourceUri, mainDependentAssembly.Codebase); Zone zone2 = Zone.CreateFromUrl(uri.AbsoluteUri); if (zone2.SecurityZone == SecurityZone.MyComputer) { Logger.AddInternalState("Application manifest zone is local machine. Zone = " + zone2.SecurityZone); if (!System.IO.File.Exists(uri.LocalPath)) { Logger.AddInternalState(uri.LocalPath + " does not exist in local machine."); flag2 = true; } } } if (flag2) { Uri providerCodebaseUri = deployment.Deployment.ProviderCodebaseUri; Logger.SetDeploymentProviderUrl(providerCodebaseUri); Logger.AddInternalState(string.Concat(new object[] { "providerUri=", providerCodebaseUri, ",sourceUri=", sourceUri })); if ((!PolicyKeys.SkipDeploymentProvider() && (providerCodebaseUri != null)) && !providerCodebaseUri.Equals(sourceUri)) { ServerInformation information; AssemblyManifest manifest = null; try { manifest = DownloadDeploymentManifestDirect(subStore, ref providerCodebaseUri, out tempFile, notification, options, out information); } catch (InvalidDeploymentException exception) { if (((exception.SubType != ExceptionTypes.Manifest) && (exception.SubType != ExceptionTypes.ManifestLoad)) && ((exception.SubType != ExceptionTypes.ManifestParse) && (exception.SubType != ExceptionTypes.ManifestSemanticValidation))) { throw; } throw new InvalidDeploymentException(ExceptionTypes.Manifest, Resources.GetString("Ex_InvalidProviderManifest"), exception); } Logger.SetDeploymentProviderServerInformation(information); SubscriptionState subscriptionState = subStore.GetSubscriptionState(deployment); if (!subStore.GetSubscriptionState(manifest).SubscriptionId.Equals(subscriptionState.SubscriptionId)) { throw new InvalidDeploymentException(ExceptionTypes.SubscriptionSemanticValidation, Resources.GetString("Ex_ProviderNotInSubscription")); } Logger.AddInternalState("Deployment provider followed: " + providerCodebaseUri); deployment = manifest; sourceUri = providerCodebaseUri; flag = true; } } if (!flag) { Logger.AddInternalState("Deployment provider not followed."); } return flag; }
private static AssemblyManifest DownloadManifest(ref Uri sourceUri, string targetPath, IDownloadNotification notification, DownloadOptions options, AssemblyManifest.ManifestType manifestType, out ServerInformation serverInformation) { Logger.AddMethodCall("DownloadManifest called."); DownloadManifestAsRawFile(ref sourceUri, targetPath, notification, options, out serverInformation); return ManifestReader.FromDocument(targetPath, manifestType, sourceUri); }
public static void DownloadDependencies(SubscriptionState subState, AssemblyManifest deployManifest, AssemblyManifest appManifest, Uri sourceUriBase, string targetDirectory, string group, IDownloadNotification notification, DownloadOptions options) { Logger.AddMethodCall("DownloadDependencies called."); Logger.AddInternalState("sourceUriBase=" + sourceUriBase); Logger.AddInternalState("targetDirectory=" + targetDirectory); Logger.AddInternalState("group=" + group); Logger.AddInternalState("DownloadOptions=" + options); FileDownloader downloader = FileDownloader.Create(); downloader.Options = options; if (group == null) { downloader.CheckForSizeLimit(appManifest.CalculateDependenciesSize(), false); } AddDependencies(downloader, deployManifest, appManifest, sourceUriBase, targetDirectory, group); downloader.DownloadModified += new FileDownloader.DownloadModifiedEventHandler(DownloadManager.ProcessDownloadedFile); if (notification != null) { downloader.AddNotification(notification); } try { downloader.Download(subState); downloader.ComponentVerifier.VerifyComponents(); VerifyRequestedPrivilegesSupport(appManifest, targetDirectory); } finally { if (notification != null) { downloader.RemoveNotification(notification); } downloader.DownloadModified -= new FileDownloader.DownloadModifiedEventHandler(DownloadManager.ProcessDownloadedFile); } }
internal static void SetApplicationManifest(AssemblyManifest applicationManifest) { Logger currentThreadLogger = GetCurrentThreadLogger(); if (currentThreadLogger != null) { lock (currentThreadLogger) { if (applicationManifest.Identity != null) { currentThreadLogger.Identities.ApplicationIdentity = applicationManifest.Identity; } currentThreadLogger.Summary.ApplicationManifest = applicationManifest; } } }
public Version CheckUpdateInManifest(SubscriptionState subState, Uri updateCodebaseUri, AssemblyManifest deployment, Version currentVersion, ref bool bUpdateInPKTGroup) { CheckOnlineShellVisibleConflict(subState, deployment); CheckInstalledAndUpdateableConflict(subState, deployment); CheckMinimumRequiredVersion(subState, deployment); SubscriptionState subscriptionState = this.GetSubscriptionState(deployment); if (!subscriptionState.SubscriptionId.Equals(subState.SubscriptionId)) { Logger.AddInternalState("Cross family update detected. Check if only PKT has changed between versions."); Logger.AddInternalState(string.Concat(new object[] { "updateCodebaseUri=", updateCodebaseUri, ", subState.DeploymentProviderUri=", subState.DeploymentProviderUri })); Logger.AddInternalState(string.Concat(new object[] { "subState=", subState.SubscriptionId, ", manSubState.SubscriptionId=", subscriptionState.SubscriptionId })); if (!updateCodebaseUri.Equals(subState.DeploymentProviderUri) || !subState.PKTGroupId.Equals(subscriptionState.PKTGroupId)) { throw new DeploymentException(ExceptionTypes.SubscriptionState, Resources.GetString("Ex_DeploymentIdentityNotInSubscription")); } Logger.AddInternalState("PKT has changed."); bUpdateInPKTGroup = true; } Version version = deployment.Identity.Version; if (version.CompareTo(currentVersion) == 0) { return null; } return version; }
internal static void SetApplicationManifest(LogIdentity log, AssemblyManifest applicationManifest) { Logger logger = GetLogger(log); if (logger != null) { lock (logger) { if (applicationManifest.Identity != null) { logger.Identities.ApplicationIdentity = applicationManifest.Identity; } logger.Summary.ApplicationManifest = applicationManifest; } } }
private static void ProcessDownloadedFile(object sender, DownloadEventArgs e) { if (e.Cookie != null) { string fileName = Path.GetFileName(e.FileLocalPath); FileDownloader downloader = (FileDownloader) sender; if ((e.FileResponseUri != null) && !e.FileResponseUri.Equals(e.FileSourceUri)) { throw new InvalidDeploymentException(ExceptionTypes.AppFileLocationValidation, string.Format(CultureInfo.CurrentUICulture, Resources.GetString("Ex_DownloadAppFileAsmRedirected"), new object[] { fileName })); } DependencyDownloadCookie cookie = (DependencyDownloadCookie) e.Cookie; if (cookie.ManifestElement is DependentAssembly) { DependentAssembly manifestElement = (DependentAssembly) cookie.ManifestElement; AssemblyManifest deployManifest = cookie.DeployManifest; AssemblyManifest appManifest = cookie.AppManifest; AssemblyManifest assemblyManifest = new AssemblyManifest(e.FileLocalPath); if (!assemblyManifest.Identity.Matches(manifestElement.Identity, true)) { throw new InvalidDeploymentException(ExceptionTypes.RefDefValidation, string.Format(CultureInfo.CurrentUICulture, Resources.GetString("Ex_DownloadRefDefMismatch"), new object[] { fileName })); } if (assemblyManifest.Identity.Equals(deployManifest.Identity) || assemblyManifest.Identity.Equals(appManifest.Identity)) { throw new InvalidDeploymentException(ExceptionTypes.ManifestSemanticValidation, string.Format(CultureInfo.CurrentUICulture, Resources.GetString("Ex_AppPrivAsmIdSameAsDeployOrApp"), new object[] { assemblyManifest.Identity.ToString() })); } System.Deployment.Application.Manifest.File[] files = assemblyManifest.Files; for (int i = 0; i < files.Length; i++) { Uri fileSourceUri = MapFileSourceUri(deployManifest, e.FileSourceUri, files[i].Name); if (!fileSourceUri.AbsoluteUri.Equals(e.FileSourceUri.AbsoluteUri, StringComparison.OrdinalIgnoreCase)) { string directoryName = Path.GetDirectoryName(e.FileLocalPath); AddFileToDownloader(downloader, deployManifest, appManifest, files[i], fileSourceUri, directoryName, files[i].NameFS, files[i].HashCollection); } } downloader.ComponentVerifier.AddFileForVerification(e.FileLocalPath, manifestElement.HashCollection); if (assemblyManifest.Identity.PublicKeyToken == null) { downloader.ComponentVerifier.AddSimplyNamedAssemblyForVerification(e.FileLocalPath, assemblyManifest); } else { downloader.ComponentVerifier.AddStrongNameAssemblyForVerification(e.FileLocalPath, assemblyManifest); } } else if (cookie.ManifestElement is System.Deployment.Application.Manifest.File) { System.Deployment.Application.Manifest.File file = (System.Deployment.Application.Manifest.File) cookie.ManifestElement; downloader.ComponentVerifier.AddFileForVerification(e.FileLocalPath, file.HashCollection); } } }
internal static void SetDeploymentManifest(LogIdentity log, AssemblyManifest deploymentManifest) { Logger logger = GetLogger(log); if (logger != null) { lock (logger) { if (deploymentManifest.Identity != null) { logger.Identities.DeploymentIdentity = deploymentManifest.Identity; } logger.Summary.DeploymentManifest = deploymentManifest; } } }
public static AssemblyManifest DownloadApplicationManifest(AssemblyManifest deploymentManifest, string targetDir, Uri deploymentUri, out Uri appSourceUri, out string appManifestPath) { return DownloadApplicationManifest(deploymentManifest, targetDir, deploymentUri, null, null, out appSourceUri, out appManifestPath); }
public SubscriptionState GetSubscriptionState(AssemblyManifest deployment) { return new SubscriptionState(this, deployment); }
private static void ReorderFilesForIconFile(AssemblyManifest manifest, System.Deployment.Application.Manifest.File[] files) { if ((manifest.Description != null) && (manifest.Description.IconFile != null)) { for (int i = 0; i < files.Length; i++) { if (string.Compare(files[i].NameFS, manifest.Description.IconFileFS, StringComparison.OrdinalIgnoreCase) == 0) { if (i != 0) { System.Deployment.Application.Manifest.File file = files[0]; files[0] = files[i]; files[i] = file; } return; } } } }
private static Uri MapFileSourceUri(AssemblyManifest deployManifest, Uri sourceUriBase, string fileName) { return UriHelper.UriFromRelativeFilePath(sourceUriBase, deployManifest.Deployment.MapFileExtensions ? (fileName + ".deploy") : fileName); }
public SubscriptionState(System.Deployment.Application.SubscriptionStore subStore, AssemblyManifest deployment) { this.Initialize(subStore, deployment.Identity.ToSubscriptionId()); }