Tools/ManagedExtensions/ManagementExtensions/Default/MDefaultRegistry.cs

   1 // Copyright 2003-2004 DigitalCraftsmen - http://www.digitalcraftsmen.com.br/
   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.ManagementExtensions.Default
  16 {
  17         using System;
  18
  19         /// <summary>
  20         /// Default (and simple) implementation of <see cref="Castle.ManagementExtensions.MRegistry"/>.
  21         /// TODO: Implement a lyfecycle for registering managed components.
  22         /// </summary>
  23         [ManagedComponent]
  24         public class MDefaultRegistry : MarshalByRefObject, MRegistry
  25         {
  26                 protected DomainCollection domains = new DomainCollection();
  27
  28                 protected MServer server;
  29
  30                 public MDefaultRegistry(MServer server)
  31                 {
  32                         if (server == null)
  33                         {
  34                                 throw new ArgumentNullException("server");
  35                         }
  36
  37                         this.server = server;
  38                 }
  39
  40                 #region MRegistry Members
  41
  42                 /// <summary>
  43                 /// Registers an instance if its not already registered.
  44                 /// </summary>
  45                 /// <param name="instance">Instance to be register - can't be null.</param>
  46                 /// <param name="name">Instance's name - can't be null.</param>
  47                 /// <returns>A ManagedInstance representing the instance data.</returns>
  48                 [ManagedOperation]
  49                 public ManagedInstance RegisterManagedObject(Object instance, ManagedObjectName name)
  50                 {
  51                         if (name == null)
  52                         {
  53                                 throw new ArgumentNullException("name");
  54                         }
  55                         if (instance == null)
  56                         {
  57                                 throw new ArgumentNullException("instance");
  58                         }
  59
  60                         ComponentType cType = MInspector.Inspect(instance);
  61                         MDynamicSupport dynamic = null;
  62
  63                         if (cType == ComponentType.None)
  64                         {
  65                                 throw new InvalidComponentException("Component is not a managed component.");
  66                         }
  67
  68                         if (cType == ComponentType.Standard)
  69                         {
  70                                 dynamic = MDynamicSupportFactory.Create(instance);
  71                         }
  72                         else if (cType == ComponentType.Dynamic)
  73                         {
  74                                 dynamic = (MDynamicSupport) instance;
  75                         }
  76
  77                         String domainName = name.Domain;
  78                         Domain domain = null;
  79
  80                         lock(domains)
  81                         {
  82                                 domain = domains[domainName];
  83
  84                                 if (domain == null)
  85                                 {
  86                                         domain = new Domain(domainName);
  87                                         domains.Add(domain);
  88                                 }
  89                         }
  90
  91                         Entry entry = new Entry(instance, dynamic);
  92
  93                         try
  94                         {
  95                                 MRegistrationListener registration = instance as MRegistrationListener;
  96
  97                                 InvokeBeforeRegister(registration, name);
  98
  99                                 lock(domain)
 100                                 {
 101                                         if (domain.Contains(name))
 102                                         {
 103                                                 throw new InstanceAlreadyRegistredException(name.ToString());
 104                                         }
 105
 106                                         domain.Add(name, entry);
 107                                 }
 108
 109                                 InvokeAfterRegister(registration);
 110                         }
 111                         catch(Exception e)
 112                         {
 113                                 domain.Remove(name);
 114
 115                                 throw e;
 116                         }
 117
 118                         return new ManagedInstance(instance.GetType().FullName, name);
 119                 }
 120
 121                 /// <summary>
 122                 /// Returns <see cref="Castle.ManagementExtensions.ManagedInstance"/>
 123                 /// of specified <see cref="Castle.ManagementExtensions.ManagedObjectName"/>.
 124                 /// </summary>
 125                 /// <param name="name">The name to be located.</param>
 126                 /// <returns>A ManagedInstance representing the instance data.</returns>
 127                 [ManagedOperation]
 128                 public ManagedInstance GetManagedInstance(ManagedObjectName name)
 129                 {
 130                         if (name == null)
 131                         {
 132                                 throw new ArgumentNullException("name");
 133                         }
 134
 135                         return new ManagedInstance(GetEntry(name).Instance.GetType().FullName, name);
 136                 }
 137
 138                 /// <summary>
 139                 /// Unregisters the specified object.
 140                 /// </summary>
 141                 /// <param name="name">The name to be located.</param>
 142                 [ManagedOperation]
 143                 public void UnregisterManagedObject(ManagedObjectName name)
 144                 {
 145                         if (name == null)
 146                         {
 147                                 throw new ArgumentNullException("name");
 148                         }
 149
 150                         String domainName = name.Domain;
 151
 152                         try
 153                         {
 154                                 Domain domain = FindDomain(domainName);
 155                                 Entry entry = domain[name];
 156
 157                                 if (entry != null)
 158                                 {
 159                                         MRegistrationListener listener = entry.Instance as MRegistrationListener;
 160
 161                                         InvokeBeforeDeregister(listener);
 162
 163                                         domain.Remove(name);
 164
 165                                         InvokeAfterDeregister(listener);
 166                                 }
 167                         }
 168                         catch(InvalidDomainException)
 169                         {
 170                         }
 171                 }
 172
 173                 /// <summary>
 174                 /// Returns true if the Registry contains the specified object.
 175                 /// </summary>
 176                 /// <param name="name">The name to be located.</param>
 177                 /// <returns>true if the object could be found</returns>
 178                 [ManagedOperation]
 179                 public bool Contains(ManagedObjectName name)
 180                 {
 181                         if (name == null)
 182                         {
 183                                 throw new ArgumentNullException("name");
 184                         }
 185
 186                         String domainName = name.Domain;
 187
 188                         Domain domain = FindDomain(domainName);
 189
 190                         return domain.Contains(name);
 191                 }
 192
 193                 /// <summary>
 194                 /// Returns the number of currently registered objects.
 195                 /// </summary>
 196                 [ManagedAttribute]
 197                 public int Count
 198                 {
 199                         get
 200                         {
 201                                 int total = 0;
 202
 203                                 foreach(Domain domain in domains)
 204                                 {
 205                                         total += domain.Count;
 206                                 }
 207
 208                                 return total;
 209                         }
 210                 }
 211
 212                 /// <summary>
 213                 /// Indexer for registered objects.
 214                 /// </summary>
 215                 public Object this[ManagedObjectName name]
 216                 {
 217                         get
 218                         {
 219                                 if (name == null)
 220                                 {
 221                                         throw new ArgumentNullException("name");
 222                                 }
 223
 224                                 return GetEntry(name).Instance;
 225                         }
 226                 }
 227
 228                 /// <summary>
 229                 /// Invokes an action in managed object
 230                 /// </summary>
 231                 /// <param name="name"></param>
 232                 /// <param name="action"></param>
 233                 /// <param name="args"></param>
 234                 /// <param name="signature"></param>
 235                 /// <returns></returns>
 236                 /// <exception cref="InvalidDomainException">If domain name is not found.</exception>
 237                 public Object Invoke(ManagedObjectName name, String action, Object[] args, Type[] signature)
 238                 {
 239                         return GetEntry(name).Invoker.Invoke(action, args, signature);
 240                 }
 241
 242                 /// <summary>
 243                 /// Returns the info (attributes and operations) about the specified object.
 244                 /// </summary>
 245                 /// <param name="name"></param>
 246                 /// <returns></returns>
 247                 /// <exception cref="InvalidDomainException">If domain name is not found.</exception>
 248                 public ManagementInfo GetManagementInfo(ManagedObjectName name)
 249                 {
 250                         return GetEntry(name).Invoker.Info;
 251                 }
 252
 253                 /// <summary>
 254                 /// Gets an attribute value of the specified managed object.
 255                 /// </summary>
 256                 /// <param name="name"></param>
 257                 /// <param name="attributeName"></param>
 258                 /// <returns></returns>
 259                 /// <exception cref="InvalidDomainException">If domain name is not found.</exception>
 260                 public Object GetAttributeValue(ManagedObjectName name, String attributeName)
 261                 {
 262                         return GetEntry(name).Invoker.GetAttributeValue(attributeName);
 263                 }
 264
 265                 /// <summary>
 266                 /// Sets an attribute value of the specified managed object.
 267                 /// </summary>
 268                 /// <param name="name"></param>
 269                 /// <param name="attributeName"></param>
 270                 /// <param name="attributeValue"></param>
 271                 /// <exception cref="InvalidDomainException">If domain name is not found.</exception>
 272                 public void SetAttributeValue(ManagedObjectName name, String attributeName, Object attributeValue)
 273                 {
 274                         GetEntry(name).Invoker.SetAttributeValue(attributeName, attributeValue);
 275                 }
 276
 277                 /// <summary>
 278                 /// Returns an array of registered domains.
 279                 /// </summary>
 280                 /// <returns>a list of domains</returns>
 281                 public String[] GetDomains()
 282                 {
 283                         return domains.ToArray();
 284                 }
 285
 286                 /// <summary>
 287                 /// Queries the registerd components.
 288                 /// </summary>
 289                 /// <returns></returns>
 290                 public ManagedObjectName[] Query(ManagedObjectName query)
 291                 {
 292                         // TODO: several queries...
 293
 294                         if (query.LiteralProperties.Equals("*"))
 295                         {
 296                                 return FindAllFromDomain(query.Domain);
 297                         }
 298
 299                         return null;
 300                 }
 301
 302                 #endregion
 303
 304                 /// <summary>
 305                 /// Helper to locate the domain.
 306                 /// </summary>
 307                 /// <param name="domainName"></param>
 308                 /// <returns></returns>
 309                 private Domain FindDomain(String domainName)
 310                 {
 311                         Domain domain = domains[domainName];
 312
 313                         if (domain == null)
 314                         {
 315                                 throw new InvalidDomainException(domainName);
 316                         }
 317
 318                         return domain;
 319                 }
 320
 321                 /// <summary>
 322                 /// Helper to locate Entries.
 323                 /// </summary>
 324                 /// <param name="name"></param>
 325                 /// <returns></returns>
 326                 private Entry GetEntry(ManagedObjectName name)
 327                 {
 328                         Domain domain = FindDomain(name.Domain);
 329                         Entry entry = domain[name];
 330
 331                         if (entry == null)
 332                         {
 333                                 throw new ManagedObjectNotFoundException(name.ToString());
 334                         }
 335
 336                         return entry;
 337                 }
 338
 339                 private void InvokeBeforeRegister(MRegistrationListener listener, ManagedObjectName name)
 340                 {
 341                         if (listener != null)
 342                         {
 343                                 listener.BeforeRegister(server, name);
 344                         }
 345                 }
 346
 347                 private void InvokeAfterRegister(MRegistrationListener listener)
 348                 {
 349                         if (listener != null)
 350                         {
 351                                 listener.AfterRegister();
 352                         }
 353                 }
 354
 355                 private void InvokeBeforeDeregister(MRegistrationListener listener)
 356                 {
 357                         if (listener != null)
 358                         {
 359                                 try
 360                                 {
 361                                         listener.BeforeDeregister();
 362                                 }
 363                                 catch(Exception)
 364                                 {
 365                                         // An exception here shall not stop us from continue
 366                                 }
 367                         }
 368                 }
 369
 370                 private void InvokeAfterDeregister(MRegistrationListener listener)
 371                 {
 372                         if (listener != null)
 373                         {
 374                                 try
 375                                 {
 376                                         listener.AfterDeregister();
 377                                 }
 378                                 catch(Exception)
 379                                 {
 380                                         // An exception here shall not stop us from continue
 381                                 }
 382                         }
 383                 }
 384
 385                 private ManagedObjectName[] FindAllFromDomain(String domainName)
 386                 {
 387                         try
 388                         {
 389                                 Domain domain = FindDomain(domainName);
 390                                 return domain.ToArray();
 391                         }
 392                         catch(InvalidDomainException)
 393                         {
 394                         }
 395
 396                         return null;
 397                 }
 398         }
 399 }