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());
}
