WasEndpointConfigContainer.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / Tools / comsvcutil / WasEndpointConfigContainer.cs / 1 / WasEndpointConfigContainer.cs

                                //------------------------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------
namespace Microsoft.Tools.ServiceModel.ComSvcConfig
{ 
    using System;
    using System.ServiceModel.Channels; 
    using System.Diagnostics; 
    using System.Configuration;
    using System.Collections; 
    using System.Collections.Specialized;
    using System.Collections.Generic;
    using System.IO;
    using System.Reflection; 
    using System.Text;
    using System.Threading; 
    using System.Runtime.InteropServices; 
    using System.Security;
    using System.ServiceModel; 
    using System.ServiceModel.Configuration;
    using System.ServiceModel.Description;
    using Microsoft.Tools.ServiceModel;
    using Microsoft.Tools.ServiceModel.SvcUtil; 

    class WasEndpointConfigContainer : EndpointConfigContainer 
    { 
        bool closed;
        AtomicFile configFile; 
        SvcFileManager svcFileManager;
        string webDirectoryName;
        string webDirectoryPath;
        string webServerName; 
        bool modified = false;
 
        WasEndpointConfigContainer(string webServerName, string webDirectoryName, string webDirectoryPath) 
        {
            if (string.IsNullOrEmpty(webDirectoryPath) || !Directory.Exists(webDirectoryPath)) 
            {
                // We will not tolerate a webDir that does not exist
                throw Tool.CreateException(SR.GetString(SR.WebDirectoryPathNotFound, webDirectoryName, webDirectoryPath), null);
            } 

            this.webDirectoryName = webDirectoryName; 
            this.webDirectoryPath = webDirectoryPath; 
            this.webServerName = webServerName;
            this.closed = false; 
            this.configFile = new AtomicFile(this.webDirectoryPath + "\\web.config");
            this.svcFileManager = new SvcFileManager(this.webDirectoryPath);
        }
 
        public override bool WasModified { get { return this.modified; } set { this.modified = value; } }
 
        public override void AbortChanges() 
        {
            this.closed = true; 
            this.configFile.Abort();
            this.svcFileManager.Abort();
        }
 
        internal AtomicFile ConfigFile { get {return this.configFile; } }
 
 
        public override void Add(IList endpointConfigs)
        { 
            ThrowIfClosed();

            Configuration config = GetConfiguration(false); // not read only
            Debug.Assert(config != null, "config != null"); 

            bool anyAdded = false; 
 
            foreach (EndpointConfig endpointConfig in endpointConfigs)
            { 
                Guid appid;
                //verify that we someone did not delete and reinstall the app from underneath us
                if (this.svcFileManager.ResolveClsid(endpointConfig.Clsid, out appid))
                { 
                    if (endpointConfig.Appid != appid)
                    { 
                        ToolConsole.WriteError(SR.GetString(SR.AppIDsDontMatch), ""); 
                        return;
                    } 
                }
            }

            foreach (EndpointConfig endpointConfig in endpointConfigs) 
            {
                bool added = this.BaseAddEndpointConfig(config, endpointConfig); 
                if (added) 
                {
                    this.svcFileManager.Add(endpointConfig.Appid, endpointConfig.Clsid); 
                    anyAdded = true;

                    // the metadata exchange endpoint is not displayed as a regular endpoint
                    if (endpointConfig.Iid == typeof(IMetadataExchange).GUID) 
                    {
                        ToolConsole.WriteLine(SR.GetString(SR.MexEndpointAdded)); 
                        continue; 
                    }
 
                    if (!Tool.Options.ShowGuids)
                    {
                        ToolConsole.WriteLine(SR.GetString(SR.InterfaceAdded, endpointConfig.ComponentProgID, endpointConfig.InterfaceName));
                    } 
                    else
                    { 
                        ToolConsole.WriteLine(SR.GetString(SR.InterfaceAdded, endpointConfig.Clsid, endpointConfig.Iid)); 
                    }
                } 
                else
                {
                    // the metadata exchange endpoint is not displayed as a regular endpoint
                    if (endpointConfig.Iid == typeof(IMetadataExchange).GUID) 
                    {
                        if (!Tool.Options.ShowGuids) 
                            ToolConsole.WriteWarning(SR.GetString(SR.MexEndpointAlreadyExposed, endpointConfig.ComponentProgID)); 
                        else
                            ToolConsole.WriteWarning(SR.GetString(SR.MexEndpointAlreadyExposed, endpointConfig.Clsid)); 
                    }
                    else
                    {
                        if (!Tool.Options.ShowGuids) 
                            ToolConsole.WriteWarning(SR.GetString(SR.InterfaceAlreadyExposed, endpointConfig.ComponentProgID, endpointConfig.InterfaceName));
                        else 
                            ToolConsole.WriteWarning(SR.GetString(SR.InterfaceAlreadyExposed, endpointConfig.Clsid, endpointConfig.Iid)); 
                    }
                } 
            }

            if (anyAdded)
            { 
                WasModified = true;
                config.Save(); 
            } 
        }
        void EnsureWSProfileBindingAdded (Configuration config) 
        {
            ServiceModelSectionGroup sg = ServiceModelSectionGroup.GetSectionGroup(config);
            if (!sg.Bindings.WSHttpBinding.Bindings.ContainsKey(this.DefaultBindingName))
            { 
                WSHttpBindingElement bindingConfig = new WSHttpBindingElement (this.DefaultBindingName);
                bindingConfig.ReliableSession.Enabled = true; 
                sg.Bindings.WSHttpBinding.Bindings.Add (bindingConfig); 
            }
            if (!sg.Bindings.WSHttpBinding.Bindings.ContainsKey(this.DefaultTransactionalBindingName)) 
            {
                WSHttpBindingElement bindingConfig = new WSHttpBindingElement (this.DefaultTransactionalBindingName);
                bindingConfig.ReliableSession.Enabled = true;
                bindingConfig.TransactionFlow = true; 
                sg.Bindings.WSHttpBinding.Bindings.Add (bindingConfig);
 
            } 
        }
 
