Facilities/Prevalence/Castle.Facilities.Prevalence/PrevalenceFacility.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.Prevalence
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Specialized;
  20
  21         using Bamboo.Prevalence;
  22         using Bamboo.Prevalence.Util;
  23
  24         using Castle.MicroKernel;
  25         using Castle.MicroKernel.Facilities;
  26         using Castle.Core.Configuration;
  27
  28         /// <summary>
  29         /// Summary description for PrevalenceFacility.
  30         /// </summary>
  31         public class PrevalenceFacility : AbstractFacility
  32         {
  33                 private static readonly String IdKey = "id";
  34                 private static readonly String IntervalKey = "snapshotIntervalInHours";
  35
  36                 public static readonly String SystemTypePropertyKey = "prevalence.systemtype";
  37                 public static readonly String StorageDirPropertyKey = "prevalence.storagedir";
  38                 public static readonly String AutoMigrationPropertyKey = "prevalence.autoversionmigration";
  39                 public static readonly String EngineIdPropertyKey = "prevalence.engineid";
  40                 public static readonly String ResetStoragePropertyKey = "prevalence.resetStorage";
  41                 public static readonly String SnapshotPeriodPropertyKey = "prevalence.snapshotPeriod";
  42
  43                 public static readonly String CleanupPolicyComponentPropertyKey = "prevalence.cleanupPolicyComponent";
  44                 public static readonly String SnapShotTakerComponentPropertyKey = "prevalence.snapshot.taker";
  45
  46                 public PrevalenceFacility()
  47                 {
  48                 }
  49
  50                 #region IFacility implementation
  51
  52                 protected override void Init()
  53                 {
  54                         RegisterExtensions();
  55                         RegisterEngines();
  56                 }
  57
  58                 public override void Dispose()
  59                 {
  60                         IConfiguration engines = GetEnginesConfig();
  61
  62                         foreach(IConfiguration engine in engines.Children)
  63                         {
  64                                 TakeSnapshotIfRequired(engine);
  65                                 HandsOffFiles(engine);
  66                         }
  67                 }
  68
  69                 #endregion
  70
  71                 private IConfiguration GetEnginesConfig()
  72                 {
  73                         return FacilityConfig.Children["engines"];
  74                 }
  75
  76                 protected void RegisterEngines()
  77                 {
  78                         IConfiguration engines = GetEnginesConfig();
  79
  80                         foreach(IConfiguration engine in engines.Children)
  81                         {
  82                                 RegisterEngine(engine);
  83                         }
  84                 }
  85
  86                 protected void RegisterExtensions()
  87                 {
  88                         Kernel.ComponentModelBuilder.AddContributor(
  89                                 new PrevalenceActivatorOverriderModelInspector() );
  90                 }
  91
  92                 protected void RegisterEngine(IConfiguration engineConfig)
  93                 {
  94                         String engineKey = engineConfig.Attributes[IdKey];
  95                         String systemId = engineConfig.Attributes["systemId"];
  96                         String resetStorage = engineConfig.Attributes["resetStorage"];
  97
  98                         Type systemType = ObtainSystemType(engineConfig);
  99                         bool autoVersion = Convert.ToBoolean( engineConfig.Attributes["autoVersionMigration"] );
 100
 101                         if (resetStorage == null) resetStorage = "false";
 102
 103                         IDictionary properties = new HybridDictionary(true);
 104
 105                         properties.Add(SystemTypePropertyKey, systemType);
 106                         properties.Add(AutoMigrationPropertyKey, autoVersion);
 107                         properties.Add(ResetStoragePropertyKey, Convert.ToBoolean(resetStorage) );
 108                         properties.Add(StorageDirPropertyKey, engineConfig.Attributes["storageDir"]);
 109
 110                         ConfigureSnapshot(engineConfig, properties);
 111
 112                         Kernel.AddComponentWithExtendedProperties(engineKey, typeof(PrevalenceEngine), properties);
 113
 114                         RegisterSystem(engineKey, systemId, systemType);
 115                 }
 116
 117                 private void ConfigureSnapshot(IConfiguration engineConfig, IDictionary properties)
 118                 {
 119                         float period = GetSnapshotInterval(engineConfig);
 120
 121                         if (RequiresSnapshots(period))
 122                         {
 123                                 if (engineConfig.Attributes["cleanupPolicyComponent"] == null)
 124                                 {
 125                                         Kernel.AddComponentInstance(CleanupPolicyComponentPropertyKey, CleanUpAllFilesPolicy.Default);
 126                                 }
 127
 128                                 properties.Add(SnapshotPeriodPropertyKey, period);
 129                         }
 130                         else
 131                         {
 132                                 properties.Add(SnapshotPeriodPropertyKey, 0f);
 133                         }
 134                 }
 135
 136                 private float GetSnapshotInterval(IConfiguration engineConfig)
 137                 {
 138                         try
 139                         {
 140                                 return Convert.ToSingle(engineConfig.Attributes[IntervalKey]);
 141                         }
 142                         catch (FormatException e)
 143                         {
 144                                 throw new KernelException("Invalid snapshotHoursPeriod.", e);
 145                         }
 146                 }
 147
 148                 private bool RequiresSnapshots(float period)
 149                 {
 150                         return period > 0;
 151                 }
 152
 153                 protected Type ObtainSystemType(IConfiguration config)
 154                 {
 155                         String systemTypeName = config.Attributes["systemType"];
 156
 157                         Type systemType = null;
 158
 159                         systemType = Type.GetType(systemTypeName, false, false);
 160
 161                         if (systemType == null)
 162                         {
 163                                 String message = String.Format(
 164                                         "Could not obtain type for prevalent system '{0}'.", systemTypeName);
 165
 166                                 throw new KernelException(message);
 167                         }
 168
 169                         return systemType;
 170                 }
 171
 172                 protected void RegisterSystem(String engineKey, String systemId, Type systemType)
 173                 {
 174                         IDictionary properties = new HybridDictionary(true);
 175
 176                         properties[EngineIdPropertyKey] = engineKey;
 177
 178                         Kernel.AddComponentWithExtendedProperties(systemId, systemType, properties);
 179                 }
 180
 181                 protected void TakeSnapshotIfRequired(IConfiguration engineConfig)
 182                 {
 183                         float period = GetSnapshotInterval(engineConfig);
 184
 185                         if (RequiresSnapshots(period))
 186                         {
 187                                 PrevalenceEngine engine = (PrevalenceEngine) Kernel[engineConfig.Attributes[IdKey]];
 188
 189                                 engine.TakeSnapshot();
 190                         }
 191                 }
 192
 193                 protected void HandsOffFiles(IConfiguration engineConfig)
 194                 {
 195                         PrevalenceEngine engine = (PrevalenceEngine) Kernel[engineConfig.Attributes[IdKey]];
 196
 197                         engine.HandsOffOutputLog();
 198                 }
 199         }
 200 }