C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Applications/Client Plugins/PSI Extension Generator Plugin/PsiExtensionGenerator.cs

/*  ----------------------------------------------------------------------------
 *  Microsoft Corporation
 *  ----------------------------------------------------------------------------
 *  Microsoft Project Server mpFx (mpFx)
 *  ----------------------------------------------------------------------------
 *  Author: Colby Africa
 *  ----------------------------------------------------------------------------
 *  License: http://code.msdn.microsoft.com/mpFx/Project/License.aspx
 *  ----------------------------------------------------------------------------
 */

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.EnterpriseServices.Internal;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Web.Services;
using System.Xml;
using Mcs.Epm.MicrosoftProject.mpFx.Client.Plugins.PsiExtensionGenerator.Properties;
using Microsoft.Win32;

namespace Mcs.Epm.MicrosoftProject.mpFx.Client.Plugins.PsiExtensionGenerator
{
    /// <summary>
    /// Implements a wrapper for generating a Project Server Interface Extension from an
    /// assembly.  See http://msdn.microsoft.com/en-us/library/bb428837.aspx for more information.
    /// <remarks>
    /// 
    /// The generator must be run on a machine with Project Server installed and configured as an application
    /// server.  Front-end servers to do not require nor allow for the deployment of extensions
    /// 
    /// The source assembly must meet the following requirements:
    /// 
    /// 1.) Implement a .NET 2.0 XML web service
    /// 2.) Root namespace = "http://schemas.microsoft.com/office/project/server/webservices/{ServiceName}/",
    /// 3.) Signed
    /// 
    /// The main method, "Generate", wraps the PSI extension generation and calls out to specific methods
    /// that closely model what is described in the walkthrough (http://msdn.microsoft.com/en-us/library/bb428837.aspx)
    /// 
    /// After using disco.exe to generate the WSDL and DISCO files, the files must be fixed up.  The default
    /// discovery files employ explicit URLs.  PSI extensions run in the context of a SharePoint shared service
    /// provider so the URLs must be fixed up to use SharePoint's utility functions to yield relative URLs.
    /// 
    /// The code used to make the changes in the xml files, in particular "SetElementAttributeValue", require a bit
    /// of explanation.  Originally I used XmlDocument to make the necessary replacements.  It does not work because
    /// the SharePoint utility functions run in the page rendering pipeline as scripts with "<% %>" tags.
    /// XmlDocument automatically escapes those characters, so I had to roll my own.  While it works, it isn't pretty.
    /// 
    /// There are two deployment scenarios.  The first, which is the default and the only supported method, is to deploy the web services
    /// assembly plus its dependencies to the GAC.  The second is to deploy it to the "bin" directory, which is 
    /// usually here: C:\Program Files\Microsoft Office Servers\12.0\WebServices\Shared\Bin
    /// 
    /// Finally, if you drop a filed named "setup.psieinstaller" into the same directory as the executable, you can specify an
    /// unattended generation.  The format of this file is this:
    /// ------------------------------------------------------------
    /// <?xml version="1.0" encoding="UTF-8"?>
    /// <InstallDirective version="1.0.0.0">
    ///     <ShowUi>true</ShowUi>
    ///     <WebServiceName>Core.asmx</WebServiceName>
    ///     <SourceAssembly>KraftPsiExtensionsCore.dll</SourceAssembly>
    ///     <DeployToBin>true</DeployToBin>
    ///     <ResetIis>true</ResetIis>
    ///     <OpenInBrowser>true</OpenInBrowser>
    /// </InstallDirective>
    /// ------------------------------------------------------------
    /// </remarks>
    /// </summary>
    internal class PsiExtensionGenerator
    {
        #region Static Methods

        /// <summary>
        /// Determine if the setup.psieinstaller file is present
        /// </summary>
        /// <param name="startupPath">The calling executable's startup path</param>
        /// <returns></returns>
        internal static bool IsInstallDirectivePresent(string startupPath)
        {
            return File.Exists(GetInstalDirectivePath(startupPath));
        }

        /// <summary>
        /// Simple wrapper for creating the setup.psieinstaller file path
        /// </summary>
        /// <param name="startupPath">The calling executable's startup path</param>
        /// <returns></returns>
        private static string GetInstalDirectivePath(string startupPath)
        {
            return Path.Combine(startupPath, "setup.psieinstaller");
        }

        #endregion

        #region Delegates