        protected override void AddBinding (Configuration config)
        {
             EnsureWSProfileBindingAdded (config);
        } 

 
        const string defaultBindingType = "wsHttpBinding"; 
        const string defaultTransactionBindingType = "wsHttpBinding";
        const string defaultMexBindingType = "mexHttpBinding"; 
        const string defaultBindingName = "comNonTransactionalBinding";
        const string defaultTransactionalBindingName = "comTransactionalBinding";

        public override string DefaultBindingType { get { return defaultBindingType; }} 
        public override string DefaultBindingName { get { return defaultBindingName; }}
        public override string DefaultTransactionalBindingType { get { return defaultTransactionBindingType;} } 
        public override string DefaultTransactionalBindingName { get { return defaultTransactionalBindingName;}} 
        public override string DefaultMexBindingType {  get { return defaultMexBindingType;}}
        public override string DefaultMexBindingName {  get { return null;}} 

        void EnsureBindingRemoved (Configuration config)
        {
 
            ServiceModelSectionGroup sg = ServiceModelSectionGroup.GetSectionGroup(config);
            if (sg.Bindings.WSHttpBinding.Bindings.ContainsKey(this.DefaultBindingName)) 
            { 
                WSHttpBindingElement element = sg.Bindings.WSHttpBinding.Bindings[this.DefaultBindingName];
                sg.Bindings.WSHttpBinding.Bindings.Remove (element); 
            }
            if (sg.Bindings.WSHttpBinding.Bindings.ContainsKey(this.DefaultTransactionalBindingName))
            {
                WSHttpBindingElement element = sg.Bindings.WSHttpBinding.Bindings[this.DefaultTransactionalBindingName]; 
                sg.Bindings.WSHttpBinding.Bindings.Remove (element);
            } 
        } 
        protected override void RemoveBinding (Configuration config)
        { 
             EnsureBindingRemoved (config);
        }
        public override void CommitChanges()
        { 
            this.configFile.Commit();
            this.svcFileManager.Commit(); 
        } 

