none
Problème avec Windows Installer 3.1 + CustomInstaller RRS feed

  • Question

  • Bonjour,

    Nous développons actuellement une application en C# sous Visual Studio 2008 et le framework .NET 3.5 SP1.
    L'installation du produit se fait via Windows Installer 3.1 auquel nous avons ajouté quelques comportements propres à l'application dans une classe CustomInstaller (cf. ci-dessous). Si l'installation et ses customisations se déroulent absolument sans problème en local sur une machine, elle s'avère impossible sur un disque réseau distant. Elle s'achève alors par une erreur (Erreur 1001 cf. captures) qui provoque la désinstallation complète du produit : l'installateur est incapable de trouver le fichier de customisation qu'il va chercher au mauvaise endroit comme le montre l'image en PJ. Le chemin originel a été altéré, un C:\ y a été ajouté sans justification ce qui rend de fait impossible la localisation du fichier en question.

    Sans cette customisation, l'installation, quelle soit locale ou distante, se déroule parfaitement.

    Quelles solutions pouvons-nous apporter à ce problème ? S'agit-il d'un dysfonctionnement de Windows Installer 3.1 ?

    Merci,

    Ci-dessous la classe du CustomInstaller associé au Windows Installer 3.1 :

    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Configuration.Install;
    using System.IO;
    using System.Security.AccessControl;
    using System.Security.Principal;
    using Microsoft.Win32;
    using MyPackage.Util;
    using System.Reflection;
    using System.Windows.Forms;
    
    namespace MyPackage.Installation.CustomActions
    {
        [RunInstaller(true)]
        public class CustomInstaller : Installer
        {
            public CustomInstaller()
            {
            }
    
            [System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.Demand)]
            public override void Install(IDictionary savedState)
            {
                savedState.Add("InstallDir", Context.Parameters["dir"]);
                base.Install(savedState);
            }
    
            [System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.Demand)]
            public override void Commit(IDictionary savedState)
            {
                base.Commit(savedState);
                FillRegistry(savedState);
            }
    
            [System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.Demand)]
            public override void Rollback(IDictionary savedState)
            {
                base.Rollback(savedState);
            }
    
            [System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.Demand)]
            public override void Uninstall(IDictionary savedState)
            {
                base.Uninstall(savedState);
            }
    
            private static void FillRegistry(IDictionary savedState)
            {
                try
                {
                    string DirPath = (string)savedState["InstallDir"];
                    if (!string.IsNullOrEmpty(DirPath))
                    {
                        RegistryKey iceInstallationRegistryKey = null;
                        RegistryKey installedAppsKey = Registry.LocalMachine.CreateSubKey(MyPackageConstants.INSTALLED_PRODUCTS_REGISTY_KEY);
                        foreach (string installedAppKeyName in installedAppsKey.GetSubKeyNames())
                        {
                            RegistryKey installedAppKey = null;
                            try
                            {
                                installedAppKey = installedAppsKey.OpenSubKey(installedAppKeyName, true);
                                string appName = installedAppKey.GetValue(MyPackageConstants.PRODUCT_NAME_REGISTRY_KEY).ToString();
                                if (appName == MyPackageFrameworkVersion.MYPACKAGE_NAME)
                                {
                                    iceInstallationRegistryKey = installedAppKey;
                                    break;
                                }
                            }
                            catch
                            {
                            }
                            finally
                            {
                                if (installedAppKey != null && installedAppKey != iceInstallationRegistryKey)
                                    installedAppKey.Close();
                            }
                        }
                        if (iceInstallationRegistryKey != null)
                        {
                            iceInstallationRegistryKey.SetValue(MyPackageConstants.INSTALL_LOCATION_REGISTRY_KEY, DirPath);
                            iceInstallationRegistryKey.SetValue(MyPackageConstants.DISPLAY_ICON_REGISTRY_KEY, Path.Combine(DirPath, MyPackageConstants.ICE_ICON_RELATIVE_PATH));
                            iceInstallationRegistryKey.Flush();
                            iceInstallationRegistryKey.Close();
                        }
                    }
                }
                catch
                {
                }
            }
    
            private static void SetRightsOnLogs(IDictionary savedState)
            {
                string DirPath = (string)savedState["InstallDir"];
                if (!string.IsNullOrEmpty(DirPath))
                {
                    string LogDirPath = Path.Combine(DirPath, MyPackageConstants.LOG_DIRECTORY);
                    if (Directory.Exists(LogDirPath))
                    {
                        DirectorySecurity securiteRepertoire = Directory.GetAccessControl(LogDirPath);
                        securiteRepertoire.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null),
                            FileSystemRights.Write | FileSystemRights.Read | FileSystemRights.ListDirectory, AccessControlType.Allow));
                        Directory.SetAccessControl(LogDirPath, securiteRepertoire);
                    }
                    string LicensesDirPath = Path.Combine(DirPath, MyPackageConstants.LICENSE_DIRECTORY);
                    if (Directory.Exists(LicensesDirPath))
                    {
                        DirectorySecurity securiteRepertoire = Directory.GetAccessControl(LicensesDirPath);
                        securiteRepertoire.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null),
                            FileSystemRights.Write | FileSystemRights.Read | FileSystemRights.ListDirectory, AccessControlType.Allow));
                        Directory.SetAccessControl(LicensesDirPath, securiteRepertoire);
                    }
                }
            }
    
            private static void DeleteDirectoryFiles(string directoryPath)
            {
                string[] files;
                if (Directory.Exists(directoryPath))
                {
                    files = Directory.GetFiles(directoryPath);
                    for (int i = 0; i < files.Length; i++)
                    {
                        try
                        {
                            File.Delete(files[i]);
                        }
                        catch { }
                    }
                }
            }
    
            private static void DeleteLogFiles(IDictionary savedState)
            {
                string DirPath = (string)savedState["InstallDir"];
                if (!string.IsNullOrEmpty(DirPath))
                    DeleteDirectoryFiles(Path.Combine(DirPath, MyPackageConstants.LOG_DIRECTORY));
            }
    
            private static void DeleteLicenseFiles(IDictionary savedState)
            {
                string DirPath = (string)savedState["InstallDir"];
                if (!string.IsNullOrEmpty(DirPath))
                    DeleteDirectoryFiles(Path.Combine(DirPath, MyPackageConstants.LICENSE_DIRECTORY));
            }
    
            private static void DeleteFiles(IDictionary savedState)
            {
                string DirPath = (string)savedState["InstallDir"];
                if (!string.IsNullOrEmpty(DirPath))
                    DeleteDirectoryFiles(DirPath);
            }
    
            private static void DeleteRootDirectory(IDictionary savedState)
            {
                string DirPath = (string)savedState["InstallDir"];
                try
                {
                    Directory.Delete(DirPath);
                }
                catch { }
            }
    
            private static void DeleteRegistryKey()
            {
                try
                {
                    RegistryKey registryKey = Registry.CurrentUser.OpenSubKey(MyPackageFrameworkVersion.GetRegistryFIPKeyPath(), true);
                    foreach (string subKeyName in registryKey.GetSubKeyNames())
                        if (subKeyName.StartsWith(MyPackageFrameworkVersion.GetRegistrySubKeyPath()))
                            registryKey.DeleteSubKeyTree(subKeyName);
                }
                catch { }
            }
    
            protected override void OnAfterUninstall(IDictionary savedState)
            {
                base.OnAfterUninstall(savedState);
                try
                {
                    DeleteLogFiles(savedState);
                    DeleteLicenseFiles(savedState);
                    DeleteFiles(savedState);
                    DeleteRootDirectory(savedState);
                    DeleteRegistryKey();
                }
                catch { }
            }
    
            protected override void OnAfterInstall(IDictionary savedState)
            {
                base.OnAfterInstall(savedState);
                SetRightsOnLogs(savedState);
            }
        }
    }

    Ci-dessous, deux captures de la procédure d'installation :

    1/ définition de l'emplacement choisi pour installer

    2/ Erreur au cours de l'installation suite à l'altération du chemin choisi





    lundi 21 mai 2012 12:50

Réponses

Toutes les réponses