InversionOfControl/Castle.MicroKernel/Facilities/Startable/StartableFacility.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.Startable
  16 {
  17         using System;
  18         using System.Collections;
  19         using Castle.MicroKernel;
  20         using Castle.MicroKernel.Facilities;
  21         using Castle.MicroKernel.SubSystems.Conversion;
  22         using Castle.Core;
  23
  24         public class StartableFacility : AbstractFacility
  25         {
  26                 private ArrayList waitList = new ArrayList();
  27                 private ITypeConverter converter;
  28
  29                 protected override void Init()
  30                 {
  31                         converter = (ITypeConverter) Kernel.GetSubSystem(SubSystemConstants.ConversionManagerKey);
  32
  33                         Kernel.ComponentModelCreated +=
  34                                 new ComponentModelDelegate(OnComponentModelCreated);
  35                         Kernel.ComponentRegistered +=
  36                                 new ComponentDataDelegate(OnComponentRegistered);
  37                 }
  38
  39                 private void OnComponentModelCreated(ComponentModel model)
  40                 {
  41                         bool startable =
  42                                 CheckIfComponentImplementsIStartable(model) || HasStartableAttributeSet(model);
  43
  44                         model.ExtendedProperties["startable"] = startable;
  45
  46                         if (startable)
  47                         {
  48                                 model.LifecycleSteps.Add(
  49                                         LifecycleStepType.Commission, StartConcern.Instance);
  50                                 model.LifecycleSteps.Add(
  51                                         LifecycleStepType.Decommission, StopConcern.Instance);
  52                         }
  53                 }
  54
  55                 private void OnComponentRegistered(String key, IHandler handler)
  56                 {
  57                         bool startable = (bool) handler.ComponentModel.ExtendedProperties["startable"];
  58
  59                         if (startable)
  60                         {
  61                                 if (handler.CurrentState == HandlerState.WaitingDependency)
  62                                 {
  63                                         AddHandlerToWaitingList(handler);
  64                                 }
  65                                 else
  66                                 {
  67                                         Start(key);
  68                                 }
  69                         }
  70
  71                         CheckWaitingList();
  72                 }
  73
  74                 private void OnHandlerStateChanged(object source, EventArgs args)
  75                 {
  76                         CheckWaitingList();
  77                 }
  78
  79                 private void AddHandlerToWaitingList(IHandler handler)
  80                 {
  81                         waitList.Add(handler);
  82
  83                         handler.OnHandlerStateChanged += new HandlerStateDelegate(OnHandlerStateChanged);
  84                 }
  85
  86                 /// <summary>
  87                 /// For each new component registered,
  88                 /// some components in the WaitingDependency
  89                 /// state may have became valid, so we check them
  90                 /// </summary>
  91                 private void CheckWaitingList()
  92                 {
  93                         IHandler[] handlers = (IHandler[]) waitList.ToArray(typeof(IHandler));
  94
  95                         IList validList = new ArrayList();
  96
  97                         foreach(IHandler handler in handlers)
  98                         {
  99                                 if (handler.CurrentState == HandlerState.Valid)
 100                                 {
 101                                         validList.Add(handler);
 102                                         waitList.Remove(handler);
 103
 104                                         handler.OnHandlerStateChanged -= new HandlerStateDelegate(OnHandlerStateChanged);
 105                                 }
 106                         }
 107
 108                         foreach(IHandler handler in validList)
 109                         {
 110                                 Start(handler.ComponentModel.Name);
 111                         }
 112                 }
 113
 114                 /// <summary>
 115                 /// Request the component instance
 116                 /// </summary>
 117                 /// <param name="key"></param>
 118                 private void Start(String key)
 119                 {
 120                         object instance = Kernel[key];
 121                 }
 122
 123                 private bool CheckIfComponentImplementsIStartable(ComponentModel model)
 124                 {
 125                         return typeof(IStartable).IsAssignableFrom(model.Implementation);
 126                 }
 127
 128                 private bool HasStartableAttributeSet(ComponentModel model)
 129                 {
 130                         bool result = false;
 131
 132                         if (model.Configuration != null)
 133                         {
 134                                 String startable = model.Configuration.Attributes["startable"];
 135
 136                                 if (startable != null)
 137                                 {
 138                                         result = (bool) converter.PerformConversion(startable, typeof(bool));
 139                                 }
 140                         }
 141
 142                         return result;
 143                 }
 144         }
 145 }