InversionOfControl/Castle.MicroKernel/Facilities/Remoting/RemotingInspector.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.Remoting
  16 {
  17         using System;
  18         using System.Runtime.Remoting;
  19         using Castle.Core;
  20
  21         using Castle.MicroKernel;
  22         using Castle.MicroKernel.ModelBuilder;
  23         using Castle.MicroKernel.Facilities;
  24         using Castle.MicroKernel.SubSystems.Conversion;
  25
  26         enum RemotingStrategy
  27         {
  28                 None,
  29                 Singleton,
  30                 SingleCall,
  31                 ClientActivated,
  32                 Component,
  33                 RecoverableComponent
  34         }
  35
  36         /// <summary>
  37         /// Inspects the model looking for remote component configuration. If found,
  38         /// do the component Remoting configuration.
  39         /// </summary>
  40         public class RemotingInspector : IContributeComponentModelConstruction
  41         {
  42                 private readonly RemotingRegistry remoteRegistry;
  43                 private readonly RemotingRegistry localRegistry;
  44                 private readonly ITypeConverter converter;
  45                 private readonly String baseUri;
  46                 private readonly bool isServer, isClient;
  47
  48             private const string UriExtension = ".rem";
  49
  50                 /// <summary>
  51                 /// Initializes a new instance of the <see cref="RemotingInspector"/> class.
  52                 /// </summary>
  53                 /// <param name="converter">The converter.</param>
  54                 /// <param name="isServer">if set to <c>true</c> is a server.</param>
  55                 /// <param name="isClient">if set to <c>true</c> is a client.</param>
  56                 /// <param name="baseUri">The base URI.</param>
  57                 /// <param name="remoteRegistry">The remote registry.</param>
  58                 /// <param name="localRegistry">The local registry.</param>
  59                 public RemotingInspector(ITypeConverter converter, bool isServer, bool isClient,
  60                         String baseUri, RemotingRegistry remoteRegistry, RemotingRegistry localRegistry)
  61                 {
  62                         this.converter = converter;
  63                         this.isServer = isServer;
  64                         this.isClient = isClient;
  65                         this.baseUri = baseUri;
  66                         this.remoteRegistry = remoteRegistry;
  67                         this.localRegistry = localRegistry;
  68                 }
  69
  70                 public void ProcessModel(IKernel kernel, ComponentModel model)
  71                 {
  72                         if (model.Configuration == null) return;
  73
  74                         String remoteserverAttValue = model.Configuration.Attributes["remoteserver"];
  75                         String remoteclientAttValue = model.Configuration.Attributes["remoteclient"];
  76
  77                         RemotingStrategy server = RemotingStrategy.None;
  78                         RemotingStrategy client = RemotingStrategy.None;
  79
  80                         if (remoteserverAttValue == null && remoteclientAttValue == null)
  81                         {
  82                                 return;
  83                         }
  84
  85                         if (remoteserverAttValue != null)
  86                         {
  87                                 server = (RemotingStrategy)
  88                                         converter.PerformConversion(remoteserverAttValue, typeof(RemotingStrategy));
  89                         }
  90
  91                         if (remoteclientAttValue != null)
  92                         {
  93                                 client = (RemotingStrategy)
  94                                         converter.PerformConversion(remoteclientAttValue, typeof(RemotingStrategy));
  95                         }
  96
  97                         DoSemanticCheck(server, model, client);
  98
  99                         ConfigureServerComponent(server, model.Implementation, model);
 100
 101                         ConfigureClientComponent(client, model.Service, model);
 102                 }
 103
 104                 private void ConfigureServerComponent(RemotingStrategy server, Type type, ComponentModel model)
 105                 {
 106                         if (server == RemotingStrategy.None) return;
 107
 108                         String uri = ConstructServerURI(server, model.Name, model);
 109
 110                         switch (server)
 111                         {
 112                                 case RemotingStrategy.Singleton:
 113                                 {
 114                                         CheckURIIsNotNull(uri, model.Name);
 115
 116                                         RemotingConfiguration.RegisterWellKnownServiceType(type, uri, WellKnownObjectMode.Singleton);
 117
 118                                         break;
 119                                 }
 120                                 case RemotingStrategy.SingleCall:
 121                                 {
 122                                         CheckURIIsNotNull(uri, model.Name);
 123
 124                                         RemotingConfiguration.RegisterWellKnownServiceType(type, uri, WellKnownObjectMode.SingleCall);
 125
 126                                         break;
 127                                 }
 128                                 case RemotingStrategy.ClientActivated:
 129                                 {
 130                                         RemotingConfiguration.RegisterActivatedServiceType(type);
 131
 132                                         break;
 133                                 }
 134                                 case RemotingStrategy.Component:
 135                                 {
 136                                         localRegistry.AddComponentEntry(model);
 137
 138                                         break;
 139                                 }
 140                                 case RemotingStrategy.RecoverableComponent:
 141                                 {
 142                                         CheckURIIsNotNull(uri, model.Name);
 143
 144                                         ValidateLifeStyle(model);
 145
 146                                         localRegistry.AddComponentEntry(model);
 147
 148                                         model.ExtendedProperties.Add("remoting.uri", uri);
 149                                         model.ExtendedProperties.Add("remoting.afinity", true);
 150
 151                                         model.CustomComponentActivator = typeof(RemoteMarshallerActivator);
 152
 153                                         break;
 154                                 }
 155                         }
 156                 }
 157
 158                 private static void ValidateLifeStyle(ComponentModel model)
 159                 {
 160                         if (model.LifestyleType != LifestyleType.Singleton &&
 161                             model.LifestyleType != LifestyleType.Undefined)
 162                         {
 163                                 throw new FacilityException(String.Format("Component {0} is marked as a 'RecoverableComponent' but is using a lifestyle " +
 164                                         "different than Singleton. Unfortunatelly Singleton is the only lifestyle supported for this of remoting component configuration", model.Name));
 165                         }
 166                 }
 167
 168                 private void ConfigureClientComponent(RemotingStrategy client, Type type, ComponentModel model)
 169                 {
 170                         if (client == RemotingStrategy.None) return;
 171
 172                         ResetDependencies(model);
 173
 174                         String uri = ConstructClientURI(client, model.Name, model);
 175
 176                         bool skipRemotingRegistration = Convert.ToBoolean(model.Configuration.Attributes["skipRemotingRegistration"]);
 177
 178                         switch (client)
 179                         {
 180                                 case RemotingStrategy.Singleton:
 181                                 case RemotingStrategy.SingleCall:
 182                                 {
 183                                         if (!skipRemotingRegistration)
 184                                         {
 185                                                 RemotingConfiguration.RegisterWellKnownClientType(type, uri);
 186                                         }
 187
 188                                         model.ExtendedProperties.Add("remoting.uri", uri);
 189                                         model.CustomComponentActivator = typeof(RemoteActivator);
 190
 191                                         break;
 192                                 }
 193                                 case RemotingStrategy.ClientActivated:
 194                                 {
 195                                         CheckHasBaseURI();
 196
 197                                         if (!skipRemotingRegistration)
 198                                         {
 199                                                 RemotingConfiguration.RegisterActivatedClientType(type, baseUri);
 200                                         }
 201
 202                                         model.ExtendedProperties.Add("remoting.appuri", baseUri);
 203                                         model.CustomComponentActivator = typeof(RemoteClientActivatedActivator);
 204
 205                                         break;
 206                                 }
 207                                 case RemotingStrategy.Component:
 208                                 {
 209                                         model.ExtendedProperties.Add("remoting.remoteregistry", remoteRegistry);
 210                                         model.CustomComponentActivator = typeof(RemoteActivatorThroughRegistry);
 211
 212                                         break;
 213                                 }
 214                                 case RemotingStrategy.RecoverableComponent:
 215                                 {
 216                                         CheckHasBaseURI();
 217
 218                                         String remoteUri = SetUriExtensionIfNeeded(uri);
 219
 220                                         model.ExtendedProperties.Add("remoting.uri", remoteUri);
 221                                         model.ExtendedProperties.Add("remoting.remoteregistry", remoteRegistry);
 222                                         model.CustomComponentActivator = typeof(RemoteActivatorThroughConnector);
 223
 224                                         break;
 225                                 }
 226                         }
 227                 }
 228
 229                 private void DoSemanticCheck(RemotingStrategy server, ComponentModel model, RemotingStrategy client)
 230                 {
 231                         if (server != RemotingStrategy.None && client != RemotingStrategy.None)
 232                         {
 233                                 String message = String.Format("Component {0} cannot be a remote server and a client "+
 234                                         "at the same time", model.Name);
 235
 236                                 throw new FacilityException(message);
 237                         }
 238
 239                         if (server == RemotingStrategy.Component && !isServer)
 240                         {
 241                                 String message = String.Format("Component {0} was marked with remoteserver='component', " +
 242                                         "but you must enable the remoting facility with isServer='true' to serve components this way", model.Name);
 243
 244                                 throw new FacilityException(message);
 245                         }
 246
 247                         if (client == RemotingStrategy.Component && !isClient)
 248                         {
 249                                 String message = String.Format("Component {0} was marked with remoteserver='component', " +
 250                                         "but you must enable the remoting facility with isServer='true' to serve components this way", model.Name);
 251
 252                                 throw new FacilityException(message);
 253                         }
 254                 }
 255
 256                 private String ConstructClientURI(RemotingStrategy client, String componentId, ComponentModel model)
 257                 {
 258                         if (client == RemotingStrategy.ClientActivated) return null;
 259
 260                         String value = model.Configuration.Attributes["uri"];
 261
 262                         String uriText;
 263
 264                         if (client != RemotingStrategy.None && baseUri != null && value == null)
 265                         {
 266                                 uriText = BuildUri(componentId);
 267                         }
 268                         else
 269                         {
 270                                 uriText = value;
 271                         }
 272
 273                         return uriText;
 274                 }
 275
 276                 private String BuildUri(String cpntUri)
 277                 {
 278                         String uriText;
 279
 280                         if (baseUri.EndsWith("/"))
 281                         {
 282                                 uriText = SetUriExtensionIfNeeded(String.Format("{0}{1}", baseUri, cpntUri));
 283                         }
 284                         else
 285                         {
 286                                 uriText = SetUriExtensionIfNeeded(String.Format("{0}/{1}", baseUri, cpntUri));
 287                         }
 288
 289                         return uriText;
 290                 }
 291
 292                 private static string SetUriExtensionIfNeeded(string uri)
 293                 {
 294                         if (!uri.EndsWith(".rem"))
 295                         {
 296                                 return uri + UriExtension;
 297                         }
 298
 299                         return uri;
 300                 }
 301
 302                 private String ConstructServerURI(RemotingStrategy server, String componentId, ComponentModel model)
 303                 {
 304                         if (server == RemotingStrategy.ClientActivated) return null;
 305
 306                         String value = model.Configuration.Attributes["uri"];
 307
 308                         String uriText;
 309
 310                         if (value == null)
 311                         {
 312                                 uriText = SetUriExtensionIfNeeded(componentId);
 313                         }
 314                         else
 315                         {
 316                                 uriText = SetUriExtensionIfNeeded(value);
 317                         }
 318
 319                         return uriText;
 320                 }
 321
 322                 /// <summary>
 323                 /// Client components are not created by the container
 324                 /// so there's no point collecting constructor dependencies
 325                 /// </summary>
 326                 /// <param name="model"></param>
 327                 private void ResetDependencies(ComponentModel model)
 328                 {
 329                         model.Dependencies.Clear();
 330                         model.Constructors.Clear();
 331                 }
 332
 333                 private void CheckHasBaseURI()
 334                 {
 335                         if (baseUri == null)
 336                         {
 337                                 String message = "baseUri must be defined in order to use client activated objects";
 338                                 throw new FacilityException(message);
 339                         }
 340                 }
 341
 342                 private void CheckURIIsNotNull(String uri, String componentId)
 343                 {
 344                         if (uri == null)
 345                         {
 346                                 String message = String.Format("Could not obtain (or infer) " +
 347                                         "URI for remote component {0}", componentId);
 348
 349                                 throw new FacilityException(message);
 350                         }
 351                 }
 352         }
 353 }