        public override string DefaultEndpointAddress(Guid appId, Guid clsid, Guid iid) 
        {
            ComAdminAppInfo adminAppInfo = ComAdminWrapper.GetAppInfo(appId.ToString("B"));
            if (null == adminAppInfo)
            { 
                throw Tool.CreateException(SR.GetString(SR.CannotFindAppInfo, appId.ToString("B")), null);
            } 
 
            ComAdminClassInfo adminClassInfo = adminAppInfo.FindClass(clsid.ToString("B"));
            if (null == adminClassInfo) 
            {
                throw Tool.CreateException(SR.GetString(SR.CannotFindClassInfo, clsid.ToString("B")), null);
            }
 
            ComAdminInterfaceInfo adminInterfaceInfo = adminClassInfo.FindInterface(iid.ToString("B"));
            if (null == adminInterfaceInfo) 
            { 
                throw Tool.CreateException(SR.GetString(SR.CannotFindInterfaceInfo, iid.ToString("B")), null);
            } 

            string uri = Uri.EscapeUriString(adminInterfaceInfo.Name);

            if (Uri.IsWellFormedUriString(uri, UriKind.RelativeOrAbsolute)) 
                return uri;
 
            return iid.ToString().ToUpperInvariant(); 
        }
 
        public override List GetBaseAddresses(EndpointConfig config)
        {
            return new List();
        } 

        public override string BaseServiceAddress(Guid appId, Guid clsid, Guid iid) 
        { 
            return String.Empty;
        } 

        public override string DefaultMexAddress(Guid appId, Guid clsid)
        {
            return  EndpointConfig.MexEndpointSuffix; 
        }
 
        public override Configuration GetConfiguration(bool readOnly) 
        {
            string fileName = this.configFile.GetCurrentFileName(readOnly); 
            if (string.IsNullOrEmpty(fileName))
            {
                return null;
            } 

            return GetConfigurationFromFile(fileName); 
        } 

        public override List GetEndpointConfigs() 
        {
            ThrowIfClosed();

            Configuration config = GetConfiguration(true); // readonly 
            if (config == null)
            { 
                // null config means there is no config to read, return an empty list 
                return new List();
            } 

            Dictionary> endpointConfigs = BaseGetEndpointsFromConfiguration(config);
            List list = new List();
 
            // now, fix up the appid for all the endpoints
            foreach (List endpoints in endpointConfigs.Values) 
            { 
                foreach (EndpointConfig endpoint in endpoints)
                { 
                    Guid appid;

                    if (this.svcFileManager.ResolveClsid(endpoint.Clsid, out appid))
                    { 
                        endpoint.Appid = appid;
                        list.Add(endpoint); 
                    } 
                    else
                    { 
                        string appName = endpoint.ApplicationName;
                        string componentID = endpoint.ComponentProgID;
                        string interfaceName = endpoint.InterfaceName;
 
                        if (!Tool.Options.ShowGuids && !string.IsNullOrEmpty(appName) && !string.IsNullOrEmpty(componentID) && !string.IsNullOrEmpty(interfaceName))
                            ToolConsole.WriteWarning(SR.GetString(SR.EndpointNotFoundInSvcFile, appName, componentID, interfaceName, endpoint.BindingName, endpoint.Address)); 
                        else 
                            ToolConsole.WriteWarning(SR.GetString(SR.EndpointNotFoundInSvcFile, endpoint.Appid.ToString ("B"), endpoint.Clsid.ToString ("B"), endpoint.Iid.ToString ("B"), endpoint.BindingName, endpoint.Address));
                    } 
                }
            }

            return list; 
        }
 
        int NumEndpointsForClsid(Configuration config, Guid clsid, Guid appId) 
        {
            ServiceModelSectionGroup sg = ServiceModelSectionGroup.GetSectionGroup(config); 
            ServiceElementCollection serviceColl = sg.Services.Services;

            foreach (ServiceElement se in serviceColl)
            { 

                string[] serviceParams = se.Name.Split(','); 
                if (serviceParams.Length != 2) 
                {
                    continue; 
                }

                Guid serviceAppId;
                Guid serviceClsid; 

                try 
                { 
                    serviceAppId = new Guid(serviceParams[0]);
                    serviceClsid = new Guid(serviceParams[1]); 
                }
                catch (FormatException)
                {
                    // Only Guid serviceTypes are of interest to us - those are the ones our listener picks up 
                    continue;
                } 
 
                if (serviceClsid == clsid && serviceAppId == appId)
                { 
                    return se.Endpoints.Count;
                }
            }
 
            return 0;
        } 
 
