Facilities/Wcf/Castle.Facilities.WcfIntegration/WcfFacility.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Facilities.WcfIntegration
  16 {
  17         using System;
  18         using System.ServiceModel;
  19         using System.ServiceModel.Description;
  20         using Castle.Core;
  21         using Castle.MicroKernel;
  22         using Castle.MicroKernel.Facilities;
  23
  24         public class WcfFacility : AbstractFacility
  25         {
  26                 private readonly WcfClientModel[] clientModels;
  27
  28                 public WcfFacility()
  29                 {
  30                 }
  31
  32                 public WcfFacility(params WcfClientModel[] clientModels)
  33                 {
  34                         foreach (WcfClientModel clientModel in clientModels)
  35                         {
  36                                 ValidateClientModel(clientModel, null);
  37                         }
  38                         this.clientModels = clientModels;
  39                 }
  40
  41                 protected override void Init()
  42                 {
  43                         Kernel.ComponentRegistered += Kernel_ComponentRegistered;
  44                         Kernel.ComponentUnregistered += Kernel_ComponentUnregistered;
  45                         Kernel.ComponentModelCreated += Kernel_ComponentModelCreated;
  46
  47                         if (clientModels != null && clientModels.Length > 0)
  48                         {
  49                                 Kernel.Resolver.AddSubResolver(new WcfClientResolver(clientModels));
  50                         }
  51                 }
  52
  53                 private void Kernel_ComponentModelCreated(ComponentModel componentModel)
  54                 {
  55                         WcfClientModel clientModel = ResolveClientModel(componentModel);
  56
  57                         if (clientModel != null)
  58                         {
  59                                 componentModel.ExtendedProperties[WcfConstants.ClientModelKey] = clientModel;
  60                                 componentModel.CustomComponentActivator = typeof(WcfClientActivator);
  61                                 componentModel.LifestyleType = LifestyleType.Transient;
  62                         }
  63                 }
  64
  65                 private void Kernel_ComponentRegistered(string key, IHandler handler)
  66                 {
  67                         ComponentModel componentModel = handler.ComponentModel;
  68                         WcfServiceModel serviceModel = ResolveServiceModel(componentModel);
  69
  70                         if (serviceModel != null)
  71                         {
  72                                 WindsorServiceHost serviceHost = CreateAndOpenServiceHost(serviceModel, componentModel);
  73                                 componentModel.ExtendedProperties[WcfConstants.ServiceHostKey] = serviceHost;
  74                         }
  75                 }
  76
  77                 private void Kernel_ComponentUnregistered(string key, IHandler handler)
  78                 {
  79                         ComponentModel componentModel = handler.ComponentModel;
  80                         ServiceHost serviceHost =
  81                                 componentModel.ExtendedProperties[WcfConstants.ServiceHostKey] as ServiceHost;
  82
  83                         if (serviceHost != null)
  84                         {
  85                                 serviceHost.Close();
  86                         }
  87                 }
  88
  89                 private WcfClientModel ResolveClientModel(ComponentModel componentModel)
  90                 {
  91                         WcfClientModel clientModel = null;
  92
  93                         if (componentModel.Service.IsInterface)
  94                         {
  95                                 if (WcfUtils.FindDependency<WcfClientModel>(
  96                                         componentModel.CustomDependencies, out clientModel))
  97                                 {
  98                                         ValidateClientModel(clientModel, componentModel);
  99                                 }
 100                         }
 101
 102                         return clientModel;
 103                 }
 104
 105                 private WcfServiceModel ResolveServiceModel(ComponentModel componentModel)
 106                 {
 107                         WcfServiceModel serviceModel = null;
 108
 109                         if (componentModel.Implementation.IsClass &&
 110                                 !componentModel.Implementation.IsAbstract)
 111                         {
 112                                 if (WcfUtils.FindDependency<WcfServiceModel>(
 113                                         componentModel.CustomDependencies, out serviceModel))
 114                                 {
 115                                         ValidateServiceModel(serviceModel, componentModel);
 116                                 }
 117                         }
 118
 119                         return serviceModel;
 120                 }
 121
 122
 123                 private void AddServiceEndpoint(WcfEndpoint endpoint, WindsorServiceHost serviceHost)
 124                 {
 125                         if (endpoint.EndpointAddress != null)
 126                         {
 127                                 ContractDescription contract = ContractDescription.GetContract(endpoint.Contract);
 128                                 serviceHost.Description.Endpoints.Add(
 129                                         new ServiceEndpoint(contract, endpoint.Binding, endpoint.EndpointAddress));
 130                         }
 131                         else if (!string.IsNullOrEmpty(endpoint.Via))
 132                         {
 133                                 serviceHost.AddServiceEndpoint(endpoint.Contract, endpoint.Binding,
 134                                         endpoint.Address, new Uri(endpoint.Via));
 135                         }
 136                         else
 137                         {
 138                                 serviceHost.AddServiceEndpoint(
 139                                         endpoint.Contract, endpoint.Binding, endpoint.Address);
 140                         }
 141                 }
 142
 143                 private WindsorServiceHost CreateAndOpenServiceHost(WcfServiceModel serviceModel,
 144                                                                                                                         ComponentModel componentModel)
 145                 {
 146                         WindsorServiceHost serviceHost = new WindsorServiceHost(
 147                                 Kernel, componentModel.Implementation, serviceModel.GetBaseAddressesUris());
 148
 149                         foreach (WcfEndpoint endpoint in serviceModel.Endpoints)
 150                         {
 151                                 AddServiceEndpoint(endpoint, serviceHost);
 152                         }
 153
 154                         serviceHost.Open();
 155                         return serviceHost;
 156                 }
 157
 158                 private void ValidateClientModel(WcfClientModel clientModel, ComponentModel componentModel)
 159                 {
 160                         Type contract;
 161
 162                         if (componentModel != null)
 163                         {
 164                                 contract = componentModel.Service;
 165                         }
 166                         else if (clientModel.Contract != null)
 167                         {
 168                                 contract = clientModel.Contract;
 169                         }
 170                         else
 171                         {
 172                                 throw new FacilityException(
 173                                         "The client endpoint does not specify a contract.");
 174                         }
 175
 176                         if ((componentModel != null) && (clientModel.Contract != null) &&
 177                                 (clientModel.Contract != componentModel.Service))
 178                         {
 179                                 throw new FacilityException("The client endpoint contract " +
 180                                         clientModel.Contract.FullName + " does not match the expected contaxt" +
 181                                         componentModel.Service.FullName + ".");
 182                         }
 183
 184                         clientModel.Contract = contract;
 185
 186                         if (string.IsNullOrEmpty(clientModel.EndpointName))
 187                         {
 188                                 if (string.IsNullOrEmpty(clientModel.Address) && (clientModel.EndpointAddress == null))
 189                                 {
 190                                         throw new FacilityException("The client endpoint for contract " +
 191                                                 contract.FullName + " does not specify an address.");
 192                                 }
 193
 194                                 if (clientModel.Binding == null)
 195                                 {
 196                                         throw new FacilityException("The client endpoint for contract " +
 197                                                 contract.FullName + " does not specify a binding.");
 198                                 }
 199                         }
 200                 }
 201
 202                 private void ValidateServiceModel(WcfServiceModel serviceModel, ComponentModel componentModel)
 203                 {
 204                         foreach (WcfEndpoint endpoint in serviceModel.Endpoints)
 205                         {
 206                                 Type contract = endpoint.Contract;
 207
 208                                 if (contract != null)
 209                                 {
 210                                         if (!contract.IsInterface)
 211                                         {
 212                                                 throw new FacilityException("The service endpoint contract " +
 213                                                         contract.FullName + " does not represent an interface.");
 214                                         }
 215                                 }
 216                                 else if (!componentModel.Service.IsInterface)
 217                                 {
 218                                         throw new FacilityException(
 219                                                 "No service endpoint contract can be implied from the componnt.");
 220                                 }
 221                                 else
 222                                 {
 223                                         endpoint.Contract = componentModel.Service;
 224                                 }
 225
 226                                 if (endpoint.Binding == null)
 227                                 {
 228                                         throw new FacilityException("The service endpoint for contract " +
 229                                                 endpoint.Contract.FullName + " does not specify a binding.");
 230                                 }
 231
 232                                 if (endpoint.Address == null && endpoint.EndpointAddress == null)
 233                                 {
 234                                         endpoint.Address = string.Empty;  // Maybe has a base address
 235                                 }
 236                         }
 237                 }
 238         }
 239 }
 240