        /// <summary>
        /// Simple delegate used for communicating generation status changes
        /// </summary>
        /// <param name="sender">This</param>
        /// <param name="args">The args<seealso cref="OnGenerationStatusChangedArgs"/></param>
        internal delegate void OnGenerationStatusChangedEventHandler(object sender, OnGenerationStatusChangedArgs args);

        #endregion

        #region Events

        /// <summary>
        /// Simple event for communicating generation status changes
        /// </summary>
        internal event OnGenerationStatusChangedEventHandler OnGenerationStatusChanged;

        #endregion

        #region Instance Data

        private readonly List<string> _ExclusionList = new List<string>(Settings.Default.ExclusionList.Split(','));
        private readonly List<string> _Output = new List<string>();
        private readonly List<string> _TempFiles = new List<string>();        

        private readonly bool _ResetIis;
        private readonly bool _DeployToBinDirectory;
        private readonly bool _OpenInBrowser;

        private string _SourceAssemblyPath;
        private string _OfficeWebServicesPath;
        private string _IsapiDirectory;
        private string _SharedServiceProvider;

        private Assembly _SourceAssembly;
        private Type _PsiExtensionType;

        private string _WebServiceName;

        private string _WebServiceFilePath;
        private string _DiscoFile;
        private string _WsdlFile;

        private bool _IsError;
        private string _BinDirectory;

        #endregion

        #region Constructors

        /// <summary>
        /// Creates an instance of PsiExtensionGenerator
        /// </summary>
        /// <param name="sharedServiceProvider">The URI to the Project Server SSP</param>
        /// <param name="sourceAssemblyPath">The path to the source assembly</param>
        /// <param name="webServiceName">The web service name</param>
        /// <param name="resetIis">True to reset IIS (this should be done if the assembly has changed)</param>
        /// <param name="openInBrowser">True to open the web service in the browser after completion</param>
        /// <param name="deployToBinDirectory"></param>
        internal PsiExtensionGenerator(string sharedServiceProvider,
                                       string sourceAssemblyPath,
                                       string webServiceName,
                                       bool resetIis,
                                       bool openInBrowser,
                                       bool deployToBinDirectory)
        {
            DiscoveryOfficeWebServicesDirectory();
            DiscoverIsapiDirectory();

            VerifyWebServiceName(webServiceName);
            VerifyAssemblyPath(sourceAssemblyPath);

            VerifySharedServiceProviderUrl(sharedServiceProvider);

            _DeployToBinDirectory = deployToBinDirectory;
            _ResetIis = resetIis;
            _OpenInBrowser = openInBrowser;

        }

        /// <summary>
        /// Empty constructor for use with unattended generations
        /// </summary>
        internal PsiExtensionGenerator() {}

        #endregion

        #region internal Methods

        /// <summary>
        /// Primary entry point for generating using the web service
        /// </summary>
        internal void Generate()
        {
            try
            {
                // Walk through each step as outline in the walkthrough...
                _Output.Clear();

                SetPsiExtensionType();

                PrepareTargetPath();

                WriteWebServiceFileContents();

                MoveToVirtualDirectory();
                
                if (_DeployToBinDirectory)
                {
                    PublishToBinDirectory();
                }
                else
                {
                    PublishToGac();
                }

                UpdateWebConfig();

                GenerateDiscoFiles();

                MoveDiscoFiles();

                FixUpDiscoFiles();                                

                AddDepencencies();

                if (_ResetIis)
                {
                    ResetIis();
                }

                if (_OpenInBrowser)
                {
                    OpenInBrowser();
                }

                DoOnGenerationStatusChanged(new OnGenerationStatusChangedArgs(Resources.UIComplete));
            }
            catch(Exception exception)
            {
                _IsError = true;
                throw new PsiGeneratorException(exception.Message, exception);
            }
            finally
            {
                CleanUp();
            }
        }

        #endregion

        #region Private Methods

        #region Main Generation Methods

        /// <summary>
        /// Given an assembly, identify the type decorated with the WebService attribute, 
        /// verify its root namespace is http://schemas.microsoft.com/office/project/server/webservices.
        /// Set
        /// </summary>
        private void SetPsiExtensionType()
        {
            DoOnGenerationStatusChanged(new OnGenerationStatusChangedArgs(Resources.UILoadingAssembly));

            Publish publish = new Publish();

            //  This needs to be done so LoadFile actually loads from the file. I found that if the file
            //  exists in the GAC, it would be loaded from there regardless.
            //  If it doesn't exist in the GAC, the following call my generate COM+ SOAP Services events
            //  in application event log
            publish.GacRemove(_SourceAssemblyPath);

            _SourceAssembly = Assembly.LoadFile(_SourceAssemblyPath);

            DoOnGenerationStatusChanged(new OnGenerationStatusChangedArgs(Resources.UILoadingTypeInformation));

            Type[] types = _SourceAssembly.GetTypes();

            //  Once a type is identified that is decorated with the WebService attribute, look to see if its namespace begins with
            //  http://schemas.microsoft.com/office/project/server/webservices
            foreach (Type type in types)
            {
                WebServiceAttribute[] attributes = type.GetCustomAttributes(typeof(WebServiceAttribute), false) as WebServiceAttribute[];

                if (attributes != null && attributes.Length > 0)
                {
                    foreach (WebServiceAttribute attribute in attributes)
                    {
                        if (attribute.Namespace.StartsWith(Settings.Default.DefaultRootNameSpace, StringComparison.CurrentCultureIgnoreCase))
                        {
                            byte[] publicKey = _SourceAssembly.GetName().GetPublicKey();                         

                            //  PSI Extensions must be signed.
                            if (publicKey.Length == 0) 
                            {
                                throw new PsiGeneratorException(Resources.AssemblyMustBeSigned);
                            }

                            _PsiExtensionType = type;

                            return;
                        }
                    }
                }
            }

            if (_PsiExtensionType == null)
            {
                throw new PsiGeneratorException(string.Format(CultureInfo.CurrentCulture,Resources.PsiWebServiceNotFound,
                                                              Settings.Default.DefaultRootNameSpace));
            }
        }

        /// <summary>
        /// Given the eventual web service name, setup a file path along side the source
        /// assembly's file path and ensure it has a .asmx extension
        /// </summary>
        private void PrepareTargetPath()
        {
            DoOnGenerationStatusChanged(new OnGenerationStatusChangedArgs(Resources.UIPrepTargetPath));

            string targetPath = Path.Combine(Path.GetDirectoryName(_SourceAssemblyPath), _WebServiceName);

            if (!Path.HasExtension(targetPath) || !Path.GetExtension(targetPath).Equals("asmx"))
            {
                targetPath = Path.ChangeExtension(targetPath, "asmx");
            }

            if (File.Exists(targetPath))
            {
                File.Delete(targetPath);
            }

            _WebServiceFilePath = targetPath;
        }

        /// <summary>
        /// Write the service file contents.
        /// <![CDATA[<%@ WebService Language="{0}" Class="{1}" %> ]]>
        /// </summary>
        private void WriteWebServiceFileContents()
        {
            DoOnGenerationStatusChanged(new OnGenerationStatusChangedArgs(Resources.UIWriteWebServiceFile));

            using (StreamWriter writer = File.CreateText(_WebServiceFilePath))
            {
                writer.AutoFlush = true;
                writer.WriteLine(string.Format(CultureInfo.CurrentCulture,Resources.AsmxContents, Settings.Default.WebServiceLanguage,
                                               _PsiExtensionType.AssemblyQualifiedName));
            }
        }

        /// <summary>
        /// Moves the web service file to to the Office Web Services directory.
        /// <remarks>
        /// Discoe.exe takes virtual directory URI, not a file path; so, the web service
        /// file must be moved prior to discovery file generation.
        /// 
        /// A reference can be found here:
        /// http://blogs.msdn.com/chrisfie/archive/2007/08/02/lessons-learned-from-writing-a-psi-extension.aspx
        /// </remarks> 
        /// </summary>
        private void MoveToVirtualDirectory()
        {
            DoOnGenerationStatusChanged(new OnGenerationStatusChangedArgs(Resources.UIMoveToVirtualDirectory));

            string copyTarget = Path.Combine(_OfficeWebServicesPath, Path.GetFileName(_WebServiceFilePath));

            if (File.Exists(copyTarget))
            {
                File.Delete(copyTarget);
            }

            File.Move(_WebServiceFilePath, copyTarget);

            _WebServiceFilePath = copyTarget;
        }

