public static List<NewsBase> SearchList(string nid) { string espath = ConfigurationManager.AppSettings["ESPath"].ToString(); string indexname = ConfigurationManager.AppSettings["IndexName"].ToString(); string typename = ConfigurationManager.AppSettings["TypeName"].ToString(); var node = new Uri(espath); var settings = new ConnectionSettings(node); var client = new ElasticClient(settings); //keyword = String.Format("*{0}*", keyword); var searchResults = client.Search<NewsBase>(s => s .Index(indexname) .Type(typename) .Query(q => q.QueryString(qs => qs.Query(nid).DefaultOperator(Operator.And))) .Sort(st => st.OnField(f => f.newsid).Order(SortOrder.Descending)) /*按ID排序,id为数字,排序正常*/ //.Sort(st=>st.OnField(f=>f.PubDate.Suffix("sort")).Descending()) /*按时间排序,时间格式,排序bug;中文字符串bug*/ .From(0) .Size(1) ); List<NewsBase> eslist = new List<NewsBase>(searchResults.Documents); //foreach (var data in searchResults.Documents) //{ // eslist.Add(data); //} return eslist; }
public void Init() { var stream = GetValidStream(); var options = new CredentialProfileOptions { AccessKey = System.Environment.GetEnvironmentVariable("AWSACCESSKEY"), SecretKey = System.Environment.GetEnvironmentVariable("AWSSECRET") }; var profile = new Amazon.Runtime.CredentialManagement.CredentialProfile("basic_profile", options); var netSDKFile = new NetSDKCredentialsFile(); var region = Amazon.RegionEndpoint.GetBySystemName(stream.AwsRegion); var creds = AWSCredentialsFactory.GetAWSCredentials(profile, netSDKFile); var connection = new AwsHttpConnection(creds, region); var pool = new SingleNodeConnectionPool(new Uri(stream.ElasticSearchDomainName)); var config = new Nest.ConnectionSettings(pool, connection); var client = new ElasticClient(config); if (client.Indices.Exists(stream.ElasticSearchIndexName).Exists) { var res = client.Indices.Delete(stream.ElasticSearchIndexName); Console.WriteLine(res.DebugInformation); } }
static void Main(string[] args) { var indexName = "geodocument"; var connectionPool = new Elasticsearch.Net.SniffingConnectionPool(new Uri[] { new Uri("http://localhost:9200") }); var connectionSettings = new Nest.ConnectionSettings(connectionPool); connectionSettings.DefaultIndex(indexName); connectionSettings.DisableDirectStreaming(); var elasticClient = new ElasticClient(connectionSettings); Func <TypeMappingDescriptor <GeoDocument>, ITypeMapping> typeMapping = m => m .Dynamic(false) .Properties(ps => ps .Keyword(k => k .Name(n => n.DocId)) .GeoShape(g => g .PointsOnly(false) .Name(o => o.GeoField))); elasticClient.CreateIndex(new CreateIndexDescriptor(indexName).Mappings(ms => ms.Map(typeMapping))); var polygon = "{\"type\":\"Polygon\",\"coordinates\":[[[5.856956,51.002753],[5.856928,51.002771],[5.856687,51.002853],[5.856956,51.002753]]]}"; var document = new GeoDocument() { DocId = "1", GeoField = JsonConvert.DeserializeObject <object>(polygon), }; var indexResponse = elasticClient.IndexDocument(document); Console.WriteLine(indexResponse.DebugInformation); elasticClient.DeleteIndex(new DeleteIndexRequest(indexName)); Console.ReadKey(); }
private static void ConfigureIdProperty(ConnectionSettings settings) { var assemblies = AppDomain.CurrentDomain.GetAssemblies(); var types = new List<Type>(); foreach (var assembly in assemblies) { try { types.AddRange(assembly.GetTypes()); } catch (ReflectionTypeLoadException exception) { Logger.WriteToLog($"ConfigureIdProperty partialy failed. Assembly={assembly.FullName}",Level.Information,exception); } } types = types.Where(x => typeof(IContent).IsAssignableFrom(x) && !x.IsInterface).ToList(); settings.MapIdPropertyFor<IContent>(x => x.ContentLink); var idProperties = ((IConnectionSettingsValues)settings).IdProperties; var name = idProperties[typeof(IContent)]; foreach (var contentType in types) { if (!idProperties.ContainsKey(contentType)) { ((IConnectionSettingsValues)settings).IdProperties.Add(contentType, name); } } }
public IEnumerable <DataAccess.DataTransferModels.Elastic.TargetDto> Query() { var node = new Uri("http://192.168.1.44:9200"); var settings = new Nest.ConnectionSettings(node).DefaultIndex("my-replica-set.cpatdb.targets"); var client = new ElasticClient(settings); //var searchResponse = client.Search<DataAccess.DataTransferModels.Elastic.TargetDto>(s => s // .Query(q => q // .Bool(b => b // .Must(m => m // .Match(match => match // .Field(f => f.Name == query) // ) // ) // ) // ) //); var searchResponse = client.Search <DataAccess.DataTransferModels.Elastic.TargetDto>(s => s .Query(q => q.MatchAll()) ); var analyticsEntry = new SearchAnalytics() { Index = "targets", searchDate = DateTime.Now }; var analyticsResponse = client.Index <SearchAnalytics>(analyticsEntry, i => i.Index("analytics")); return(searchResponse.Documents.ToList()); }
public BlackListDataManager() { try { var elasticSearchUrl = ConfigurationManager.AppSettings["ElasticStoreConnection"]; var index = ConfigurationManager.AppSettings["EIndex_BlackList"]; _settings = new ConnectionSettings(new Uri(elasticSearchUrl)).SetDefaultIndex(index).PluralizeTypeNames(); _client = new ElasticClient(_settings); var isIndexExist = _client.IndexExists(i => i.Index(index)); if (!isIndexExist.Exists) { _client.CreateIndex(c => c.Index(index)); _settings.SetDefaultIndex(index); _client = new ElasticClient(_settings); } var response = _client.Map<BlockedUser>( h => h.MapFromAttributes(10).Properties(p => p .String(s => s.Name(i => i.ByEmail).Index(FieldIndexOption.NotAnalyzed)) .String(s => s.Name(i => i.ToEmail).Index(FieldIndexOption.NotAnalyzed)) )); IsServerError(response); } catch (Exception ex) { Logger.LogException(ex, _soruce, "BlackListDataManager", Severity.Critical); throw; } }
public Storage(string serverUrl) { var passportIndices = new List<string> { ServiceIndex, UserIndex, ClaimIndex, TenantIndex }; var local = new Uri(serverUrl); var settings = new ConnectionSettings(local).DefaultIndex(DefaultIndex); _client = new ElasticClient(settings); var res = _client.LowLevel.ClusterHealth<object>(); if (res.SuccessOrKnownError) { foreach (var index in passportIndices) { res = _client.LowLevel.IndicesExists<object>(index); if (res.HttpStatusCode != 200) { Console.WriteLine($"{index} Index does not exist - Initialising"); InitialiseIndex(index); } else { Console.WriteLine($"{index} Index is accesible"); } } } else { throw new InvalidOperationException("Elastic search server is not reachable"); } }
public BeerElasticsearch() { string url = WebConfigurationManager.AppSettings["elasticsearch"]; this._node = new Uri(url); this._settings = new ConnectionSettings(_node, defaultIndex: Setting.ElasticSearchIndex); this._client = new ElasticClient(_settings); }
/**== Custom Connection Implementations * * The client abstracts sending the request and creating a response behind `IConnection` * * By default the client will use a WebRequest based version on the desktop CLR (.NET 4.5 and up targets) * and a HttpClient based HttpConnection specifically build for the Core CLR (netstandard 1.6). * * The reason for the split is because WebRequest and ServicePoint are not directly available on netstandard 1.6 * * However the implementation written against WebRequest is the most matured implementation that we weren't ready to it give up. * There are also a couple of important toggles that are easy to set against a `ServicePoint` that we'd have to give up * had we jumped on the `HttpClient` completely. * * Another limitation is that `HttpClient` has no synchronous code paths and supporting that means doing hacky async patches which definitely * need time to bake. * * So why would you ever want to pass your own `IConnection`? Let's look at a couple of examples * */ public void OverrideHow() { var connection = new InMemoryConnection(); var connectionPool = new SingleNodeConnectionPool(new Uri("http://localhost:9200")); var settings = new ConnectionSettings(connectionPool, connection); var client = new ElasticClient(settings); }
public void RebuildIndex(string userId, int? noteId) { if (!string.IsNullOrWhiteSpace(userId)) { var notes = new List<NoteModel>(); if (noteId.HasValue) notes.Add(Repository.GetById(noteId.Value)); else notes = Repository.GetByUserId(userId).ToList(); var settings = new ConnectionSettings(new Uri("http://localhost:9200"), "mapnotes"); var client = new ElasticClient(settings); var indexExists = client.IndexExists("mapnotes"); if (!indexExists.Exists) { client.CreateIndex(descriptor => descriptor.Index("mapnotes") .AddMapping<NoteIndex>(m => m.Properties(p => p.GeoPoint(d => d.Name(f => f.Location).IndexLatLon())))); } foreach (var note in notes) { client.Index(new NoteIndex { Id = note.Id, UserId = note.UserId, Title = note.Title, Location = new Location(note.Latitude, note.Longitude) }); } } }
public IResponse Execute() { // create client connection var node = new Uri(ServerUrl); var conn = new ConnectionSettings(node, this.IndexName); var client = new ElasticClient(conn); // check index name existance var existenceResult = client.GetIndex(i => i.Index(IndexName)); if (existenceResult.ConnectionStatus.Success) { // delete exist index var deleteResult = client.DeleteIndex(i => i.Index(IndexName)); if (!deleteResult.Acknowledged) return deleteResult; } // create index var createResult = client.CreateIndex(i => i.Index(IndexName)); if (!createResult.Acknowledged) return createResult; // set analyzer SetAnalyzers(client); // put mapping var putResult = client.Map<TranslationMemory>(m => m.Index(this.IndexName).MapFromAttributes()); //var putResult = client.Map<ElasticSearchProject>(m => m.Index(this.IndexName)); return putResult; }
public async Task<IEnumerable<Message>> Get(string q, int from, int size) { var url = ConfigurationManager.AppSettings["ES_URL"]; var setting = new ConnectionSettings(new Uri(url)); var client = new ElasticClient(setting); // Parse the search query string[] terms = q.Split(' '); var personTerm = terms.SingleOrDefault(x => x.StartsWith("person:")); if (!string.IsNullOrEmpty(personTerm)) { terms = terms.Except(new string[] { personTerm }).ToArray(); personTerm = personTerm.Replace("person:", string.Empty); } var textTerms = string.Join(" ", terms); var searchResults = await client.SearchAsync<Message>(s => s .AllIndices() .AllTypes() .Size(size) .From(from) .SortAscending(f => f.Date) .Query(qry => (qry.Term("from", personTerm) || qry.Term("to", personTerm)) && qry.Match(m => m .OnField(f => f.Text) .Query(textTerms) .Operator(Operator.And)))); return searchResults.Documents; }
public void PopulateFromConnections(IEnumerable<string> settingNodes) { string lastErrorMessage = null; Exception lastException = null; foreach (var n in settingNodes) { var uri = new Uri(string.Format("http://{0}", n)); var cs = new ConnectionSettings(uri).SetTimeout(2000); var profiledConn = new ProfiledElasticConnection(cs); var cli = new ElasticClient(cs, profiledConn); IResponse response = RefreshFromConnection(cli); // Some implementations are raw if (response == null) return; // All's well with the world if (response.IsValid) return; if (response.ConnectionStatus.Error == null) continue; lastErrorMessage = response.ConnectionStatus.Error.ExceptionMessage; lastException = response.ConnectionStatus.Error.OriginalException; } // Failed to poll all nodes if (lastErrorMessage.HasValue()) { throw new Exception("Failed to poll all elastic nodes for " + GetType().Name + ": " + lastErrorMessage, lastException); } throw new Exception("Failed to poll all elastic nodes for " + GetType().Name); }
/// <summary> /// Provides base <see cref="ElasticClient"/> with profiling features to current <see cref="MiniProfiler"/> session. /// </summary> /// <param name="configuration">Instance of <see cref="ConnectionSettings"/>. Its responses will be handled and pushed to <see cref="MiniProfiler"/></param> public ProfiledElasticClient(ConnectionSettings configuration) : base(configuration) { ProfilerUtils.ExcludeElasticsearchAssemblies(); ProfilerUtils.ApplyConfigurationSettings(configuration); configuration.SetConnectionStatusHandler(response => MiniProfilerElasticsearch.HandleResponse(response, _profiler)); }
static void Main(string[] args) { var context = new ElasticDBEntities(); var artists = context.Artists.ToList(); var node = "http://localhost:9200"; var searchBoxUri = new Uri(node); var settings = new ConnectionSettings(searchBoxUri); //settings.SetDefaultIndex("sample"); var client = new ElasticClient(settings); if (client.IndexExists("store").Exists) { client.DeleteIndex("store"); } //client.CreateIndex("sample"); foreach (var artist in artists) { //var index = client.Index(artist); var index = client.Index(artist, i => i.Index("store").Refresh()); } // Index all documents //client.IndexMany<Artist>(artists); }
public static ConnectionSettings CreateSettings(Func<ConnectionSettings, ConnectionSettings> modifySettings = null, int port = 9200, bool forceInMemory = false) { var defaultSettings = new ConnectionSettings(new SingleNodeConnectionPool(CreateNode(port)), CreateConnection(forceInMemory: forceInMemory)) .SetDefaultIndex("default-index") .PrettyJson() .InferMappingFor<Project>(map => map .IndexName("project") .IdProperty(p => p.Name) ) .InferMappingFor<CommitActivity>(map => map .IndexName("project") .TypeName("commits") ) .InferMappingFor<Developer>(map => map .IndexName("devs") .Ignore(p => p.PrivateValue) .Rename(p => p.OnlineHandle, "nickname") ) //We try and fetch the test name during integration tests when running fiddler to send the name //as the TestMethod header, this allows us to quickly identify which test sent which request .SetGlobalHeaders(new NameValueCollection { { "TestMethod", ExpensiveTestNameForIntegrationTests() } }); var settings = modifySettings != null ? modifySettings(defaultSettings) : defaultSettings; return settings; }
public GameDataManager() { try { var elasticSearchUrl = ConfigurationManager.AppSettings["ElasticStoreConnection"]; var index = ConfigurationManager.AppSettings["EIndex_Game"]; _settings = new ConnectionSettings(new Uri(elasticSearchUrl)).SetDefaultIndex(index).PluralizeTypeNames(); _client = new ElasticClient(_settings); var isIndexExist = _client.IndexExists(i => i.Index(index)); if (!isIndexExist.Exists) { _client.CreateIndex(c => c.Index(index)); _settings.SetDefaultIndex(index); _client = new ElasticClient(_settings); } var response = _client.Map<Game>( h => h.Properties(p => p .String(s => s.Name(i => i.GameId).Index(FieldIndexOption.NotAnalyzed)) .String(s => s.Name(i => i.Status).Index(FieldIndexOption.NotAnalyzed)) .String(s => s.Name(i => i.TurnOfPlayer).Index(FieldIndexOption.NotAnalyzed)) .Object<Winner>(o => o.Name(w => w.Winner).Properties(wp => wp.String(f => f.Name(l => l.FacebookId).Index(FieldIndexOption.NotAnalyzed))) ))); IsServerError(response); } catch (Exception ex) { Logger.LogException(ex, _source, "GameDataManager", Severity.Critical); throw; } }
public ElasticRepo() { var node = new Uri("http://localhost:9200"); var settings = new ConnectionSettings(node, defaultIndex: "restaurant"); var client = new ElasticClient(settings); _Client = client; }
/// <summary> /// C/tor /// </summary> /// <param name="namedLock">The name of the lock to create. REQUIRED</param> /// <param name="client">An instance of an elastic search NEST client. Will be created automatically by default. Use this if connecting to an elastic cluster.</param> /// <param name="indexName">The name of the elastic search index. Default = distributedlocks</param> public ElasticSearchDistributedLock(string namedLock, IElasticClient client = null, string indexName = "distributedlocks") { if (string.IsNullOrEmpty(namedLock)) throw new ArgumentException("namedLock cannot be null or empty"); mIndex = indexName; Name = namedLock; mStopwatch = new Stopwatch(); //Only do this once per process.. if (string.IsNullOrEmpty(mOwner)) { mOwner = BuildOwnerIdentifier(); } //Create a default client if none handed in if (client == null) { var settings = new ConnectionSettings(defaultIndex: mIndex); mClient = new ElasticClient(settings); } else { mClient = client; } }
public void construct_client_with_invalid_hostname() { Assert.Throws<UriFormatException>(() => { var settings = new ConnectionSettings("some mangled hostname", 80); }); }
public void Initialize(string uri = "http://localhost:9200/", bool deleteIndex = false) { _logger.Info("Initialing elastic search with uri: " + uri); var connectionString = new ConnectionSettings( new Uri(uri)) .DefaultIndex(OSM_NAMES_INDEX) .PrettyJson(); _elasticClient = new ElasticClient(connectionString); if (deleteIndex && _elasticClient.IndexExists(OSM_NAMES_INDEX).Exists) { _elasticClient.DeleteIndex(OSM_NAMES_INDEX); } if (deleteIndex && _elasticClient.IndexExists(OSM_HIGHWAYS_INDEX).Exists) { _elasticClient.DeleteIndex(OSM_HIGHWAYS_INDEX); } _elasticClient.CreateIndex(OSM_HIGHWAYS_INDEX, c => c.Mappings( ms => ms.Map<object>(m => m.Properties(ps => ps.GeoShape(g => g.Name("geometry") .Tree(GeoTree.Geohash) .TreeLevels(10) .DistanceErrorPercentage(0.2)))))); _logger.Info("Finished initialing elastic search with uri: " + uri); }
public PostIndexer() { var node = new Uri("http://localhost:9200"); var settings = new ConnectionSettings(node); _client = new ElasticClient(settings); }
public void TestIndexTimeout() { var timeout = 1; var s = new ConnectionSettings(Test.Default.Host, Test.Default.Port, timeout) .SetDefaultIndex(Test.Default.DefaultIndex) .SetMaximumAsyncConnections(Test.Default.MaximumAsyncConnections) .UsePrettyResponses(); var client = new ElasticClient(s); var newProject = new ElasticSearchProject { Name = "COBOLES", //COBOL ES client ? }; var t = client.IndexAsync<ElasticSearchProject>(newProject); t.Wait(1000); var cs = t.Result; Assert.False(cs.Success); Assert.NotNull(cs.Error); Assert.NotNull(cs.Error.OriginalException); Trace.WriteLine(cs.Error.OriginalException); Assert.IsNotNullOrEmpty(cs.Error.ExceptionMessage); Assert.IsTrue(cs.Error.OriginalException is WebException); var we = cs.Error.OriginalException as WebException; Assert.IsTrue(cs.Error.ExceptionMessage.Contains("The request was canceled")); Assert.IsTrue(we.Status == WebExceptionStatus.RequestCanceled); Assert.True(t.IsCompleted, "task did not complete"); Assert.False(t.IsFaulted, "task was faulted, wich means the exception did not cleanly pass to ConnectionStatus"); }
public ElasticClient Client() { var node = new Uri("http://10.128.36.197:9200/"); var settings = new ConnectionSettings(node, defaultIndex: "disk"); return new ElasticClient(settings); }
public static IElasticClient GetClient() { var node = new Uri("http://localhost:9200"); var settings = new ConnectionSettings(node); settings.DefaultIndex("stackoverflow"); return new ElasticClient(settings); }
public async Task Example() { Environment.SetEnvironmentVariable("EVENTSTOREURL", "tcp://*****:*****@"http://localhost:9200"; //Environment.GetEnvironmentVariable("ELASTICSEARCHURL"); Uri node = new Uri(elasticSearchUrl); Nest.ConnectionSettings settings = new Nest.ConnectionSettings(node); settings.DisableDirectStreaming(); ElasticClient elasticClient = new ElasticClient(settings); // We wire up EventFlow with all of our classes. Instead of adding events, // commands, etc. explicitly, we could have used the the simpler // AddDefaults(Assembly) instead. using (var resolver = EventFlowOptions.New .AddEvents(typeof(ExampleEvent)) .AddCommands(typeof(ExampleCommand), typeof(ExampleUpdateCommand)) .AddCommandHandlers(typeof(ExampleCommandHandler), typeof(ExampleUpdateCommandHandler)) .ConfigureEventStorePersistence("tcp://localhost:1113") .ConfigureElasticsearch(() => elasticClient) .UseElasticsearchReadModel <ExampleReadModel>() //.UseInMemoryReadStoreFor<ExampleReadModel>() .CreateResolver()) { for (int i = 0; i < 10; i++) { var rndMagicNum = new Random().Next(); // Create a new identity for our aggregate root var exampleId = ExampleId.New; // Resolve the command bus and use it to publish a command var commandBus = resolver.Resolve <ICommandBus>(); await commandBus.PublishAsync( new ExampleCommand(exampleId, rndMagicNum), CancellationToken.None) .ConfigureAwait(false); await commandBus.PublishAsync( new ExampleUpdateCommand(exampleId, 1), CancellationToken.None) .ConfigureAwait(false); // Resolve the query handler and use the built-in query for fetching // read models by identity to get our read model representing the // state of our aggregate root var queryProcessor = resolver.Resolve <IQueryProcessor>(); var exampleReadModel = await queryProcessor.ProcessAsync( new ReadModelByIdQuery <ExampleReadModel>(exampleId), CancellationToken.None) .ConfigureAwait(false); // Verify that the read model has the expected magic number exampleReadModel.MagicNumber.Should().Be(1); Output.WriteLine(exampleId.Value); } } }
private IConnectionSettingsValues InitialiseConnectionSettings() { var config = _configProvider.Get <ElasticConfig>(); var connectionSettings = new Nest .ConnectionSettings(new SingleNodeConnectionPool(new Uri(config.Url))) .ThrowExceptions(); connectionSettings.BasicAuthentication(config.UserName, config.Password); return(connectionSettings); }
protected static ElasticClient GetESClient(PluginConfig pluginConfig) { using (ConnectionSettings connection = new Nest.ConnectionSettings(new Uri(pluginConfig.ElasticsearchUrl))) { if (pluginConfig.SecurityType == "basic" && pluginConfig.Username != null && pluginConfig.Password != null) { connection.BasicAuthentication(pluginConfig.Username, pluginConfig.Password); } connection.DefaultIndex("active-homeseer-index"); ElasticClient client = new Nest.ElasticClient(connection); return(client); } }
public static ElasticClient CreateEsClient(string host, string indexName) { var uri = new Uri(host); var pool = new Elasticsearch.Net.SingleNodeConnectionPool(uri); var transportsConnectionSettings = new Nest.ConnectionSettings(pool, new Elasticsearch.Net.HttpConnection(), new SerializerFactory((settings, values) => { //settings.Converters.Add(new GeometryConverter()); //settings.Converters.Add(new CoordinateConverter()); })) .DefaultIndex(indexName) .DisableDirectStreaming(); return(new Nest.ElasticClient(transportsConnectionSettings)); }
public static void AddElasticsearch(this IServiceCollection services, IConfiguration configuration) { var url = configuration["elasticsearch:url"]; var defaultIndex = configuration["elasticsearch:index"]; var settings = new Nest.ConnectionSettings(new Uri(url)) .DefaultIndex(defaultIndex) .DefaultMappingFor <News>(m => m .PropertyName(p => p.Id, "id") ); var client = new ElasticClient(settings); services.AddSingleton <IElasticClient>(client); }
public string ListIndices() { var node = new Uri("http://192.168.1.44:9200"); var settings = new Nest.ConnectionSettings(node).DefaultIndex("my-replica-set.cpatdb.targets"); var client = new ElasticClient(settings); var searchResponse = client.Search <DataAccess.DataTransferModels.Elastic.TargetDto>(s => s .Query(q => q.MatchAll()) ); // just using this as a test for now // Call to Elastic, get a list of the indices. return("this is a test"); }
public DataAccess(ICsvReader csvReader, IConfiguration configuration) { this.csvReader = csvReader; this.configuration = configuration; var uri = new Uri(configuration.GetSection("Elastic").GetSection("Host").Value); var pool = new Elasticsearch.Net.SingleNodeConnectionPool(uri); var transportsConnectionSettings = new Nest.ConnectionSettings(pool, new Elasticsearch.Net.HttpConnection(), new SerializerFactory((settings, values) => { //settings.Converters.Add(new GeometryConverter()); //settings.Converters.Add(new CoordinateConverter()); })) .DefaultIndex(configuration.GetSection("Elastic").GetSection("Index").Value) .DisableDirectStreaming(); airportElasticClient = new Nest.ElasticClient(transportsConnectionSettings); }
public static void AddElasticsearchClient(this IServiceCollection services, IConfiguration configuration, string mappingAssemblyName) { var url = configuration[MicroserviceConfigurationVariables.ElasticSearch.SERVER]; var defaultIndex = configuration[MicroserviceConfigurationVariables.ElasticSearch.INDEX]; var user = configuration[MicroserviceConfigurationVariables.ElasticSearch.USERNAME]; var password = configuration[MicroserviceConfigurationVariables.ElasticSearch.PASSWORD]; var settings = new ConnectionSettings(new Uri(url)) .DefaultIndex(defaultIndex) .BasicAuthentication(user, password) .ThrowExceptions(); var client = new ElasticClient(settings); AddElasticsearchMappings(client, mappingAssemblyName); services.AddSingleton(client); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { // Add framework services. services.AddMvc(); services.AddTransient <ISearchIndexBuilder, SearchIndexBuilder>(); services.AddTransient <IBoardGameCsvRowMapper, BoardGameCsvRowMapper>(); services.AddTransient <IBoardGameCsvReader, BoardGameCsvReader>(); services.AddTransient <ISearchResultsMapper, SearchResultsMapper>(); services.AddTransient <ISearcher, Searcher>(); services.AddTransient <IElasticClient>(s => { var node = new Uri("http://localhost:9201"); var settings = new Nest.ConnectionSettings(node); settings.DefaultIndex("games"); return(new ElasticClient(settings)); }); }
private static IElasticClient GetElastic() { var url = Configuration["ElasticConnection"]; var user = Configuration["ElasticUserName"]; var password = Configuration["ElasticPassword"]; var node = new Uri(url); var pool = new SingleNodeConnectionPool(node); var regex = new Regex("([+\\-!\\(\\){}\\[\\]^\"~*?:\\\\\\/>< ]|[&\\|]{2}|AND|OR|NOT)", RegexOptions.Compiled); var settings = new Nest.ConnectionSettings(pool, (builtin, param) => new JsonNetSerializer(builtin, param)) .BasicAuthentication(user, password) .DefaultIndex("eShop") .DefaultFieldNameInferrer(field => regex.Replace(field, "")) .DisableDirectStreaming(); return(new ElasticClient(settings)); }
public void Init() { var stream = GetValidStream(); var connection = new AwsHttpConnection(stream.AWSRegion, new StaticCredentialsProvider(new AwsCredentials { AccessKey = stream.AWSAccessKey, SecretKey = stream.AWSSecretKey })); var pool = new SingleNodeConnectionPool(new Uri(stream.ESDomainName)); var config = new Nest.ConnectionSettings(pool, connection); var client = new ElasticClient(config); if (client.IndexExists(stream.ESIndexName).Exists) { var res = client.DeleteIndex(stream.ESIndexName); Console.WriteLine(res.DebugInformation); } }
protected void lnkbtnImportFile_Click(object sender, EventArgs e) { int success = 0; string APP_PATH = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); DataTable dtProdOrder = new DataTable(); if (fileprodOrder.HasFile) { string fileName = fileprodOrder.FileName; if (Path.GetExtension(fileName) != ".xlsx") { ScriptManager.RegisterStartupScript(this, GetType(), "RecordsTextopenModaladded", "openWarningModal('Please choose a valid excel(.xlsx) file.');", true); return; } else { string savedFileName = ""; if (!Directory.Exists(Server.MapPath("ImportedFiles"))) { Directory.CreateDirectory(Server.MapPath("ImportedFiles")); savedFileName = Server.MapPath("ImportedFiles//" + fileName); } else { savedFileName = Server.MapPath("ImportedFiles//" + fileName); } fileprodOrder.SaveAs(savedFileName); List <TroubleshootingData1> list = GetDataTableFromFile(savedFileName); if (list.Count > 0) { var uris = new Uri(ConfigurationManager.AppSettings["elasticsearchConnString"].ToString()); var settings = new Nest.ConnectionSettings(uris); var client = new ElasticClient(settings); var bulkIndexResponse = client.Bulk(b => b .Index("servicereport2") .IndexMany(list) ); } } } }
private IBulkResponse IndexNews(IEnumerable <NewsArticle> newsArticles) { if (newsArticles == null || !newsArticles.Any()) { return(null); } // Connecting to Elasticsearch string protocol = Settings.GetSetting("ElasticSearch.Protocol", "http"); string host = Settings.GetSetting("ElasticSearch.Host", "elastic.local"); string port = Settings.GetSetting("ElasticSearch.Port", "9200"); var node = new Uri(string.Format("{0}://{1}:{2}", protocol, host, port)); var settings = new Nest.ConnectionSettings(node); var client = new Nest.ElasticClient(settings); // Reindexing items var indexName = Settings.GetSetting("ElasticSearch.ArticlesIndex", "articles-index"); var indexerResponse = client.IndexMany(newsArticles, indexName); return(indexerResponse); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddControllers() .AddNewtonsoftJson(); services.AddSingleton(_ => { var connection = EventStoreConnection.Create("ConnectTo=tcp://admin:changeit@localhost:1113"); connection.ConnectAsync().Wait(); return(connection); }); services.AddTransient <IPostRepository, PostRepository>(); services.AddTransient <IPostQueries, PostQueries>(); services.AddMediatR(Assembly.GetExecutingAssembly()); services.AddSingleton(_ => { var settings = new Nest.ConnectionSettings(new Uri("http://localhost:9200")) .DefaultMappingFor <Application.Models.Post>(m => m .IndexName("posts") ); return(new ElasticClient(settings)); }); }
public static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args) .ConfigureServices((hostContext, services) => { services.AddScoped <IOrcestratorService, OrchestratorService>(); services.AddScoped <IAmqService, AmqService>(); services.AddScoped <IUnitOfWork, UnitOfWork>(); services.AddScoped <ILogService, LogService>(); services.AddScoped <IApiCall, ApiCall>(); services.AddDbContext <MedAppDbContext>(options => options.UseSqlServer("Server = localhost, 1433; Database = TimeScheduel; User ID = SA; Password = Passw0rd;")); services.AddHostedService <Worker>(); var settings = new Nest.ConnectionSettings(new Uri("http://elasticsearch:9200")); services.AddSingleton(settings); services.AddScoped(s => { var connectionSettings = s.GetRequiredService <Nest.ConnectionSettings>(); var client = new ElasticClient(connectionSettings); return(client); }); });
public static IElasticClient ConfigureElastic() { Logger.Info("Setting up Elastic"); var connectionString = ConfigurationManager.ConnectionStrings["Elastic"]; if (connectionString == null) { throw new ArgumentException("No elastic connection string found"); } var data = connectionString.ConnectionString.Split(';'); var url = data.FirstOrDefault(x => x.StartsWith("Url", StringComparison.CurrentCultureIgnoreCase)); if (url == null) { throw new ArgumentException("No URL parameter in elastic connection string"); } var index = data.FirstOrDefault(x => x.StartsWith("DefaultIndex", StringComparison.CurrentCultureIgnoreCase)); if (string.IsNullOrEmpty(index)) { throw new ArgumentException("No DefaultIndex parameter in elastic connection string"); } index = index.Substring(13); var node = new Uri(url.Substring(4)); var pool = new Elasticsearch.Net.SingleNodeConnectionPool(node); var regex = new Regex("([+\\-!\\(\\){}\\[\\]^\"~*?:\\\\\\/>< ]|[&\\|]{2}|AND|OR|NOT)", RegexOptions.Compiled); var settings = new Nest.ConnectionSettings(pool, (_) => new JsonNetSerializer(_)) .DefaultIndex(index) .DefaultTypeNameInferrer(type => type.FullName .Replace("Pulse.Presentation.ServiceStack.", "") .Replace("Pulse.Application.Elastic.", "") .Replace('.', '_') ) .DefaultFieldNameInferrer(field => regex.Replace(field, "")); #if DEBUG settings = settings.DisableDirectStreaming(); #endif var client = new ElasticClient(settings); if (!client.IndexExists(index).Exists) { client.CreateIndex(index, i => i .Settings(s => s .NumberOfShards(8) .NumberOfReplicas(0) .Analysis(analysis => analysis .TokenFilters(f => f.NGram("ngram", d => d.MinGram(1).MaxGram(15))) .Analyzers(a => a .Custom("default_index", t => t.Tokenizer("keyword").Filters(new[] { "standard", "lowercase", "asciifolding", "kstem", "ngram" })) .Custom("suffix", t => t.Tokenizer("keyword").Filters(new[] { "standard", "lowercase", "asciifolding", "reverse" })) ) ))); } return(client); }
public IElasticClient ConfigureElastic() { var connectionString = ConfigurationManager.ConnectionStrings["Elastic"]; if (connectionString == null) { throw new ArgumentException("No elastic connection string found"); } var data = connectionString.ConnectionString.Split(';'); var url = data.FirstOrDefault(x => x.StartsWith("Url", StringComparison.CurrentCultureIgnoreCase)); if (url == null) { throw new ArgumentException("No URL parameter in elastic connection string"); } var index = data.FirstOrDefault(x => x.StartsWith("DefaultIndex", StringComparison.CurrentCultureIgnoreCase)); if (index.IsNullOrEmpty()) { throw new ArgumentException("No DefaultIndex parameter in elastic connection string"); } index = index.Substring(13); var node = new Uri(url.Substring(4)); var settings = new Nest.ConnectionSettings(node); settings.SetDefaultIndex(index); settings.SetDefaultTypeNameInferrer(type => type.FullName.Replace("Demo.Application.ServiceStack.", "").Replace('.', '_')); // Disable camel case field names (need to match out POCO field names) settings.SetDefaultPropertyNameInferrer(field => field); var client = new ElasticClient(settings); if (!client.IndexExists(index).Exists) { client.CreateIndex(index, i => i .Analysis(analysis => analysis .TokenFilters(f => f .Add("ngram", new Nest.NgramTokenFilter { MinGram = 2, MaxGram = 15 }) ) .Analyzers(a => a .Add( "default_index", new Nest.CustomAnalyzer { Tokenizer = "standard", Filter = new[] { "standard", "lowercase", "asciifolding", "kstem", "ngram" } } ) .Add( "suffix", new Nest.CustomAnalyzer { Tokenizer = "keyword", Filter = new[] { "standard", "lowercase", "asciifolding", "reverse" } } ) ) )); } return(client); }
private SearchAdapter() { esconnSetting = new ConnectionSettings( new Uri(ESConnectionSetting.Node), "lt028310"); esClient = new ElasticClient(esconnSetting); }
static void Main(string[] args) { elasticSettings = new ConnectionSettings(new Uri("http://127.0.0.1:9200")) .SetDefaultIndex("people"); client = new ElasticClient(elasticSettings); ///// ** Basic search with QueryString var searchResults = client.Search<Person>(s => s.Query(q => q. QueryString(x => x.Query("toto"). OnField(of => of.LastName)))); foreach (var result in searchResults.Documents) { Console.WriteLine("Found: {0}", result.FirstName + " " + result.LastName); } ///// ** Basic search on Message //var searchResults = client.Search<Person>(s => s.Query(q => q. // QueryString(x => x.Query("brother"). // OnField(of => of.Message). // Operator((Operator.and))))); //foreach (var result in searchResults.Documents) //{ // Console.WriteLine("Found: {0}", result.FirstName + " " + result.LastName); //} Console.ReadKey(); }
[U] public void SearchDoesNotTakeDefaultIndexIntoAccount() { var node = new Uri("http://localhost:9200"); var connectionPool = new SingleNodeConnectionPool(node); var connectionSettings = new ConnectionSettings(connectionPool, connection: new InMemoryConnection()) .DefaultIndex("logstash-*") .DefaultFieldNameInferrer(p => p) .OnRequestCompleted(info => { // info.Uri is /_search/ without the default index // my ES instance throws an error on the .kibana index (@timestamp field not mapped because I sort on @timestamp) }); var client = new ElasticClient(connectionSettings); var response = client.Search<ESLogEvent>(s=>s); response.ApiCall.Uri.AbsolutePath.Should().Be("/logstash-%2A/eslogevent/_search"); response = client.Search<ESLogEvent>(new SearchRequest<ESLogEvent>{ }); response.ApiCall.Uri.AbsolutePath.Should().Be("/logstash-%2A/eslogevent/_search"); response = client.Search<ESLogEvent>(new SearchRequest { }); response.ApiCall.Uri.AbsolutePath.Should().Be("/_search"); }
public static void Main(string[] args) { var node = new Uri("http://localhost:9200"); var settings = new ConnectionSettings(node, "elastic-searcher"); settings.SetDefaultTypeNameInferrer(t => t.Name.ToUpperInvariant()); IElasticClient client = new ElasticClient(settings); IPersonSearch personSearcher = new PersonSearch(client); Utils.IndexItems(client); var value = Console.ReadLine(); int id = Convert.ToInt32(value); if (id != 0) { personSearcher.GetItem<Person>(id); } else { Utils.ClearItems(client); } Console.ReadKey(); }
public ActionResult ReIndexAll() { var documents = db.Documents.ToList(); var uriString = ConfigurationManager.AppSettings["SEARCHBOX_URL"]; var searchBoxUri = new Uri(uriString); var settings = new ConnectionSettings(searchBoxUri); settings.SetDefaultIndex("sample"); var client = new ElasticClient(settings); // delete index if exists at startup if (client.IndexExists("sample").Exists) { client.DeleteIndex("sample"); } // Create a new "sample" index with default settings client.CreateIndex("sample", new IndexSettings()); // Index all documents client.IndexMany<Document>(documents); ViewBag.Message = "Reindexing all database is complete!"; return RedirectToAction("Index"); }
public void Run(string indexName, int port, int numMessages, int bufferSize) { var bulkParms = new SimpleBulkParameters() { Refresh = false }; var settings = new ConnectionSettings("localhost", port) .SetDefaultIndex(indexName); var client = new ElasticClient(settings, new ThriftConnection(settings)); Connect(client, settings); IList<Message> msgBuffer = new List<Message>(bufferSize); var msgGenerator = new MessageGenerator(); foreach (var msg in msgGenerator.Generate(numMessages)) { msgBuffer.Add(msg); // Flush buffer once max size reached if (msgBuffer.Count >= bufferSize) { client.IndexMany(msgBuffer, indexName, bulkParms); msgBuffer.Clear(); Interlocked.Add(ref NumSent, bufferSize); // Output how many messages sent so far if (NumSent % 10000 == 0) { Console.WriteLine("Sent {0:0,0} messages over Thrift", NumSent); } } } }
// GET: Search public ActionResult Index(string r) { var uri = new Uri("https://IlwEAOgvDkuHk3yiB74RhwSs1YC0KCUu:@aniknaemm.east-us.azr.facetflow.io"); var settings = new ConnectionSettings(uri).SetDefaultIndex("indexdem"); var client = new ElasticClient(settings); var result = client.Search<Demotivator>(q => q .Query(f => f .QueryString(t => t.Query(r + "*").OnFields(u => u.Name)) || f .QueryString(t => t.Query(r + "*").OnFields(u => u.Str1))) ); SearchViewModel model = new SearchViewModel(); List<Demotivator> tr = new List<Demotivator>(); foreach (var t in result.Hits) { var sleep = (Demotivator)t.Source; int temp = new int(); if (sleep != null) { tr.Add(sleep); } else { } } model.demotivators = tr; return View(model); }
public LogstashRepo() { var node = new Uri("http://localhost:9200"); var settings = new ConnectionSettings(node, defaultIndex: "logstash-2015.08.18"); var client = new ElasticClient(settings); _client = client; }