private void CompileNxBrePolicySet(IPolicySetVersionCache version, IPolicySet policySet, string target) { if ((null == version) || (null == policySet) || (string.IsNullOrEmpty(target))) return; NxPolicyStore nxBreStore = new NxPolicyStore(); nxBreStore.ResourceManager = ResourcesCache.GetResources(); policySet.Export(nxBreStore); CompiledPolicySetExtractor cpse = new CompiledPolicySetExtractor(nxBreStore.XMLRepresentation); List<string> channels = cpse.GetChannelNames(); foreach (string channel in channels) { string objects = cpse.GetObjects(channel); string rules = cpse.GetRules(channel); ICompiledPolicySetCache cps = version.GetCompiledPolicySet(channel, target); if (cps == null) { cps = version.NewCompiledPolicySet(channel, target, rules, objects); } else { cps.Content = rules; cps.ObjectReferences = objects; } SaveLanguages(cpse.GetLanguages(), cps); } }
public void WriteChildCollection(IPolicySet policySet, IPolicyObject parent, string name, IPolicyObjectCollection<IPolicyObject> collection) { if (parent == null) return; IPolicy policy = parent as IPolicy; if (policy == null) return; string ruleXpath = string.Format(CultureInfo.InvariantCulture, "PolicySet[@id='{0}']/Policies/Policy[@id='{1}']", XmlHelpers.GetPolicyObjectIdString(policySet), XmlHelpers.GetPolicyObjectIdString(parent)); XmlNode xmlRuleNode = m_policieSetsNode.SelectSingleNode(ruleXpath); if (xmlRuleNode == null) { new XmlCataloguePolicyWriter(m_xmlRootNode, policy).Write(); xmlRuleNode = m_xmlRootNode.SelectSingleNode(ruleXpath); } if (collection.Count == 0) return; IPolicyChannel channel = collection[0] as IPolicyChannel; if (channel == null) { new XmlConditionsWriter(xmlRuleNode, collection).Write(); } else { new XmlPolicyChannelsWriter(xmlRuleNode, collection).Write(); } }
public void SaveCompiledStreams(IPolicySetVersionCache version, IPolicySet policySet) { if ((null == version) || (null == policySet)) return; CompileNxBrePolicySet(version, policySet, "Client"); }
public Context(MDIChildForm parent, IPolicyStore policyStore) { m_parent = parent; m_policyStore = policyStore; //TODO: this will be refactored when IPolicy layer is removed m_policySet = m_policyStore.Reader.PolicySets[0]; }
public PolicySetSummary(IPolicySet set) { m_set = set; foreach (IPolicy policy in m_set.Policies) { m_policySummaryList.Add(new PolicySummary(policy)); } }
private void ReadPolicySet(string filename, out IPolicySet policySet) { PolicySetItem policySetItem = PolicySuites.Instance.LoadPolicySet("localhost", filename); policySet = new Policy.ObjectModel.PolicySet(policySetItem.Data.Identifier, policySetItem.Data.Name, null, policySetItem.Data.MasterCatalogue, false); AddPoliciesToPolicySet(policySet, policySetItem.Data.Policies); PolicySuites.Instance.ClosePolicySet(policySetItem.Data); }
public ExplicitRegistration(IPolicySet validators, Type mappedTo, LifetimeManager lifetimeManager, InjectionMember[] injectionMembers = null) { Type = mappedTo; Key = typeof(LifetimeManager); Value = lifetimeManager; LifetimeManager.InUse = true; InjectionMembers = injectionMembers; Next = (PolicyEntry)validators; }
private static bool ValidateInterPolicyConflicts(IPolicySet policyset, PolicySetValidator.AddViolationMessageHandler AddMessage) { bool retVal = true; for (int i = 0; i < policyset.Policies.Count; i++) { for (int j = i + 1; j < policyset.Policies.Count; j++) { IPolicy policy1 = policyset.Policies[i]; IPolicy policy2 = policyset.Policies[j]; List<FileType> checkTypes1 = GetFileTypesForPolicy(policy1.Conditions); List<CellActionsCollection> checkActions1 = GetActionsForPolicy(policy1.Channels, policyset, true); List<FileType> checkTypes2 = GetFileTypesForPolicy(policy2.Conditions); List<CellActionsCollection> checkActions2 = GetActionsForPolicy(policy2.Channels, policyset, true); FileType foundType = FileType.Unknown; foreach (FileType filetype in checkTypes1) { if (checkTypes2.Contains(filetype)) { foundType = filetype; break; } } if (foundType == FileType.Unknown) continue; foreach (CellActionsCollection collection in checkActions1) { IAction foundAction = null; foreach (IAction action in collection.Actions) { m_actionPredicate = action.Name.Value; if (!checkActions2.Exists(FindActionPredicate)) continue; foundAction = action; break; } if (null == foundAction) continue; retVal = false; if (null != AddMessage) AddMessage(policy2.Name.Value, string.Format(CultureInfo.CurrentCulture, Properties.Resources.VALIDATION_INTERPOLICY_FILETYPEACTION_CONFLICT, foundType, policy1.Name.Value, foundAction.Name.Value), false); } } } return retVal; }
public virtual void Add(IPolicySet set) { var node = (PolicyEntry)this; while (null != node.Next) { node = node.Next; } node.Next = (PolicyEntry)set; }
public HookrRepository(HookrContext context, IPolicySet policySet, ITelegramUserIdProvider telegramUserIdProvider, ILoaderProvider loaderProvider) { PolicySet = policySet; this.telegramUserIdProvider = telegramUserIdProvider; this.loaderProvider = loaderProvider; Context = context; }
public override ResolveDelegate <BuilderContext> GetResolver(Type type, IPolicySet registration, ResolveDelegate <BuilderContext> seed) { // Select ConstructorInfo var selector = GetOrDefault(registration); var selection = selector.Select(type, registration) .FirstOrDefault(); // Select constructor for the Type ConstructorInfo info; object[] resolvers = null; switch (selection) { case ConstructorInfo memberInfo: info = memberInfo; break; case MethodBase <ConstructorInfo> injectionMember: info = injectionMember.MemberInfo(type); resolvers = injectionMember.Data; break; case Exception exception: return((ref BuilderContext c) => { if (null == c.Existing) { throw exception; } return c.Existing; }); default: return((ref BuilderContext c) => { if (null == c.Existing) { throw new InvalidOperationException($"No public constructor is available for type {c.Type}.", new InvalidRegistrationException()); } return c.Existing; }); } // Get lifetime manager var lifetimeManager = (LifetimeManager)registration.Get(typeof(LifetimeManager)); return(lifetimeManager is PerResolveLifetimeManager ? GetPerResolveDelegate(info, resolvers) : GetResolverDelegate(info, resolvers)); }
private void AddPoliciesToPolicySet(IPolicySet policySet, IPolicyObjectCollection<IPolicy> policies) { foreach (IPolicy policy in policies) { // This will force the policy to read the conditions from the test file if the policy has any. if (null == policy.Conditions) continue; } (policySet as PolicySet).Policies = policies; }
public NxPolicySet(IPolicySet policySet, ChannelType channelType) { m_ChannelType = channelType; NxSet policies = new NxSet("Policies"); List<NxParameter> parameters = NxUtils.GetAttributes(policySet); parameters.Add(new NxParameter("Name", policySet)); policies.Append(new NxEvaluate("BeforePolicy", parameters)); policies.Append(new NxInvokeSet("C1C0D5EA-5B82-4607-AE41-D52739AA6AB1")); policies.Append(new NxEvaluate("AfterPolicy", parameters)); AppendSet(policies); }
public TelegramHookrRepository(HookrContext context, IPolicySet policySet, ITelegramUserIdProvider telegramUserIdProvider, IMemoryCache memoryCache, ILoaderProvider loaderProvider) : base(context, policySet, telegramUserIdProvider, loaderProvider) { this.memoryCache = memoryCache; }
/// <summary> /// Checks if a policy object exists in a policy set's master catalogue /// </summary> /// <param name="policySet">The policy set whose master catalogue we will be looking in</param> /// <param name="policyObject">The policy object we are looking up in the catalogue</param> /// <returns>True if the policy object exists in the policy set master catalogue, otherwise false</returns> public static bool IsInMyMasterCatalogue(IPolicySet policySet, IPolicyObject policyObject) { if (policyObject is IActionGroup) { return policySet.MasterCatalogue.ActionGroups.Contains(policyObject); } else if (policyObject is IAction) { return policySet.MasterCatalogue.Actions.Contains(policyObject); } else if (policyObject is IRoutingItem) { return policySet.MasterCatalogue.Locations.Contains(policyObject); } else if (policyObject is IRoutingItemCollections) { return policySet.MasterCatalogue.LocationsCollection.Contains(policyObject); } else if (policyObject is ICataloguePolicy) { return policySet.MasterCatalogue.CataloguePolicies.Contains(policyObject); } else if (policyObject is IChannel) { return policySet.MasterCatalogue.Channels.Contains(policyObject); } else if (policyObject is IConditionGroup) { return policySet.MasterCatalogue.ConditionGroups.Contains(policyObject); } else if (policyObject is ICondition) { return policySet.MasterCatalogue.Conditions.Contains(policyObject); } else if (policyObject is IDataElement) { return policySet.MasterCatalogue.DataElements.Contains(policyObject); } else if (policyObject is IRoutingTable) { return policySet.MasterCatalogue.RoutingTables.Contains(policyObject); } else { Logger.LogError("Unsupported IPolicyObject"); throw new ArgumentException("Unsupported IPolicyObject"); } }
internal static void Set(this Registry <IPolicySet> registry, Type type, IPolicySet set) { var hashCode = type.GetHashCode(); var targetBucket = (hashCode & UnityContainer.HashMask) % registry.Buckets.Length; for (var i = registry.Buckets[targetBucket]; i >= 0; i = registry.Entries[i].Next) { ref var candidate = ref registry.Entries[i]; if (candidate.HashCode != hashCode || candidate.Type != type || candidate.Value is ImplicitRegistration) { continue; } candidate.Value = set; return; }
public void SetUpTest() { m_stateMachine = new DynamicMock(typeof(IStateMachine)); XmlPolicyLanguageStore languageStore = XmlPolicyLanguageStore.Instance; languageStore.Reset(); IPolicyLanguage language = new PolicyLanguage(new Guid("{E8B22533-98EB-4D00-BDE4-406DC3E1858B}"), "en"); languageStore.AddLanguage(language); PolicyLanguageCache.Instance.ActiveLanguageId = language.Identifier; XMLPolicyCatalogueStore catalogueStore = XMLPolicyCatalogueStore.Instance; catalogueStore.Reset(); PolicyCatalogue policyCatalogue = new PolicyCatalogue(new Guid("{AB5E2A43-01FB-4AA6-98FC-8F74BB0621CA}"), language.Identifier, new TranslateableLanguageItem("{B5C31A66-1B39-4CA7-BF02-AF271B5864F7}"), catalogueStore); catalogueStore.AddPolicyCatalogue(policyCatalogue); IPolicyStore policyStore = new XmlStore(); m_policySet = new PolicySet(Guid.NewGuid(), new TranslateableLanguageItem("TestPolicySet"), policyStore, policyCatalogue, false); }
private void FilterPolicies(IPolicySet policySet) { if (null == policySet) return; IPolicyObjectCollection<IPolicy> policies = new PolicyObjectCollection<IPolicy>(); foreach (IPolicy policy in policySet.Policies) { IPolicy reducedPolicy = FilterPolicy(policy); if (null == reducedPolicy) continue; policies.Add(reducedPolicy); } m_reducedPolicySet.Policies = policies; }
/// <summary> /// Creates a new policy object with default AuditLevel and ConditionGroup values. The IPolicy /// is created with a new GUID. /// </summary> /// <param name="policyName">The name of the policy</param> /// <param name="policySet">The policy set to which this policy belongs</param> /// <param name="policyStatus">The status of the policy</param> /// <param name="auditLevel">The audit level of the policy</param> /// <returns>The IPolicy object</returns> public static IPolicy CreatePolicy(string policyName, IPolicySet policySet, PolicyStatus policyStatus, string auditLevel) { IPolicy policy = new P5Policy(policySet, System.Guid.NewGuid(), new TranslateableLanguageItem(policyName), policyStatus); policy["AuditLevel"] = new NonTranslateableLanguageItem(auditLevel); policy["blockOnException"] = new NonTranslateableLanguageItem(bool.TrueString); policy[PolicyConstants.SkipVerifiedMessages] = new NonTranslateableLanguageItem(bool.FalseString); //create root condition group on the policy ChannelType[] channelTypes = PolicyTypeInfoManager.Instance.GetInfo(policySet.PolicyType).ChannelTypes; IPolicyChannel[] channels = ChannelFactory.CreateChannels(channelTypes); policy.Conditions.Add(new ConditionGroup(Guid.NewGuid(), new TranslateableLanguageItem("Default Condition Group"), ConditionLogic.AND, false)); foreach (IPolicyChannel channel in channels) { policy.Channels.Add(channel); } return policy; }
public override IEnumerable <object> Select(Type type, IPolicySet registration) { HashSet <object> memberSet = new HashSet <object>(); // Select Injected Members if (null != ((ImplicitRegistration)registration).InjectionMembers) { foreach (var injectionMember in ((ImplicitRegistration)registration).InjectionMembers) { if (injectionMember is InjectionMember <MethodInfo, object[]> && memberSet.Add(injectionMember)) { yield return(injectionMember); } } } // Select Attributed members IEnumerable <MethodInfo> members = DeclaredMembers(type); if (null == members) { yield break; } foreach (var member in members) { foreach (var attribute in Markers) { #if NET40 if (!member.IsDefined(attribute, true) || #else if (!member.IsDefined(attribute) || #endif !memberSet.Add(member)) { continue; } yield return(member); break; } } }
public IEnumerable <object> Select(Type type, IPolicySet registration) { object originalConstructor = OriginalConstructorSelectorPolicy.Select(type, registration) .First(); switch (originalConstructor) { case ConstructorInfo info: return(new [] { FromConstructorInfo(info, InterceptingType) }); case SelectedConstructor selectedConstructor: return(new [] { FromSelectedConstructor(selectedConstructor, InterceptingType) }); case MethodBase <ConstructorInfo> methodBaseMember: return(new [] { FromMethodBaseMember(methodBaseMember, InterceptingType) }); } throw new InvalidOperationException("Unknown type"); }
public MDIChildForm AddPolicySetWindow(IPolicySet policySet, PolicySetVersionStatus status, string version) { Guid childFormId = Guid.NewGuid(); string nodeName; if (CultureInfo.CurrentCulture.TwoLetterISOLanguageName == "en") nodeName = string.Format(CultureInfo.CurrentCulture, "{0} - v{1} [{2}]", policySet.Name.Value, version, Workshare.Policy.PolicySuites.Instance.GetStatusText(status)); else nodeName = string.Format(CultureInfo.CurrentCulture, "{0} - [{1}]", policySet.Name.Value, Workshare.Policy.PolicySuites.Instance.GetStatusText(status)); TreeObject treeObject = new TreeObject(childFormId, (int)TreeViewControllerPolicyOriented.NodeType.PolicySet, nodeName, policySet); policySetTreeView.Nodes.Add(treeObject); MDIChildForm childForm = new MDIChildForm(childFormId, policySet, policySetTreeView, treeObject); ChildFormData childFormData = new ChildFormData(childFormId, childForm, status, policySet); treeObject.Tag = childFormData; policySetTreeView.SelectedNode = treeObject; return childForm; }
public override IEnumerable <Expression> GetExpressions(Type type, IPolicySet registration) { // Select ConstructorInfo var selector = GetOrDefault(registration); var selection = selector.Select(type, registration) .FirstOrDefault(); // Select constructor for the Type object[] resolvers = null; ConstructorInfo info = null; IEnumerable <Expression> parametersExpr; switch (selection) { case ConstructorInfo memberInfo: info = memberInfo; parametersExpr = CreateParameterExpressions(info.GetParameters()); break; case MethodBase <ConstructorInfo> injectionMember: info = injectionMember.MemberInfo(type); resolvers = injectionMember.Data; parametersExpr = CreateParameterExpressions(info.GetParameters(), resolvers); break; case Exception exception: return(new[] { Expression.IfThen( Expression.Equal(Expression.Constant(null), BuilderContextExpression.Existing), Expression.Throw(Expression.Constant(exception))) }); default: return(NoConstructorExpr); } // Get lifetime manager var lifetimeManager = (LifetimeManager)registration.Get(typeof(LifetimeManager)); return(lifetimeManager is PerResolveLifetimeManager ? new[] { GetResolverExpression(info, resolvers), SetPerBuildSingletonExpr } : new Expression[] { GetResolverExpression(info, resolvers) }); }
public static List<Guid> GetCategories(IPolicySet policySet) { if (policySet == null || policySet.Policies == null || policySet.Policies.Count == 0) { return new List<Guid>(); } Dictionary<Guid, bool> categoryIDs = new Dictionary<Guid, bool>(); foreach (IPolicy policy in policySet.Policies) { if (policy == null || policy.Conditions == null) { continue; } foreach (IPolicyObject conditionObj in policy.Conditions) { if (conditionObj is IConditionGroup) { AddForensicCategoryIDs(conditionObj as IConditionGroup, categoryIDs); } else if (conditionObj is ICondition) { AddForensicCategoryIDs(conditionObj as ICondition, categoryIDs); } } } List<Guid> result = new List<Guid>(); foreach (Guid guid in categoryIDs.Keys) { result.Add(guid); } return result; }
public override IEnumerable <object> Select(Type type, IPolicySet registration) { // Select Injected Members if (null != ((InternalRegistration)registration).InjectionMembers) { foreach (var injectionMember in ((InternalRegistration)registration).InjectionMembers) { if (injectionMember is InjectionMember <ConstructorInfo, object[]> ) { return(new[] { injectionMember }); } } } // Enumerate to array var constructors = DeclaredMembers(type).ToArray(); if (1 >= constructors.Length) { return(constructors); } // Select Attributed constructors foreach (var constructor in constructors) { for (var i = 0; i < AttributeFactories.Length; i++) { #if NET40 if (!constructor.IsDefined(AttributeFactories[i].Type, true)) #else if (!constructor.IsDefined(AttributeFactories[i].Type)) #endif { continue; } return(new[] { constructor }); } } // Select default return(new[] { SelectMethod(type, constructors) }); }
public virtual IEnumerable <object> Select(Type type, IPolicySet registration) { HashSet <object> memberSet = new HashSet <object>(); // Select Injected Members foreach (var injectionMember in ((ImplicitRegistration)registration).InjectionMembers ?? EmptyCollection) { if (injectionMember is InjectionMember <TMemberInfo, TData> && memberSet.Add(injectionMember)) { yield return(injectionMember); } } // Select Attributed members IEnumerable <TMemberInfo> members = DeclaredMembers(type); if (null == members) { yield break; } foreach (var member in members) { foreach (var node in AttributeFactories) { #if NET40 if (!member.IsDefined(node.Type, true) || #else if (!member.IsDefined(node.Type) || #endif !memberSet.Add(member)) { continue; } yield return(member); break; } } }
public IPolicySet ApplyFilter(IPolicySet policySet) { if (null == policySet) return null; // Lets create a dummy catalgue store. Store.XMLPolicyCatalogueStore catalogueStore = new Store.XMLPolicyCatalogueStore(); IPolicyCatalogue reducedCatalogue = new PolicyCatalogue(Guid.NewGuid(), policySet.MasterCatalogue.LanguageId, catalogueStore); Store.XmlStore store = new Store.XmlStore(); m_reducedPolicySet = new PolicySet(policySet.Identifier, policySet.Name, store, reducedCatalogue, policySet.ReadOnly); Dictionary<string, IPolicyLanguageItem>.Enumerator enumerator = policySet.GetAttributeEnumerator(); while (enumerator.MoveNext()) { m_reducedPolicySet[enumerator.Current.Key] = enumerator.Current.Value; } FilterPolicies(policySet); return m_reducedPolicySet; }
public override IEnumerable <object> Select(Type type, IPolicySet registration) { // Select Injected Members foreach (var injectionMember in ((ImplicitRegistration)registration).InjectionMembers ?? EmptyCollection) { if (injectionMember is InjectionMember <ConstructorInfo, object[]> ) { return(new[] { injectionMember }); } } // Enumerate to array var constructors = DeclaredMembers(type).ToArray(); if (1 >= constructors.Length) { return(constructors); } // Select Attributed constructors foreach (var constructor in constructors) { foreach (var attribute in Markers) { #if NET40 if (!constructor.IsDefined(attribute, true)) #else if (!constructor.IsDefined(attribute)) #endif { continue; } return(new[] { constructor }); } } // Select default return(new[] { SelectMethod(type, constructors) }); }
public UIStateMachine(IPolicySet policyset, MDIChildForm childform) { PolicyLanguageCache.Instance.ActiveLanguageId = policyset.MasterCatalogue.LanguageId; m_policySet = policyset; m_ChildForm = childform; m_InitState.PolicySet = m_policySet; m_InitState.SetParent(childform); AddState(m_CloseState); AddState(m_InitState); AddState(m_ShowConditionsState); AddState(m_ShowPoliciesState); AddState(m_AddPolicyState); AddState(m_CopyPolicyState); AddState(m_ShowPolicyState); AddState(m_ShowActionsState); AddState(m_deletePolicyState); AddState(m_DeleteAllPoliciesState); AddState(m_deletePolicySetState); AddState(m_EditConditionState); AddState(m_NewConditionState); AddState(m_addAddressCollectionState); AddState(m_editRoutingDetailState); AddState(m_deleteAddressCollectionState); AddState(m_savePolicySetState); AddState(m_addActionState); AddState(m_addActionConditionGroupState); AddState(m_editCustomActionGroupState); AddState(m_editActionState); AddState(m_deleteActionState); AddState(m_activatePolicyState); AddState(m_exportState); AddState(m_importState); AddState(m_deleteConditionState); AddState(m_changeRoutingTypeState); }
public void WritePolicySet(IPolicySet policySet) { XmlNode xmlPolicyNode = m_xmlDocument.CreateElement("PolicySet"); m_policieSetsNode.AppendChild(xmlPolicyNode); string id = XmlHelpers.GetPolicyObjectIdString(policySet); XmlHelpers.AddAttribute(xmlPolicyNode, "id", id); XmlHelpers.AddLanguageItemAttribute(xmlPolicyNode, "name", policySet.Name); XmlHelpers.AddLanguageItemAttribute(xmlPolicyNode, "Description", policySet.Description); XmlHelpers.AddAttribute(xmlPolicyNode, "mastercatalogueId", policySet.MasterCatalogue.Identifier); XmlHelpers.AddReadOnlyAttribute(xmlPolicyNode, policySet.ReadOnly); // TODO: AP: Remove condition // (it's a bit lazy because it saves me having to rewrite all the unit tests that check legacy policy XML // formats. It works because policy sets without the policyType attribute default to the legacy policy type) if (policySet.PolicyType != PolicyType.Legacy) { XmlHelpers.AddAttribute(xmlPolicyNode, "policyType", policySet.PolicyType.ToString()); } XmlHelpers.AddCustomAttributes(xmlPolicyNode, policySet); XmlNode xmlPoliciesNode = m_xmlDocument.CreateElement("Policies"); xmlPolicyNode.AppendChild(xmlPoliciesNode); }
/// <summary> /// /// </summary> /// <remarks> /// Call hierarchy: /// <see cref="GetExpressions"/> /// + <see cref="SelectMembers"/> /// + <see cref="ExpressionsFromSelected"/> /// + <see cref="BuildMemberExpression"/> /// + <see cref="GetResolverExpression"/> /// </remarks> /// <param name="type"></param> /// <param name="registration"></param> /// <returns></returns> public abstract IEnumerable <Expression> GetExpressions(Type type, IPolicySet registration);
public ConstructorDiagnostic(IPolicySet policySet, UnityContainer container) : base(policySet, container) { }
public override IEnumerable <object> Select(Type type, IPolicySet registration) { HashSet <object> memberSet = new HashSet <object>(); // Select Injected Members if (null != ((InternalRegistration)registration).InjectionMembers) { foreach (var injectionMember in ((InternalRegistration)registration).InjectionMembers) { if (injectionMember is InjectionMember <MethodInfo, object[]> && memberSet.Add(injectionMember)) { yield return(injectionMember); } } } // Select Attributed members foreach (var member in type.GetDeclaredMethods()) { for (var i = 0; i < AttributeFactories.Length; i++) { #if NET40 if (!member.IsDefined(AttributeFactories[i].Type, true) || #else if (!member.IsDefined(AttributeFactories[i].Type) || #endif !memberSet.Add(member)) { continue; } // Validate if (member.IsStatic) { throw new ArgumentException( $"Static method {member.Name} on type '{member.DeclaringType.Name}' is marked for injection. Static methods cannot be injected"); } if (member.IsPrivate) { throw new InvalidOperationException( $"Private method '{member.Name}' on type '{member.DeclaringType.Name}' is marked for injection. Private methods cannot be injected"); } if (member.IsFamily) { throw new InvalidOperationException( $"Protected method '{member.Name}' on type '{member.DeclaringType.Name}' is marked for injection. Protected methods cannot be injected"); } if (member.IsGenericMethodDefinition) { throw new ArgumentException( $"Open generic method {member.Name} on type '{member.DeclaringType.Name}' is marked for injection. Open generic methods cannot be injected."); } var parameters = member.GetParameters(); if (parameters.Any(param => param.IsOut)) { throw new ArgumentException( $"Method {member.Name} on type '{member.DeclaringType.Name}' is marked for injection. Methods with 'out' parameters cannot be injected."); } if (parameters.Any(param => param.ParameterType.IsByRef)) { throw new ArgumentException( $"Method {member.Name} on type '{member.DeclaringType.Name}' is marked for injection. Methods with 'ref' parameters cannot be injected."); } yield return(member); break; } } }
public override IEnumerable <object> Select(Type type, IPolicySet registration) { HashSet <object> memberSet = new HashSet <object>(); // Select Injected Members if (null != ((InternalRegistration)registration).InjectionMembers) { foreach (var injectionMember in ((InternalRegistration)registration).InjectionMembers) { if (injectionMember is InjectionMember <FieldInfo, object> && memberSet.Add(injectionMember)) { yield return(injectionMember); } } } // Select Attributed members foreach (var member in type.GetDeclaredFields()) { for (var i = 0; i < AttributeFactories.Length; i++) { #if NET40 if (!member.IsDefined(AttributeFactories[i].Type, true) || #else if (!member.IsDefined(AttributeFactories[i].Type) || #endif !memberSet.Add(member)) { continue; } if (member.IsStatic) { throw new InvalidOperationException( $"Static field '{member.Name}' on type '{type?.Name}' is marked for injection. Static fields cannot be injected"); } if (member.IsInitOnly) { throw new InvalidOperationException( $"Readonly field '{member.Name}' on type '{type?.Name}' is marked for injection. Readonly fields cannot be injected"); } if (member.IsPrivate) { throw new InvalidOperationException( $"Private field '{member.Name}' on type '{type?.Name}' is marked for injection. Private fields cannot be injected"); } if (member.IsFamily) { throw new InvalidOperationException( $"Protected field '{member.Name}' on type '{type?.Name}' is marked for injection. Protected fields cannot be injected"); } yield return(member); break; } } }
/// <param name="set">the IPolicySet to summarise</param> public BasicTextSummaryWriter( IPolicySet set ) { m_pss = new PolicySetSummary(set); }
/// <summary> /// Removes a RoutingTable from a policy set's master catalogue /// </summary> /// <param name="policySet">The policy set from whose catalogue we will remove the RoutingTable</param> /// <param name="routingTable">The Routingtable to remove</param> private static void RemoveRoutingTable(IPolicySet policySet, IRoutingTable routingTable) { if (null == policySet || null == routingTable) { return; } IRoutingItemCollections addressGroup = routingTable.Sources; foreach (IRoutingItemCollection addressCollection in addressGroup) { RemoveAddressCollection(policySet, addressCollection); } addressGroup = routingTable.Destinations; foreach (IRoutingItemCollection addressCollection in addressGroup) { RemoveAddressCollection(policySet, addressCollection); } policySet.MasterCatalogue.RoutingTables.Remove(routingTable); }
private ResolveDelegate <PipelineContext> PipelineFromTypeFactory(ref HashKey key, UnityContainer container, IPolicySet set) { Debug.Assert(null != _registry); Debug.Assert(null != key.Type); LifetimeManager?manager = null; ResolveDelegate <PipelineContext>?pipeline = null; var typeFactory = (TypeFactoryDelegate)set.Get(typeof(TypeFactoryDelegate)); // Add Pipeline to the Registry lock (_syncRegistry) { bool adding = true; var collisions = 0; var targetBucket = key.HashCode % _registry.Buckets.Length; for (var i = _registry.Buckets[targetBucket]; i >= 0; i = _registry.Entries[i].Next) { ref var candidate = ref _registry.Entries[i]; if (candidate.Key != key) { collisions++; continue; } // Pipeline already been created if (null != candidate.Pipeline) { return(candidate.Pipeline); } // Lifetime Manager manager = (LifetimeManager)set.Get(typeof(LifetimeManager)) ?? Context.TypeLifetimeManager.CreateLifetimePolicy(); manager.PipelineDelegate = (ResolveDelegate <PipelineContext>)SpinWait; // Type has not been registered if (null == candidate.Registration) { candidate.Pipeline = manager.Pipeline; } adding = false; break; } if (adding) { // Expand if required if (_registry.RequireToGrow || CollisionsCutPoint < collisions) { _registry = new Registry(_registry); targetBucket = key.HashCode % _registry.Buckets.Length; } // Lifetime Manager manager = (LifetimeManager)set.Get(typeof(LifetimeManager)) ?? Context.TypeLifetimeManager.CreateLifetimePolicy(); manager.PipelineDelegate = (ResolveDelegate <PipelineContext>)SpinWait; // Create new entry ref var entry = ref _registry.Entries[_registry.Count]; entry.Key = key; entry.Pipeline = manager.Pipeline; entry.Next = _registry.Buckets[targetBucket]; _registry.Buckets[targetBucket] = _registry.Count++; }
/// <summary> /// Removes a DataElement from a policy set's master catalogue. /// /// This should only be called for DataElements that are part of a collection, ie /// Action.DataElements and DataElements that are method parameters /// </summary> /// <param name="policySet">The policy set from whose catalogue we will remove the DataElement</param> /// <param name="dataElement">The DataElement to remove</param> private static void RemoveDataElement(IPolicySet policySet, IDataElement dataElement) { if (null == policySet || null == dataElement) { return; } if (dataElement.Data is IDataSource) { IDataSource source = dataElement.Data as IDataSource; foreach (IParameter parameter in source.Method.Parameters) { RemoveDataElement(policySet, parameter.Value); } } policySet.MasterCatalogue.DataElements.Remove(dataElement); }
/// <summary> /// Removes a Channel from a policy set's master catalogue /// </summary> /// <param name="policySet">The policy set from whose catalogue we will remove the Channel</param> /// <param name="channel">The Channel to remove</param> private static void RemoveChannel(IPolicySet policySet, IPolicyChannel channel) { if (null == policySet || null == channel) { return; } IRoutingTable routingTable = channel.Routing; foreach(IRoutingItemCollection sender in routingTable.Sources) { foreach (IRoutingItemCollection recipient in routingTable.Destinations) { if (channel.Actions.HasCell(sender, recipient)) { IActionMatrixCell cell = channel.Actions[sender, recipient]; foreach (IActionConditionGroup actionConditionGroup in cell.ActionConditionGroups) { RemoveConditionGroup(policySet, actionConditionGroup); } } } } //remove routing table RemoveRoutingTable(policySet, channel.Routing); IChannel channelInCatalogue = policySet.MasterCatalogue.Channels[channel.Identifier]; policySet.MasterCatalogue.Channels.Remove(channelInCatalogue); }
/// <summary> /// Removes a ConditionGroup from a policy set's master catalogue /// </summary> /// <param name="policySet">The policy set from whose catalogue we will remove the ConditionGroup</param> /// <param name="conditionGroup">The ConditionGroup to remove</param> private static void RemoveConditionGroup(IPolicySet policySet, IConditionGroup conditionGroup) { if ((null == policySet) || (null == conditionGroup)) { return; } foreach(IPolicyObject conditionOrGroup in conditionGroup.Conditions) { if (conditionOrGroup is ICondition) { RemoveCondition(policySet, conditionOrGroup as ICondition); } else if (conditionOrGroup is IConditionGroup) { RemoveConditionGroup(policySet, conditionOrGroup as IConditionGroup); } } //do extra processing on the IActionConditionGroup specialization if (conditionGroup is IActionConditionGroup) { RemoveActionGroup(policySet, ((IActionConditionGroup)conditionGroup).ActionGroup); } policySet.MasterCatalogue.ConditionGroups.Remove(conditionGroup); }
/// <summary> /// Removes a condition from a policy set's master catalogue /// </summary> /// <param name="policySet">The policy set from whose catalogue we will remove the condition</param> /// <param name="condition">The condition to remove</param> private static void RemoveCondition(IPolicySet policySet, ICondition condition) { if ((null == policySet) || (null == condition)) { return; } RemoveDataElement(policySet, condition.DataLeft); RemoveDataElement(policySet, condition.DataRight); policySet.MasterCatalogue.Conditions.Remove(condition); }
/// <summary> /// Removes a policy from a policy set's master catalogue /// </summary> /// <param name="policySet">The policy set from whose catalogue we will remove the policy</param> /// <param name="policy">The policy to remove</param> private static void RemovePolicy(IPolicySet policySet, IPolicy policy) { if (null == policySet || null == policy) { return; } foreach(IPolicyObject conditionOrGroup in policy.Conditions) { if (conditionOrGroup is ICondition) { RemoveCondition(policySet, conditionOrGroup as ICondition); } else { RemoveConditionGroup(policySet, conditionOrGroup as IConditionGroup); } } foreach(IPolicyChannel channel in policy.Channels) { RemoveChannel(policySet, channel); } policySet.MasterCatalogue.CataloguePolicies.Remove(policy); }
public PropertyDiagnostic(IPolicySet policySet) : base(policySet) { }
/// <summary> /// Removes an ActionGroup from a policy set's master catalogue /// </summary> /// <param name="policySet">The policy set from whose catalogue we will remove the ActionGroup</param> /// <param name="actionGroup">The ActionGroup to remove</param> private static void RemoveActionGroup(IPolicySet policySet, IActionGroup actionGroup) { if (null == policySet || null == actionGroup) { return; } foreach (IActionGroup childActionGroup in actionGroup.ActionGroups) { RemoveActionGroup(policySet, childActionGroup); } foreach (IAction childAction in actionGroup.Actions) { RemoveAction(policySet, childAction); } policySet.MasterCatalogue.ActionGroups.Remove(actionGroup); }
public override IEnumerable <object> Select(Type type, IPolicySet registration) { HashSet <object> memberSet = new HashSet <object>(); // Select Injected Members foreach (var injectionMember in ((ImplicitRegistration)registration).InjectionMembers ?? EmptyCollection) { if (injectionMember is InjectionMember <PropertyInfo, object> && memberSet.Add(injectionMember)) { yield return(injectionMember); } } // Select Attributed members foreach (var member in type.GetDeclaredProperties()) { foreach (var node in AttributeFactories) { #if NET40 if (!member.IsDefined(node.Type, true) || #else if (!member.IsDefined(node.Type) || #endif !memberSet.Add(member)) { continue; } var setter = member.GetSetMethod(true); if (!member.CanWrite || null == setter) { yield return(new InvalidRegistrationException( $"Readonly property '{member.Name}' on type '{type?.Name}' is marked for injection. Readonly properties cannot be injected")); } if (0 != member.GetIndexParameters().Length) { yield return(new InvalidRegistrationException( $"Indexer '{member.Name}' on type '{type?.Name}' is marked for injection. Indexers cannot be injected")); } if (setter.IsStatic) { yield return(new InvalidRegistrationException( $"Static property '{member.Name}' on type '{type?.Name}' is marked for injection. Static properties cannot be injected")); } if (setter.IsPrivate) { yield return(new InvalidRegistrationException( $"Private property '{member.Name}' on type '{type?.Name}' is marked for injection. Private properties cannot be injected")); } if (setter.IsFamily) { yield return(new InvalidRegistrationException( $"Protected property '{member.Name}' on type '{type?.Name}' is marked for injection. Protected properties cannot be injected")); } yield return(member); break; } } }
/// <summary> /// Removes an Action from a policy set's master catalogue /// </summary> /// <param name="policySet">The policy set from whose catalogue we will remove the Action</param> /// <param name="action">The Action to remove</param> private static void RemoveAction(IPolicySet policySet, IAction action) { if (null == policySet || null == action) { return; } foreach (IDataElement dataElement in action.DataElements) { RemoveDataElement(policySet, dataElement); } policySet.MasterCatalogue.Actions.Remove(action); }
public FieldDiagnostic(IPolicySet policySet) : base(policySet) { }
/// <summary> /// Removes an RoutingItemCollection from a policy set's master catalogue /// </summary> /// <param name="policySet">The policy set from whose catalogue we will remove the RoutingItemCollection</param> /// <param name="locationCollection">The RoutingItemCollection to remove</param> private static void RemoveAddressCollection(IPolicySet policySet, IRoutingItemCollection addressCollection) { if (null == policySet || null == addressCollection) { return; } foreach (IRoutingItem address in addressCollection) { RemoveAddress(policySet, address); } policySet.MasterCatalogue.LocationsCollection.Remove(addressCollection); }
public ConstructorProcessor(IPolicySet policySet, Func <Type, bool> isTypeRegistered) : base(policySet, typeof(InjectionConstructorAttribute)) { _isTypeRegistered = isTypeRegistered; SelectMethod = SmartSelector; }
/// <summary> /// Removes an RoutingItem from a policy set's master catalogue /// </summary> /// <param name="policySet">The policy set from whose catalogue we will remove the RoutingItem</param> /// <param name="location">The Channel to remove</param> private static void RemoveAddress(IPolicySet policySet, IRoutingItem address) { if (null == policySet || null == address) { return; } policySet.MasterCatalogue.Locations.Remove(address); }
public MethodDiagnostic(IPolicySet policySet, UnityContainer container) : base(policySet, container) { }
/// <summary> /// Removes a policy object from a policy set's master catalogue. This method assumes that there is no sharing of /// objects within the object model; when a policy object is removed from the catalogue, all children of this /// policy object are also removed. /// /// Be careful when using this method; in general, the object model dictates that it is only logical to explicitly /// remove those objects that are stored within a collection. You should also ensure you remove the policy object from /// the parent expression *before* calling this method. /// /// Example 1: a policy, stored in policySet.Policies, is safe to remove from the catalogue explicitly, so long as you /// remove it from policySet.Policies before calling this method. /// /// Example 2: a DataElement, stored in Condition.DataLeft, should not be removed explicitly via this method. Note that if /// you decide to remove the parent Condition from the catalogue, the DataElement will be implicitly removed for you. /// /// Ignoring this advice is not dangerous per se; the only problem you should see is that the policy object will /// reappear in the catalogue the next time you inspect the parent object. /// /// Note: At the time of writing, because of problems with the object model not deleting action matrix cells when an location /// collection is removed, explicit removal of LocationsCollection and Locations has been disabled. These can still be /// removed implicitly if you remove a PolicyChannel (or another object even higher up the object model). /// </summary> /// <param name="policySet">The policy set from whose master catalogue we should remove the policy object</param> /// <param name="policyObject">The policy object to remove</param> public static void RemovePolicyObjectFromCatalogue(IPolicySet policySet, IPolicyObject policyObject) { if (policyObject is IPolicy) { RemovePolicy(policySet, policyObject as IPolicy); return; } if (policyObject is ICondition) { RemoveCondition(policySet, policyObject as ICondition); return; } if (policyObject is IConditionGroup) { RemoveConditionGroup(policySet, policyObject as IConditionGroup); return; } if (policyObject is IDataElement) { //use this with care. If the DataElement is condition.DataLeft or condition.DataRight, //the dataelement will be added back into the catalogue the next time the parent condition is //inspected. Only use this if removing a DataElement from an action or from a parameter in a //method. RemoveDataElement(policySet, policyObject as IDataElement); return; } if (policyObject is IPolicyChannel) { RemoveChannel(policySet, policyObject as IPolicyChannel); return; } if (policyObject is IAction) { RemoveAction(policySet, policyObject as IAction); return; } //for now, don't support removal of individual location collections, as the object model doesn't delete //action matrix cells for us and so the location collection is automatically re-added into the catalogue. //however, location groups can be removed as part of a channel removal. //TODO: refactor object model to correctly remove action matrix cells //if (policyObject is IRoutingItemCollection) //{ // RemoveAddressCollection(policySet, policyObject as IRoutingItemCollection); // return; //} //for now, don't support removal of individual locations, as the object model doesn't delete //action matrix cells for us and so the location is automatically re-added into the catalogue. //however, locations can be removed as part of a channel removal. //TODO: refactor object model to correctly remove action matrix cells //if (policyObject is IRoutingItem) //{ // RemoveAddress(policySet, policyObject as IRoutingItem); // return; //} //It is illogical to attempt to remove the following objects in isolation; these should only //ever be removed from the catalogue because their parent object is being removed // //- remove a routing table only when removing an entire channel //- remove an action group only when removing an action condition group Utilities.ErrorMessage errorMessage = new Utilities.ErrorMessage( "POLICY_UNSUPPORTED_TYPE", "Workshare.PolicyDesigner.Properties.Resources", System.Reflection.Assembly.GetExecutingAssembly(), policyObject.ToString()); Logger.LogError(errorMessage.LogString); throw new ArgumentException(errorMessage.DisplayString); }
public MethodProcessor(IPolicySet policySet, UnityContainer container) : base(policySet, typeof(InjectionMethodAttribute), container) { }
public override MemberSelector <ConstructorInfo> GetOrDefault(IPolicySet registration) => registration.Get <MemberSelector <ConstructorInfo> >() ?? Defaults.SelectConstructor;
public override ResolveDelegate <BuilderContext> GetResolver(Type type, IPolicySet registration, ResolveDelegate <BuilderContext> seed) { #if NETSTANDARD1_0 || NETCOREAPP1_0 var typeInfo = type.GetTypeInfo(); #else var typeInfo = type; #endif // Validate if Type could be created if (typeInfo.IsInterface) { return((ref BuilderContext c) => { if (null == c.Existing) { throw new InvalidOperationException(string.Format(CannotConstructInterface, c.Type), new InvalidRegistrationException()); } return c.Existing; }); } if (typeInfo.IsAbstract) { return((ref BuilderContext c) => { if (null == c.Existing) { throw new InvalidOperationException(string.Format(CannotConstructAbstractClass, c.Type), new InvalidRegistrationException()); } return c.Existing; }); } if (typeInfo.IsSubclassOf(typeof(Delegate))) { return((ref BuilderContext c) => { if (null == c.Existing) { throw new InvalidOperationException(string.Format(CannotConstructDelegate, c.Type), new InvalidRegistrationException()); } return c.Existing; }); } if (type == typeof(string)) { return((ref BuilderContext c) => { if (null == c.Existing) { throw new InvalidOperationException(string.Format(TypeIsNotConstructable, c.Type), new InvalidRegistrationException()); } return c.Existing; }); } return(base.GetResolver(type, registration, seed)); }
public override MemberSelector <FieldInfo> GetOrDefault(IPolicySet registration) => registration.Get <MemberSelector <FieldInfo> >() ?? Defaults.SelectField;
public override IEnumerable <object> Select(Type type, IPolicySet registration) { var members = new List <InjectionMember>(); // Select Injected Members if (null != ((InternalRegistration)registration).InjectionMembers) { foreach (var injectionMember in ((InternalRegistration)registration).InjectionMembers) { if (injectionMember is InjectionMember <ConstructorInfo, object[]> ) { members.Add(injectionMember); } } } switch (members.Count) { case 1: return(members.ToArray()); case 0: break; default: return(new[] { new InvalidOperationException($"Multiple Injection Constructors are registered for Type {type.FullName}", new InvalidRegistrationException()) }); } // Enumerate to array var constructors = DeclaredMembers(type).ToArray(); if (1 >= constructors.Length) { return(constructors); } var selection = new HashSet <ConstructorInfo>(); // Select Attributed constructors foreach (var constructor in constructors) { for (var i = 0; i < AttributeFactories.Length; i++) { #if NET40 if (!constructor.IsDefined(AttributeFactories[i].Type, true)) #else if (!constructor.IsDefined(AttributeFactories[i].Type)) #endif { continue; } selection.Add(constructor); } } switch (selection.Count) { case 1: return(selection.ToArray()); case 0: break; default: return(new[] { new InvalidOperationException($"Multiple Constructors are annotated for injection on Type {type.FullName}", new InvalidRegistrationException()) }); } // Select default return(new[] { SelectMethod(type, constructors) }); }
public override ISelect <FieldInfo> GetOrDefault(IPolicySet registration) => registration.Get <ISelect <FieldInfo> >() ?? Defaults.FieldsSelector;
/// <summary> /// /// </summary> /// <remarks> /// Call hierarchy: /// <see cref="GetResolver"/> /// + <see cref="SelectMembers"/> /// + <see cref="ResolversFromSelected"/> /// + <see cref="BuildMemberResolver"/> /// + <see cref="GetResolverDelegate"/> /// </remarks> /// <param name="type"></param> /// <param name="registration"></param> /// <param name="seed"></param> /// <returns></returns> public abstract ResolveDelegate <BuilderContext> GetResolver(Type type, IPolicySet registration, ResolveDelegate <BuilderContext> seed);
public ConstructorProcessor(IPolicySet policySet, UnityContainer container) : base(policySet, typeof(InjectionConstructorAttribute), container) { SelectMethod = SmartSelector; }