        /// <summary>
        /// Generate the discovery files for the web service
        /// </summary>
        private void GenerateDiscoFiles()
        {
            DoOnGenerationStatusChanged(new OnGenerationStatusChangedArgs(Resources.UIGeneratingDiscoFiles));

            Environment.CurrentDirectory = Path.GetDirectoryName(_SourceAssemblyPath);

            string discoPath = GetDiscoExePath();

            string webServiceUrl = GetPsiWebServiceUrl();

            CreateProcess(discoPath, webServiceUrl);

            bool terminate = false;

            // Output is collected and reported after the fact. 

            List<string> htmlOutput = new List<string>();
            bool inhtmlOutput = false;

            foreach (string outputMessage in _Output)
            {
                if (outputMessage.Contains("ERROR"))
                {
                    terminate = true;
                }
                if (outputMessage.StartsWith("<html>", StringComparison.CurrentCultureIgnoreCase))
                {
                    inhtmlOutput = true;
                }
                else if (outputMessage.StartsWith("</html>", StringComparison.CurrentCultureIgnoreCase))
                {
                    htmlOutput.Add(outputMessage);
                    inhtmlOutput = false;
                }
                else
                {
                    if (!inhtmlOutput)
                    {
                        DoOnGenerationStatusChanged(new OnGenerationStatusChangedArgs(outputMessage));
                    }
                }

                if (inhtmlOutput)
                {
                    htmlOutput.Add(outputMessage);
                }
            }

            if (htmlOutput.Count > 0)
            {
                //  Disco.exe reported an error, which it does so in html format.  Write out the html file to a
                //  temp file and display it to the user.
                string tempFile = Path.GetTempFileName();

                if (File.Exists(tempFile))
                {
                    File.Delete(tempFile);
                }

                tempFile = Path.ChangeExtension(tempFile, "htm");

                File.WriteAllLines(tempFile, htmlOutput.ToArray());

                Process.Start(tempFile);

                _TempFiles.Add(tempFile);
            }

            string discoResults = Path.Combine(Path.GetDirectoryName(_SourceAssemblyPath), "results.discomap");

            if (File.Exists(discoResults))
            {
                _TempFiles.Add(discoResults);
            }
            
            if (terminate)
            {
                throw new PsiGeneratorException(Resources.ErrorDiscoGenerationFailed);
            }

        }

        /// <summary>
        /// Move the disco files from the directory in which they were generated to the ISAPI directory
        /// </summary>
        private void MoveDiscoFiles()
        {
            DoOnGenerationStatusChanged(new OnGenerationStatusChangedArgs(Resources.UIMovingDiscoFiles));

            string outputPath = Path.GetDirectoryName(_SourceAssemblyPath);

            _WsdlFile = MoveDiscoveryFile(outputPath, "wsdl", Resources.ErrorMoveWsdl);

            _DiscoFile = MoveDiscoveryFile(outputPath, "disco", Resources.ErrorMoveDisco);
        }        

        /// <summary>
        /// Replace absolutely paths with relative paths 
        /// </summary>
        private void FixUpDiscoFiles()
        {
            DoOnGenerationStatusChanged(new OnGenerationStatusChangedArgs(Resources.UIFixupDiscoFiles));

            List<string> file = new List<string>();

            file.AddRange(File.ReadAllLines(_DiscoFile));
            FixUpHeader(file);

            SetElementAttributeValue(file, "contractRef", "ref", Resources.refContents);
            SetElementAttributeValue(file, "contractRef", "docRef", Resources.docRefContents);
            SetElementAttributeValue(file, "soap", "address", Resources.addressContents);

            File.WriteAllLines(_DiscoFile, file.ToArray());

            file.Clear();

            file.AddRange(File.ReadAllLines(_WsdlFile));
            FixUpHeader(file);

            SetElementAttributeValue(file, "soap:address", "location", Resources.soapAddressContents);
            SetElementAttributeValue(file, "soap12:address", "location", Resources.soapAddressContents);

            File.WriteAllLines(_WsdlFile, file.ToArray());
        }

        /// <summary>
        /// Publish to GAC 
        /// </summary>
        private void PublishToGac()
        {
            DoOnGenerationStatusChanged(new OnGenerationStatusChangedArgs(Resources.UIPublishingToGac));

            Publish publish = new Publish();

            if (_SourceAssembly.GlobalAssemblyCache)
            {
                if (_SourceAssembly.Location == null)
                {
                    throw new PsiGeneratorException(Resources.ErrorAssemblyLocation);
                }

                publish.GacRemove(_SourceAssembly.Location);
            }

            publish.GacInstall(_SourceAssemblyPath);
        }

