mcs/class/referencesource/System.Workflow.Runtime/WorkflowDefinitionDispenser.cs

   1 #region Imports
   2
   3 using System;
   4 using System.ComponentModel;
   5 using System.ComponentModel.Design;
   6 using System.ComponentModel.Design.Serialization;
   7 using System.Diagnostics;
   8 using System.Collections;
   9 using System.Collections.Generic;
  10 using System.Collections.Specialized;
  11 using System.Collections.ObjectModel;
  12 using System.Configuration;
  13 using System.Reflection;
  14 using System.Threading;
  15 using System.Globalization;
  16 using System.IO;
  17 using System.Xml;
  18 using System.Text;
  19 using System.Workflow.Runtime.Hosting;
  20 using System.Workflow.Runtime.Configuration;
  21 using System.Workflow.ComponentModel;
  22 using System.Workflow.Runtime.Tracking;
  23 using System.Workflow.ComponentModel.Compiler;
  24 using System.Workflow.ComponentModel.Serialization;
  25 using System.Security.Cryptography;
  26 using System.Workflow.ComponentModel.Design;
  27
  28 #endregion
  29
  30
  31 namespace System.Workflow.Runtime
  32 {
  33     internal sealed class WorkflowDefinitionDispenser : IDisposable
  34     {
  35         private MruCache workflowTypes;
  36         private MruCache xomlFragments;
  37         private Dictionary<Type, List<PropertyInfo>> workflowOutParameters;
  38         private WorkflowRuntime workflowRuntime;
  39         private bool validateOnCreate = true;
  40         internal static DependencyProperty WorkflowDefinitionHashCodeProperty = DependencyProperty.RegisterAttached("WorkflowDefinitionHashCode", typeof(byte[]), typeof(WorkflowDefinitionDispenser));
  41         internal event EventHandler<WorkflowDefinitionEventArgs> WorkflowDefinitionLoaded;
  42
  43         private ReaderWriterLock parametersLock;
  44
  45         internal WorkflowDefinitionDispenser(WorkflowRuntime runtime, bool validateOnCreate, int capacity)
  46         {
  47             if (capacity <= 0)
  48             {
  49                 capacity = 2000;
  50             }
  51             this.workflowRuntime = runtime;
  52             this.workflowTypes = new MruCache(capacity, this, CacheType.Type);
  53             this.xomlFragments = new MruCache(capacity, this, CacheType.Xoml);
  54             this.workflowOutParameters = new Dictionary<Type, List<PropertyInfo>>();
  55             this.parametersLock = new ReaderWriterLock();
  56             this.validateOnCreate = validateOnCreate;
  57         }
  58
  59         internal ReadOnlyCollection<PropertyInfo> GetOutputParameters(Activity rootActivity)
  60         {
  61             Type workflowType = rootActivity.GetType();
  62             this.parametersLock.AcquireReaderLock(-1);
  63             try
  64             {
  65                 if (this.workflowOutParameters.ContainsKey(workflowType))
  66                     return new ReadOnlyCollection<PropertyInfo>(this.workflowOutParameters[workflowType]);
  67             }
  68             finally
  69             {
  70                 this.parametersLock.ReleaseLock();
  71             }
  72
  73             // We will recurse at most once because CacheOutputParameters() will perform negative caching.
  74             CacheOutputParameters(rootActivity);
  75             return GetOutputParameters(rootActivity);
  76         }
  77
  78         internal void GetWorkflowTypes(out ReadOnlyCollection<Type> keys, out ReadOnlyCollection<Activity> values)
  79         {
  80             this.workflowTypes.GetWorkflowDefinitions<Type>(out keys, out values);
  81         }
  82
  83         internal void GetWorkflowDefinitions(out ReadOnlyCollection<byte[]> keys, out ReadOnlyCollection<Activity> values)
  84         {
  85             this.xomlFragments.GetWorkflowDefinitions<byte[]>(out keys, out values);
  86         }
  87
  88         internal Activity GetWorkflowDefinition(byte[] xomlHashCode)
  89         {
  90             Activity workflowDefinition = null;
  91             if (xomlHashCode == null)
  92                 throw new ArgumentNullException("xomlHashCode");
  93
  94             workflowDefinition = xomlFragments.GetDefinition(xomlHashCode);
  95
  96             if (workflowDefinition == null)
  97                 throw new ArgumentException("xomlHashCode");
  98
  99             return workflowDefinition;
 100         }
 101
 102         internal Activity GetWorkflowDefinition(Type workflowType)
 103         {
 104             if (workflowType == null)
 105                 throw new ArgumentNullException("workflowType");
 106
 107             return this.GetRootActivity(workflowType, false, true);
 108         }
 109
 110         internal Activity GetRootActivity(Type workflowType, bool createNew, bool initForRuntime)
 111         {
 112             Activity root = null;
 113
 114             if (createNew)
 115                 return LoadRootActivity(workflowType, false, initForRuntime);
 116             bool exist;
 117             root = workflowTypes.GetOrGenerateDefinition(workflowType, null, null, null, initForRuntime, out exist);
 118             if (exist)
 119             {
 120                 return root;
 121             }
 122             // Set the locking object used for cloning the definition
 123             // for non-internal use (WorkflowInstance.GetWorkflowDefinition
 124             // and WorkflowCompletedEventArgs.WorkflowDefinition)
 125             WorkflowDefinitionLock.SetWorkflowDefinitionLockObject(root, new object());
 126
 127             EventHandler<WorkflowDefinitionEventArgs> localWorkflowDefinitionLoaded = WorkflowDefinitionLoaded;
 128             if (localWorkflowDefinitionLoaded != null)
 129                 localWorkflowDefinitionLoaded(this.workflowRuntime, new WorkflowDefinitionEventArgs(workflowType));
 130
 131             return root;
 132         }
 133
 134         // This function will create a new root activity definition tree by deserializing the xoml and the rules file.
 135         // The last parameter createNew should be true when the caller is asking for a new definition for performing
 136         // dynamic updates instead of a cached definition.
 137         internal Activity GetRootActivity(string xomlText, string rulesText, bool createNew, bool initForRuntime)
 138         {
 139             if (string.IsNullOrEmpty(xomlText))
 140                 throw new ArgumentNullException("xomlText");
 141
 142             //calculate the "hash". Think 60s!
 143             byte[] xomlHashCode = null;
 144             MemoryStream xomlBytesStream = new MemoryStream();
 145             using (StreamWriter streamWriter = new StreamWriter(xomlBytesStream))
 146             {
 147                 streamWriter.Write(xomlText);
 148
 149                 //consider rules, if they exist
 150                 if (!string.IsNullOrEmpty(rulesText))
 151                     streamWriter.Write(rulesText);
 152
 153                 streamWriter.Flush();
 154                 xomlBytesStream.Position = 0;
 155
 156                 xomlHashCode = MD5HashHelper.ComputeHash(xomlBytesStream.GetBuffer());
 157             }
 158
 159             if (createNew)
 160                 return LoadRootActivity(xomlText, rulesText, xomlHashCode, false, initForRuntime);
 161
 162             bool exist;
 163             Activity root = xomlFragments.GetOrGenerateDefinition(null, xomlText, rulesText, xomlHashCode, initForRuntime, out exist);
 164             if (exist)
 165             {
 166                 return root;
 167             }
 168             // Set the locking object used for cloning the definition
 169             // for non-internal use (WorkflowInstance.GetWorkflowDefinition
 170             // and WorkflowCompletedEventArgs.WorkflowDefinition)
 171             WorkflowDefinitionLock.SetWorkflowDefinitionLockObject(root, new object());
 172
 173             EventHandler<WorkflowDefinitionEventArgs> localWorkflowDefinitionLoaded = WorkflowDefinitionLoaded;
 174             if (localWorkflowDefinitionLoaded != null)
 175                 localWorkflowDefinitionLoaded(this.workflowRuntime, new WorkflowDefinitionEventArgs(xomlHashCode));
 176
 177             return root;
 178         }
 179
 180         internal void ValidateDefinition(Activity root, bool isNewType, ITypeProvider typeProvider)
 181         {
 182             if (!this.validateOnCreate)
 183                 return;
 184
 185             ValidationErrorCollection errors = new ValidationErrorCollection();
 186
 187             // For validation purposes, create a type provider in the type case if the
 188             // host did not push one.
 189             if (typeProvider == null)
 190                 typeProvider = WorkflowRuntime.CreateTypeProvider(root);
 191
 192             // Validate that we are purely XAML.
 193             if (!isNewType)
 194             {
 195                 if (!string.IsNullOrEmpty(root.GetValue(WorkflowMarkupSerializer.XClassProperty) as string))
 196                     errors.Add(new ValidationError(ExecutionStringManager.XomlWorkflowHasClassName, ErrorNumbers.Error_XomlWorkflowHasClassName));
 197
 198                 Queue compositeActivities = new Queue();
 199                 compositeActivities.Enqueue(root);
 200                 while (compositeActivities.Count > 0)
 201                 {
 202                     Activity activity = compositeActivities.Dequeue() as Activity;
 203
 204                     if (activity.GetValue(WorkflowMarkupSerializer.XCodeProperty) != null)
 205                         errors.Add(new ValidationError(ExecutionStringManager.XomlWorkflowHasCode, ErrorNumbers.Error_XomlWorkflowHasCode));
 206
 207                     CompositeActivity compositeActivity = activity as CompositeActivity;
 208                     if (compositeActivity != null)
 209                     {
 210                         foreach (Activity childActivity in compositeActivity.EnabledActivities)
 211                             compositeActivities.Enqueue(childActivity);
 212                     }
 213                 }
 214             }
 215
 216             ServiceContainer serviceContainer = new ServiceContainer();
 217             serviceContainer.AddService(typeof(ITypeProvider), typeProvider);
 218
 219             ValidationManager validationManager = new ValidationManager(serviceContainer);
 220             using (WorkflowCompilationContext.CreateScope(validationManager))
 221             {
 222                 foreach (Validator validator in validationManager.GetValidators(root.GetType()))
 223                 {
 224                     foreach (ValidationError error in validator.Validate(validationManager, root))
 225                     {
 226                         if (!error.UserData.Contains(typeof(Activity)))
 227                             error.UserData[typeof(Activity)] = root;
 228
 229                         errors.Add(error);
 230                     }
 231                 }
 232             }
 233             if (errors.HasErrors)
 234                 throw new WorkflowValidationFailedException(ExecutionStringManager.WorkflowValidationFailure, errors);
 235         }
 236
 237         public void Dispose()
 238         {
 239             xomlFragments.Dispose();
 240             workflowTypes.Dispose();
 241         }
 242
 243         private Activity LoadRootActivity(Type workflowType, bool createDefinition, bool initForRuntime)
 244         {
 245             WorkflowLoaderService loader = workflowRuntime.GetService<WorkflowLoaderService>();
 246             Activity root = loader.CreateInstance(workflowType);
 247             if (root == null)
 248                 throw new InvalidOperationException(ExecutionStringManager.CannotCreateRootActivity);
 249             if (root.GetType() != workflowType)
 250                 throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, ExecutionStringManager.WorkflowTypeMismatch, workflowType.FullName));
 251
 252             if (createDefinition)
 253                 ValidateDefinition(root, true, workflowRuntime.GetService<ITypeProvider>());
 254
 255             if (initForRuntime)
 256                 ((IDependencyObjectAccessor)root).InitializeDefinitionForRuntime(null);
 257
 258             root.SetValue(Activity.WorkflowRuntimeProperty, workflowRuntime);
 259
 260             return root;
 261         }
 262
 263         private Activity LoadRootActivity(string xomlText, string rulesText, byte[] xomlHashCode, bool createDefinition, bool initForRuntime)
 264         {
 265             Activity root = null;
 266             WorkflowLoaderService loader = workflowRuntime.GetService<WorkflowLoaderService>();
 267
 268             using (StringReader xomlTextReader = new StringReader(xomlText))
 269             {
 270                 using (XmlReader xomlReader = XmlReader.Create(xomlTextReader))
 271                 {
 272                     XmlReader rulesReader = null;
 273                     StringReader rulesTextReader = null;
 274                     try
 275                     {
 276                         if (!string.IsNullOrEmpty(rulesText))
 277                         {
 278                             rulesTextReader = new StringReader(rulesText);
 279                             rulesReader = XmlReader.Create(rulesTextReader);
 280                         }
 281                         root = loader.CreateInstance(xomlReader, rulesReader);
 282                     }
 283                     finally
 284                     {
 285                         if (rulesReader != null)
 286                             rulesReader.Close();
 287                         if (rulesTextReader != null)
 288                             rulesTextReader.Close();
 289                     }
 290                 }
 291             }
 292
 293             if (root == null)
 294                 throw new InvalidOperationException(ExecutionStringManager.CannotCreateRootActivity);
 295
 296             if (createDefinition)
 297             {
 298                 ITypeProvider typeProvider = workflowRuntime.GetService<ITypeProvider>();
 299                 ValidateDefinition(root, false, typeProvider);
 300             }
 301
 302             if (initForRuntime)
 303                 ((IDependencyObjectAccessor)root).InitializeDefinitionForRuntime(null);
 304
 305             // Save the original markup.
 306             root.SetValue(Activity.WorkflowXamlMarkupProperty, xomlText);
 307             root.SetValue(Activity.WorkflowRulesMarkupProperty, rulesText);
 308             root.SetValue(WorkflowDefinitionHashCodeProperty, xomlHashCode);
 309             root.SetValue(Activity.WorkflowRuntimeProperty, workflowRuntime);
 310
 311             return root;
 312         }
 313
 314         private void CacheOutputParameters(Activity rootActivity)
 315         {
 316             Type workflowType = rootActivity.GetType();
 317             List<PropertyInfo> outputParameters = null;
 318
 319             this.parametersLock.AcquireWriterLock(-1);
 320
 321             try
 322             {
 323                 if (this.workflowOutParameters.ContainsKey(workflowType))
 324                     return;
 325
 326                 // Cache negative and positive cases!
 327                 outputParameters = new List<PropertyInfo>();
 328                 this.workflowOutParameters.Add(workflowType, outputParameters);
 329
 330                 PropertyInfo[] properties = workflowType.GetProperties();
 331                 foreach (PropertyInfo property in properties)
 332                 {
 333                     if (!property.CanRead || property.DeclaringType == typeof(DependencyObject) || property.DeclaringType == typeof(Activity) || property.DeclaringType == typeof(CompositeActivity))
 334                         continue;
 335
 336                     bool ignoreProperty = false;
 337                     foreach (DependencyProperty dependencyProperty in rootActivity.MetaDependencyProperties)
 338                     {
 339                         if (dependencyProperty.Name == property.Name && dependencyProperty.DefaultMetadata.IsMetaProperty)
 340                         {
 341                             ignoreProperty = true;
 342                             break;
 343                         }
 344                     }
 345
 346                     if (!ignoreProperty)
 347                         outputParameters.Add(property);
 348                 }
 349             }
 350             finally
 351             {
 352                 Thread.MemoryBarrier();
 353                 this.parametersLock.ReleaseLock();
 354             }
 355         }
 356
 357         private enum CacheType
 358         {
 359             Type = 0,
 360             Xoml = 1,
 361         }
 362
 363         private class MruCache : IDisposable
 364         {
 365             Hashtable hashtable;
 366             LinkedList<Activity> mruList;
 367             int size;
 368             int capacity;
 369             WorkflowDefinitionDispenser dispenser;
 370             CacheType type;
 371
 372             internal MruCache(int capacity, WorkflowDefinitionDispenser dispenser, CacheType type)
 373             {
 374                 if (type == CacheType.Xoml)
 375                 {
 376                     this.hashtable = new Hashtable((IEqualityComparer)new DigestComparerWrapper());
 377                 }
 378                 else
 379                 {
 380                     this.hashtable = new Hashtable();
 381                 }
 382                 this.mruList = new LinkedList<Activity>();
 383                 this.capacity = capacity;
 384                 this.dispenser = dispenser;
 385                 this.type = type;
 386             }
 387
 388             private void RemoveFromDictionary(Activity activity)
 389             {
 390                 byte[] key = activity.GetValue(WorkflowDefinitionHashCodeProperty) as byte[];
 391                 if (key != null)
 392                 {
 393                     this.hashtable.Remove(key);
 394                 }
 395                 else
 396                 {
 397                     Type type = activity.GetType();
 398                     this.hashtable.Remove(type);
 399                 }
 400             }
 401
 402             private void AddToDictionary(LinkedListNode<Activity> node)
 403             {
 404                 byte[] key = node.Value.GetValue(WorkflowDefinitionHashCodeProperty) as byte[];
 405                 if (key != null)
 406                 {
 407                     this.hashtable.Add(key, node);
 408                 }
 409                 else
 410                 {
 411                     Type type = node.Value.GetType();
 412                     this.hashtable.Add(type, node);
 413                 }
 414             }
 415
 416             internal Activity GetDefinition(byte[] md5Codes)
 417             {
 418                 LinkedListNode<Activity> node;
 419                 node = this.hashtable[md5Codes] as LinkedListNode<Activity>;
 420                 if (node != null)
 421                 {
 422                     return node.Value;
 423                 }
 424                 else
 425                 {
 426                     return null;
 427                 }
 428             }
 429
 430             internal Activity GetOrGenerateDefinition(Type type, string xomlText, string rulesText, byte[] md5Codes, bool initForRuntime, out bool exist)
 431             {
 432                 LinkedListNode<Activity> node;
 433                 object key;
 434
 435                 if (type != null)
 436                 {
 437                     key = type;
 438                 }
 439                 else
 440                 {
 441                     key = md5Codes;
 442                 }
 443                 try
 444                 {
 445                     exist = false;
 446                     node = this.hashtable[key] as LinkedListNode<Activity>;
 447
 448                     if (node != null)
 449                     {
 450                         lock (this.mruList)
 451                         {
 452                             node = this.hashtable[key] as LinkedListNode<Activity>;
 453                             if (node != null)
 454                             {
 455                                 exist = true;
 456                                 this.mruList.Remove(node);
 457                                 this.mruList.AddFirst(node);
 458                             }
 459                             else
 460                             {
 461                                 exist = false;
 462                             }
 463                         }
 464                     }
 465
 466                     if (!exist)
 467                     {
 468                         lock (this.hashtable)
 469                         {
 470                             node = this.hashtable[key] as LinkedListNode<Activity>;
 471                             if (node != null)
 472                             {
 473                                 exist = true;
 474                                 lock (this.mruList)
 475                                 {
 476                                     this.mruList.Remove(node);
 477                                     this.mruList.AddFirst(node);
 478                                 }
 479                             }
 480                             else
 481                             {
 482                                 exist = false;
 483                                 Activity activity;
 484                                 if (type != null)
 485                                 {
 486                                     activity = this.dispenser.LoadRootActivity(type, true, initForRuntime);
 487                                 }
 488                                 else
 489                                 {
 490                                     activity = this.dispenser.LoadRootActivity(xomlText, rulesText, key as byte[], true, initForRuntime);
 491                                 }
 492                                 lock (this.mruList)
 493                                 {
 494                                     if (this.size < this.capacity)
 495                                     {
 496                                         this.size++;
 497                                     }
 498                                     else
 499                                     {
 500                                         RemoveFromDictionary(this.mruList.Last.Value);
 501                                         this.mruList.RemoveLast();
 502                                     }
 503                                     node = new LinkedListNode<Activity>(activity);
 504                                     AddToDictionary(node);
 505                                     this.mruList.AddFirst(node);
 506                                 }
 507                             }
 508                         }
 509                     }
 510                 }
 511                 finally
 512                 {
 513                     Thread.MemoryBarrier();
 514                 }
 515                 return node.Value;
 516             }
 517
 518             internal void GetWorkflowDefinitions<K>(out ReadOnlyCollection<K> keys, out ReadOnlyCollection<Activity> values)
 519             {
 520                 lock (this.hashtable)
 521                 {
 522                     if (((typeof(K) == typeof(Type)) && (this.type == CacheType.Type)) || ((typeof(K) == typeof(byte[])) && (this.type == CacheType.Xoml)))
 523                     {
 524                         List<K> keyList = new List<K>();
 525                         foreach (K key in this.hashtable.Keys)
 526                         {
 527                             keyList.Add(key);
 528                         }
 529                         keys = new ReadOnlyCollection<K>(keyList);
 530                         List<Activity> list = new List<Activity>();
 531                         foreach (LinkedListNode<Activity> node in this.hashtable.Values)
 532                         {
 533                             list.Add(node.Value);
 534                         }
 535                         values = new ReadOnlyCollection<Activity>(list);
 536                     }
 537                     else
 538                     {
 539                         keys = null;
 540                         values = null;
 541                     }
 542                 }
 543             }
 544
 545             public void Dispose()
 546             {
 547                 foreach (LinkedListNode<Activity> node in hashtable.Values)
 548                 {
 549                     try
 550                     {
 551                         node.Value.Dispose();
 552                     }
 553                     catch (Exception)//ignore any dispose exception.
 554                     {
 555                     }
 556                 }
 557             }
 558         }
 559
 560         private class DigestComparerWrapper : IEqualityComparer
 561         {
 562             IEqualityComparer<byte[]> comparer = (IEqualityComparer<byte[]>)new DigestComparer();
 563             bool IEqualityComparer.Equals(object object1, object object2)
 564             {
 565                 return comparer.Equals((byte[])object1, (byte[])object2);
 566             }
 567
 568             int IEqualityComparer.GetHashCode(object obj)
 569             {
 570                 return comparer.GetHashCode((byte[])obj);
 571             }
 572         }
 573
 574     }
 575
 576     internal class WorkflowDefinitionLock : IDisposable
 577     {
 578         internal static readonly DependencyProperty WorkflowDefinitionLockObjectProperty = DependencyProperty.RegisterAttached("WorkflowDefinitionLockObject", typeof(object), typeof(WorkflowDefinitionLock), new PropertyMetadata(DependencyPropertyOptions.NonSerialized));
 579
 580         internal static object GetWorkflowDefinitionLockObject(DependencyObject dependencyObject)
 581         {
 582             // The Dependency Properties are kept in a Dictionary<>, which is not thread safe between
 583             // "getters" and "setters", so lock around the "getter", too.
 584             lock (dependencyObject)
 585             {
 586                 return dependencyObject.GetValue(WorkflowDefinitionLockObjectProperty);
 587             }
 588         }
 589
 590         internal static void SetWorkflowDefinitionLockObject(DependencyObject dependencyObject, object value)
 591         {
 592             lock (dependencyObject)
 593             {
 594                 if (dependencyObject.GetValue(WorkflowDefinitionLockObjectProperty) == null)
 595                 {
 596                     dependencyObject.SetValue(WorkflowDefinitionLockObjectProperty, value);
 597                 }
 598             }
 599         }
 600
 601         private object _syncObj;
 602
 603         public WorkflowDefinitionLock(Activity definition)
 604         {
 605             this._syncObj = GetWorkflowDefinitionLockObject(definition);
 606
 607             Debug.Assert(this._syncObj != null, "Definition's synchronization object was null.  This should always be set.");
 608
 609 #pragma warning disable 0618
 610             //@
 611             Monitor.Enter(this._syncObj);
 612 #pragma warning restore 0618
 613         }
 614
 615         #region IDisposable Members
 616
 617         public void Dispose()
 618         {
 619             Monitor.Exit(this._syncObj);
 620         }
 621
 622         #endregion
 623     }
 624 }