public async Task <Response <DatabaseVulnerabilityAssessmentRuleBaseline> > GetAsync(string resourceGroupName, string serverName, string databaseName, VulnerabilityAssessmentName vulnerabilityAssessmentName, string ruleId, VulnerabilityAssessmentPolicyBaselineName baselineName, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (serverName == null)
{
throw new ArgumentNullException(nameof(serverName));
}
if (databaseName == null)
{
throw new ArgumentNullException(nameof(databaseName));
}
if (ruleId == null)
{
throw new ArgumentNullException(nameof(ruleId));
}
using var message = CreateGetRequest(resourceGroupName, serverName, databaseName, vulnerabilityAssessmentName, ruleId, baselineName);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
{
DatabaseVulnerabilityAssessmentRuleBaseline value = default;
using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
value = DatabaseVulnerabilityAssessmentRuleBaseline.DeserializeDatabaseVulnerabilityAssessmentRuleBaseline(document.RootElement);
return(Response.FromValue(value, message.Response));
}
/// <summary>
/// Transforms the given model to its endpoints acceptable structure and sends it to the endpoint
/// </summary>
public void SetVulnerabilityAssessmentRuleBaseline(VulnerabilityAssessmentRuleBaselineModel model, string serverName, string databaseName, ApplyToType applyToType)
{
var ruleBaseline = new DatabaseVulnerabilityAssessmentRuleBaseline()
{
BaselineResults = new List <DatabaseVulnerabilityAssessmentRuleBaselineItem>()
};
foreach (var baselineResult in model.BaselineResult)
{
var ruleBaselineItem = new DatabaseVulnerabilityAssessmentRuleBaselineItem()
{
Result = baselineResult.Result
};
ruleBaseline.BaselineResults.Add(ruleBaselineItem);
}
if (applyToType == ApplyToType.Database)
{
VulnerabilityAssessmentCommunicator.SetDatabaseVulnerabilityAssessmentRuleBaseline(model.ResourceGroupName, serverName,
databaseName, model.RuleId, model.RuleAppliesToMaster, ruleBaseline);
}
else
{
VulnerabilityAssessmentCommunicator.SetManagedDatabaseVulnerabilityAssessmentRuleBaseline(model.ResourceGroupName, serverName,
databaseName, model.RuleId, model.RuleAppliesToMaster, ruleBaseline);
}
}
/// <summary>
/// Transforms the given model to its endpoints acceptable structure and sends it to the endpoint
/// </summary>
public void SetDatabaseVulnerabilityAssessmentRuleBaseline(DatabaseVulnerabilityAssessmentRuleBaselineModel model)
{
var ruleBaseline = new DatabaseVulnerabilityAssessmentRuleBaseline()
{
BaselineResults = new List <DatabaseVulnerabilityAssessmentRuleBaselineItem>()
};
foreach (var baselineResult in model.BaselineResult)
{
var ruleBaselineItem = new DatabaseVulnerabilityAssessmentRuleBaselineItem()
{
Result = baselineResult.Result
};
ruleBaseline.BaselineResults.Add(ruleBaselineItem);
}
VulnerabilityAssessmentCommunicator.SetDatabaseVulnerabilityAssessmentRuleBaseline(model.ResourceGroupName, model.ServerName,
model.DatabaseName, model.RuleId, model.RuleAppliesToMaster, ruleBaseline);
}
private void ValidateBaselineRule(SqlManagementClient sqlClient, ResourceGroup resourceGroup, ManagedInstance managedInstance, string dbName, bool isServerLevelRule)
{
string testRuleId = "VA2031";
var ruleBaselineToSet = new DatabaseVulnerabilityAssessmentRuleBaseline(
new List <DatabaseVulnerabilityAssessmentRuleBaselineItem>()
{
new DatabaseVulnerabilityAssessmentRuleBaselineItem()
{
Result = new string[] { "userA", "SELECT" }
},
new DatabaseVulnerabilityAssessmentRuleBaselineItem()
{
Result = new string[] { "userB", "SELECT" }
}
});
VulnerabilityAssessmentPolicyBaselineName baselineName = isServerLevelRule
? VulnerabilityAssessmentPolicyBaselineName.Master
: VulnerabilityAssessmentPolicyBaselineName.Default;
sqlClient.ManagedDatabaseVulnerabilityAssessmentRuleBaselines.CreateOrUpdate(resourceGroup.Name, managedInstance.Name, dbName, testRuleId, baselineName, ruleBaselineToSet);
// Get baseline
DatabaseVulnerabilityAssessmentRuleBaseline actualBaseline = sqlClient.ManagedDatabaseVulnerabilityAssessmentRuleBaselines.Get(resourceGroup.Name, managedInstance.Name, dbName, testRuleId, baselineName);
Assert.Equal(ruleBaselineToSet.BaselineResults.Count(), actualBaseline.BaselineResults.Count());
SqlManagementTestUtilities.AssertCollection(ruleBaselineToSet.BaselineResults[0].Result, actualBaseline.BaselineResults[0].Result);
SqlManagementTestUtilities.AssertCollection(ruleBaselineToSet.BaselineResults[1].Result, actualBaseline.BaselineResults[1].Result);
// Delete baseline
sqlClient.ManagedDatabaseVulnerabilityAssessmentRuleBaselines.Delete(resourceGroup.Name, managedInstance.Name, dbName, testRuleId, baselineName);
// Get baseline should fail after deleting the baseline
Assert.Throws <CloudException>(() =>
{
sqlClient.ManagedDatabaseVulnerabilityAssessmentRuleBaselines.Get(resourceGroup.Name, managedInstance.Name, dbName, testRuleId, baselineName);
});
}
public virtual async Task <Response <DatabaseVulnerabilityAssessmentRuleBaseline> > CreateOrUpdateAsync(string resourceGroupName, string managedInstanceName, string databaseName, VulnerabilityAssessmentName vulnerabilityAssessmentName, string ruleId, VulnerabilityAssessmentPolicyBaselineName baselineName, DatabaseVulnerabilityAssessmentRuleBaseline parameters, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("ManagedDatabaseVulnerabilityAssessmentRuleBaselinesOperations.CreateOrUpdate");
scope.Start();
try
{
return(await RestClient.CreateOrUpdateAsync(resourceGroupName, managedInstanceName, databaseName, vulnerabilityAssessmentName, ruleId, baselineName, parameters, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Calls the set Vulnerability Assessment APIs for the database Vulnerability Assessment rule baseline for the given rule in the given database in the given database server in the given resource group
/// </summary>
public void SetDatabaseVulnerabilityAssessmentRuleBaseline(string resourceGroupName, string serverName, string databaseName, string ruleId,
bool ruleAppliesToMaster, DatabaseVulnerabilityAssessmentRuleBaseline parameters)
{
GetCurrentSqlClient().DatabaseVulnerabilityAssessmentRuleBaselines.CreateOrUpdate(resourceGroupName, serverName, databaseName, ruleId,
ruleAppliesToMaster ? VulnerabilityAssessmentPolicyBaselineName.Master : VulnerabilityAssessmentPolicyBaselineName.Default, parameters);
}
/// <summary>
/// Creates or updates a database's vulnerability assessment rule baseline.
/// </summary>
/// <param name='resourceGroupName'>
/// The name of the resource group that contains the resource. You can obtain
/// this value from the Azure Resource Manager API or the portal.
/// </param>
/// <param name='managedInstanceName'>
/// The name of the managed instance.
/// </param>
/// <param name='databaseName'>
/// The name of the database for which the vulnerability assessment rule
/// baseline is defined.
/// </param>
/// <param name='ruleId'>
/// The vulnerability assessment rule ID.
/// </param>
/// <param name='baselineName'>
/// The name of the vulnerability assessment rule baseline (default implies a
/// baseline on a database level rule and master for server level rule).
/// Possible values include: 'master', 'default'
/// </param>
/// <param name='parameters'>
/// The requested rule baseline resource.
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="CloudException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <exception cref="SerializationException">
/// Thrown when unable to deserialize the response
/// </exception>
/// <exception cref="ValidationException">
/// Thrown when a required parameter is null
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// Thrown when a required parameter is null
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <AzureOperationResponse <DatabaseVulnerabilityAssessmentRuleBaseline> > CreateOrUpdateWithHttpMessagesAsync(string resourceGroupName, string managedInstanceName, string databaseName, string ruleId, VulnerabilityAssessmentPolicyBaselineName baselineName, DatabaseVulnerabilityAssessmentRuleBaseline parameters, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (resourceGroupName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "resourceGroupName");
}
if (managedInstanceName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "managedInstanceName");
}
if (databaseName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "databaseName");
}
if (ruleId == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "ruleId");
}
if (parameters == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "parameters");
}
if (parameters != null)
{
parameters.Validate();
}
if (Client.SubscriptionId == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.SubscriptionId");
}
string vulnerabilityAssessmentName = "default";
string apiVersion = "2020-11-01-preview";
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("resourceGroupName", resourceGroupName);
tracingParameters.Add("managedInstanceName", managedInstanceName);
tracingParameters.Add("databaseName", databaseName);
tracingParameters.Add("vulnerabilityAssessmentName", vulnerabilityAssessmentName);
tracingParameters.Add("ruleId", ruleId);
tracingParameters.Add("baselineName", baselineName);
tracingParameters.Add("parameters", parameters);
tracingParameters.Add("apiVersion", apiVersion);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "CreateOrUpdate", tracingParameters);
}
// Construct URL
var _baseUrl = Client.BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/managedInstances/{managedInstanceName}/databases/{databaseName}/vulnerabilityAssessments/{vulnerabilityAssessmentName}/rules/{ruleId}/baselines/{baselineName}").ToString();
_url = _url.Replace("{resourceGroupName}", System.Uri.EscapeDataString(resourceGroupName));
_url = _url.Replace("{managedInstanceName}", System.Uri.EscapeDataString(managedInstanceName));
_url = _url.Replace("{databaseName}", System.Uri.EscapeDataString(databaseName));
_url = _url.Replace("{vulnerabilityAssessmentName}", System.Uri.EscapeDataString(vulnerabilityAssessmentName));
_url = _url.Replace("{ruleId}", System.Uri.EscapeDataString(ruleId));
_url = _url.Replace("{baselineName}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.SerializeObject(baselineName, Client.SerializationSettings).Trim('"')));
_url = _url.Replace("{subscriptionId}", System.Uri.EscapeDataString(Client.SubscriptionId));
List <string> _queryParameters = new List <string>();
if (apiVersion != null)
{
_queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(apiVersion)));
}
if (_queryParameters.Count > 0)
{
_url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters);
}
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("PUT");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (Client.GenerateClientRequestId != null && Client.GenerateClientRequestId.Value)
{
_httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString());
}
if (Client.AcceptLanguage != null)
{
if (_httpRequest.Headers.Contains("accept-language"))
{
_httpRequest.Headers.Remove("accept-language");
}
_httpRequest.Headers.TryAddWithoutValidation("accept-language", Client.AcceptLanguage);
}
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (parameters != null)
{
_requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(parameters, Client.SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
}
// Set Credentials
if (Client.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200)
{
var ex = new CloudException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
try
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
CloudError _errorBody = Rest.Serialization.SafeJsonConvert.DeserializeObject <CloudError>(_responseContent, Client.DeserializationSettings);
if (_errorBody != null)
{
ex = new CloudException(_errorBody.Message);
ex.Body = _errorBody;
}
}
catch (JsonException)
{
// Ignore the exception
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_httpResponse.Headers.Contains("x-ms-request-id"))
{
ex.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new AzureOperationResponse <DatabaseVulnerabilityAssessmentRuleBaseline>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
if (_httpResponse.Headers.Contains("x-ms-request-id"))
{
_result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
// Deserialize Response
if ((int)_statusCode == 200)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject <DatabaseVulnerabilityAssessmentRuleBaseline>(_responseContent, Client.DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
/// <summary>
/// Creates or updates a database's vulnerability assessment rule baseline.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group that contains the resource. You can obtain
/// this value from the Azure Resource Manager API or the portal.
/// </param>
/// <param name='serverName'>
/// The name of the server.
/// </param>
/// <param name='databaseName'>
/// The name of the database for which the vulnerability assessment rule
/// baseline is defined.
/// </param>
/// <param name='ruleId'>
/// The vulnerability assessment rule ID.
/// </param>
/// <param name='parameters'>
/// The requested rule baseline resource.
/// </param>
public static DatabaseVulnerabilityAssessmentRuleBaseline CreateOrUpdate(this IDatabaseVulnerabilityAssessmentRuleBaselinesOperations operations, string resourceGroupName, string serverName, string databaseName, string ruleId, DatabaseVulnerabilityAssessmentRuleBaseline parameters)
{
return(CreateOrUpdate(operations, resourceGroupName, serverName, databaseName, ruleId, VulnerabilityAssessmentPolicyBaselineName.Default, parameters));
}
/// <summary>
/// Creates or updates a database's vulnerability assessment rule baseline.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group that contains the resource. You can obtain
/// this value from the Azure Resource Manager API or the portal.
/// </param>
/// <param name='serverName'>
/// The name of the server.
/// </param>
/// <param name='databaseName'>
/// The name of the database for which the vulnerability assessment rule
/// baseline is defined.
/// </param>
/// <param name='ruleId'>
/// The vulnerability assessment rule ID.
/// </param>
/// <param name='parameters'>
/// The requested rule baseline resource.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <DatabaseVulnerabilityAssessmentRuleBaseline> CreateOrUpdateAsync(this IDatabaseVulnerabilityAssessmentRuleBaselinesOperations operations, string resourceGroupName, string serverName, string databaseName, string ruleId, DatabaseVulnerabilityAssessmentRuleBaseline parameters, CancellationToken cancellationToken = default(CancellationToken))
{
return(await CreateOrUpdateAsync(operations, resourceGroupName, serverName, databaseName, ruleId, VulnerabilityAssessmentPolicyBaselineName.Default, parameters, cancellationToken).ConfigureAwait(false));
}
/// <summary>
/// Creates or updates a database's vulnerability assessment rule baseline.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group that contains the resource. You can obtain
/// this value from the Azure Resource Manager API or the portal.
/// </param>
/// <param name='serverName'>
/// The name of the server.
/// </param>
/// <param name='databaseName'>
/// The name of the database for which the vulnerability assessment rule
/// baseline is defined.
/// </param>
/// <param name='ruleId'>
/// The vulnerability assessment rule ID.
/// </param>
/// <param name='baselineName'>
/// The name of the vulnerability assessment rule baseline (default implies a
/// baseline on a database level rule and master for server level rule).
/// Possible values include: 'master', 'default'
/// </param>
/// <param name='parameters'>
/// The requested rule baseline resource.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <DatabaseVulnerabilityAssessmentRuleBaseline> CreateOrUpdateAsync(this IDatabaseVulnerabilityAssessmentRuleBaselinesOperations operations, string resourceGroupName, string serverName, string databaseName, string ruleId, VulnerabilityAssessmentPolicyBaselineName baselineName, DatabaseVulnerabilityAssessmentRuleBaseline parameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, serverName, databaseName, ruleId, baselineName, parameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Creates or updates a database's vulnerability assessment rule baseline.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group that contains the resource. You can obtain
/// this value from the Azure Resource Manager API or the portal.
/// </param>
/// <param name='serverName'>
/// The name of the server.
/// </param>
/// <param name='databaseName'>
/// The name of the database for which the vulnerability assessment rule
/// baseline is defined.
/// </param>
/// <param name='ruleId'>
/// The vulnerability assessment rule ID.
/// </param>
/// <param name='baselineName'>
/// The name of the vulnerability assessment rule baseline (default implies a
/// baseline on a database level rule and master for server level rule).
/// Possible values include: 'master', 'default'
/// </param>
/// <param name='parameters'>
/// The requested rule baseline resource.
/// </param>
public static DatabaseVulnerabilityAssessmentRuleBaseline CreateOrUpdate(this IDatabaseVulnerabilityAssessmentRuleBaselinesOperations operations, string resourceGroupName, string serverName, string databaseName, string ruleId, VulnerabilityAssessmentPolicyBaselineName baselineName, DatabaseVulnerabilityAssessmentRuleBaseline parameters)
{
return(operations.CreateOrUpdateAsync(resourceGroupName, serverName, databaseName, ruleId, baselineName, parameters).GetAwaiter().GetResult());
}
public virtual Response <DatabaseVulnerabilityAssessmentRuleBaseline> CreateOrUpdate(string resourceGroupName, string serverName, string databaseName, VulnerabilityAssessmentName vulnerabilityAssessmentName, string ruleId, VulnerabilityAssessmentPolicyBaselineName baselineName, DatabaseVulnerabilityAssessmentRuleBaseline parameters, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("DatabaseVulnerabilityAssessmentRuleBaselinesOperations.CreateOrUpdate");
scope.Start();
try
{
return(RestClient.CreateOrUpdate(resourceGroupName, serverName, databaseName, vulnerabilityAssessmentName, ruleId, baselineName, parameters, cancellationToken));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
