private void SetRetention(DiagnosticSettingsResource properties)
{
var retentionPolicy = new RetentionPolicy
{
Enabled = this.RetentionEnabled.Value,
Days = this.RetentionInDays.Value
};
if (properties.Logs != null && this.IsParameterBound(c => c.Category))
{
WriteDebugWithTimestamp("Setting retention policy for logs");
properties.Logs = properties.Logs.Select(setting =>
{
if (setting != null)
{
setting.RetentionPolicy = this.Category.Contains(setting.Category) ? retentionPolicy : (setting.RetentionPolicy == null ? null : setting.RetentionPolicy);
}
return(setting);
}).ToList();
}
if (properties.Metrics != null && this.IsParameterBound(c => c.MetricCategory))
{
WriteDebugWithTimestamp("Setting retention policy for metrics");
properties.Metrics = properties.Metrics.Select(setting =>
{
if (setting != null)
{
setting.RetentionPolicy = this.MetricCategory.Contains(setting.Category) ? retentionPolicy : (setting.RetentionPolicy == null ? null : setting.RetentionPolicy);
}
return(setting);
}).ToList();
}
}
public void SetServiceBus()
{
string newServiceBusId = "otherservicebus";
cmdlet.ServiceBusRuleId = newServiceBusId;
cmdlet.MyInvocation.BoundParameters[SetAzureRmDiagnosticSettingCommand.ServiceBusRuleIdParamName] = newServiceBusId;
cmdlet.ExecuteCmdlet();
DiagnosticSettingsResource expectedSettings = GetDefaultSetting();
expectedSettings.ServiceBusRuleId = newServiceBusId;
VerifyCalledOnce();
VerifySettings(expectedSettings, this.calledSettings);
// Test with EventHubName
cmdlet.ServiceBusRuleId = null;
cmdlet.EventHubName = newServiceBusId;
cmdlet.MyInvocation.BoundParameters[SetAzureRmDiagnosticSettingCommand.EventHubNameParamName] = newServiceBusId;
cmdlet.ExecuteCmdlet();
expectedSettings.EventHubName = newServiceBusId;
expectedSettings.ServiceBusRuleId = null;
VerifySettings(expectedSettings, this.calledSettings);
}
private void DisableDiagnosticsAuditWhenOnlyAuditCategoryIsEnabled(
ServerAuditModel model,
DiagnosticSettingsResource settings,
string oldEventHubName,
string oldEventHubAuthorizationRuleId,
string oldWorkspaceId)
{
if (RemoveFirstDiagnosticSettings(model) == false)
{
throw DefinitionsCommon.RemoveDiagnosticSettingsException;
}
try
{
DisableDiagnosticsAuditWhenDiagnosticsEnablingAuditCategoryDoNotExist(model);
}
catch (Exception)
{
try
{
CreateDiagnosticSettings(oldEventHubName, oldEventHubAuthorizationRuleId, oldWorkspaceId, model);
}
catch (Exception) { }
throw;
}
}
private void SetStorage(DiagnosticSettingsResource properties)
{
if (this.isStorageParamPresent)
{
properties.StorageAccountId = this.StorageAccountId;
}
}
private void SetEventHubRule(DiagnosticSettingsResource properties)
{
if (this.isEventHubRuleParamPresent)
{
properties.EventHubAuthorizationRuleId = this.EventHubAuthorizationRuleId;
}
}
public void CreateGetUpdateDiagnosticSetting()
{
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var insightsClient = GetMonitorManagementClient(context, handler);
var parameters = CreateDiagnosticSettings();
DiagnosticSettingsResource response = insightsClient.DiagnosticSettings.CreateOrUpdate(
resourceUri: ResourceUri,
parameters: parameters,
name: "service");
if (!this.IsRecording)
{
Check(response, parameters);
}
DiagnosticSettingsResource actual = insightsClient.DiagnosticSettings.Get(resourceUri: ResourceUri, name: "service");
if (!this.IsRecording)
{
Check(actual, parameters);
Utilities.AreEqual(response, actual);
}
}
}
internal bool UpdateDiagnosticSettings(
DiagnosticSettingsResource settings,
dynamic model)
{
DiagnosticSettingsResource updatedSettings;
if (model is DatabaseBlobAuditingSettingsModel || model is DatabaseAuditModel)
{
updatedSettings = Communicator.UpdateDiagnosticSettings(settings,
model.ResourceGroupName, model.ServerName, model.DatabaseName);
}
else
{
updatedSettings = Communicator.UpdateDiagnosticSettings(settings,
model.ResourceGroupName, model.ServerName);
}
if (updatedSettings == null)
{
return(false);
}
model.DiagnosticsEnablingAuditCategory =
AuditingEndpointsCommunicator.IsAuditCategoryEnabled(updatedSettings) ?
new List <DiagnosticSettingsResource> {
updatedSettings
} : null;
return(true);
}
private void EnableWhenOnlyAuditCategoryIsEnabled(SqlAuditAdapter adapter, DiagnosticSettingsResource settings,
string oldEventHubName, string oldEventHubAuthorizationRuleId, string oldWorkspaceId)
{
settings.EventHubName = GetEventHubNameOnCreateOrUpdate(settings);
settings.EventHubAuthorizationRuleId = GetEventHubAuthorizationRuleIdOnCreateOrUpdate(settings);
settings.WorkspaceId = GetWorkspaceIdOnCreateOrUpdate(settings);
if (adapter.UpdateDiagnosticSettings(settings, this) == false)
{
throw DefinitionsCommon.UpdateDiagnosticSettingsException;
}
try
{
IsGlobalAuditEnabled = true;
IsAzureMonitorTargetEnabled = true;
if (SetAuditingPolicy(adapter) == false)
{
throw DefinitionsCommon.SetAuditingSettingsException;
}
}
catch (Exception)
{
try
{
settings.EventHubName = oldEventHubName;
settings.EventHubAuthorizationRuleId = oldEventHubAuthorizationRuleId;
settings.WorkspaceId = oldWorkspaceId;
adapter.UpdateDiagnosticSettings(settings, this);
}
catch (Exception) { }
throw;
}
}
internal void RemoveAuditingSettings(ServerAuditModel model)
{
model.BlobStorageTargetState = AuditStateType.Disabled;
model.EventHubTargetState = AuditStateType.Disabled;
model.LogAnalyticsTargetState = AuditStateType.Disabled;
DisableDiagnosticsAuditWhenDiagnosticsEnablingAuditCategoryDoNotExist(model);
Exception exception = null;
while (model.DiagnosticsEnablingAuditCategory != null &&
model.DiagnosticsEnablingAuditCategory.Any())
{
DiagnosticSettingsResource settings = model.DiagnosticsEnablingAuditCategory.First();
if (IsAnotherCategoryEnabled(settings))
{
if (DisableAuditCategory(model, settings) == false)
{
exception = DefinitionsCommon.UpdateDiagnosticSettingsException;
}
}
else
{
if (RemoveFirstDiagnosticSettings(model) == false)
{
exception = DefinitionsCommon.RemoveDiagnosticSettingsException;
}
}
}
if (exception != null)
{
throw exception;
}
}
private static void Check(DiagnosticSettingsResource expected, DiagnosticSettingsResource actual)
{
Assert.Equal(expected.StorageAccountId, actual.StorageAccountId);
Assert.Equal(expected.EventHubAuthorizationRuleId, actual.EventHubAuthorizationRuleId);
Assert.Equal(expected.EventHubName, actual.EventHubName);
Assert.Equal(expected.WorkspaceId, actual.WorkspaceId);
}
private bool UpdateDiagnosticSettingsForModel(
DiagnosticSettingsResource settings, AuditModelType model)
{
DiagnosticSettingsResource modifiedSettings = UpdateDiagnosticSettings(settings, model);
if (modifiedSettings == null)
{
return(false);
}
List <DiagnosticSettingsResource> diagnosticsEnablingAuditCategory = new List <DiagnosticSettingsResource>();
foreach (DiagnosticSettingsResource existingSettings in model.DiagnosticsEnablingAuditCategory)
{
if (!string.Equals(modifiedSettings.Id, existingSettings.Id))
{
diagnosticsEnablingAuditCategory.Add(existingSettings);
}
else if (AuditingEndpointsCommunicator.IsAuditCategoryEnabled(modifiedSettings, GetDiagnosticsEnablingAuditCategoryName()))
{
diagnosticsEnablingAuditCategory.Add(modifiedSettings);
}
}
model.DiagnosticsEnablingAuditCategory = diagnosticsEnablingAuditCategory.Any() ? diagnosticsEnablingAuditCategory : null;
return(true);
}
public void DiagnosticSettings_UpdateTest()
{
var resource = CreateDiagnosticSettings();
var handler = new RecordedDelegatingHandler();
var monitorManagementClient = GetMonitorManagementClient(handler);
var serializedObject = Microsoft.Rest.Serialization.SafeJsonConvert.SerializeObject(resource, monitorManagementClient.SerializationSettings);
var expectedResponse = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(serializedObject)
};
handler = new RecordedDelegatingHandler(expectedResponse);
monitorManagementClient = GetMonitorManagementClient(handler);
DiagnosticSettingsResource patchResource = new DiagnosticSettingsResource(
storageAccountId: resource.StorageAccountId,
eventHubAuthorizationRuleId: resource.EventHubAuthorizationRuleId,
metrics: resource.Metrics,
logs: resource.Logs,
workspaceId: resource.WorkspaceId
);
DiagnosticSettingsResource response = monitorManagementClient.DiagnosticSettings.CreateOrUpdate(
resourceUri: ResourceUri,
parameters: patchResource,
name: "service");
AreEqual(resource, response);
}
private void SetAllCategoriesAndTimegrains(DiagnosticSettingsResource properties)
{
if (!this.isEnbledParameterPresent)
{
return;
}
WriteDebugWithTimestamp("Setting Enabled property for logs");
if (properties.Logs == null)
{
properties.Logs = new List <LogSettings>();
}
foreach (var log in properties.Logs)
{
log.Enabled = this.Enabled;
}
WriteDebugWithTimestamp("Setting Enabled property for metrics");
if (properties.Metrics == null)
{
properties.Metrics = new List <MetricSettings>();
}
foreach (var metric in properties.Metrics)
{
metric.Enabled = this.Enabled;
}
}
private void SetWorkspace(DiagnosticSettingsResource properties)
{
if (this.isWorkspaceParamPresent)
{
properties.WorkspaceId = this.WorkspaceId;
}
}
private void SetRetention(DiagnosticSettingsResource properties)
{
var retentionPolicy = new RetentionPolicy
{
Enabled = this.RetentionEnabled.Value,
Days = this.RetentionInDays.Value
};
if (properties.Logs != null)
{
WriteDebugWithTimestamp("Setting retention policy for logs");
foreach (LogSettings logSettings in properties.Logs)
{
logSettings.RetentionPolicy = retentionPolicy;
}
}
if (properties.Metrics != null)
{
WriteDebugWithTimestamp("Setting retention policy for metrics");
foreach (MetricSettings metricSettings in properties.Metrics)
{
metricSettings.RetentionPolicy = retentionPolicy;
}
}
}
/// <summary>
/// Initializes a new instance of the PSServiceDiagnosticSettings class.
/// </summary>
public PSServiceDiagnosticSettings(DiagnosticSettingsResource serviceDiagnosticSettings)
: base(
name: serviceDiagnosticSettings?.Name,
id: serviceDiagnosticSettings?.Id,
type: serviceDiagnosticSettings?.Type,
metrics: serviceDiagnosticSettings?.Metrics,
logs: serviceDiagnosticSettings?.Logs)
{
if (serviceDiagnosticSettings != null)
{
this.StorageAccountId = serviceDiagnosticSettings.StorageAccountId;
this.EventHubName = serviceDiagnosticSettings.EventHubName;
this.ServiceBusRuleId = this.EventHubName;
this.EventHubAuthorizationRuleId = serviceDiagnosticSettings.EventHubAuthorizationRuleId;
this.Metrics = new List <Management.Monitor.Management.Models.MetricSettings>();
foreach (MetricSettings metricSettings in serviceDiagnosticSettings.Metrics)
{
this.Metrics.Add(new PSMetricSettings(metricSettings));
}
this.Logs = new List <Management.Monitor.Management.Models.LogSettings>();
foreach (LogSettings logSettings in serviceDiagnosticSettings.Logs)
{
this.Logs.Add(new PSLogSettings(logSettings));
}
this.WorkspaceId = serviceDiagnosticSettings.WorkspaceId;
}
}
private void SetStorage(DiagnosticSettingsResource properties)
{
if (this.isStorageParamPresent)
{
WriteDebugWithTimestamp("Setting storage account Id");
properties.StorageAccountId = this.StorageAccountId;
}
}
protected override void MarkAuditStateAsEnabled()
{
AuditState = AuditStateType.Enabled;
DiagnosticSettingsResource settings = DiagnosticsEnablingAuditCategory.FirstOrDefault(
s => !string.IsNullOrEmpty(s.WorkspaceId));
WorkspaceResourceId = settings.WorkspaceId;
}
private void SetWorkspace(DiagnosticSettingsResource properties)
{
if (this.isWorkspaceParamPresent)
{
WriteDebugWithTimestamp("Setting workspace Id");
properties.WorkspaceId = this.WorkspaceId;
}
}
private void SetEventHubRule(DiagnosticSettingsResource properties)
{
if (this.isEventHubRuleParamPresent)
{
WriteDebugWithTimestamp("Setting event hub rule Id");
properties.EventHubAuthorizationRuleId = this.EventHubAuthorizationRuleId;
}
}
protected override void MarkAuditStateAsEnabled()
{
AuditState = AuditStateType.Enabled;
DiagnosticSettingsResource settings = DiagnosticsEnablingAuditCategory.FirstOrDefault(
s => !string.IsNullOrEmpty(s.EventHubAuthorizationRuleId));
EventHubName = settings.EventHubName;
EventHubAuthorizationRuleResourceId = settings.EventHubAuthorizationRuleId;
}
public async Task Get()
{
var settingName = Recording.GenerateAssetName("testDiagnosticSettings-");
var setting = await CreateDiagnosticSettingsAsync(settingName);
DiagnosticSettingsResource setting2 = await setting.GetAsync();
ResourceDataHelper.AssertDiagnosticSetting(setting.Data, setting2.Data);
}
private static void DetermineTargetsState(
AuditModelType model,
BlobAuditingPolicyState policyState)
{
if (policyState == BlobAuditingPolicyState.Disabled)
{
model.BlobStorageTargetState = AuditStateType.Disabled;
model.EventHubTargetState = AuditStateType.Disabled;
model.LogAnalyticsTargetState = AuditStateType.Disabled;
}
else
{
if (string.IsNullOrEmpty(model.StorageAccountResourceId))
{
model.BlobStorageTargetState = AuditStateType.Disabled;
}
else
{
model.BlobStorageTargetState = AuditStateType.Enabled;
}
if (model.IsAzureMonitorTargetEnabled == null ||
model.IsAzureMonitorTargetEnabled == false ||
model.DiagnosticsEnablingAuditCategory == null)
{
model.EventHubTargetState = AuditStateType.Disabled;
model.LogAnalyticsTargetState = AuditStateType.Disabled;
}
else
{
DiagnosticSettingsResource eventHubSettings = model.DiagnosticsEnablingAuditCategory.FirstOrDefault(
settings => !string.IsNullOrEmpty(settings.EventHubAuthorizationRuleId));
if (eventHubSettings == null)
{
model.EventHubTargetState = AuditStateType.Disabled;
}
else
{
model.EventHubTargetState = AuditStateType.Enabled;
model.EventHubName = eventHubSettings.EventHubName;
model.EventHubAuthorizationRuleResourceId = eventHubSettings.EventHubAuthorizationRuleId;
}
DiagnosticSettingsResource logAnalyticsSettings = model.DiagnosticsEnablingAuditCategory.FirstOrDefault(
settings => !string.IsNullOrEmpty(settings.WorkspaceId));
if (logAnalyticsSettings == null)
{
model.LogAnalyticsTargetState = AuditStateType.Disabled;
}
else
{
model.LogAnalyticsTargetState = AuditStateType.Enabled;
model.WorkspaceResourceId = logAnalyticsSettings.WorkspaceId;
}
}
}
}
public SetDiagnosticSettingCommandTests(Xunit.Abstractions.ITestOutputHelper output)
{
ServiceManagemenet.Common.Models.XunitTracingInterceptor.AddToContext(new ServiceManagemenet.Common.Models.XunitTracingInterceptor(output));
this.insightsDiagnosticsOperationsMock = new Mock <IDiagnosticSettingsOperations>();
this.insightsManagementClientMock = new Mock <MonitorManagementClient>();
this.commandRuntimeMock = new Mock <ICommandRuntime>();
this.cmdlet = new SetAzureRmDiagnosticSettingCommand()
{
CommandRuntime = commandRuntimeMock.Object,
MonitorManagementClient = insightsManagementClientMock.Object
};
this.ExistingSetting = GetDefaultSetting();
insightsDiagnosticsOperationsMock.Setup(f => f.GetWithHttpMessagesAsync(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <Dictionary <string, List <string> > >(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <AzureOperationResponse <DiagnosticSettingsResource> >(new AzureOperationResponse <DiagnosticSettingsResource>
{
Body = this.ExistingSetting
}));
insightsDiagnosticsOperationsMock.Setup(f => f.CreateOrUpdateWithHttpMessagesAsync(
It.IsAny <string>(),
It.IsAny <DiagnosticSettingsResource>(),
It.IsAny <string>(),
It.IsAny <Dictionary <string, List <string> > >(),
It.IsAny <CancellationToken>()))
.Returns((string a, DiagnosticSettingsResource x, string name, Dictionary <string, List <string> > b, CancellationToken c) =>
{
calledSettings = new DiagnosticSettingsResource(name: name)
{
EventHubAuthorizationRuleId = x.EventHubAuthorizationRuleId,
EventHubName = x.EventHubName,
Logs = x.Logs,
Metrics = x.Metrics,
StorageAccountId = x.StorageAccountId,
WorkspaceId = x.WorkspaceId
};
return(Task.FromResult(new AzureOperationResponse <DiagnosticSettingsResource>
{
Body = x
}));
});
insightsManagementClientMock.SetupGet(f => f.DiagnosticSettings).Returns(this.insightsDiagnosticsOperationsMock.Object);
cmdlet.ResourceId = resourceId;
// Setup Confirmation
commandRuntimeMock.Setup(f => f.ShouldProcess(It.IsAny <string>())).Returns(true);
commandRuntimeMock.Setup(f => f.ShouldProcess(It.IsAny <string>(), It.IsAny <string>())).Returns(true);
commandRuntimeMock.Setup(f => f.ShouldProcess(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(true);
commandRuntimeMock.Setup(f => f.ShouldContinue(It.IsAny <string>(), It.IsAny <string>())).Returns(true);
}
public void DisableEventHub()
{
cmdlet.MyInvocation.BoundParameters[SetAzureRmDiagnosticSettingCommand.EventHubRuleIdParamName] = null;
cmdlet.ExecuteCmdlet();
DiagnosticSettingsResource expectedSettings = GetDefaultSetting();
VerifyCalledOnce();
VerifySettings(expectedSettings, this.calledSettings);
}
public DiagnosticSettingsResource CreateDiagnosticSettings(
string categoryName, string settingsName,
string eventHubName, string eventHubAuthorizationRuleId, string workspaceId,
string resourceGroupName, string serverName, string databaseName = "master")
{
string resoureUri = GetResourceUri(resourceGroupName, serverName, databaseName);
IMonitorManagementClient client = GetMonitorManagementClient();
DiagnosticSettingsResource settings = new DiagnosticSettingsResource
{
Logs = new List <LogSettings>(),
Metrics = new List <MetricSettings>(),
EventHubName = eventHubName,
EventHubAuthorizationRuleId = eventHubAuthorizationRuleId,
WorkspaceId = workspaceId
};
try
{
IList <DiagnosticSettingsCategoryResource> supportedCategories =
client.DiagnosticSettingsCategory.ListAsync(resoureUri).Result.Value;
if (supportedCategories != null)
{
foreach (DiagnosticSettingsCategoryResource category in supportedCategories)
{
if (category.CategoryType == CategoryType.Metrics)
{
settings.Metrics.Add(new MetricSettings(false, null, category.Name));
}
else
{
settings.Logs.Add(
new LogSettings(
string.Equals(category.Name, categoryName),
category.Name));
}
}
}
}
catch (AggregateException ex)
{
if (!(ex.InnerException is ErrorResponseException ex1) ||
ex1.Response.StatusCode != System.Net.HttpStatusCode.NotFound)
{
throw ex.InnerException ?? ex;
}
}
if (!settings.Logs.Any(l => string.Equals(l.Category, categoryName)))
{
settings.Logs.Add(new LogSettings(true, categoryName));
}
return(client.DiagnosticSettings.CreateOrUpdateAsync(
resoureUri, settings, settingsName).Result);
}
private bool SetAuditCategoryState(SqlAuditAdapter adapter, DiagnosticSettingsResource settings, bool isEenabled)
{
var log = settings?.Logs?.FirstOrDefault(l => string.Equals(l.Category, DefinitionsCommon.SQLSecurityAuditCategory));
if (log != null)
{
log.Enabled = isEenabled;
}
return(adapter.UpdateDiagnosticSettings(settings, this));
}
protected override void ProcessRecordInternal()
{
// Temporary service name constant provided for backwards compatibility
DiagnosticSettingsResource result = this.MonitorManagementClient.DiagnosticSettings.Get(
resourceUri: this.ResourceId,
name: string.IsNullOrWhiteSpace(this.Name) ? SetAzureRmDiagnosticSettingCommand.TempServiceName : this.Name);
var psResult = new PSServiceDiagnosticSettings(result);
WriteObject(psResult);
}
public void SetSomeCategories()
{
cmdlet.Category = new List <string> {
"TestCategory1"
};
cmdlet.Enabled = false;
cmdlet.MyInvocation.BoundParameters[SetAzureRmDiagnosticSettingCommand.EnabledParamName] = false;
cmdlet.ExecuteCmdlet();
DiagnosticSettingsResource expectedSettings = GetDefaultSetting();
expectedSettings.Logs[0].Enabled = false;
VerifyCalledOnce();
VerifySettings(expectedSettings, this.calledSettings, suffix: "#1");
// Testing the new categories must be known before the cmdlet can add them
expectedSettings.Logs.Add(
new LogSettings()
{
Category = "TestCategory3",
RetentionPolicy = new RetentionPolicy
{
Days = 0,
Enabled = false
}
});
cmdlet.Category = new List <string> {
"TestCategory3"
};
cmdlet.Enabled = false;
cmdlet.MyInvocation.BoundParameters[SetAzureRmDiagnosticSettingCommand.EnabledParamName] = false;
cmdlet.ExecuteCmdlet();
// Testing the new metric categories must be known before the cmdlet can add them
expectedSettings.Metrics[0].Enabled = false;
cmdlet.Category = null;
cmdlet.MetricCategory = new List <string> {
"MetricCat1"
};
cmdlet.Enabled = false;
cmdlet.MyInvocation.BoundParameters[SetAzureRmDiagnosticSettingCommand.EnabledParamName] = false;
cmdlet.ExecuteCmdlet();
VerifySettings(expectedSettings, this.calledSettings, suffix: "#2");
// Testing the new categories must be known before the cmdlet can add them
cmdlet.MetricCategory = new List <string> {
"MetricCat3"
};
cmdlet.Enabled = false;
cmdlet.MyInvocation.BoundParameters[SetAzureRmDiagnosticSettingCommand.EnabledParamName] = false;
cmdlet.ExecuteCmdlet();
}
private void ChangeWhenDiagnosticSettingsExist(SqlAuditAdapter adapter, DiagnosticSettingsResource settings)
{
if (SqlAuditAdapter.IsAnotherCategoryEnabled(settings))
{
ChangeWhenMultipleCategoriesAreEnabled(adapter, settings);
}
else
{
ChangeWhenOnlyAuditCategoryIsEnabled(adapter, settings);
}
}