Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Changes In Branch VsInstallerWork Excluding Merge-Ins
This is equivalent to a diff from 813e72935f to 91450285a2
2012-01-04
| ||
03:04 | Merge the VS designer component installer changes to the trunk. check-in: b01877dd2c user: mistachkin tags: trunk | |
03:01 | Use the 'thisAssembly' variable consistently when showing a message box to the interactive user. Closed-Leaf check-in: 91450285a2 user: mistachkin tags: VsInstallerWork | |
2012-01-03
| ||
08:09 | Remove unnecessary local variable. check-in: 7918c37463 user: mistachkin tags: VsInstallerWork | |
2012-01-02
| ||
12:14 | Work on making the installer tool verify that the core assembly is supported by the requested versions of Visual Studio (i.e. based on the image runtime version). check-in: 16872024de user: mistachkin tags: VsInstallerWork | |
03:46 | Make sure the DbProviderFactory modifications by the installer are logged at the highest priority level and are always logged in 'what-if' mode. check-in: 813e72935f user: mistachkin tags: trunk | |
2012-01-01
| ||
06:06 | Cleanup log file name variables used by the installer unit tests. check-in: 98632c4b63 user: mistachkin tags: trunk | |
Changes to Tests/common.eagle.
︙ | ︙ | |||
298 299 300 301 302 303 304 | } } proc tryLoadAssembly { fileName } { set fileName [getBinaryFileName $fileName] if {[catch {set assembly \ | | > > > > > > > | 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 | } } proc tryLoadAssembly { fileName } { set fileName [getBinaryFileName $fileName] if {[catch {set assembly \ [object load -loadtype File -alias $fileName]}] == 0} then { # # NOTE: Now, add the necessary test constraint. # addConstraint [file rootname [file tail $fileName]] # # NOTE: Grab the image runtime version from the assembly because # several tests rely on it having a certain value. # addConstraint [appendArgs [file tail $fileName] _ \ [$assembly ImageRuntimeVersion]] # # NOTE: Return the full path of the loaded file. # return $fileName } return "" |
︙ | ︙ | |||
703 704 705 706 707 708 709 710 711 712 713 714 715 716 | # checkForSQLite $::test_channel # # NOTE: Report the resource usage prior to running any tests. # reportSQLiteResources $::test_channel } } proc runSQLiteTestEpilogue {} { # # NOTE: Skip running our custom epilogue if the main one has been skipped. # | > > > > > > | 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 | # checkForSQLite $::test_channel # # NOTE: Report the resource usage prior to running any tests. # reportSQLiteResources $::test_channel # # NOTE: Show the active test constraints. # tputs $::test_channel [appendArgs "---- constraints: " \ [formatList [lsort [getConstraints]]] \n] } } proc runSQLiteTestEpilogue {} { # # NOTE: Skip running our custom epilogue if the main one has been skipped. # |
︙ | ︙ |
Changes to Tests/installer.eagle.
︙ | ︙ | |||
86 87 88 89 90 91 92 | list $code [expr {$code == 0 ? [string equal [readFile $fileName] \ [subst -nobackslashes [readFile $testInstallVs2008LogFile]]] : $error}] } -cleanup { catch {file delete $fileName} unset -nocomplain code output error fileName | | | < | 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 | list $code [expr {$code == 0 ? [string equal [readFile $fileName] \ [subst -nobackslashes [readFile $testInstallVs2008LogFile]]] : $error}] } -cleanup { catch {file delete $fileName} unset -nocomplain code output error fileName } -constraints {eagle visualStudio2008 System.Data.SQLite.dll_v2.0.50727\ file_Installer.exe file_Installer_Test_Vs2008.log} -result {0 True}} ############################################################################### runTest {test installer-1.2 {uninstaller tool / Visual Studio 2008} -setup { set fileName [file join [getTemporaryPath] \ [file tail $testUninstallVs2008LogFile]] |
︙ | ︙ | |||
118 119 120 121 122 123 124 | list $code [expr {$code == 0 ? [string equal [readFile $fileName] \ [subst -nobackslashes [readFile $testUninstallVs2008LogFile]]] : $error}] } -cleanup { catch {file delete $fileName} unset -nocomplain code output error fileName | | | < | 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 | list $code [expr {$code == 0 ? [string equal [readFile $fileName] \ [subst -nobackslashes [readFile $testUninstallVs2008LogFile]]] : $error}] } -cleanup { catch {file delete $fileName} unset -nocomplain code output error fileName } -constraints {eagle visualStudio2008 System.Data.SQLite.dll_v2.0.50727\ file_Installer.exe file_Uninstaller_Test_Vs2008.log} -result {0 True}} ############################################################################### runTest {test installer-1.3 {installer tool / Visual Studio 2010} -setup { set fileName [file join [getTemporaryPath] \ [file tail $testInstallVs2010LogFile]] |
︙ | ︙ | |||
150 151 152 153 154 155 156 | list $code [expr {$code == 0 ? [string equal [readFile $fileName] \ [subst -nobackslashes [readFile $testInstallVs2010LogFile]]] : $error}] } -cleanup { catch {file delete $fileName} unset -nocomplain code output error fileName | | | < | 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 | list $code [expr {$code == 0 ? [string equal [readFile $fileName] \ [subst -nobackslashes [readFile $testInstallVs2010LogFile]]] : $error}] } -cleanup { catch {file delete $fileName} unset -nocomplain code output error fileName } -constraints {eagle visualStudio2010 System.Data.SQLite.dll_v4.0.30319\ file_Installer.exe file_Installer_Test_Vs2010.log} -result {0 True}} ############################################################################### runTest {test installer-1.4 {uninstaller tool / Visual Studio 2010} -setup { set fileName [file join [getTemporaryPath] \ [file tail $testUninstallVs2010LogFile]] |
︙ | ︙ | |||
182 183 184 185 186 187 188 | list $code [expr {$code == 0 ? [string equal [readFile $fileName] \ [subst -nobackslashes [readFile $testUninstallVs2010LogFile]]] : $error}] } -cleanup { catch {file delete $fileName} unset -nocomplain code output error fileName | | | < | 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 | list $code [expr {$code == 0 ? [string equal [readFile $fileName] \ [subst -nobackslashes [readFile $testUninstallVs2010LogFile]]] : $error}] } -cleanup { catch {file delete $fileName} unset -nocomplain code output error fileName } -constraints {eagle visualStudio2010 System.Data.SQLite.dll_v4.0.30319\ file_Installer.exe file_Uninstaller_Test_Vs2010.log} -result {0 True}} ############################################################################### unset -nocomplain testUninstallVs2010LogFile testUninstallVs2008LogFile \ testInstallVs2010LogFile testInstallVs2008LogFile installerExeFile \ systemDataSQLiteDllFile ############################################################################### runSQLiteTestEpilogue runTestEpilogue |
Changes to tools/install/Installer.cs.
︙ | ︙ | |||
54 55 56 57 58 59 60 | ); /////////////////////////////////////////////////////////////////////////// internal delegate bool VisualStudioRegistryCallback( RegistryKey rootKey, Version vsVersion, | | < < < | 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 | ); /////////////////////////////////////////////////////////////////////////// internal delegate bool VisualStudioRegistryCallback( RegistryKey rootKey, Version vsVersion, Installer.Package package, object clientData, bool whatIf, bool verbose, ref string error ); #endregion |
︙ | ︙ | |||
1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 | // do nothing. } } #endregion /////////////////////////////////////////////////////////////////////// #region Configuration Class private sealed class Configuration { #region Private Constants private const char Switch = '-'; private const char AltSwitch = '/'; | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 | // do nothing. } } #endregion /////////////////////////////////////////////////////////////////////// #region VersionListMap Class private sealed class VersionListMap : Dictionary<Version, VersionList> { public VersionListMap() { // do nothing. } } #endregion /////////////////////////////////////////////////////////////////////// #region Package Class internal sealed class Package { #region Public Constructors public Package() { // do nothing. } #endregion /////////////////////////////////////////////////////////////////// #region Public Properties private Guid packageId; public Guid PackageId { get { return packageId; } set { packageId = value; } } /////////////////////////////////////////////////////////////////// private Guid serviceId; public Guid ServiceId { get { return serviceId; } set { serviceId = value; } } /////////////////////////////////////////////////////////////////// private Guid dataSourceId; public Guid DataSourceId { get { return dataSourceId; } set { dataSourceId = value; } } /////////////////////////////////////////////////////////////////// private Guid dataProviderId; public Guid DataProviderId { get { return dataProviderId; } set { dataProviderId = value; } } /////////////////////////////////////////////////////////////////// private Guid adoNetTechnologyId; public Guid AdoNetTechnologyId { get { return adoNetTechnologyId; } set { adoNetTechnologyId = value; } } #endregion } #endregion /////////////////////////////////////////////////////////////////////// #region Configuration Class private sealed class Configuration { #region Private Constants private const char Switch = '-'; private const char AltSwitch = '/'; |
︙ | ︙ | |||
2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 | // // NOTE: Show where we are running from and how we were // invoked. // string location = assembly.Location; TraceOps.Trace( TracePriority.Medium, traceCallback, String.Format( "Original command line is: {0}", Environment.CommandLine), traceCategory); if (!configuration.whatIf) { | > > > > > | 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 | // // NOTE: Show where we are running from and how we were // invoked. // string location = assembly.Location; TraceOps.Trace( TracePriority.Medium, traceCallback, String.Format( "Running executable is: {0}", ForDisplay(location)), traceCategory); TraceOps.Trace( TracePriority.Medium, traceCallback, String.Format( "Original command line is: {0}", Environment.CommandLine), traceCategory); if (!configuration.whatIf) { |
︙ | ︙ | |||
2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 | { TraceOps.Trace( TracePriority.Highest, traceCallback, e, traceCategory); error = "Failed to process configuration."; } return false; } #endregion /////////////////////////////////////////////////////////////////// | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 | { TraceOps.Trace( TracePriority.Highest, traceCallback, e, traceCategory); error = "Failed to process configuration."; } return false; } /////////////////////////////////////////////////////////////////// public static bool CheckRuntimeVersion( Configuration configuration, bool strict, ref string error ) { try { if (configuration == null) { error = "Invalid configuration."; return false; } // // NOTE: What version of the runtime was the core (primary) // assembly compiled against (e.g. "v2.0.50727" or // "v4.0.30319"). // string coreImageRuntimeVersion = GetImageRuntimeVersion( configuration.coreFileName); // // TODO: Restrict the configuration based on which image // runtime versions (which more-or-less correspond // to .NET Framework versions) are supported by the // versions of Visual Studio that are installed. // if (String.IsNullOrEmpty(coreImageRuntimeVersion)) { error = "invalid core file image runtime version"; return false; } else if (String.Equals( coreImageRuntimeVersion, CLR2ImageRuntimeVersion, StringComparison.InvariantCulture)) { // // NOTE: For the CLR v2.0 runtime, make sure we disable // any attempt to use it for things that require // an assembly compiled for the CLR v4.0. It is // uncertain if this is actually a problem in // practice as the CLR v4.0 can load and use an // assembly compiled with the CLR v2.0; however, // since this project offers both configurations, // we currently disallow this mismatch. // configuration.noNetFx40 = true; configuration.noVs2010 = true; TraceOps.Trace( TracePriority.Medium, traceCallback, String.Format( "Assembly is compiled for the .NET Framework {0}, " + "support for .NET Framework {1} is now disabled.", CLR2ImageRuntimeVersion, CLR4ImageRuntimeVersion), traceCategory); } else if (String.Equals( coreImageRuntimeVersion, CLR4ImageRuntimeVersion, StringComparison.InvariantCulture)) { // // NOTE: For the CLR v4.0 runtime, make sure we disable // any attempt to use it for things that require // an assembly compiled for the CLR v2.0. // configuration.noNetFx20 = true; configuration.noVs2008 = true; TraceOps.Trace( TracePriority.Medium, traceCallback, String.Format( "Assembly is compiled for the .NET Framework {0}, " + "support for .NET Framework {1} is now disabled.", ForDisplay(CLR4ImageRuntimeVersion), ForDisplay(CLR2ImageRuntimeVersion)), traceCategory); } else { error = String.Format( "unsupported core file image runtime version " + "{0}, must be {1} or {2}", ForDisplay(coreImageRuntimeVersion), ForDisplay(CLR2ImageRuntimeVersion), ForDisplay(CLR4ImageRuntimeVersion)); return false; } return true; } catch (Exception e) { TraceOps.Trace( TracePriority.Highest, traceCallback, e, traceCategory); error = "Failed to check image runtime version."; } return false; } #endregion /////////////////////////////////////////////////////////////////// |
︙ | ︙ | |||
2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 | { get { return confirm; } set { confirm = value; } } #endregion } #endregion #endregion /////////////////////////////////////////////////////////////////////// #region Private Constant Data private const string CoreFileName = "System.Data.SQLite.dll"; private const string LinqFileName = "System.Data.SQLite.Linq.dll"; private const string DesignerFileName = "SQLite.Designer.dll"; private const string ProviderName = "SQLite Data Provider"; private const string ProjectName = "System.Data.SQLite"; private const string LegacyProjectName = "SQLite"; private const string InvariantName = "System.Data.SQLite"; private const string FactoryTypeName = "System.Data.SQLite.SQLiteFactory"; private const string Description = ".NET Framework Data Provider for SQLite"; /////////////////////////////////////////////////////////////////////// private const string NameAndValueFormat = "{0}: {1}"; private const string LogFileSuffix = ".log"; /////////////////////////////////////////////////////////////////////// | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 | { get { return confirm; } set { confirm = value; } } #endregion } #endregion /////////////////////////////////////////////////////////////////////// #region FrameworkList Class private sealed class FrameworkList { #region Public Constructors public FrameworkList() { // do nothing. } #endregion /////////////////////////////////////////////////////////////////// #region Public Methods private RegistryKey rootKey; public RegistryKey RootKey { get { return rootKey; } set { rootKey = value; } } /////////////////////////////////////////////////////////////////// private StringList names; public StringList Names { get { return names; } set { names = value; } } /////////////////////////////////////////////////////////////////// private VersionMap versions; public VersionMap Versions { get { return versions; } set { versions = value; } } /////////////////////////////////////////////////////////////////// private StringList platformNames; public StringList PlatformNames { get { return platformNames; } set { platformNames = value; } } #endregion } #endregion /////////////////////////////////////////////////////////////////////// #region VsList Class private sealed class VsList { #region Public Constructors public VsList() { // do nothing. } #endregion /////////////////////////////////////////////////////////////////// #region Public Properties private RegistryKey rootKey; public RegistryKey RootKey { get { return rootKey; } set { rootKey = value; } } /////////////////////////////////////////////////////////////////// private VersionList versions; public VersionList Versions { get { return versions; } set { versions = value; } } /////////////////////////////////////////////////////////////////// private VersionListMap frameworkVersions; public VersionListMap FrameworkVersions { get { return frameworkVersions; } set { frameworkVersions = value; } } /////////////////////////////////////////////////////////////////// private VersionList installedVersions; public VersionList InstalledVersions { get { return installedVersions; } set { installedVersions = value; } } #endregion } #endregion #endregion /////////////////////////////////////////////////////////////////////// #region Private Constant Data private const string CoreFileName = "System.Data.SQLite.dll"; private const string LinqFileName = "System.Data.SQLite.Linq.dll"; private const string DesignerFileName = "SQLite.Designer.dll"; private const string ProviderName = "SQLite Data Provider"; private const string ProjectName = "System.Data.SQLite"; private const string LegacyProjectName = "SQLite"; private const string InvariantName = "System.Data.SQLite"; private const string FactoryTypeName = "System.Data.SQLite.SQLiteFactory"; private const string Description = ".NET Framework Data Provider for SQLite"; /////////////////////////////////////////////////////////////////////// private const string CLR2ImageRuntimeVersion = "v2.0.50727"; private const string CLR4ImageRuntimeVersion = "v4.0.30319"; /////////////////////////////////////////////////////////////////////// private const string NameAndValueFormat = "{0}: {1}"; private const string LogFileSuffix = ".log"; /////////////////////////////////////////////////////////////////////// |
︙ | ︙ | |||
2479 2480 2481 2482 2483 2484 2485 | private static readonly string XPathForRemoveElement = "configuration/system.data/DbProviderFactories/remove[@invariant=\"{0}\"]"; #endregion /////////////////////////////////////////////////////////////////////// | | < < < < < < < < < < < < < < < < < | 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 | private static readonly string XPathForRemoveElement = "configuration/system.data/DbProviderFactories/remove[@invariant=\"{0}\"]"; #endregion /////////////////////////////////////////////////////////////////////// #region Private Static Data private static Assembly thisAssembly = Assembly.GetExecutingAssembly(); private static string traceCategory = Path.GetFileName( thisAssembly.Location); private static TraceCallback traceCallback = AppTrace; #endregion /////////////////////////////////////////////////////////////////////// #region Trace Handling private static string GetLogFileName() { |
︙ | ︙ | |||
2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 | return result; } #endregion /////////////////////////////////////////////////////////////////////// #region .NET Framework Handling private static string GetFrameworkDirectory( RegistryKey rootKey, Version frameworkVersion, bool whatIf, bool verbose ) { | > > > > > > > > > > > > > > > > > > > > > > | 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 | return result; } #endregion /////////////////////////////////////////////////////////////////////// #region .NET Framework Handling private static string GetImageRuntimeVersion( string fileName ) { try { Assembly assembly = Assembly.ReflectionOnlyLoadFrom(fileName); /* throw */ if (assembly != null) return assembly.ImageRuntimeVersion; } catch { // do nothing. } return null; } /////////////////////////////////////////////////////////////////////// private static string GetFrameworkDirectory( RegistryKey rootKey, Version frameworkVersion, bool whatIf, bool verbose ) { |
︙ | ︙ | |||
2722 2723 2724 2725 2726 2727 2728 | return null; } #endregion /////////////////////////////////////////////////////////////////////// #region Per-Framework/Platform Handling | | | > > > > | | > > | | | | | | > > | > | | | | | | | | > | | | | | | | | | | | > | > > | | | | | | 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 | return null; } #endregion /////////////////////////////////////////////////////////////////////// #region Per-Framework/Platform Handling private static void InitializeFrameworkList( Configuration configuration, ref FrameworkList frameworkList ) { if (frameworkList == null) frameworkList = new FrameworkList(); if (frameworkList.RootKey == null) frameworkList.RootKey = Registry.LocalMachine; /////////////////////////////////////////////////////////////////// if (frameworkList.Names == null) { frameworkList.Names = new StringList(); if ((configuration == null) || !configuration.NoDesktop) frameworkList.Names.Add(".NETFramework"); if ((configuration == null) || !configuration.NoCompact) { frameworkList.Names.Add(".NETCompactFramework"); frameworkList.Names.Add(".NETCompactFramework"); frameworkList.Names.Add(".NETCompactFramework"); } } /////////////////////////////////////////////////////////////////// if (frameworkList.Versions == null) { frameworkList.Versions = new VersionMap(); if ((configuration == null) || !configuration.NoDesktop) { VersionList desktopVersionList = new VersionList(); if ((configuration == null) || !configuration.NoNetFx20) desktopVersionList.Add(new Version(2, 0, 50727)); if ((configuration == null) || !configuration.NoNetFx40) desktopVersionList.Add(new Version(4, 0, 30319)); frameworkList.Versions.Add(".NETFramework", desktopVersionList); } if ((configuration == null) || !configuration.NoCompact) { frameworkList.Versions.Add(".NETCompactFramework", new VersionList(new Version[] { new Version(2, 0, 0, 0), new Version(3, 5, 0, 0) })); } } /////////////////////////////////////////////////////////////////// if (frameworkList.PlatformNames == null) { frameworkList.PlatformNames = new StringList(); if ((configuration == null) || !configuration.NoDesktop) frameworkList.PlatformNames.Add(null); if ((configuration == null) || !configuration.NoCompact) { frameworkList.PlatformNames.Add("PocketPC"); frameworkList.PlatformNames.Add("Smartphone"); frameworkList.PlatformNames.Add("WindowsCE"); } } } /////////////////////////////////////////////////////////////////////// private static bool HaveFramework( |
︙ | ︙ | |||
2808 2809 2810 2811 2812 2813 2814 | using (MockRegistryKey key = RegistryHelper.OpenSubKey( rootKey, keyName, false, whatIf, verbose)) { if (key == null) return false; | | > > > > > > > | | | | | | | | | | | | 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 | using (MockRegistryKey key = RegistryHelper.OpenSubKey( rootKey, keyName, false, whatIf, verbose)) { if (key == null) return false; if (platformName != null) // NOTE: Skip non-desktop. return true; string directory = GetFrameworkDirectory( rootKey, frameworkVersion, whatIf, verbose); if (String.IsNullOrEmpty(directory)) return false; if (!Directory.Exists(directory)) return false; return true; } } /////////////////////////////////////////////////////////////////////// private static bool ForEachFrameworkConfig( FrameworkList frameworkList, FrameworkConfigCallback callback, string invariant, string name, string description, string typeName, AssemblyName assemblyName, object clientData, bool whatIf, bool verbose, ref bool saved, ref string error ) { if (frameworkList == null) { error = "invalid framework list"; return false; } RegistryKey rootKey = frameworkList.RootKey; if (rootKey == null) { error = "invalid root key"; return false; } if (!Object.ReferenceEquals(rootKey, Registry.CurrentUser) && !Object.ReferenceEquals(rootKey, Registry.LocalMachine)) { error = "root key must be per-user or per-machine"; return false; } if (frameworkList.Names == null) { error = "no framework names found"; return false; } if (frameworkList.Versions == null) { error = "no framework versions found"; return false; } if (frameworkList.PlatformNames == null) { error = "no platform names found"; return false; } if (frameworkList.Names.Count != frameworkList.PlatformNames.Count) { error = String.Format("framework name count {0} does not " + "match platform name count {1}", frameworkList.Names.Count, frameworkList.PlatformNames.Count); return false; } for (int index = 0; index < frameworkList.Names.Count; index++) { // // NOTE: Grab the name of the framework (e.g. ".NETFramework") // and the name of the platform (e.g. "WindowsCE"). // string frameworkName = frameworkList.Names[index]; string platformName = frameworkList.PlatformNames[index]; // // NOTE: Skip all non-desktop frameworks (i.e. if the platform // name is not null). // if (platformName != null) continue; // // NOTE: Grab the supported versions of this particular // framework. // VersionList frameworkVersionList; if (!frameworkList.Versions.TryGetValue( frameworkName, out frameworkVersionList) || (frameworkVersionList == null)) { continue; } foreach (Version frameworkVersion in frameworkVersionList) |
︙ | ︙ | |||
3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 | return true; } /////////////////////////////////////////////////////////////////////// private static bool ForEachFrameworkRegistry( FrameworkRegistryCallback callback, object clientData, bool whatIf, bool verbose, ref string error ) { | > > > > > > > | | | | | | | | | | | | 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 | return true; } /////////////////////////////////////////////////////////////////////// private static bool ForEachFrameworkRegistry( FrameworkList frameworkList, FrameworkRegistryCallback callback, object clientData, bool whatIf, bool verbose, ref string error ) { if (frameworkList == null) { error = "invalid framework list"; return false; } RegistryKey rootKey = frameworkList.RootKey; if (rootKey == null) { error = "invalid root key"; return false; } if (!Object.ReferenceEquals(rootKey, Registry.CurrentUser) && !Object.ReferenceEquals(rootKey, Registry.LocalMachine)) { error = "root key must be per-user or per-machine"; return false; } if (frameworkList.Names == null) { error = "no framework names found"; return false; } if (frameworkList.Versions == null) { error = "no framework versions found"; return false; } if (frameworkList.PlatformNames == null) { error = "no platform names found"; return false; } if (frameworkList.Names.Count != frameworkList.PlatformNames.Count) { error = String.Format("framework name count {0} does not " + "match platform name count {1}", frameworkList.Names.Count, frameworkList.PlatformNames.Count); return false; } for (int index = 0; index < frameworkList.Names.Count; index++) { // // NOTE: Grab the name of the framework (e.g. ".NETFramework") // and the name of the platform (e.g. "WindowsCE"). // string frameworkName = frameworkList.Names[index]; string platformName = frameworkList.PlatformNames[index]; // // NOTE: Grab the supported versions of this particular // framework. // VersionList frameworkVersionList; if (!frameworkList.Versions.TryGetValue( frameworkName, out frameworkVersionList) || (frameworkVersionList == null)) { continue; } foreach (Version frameworkVersion in frameworkVersionList) |
︙ | ︙ | |||
3117 3118 3119 3120 3121 3122 3123 | return true; } #endregion /////////////////////////////////////////////////////////////////////// #region Per-Visual Studio Version Handling | | | > > > > | | | < < | < | | > | < < > | < | | < < < | | | > > | > > | > > > > > > | 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 | return true; } #endregion /////////////////////////////////////////////////////////////////////// #region Per-Visual Studio Version Handling private static void InitializeVsList( Configuration configuration, ref VsList vsList ) { if (vsList == null) vsList = new VsList(); if (vsList.RootKey == null) vsList.RootKey = Registry.LocalMachine; if (vsList.Versions == null) { vsList.Versions = new VersionList(); // vsList.Versions.Add(new Version(8, 0)); // Visual Studio 2005 if ((configuration == null) || !configuration.NoVs2008) vsList.Versions.Add(new Version(9, 0)); // Visual Studio 2008 if ((configuration == null) || !configuration.NoVs2010) vsList.Versions.Add(new Version(10, 0));// Visual Studio 2010 } if (vsList.FrameworkVersions == null) { vsList.FrameworkVersions = new VersionListMap(); // vsList.FrameworkVersions.Add(new Version(8, 0), // new VersionList(new Version[] { // new Version(2, 0, 50727) })); if ((configuration == null) || !configuration.NoVs2008) vsList.FrameworkVersions.Add(new Version(9, 0), new VersionList(new Version[] { new Version(2, 0, 50727) })); if ((configuration == null) || !configuration.NoVs2010) vsList.FrameworkVersions.Add(new Version(10, 0), new VersionList(new Version[] { new Version(2, 0, 50727), new Version(4, 0, 30319) })); } } /////////////////////////////////////////////////////////////////////// private static bool HaveVsVersion( RegistryKey rootKey, Version vsVersion, bool whatIf, bool verbose ) { if (vsVersion == null) return false; string format = "Software\\Microsoft\\VisualStudio\\{0}"; string keyName = String.Format(format, vsVersion); using (MockRegistryKey key = RegistryHelper.OpenSubKey( rootKey, keyName, false, whatIf, verbose)) { if (key == null) |
︙ | ︙ | |||
3197 3198 3199 3200 3201 3202 3203 3204 | return true; } } /////////////////////////////////////////////////////////////////////// private static bool ForEachVsVersionRegistry( VisualStudioRegistryCallback callback, | > | < < < > > > > > > | | | | < | 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 | return true; } } /////////////////////////////////////////////////////////////////////// private static bool ForEachVsVersionRegistry( VsList vsList, VisualStudioRegistryCallback callback, Package package, object clientData, bool whatIf, bool verbose, ref string error ) { if (vsList == null) { error = "invalid VS list"; return false; } RegistryKey rootKey = vsList.RootKey; if (rootKey == null) { error = "invalid root key"; return false; } if (!Object.ReferenceEquals(rootKey, Registry.CurrentUser) && !Object.ReferenceEquals(rootKey, Registry.LocalMachine)) { error = "root key must be per-user or per-machine"; return false; } if (vsList.Versions == null) { error = "no VS versions found"; return false; } foreach (Version vsVersion in vsList.Versions) { TraceOps.Trace( TracePriority.Lower, traceCallback, String.Format( "vsVersion = {0}", ForDisplay(vsVersion)), traceCategory); if (!HaveVsVersion(rootKey, vsVersion, whatIf, verbose)) { TraceOps.Trace(TracePriority.Low, traceCallback, "Visual Studio version not found, skipping...", traceCategory); continue; } if (callback == null) continue; if (!callback( rootKey, vsVersion, package, clientData, whatIf, verbose, ref error)) { return false; } } return true; |
︙ | ︙ | |||
3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 | /////////////////////////////////////////////////////////////////////// #region Visual Studio Handling private static string GetVsKeyName( Version vsVersion ) { return String.Format("Software\\Microsoft\\VisualStudio\\{0}", vsVersion); } /////////////////////////////////////////////////////////////////////// #region Visual Studio Data Source Handling private static bool AddVsDataSource( RegistryKey rootKey, Version vsVersion, | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | < > > > > > > > > > > > > | 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 | /////////////////////////////////////////////////////////////////////// #region Visual Studio Handling private static string GetVsKeyName( Version vsVersion ) { if (vsVersion == null) return null; return String.Format("Software\\Microsoft\\VisualStudio\\{0}", vsVersion); } /////////////////////////////////////////////////////////////////////// #region Visual Studio Version Handling private static bool AddVsVersion( RegistryKey rootKey, Version vsVersion, Package package, object clientData, bool whatIf, bool verbose, ref string error ) { if (vsVersion != null) { VsList vsList = clientData as VsList; if (vsList != null) { if (vsList.InstalledVersions == null) vsList.InstalledVersions = new VersionList(); if (!vsList.InstalledVersions.Contains(vsVersion)) vsList.InstalledVersions.Add(vsVersion); } } return true; } #endregion /////////////////////////////////////////////////////////////////////// #region Visual Studio Data Source Handling private static bool AddVsDataSource( RegistryKey rootKey, Version vsVersion, Package package, bool whatIf, bool verbose, ref string error ) { if (vsVersion == null) { error = "invalid VS version"; return false; } if (package == null) { error = "invalid VS package"; return false; } string keyName = GetVsKeyName(vsVersion); using (MockRegistryKey key = RegistryHelper.OpenSubKey( rootKey, keyName, false, whatIf, verbose)) { if (key == null) { |
︙ | ︙ | |||
3649 3650 3651 3652 3653 3654 3655 | error = String.Format( "could not open registry key: {0}\\DataSources", key); return false; } | | > | | | | | | | > > > > > > > > > > > > | 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 | error = String.Format( "could not open registry key: {0}\\DataSources", key); return false; } using (MockRegistryKey dataSourceKey = RegistryHelper.CreateSubKey(subKey, package.DataSourceId.ToString(VsIdFormat), whatIf, verbose)) { if (dataSourceKey == null) { error = String.Format( "could not create registry key: {0}\\{1}", key, package.DataSourceId.ToString(VsIdFormat)); return false; } RegistryHelper.SetValue( dataSourceKey, null, String.Format( "{0} Database File", ProjectName), whatIf, verbose); RegistryHelper.CreateSubKey(dataSourceKey, String.Format("SupportingProviders\\{0}", package.DataProviderId.ToString(VsIdFormat)), whatIf, verbose); } } } return true; } /////////////////////////////////////////////////////////////////////// private static bool RemoveVsDataSource( RegistryKey rootKey, Version vsVersion, Package package, bool whatIf, bool verbose, ref string error ) { if (vsVersion == null) { error = "invalid VS version"; return false; } if (package == null) { error = "invalid VS package"; return false; } string keyName = GetVsKeyName(vsVersion); using (MockRegistryKey key = RegistryHelper.OpenSubKey( rootKey, keyName, false, whatIf, verbose)) { if (key == null) { |
︙ | ︙ | |||
3716 3717 3718 3719 3720 3721 3722 | "could not open registry key: {0}\\DataSources", key); return false; } RegistryHelper.DeleteSubKeyTree( | | | | < < < > > > > > > < | | < | < > > > > > | > | | 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 | "could not open registry key: {0}\\DataSources", key); return false; } RegistryHelper.DeleteSubKeyTree( subKey, package.DataSourceId.ToString(VsIdFormat), whatIf, verbose); } } return true; } /////////////////////////////////////////////////////////////////////// private static bool ProcessVsDataSource( RegistryKey rootKey, Version vsVersion, Package package, object clientData, bool whatIf, bool verbose, ref string error ) { if (package == null) { error = "invalid VS package"; return false; } AnyPair<string, bool> pair = clientData as AnyPair<string, bool>; if (pair == null) { error = "invalid VS callback data"; return false; } if (pair.Y) { return AddVsDataSource( rootKey, vsVersion, package, whatIf, verbose, ref error); } else { return RemoveVsDataSource( rootKey, vsVersion, package, whatIf, verbose, ref error); } } #endregion /////////////////////////////////////////////////////////////////////// #region Visual Studio Data Provider Handling private static bool AddVsDataProvider( RegistryKey rootKey, Version vsVersion, Package package, string fileName, bool whatIf, bool verbose, ref string error ) { if (vsVersion == null) { error = "invalid VS version"; return false; } if (package == null) { error = "invalid VS package"; return false; } string keyName = GetVsKeyName(vsVersion); using (MockRegistryKey key = RegistryHelper.OpenSubKey( rootKey, keyName, false, whatIf, verbose)) |
︙ | ︙ | |||
3808 3809 3810 3811 3812 3813 3814 | error = String.Format( "could not open registry key: {0}\\DataProviders", key); return false; } | | > | | | | | | > | 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 | error = String.Format( "could not open registry key: {0}\\DataProviders", key); return false; } using (MockRegistryKey dataProviderKey = RegistryHelper.CreateSubKey(subKey, package.DataProviderId.ToString(VsIdFormat), whatIf, verbose)) { if (dataProviderKey == null) { error = String.Format( "could not create registry key: {0}\\{1}", key, package.DataProviderId.ToString(VsIdFormat)); return false; } RegistryHelper.SetValue( dataProviderKey, null, Description, whatIf, verbose); RegistryHelper.SetValue( dataProviderKey, "InvariantName", InvariantName, whatIf, verbose); RegistryHelper.SetValue( dataProviderKey, "Technology", package.AdoNetTechnologyId.ToString(VsIdFormat), whatIf, verbose); RegistryHelper.SetValue( dataProviderKey, "CodeBase", fileName, whatIf, verbose); RegistryHelper.SetValue( dataProviderKey, "FactoryService", package.ServiceId.ToString(VsIdFormat), whatIf, verbose); RegistryHelper.CreateSubKey(dataProviderKey, "SupportedObjects\\DataConnectionUIControl", whatIf, verbose); RegistryHelper.CreateSubKey(dataProviderKey, "SupportedObjects\\DataConnectionProperties", |
︙ | ︙ | |||
3873 3874 3875 3876 3877 3878 3879 | } /////////////////////////////////////////////////////////////////////// private static bool RemoveVsDataProvider( RegistryKey rootKey, Version vsVersion, | | > > > > > > | 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 | } /////////////////////////////////////////////////////////////////////// private static bool RemoveVsDataProvider( RegistryKey rootKey, Version vsVersion, Package package, bool whatIf, bool verbose, ref string error ) { if (vsVersion == null) { error = "invalid VS version"; return false; } string keyName = GetVsKeyName(vsVersion); using (MockRegistryKey key = RegistryHelper.OpenSubKey( rootKey, keyName, false, whatIf, verbose)) { if (key == null) { |
︙ | ︙ | |||
3906 3907 3908 3909 3910 3911 3912 | "could not open registry key: {0}\\DataProviders", key); return false; } RegistryHelper.DeleteSubKeyTree( | | | | < < < | | | > > > > > > > > > > > > > > > > > > > > > > > > > > > | < > > > > > > > > > > > > | 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 | "could not open registry key: {0}\\DataProviders", key); return false; } RegistryHelper.DeleteSubKeyTree( subKey, package.DataProviderId.ToString(VsIdFormat), whatIf, verbose); } } return true; } /////////////////////////////////////////////////////////////////////// private static bool ProcessVsDataProvider( RegistryKey rootKey, Version vsVersion, Package package, object clientData, bool whatIf, bool verbose, ref string error ) { AnyPair<string, bool> pair = clientData as AnyPair<string, bool>; if (pair == null) { error = "invalid VS callback data"; return false; } if (pair.Y) { return AddVsDataProvider( rootKey, vsVersion, package, pair.X, whatIf, verbose, ref error); } else { return RemoveVsDataProvider( rootKey, vsVersion, package, whatIf, verbose, ref error); } } #endregion /////////////////////////////////////////////////////////////////////// #region Visual Studio Package Handling private static void InitializeVsPackage( ref Package package ) { if (package == null) { package = new Package(); package.AdoNetTechnologyId = new Guid( "77AB9A9D-78B9-4BA7-91AC-873F5338F1D2"); package.PackageId = new Guid( "DCBE6C8D-0E57-4099-A183-98FF74C64D9C"); package.ServiceId = new Guid( "DCBE6C8D-0E57-4099-A183-98FF74C64D9D"); package.DataSourceId = new Guid( "0EBAAB6E-CA80-4B4A-8DDF-CBE6BF058C71"); package.DataProviderId = new Guid( "0EBAAB6E-CA80-4B4A-8DDF-CBE6BF058C70"); } } /////////////////////////////////////////////////////////////////////// private static bool AddVsPackage( RegistryKey rootKey, Version vsVersion, Package package, string fileName, bool whatIf, bool verbose, ref string error ) { if (vsVersion == null) { error = "invalid VS version"; return false; } if (package == null) { error = "invalid VS package"; return false; } string keyName = GetVsKeyName(vsVersion); using (MockRegistryKey key = RegistryHelper.OpenSubKey( rootKey, keyName, false, whatIf, verbose)) { if (key == null) { |
︙ | ︙ | |||
3993 3994 3995 3996 3997 3998 3999 | "could not open registry key: {0}\\Packages", key); return false; } using (MockRegistryKey packageKey = RegistryHelper.CreateSubKey( | | | | 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 | "could not open registry key: {0}\\Packages", key); return false; } using (MockRegistryKey packageKey = RegistryHelper.CreateSubKey( subKey, package.PackageId.ToString(VsIdFormat), whatIf, verbose)) { if (packageKey == null) { error = String.Format( "could not create registry key: {0}\\{1}", key, package.PackageId.ToString(VsIdFormat)); return false; } RegistryHelper.SetValue(packageKey, null, String.Format( "{0} Designer Package", ProjectName), whatIf, verbose); |
︙ | ︙ | |||
4067 4068 4069 4070 4071 4072 4073 | "could not open registry key: {0}\\Menus", key); return false; } RegistryHelper.SetValue( | | | | | | > | < > > > > > > > > > > > > | 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 | "could not open registry key: {0}\\Menus", key); return false; } RegistryHelper.SetValue( subKey, package.PackageId.ToString(VsIdFormat), ", 1000, 3", whatIf, verbose); } using (MockRegistryKey subKey = RegistryHelper.OpenSubKey( key, "Services", true, whatIf, verbose)) { if (subKey == null) { error = String.Format( "could not open registry key: {0}\\Services", key); return false; } using (MockRegistryKey serviceKey = RegistryHelper.CreateSubKey( subKey, package.ServiceId.ToString(VsIdFormat), whatIf, verbose)) { if (serviceKey == null) { error = String.Format( "could not create registry key: {0}\\{1}", key, package.ServiceId.ToString(VsIdFormat)); return false; } RegistryHelper.SetValue(serviceKey, null, package.PackageId.ToString(VsIdFormat), whatIf, verbose); RegistryHelper.SetValue(serviceKey, "Name", String.Format("{0} Designer Service", ProjectName), whatIf, verbose); } } } return true; } /////////////////////////////////////////////////////////////////////// private static bool RemoveVsPackage( RegistryKey rootKey, Version vsVersion, Package package, bool whatIf, bool verbose, ref string error ) { if (vsVersion == null) { error = "invalid VS version"; return false; } if (package == null) { error = "invalid VS package"; return false; } string keyName = GetVsKeyName(vsVersion); using (MockRegistryKey key = RegistryHelper.OpenSubKey( rootKey, keyName, false, whatIf, verbose)) { if (key == null) { |
︙ | ︙ | |||
4148 4149 4150 4151 4152 4153 4154 | "could not open registry key: {0}\\Packages", key); return false; } RegistryHelper.DeleteSubKeyTree( | | > | | | < < < | | | > > | > > | > > > > > > > > > | | | 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 | "could not open registry key: {0}\\Packages", key); return false; } RegistryHelper.DeleteSubKeyTree( key, package.PackageId.ToString(VsIdFormat), whatIf, verbose); } using (MockRegistryKey subKey = RegistryHelper.OpenSubKey( key, "Menus", true, whatIf, verbose)) { if (subKey == null) { error = String.Format( "could not open registry key: {0}\\Menus", key); return false; } RegistryHelper.DeleteValue( subKey, package.PackageId.ToString(VsIdFormat), whatIf, verbose); } using (MockRegistryKey subKey = RegistryHelper.OpenSubKey( key, "Services", true, whatIf, verbose)) { if (subKey == null) { error = String.Format( "could not open registry key: {0}\\Services", key); return false; } RegistryHelper.DeleteSubKeyTree( subKey, package.ServiceId.ToString(VsIdFormat), whatIf, verbose); } } return true; } /////////////////////////////////////////////////////////////////////// private static bool ProcessVsPackage( RegistryKey rootKey, Version vsVersion, Package package, object clientData, bool whatIf, bool verbose, ref string error ) { AnyPair<string, bool> pair = clientData as AnyPair<string, bool>; if (pair == null) { error = "invalid VS callback data"; return false; } if (pair.Y) { return AddVsPackage( rootKey, vsVersion, package, pair.X, whatIf, verbose, ref error); } else { return RemoveVsPackage( rootKey, vsVersion, package, whatIf, verbose, ref error); } } #endregion #endregion /////////////////////////////////////////////////////////////////////// #region Application Entry Point private static int Main( string[] args ) { Configuration configuration = null; string error = null; /////////////////////////////////////////////////////////////////// #region Command Line Processing if (!Configuration.FromArgs( args, true, ref configuration, ref error) || !Configuration.Process( args, configuration, true, ref error) || !Configuration.CheckRuntimeVersion( configuration, true, ref error)) { TraceOps.ShowMessage( TracePriority.Highest, traceCallback, thisAssembly, error, traceCategory, MessageBoxButtons.OK, MessageBoxIcon.Error); return 1; /* FAILURE */ } #endregion /////////////////////////////////////////////////////////////////// #region .NET Framework / Visual Studio Data Package package = null; FrameworkList frameworkList = null; VsList vsList = null; /////////////////////////////////////////////////////////////////// InitializeVsPackage(ref package); InitializeFrameworkList(configuration, ref frameworkList); InitializeVsList(configuration, ref vsList); #endregion /////////////////////////////////////////////////////////////////// AssemblyName assemblyName = AssemblyName.GetAssemblyName( configuration.CoreFileName); /* throw */ |
︙ | ︙ | |||
4325 4326 4327 4328 4329 4330 4331 | #endregion /////////////////////////////////////////////////////////////////// #region .NET AssemblyFolders if (configuration.HasFlags(InstallFlags.AssemblyFolders, true)) { | | > | | | > | | | | < | | | | | < | | | | | | < | | | | | > > | | 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 | #endregion /////////////////////////////////////////////////////////////////// #region .NET AssemblyFolders if (configuration.HasFlags(InstallFlags.AssemblyFolders, true)) { if (!ForEachFrameworkRegistry( frameworkList, ProcessAssemblyFolders, directoryPair, configuration.WhatIf, configuration.Verbose, ref error)) { TraceOps.ShowMessage( TracePriority.Highest, traceCallback, thisAssembly, error, traceCategory, MessageBoxButtons.OK, MessageBoxIcon.Error); return 1; /* FAILURE */ } } #endregion /////////////////////////////////////////////////////////////////// #region .NET DbProviderFactory if (configuration.HasFlags(InstallFlags.DbProviderFactory, true)) { bool saved = false; if (!ForEachFrameworkConfig( frameworkList, ProcessDbProviderFactory, InvariantName, ProviderName, Description, FactoryTypeName, assemblyName, directoryPair, configuration.WhatIf, configuration.Verbose, ref saved, ref error)) { TraceOps.ShowMessage( TracePriority.Highest, traceCallback, thisAssembly, error, traceCategory, MessageBoxButtons.OK, MessageBoxIcon.Error); return 1; /* FAILURE */ } } #endregion /////////////////////////////////////////////////////////////////// #region VS Package if (configuration.HasFlags(InstallFlags.VsPackage, true)) { if (!ForEachVsVersionRegistry( vsList, ProcessVsPackage, package, fileNamePair, configuration.WhatIf, configuration.Verbose, ref error)) { TraceOps.ShowMessage( TracePriority.Highest, traceCallback, thisAssembly, error, traceCategory, MessageBoxButtons.OK, MessageBoxIcon.Error); return 1; /* FAILURE */ } } #endregion /////////////////////////////////////////////////////////////////// #region VS DataSource if (configuration.HasFlags(InstallFlags.VsDataSource, true)) { if (!ForEachVsVersionRegistry( vsList, ProcessVsDataSource, package, fileNamePair, configuration.WhatIf, configuration.Verbose, ref error)) { TraceOps.ShowMessage( TracePriority.Highest, traceCallback, thisAssembly, error, traceCategory, MessageBoxButtons.OK, MessageBoxIcon.Error); return 1; /* FAILURE */ } } #endregion /////////////////////////////////////////////////////////////////// #region VS DataProvider if (configuration.HasFlags(InstallFlags.VsDataProvider, true)) { if (!ForEachVsVersionRegistry( vsList, ProcessVsDataProvider, package, fileNamePair, configuration.WhatIf, configuration.Verbose, ref error)) { TraceOps.ShowMessage( TracePriority.Highest, traceCallback, thisAssembly, error, traceCategory, MessageBoxButtons.OK, MessageBoxIcon.Error); return 1; /* FAILURE */ } } #endregion /////////////////////////////////////////////////////////////////// #region Log Summary TraceOps.Trace( TracePriority.Higher, traceCallback, String.Format( "subKeysCreated = {0}, subKeysDeleted = {1}, " + "keyValuesSet = {2}, keyValuesDeleted = {3}", ForDisplay(RegistryHelper.SubKeysCreated), ForDisplay(RegistryHelper.SubKeysDeleted), ForDisplay(RegistryHelper.KeyValuesSet), ForDisplay(RegistryHelper.KeyValuesDeleted)), traceCategory); #endregion /////////////////////////////////////////////////////////////////// return 0; /* SUCCESS */ } #endregion } #endregion } |