Tools/ManagedExtensions/ManagementExtensions/Default/MDefaultServer.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         using System.Reflection;
  19
  20         /// <summary>
  21         /// Summary description for MDefaultServer.
  22         /// </summary>
  23         public class MDefaultServer : MarshalByRefObject, MServer
  24         {
  25                 protected MRegistry registry;
  26
  27                 public MDefaultServer()
  28                 {
  29                         // TODO: Allow customisation of MRegistry
  30
  31                         registry = new Default.MDefaultRegistry(this);
  32
  33                         SetupRegistry();
  34                 }
  35
  36                 private void SetupRegistry()
  37                 {
  38                         RegisterManagedObject(registry, MConstants.REGISTRY_NAME);
  39                 }
  40
  41                 #region MServer Members
  42
  43                 /// <summary>
  44                 /// TODO: Summary
  45                 /// </summary>
  46                 /// <param name="typeName"></param>
  47                 /// <returns></returns>
  48                 public Object Instantiate(String typeName)
  49                 {
  50                         if (typeName == null)
  51                         {
  52                                 throw new ArgumentNullException("typeName");
  53                         }
  54
  55                         Type targetType = Type.GetType(typeName, true, true);
  56
  57                         object instance = AppDomain.CurrentDomain.CreateInstanceAndUnwrap(
  58                                 targetType.Assembly.FullName, targetType.FullName);
  59
  60                         return instance;
  61                 }
  62
  63                 /// <summary>
  64                 /// Instantiates the specified type using the server domain.
  65                 /// </summary>
  66                 /// <param name="typeName"></param>
  67                 /// <param name="typeName"></param>
  68                 /// <returns></returns>
  69                 public Object Instantiate(String assemblyName, String typeName)
  70                 {
  71                         if (assemblyName == null)
  72                         {
  73                                 throw new ArgumentNullException("assemblyName");
  74                         }
  75                         if (typeName == null)
  76                         {
  77                                 throw new ArgumentNullException("typeName");
  78                         }
  79
  80                         object instance = AppDomain.CurrentDomain.CreateInstanceAndUnwrap(
  81                                 assemblyName, typeName);
  82
  83                         return instance;
  84                 }
  85
  86                 /// <summary>
  87                 /// TODO: Summary
  88                 /// </summary>
  89                 /// <param name="typeName"></param>
  90                 /// <param name="name"></param>
  91                 /// <returns></returns>
  92                 public ManagedInstance CreateManagedObject(String typeName, ManagedObjectName name)
  93                 {
  94                         if (typeName == null)
  95                         {
  96                                 throw new ArgumentNullException("typeName");
  97                         }
  98                         if (name == null)
  99                         {
 100                                 throw new ArgumentNullException("name");
 101                         }
 102
 103                         Object instance = Instantiate(typeName);
 104                         return RegisterManagedObject(instance, name);
 105                 }
 106
 107                 /// <summary>
 108                 /// TODO: Summary
 109                 /// </summary>
 110                 /// <param name="assemblyName"></param>
 111                 /// <param name="typeName"></param>
 112                 /// <param name="name"></param>
 113                 /// <returns></returns>
 114                 public ManagedInstance CreateManagedObject(String assemblyName, String typeName, ManagedObjectName name)
 115                 {
 116                         if (assemblyName == null)
 117                         {
 118                                 throw new ArgumentNullException("assemblyName");
 119                         }
 120                         if (typeName == null)
 121                         {
 122                                 throw new ArgumentNullException("typeName");
 123                         }
 124                         if (name == null)
 125                         {
 126                                 throw new ArgumentNullException("name");
 127                         }
 128
 129                         Object instance = Instantiate(assemblyName, typeName);
 130                         return RegisterManagedObject(instance, name);
 131                 }
 132
 133
 134                 /// <summary>
 135                 /// TODO: Summary
 136                 /// </summary>
 137                 /// <param name="instance"></param>
 138                 /// <param name="name"></param>
 139                 /// <returns></returns>
 140         public ManagedInstance RegisterManagedObject(Object instance, ManagedObjectName name)
 141                 {
 142                         if (instance == null)
 143                         {
 144                                 throw new ArgumentNullException("instance");
 145                         }
 146                         if (name == null)
 147                         {
 148                                 throw new ArgumentNullException("name");
 149                         }
 150
 151                         return registry.RegisterManagedObject(instance, name);
 152                 }
 153
 154                 /// <summary>
 155                 /// TODO: Summary
 156                 /// </summary>
 157                 /// <param name="name"></param>
 158                 /// <returns></returns>
 159                 public ManagedInstance GetManagedInstance(ManagedObjectName name)
 160                 {
 161                         if (name == null)
 162                         {
 163                                 throw new ArgumentNullException("name");
 164                         }
 165
 166                         return registry.GetManagedInstance(name);
 167                 }
 168
 169                 /// <summary>
 170                 /// TODO: Summary
 171                 /// </summary>
 172                 /// <param name="name"></param>
 173                 public void UnregisterManagedObject(ManagedObjectName name)
 174                 {
 175                         if (name == null)
 176                         {
 177                                 throw new ArgumentNullException("name");
 178                         }
 179
 180                         registry.UnregisterManagedObject(name);
 181                 }
 182
 183                 /// <summary>
 184                 /// Invokes an action in managed object
 185                 /// </summary>
 186                 /// <param name="name"></param>
 187                 /// <param name="action"></param>
 188                 /// <param name="args"></param>
 189                 /// <param name="signature"></param>
 190                 /// <returns></returns>
 191                 /// <exception cref="InvalidDomainException">If domain name is not found.</exception>
 192                 public Object Invoke(ManagedObjectName name, String action, Object[] args, Type[] signature)
 193                 {
 194                         if (name == null)
 195                         {
 196                                 throw new ArgumentNullException("name");
 197                         }
 198                         if (action == null)
 199                         {
 200                                 throw new ArgumentNullException("action");
 201                         }
 202                         return registry.Invoke(name, action, args, signature);
 203                 }
 204
 205                 /// <summary>
 206                 /// Returns the info (attributes and operations) about the specified object.
 207                 /// </summary>
 208                 /// <param name="name"></param>
 209                 /// <returns></returns>
 210                 /// <exception cref="InvalidDomainException">If domain name is not found.</exception>
 211                 public ManagementInfo GetManagementInfo(ManagedObjectName name)
 212                 {
 213                         if (name == null)
 214                         {
 215                                 throw new ArgumentNullException("name");
 216                         }
 217
 218                         return registry.GetManagementInfo(name);
 219                 }
 220
 221                 /// <summary>
 222                 /// Gets an attribute value of the specified managed object.
 223                 /// </summary>
 224                 /// <param name="name"></param>
 225                 /// <param name="attributeName"></param>
 226                 /// <returns></returns>
 227                 /// <exception cref="InvalidDomainException">If domain name is not found.</exception>
 228                 public Object GetAttribute(ManagedObjectName name, String attributeName)
 229                 {
 230                         if (name == null)
 231                         {
 232                                 throw new ArgumentNullException("name");
 233                         }
 234                         if (attributeName == null)
 235                         {
 236                                 throw new ArgumentNullException("attributeName");
 237                         }
 238
 239                         return registry.GetAttributeValue(name, attributeName);
 240                 }
 241
 242                 /// <summary>
 243                 /// Sets an attribute value of the specified managed object.
 244                 /// </summary>
 245                 /// <param name="name"></param>
 246                 /// <param name="attributeName"></param>
 247                 /// <param name="attributeValue"></param>
 248                 /// <exception cref="InvalidDomainException">If domain name is not found.</exception>
 249                 public void SetAttribute(ManagedObjectName name, String attributeName, Object attributeValue)
 250                 {
 251                         if (name == null)
 252                         {
 253                                 throw new ArgumentNullException("name");
 254                         }
 255                         if (attributeName == null)
 256                         {
 257                                 throw new ArgumentNullException("attributeName");
 258                         }
 259
 260                         registry.SetAttributeValue(name, attributeName, attributeValue);
 261                 }
 262
 263                 /// <summary>
 264                 /// Returns an array of registered domains.
 265                 /// </summary>
 266                 /// <returns>a list of domains</returns>
 267                 public String[] GetDomains()
 268                 {
 269                         return registry.GetDomains();
 270                 }
 271
 272                 /// <summary>
 273                 /// Queries the registerd components.
 274                 /// </summary>
 275                 /// <returns></returns>
 276                 public ManagedObjectName[] Query(ManagedObjectName query)
 277                 {
 278                         return registry.Query(query);
 279                 }
 280
 281                 #endregion
 282         }
 283 }