        /// <summary>
        /// Update web config 
        /// </summary>
        private void UpdateWebConfig()
        {
            string webConfigFilePath = Path.GetDirectoryName(_WebServiceFilePath);

            webConfigFilePath = Path.Combine(webConfigFilePath, "web.config");

            if (!File.Exists(webConfigFilePath))
            {
                throw new PsiGeneratorException(Resources.ErrorWebConfigNotFound);
            }

            DoOnGenerationStatusChanged(new OnGenerationStatusChangedArgs(string.Format(CultureInfo.CurrentCulture, Resources.UIAddingToWebConfig, webConfigFilePath)));

            XmlDocument configXml = new XmlDocument();
            configXml.Load(webConfigFilePath);

            XmlNode assembliesNode = configXml.SelectSingleNode("/configuration/system.web/compilation/assemblies");
                       
            bool exitSearch = false;
            //  Looking for <add assembly="[AssemblyFullName]" /> 
            for (int j = 0; j < assembliesNode.ChildNodes.Count; j++)
            {
                for (int i = 0; i < assembliesNode.ChildNodes[j].Attributes.Count; i++)
                {
                    if (assembliesNode.ChildNodes[j].Attributes[i].Value.Equals(_PsiExtensionType.Assembly.FullName))
                    {
                        //  Remove if it exists
                        assembliesNode.RemoveChild(assembliesNode.ChildNodes[j]);
                        exitSearch = true;
                        break;
                    }
                }

                if (exitSearch)
                {
                    break;
                }
            }

            XmlNode assemblyNode = configXml.CreateElement("add");

            XmlAttribute assemblyAttribute = configXml.CreateAttribute("assembly");

            assemblyNode.Attributes.Append(assemblyAttribute);

            assemblyAttribute.Value = _PsiExtensionType.Assembly.FullName;

            assembliesNode.AppendChild(assemblyNode);

            configXml.Save(webConfigFilePath);
        }

        /// <summary>
        /// Reset IIS
        /// </summary>
        private void ResetIis()
        {
            DoOnGenerationStatusChanged(new OnGenerationStatusChangedArgs(Resources.UIResetIis));

            _Output.Clear();

            Process process = new Process
                                  {
                                      StartInfo =
                                          {
                                              FileName = "IISRESET",
                                              CreateNoWindow = true,
                                              RedirectStandardError = true,
                                              RedirectStandardOutput = true,
                                              UseShellExecute = false
                                          },
                                      EnableRaisingEvents = true
                                  };

            process.OutputDataReceived += process_OutputDataReceived;
            process.ErrorDataReceived += process_ErrorDataReceived;

            process.Start();

            process.BeginOutputReadLine();
            process.BeginErrorReadLine();

            process.WaitForExit();

            foreach (string outputMessage in _Output)
            {
                if (outputMessage.StartsWith("-", StringComparison.CurrentCultureIgnoreCase))
                {
                    DoOnGenerationStatusChanged(new OnGenerationStatusChangedArgs(outputMessage));
                }
                else
                {
                    DoOnGenerationStatusChanged(new OnGenerationStatusChangedArgs(string.Format(CultureInfo.CurrentCulture,"\t{0}", outputMessage)));
                }
            }
        }

        /// <summary>
        /// Open in browser
        /// </summary>
        private void OpenInBrowser()
        {
            DoOnGenerationStatusChanged(new OnGenerationStatusChangedArgs(Resources.UIOpenInBrowser));
            string url = GetPsiWebServiceUrl();

            Process.Start(url);
        }

        /// <summary>
        /// As advertised, clean up.
        /// </summary>
        private void CleanUp()
        {
            if (_IsError)
            {
                if (_DeployToBinDirectory && !string.IsNullOrEmpty(_BinDirectory))
                {
                    string targetPath = Path.Combine(_BinDirectory, Path.GetFileName(_SourceAssemblyPath));

                    DeleteFile(targetPath);
                }
                else
                {
                    UninstallFromGac();
                }
            }

            foreach (string file in _TempFiles)
            {
                if (File.Exists(file))
                {
                    try
                    {
                        File.Delete(file);
                    }
                    catch
                    {/*  Swallow  */ }
                }
            }
        }

        #endregion

        #region Wrappers

        private void DoOnGenerationStatusChanged(OnGenerationStatusChangedArgs args)
        {
            if (OnGenerationStatusChanged != null)
            {
                OnGenerationStatusChanged(this, args);
            }
        }

        private void CreateProcess(string fileName, string arguements)
        {
            Process process = new Process
                                  {
                                      StartInfo =
                                          {
                                              FileName = fileName,
                                              CreateNoWindow = true,
                                              Arguments = arguements,
                                              RedirectStandardError = true,
                                              RedirectStandardOutput = true,
                                              UseShellExecute = false
                                          },
                                      EnableRaisingEvents = true
                                  };

            process.OutputDataReceived += process_OutputDataReceived;
            process.ErrorDataReceived += process_ErrorDataReceived;

            process.Start();

            process.BeginOutputReadLine();
            process.BeginErrorReadLine();

            process.WaitForExit();
        }

