public async Task <IEnumerable <RoleAndDescription> > GetRolesAsync(AvailableRolesOptions?options = null)
{
options ??= AvailableRolesOptions.Default;
var uri = GetRolesUri();
_logger.LogInformation("Attempting to get all available roles - {uri}", _redactor.MetaData(uri));
try
{
// get roles
var result = await _client.GetAsync(uri, options.TokenValue).ConfigureAwait(false);
result.EnsureSuccessStatusCode();
// get roles from result
var json = JArray.Parse(await result.Content.ReadAsStringAsync().ConfigureAwait(false));
return(json.Select(RoleAndDescription.FromJson));
}
catch (Exception exception)
{
_logger.LogError(exception, "Error trying to get all available roles - {uri}", _redactor.SystemData(uri));
throw;
}
}
public async Task CreateDataverseAsync(string dataverseName, CreateAnalyticsDataverseOptions?options = null)
{
options ??= new CreateAnalyticsDataverseOptions();
_logger.LogInformation("Attempting to create dataverse with name {dataverseName}",
_redactor.MetaData(dataverseName));
try
{
if (string.IsNullOrWhiteSpace(dataverseName))
{
throw new InvalidArgumentException("dataverseName is a required parameter");
}
var ignoreStr = options.IgnoreIfExistsValue ? " IF NOT EXISTS" : string.Empty;
var statement = $"CREATE DATAVERSE `{dataverseName}`{ignoreStr}";
await _client
.QueryAsync <dynamic>(statement, queryOptions => queryOptions.CancellationToken(options.TokenValue))
.ConfigureAwait(false);
}
catch (DataverseExistsException)
{
_logger.LogError("Failed to create dataverse with name {dataverseName} because it already exists.",
_redactor.MetaData(dataverseName));
throw;
}
catch (Exception exception)
{
_logger.LogError(exception, "Failed to create dataverse with name {dataverseName}",
_redactor.MetaData(dataverseName));
throw;
}
}
public async Task BuildDeferredIndexesAsync(string bucketName, BuildDeferredQueryIndexOptions?options = null)
{
options ??= BuildDeferredQueryIndexOptions.Default;
_logger.LogInformation("Attempting to build deferred query indexes on bucket {bucketName}",
_redactor.MetaData(bucketName));
try
{
var indexes = await this.GetAllIndexesAsync(bucketName,
queryOptions => queryOptions.CancellationToken(options.TokenValue)
).ConfigureAwait(false);
var tasks = new List <Task>();
foreach (var index in indexes.Where(i => i.State == "pending" || i.State == "deferred"))
{
var statement = $"BUILD INDEX ON {bucketName}({index.Name}) USING GSI;";
tasks.Add(_queryClient.QueryAsync <dynamic>(statement,
queryOptions => queryOptions.CancellationToken(options.TokenValue)
));
}
await Task.WhenAll(tasks).ConfigureAwait(false);
}
catch (Exception exception)
{
_logger.LogError(exception, "Error trying to build deferred query indexes on {bucketName}",
_redactor.MetaData(bucketName));
throw;
}
}
public async Task AllowQueryingAsync(string indexName, AllowQueryingSearchIndexOptions?options = null)
{
options ??= AllowQueryingSearchIndexOptions.Default;
var baseUri = GetQueryControlUri(indexName, true);
_logger.LogInformation("Trying to allow querying for index with name {indexName} - {baseUri}",
_redactor.MetaData(indexName), _redactor.SystemData(baseUri));
try
{
var result = await _client.PostAsync(baseUri, null, options.TokenValue).ConfigureAwait(false);
if (result.StatusCode == HttpStatusCode.NotFound)
{
throw new SearchIndexNotFound(indexName);
}
result.EnsureSuccessStatusCode();
}
catch (Exception exception)
{
_logger.LogError(exception, "Failed to allow querying for index with name {indexName} - {baseUri}",
_redactor.MetaData(indexName), _redactor.SystemData(baseUri));
throw;
}
}
public async Task CreateBucketAsync(BucketSettings settings, CreateBucketOptions?options = null)
{
options ??= new CreateBucketOptions();
var uri = GetUri();
_logger.LogInformation("Attempting to create bucket with name {settings.Name} - {uri}",
_redactor.MetaData(settings.Name), _redactor.SystemData(uri));
try
{
// create bucket
var content = new FormUrlEncodedContent(GetBucketSettingAsFormValues(settings));
var result = await _client.PostAsync(uri, content, options.TokenValue).ConfigureAwait(false);
if (result.StatusCode == HttpStatusCode.BadRequest)
{
var json = await result.Content.ReadAsStringAsync().ConfigureAwait(false);
if (json.IndexOf("Bucket with given name already exists", StringComparison.InvariantCultureIgnoreCase) >= 0)
{
throw new BucketExistsException(settings.Name);
}
}
result.EnsureSuccessStatusCode();
}
catch (BucketExistsException)
{
_logger.LogError("Failed to create bucket with name {settings.Name} because it already exists",
_redactor.MetaData(settings.Name));
throw;
}
catch (Exception exception)
{
_logger.LogError(exception, "Failed to create bucket with name {settings.Name} - {uri}",
_redactor.MetaData(settings.Name), _redactor.SystemData(uri));
throw;
}
}
public async Task <DesignDocument> GetDesignDocumentAsync(string designDocName, DesignDocumentNamespace @namespace, GetDesignDocumentOptions?options = null)
{
options ??= GetDesignDocumentOptions.Default;
var uri = GetUri(designDocName, @namespace);
_logger.LogInformation("Attempting to get design document {_bucketName}/{designDocName} - {uri}",
_redactor.MetaData(_bucketName), _redactor.MetaData(designDocName), _redactor.SystemData(uri));
try
{
using var httpClient = _httpClientFactory.Create();
var result = await httpClient.GetAsync(uri, options.TokenValue).ConfigureAwait(false);
if (result.StatusCode == HttpStatusCode.NotFound)
{
throw new DesignDocumentNotFoundException(_bucketName, designDocName);
}
result.EnsureSuccessStatusCode();
var content = await result.Content.ReadAsStringAsync().ConfigureAwait(false);
var designDocument = JsonConvert.DeserializeObject <DesignDocument>(content);
designDocument !.Name = designDocName;
return(designDocument);
}
catch (Exception exception)
{
_logger.LogError(exception, "Failed to get design document {_bucketName}/{designDocName} - {uri}",
_redactor.MetaData(_bucketName), _redactor.MetaData(designDocName), _redactor.SystemData(uri));
throw;
}
}
public async Task CreateBucketAsync(BucketSettings settings, CreateBucketOptions?options = null)
{
options ??= new CreateBucketOptions();
var uri = GetUri();
_logger.LogInformation("Attempting to create bucket with name {settings.Name} - {uri}",
_redactor.MetaData(settings.Name), _redactor.SystemData(uri));
try
{
// create bucket
var content = new FormUrlEncodedContent(settings !.ToFormValues());
using var httpClient = _httpClientFactory.Create();
var result = await httpClient.PostAsync(uri, content, options.TokenValue).ConfigureAwait(false);
if (result.IsSuccessStatusCode)
{
return;
}
var body = await result.Content.ReadAsStringAsync().ConfigureAwait(false);
var ctx = new ManagementErrorContext
{
HttpStatus = result.StatusCode,
Message = body,
Statement = uri.ToString()
};
//Throw specific exception if a rate limiting exception is thrown.
result.ThrowIfRateLimitingError(body, ctx);
if (result.StatusCode == HttpStatusCode.BadRequest)
{
if (body.IndexOf("Bucket with given name already exists",
StringComparison.InvariantCultureIgnoreCase) >= 0)
{
throw new BucketExistsException(settings.Name);
}
}
//Throw any other error cases
result.ThrowOnError(ctx);
}
catch (BucketExistsException)
{
_logger.LogError("Failed to create bucket with name {settings.Name} because it already exists",
_redactor.MetaData(settings.Name));
throw;
}
catch (Exception exception)
{
_logger.LogError(exception, "Failed to create bucket with name {settings.Name} - {uri}",
_redactor.MetaData(settings.Name), _redactor.SystemData(uri));
throw;
}
}
public async Task CreateDataverseAsync(string dataverseName, CreateAnalyticsDataverseOptions?options = null)
{
options ??= new CreateAnalyticsDataverseOptions();
_logger.LogInformation("Attempting to create dataverse with name {dataverseName}",
_redactor.MetaData(dataverseName));
try
{
dataverseName = UncompoundName(dataverseName);
var ignoreStr = options.IgnoreIfExistsValue ? " IF NOT EXISTS" : string.Empty;
var statement = $"CREATE DATAVERSE {dataverseName}{ignoreStr}";
await _client
.QueryAsync <dynamic>(statement, options.CreateAnalyticsOptions())
.ConfigureAwait(false);
}
catch (DataverseExistsException)
{
_logger.LogError("Failed to create dataverse with name {dataverseName} because it already exists.",
_redactor.MetaData(dataverseName));
throw;
}
catch (Exception exception)
{
_logger.LogError(exception, "Failed to create dataverse with name {dataverseName}",
_redactor.MetaData(dataverseName));
throw;
}
}
