Beispiel #1
0
 public static Version GetMaxVersion()
 {
     return(AssemblyUtils.GetMaxWebPagesVersion());
 }
Beispiel #2
0
        /// <param name="path">Physical or virtual path to a directory where we need to determine the version of WebPages to be used.</param>
        /// <remarks>
        /// In a non-hosted scenario, this method would only look at a web.config that is present at the current path. Any config settings at an
        /// ancestor directory would not be considered.
        /// </remarks>
        public static Version GetVersionWithoutEnabledCheck(string path)
        {
            var maxVersion = AssemblyUtils.GetMaxWebPagesVersion();

            return(GetVersionWithoutEnabledCheckInternal(path, maxVersion));
        }
Beispiel #3
0
 public static IEnumerable <AssemblyName> GetWebPagesAssemblies()
 {
     return(AssemblyUtils.GetAssembliesForVersion(AssemblyUtils.ThisAssemblyName.Version));
 }
Beispiel #4
0
        // Adds Parameter for unit tests
        internal static bool StartCore(
            IFileSystem fileSystem,
            string appDomainAppPath,
            string binDirectory,
            NameValueCollection appSettings,
            IEnumerable <AssemblyName> loadedAssemblies,
            IBuildManager buildManager,
            Action <Version> loadWebPages,
            Action registerForChangeNotification,
            Func <string, AssemblyName> getAssemblyNameThunk = null
            )
        {
            if (WebPagesDeployment.IsExplicitlyDisabled(appSettings))
            {
                // If WebPages is explicitly disabled, exit.
                Debug.WriteLine(
                    "WebPages Bootstrapper v{0}: not loading WebPages since it is disabled",
                    AssemblyUtils.ThisAssemblyName.Version
                    );
                return(false);
            }

            Version maxWebPagesVersion = AssemblyUtils.GetMaxWebPagesVersion(loadedAssemblies);

            Debug.Assert(maxWebPagesVersion != null, "Function must return some max value.");
            if (AssemblyUtils.ThisAssemblyName.Version != maxWebPagesVersion)
            {
                // Always let the highest version determine what needs to be done. This would make future proofing simpler.
                Debug.WriteLine(
                    "WebPages Bootstrapper v{0}: Higher version v{1} is available.",
                    AssemblyUtils.ThisAssemblyName.Version,
                    maxWebPagesVersion
                    );
                return(false);
            }

            var webPagesEnabled = WebPagesDeployment.IsEnabled(
                fileSystem,
                appDomainAppPath,
                appSettings
                );
            Version binVersion = AssemblyUtils.GetVersionFromBin(
                binDirectory,
                fileSystem,
                getAssemblyNameThunk
                );
            Version configVersion = WebPagesDeployment.GetVersionFromConfig(appSettings);
            Version version       = configVersion ?? binVersion ?? AssemblyUtils.WebPagesV1Version;

            // Asserts to ensure unit tests are set up correctly. So essentially, we're unit testing the unit tests.
            Debug.Assert(version != null, "GetVersion always returns a version");
            Debug.Assert(
                binVersion == null || binVersion <= maxWebPagesVersion,
                "binVersion cannot be higher than max version"
                );

            if ((binVersion != null) && (binVersion != version))
            {
                // Determine if there's a version conflict. A conflict could occur if there's a version specified in the bin which is different from the version specified in the
                // config that is different.
                throw new InvalidOperationException(
                          String.Format(
                              CultureInfo.CurrentCulture,
                              ConfigurationResources.WebPagesVersionConflict,
                              version,
                              binVersion
                              )
                          );
            }
            else if (binVersion != null)
            {
                // The rest of the code is only meant to be executed if we are executing from the GAC.
                // If a version is bin deployed, we don't need to do anything special to bootstrap.
                return(false);
            }
            else if (!webPagesEnabled)
            {
                Debug.WriteLine(
                    "WebPages Bootstrapper v{0}: WebPages not enabled, registering for change notifications",
                    AssemblyUtils.ThisAssemblyName.Version
                    );
                // Register for change notifications under the application root
                registerForChangeNotification();
                return(false);
            }
            else if (!AssemblyUtils.IsVersionAvailable(loadedAssemblies, version))
            {
                if (
                    version == AssemblyUtils.WebPagesV1Version &&
                    configVersion == null &&
                    binVersion == null
                    )
                {
                    // No version was specified. We're implicitly assuming that the site is a v1 site. However, the user does not have V1 binaries available.
                    throw new InvalidOperationException(
                              ConfigurationResources.WebPagesImplicitVersionFailure
                              );
                }
                else
                {
                    throw new InvalidOperationException(
                              String.Format(
                                  CultureInfo.CurrentCulture,
                                  ConfigurationResources.WebPagesVersionNotFound,
                                  version,
                                  AssemblyUtils.ThisAssemblyName.Version
                                  )
                              );
                }
            }

            Debug.WriteLine(
                "WebPages Bootstrapper v{0}: loading version {1}, loading WebPages",
                AssemblyUtils.ThisAssemblyName.Version,
                version
                );
            // If the version the application was compiled earlier was different, invalidate compilation results by adding a file to the bin.
            InvalidateCompilationResultsIfVersionChanged(
                buildManager,
                fileSystem,
                binDirectory,
                version
                );
            loadWebPages(version);
            return(true);
        }