internal static IEnumerable <PolicyDefinition> GetPolicies(IEnumerable <Assembly> assemblies) { var policies = new Dictionary <string, PolicyDefinition>(); foreach (var assembly in assemblies) { foreach (var policyType in assembly.GetTypes().Where(t => !t.IsInterface && typeof(Policy).IsAssignableFrom(t))) { var name = policyType.FullName; var overrideType = policyType.GetInterfaces().FirstOrDefault(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(OverridePolicy <>)); if (overrideType != null) { name = overrideType.GetGenericArguments()[0].FullName; } if (policies.ContainsKey(name) && overrideType == null) { continue; } policies[name] = new PolicyDefinition { Policy = (Policy)Activator.CreateInstance(policyType), Name = name }; } } return(policies.Values); }
/// <summary> /// Constructs the resource /// </summary> private JToken GetResource(string resourceId, string apiVersion) { var resource = this.GetExistingResource(resourceId, apiVersion).Result.ToResource(); var policyRuleJson = string.IsNullOrEmpty(this.Policy) ? resource.Properties["policyRule"]?.ToString() : GetObjectFromParameter(this.Policy).ToString(); var metaDataJson = string.IsNullOrEmpty(this.Metadata) ? resource.Properties["metadata"]?.ToString() : GetObjectFromParameter(this.Metadata).ToString(); var parameterJson = string.IsNullOrEmpty(this.Parameter) ? resource.Properties["parameters"]?.ToString() : GetObjectFromParameter(this.Parameter).ToString(); PolicyDefinitionMode tempMode; PolicyDefinitionMode?existingMode = null; if (Enum.TryParse(resource.Properties["mode"]?.ToString(), true, out tempMode)) { existingMode = tempMode; } var policyDefinitionObject = new PolicyDefinition { Name = this.Name ?? resource.Name, Properties = new PolicyDefinitionProperties { Description = this.Description ?? resource.Properties["description"]?.ToString(), DisplayName = this.DisplayName ?? resource.Properties["displayName"]?.ToString(), PolicyRule = string.IsNullOrEmpty(policyRuleJson) ? null : JObject.Parse(policyRuleJson), Metadata = string.IsNullOrEmpty(metaDataJson) ? null : JObject.Parse(metaDataJson), Parameters = string.IsNullOrEmpty(parameterJson) ? null : JObject.Parse(parameterJson), Mode = this.Mode ?? existingMode } }; return(policyDefinitionObject.ToJToken()); }
/// <summary> /// Constructs the policy definition by combining command line parameters and json object /// </summary> private JToken GetResource() { var policyDefinitionObject = new PolicyDefinition { Name = this.Name, Properties = new PolicyDefinitionProperties() }; var policyObject = this.GetObjectFromParameter(this.Policy, nameof(this.Policy)); if (policyObject["policyRule"] != null) { // policy parameter was a full policy object, populate the properties from it, override from other command line parameters policyDefinitionObject.Properties.Description = this.Description ?? policyObject["description"]?.ToString(); policyDefinitionObject.Properties.DisplayName = this.DisplayName ?? policyObject["displayName"]?.ToString(); policyDefinitionObject.Properties.PolicyRule = policyObject["policyRule"] as JObject; policyDefinitionObject.Properties.Metadata = this.Metadata == null ? policyObject["metadata"] as JObject : this.GetObjectFromParameter(this.Metadata, nameof(this.Metadata)); policyDefinitionObject.Properties.Parameters = this.Parameter == null ? policyObject["parameters"] as JObject : this.GetObjectFromParameter(this.Parameter, nameof(this.Parameter)); policyDefinitionObject.Properties.Mode = string.IsNullOrEmpty(this.Mode) ? policyObject["mode"]?.ToString() ?? PolicyDefinitionMode.All : this.Mode; } else { // policy parameter was a rule object, populate policy rule from it and the properties from command line parameters policyDefinitionObject.Properties.Description = this.Description; policyDefinitionObject.Properties.DisplayName = this.DisplayName; policyDefinitionObject.Properties.PolicyRule = this.GetObjectFromParameter(this.Policy, nameof(this.Policy)); policyDefinitionObject.Properties.Metadata = this.Metadata == null ? null : this.GetObjectFromParameter(this.Metadata, nameof(this.Metadata)); policyDefinitionObject.Properties.Parameters = this.Parameter == null ? null : this.GetObjectFromParameter(this.Parameter, nameof(this.Parameter)); policyDefinitionObject.Properties.Mode = string.IsNullOrEmpty(this.Mode) ? PolicyDefinitionMode.All : this.Mode; } return(policyDefinitionObject.ToJToken()); }
public void Verify_cannot_create_policy_4() { var container = GetContainerBuilder().BuildServiceProvider(); var result = container.GetService <IBrokerObjectFactory>() .Object <Policy>() .Create(x => { x.Configure(p => { p.UsingPattern("^amq."); p.HasPriority(0); p.HasArguments(d => { d.SetHighAvailabilityMode(HighAvailabilityModes.All); d.SetFederationUpstreamSet("all"); d.SetExpiry(1000); }); p.ApplyTo("all"); }); }) .GetResult(); result.HasFaulted.ShouldBeTrue(); result.DebugInfo.ShouldNotBeNull(); PolicyDefinition definition = result.DebugInfo.Request.ToObject <PolicyDefinition>(); definition.Pattern.ShouldBe("^amq."); definition.Priority.ShouldBe(0); definition.Arguments["ha-mode"].ShouldBe("all"); definition.Arguments["expires"].ShouldBe("1000"); definition.ApplyTo.ShouldBe("all"); result.Errors.Count.ShouldBe(2); }
private void Setup(TfsDriveParameter dynamicParameters) { Container = new UnityContainer(); Container.AddNewExtension <Interception>(); //Container.RegisterType<IContainer, TfsDrive>(new TransientLifetimeManager(), new InterceptionBehavior<PolicyInjectionBehavior>(), new Interceptor<InterfaceInterceptor>()); Container.RegisterType <IContainer, TfsDrive>(new TransientLifetimeManager()); Container.RegisterType <CachingLifetimeManager>(new ContainerControlledLifetimeManager()); if (null != dynamicParameters.DataService) { Container.RegisterInstance(dynamicParameters.DataService); } else { Container.RegisterType <ITfsDataService, TfsRestDataService>(new ContainerControlledLifetimeManager(), new InjectionConstructor( new InjectionParameter <string>(dynamicParameters.Url), new InjectionParameter <string>(dynamicParameters.AccessToken) ), new InterceptionBehavior <PolicyInjectionBehavior>(), new Interceptor <InterfaceInterceptor>()); } PolicyDefinition loggingPolicy = Container.Configure <Interception>().AddPolicy("logging"); loggingPolicy.AddMatchingRule <AssemblyMatchingRule>(new InjectionConstructor(new InjectionParameter(GetType().Assembly.FullName))); loggingPolicy.AddCallHandler <LoggingCallHandler>(new ContainerControlledLifetimeManager(), new InjectionConstructor()); loggingPolicy.AddCallHandler <PerformanceMeasurementHandler>(new ContainerControlledLifetimeManager(), new InjectionConstructor()); loggingPolicy.AddCallHandler <CachingCallHandler>(Container.Resolve <CachingLifetimeManager>(), new InjectionConstructor()); TfsDataService = Container.Resolve <ITfsDataService>(); }
/// <summary> /// Constructs the resource /// </summary> private JToken GetResource(string resourceId, string apiVersion) { var resource = this.GetExistingResource(resourceId, apiVersion).Result.ToResource(); var policyDefinitionObject = new PolicyDefinition { Name = this.Name ?? ResourceIdUtility.GetResourceName(this.Id), Properties = new PolicyDefinitionProperties { Description = this.Description ?? (resource.Properties["description"] != null ? resource.Properties["description"].ToString() : null), DisplayName = this.DisplayName ?? (resource.Properties["displayName"] != null ? resource.Properties["displayName"].ToString() : null) } }; if (!string.IsNullOrEmpty(this.Policy)) { policyDefinitionObject.Properties.PolicyRule = JObject.Parse(GetPolicyRuleObject().ToString()); } else { policyDefinitionObject.Properties.PolicyRule = JObject.Parse(resource.Properties["policyRule"].ToString()); } return(policyDefinitionObject.ToJToken()); }
public void Verify_can_create_policy() { var container = GetContainerBuilder().BuildServiceProvider(); var result = container.GetService <IBrokerObjectFactory>() .Object <Policy>() .Create(x => { x.Policy("P5"); x.Configure(p => { p.UsingPattern("^amq."); p.HasPriority(0); p.HasArguments(d => { d.SetHighAvailabilityMode(HighAvailabilityModes.All); d.SetExpiry(1000); }); p.ApplyTo("all"); }); x.Targeting(t => t.VirtualHost("HareDu")); }) .GetResult(); result.HasFaulted.ShouldBeFalse(); result.DebugInfo.ShouldNotBeNull(); PolicyDefinition definition = result.DebugInfo.Request.ToObject <PolicyDefinition>(); definition.Pattern.ShouldBe("^amq."); definition.Priority.ShouldBe(0); definition.Arguments["ha-mode"].ShouldBe("all"); definition.Arguments["expires"].ShouldBe("1000"); definition.ApplyTo.ShouldBe("all"); }
static H容器() { _IUnityContainer = new UnityContainer(); _Interception = _IUnityContainer.AddNewExtension <Interception>().Configure <Interception>(); _PolicyDefinition = _Interception.AddPolicy("MyPolicy"); _PolicyDefinition.AddMatchingRule <AlwaysMatchingRule>(); _PolicyDefinition.AddCallHandler <LoggerCallHandler>(new ContainerControlledLifetimeManager()); }
public static PolicyDefinition AddSingletonCallHandler <T>( this PolicyDefinition policyDefinition) where T : ICallHandler { if (policyDefinition == null) { throw new ArgumentNullException(nameof(policyDefinition)); } return(policyDefinition .AddCallHandler <T>(new ContainerControlledLifetimeManager()) ); }
/// <summary> /// /// </summary> /// <param name="container"></param> public void Configure(IUnityContainer container) { PolicyDefinition policyDefinition = container.Configure <Interception>().AddPolicy(this.Name); foreach (MatchingRuleConfigurationElement ruleElement in MatchingRules) { ruleElement.Configure(policyDefinition); } foreach (CallHandlerConfigurationElement handlerElement in CallHandlers) { handlerElement.Configure(policyDefinition); } }
internal void ConfigureContainer(IUnityContainer container) { PolicyDefinition policyDefinition = container.Configure <Interception>().AddPolicy(this.Name); foreach (var matchingRuleElement in this.MatchingRules) { matchingRuleElement.Configure(container, policyDefinition); } foreach (var callHandlerElement in this.CallHandlers) { callHandlerElement.Configure(container, policyDefinition); } }
/// <summary> /// Constructs the resource /// </summary> private JToken GetResource() { var policyDefinitionObject = new PolicyDefinition { Name = this.Name, Properties = new PolicyDefinitionProperties { Description = this.Description ?? null, DisplayName = this.DisplayName ?? null, PolicyRule = JObject.Parse(GetPolicyRuleObject().ToString()) } }; return(policyDefinitionObject.ToJToken()); }
internal void Configure(PolicyDefinition policyDefinition) { if (string.IsNullOrEmpty(this.TypeName)) { policyDefinition.AddMatchingRule(this.Name); } else { policyDefinition.AddMatchingRule( this.Type, this.Name, this.Lifetime != null ? this.Lifetime.CreateLifetimeManager() : null, this.Injection != null ? this.Injection.GetInjectionMembers() : new InjectionMember[0]); } }
internal void Configure(IUnityContainer container, PolicyDefinition policyDefinition) { if (string.IsNullOrEmpty(this.TypeName)) { policyDefinition.AddCallHandler(this.Name); } else { Type handlerType = TypeResolver.ResolveType(TypeName); IEnumerable<InjectionMember> injectionMembers = Injection.SelectMany( element => element.GetInjectionMembers(container, typeof(ICallHandler), handlerType, Name)); policyDefinition.AddCallHandler(handlerType, Lifetime.CreateLifetimeManager(), injectionMembers.ToArray()); } }
internal void Configure(IUnityContainer container, PolicyDefinition policyDefinition) { if (string.IsNullOrEmpty(this.TypeName)) { policyDefinition.AddCallHandler(this.Name); } else { Type handlerType = TypeResolver.ResolveType(TypeName); IEnumerable <InjectionMember> injectionMembers = Injection.SelectMany( element => element.GetInjectionMembers(container, typeof(ICallHandler), handlerType, Name)); policyDefinition.AddCallHandler(handlerType, Lifetime.CreateLifetimeManager(), injectionMembers.ToArray()); } }
/// <summary> /// Constructs the policy definition by combining command line parameters and existing policy definition /// </summary> private JToken GetResource(string resourceId, string apiVersion) { var resource = this.GetExistingResource(resourceId, apiVersion).Result.ToResource(); // apply incoming object properties if present if (this.InputObject != null) { resource.Properties = this.InputObject.Properties.ToJToken(); } var policyDefinitionObject = new PolicyDefinition { Name = this.Name ?? resource.Name, Properties = new PolicyDefinitionProperties() }; JObject policyObject = this.Policy != null?this.GetObjectFromParameter(this.Policy, nameof(this.Policy)) : null; if (policyObject != null && policyObject["policyRule"] != null) { // policy parameter was a full policy object, populate the properties from it, override from other command line parameters policyDefinitionObject.Properties.Description = this.Description ?? policyObject["description"]?.ToString() ?? resource.Properties["description"]?.ToString(); policyDefinitionObject.Properties.DisplayName = this.DisplayName ?? policyObject["displayName"]?.ToString() ?? resource.Properties["displayName"]?.ToString(); policyDefinitionObject.Properties.PolicyRule = policyObject["policyRule"] as JObject ?? resource.Properties["policyRule"] as JObject; policyDefinitionObject.Properties.Metadata = this.Metadata == null ? policyObject["metadata"] as JObject ?? resource.Properties["metadata"] as JObject : this.GetObjectFromParameter(this.Metadata, nameof(this.Metadata)); policyDefinitionObject.Properties.Parameters = this.Parameter == null ? policyObject["parameters"] as JObject ?? resource.Properties["metadata"] as JObject : this.GetObjectFromParameter(this.Parameter, nameof(this.Parameter)); policyDefinitionObject.Properties.Mode = string.IsNullOrEmpty(this.Mode) ? policyObject["mode"]?.ToString() ?? resource.Properties["mode"]?.ToString() ?? PolicyDefinitionMode.All : this.Mode; } else { // policy parameter was a rule object, populate policy rule from it and the properties from command line parameters policyDefinitionObject.Properties.Description = this.Description ?? resource.Properties["description"]?.ToString(); policyDefinitionObject.Properties.DisplayName = this.DisplayName ?? resource.Properties["displayName"]?.ToString(); policyDefinitionObject.Properties.PolicyRule = policyObject ?? resource.Properties["policyRule"] as JObject; policyDefinitionObject.Properties.Metadata = this.Metadata == null ? resource.Properties["metadata"] as JObject : this.GetObjectFromParameter(this.Metadata, nameof(this.Metadata)); policyDefinitionObject.Properties.Parameters = this.Parameter == null ? resource.Properties["parameters"] as JObject : this.GetObjectFromParameter(this.Parameter, nameof(this.Parameter)); policyDefinitionObject.Properties.Mode = string.IsNullOrEmpty(this.Mode) ? resource.Properties["mode"]?.ToString() ?? PolicyDefinitionMode.All : this.Mode; } return(policyDefinitionObject.ToJToken()); }
internal void Configure(IUnityContainer container, PolicyDefinition policyDefinition) { if (string.IsNullOrEmpty(TypeName)) { policyDefinition.AddMatchingRule(Name); } else { Type matchingRuleType = TypeResolver.ResolveType(TypeName); LifetimeManager lifetime = Lifetime.CreateLifetimeManager(); IEnumerable<InjectionMember> injectionMembers = Injection.SelectMany( element => element.GetInjectionMembers(container, typeof(IMatchingRule), matchingRuleType, Name)); policyDefinition.AddMatchingRule(matchingRuleType, lifetime, injectionMembers.ToArray()); } }
internal void Configure(IUnityContainer container, PolicyDefinition policyDefinition) { if (string.IsNullOrEmpty(TypeName)) { policyDefinition.AddMatchingRule(Name); } else { Type matchingRuleType = TypeResolver.ResolveType(TypeName); LifetimeManager lifetime = Lifetime.CreateLifetimeManager(); IEnumerable <InjectionMember> injectionMembers = Injection.SelectMany( element => element.GetInjectionMembers(container, typeof(IMatchingRule), matchingRuleType, Name)); policyDefinition.AddMatchingRule(matchingRuleType, lifetime, injectionMembers.ToArray()); } }
/// <summary> /// Constructs the resource /// </summary> private JToken GetResource() { var policyDefinitionObject = new PolicyDefinition { Name = this.Name, Properties = new PolicyDefinitionProperties { Description = this.Description ?? null, DisplayName = this.DisplayName ?? null, PolicyRule = this.GetObjectFromParameter(this.Policy, nameof(this.Policy)), Metadata = this.Metadata == null ? null : this.GetObjectFromParameter(this.Metadata, nameof(this.Metadata)), Parameters = this.Parameter == null ? null : this.GetObjectFromParameter(this.Parameter, nameof(this.Parameter)), Mode = string.IsNullOrEmpty(this.Mode) ? PolicyDefinitionMode.All : this.Mode } }; return(policyDefinitionObject.ToJToken()); }
/// <summary> /// Constructs the resource /// </summary> private JToken GetResource() { var policyDefinitionObject = new PolicyDefinition { Name = this.Name, Properties = new PolicyDefinitionProperties { Description = this.Description ?? null, DisplayName = this.DisplayName ?? null, PolicyRule = JObject.Parse(this.GetObjectFromParameter(this.Policy).ToString()), Metadata = this.Metadata == null ? null : JObject.Parse(this.GetObjectFromParameter(this.Metadata).ToString()), Parameters = this.Parameter == null ? null : JObject.Parse(this.GetObjectFromParameter(this.Parameter).ToString()), Mode = this.Mode.HasValue ? this.Mode : PolicyDefinitionMode.All } }; return(policyDefinitionObject.ToJToken()); }
public void TestInitialize() { Container = new UnityContainer(); Container.AddNewExtension <Interception>(); Container.RegisterType <ITenantStore, TenantStore>(new InterceptionBehavior <PolicyInjectionBehavior>(), new Interceptor <InterfaceInterceptor>()); Container.RegisterType <ISurveyStore, SurveyStore>(new InterceptionBehavior <PolicyInjectionBehavior>(), new Interceptor <InterfaceInterceptor>()); InjectionProperty first = new InjectionProperty("Order", 1); InjectionProperty second = new InjectionProperty("Order", 2); PolicyDefinition loggingPolicy = Container.Configure <Interception>().AddPolicy("logging"); loggingPolicy.AddMatchingRule <AssemblyMatchingRule>(new InjectionConstructor(new InjectionParameter(GetType().Assembly.FullName))); loggingPolicy.AddCallHandler <LoggingCallHandler>(new ContainerControlledLifetimeManager(), new InjectionConstructor(), first); PolicyDefinition cachingPolicy = Container.Configure <Interception>().AddPolicy("caching"); cachingPolicy.AddMatchingRule <AssemblyMatchingRule>(new InjectionConstructor(new InjectionParameter(GetType().Assembly.FullName))); cachingPolicy.AddCallHandler <CachingCallHandler>(new ContainerControlledLifetimeManager(), new InjectionConstructor(), second); }
public void Architecture_DomainLayer_ShouldAdhereToTheOnionArchitectureDomainLayerPolicy() { PolicyDefinition domainLayerPolicy = Policy .Define("Onion Architecture Domain Layer Policy", "The domain layer should not have reference to any other layer within the application core.") .For(Types.InAssembly(typeof(ICoreModule).Assembly)) .Add(t => t.That() .ResideInNamespace("Demo.Core.Domain") .ShouldNot() .HaveDependencyOn("Demo.Core.Repositories"), "Enforcing Domain Layer Policy", "Domain layer should not have references to the repositories layer." ) .Add(t => t.That() .ResideInNamespace("Demo.Core.Domain") .ShouldNot() .HaveDependencyOn("Demo.Core.Services"), "Enforcing Domain Layer Policy", "Domain layer should not have references to the services layer." ); bool actualResult = domainLayerPolicy.Evaluate().HasViolations; actualResult.Should().BeFalse(); }
public async Task <Result> Create(Action <PolicyCreateAction> action, CancellationToken cancellationToken = default) { cancellationToken.RequestCanceled(); var impl = new PolicyCreateActionImpl(); action(impl); impl.Validate(); PolicyDefinition definition = impl.Definition.Value; Debug.Assert(definition != null); string url = $"api/policies/{impl.VirtualHost.Value.ToSanitizedName()}/{impl.PolicyName.Value}"; if (impl.Errors.Value.Any()) { return(new FaultedResult(impl.Errors.Value, new DebugInfoImpl(url, definition.ToJsonString(Deserializer.Options)))); } return(await Put(url, definition, cancellationToken).ConfigureAwait(false)); }
public void WritePolicy(string name, string policyDefinition) { if (_policies.TryGetValue(name, out var polDef)) { if (polDef.IsUpdateForbidden) { throw new ArgumentException( $"cannot update {name} policy"); } } IPolicy pol; try { // Parse and validate the policy definition pol = PolicyManager.ParseDefinition(policyDefinition); } catch (Exception ex) { throw new ArgumentException( $"Failed to parse policy: {ex.GetBaseException().Message}"); } if (polDef == null) { polDef = new PolicyDefinition { Name = name } } ; polDef.Definition = policyDefinition; polDef.Policy = pol; // TODO: move this to persistent operations _policies[name] = polDef; }
public async Task <Response <PolicyDefinition> > CreateOrUpdateAsync(string policyDefinitionName, PolicyDefinition parameters, CancellationToken cancellationToken = default) { if (policyDefinitionName == null) { throw new ArgumentNullException(nameof(policyDefinitionName)); } if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } using var message = CreateCreateOrUpdateRequest(policyDefinitionName, parameters); await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false); switch (message.Response.Status) { case 201: { PolicyDefinition value = default; using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false); value = PolicyDefinition.DeserializePolicyDefinition(document.RootElement); return(Response.FromValue(value, message.Response)); }
/// <summary> /// Creates or updates a policy definition in a subscription. /// </summary> /// <remarks> /// This operation creates or updates a policy definition in the given /// subscription with the given name. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='policyDefinitionName'> /// The name of the policy definition to create. /// </param> /// <param name='parameters'> /// The policy definition properties. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <PolicyDefinition> CreateOrUpdateAsync(this IPolicyDefinitionsOperations operations, string policyDefinitionName, PolicyDefinition parameters, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(policyDefinitionName, parameters, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
/// <summary> /// Creates or updates a policy definition in a subscription. /// </summary> /// <remarks> /// This operation creates or updates a policy definition in the given /// subscription with the given name. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='policyDefinitionName'> /// The name of the policy definition to create. /// </param> /// <param name='parameters'> /// The policy definition properties. /// </param> public static PolicyDefinition CreateOrUpdate(this IPolicyDefinitionsOperations operations, string policyDefinitionName, PolicyDefinition parameters) { return(operations.CreateOrUpdateAsync(policyDefinitionName, parameters).GetAwaiter().GetResult()); }
/// <summary> /// Creates or updates a policy definition in a management group. /// </summary> /// <remarks> /// This operation creates or updates a policy definition in the given /// management group with the given name. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='policyDefinitionName'> /// The name of the policy definition to create. /// </param> /// <param name='parameters'> /// The policy definition properties. /// </param> /// <param name='managementGroupId'> /// The ID of the management group. /// </param> public static PolicyDefinition CreateOrUpdateAtManagementGroup(this IPolicyDefinitionsOperations operations, string policyDefinitionName, PolicyDefinition parameters, string managementGroupId) { return(operations.CreateOrUpdateAtManagementGroupAsync(policyDefinitionName, parameters, managementGroupId).GetAwaiter().GetResult()); }
public virtual async Task <Response <PolicyDefinition> > CreateOrUpdateAsync(string policyDefinitionName, PolicyDefinition parameters, CancellationToken cancellationToken = default) { using var scope = _clientDiagnostics.CreateScope("PolicyDefinitionsOperations.CreateOrUpdate"); scope.Start(); try { return(await RestClient.CreateOrUpdateAsync(policyDefinitionName, parameters, cancellationToken).ConfigureAwait(false)); } catch (Exception e) { scope.Failed(e); throw; } }
public virtual Response <PolicyDefinition> CreateOrUpdate(string policyDefinitionName, PolicyDefinition parameters, CancellationToken cancellationToken = default) { using var scope = _clientDiagnostics.CreateScope("PolicyDefinitionsOperations.CreateOrUpdate"); scope.Start(); try { return(RestClient.CreateOrUpdate(policyDefinitionName, parameters, cancellationToken)); } catch (Exception e) { scope.Failed(e); throw; } }
private IEnumerable <PolicyData> GetPolicyStatusesHelper(PolicySetDefinition[] policySetDefinitions, IEnumerable <GuestConfigurationAssignment> gcrpAssignments, string resourceGroupName) { var gcPolicyAssignmentsList = new List <PolicyData>(); foreach (var policySetDefinition in policySetDefinitions) { // Get policy definitions in initiative var policyDefinitionIdsInInitiative = policySetDefinition.PolicyDefinitions.Select( policyDef => { return(policyDef.PolicyDefinitionId); } ).ToList(); // Get all policy definitions in subscription var policyDefinitionsForTheInitiative = new List <PolicyDefinition>(); foreach (var policyDefinitionIdInInitiative in policyDefinitionIdsInInitiative) { var _initiativeName = GetInitiativeNameFromId(policyDefinitionIdInInitiative); PolicyDefinition policyDef = null; try { policyDef = PolicyClient.PolicyDefinitions.GetBuiltIn(_initiativeName); } catch (Microsoft.Rest.Azure.CloudException ex) when(HttpStatusCode.NotFound.Equals(ex.Response.StatusCode)) { policyDef = PolicyClient.PolicyDefinitions.Get(_initiativeName); } if (policyDef != null) { policyDefinitionsForTheInitiative.Add(policyDef); } } var gcrp_AssignmentName_Assignment_Map = new Dictionary <string, GuestConfigurationAssignment>(); foreach (var gcrpAssignment in gcrpAssignments) { gcrp_AssignmentName_Assignment_Map.Add(gcrpAssignment.Name, gcrpAssignment); } // Get all gcrp assignments for the initiative - for policy definitions of category "Guest Configuration", effectType "AuditIfNotExists" or "Audit" foreach (var policyDef in policyDefinitionsForTheInitiative) { try { var policyRule = JObject.Parse(policyDef.PolicyRule.ToString()); var policyRuleDictionary = policyRule.ToObject <Dictionary <string, object> >(); var policyRuleThen = JObject.Parse(policyRuleDictionary["then"].ToString()); var policyRuleThenDictionary = policyRuleThen.ToObject <Dictionary <string, object> >(); var effectType = policyRuleThenDictionary["effect"].ToString(); var effectTypeLower = effectType.ToLower(); if (Constants.AuditIfNotExists != effectTypeLower && Constants.Audit != effectTypeLower) { continue; } var policyMetadata = JObject.Parse(policyDef.Metadata.ToString()); var policyMetadataDictionary = policyMetadata.ToObject <Dictionary <string, object> >(); var policyCategory = policyMetadataDictionary["category"].ToString().ToLower(); if (Constants.GuestConfigurationCategory != policyCategory) { continue; } string guestConfigurationAssignmentNameInPolicy = null; if (Constants.AuditIfNotExists == effectTypeLower) { var policyRuleThenDetails = JObject.Parse(policyRuleThenDictionary["details"].ToString()); var policyRuleDetailsDictionary = policyRuleThenDetails.ToObject <Dictionary <string, object> >(); guestConfigurationAssignmentNameInPolicy = policyRuleDetailsDictionary["name"].ToString(); } else if (Constants.Audit == effectTypeLower) { var policyRuleIf = JObject.Parse(policyRuleDictionary["if"].ToString()); var policyRuleIfDictionary = policyRuleIf.ToObject <Dictionary <string, object> >(); var policyRuleIfAllOf = policyRuleIfDictionary["allOf"]; var policyRuleIfAllOfJArray = JArray.FromObject(policyRuleIfAllOf); var guestConfigurationAssignmentNameInPolicyArray = policyRuleIfAllOfJArray.Single( x => x.Value <string>("field") == "name" ); guestConfigurationAssignmentNameInPolicy = guestConfigurationAssignmentNameInPolicyArray.Value <string>("equals"); } if (!string.IsNullOrEmpty(guestConfigurationAssignmentNameInPolicy) && gcrp_AssignmentName_Assignment_Map.ContainsKey(guestConfigurationAssignmentNameInPolicy)) { var assignments = PolicyClient.PolicyAssignments.ListForResourceGroup(resourceGroupName, string.Format("policyDefinitionId eq '{0}'", policySetDefinition.Id)); var gcrpAsgnment = gcrp_AssignmentName_Assignment_Map[guestConfigurationAssignmentNameInPolicy]; if (gcrpAsgnment != null && assignments.Count() > 0) { gcPolicyAssignmentsList.Add(new PolicyData(gcrpAsgnment, policyDef.DisplayName, policySetDefinition.Name)); } } } catch (Exception) { this.WriteWarning(string.Format(StringResources.InvalidPolicyDefinition, policyDef.DisplayName)); continue; } } } return(gcPolicyAssignmentsList); }
/// <summary> /// Create or update a policy definition. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='policyDefinitionName'> /// The policy definition name. /// </param> /// <param name='parameters'> /// The policy definition properties. /// </param> public static PolicyDefinition CreateOrUpdate(this IPolicyDefinitionsOperations operations, string policyDefinitionName, PolicyDefinition parameters) { return(Task.Factory.StartNew(s => ((IPolicyDefinitionsOperations)s).CreateOrUpdateAsync(policyDefinitionName, parameters), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult()); }