        public override void PrepareChanges()
        { 
            this.closed = true;
            bool workDone = this.configFile.HasBeenModified() && WasModified;

 
            this.configFile.Prepare();
 
            if (workDone) 
            {
                ToolConsole.WriteLine(SR.GetString((this.configFile.OriginalFileExists ? SR.FileUpdated : SR.FileCreated), configFile.OriginalFileName)); 
            }

            this.svcFileManager.Prepare();
        } 

        public override void Remove(IList endpointConfigs) 
        { 
            ThrowIfClosed();
 
            Configuration config = GetConfiguration(false); // not read only
            Debug.Assert(config != null, "config != null");

            bool anyRemoved = false; 

            foreach (EndpointConfig endpointConfig in endpointConfigs) 
            { 
                bool removed = this.BaseRemoveEndpointConfig(config, endpointConfig);
                if (removed) 
                {
                    anyRemoved = true;

                    if (NumEndpointsForClsid(config, endpointConfig.Clsid, endpointConfig.Appid) == 0) 
                    {
                        // We can only Remove the SVC file when there are no more endpoints for the Clsid 
                        this.svcFileManager.Remove(endpointConfig.Appid, endpointConfig.Clsid); 
                    }
                    if (!Tool.Options.ShowGuids) 
                        ToolConsole.WriteLine(SR.GetString(SR.InterfaceRemoved, endpointConfig.ComponentProgID, endpointConfig.InterfaceName));
                    else
                        ToolConsole.WriteLine(SR.GetString(SR.InterfaceRemoved, endpointConfig.Clsid, endpointConfig.Iid));
                } 
                else if(!endpointConfig.IsMexEndpoint)
                { 
                    if (!Tool.Options.ShowGuids) 
                        ToolConsole.WriteWarning(SR.GetString(SR.InterfaceNotExposed, endpointConfig.ComponentProgID, endpointConfig.InterfaceName));
                    else 
                        ToolConsole.WriteWarning(SR.GetString(SR.InterfaceNotExposed, endpointConfig.Clsid, endpointConfig.Iid));
                }
            }
 
            if (anyRemoved)
            { 
                WasModified = true; 
                config.Save();
            } 
        }

        void ThrowIfClosed()
        { 
            if (this.closed)
            { 
                Debug.Assert(false, "attempting operation after container is closed"); 
                throw new InvalidOperationException();
            } 
        }

        public static string DefaultWebServer
        { 
            get { return WasAdminWrapper.DefaultWebServer; }
        } 
 
        public static List Get()
        { 
            List containers = new List();
            string [] webServers = WasAdminWrapper.GetWebServerNames();
            if (webServers != null)
            { 
                foreach (string webServer in webServers)
                { 
                    List cont = Get(webServer); 
                    containers.AddRange(cont);
                } 
            }
            return containers;
        }
 
        public static List Get(string webServer)
        { 
            List containers = new List(); 
            string [] webDirectories = WasAdminWrapper.GetWebDirectoryNames(webServer);
            if (webDirectories != null) 
            {
                foreach (string webDirectory in webDirectories)
                {
                    WasEndpointConfigContainer container = Get(webServer, webDirectory); 
                    if (container != null)
                    { 
                        containers.Add(container); 
                    }
                } 
            }
            return containers;
        }
 
        public static WasEndpointConfigContainer Get(string webServer, string webDirectory)
        { 
            string webDirectoryPath = null; 

            if (WasAdminWrapper.GetWebDirectoryPath(webServer, webDirectory, out webDirectoryPath)) 
            {
                try
                {
                    return new WasEndpointConfigContainer(webServer, webDirectory, webDirectoryPath); 
                }
                catch (Exception ex) 
                { 
                    if (ex is NullReferenceException || ex is SEHException)
                    { 
                        throw ex;
                    }
                    ToolConsole.WriteWarning (SR.GetString (SR.FailedToLoadConfigForWebDirectoryOnWebSite, webDirectory, webServer));
 
                }
                return null; 
            } 
            else
            { 
                return null;
            }
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.


                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK