private void CreateIndex(string indexName)
{
if (_client.IndexExists(indexName).Exists)
{
return;
}
var indexSettings = new IndexSettings
{
{ "index.store.compress.stored", true },
{ "index.store.compress.tv", true },
{ "index.query.default_field", ElasticSearchFields.Message }
};
IIndicesOperationResponse result = _client.CreateIndex(indexName, indexSettings);
CreateMappings(indexName);
if (!result.OK)
{
throw new ApplicationException(string.Format("Failed to create index: '{0}'. Result: '{1}'", indexName, result.ConnectionStatus.Result));
}
Log.Trace(string.Format("{0}: Index '{1}' i successfully created.", LogContext.LogType, indexName));
}
public ElasticsearchIndexCreationStrategyResult(IEnumerable <IElasticsearchIndexContributor> contributors, bool success, IIndicesOperationResponse indexResponse, Exception exception)
{
Contributors = contributors;
Success = success;
IndexResponse = indexResponse;
Exception = exception;
}
public ElasticsearchIndexCreationStrategyResult(IEnumerable<IElasticsearchIndexContributor> contributors, bool success, IIndicesOperationResponse indexResponse, Exception exception)
{
Contributors = contributors;
Success = success;
IndexResponse = indexResponse;
Exception = exception;
}
public HttpResponseMessage CreateIndex(FormDataCollection postData)
{
SampleConfiguration config = new SampleConfiguration();
esNode = new Uri(config.ElasticsearchServerHost);
string indexName = postData.Get("indexName");
connectionSettings = new ConnectionSettings(esNode, defaultIndex: indexName);
var indexSettings = new IndexSettings();
indexSettings.NumberOfShards = 1;
indexSettings.NumberOfReplicas = 0;
esClient = new ElasticClient(connectionSettings);
IIndicesOperationResponse indexOperationResponse = esClient.CreateIndex(c => c
.Index(indexName)
.InitializeUsing(indexSettings)
.AddMapping <Product>(m => m.MapFromAttributes())
);
if (indexOperationResponse.Acknowledged == true)
{
return(Request.CreateResponse(HttpStatusCode.Created, indexOperationResponse.Acknowledged));
}
else
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, indexOperationResponse.Acknowledged));
}
}
private static void AssertIndexCreateSuccess(IIndicesOperationResponse createResponse)
{
var status = createResponse.ConnectionStatus;
if (!status.Success)
{
if (status.OriginalException != null)
{
throw status.OriginalException;
}
throw new ApplicationException("Error while creating index, " + Encoding.UTF8.GetString(status.ResponseRaw));
}
}
private bool CreateIndex(string indexName)
{
if (client.IndexExists(indexName).Exists)
{
return(true);
}
var indexSettings = new IndexSettings();
indexSettings.Add("index.store.compress.stored", true);
indexSettings.Add("index.store.compress.tv", true);
indexSettings.Add("index.query.default_field", "@message");
IIndicesOperationResponse result = client.CreateIndex(indexName, indexSettings);
CreateMappings(indexName);
if (!result.OK)
{
logger.Error(string.Format("Failed to create index: '{0}'. Result: '{1}' Retrying...", indexName, result.ConnectionStatus.Result));
}
return(result.OK);
}
private void OnCompleted(IEnumerable <IElasticsearchIndexCreationSuccessContributor> contributors, IIndicesOperationResponse indexResponse)
{
foreach (var c in contributors)
{
c.OnSuccess(_client, indexResponse);
}
}
public void ConfigureIndexes(IElasticClient client)
{
foreach (var index in GetIndexes())
{
IIndicesOperationResponse response = null;
int currentVersion = GetAliasVersion(client, index.Name);
var templatedIndex = index as ITemplatedElasticSeachIndex;
if (templatedIndex != null)
{
response = client.PutTemplate(index.VersionedName, template => templatedIndex.CreateTemplate(template).AddAlias(index.Name));
}
else if (!client.IndexExists(index.VersionedName).Exists)
{
response = client.CreateIndex(index.VersionedName, descriptor => index.CreateIndex(descriptor).AddAlias(index.Name));
}
Debug.Assert(response == null || response.IsValid, response?.ServerError != null ? response.ServerError.Error : "An error occurred creating the index or template.");
// Add existing indexes to the alias.
if (!client.AliasExists(index.Name).Exists)
{
if (templatedIndex != null)
{
var indices = client.IndicesStats().Indices.Where(kvp => kvp.Key.StartsWith(index.VersionedName)).Select(kvp => kvp.Key).ToList();
if (indices.Count > 0)
{
var descriptor = new AliasDescriptor();
foreach (string name in indices)
{
descriptor.Add(add => add.Index(name).Alias(index.Name));
}
response = client.Alias(descriptor);
}
}
else
{
response = client.Alias(a => a.Add(add => add.Index(index.VersionedName).Alias(index.Name)));
}
Debug.Assert(response != null && response.IsValid, response?.ServerError != null ? response.ServerError.Error : "An error occurred creating the alias.");
}
// already on current version
if (currentVersion >= index.Version || currentVersion < 1)
{
continue;
}
// upgrade
_lockProvider.TryUsingAsync("reindex", async() => {
await _workItemQueue.EnqueueAsync(new ReindexWorkItem {
OldIndex = String.Concat(index.Name, "-v", currentVersion),
NewIndex = index.VersionedName,
Alias = index.Name,
DeleteOld = true
});
}, TimeSpan.Zero, CancellationToken.None);
}
}
private void OnError(IList <IElasticsearchIndexCreationFailureContributor> contributors, IIndicesOperationResponse response = null, Exception ex = null)
{
foreach (var c in contributors)
{
c.OnFailure(_client, response, ex);
}
}
protected virtual IElasticsearchIndexCreationStrategyResult CreateResult(IList <IElasticsearchIndexContributor> contributors, bool success, IIndicesOperationResponse response, Exception ex)
{
return(new ElasticsearchIndexCreationStrategyResult(contributors, success, response, ex));
}
private IElasticsearchIndexCreationStrategyResult CreateResultCore(IList <IElasticsearchIndexContributor> contributors, IIndicesOperationResponse response, Exception ex)
{
return(CreateResult(contributors, (ex == null && response.IsValid), response, ex));
}
public virtual void ConfigureIndexes(IElasticClient client, IEnumerable <IElasticIndex> indexes = null)
{
if (indexes == null)
{
indexes = GetIndexes();
}
foreach (var idx in indexes)
{
int currentVersion = GetAliasVersion(client, idx.AliasName);
IIndicesOperationResponse response = null;
var templatedIndex = idx as ITemplatedElasticIndex;
if (templatedIndex != null)
{
response = client.PutTemplate(idx.VersionedName, template => templatedIndex.CreateTemplate(template).AddAlias(idx.AliasName));
}
else if (!client.IndexExists(idx.VersionedName).Exists)
{
response = client.CreateIndex(idx.VersionedName, descriptor => idx.CreateIndex(descriptor).AddAlias(idx.AliasName));
}
Debug.Assert(response == null || response.IsValid, response?.ServerError != null ? response.ServerError.Error : "An error occurred creating the index or template.");
// Add existing indexes to the alias.
if (!client.AliasExists(idx.AliasName).Exists)
{
if (templatedIndex != null)
{
var indices = client.IndicesStats().Indices.Where(kvp => kvp.Key.StartsWith(idx.VersionedName)).Select(kvp => kvp.Key).ToList();
if (indices.Count > 0)
{
var descriptor = new AliasDescriptor();
foreach (string name in indices)
{
descriptor.Add(add => add.Index(name).Alias(idx.AliasName));
}
response = client.Alias(descriptor);
}
}
else
{
response = client.Alias(a => a.Add(add => add.Index(idx.VersionedName).Alias(idx.AliasName)));
}
Debug.Assert(response != null && response.IsValid, response?.ServerError != null ? response.ServerError.Error : "An error occurred creating the alias.");
}
// already on current version
if (currentVersion >= idx.Version || currentVersion < 1)
{
continue;
}
var reindexWorkItem = new ReindexWorkItem {
OldIndex = String.Concat(idx.AliasName, "-v", currentVersion),
NewIndex = idx.VersionedName,
Alias = idx.AliasName,
DeleteOld = true,
ParentMaps = idx.GetIndexTypes()
.Select(kvp => new ParentMap {
Type = kvp.Value.Name, ParentPath = kvp.Value.ParentPath
})
.Where(m => !String.IsNullOrEmpty(m.ParentPath))
.ToList()
};
bool isReindexing = _lockProvider.IsLockedAsync(String.Concat("reindex:", reindexWorkItem.Alias, reindexWorkItem.OldIndex, reindexWorkItem.NewIndex)).Result;
// already reindexing
if (isReindexing)
{
continue;
}
// enqueue reindex to new version
_lockProvider.TryUsingAsync("enqueue-reindex", () => _workItemQueue.EnqueueAsync(reindexWorkItem), TimeSpan.Zero, CancellationToken.None).Wait();
}
}
public void OnSuccess(IElasticClient client, IIndicesOperationResponse response)
{
client.Alias(a => a.Add(aa => aa.Alias(client.Infer.DefaultIndex).Index(_indexName)));
}
