Facilities/Wcf/Castle.Facilities.WcfIntegration/WcfEndpoint.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.Collections.Generic;
  19     using System.ServiceModel;
  20     using System.ServiceModel.Channels;
  21         using System.ServiceModel.Description;
  22
  23         public static class WcfEndpoint
  24         {
  25                 public static ServiceEndpointModel FromEndpoint(ServiceEndpoint endpoint)
  26                 {
  27                         return new ContractEndpointModel().FromEndpoint(endpoint);
  28                 }
  29
  30                 public static ConfigurationEndpointModel FromConfiguration(string endpointName)
  31                 {
  32                         return new ContractEndpointModel().FromConfiguration(endpointName);
  33                 }
  34
  35                 public static BindingEndpointModel BoundTo(Binding binding)
  36                 {
  37                         return new ContractEndpointModel().BoundTo(binding);
  38                 }
  39
  40                 public static BindingAddressEndpointModel At(string address)
  41                 {
  42                         return new ContractEndpointModel().At(address);
  43                 }
  44
  45                 public static BindingAddressEndpointModel At(Uri address)
  46                 {
  47                         return new ContractEndpointModel().At(address);
  48                 }
  49
  50                 public static ContractEndpointModel ForContract(Type contract)
  51                 {
  52                         return new ContractEndpointModel(contract);
  53                 }
  54
  55                 public static ContractEndpointModel ForContract<Contract>()
  56                         where Contract : class
  57                 {
  58                         return ForContract(typeof(Contract));
  59                 }
  60         }
  61
  62         #region Nested Class: WcfEndpointBase
  63
  64         public abstract class WcfEndpointBase : IWcfEndpoint
  65         {
  66                 private Type contract;
  67                 private ICollection<IWcfBehavior> behaviors;
  68
  69                 protected WcfEndpointBase(Type contract)
  70                 {
  71                         this.contract = contract;
  72                 }
  73
  74                 #region IWcfEndpoint Members
  75
  76                 public Type Contract
  77                 {
  78                         get { return contract; }
  79                 }
  80
  81                 Type IWcfEndpoint.Contract
  82                 {
  83                         get { return contract; }
  84                         set { contract = value; }
  85                 }
  86
  87                 public ICollection<IWcfBehavior> Behaviors
  88                 {
  89                         get
  90                         {
  91                                 if (behaviors == null)
  92                                 {
  93                                         behaviors = new List<IWcfBehavior>();
  94                                 }
  95                                 return behaviors;
  96                         }
  97                 }
  98
  99                 void IWcfEndpoint.Accept(IWcfEndpointVisitor visitor)
 100                 {
 101                         Accept(visitor);
 102                 }
 103
 104                 protected abstract void Accept(IWcfEndpointVisitor visitor);
 105
 106                 #endregion
 107         }
 108
 109         public abstract class WcfEndpointBase<T> : WcfEndpointBase
 110                 where T : WcfEndpointBase<T>
 111         {
 112                 protected WcfEndpointBase(Type contract)
 113                         : base(contract)
 114                 {
 115                 }
 116
 117                 public T AddBehaviors(params object[] behaviors)
 118                 {
 119                         foreach (object behavior in behaviors)
 120                         {
 121                                 Behaviors.Add(WcfExplcitBehavior.CreateFrom(behavior));
 122                         }
 123                         return (T)this;
 124                 }
 125         }
 126
 127         #endregion
 128
 129         #region Nested Class: ContractModel
 130
 131         public class ContractEndpointModel : WcfEndpointBase<ContractEndpointModel>
 132         {
 133                 internal ContractEndpointModel()
 134                         : this(null)
 135                 {
 136                 }
 137
 138                 internal ContractEndpointModel(Type contract)
 139                         : base(contract)
 140                 {
 141                 }
 142
 143                 public ServiceEndpointModel FromEndpoint(ServiceEndpoint endpoint)
 144                 {
 145                         if (endpoint == null)
 146                         {
 147                                 throw new ArgumentNullException("endpoint");
 148                         }
 149
 150                         return new ServiceEndpointModel(Contract, endpoint);
 151                 }
 152
 153                 public ConfigurationEndpointModel FromConfiguration(string endpointName)
 154                 {
 155                         if (string.IsNullOrEmpty(endpointName))
 156                         {
 157                                 throw new ArgumentException("endpointName cannot be nul or empty");
 158                         }
 159                         return new ConfigurationEndpointModel(Contract, endpointName);
 160                 }
 161
 162                 public BindingEndpointModel BoundTo(Binding binding)
 163                 {
 164                         if (binding == null)
 165                         {
 166                                 throw new ArgumentNullException("binding");
 167                         }
 168                         return new BindingEndpointModel(Contract, binding);
 169                 }
 170
 171                 public BindingAddressEndpointModel At(string address)
 172                 {
 173                         return new BindingEndpointModel(Contract, null).At(address);
 174                 }
 175
 176                 public BindingAddressEndpointModel At(Uri address)
 177                 {
 178                         return new BindingEndpointModel(Contract, null).At(address);
 179                 }
 180
 181                 protected override void Accept(IWcfEndpointVisitor visitor)
 182                 {
 183                         visitor.VisitContractEndpoint(this);
 184                 }
 185         }
 186
 187         #endregion
 188
 189         #region Nested Class: ServiceEndpointModel
 190
 191         public class ServiceEndpointModel : WcfEndpointBase<ServiceEndpointModel>
 192         {
 193                 private readonly ServiceEndpoint endpoint;
 194
 195                 internal ServiceEndpointModel(Type contract, ServiceEndpoint endpoint)
 196                         : base(contract)
 197                 {
 198                         this.endpoint = endpoint;
 199                 }
 200
 201                 public ServiceEndpoint ServiceEndpoint
 202                 {
 203                         get { return endpoint; }
 204                 }
 205
 206                 protected override void Accept(IWcfEndpointVisitor visitor)
 207                 {
 208                         visitor.VisitServiceEndpoint(this);
 209                 }
 210         }
 211
 212         #endregion
 213
 214         #region Nested Class: ConfigurationEndpointModel
 215
 216         public class ConfigurationEndpointModel : WcfEndpointBase<ConfigurationEndpointModel>
 217         {
 218                 private readonly string endpointName;
 219
 220                 internal ConfigurationEndpointModel(Type contract, string endpointName)
 221                         : base(contract)
 222                 {
 223                         this.endpointName = endpointName;
 224                 }
 225
 226                 public string EndpointName
 227                 {
 228                         get { return endpointName; }
 229                 }
 230
 231                 protected override void Accept(IWcfEndpointVisitor visitor)
 232                 {
 233                         visitor.VisitConfigurationEndpoint(this);
 234                 }
 235         }
 236
 237         #endregion
 238
 239         #region Nested Class: BindingEndpointModel
 240
 241         public class BindingEndpointModel : WcfEndpointBase<BindingEndpointModel>
 242         {
 243                 private readonly Binding binding;
 244
 245                 internal BindingEndpointModel(Type contract, Binding binding)
 246                         : base(contract)
 247                 {
 248                         this.binding = binding;
 249                 }
 250
 251                 public Binding Binding
 252                 {
 253                         get { return binding; }
 254                 }
 255
 256                 public BindingAddressEndpointModel At(string address)
 257                 {
 258                         if (string.IsNullOrEmpty(address))
 259                         {
 260                                 throw new ArgumentException("address cannot be null or empty");
 261                         }
 262                         return new BindingAddressEndpointModel(Contract, Binding, address);
 263                 }
 264
 265                 public BindingAddressEndpointModel At(Uri address)
 266                 {
 267                         if (address == null)
 268                         {
 269                                 throw new ArgumentNullException("address");
 270                         }
 271                         return new BindingAddressEndpointModel(Contract, Binding, address.AbsoluteUri);
 272                 }
 273
 274                 public BindingAddressEndpointModel At(EndpointAddress address)
 275                 {
 276                         if (address == null)
 277                         {
 278                                 throw new ArgumentNullException("address");
 279                         }
 280                         return new BindingAddressEndpointModel(Contract, Binding, address);
 281                 }
 282
 283                 protected override void Accept(IWcfEndpointVisitor visitor)
 284                 {
 285                         visitor.VisitBindingEndpoint(this);
 286                 }
 287         }
 288
 289         #endregion
 290
 291         #region Nested Class: BindingAddressEndpointModel
 292
 293         public class BindingAddressEndpointModel : WcfEndpointBase<BindingAddressEndpointModel>
 294         {
 295                 private readonly Binding binding;
 296                 private readonly string address;
 297                 private readonly EndpointAddress endpointAddress;
 298                 private string via;
 299
 300                 internal BindingAddressEndpointModel(Type contract, Binding binding,
 301                                                                                          string address)
 302                         : base(contract)
 303                 {
 304                         this.binding = binding;
 305                         this.address = address;
 306                 }
 307
 308                 internal BindingAddressEndpointModel(Type contract, Binding binding,
 309                                                                                          EndpointAddress address)
 310                         : base(contract)
 311                 {
 312                         this.binding = binding;
 313                         this.endpointAddress = address;
 314                 }
 315
 316                 public Binding Binding
 317                 {
 318                         get { return binding; }
 319                 }
 320
 321                 public string Address
 322                 {
 323                         get { return address ?? endpointAddress.Uri.AbsoluteUri; }
 324                 }
 325
 326                 public EndpointAddress EndpointAddress
 327                 {
 328                         get { return endpointAddress; }
 329                 }
 330
 331                 public Uri ViaAddress
 332                 {
 333                         get { return new Uri(via, UriKind.Absolute); }
 334                 }
 335
 336                 public bool HasViaAddress
 337                 {
 338                         get { return !string.IsNullOrEmpty(via); }
 339                 }
 340
 341                 public BindingAddressEndpointModel Via(string physicalAddress)
 342                 {
 343                         via = physicalAddress;
 344                         return this;
 345                 }
 346
 347                 protected override void Accept(IWcfEndpointVisitor visitor)
 348                 {
 349                         visitor.VisitBindingAddressEndpoint(this);
 350                 }
 351         }
 352
 353         #endregion
 354 }
 355