        private static void DeleteFile(string tempFile)
        {
            if (File.Exists(tempFile))
            {
                File.Delete(tempFile);
            }
        }


        private void ReportFeedback(DataReceivedEventArgs e)
        {
            if (!string.IsNullOrEmpty(e.Data))
            {
                _Output.Add(e.Data);
            }            
        }

        #endregion

        #region Publishing methods

        /// <summary>
        /// Publish the web service assembly to the bin directory
        /// </summary>
        private void PublishToBinDirectory()
        {
            DirectoryInfo parentDirectory = Directory.GetParent(_OfficeWebServicesPath);

            if (parentDirectory == null)
            {
                throw new DirectoryNotFoundException(_OfficeWebServicesPath);
            }

            _BinDirectory = Path.Combine(parentDirectory.FullName, "Bin");

            if (!Directory.Exists(_BinDirectory))
            {
                Directory.CreateDirectory(_BinDirectory);
            }

            string targetPath = Path.Combine(_BinDirectory, Path.GetFileName(_SourceAssemblyPath));
            DeleteFile(targetPath);

            File.Copy(_SourceAssemblyPath, targetPath);

        }

        /// <summary>
        /// Uninstall from GAC.
        /// </summary>
        private void UninstallFromGac()
        {
            Publish publish = new Publish();

            if (_SourceAssembly.GlobalAssemblyCache)
            {
                if (_SourceAssembly.Location == null)
                {
                    throw new PsiGeneratorException(Resources.ErrorAssemblyLocation);
                }

                publish.GacRemove(_SourceAssembly.Location);
            }
        }

        /// <summary>
        /// Add dependencies to either the GAC or bin directory
        /// <remarks>
        /// This is messy, but it is what I came up with first.  Here is how it works:
        /// 1.) Get a list of all the referenced assemblies for the source assembly
        /// 2.) Look in the same directory for all files.
        /// 3.) Attempt to load each file as an assembly
        /// 4.) Iterate over the list of referenced assemblies
        /// 5.) Make sure they aren't in the exclusion list (this is important
        ///     so dependencies from Project and SharePoint don't get redeployed
        /// 6.) Determine if the assembly's full name matches that which is
        ///     listed in the reference assemblies
        /// 7.) If so, the file IMPLEMENTS the reference and can be added to the GAC
        ///     or bin directory.
        /// </remarks>
        /// </summary>
        private void AddDepencencies()
        {
            AssemblyName[] referencedAssemblies = _SourceAssembly.GetReferencedAssemblies();

            string[] files = Directory.GetFiles(Path.GetDirectoryName(_SourceAssemblyPath), "*.dll");

            Dictionary<AssemblyName, Assembly> assemblies = new Dictionary<AssemblyName, Assembly>();

            foreach (string file in files)
            {
                try
                {
                    AssemblyName name = AssemblyName.GetAssemblyName(file);

                    assemblies.Add(name, Assembly.LoadFile(file));
                }
                catch (BadImageFormatException) { }
            }

            foreach (AssemblyName assemblyName in referencedAssemblies)
            {
                if (!IsInExclusionList(assemblyName))
                {
                    foreach (KeyValuePair<AssemblyName, Assembly> pair in assemblies)
                    {
                        if (pair.Value.FullName == assemblyName.FullName)
                        {
                            DoOnGenerationStatusChanged(new OnGenerationStatusChangedArgs(string.Format(CultureInfo.CurrentCulture, Resources.UIAddDependency, assemblyName.FullName)));

                            Assembly assembly = assemblies[pair.Key];

                            if (assembly.Location == null)
                            {
                                throw new PsiGeneratorException(string.Format(CultureInfo.CurrentCulture, Resources.ErrorDependentAssemblyLocation, assembly.FullName));
                            }

                            if (_DeployToBinDirectory)
                            {
                                string fileName = Path.GetFileName(assembly.Location);

                                fileName = Path.Combine(_BinDirectory, fileName);

                                if (File.Exists(fileName))
                                {
                                    File.Delete(fileName);
                                }

                                File.Copy(assembly.Location, fileName);
                            }
                            else
                            {
                                Publish publish = new Publish();
                                publish.GacRemove(assembly.Location);
                                publish.GacInstall(assembly.Location);
                            }
                            break;
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Determine whether a given assembly name starts with any
        /// item in the inclusion list.
        /// </summary>
        /// <param name="assemblyName"></param>
        /// <returns></returns>
        private bool IsInExclusionList(AssemblyName assemblyName)
        {
            string assemblyFullName = assemblyName.FullName;

            if (assemblyFullName.Equals(_SourceAssembly.FullName))
            {
                return true;
            }

            foreach (string excludedItem in _ExclusionList)
            {
                if (assemblyFullName.StartsWith(excludedItem, StringComparison.CurrentCultureIgnoreCase))
                {
                    return true;
                }
            }

            return false;
        }

        #endregion

        #region Path Creation & Discovery Methods

        /// <summary>
        /// Use the registry to discover the ISAPI directory
        /// </summary>
        private void DiscoverIsapiDirectory()
        {
            using (RegistryKey officeServerKey = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\.NETFramework\AssemblyFolders\SharePoint"))
            {
                if (officeServerKey != null)
                {
                    object keyValue = officeServerKey.GetValue(string.Empty);

                    if (keyValue != null)
                    {
                        string isapiDirectory = keyValue.ToString();

                        isapiDirectory = Path.Combine(isapiDirectory, "PSI");

                        if (Directory.Exists(isapiDirectory))
                        {
                            _IsapiDirectory = isapiDirectory;
                            return;
                        }
                    }
                }
            }

            throw new PsiGeneratorException("ISAPI directory not found.");
        }

        /// <summary>
        /// Use the registry to discover the Office web services directory
        /// </summary>
        private void DiscoveryOfficeWebServicesDirectory()
        {
            using (RegistryKey officeServerKey = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Office Server\12.0"))
            {
                if (officeServerKey != null)
                {
                    object keyValue = officeServerKey.GetValue("BinPath");

                    if (keyValue != null)
                    {
                        _OfficeWebServicesPath = keyValue.ToString();

                        if (_OfficeWebServicesPath.EndsWith("\\", StringComparison.CurrentCultureIgnoreCase))                        
                        
                        {
                            // Prevent having to call Directory.GetParent twice
                            _OfficeWebServicesPath = _OfficeWebServicesPath.Substring(0, _OfficeWebServicesPath.Length - 1);
                        }
                    }
                }
            }

            DirectoryInfo parentDirectory = Directory.GetParent(_OfficeWebServicesPath);

            if (parentDirectory != null)
            {
                _OfficeWebServicesPath = parentDirectory.FullName;

                _OfficeWebServicesPath = Path.Combine(_OfficeWebServicesPath, "WebServices\\Shared\\PSI");

                if (Directory.Exists(_OfficeWebServicesPath))
                {
                    return;
                }
            }

            throw new PsiGeneratorException(Resources.ErrorMustRunOnProjectServer);
        }

        /// <summary>
        /// Get the PSI Web service url
        /// </summary>
        /// <returns></returns>
        private string GetPsiWebServiceUrl()
        {
            return string.Format(CultureInfo.CurrentCulture, "{0}PSI/{1}", _SharedServiceProvider, Path.GetFileName(_WebServiceFilePath));
        }

        /// <summary>
        /// Return the path to disco.exe, which must exist in the same directory as the generator
        /// </summary>
        /// <returns></returns>
        private static string GetDiscoExePath()
        {
            string discoPath = Assembly.GetExecutingAssembly().Location;

            discoPath = Path.GetDirectoryName(discoPath);

            discoPath = Path.Combine(discoPath, "disco.exe");

            if (!File.Exists(discoPath))
            {
                throw new FileNotFoundException(string.Format(CultureInfo.CurrentCulture, "File not found: {0}", discoPath));
            }

            return discoPath;
        }

        #endregion

        #region Verification Methods

        /// <summary>
        /// Verify the source assembly path
        /// </summary>
        /// <param name="sourceAssemblyPath">The path</param>
        private void VerifyAssemblyPath(string sourceAssemblyPath)
        {
            if (string.IsNullOrEmpty(sourceAssemblyPath))
            {
                throw new ArgumentException(Resources.ErrorInvalidSourcePath);
            }

            if (!File.Exists(sourceAssemblyPath))
            {
                throw new FileNotFoundException(_SourceAssemblyPath);
            }

            _SourceAssemblyPath = sourceAssemblyPath;
        }

        /// <summary>
        /// Verify the web service name
        /// </summary>
        /// <param name="webServiceName">The name</param>
        private void VerifyWebServiceName(string webServiceName)
        {
            if (string.IsNullOrEmpty(webServiceName))
            {
                throw new ArgumentException(Resources.ErrorInvalidWebServiceName);
            }
            _WebServiceName = webServiceName;
        }

        /// <summary>
        /// Verify the shared service provider url
        /// </summary>
        /// <param name="sharedServiceProvider">The url</param>
        private void VerifySharedServiceProviderUrl(string sharedServiceProvider)
        {
            Uri testUri;

            _SharedServiceProvider = sharedServiceProvider;

            if (!Uri.TryCreate(_SharedServiceProvider, UriKind.Absolute, out testUri))
            {
                throw new UriFormatException(Resources.ErrorInvalidShareServiceProviderUrl);
            }

            if (!_SharedServiceProvider.EndsWith("/", StringComparison.CurrentCultureIgnoreCase))
            {
                _SharedServiceProvider = string.Format(CultureInfo.CurrentCulture,"{0}/", _SharedServiceProvider);
            }
        }

        #endregion

        #region Discovery File Manipulation Methods

        /// <summary>
        /// Place the xml node with the required asp.net markup. 
        /// </summary>
        /// <param name="file">The lines of the file</param>
        private static void FixUpHeader(IList<string> file)
        {            
            file.RemoveAt(0);
            file.Insert(0, Resources.importSharePointObjectModelContents);
        }

        /// <summary>
        /// Set a given element\attribute value
        /// </summary>
        /// <param name="file">The lines of the file</param>
        /// <param name="elementName">The element name to search for</param>
        /// <param name="attributeName">The attribute to set</param>
        /// <param name="value">The value to set it to</param>
        private static void SetElementAttributeValue(IList<string> file, string elementName, string attributeName, string value)
        {
            int count = 0;

            if (!elementName.StartsWith("<", StringComparison.CurrentCultureIgnoreCase))
            {
                elementName = string.Format(CultureInfo.CurrentCulture,"<{0}", elementName);
            }

            for (int i = 0; i < file.Count; i++)
            {
                string line = file[i];
                string trimmedLine = line.Trim();

                if (trimmedLine.StartsWith(elementName, StringComparison.CurrentCultureIgnoreCase))
                {
                    string attributeWithEquals = string.Format(CultureInfo.CurrentCulture,"{0}=", attributeName);

                    int attributeStart = trimmedLine.IndexOf(attributeWithEquals, StringComparison.CurrentCultureIgnoreCase);

                    if (attributeStart != -1)
                    {
                        string attributeAndValue = trimmedLine.Substring(attributeStart);

                        int openingQuotes = attributeAndValue.IndexOf("\"", StringComparison.CurrentCultureIgnoreCase);
                        int closingQuotes = attributeAndValue.IndexOf("\"", openingQuotes + 1, StringComparison.CurrentCultureIgnoreCase);

                        attributeAndValue = attributeAndValue.Substring(0, closingQuotes);

                        file[i] = file[i].Replace(attributeAndValue, attributeName + "=\"" + value);

                        count++;
                    }
                }
            }

            if (count == 0)
            {
                throw new PsiGeneratorException(string.Format(CultureInfo.CurrentCulture,Resources.ErrorXmlNotFound, elementName, attributeName));
            }
        }

        /// <summary>
        /// Move the discovery file
        /// </summary>
        /// <param name="outputPath">The target directory</param>
        /// <param name="suffix">The suffix to append to the name (file.disco --> filedisco.aspx)</param>
        /// <param name="errorMessage">The error message to show if the file cannot be moved. </param>
        /// <returns></returns>
        private string MoveDiscoveryFile(string outputPath, string suffix, string errorMessage)
        {            
            string fileName = Path.GetFileName(_WebServiceFilePath);

            string filePath = Path.Combine(outputPath, Path.ChangeExtension(fileName, suffix));

            if (!File.Exists(filePath))
            {
                throw new PsiGeneratorException(errorMessage);
            }

            string targetFile = Path.GetFileNameWithoutExtension(fileName);

            targetFile = string.Format(CultureInfo.CurrentCulture, "{1}{0}.aspx", suffix, targetFile);
            targetFile = Path.Combine(_IsapiDirectory, targetFile);

            DeleteFile(targetFile);

            File.Move(filePath, targetFile);

            return targetFile;
        }

        #endregion

        #region Miscellanous

        #endregion

        #endregion

        #region Event Handlers

        private void process_ErrorDataReceived(object sender, DataReceivedEventArgs e)
        {
            ReportFeedback(e);
        }

        private void process_OutputDataReceived(object sender, DataReceivedEventArgs e)
        {
            ReportFeedback(e);
        }

        #endregion
    }
}

---