private void ConfigureDependencies(IServiceCollection services)
{
//see: https://github.com/aspnet/Hosting/issues/793
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddSingleton(sp => sp.GetService <IOptions <SiteConfig> >().Value);
services.AddTransient(sp => ElasticClientFactory.GetClient(sp));
// Add DependencyAttribute (ScopedDependency, SingletonDependency, TransientDependency) to the class in order to be scanned
services.ConfigureAttributedDependencies();
{
var options = ConfigurationOptions.Parse(Configuration["SlambyApi:Redis:Configuration"]);
//HACK: https://github.com/dotnet/corefx/issues/8768
//this should be removed when https://github.com/dotnet/corefx/issues/11564 is closed
options = RedisDnsHelper.CorrectOption(options);
if (options == null)
{
Log.Logger.Error("Can't resolve the name of the Redis server!");
return;
}
services.AddSingleton(RedisDnsHelper.CorrectOption(options));
services.AddSingleton <ConnectionMultiplexer>(sp => ConnectionMultiplexer.Connect(sp.GetService <ConfigurationOptions>()));
}
}
public void Configure(IWebJobsBuilder builder)
{
string environment = Environment.GetEnvironmentVariable("AZURE_FUNCTIONS_ENVIRONMENT");
builder.Services.AddSingleton(_ => ElasticClientFactory.Create());
builder.Services.AddSingleton(_ => DocumentClientFactory.Create());
builder.Services.AddSingleton <IAttemptService, AttemptService>();
builder.Services.AddSingleton <IZoneService, ZoneService>();
builder.Services.AddSingleton <IToyDistributionProblemRepository, ToyDistributionProblemRepository>();
if (!string.Equals(environment, "Development", StringComparison.OrdinalIgnoreCase))
{
builder.Services.AddLogging(loggingBuilder => loggingBuilder
.AddSerilog(new LoggerConfiguration()
.WriteTo
.Elasticsearch(new ElasticsearchSinkOptions(ElasticClientFactory.Url)
{
AutoRegisterTemplate = true,
AutoRegisterTemplateVersion = AutoRegisterTemplateVersion.ESv7,
MinimumLogEventLevel = LogEventLevel.Information,
ModifyConnectionSettings = connection =>
{
connection.BasicAuthentication(ElasticClientFactory.Username, ElasticClientFactory.Password);
return(connection);
}
})
.CreateLogger()));
}
}
protected override void When()
{
var conf = new ElasticClientConfiguration(new Uri(ElasticUrl), ElasticUsername, ElasticPassword);
_factory = conf.CreateClientFactory() as ElasticClientFactory;
_factory.CreateClient();
}
public static void GetInstance_Should_Return_Write_Instance()
{
// arrange
ElasticsearchOptions options = new ElasticsearchOptions
{
DefaultIndexName = "index-d",
DefaultTypeName = "type-d",
Environment = "my-env",
MaximumRetries = 4,
ReadUrl = "http://esread:9200",
WriteUrl = "http://eswrite:9200",
TimeoutInSeconds = 30
};
// act
var client = ElasticClientFactory.GetInstance(ConnectionMode.Write, options);
// assert
Assert.Equal("type-d", client.ConnectionSettings.DefaultTypeName);
Assert.Equal("index-d", client.ConnectionSettings.DefaultIndex);
Assert.Equal(30, client.ConnectionSettings.RequestTimeout.TotalSeconds);
Assert.Equal(4, client.ConnectionSettings.MaxRetries);
Assert.Equal("my-env", client.ConnectionSettings.Headers.Get("Environment"));
Assert.Equal("http://eswrite:9200/", client.ConnectionSettings.ConnectionPool.Nodes.First().Uri.AbsoluteUri);
}
protected BaseElasticsearch(
ConnectionMode mode,
ElasticsearchOptions options,
Func <string, T, string> generateIndexName)
{
this.ElasticClient = ElasticClientFactory.GetInstance(mode, options);
this.GenerateIndexName = generateIndexName;
this.Options = options;
}
public static void GetInstance_Should_Throws_Exception_When_Options_Is_Null()
{
// arrange
ElasticsearchOptions options = null;
// act & assert
var exception = Assert.Throws <ArgumentNullException>(() =>
ElasticClientFactory.GetInstance(ConnectionMode.Write, options));
}
public static IClientFactory GetClientFactory()
{
var connectionFactory = ConnectionSettingsFactoryHelper.GetHTTPConnection();
var connectionPool = ConnectionSettingsFactoryHelper.GetSingleNodePool();
var settingsProvider = new ConnectionSettingsProvider(connectionFactory, connectionPool);
var connectionManager = new ConnectionManager(settingsProvider);
var clientFactory = new ElasticClientFactory(connectionManager);
return(clientFactory);
}
/// <summary>
/// Configures the identity builder with ElasticIdentity components,
/// and registers dependencies for that component which have not already been
/// registered.
/// </summary>
/// <param name="serverName">
/// The server:port combination which the <see cref="ElasticUserStore"/> will connect to. E.g. localhost:9200
/// </param>
/// <param name="indexName">
/// The index which will contain the user information.
/// </param>
public static IdentityBuilder AddElasticIdentity(
this IdentityBuilder identityBuilder,
string serverName,
string indexName = DEFAULT_INDEX_NAME)
{
var node = new Uri("http://" + serverName.Replace("http://", ""));
IElasticClient elasticClient = ElasticClientFactory.Create(node, indexName);
return(AddElasticIdentity(identityBuilder, elasticClient));
}
public DataSetService(ServiceQuery serviceQuery, IQueryFactory queryFactory,
IndexQuery indexQuery, ElasticClientFactory clientFactory,
ILoggerFactory loggerFactory, IGlobalStoreManager globalStore)
{
GlobalStore = globalStore;
this.clientFactory = clientFactory;
this.indexQuery = indexQuery;
this.queryFactory = queryFactory;
this.serviceQuery = serviceQuery;
this.logger = loggerFactory.CreateLogger <DataSetService>();
}
public DBUpdateService(ElasticClientFactory clientFactory, IndexQuery indexQuery, IQueryFactory queryFactory,
ILoggerFactory loggerFactory, MetadataQuery metadataQuery, ServiceQuery serviceQuery, ProcessQuery processQuery,
ServiceManager serviceManager)
{
this.serviceManager = serviceManager;
this.processQuery = processQuery;
this.serviceQuery = serviceQuery;
this.metadataQuery = metadataQuery;
this.queryFactory = queryFactory;
this.indexQuery = indexQuery;
this.clientFactory = clientFactory;
this.logger = loggerFactory.CreateLogger <DBUpdateService>();
}
public StartupService(SiteConfig siteConfig, ILogger <StartupService> logger,
ElasticClientFactory elasticClientFactory, DataSetService dataSetService,
DBUpdateService dbUpdateService, MachineResourceService machineResourceService,
ServiceManager serviceManager, ILicenseManager licenseManager)
{
this.licenseManager = licenseManager;
this.serviceManager = serviceManager;
this.dbUpdateService = dbUpdateService;
this.dataSetService = dataSetService;
this.logger = logger;
this.elasticClientFactory = elasticClientFactory;
this.siteConfig = siteConfig;
this.machineResourceService = machineResourceService;
}
public ElasticUserStoreTest()
{
_indexName = $"{nameof(ElasticUserStoreTest)}_{Guid.NewGuid()}".ToLowerInvariant();
var node = new Uri("http://localhost:9200");
_elasticClient = ElasticClientFactory.Create(node, _indexName);
_store = new ElasticUserStore(_elasticClient);
// the generic store refreshes immediately
var store = new ElasticUserStore <string, ElasticIdentityUser>(_elasticClient);
store.CreateAsync(_user1, CancellationToken.None).GetAwaiter().GetResult();
_elasticClient.Indices.Refresh(_indexName);
}
public void Foo()
{
var elasticClient = ElasticClientFactory.ElasticClient();
elasticClient.Index(
new Employee
{
FirstName = "John",
LastName = "Smith",
Age = 25,
About = "I love to go rock climbing",
Interests = new[] { "sports", "music" }
}, d => d.Index("megacorp").Type("employee"));
elasticClient.Get <Employee>(1);
}
public async Task Can_join_channel()
{
////Arrange
var client = ElasticClientFactory.Create();
var user = TestExtensions.RandomUser();
await new UserService().EnsureUser(user);
////Act
await new ChannelService().Join(user, "global");
////Assert
await client.Indices.RefreshAsync(Indices.Index <UserAccount>());
var userAccount = await new UserService().FindById(user.UserId());
Assert.IsTrue(userAccount.Channels.Contains("global"));
}
protected IntegrationTestsBase()
{
Fixture = new Fixture();
var server = GetSettingsValue("ElasticSearch.ReadModelNodeList", "http://localhost:9200");
var username = GetSettingsValue("ElasticSearch.UserName", "");
var password = GetSettingsValue("ElasticSearch.Password", "");
ElasticClient = ElasticClientFactory.CreateElasticClient(server, username, password);
if (ElasticClient.Indices.Exists(IndexName).Exists)
{
ElasticClient.Indices.Delete(IndexName);
}
ElasticClient.Indices.Create(IndexName, d => d.Settings(descriptor => descriptor).Map(m => m.AutoMap <T>()));
Sut = new ElasticQueryable <T>(ElasticClient, IndexName);
}
private void AddClassesToIoC(IServiceCollection services)
{
services.AddSingleton <IFileReader, FileReader>();
services.AddSingleton <IDeSerializer <Account>, AccountDeSerializer>();
services.AddSingleton <IDeSerializer <Transaction>, TransactionDeSerializer>();
var client = new ElasticClientFactory(Configuration).CreateElasticClient();
services.AddSingleton(client);
services.AddSingleton <IndexCreator <Account> >();
services.AddSingleton <IndexCreator <Transaction> >();
services.AddSingleton <Importer <Account> >();
services.AddSingleton <Importer <Transaction> >();
services.AddSingleton <IAccountQueryCreator, AccountQueryCreator>();
services.AddSingleton <ITransactionQueryCreator, TransactionQueryCreator>();
services.AddSingleton <IAccountSearcher>(p => new AccountSearcher(client,
p.GetService <IAccountQueryCreator>(), _accountIndex));
services.AddSingleton <ITransactionSearcher>(p => new TransactionSearcher(client,
p.GetService <ITransactionQueryCreator>(), _transactionIndex));
}
public async Task Can_join_private_channel()
{
////Arrange
var client = ElasticClientFactory.Create();
var user1 = TestExtensions.RandomUser();
var user2 = TestExtensions.RandomUser();
await new UserService().EnsureUser(user1);
await new UserService().EnsureUser(user2);
////Act
var channel = await new ChannelService().Create(user1, "tester", false, new[] { user1.UserId(), user2.UserId() });
await new ChannelService().Join(user1, channel.Id);
////Assert
await client.Indices.RefreshAsync(Indices.Index <UserAccount>());
var userAccount = await new UserService().FindById(user1.UserId());
Assert.IsTrue(userAccount.Channels.Contains(channel.Id));
}
private static void Main(string[] args)
{
IConfiguration config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
var directoryPath = config.GetValue <string>("DirectoryPath");
var client = new ElasticClientFactory(config).CreateElasticClient();
var queryCreator = new QueryCreator();
var searcher = new Searcher(client, queryCreator, Index);
var consoleView = new ConsoleView();
var controller = new Controller(consoleView, searcher);
if (!IsIndexExisting(Index, client))
{
var indexCreator = new IndexCreator(client);
indexCreator.CreateIndex(Index);
var fileReader = new DocFileReader();
var docCreator = new DocFactory(fileReader);
var importer = new Importer <Doc>(client);
importer.Import(docCreator.GetAllDocuments(directoryPath), Index);
}
controller.Run();
}
public BaseQuery(ElasticClientFactory elasticClientFactory, string indexName, SiteConfig siteConfig)
{
IndexName = indexName;
Client = elasticClientFactory.GetClient(indexName);
SiteConfig = siteConfig;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(options =>
{
//TODO: Think about a more appropriate restriction policy
options.AddPolicy("CorsPolicy",
builder =>
{
builder
.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader()
.DisallowCredentials();
});
});
services.AddControllers();
services.AddAutoMapper(config =>
{
config.CreateMap <Book, BookDto>().ReverseMap();
config.CreateMap <OperationResult, OperationResultDto>().ReverseMap();
}, typeof(Startup));
services.AddMediatR(typeof(GetBooksQueryHandler).Assembly);
services.AddTransient(typeof(IPipelineBehavior <,>), typeof(ValidationBehavior <,>));
services.AddValidatorsFromAssembly(typeof(UpsertBookValidator).Assembly);
services.AddTransient <IElasticRepository, ElasticRepository>();
services.AddTransient <IBookService, BookService>();
services.AddTransient <IBookRepository, ElasticBookRepository>();
services.AddTransient <IFileService>(x => new BlobFileService("UseDevelopmentStorage=true"));
services.AddTransient <IPdfParser, PdfParser>();
services.AddRabbitMQ(Configuration["RabbitMq:Host"]);
services.AddTransient <IMessageProducerService, MessageProducerService>();
services.AddHostedService <BookUpsertSubscriberService>();
services.AddHostedService <BookUpsertedSubscriberService>();
var elasticHosts = Configuration.GetSection("Elasticsearch:Hosts")
.AsEnumerable()
.Where(x => x.Value != null)
.Select(x => x.Value);
services.AddSingleton(x =>
ElasticClientFactory.CreateElasticClient(elasticHosts, Configuration["Elasticsearch:Username"], Configuration["Elasticsearch:Password"]));
services.AddTransient <IEnumerable <IElasticQuery> >(x => new List <IElasticQuery> {
new GetBooksQuery()
});
services.AddTransient <IEnumerable <IElasticCommand> >(x => new List <IElasticCommand> {
new UpsertBookCommand()
});
services.AddSignalR();
var redisHosts = Configuration.GetSection("Redis:Hosts")
.AsEnumerable()
.Where(x => x.Value != null)
.Select(x => x.Value);
services.UseRedisCaching(redisHosts, uint.Parse(Configuration["Redis:Database"]));
services.AddSwaggerGen(c =>
{
c.SwaggerDoc(
"v1",
info: new Microsoft.OpenApi.Models.OpenApiInfo()
{
Title = "Book Store",
Version = "1.0",
Description = "Book Store"
}
);
});
}
public ServiceQuery(ElasticClientFactory elasticClientFactory, IndexQuery indexQuery, SiteConfig siteConfig) :
base(elasticClientFactory, Constants.SlambyServicesIndex, siteConfig)
{
this.indexQuery = indexQuery;
this.elasticClientFactory = elasticClientFactory;
}
static void Main(string[] args)
{
Randomizer.Seed = new Random(3897234);
var random = new Bogus.Randomizer();
var guildNames = new[] { null, "Guild A", "Guild B", "Guild C", "Guild D", "Guild E" };
var faction = new [] { "Horde", "Alliance", "Undefined" };
var race = new[]
{
"Human", "Kaldorei", "Gnome", "Dwarf", "Worgen", "Orc", "Tauren",
"Forsaken", "Sindorei", "Goblin", "Pandaren"
};
var isActive = new[] { true, false };
var dateInfo = new Faker <DateInfo>()
.StrictMode(true)
.RuleFor(x => x.CreatedDate, f => f.Date.Recent())
.RuleFor(x => x.UpdatedDate, f => f.Date.Recent());
var story = new Faker <Story>()
.StrictMode(true)
.RuleFor(x => x.Body, f => f.Lorem.Paragraphs(3))
.RuleFor(x => x.Id, f => f.IndexFaker)
.RuleFor(x => x.Title, f => f.Lorem.Sentence())
.RuleFor(x => x.DateInfo, f => dateInfo.Generate());
var picture = new Faker <Picture>()
.StrictMode(true)
.RuleFor(x => x.Id, f => f.IndexFaker)
.RuleFor(x => x.Caption, f => f.Lorem.Sentence())
.RuleFor(x => x.Url, f => f.Internet.Url());
var guild = new Faker <Guild>()
.StrictMode(true)
.RuleFor(x => x.Name, f => f.PickRandom(guildNames))
.RuleFor(x => x.Description, f => f.Lorem.Paragraphs(3));
var character = new Faker <Character>()
.StrictMode(true)
.RuleFor(x => x.Id, f => f.IndexFaker)
.RuleFor(x => x.FirstName, f => f.Name.FirstName())
.RuleFor(x => x.LastName, f => f.Name.LastName())
.RuleFor(x => x.EyeColor, f => f.Commerce.Color())
.RuleFor(x => x.EyeColor, f => f.Commerce.Color())
.RuleFor(x => x.Weight, f => f.Lorem.Sentence())
.RuleFor(x => x.Height, f => f.Lorem.Sentence())
.RuleFor(x => x.SkinColor, f => f.Commerce.Color())
.RuleFor(x => x.Race, f => f.PickRandom(race))
.RuleFor(x => x.Faction, f => f.PickRandom(faction))
.RuleFor(x => x.Background, f => f.Lorem.Paragraphs(7))
.RuleFor(x => x.Residence, f => f.Lorem.Word())
.RuleFor(x => x.Occupation, f => f.Lorem.Sentence())
.RuleFor(x => x.PhysicalAppearance, f => f.Lorem.Paragraphs(2))
.RuleFor(x => x.Friends, f => f.Lorem.Words().ToList())
.RuleFor(x => x.Stories, f => story.Generate(random.Number(1, 10)).ToList())
.RuleFor(x => x.Pictures, f => picture.Generate(random.Number(1, 10)).ToList())
.RuleFor(x => x.Guild, f => guild.Generate())
.RuleFor(x => x.DateInfo, f => dateInfo.Generate());
var user = new Faker <User>()
.StrictMode(true)
.RuleFor(x => x.UserName, f => f.Internet.UserName())
.RuleFor(x => x.DateInfo, dateInfo.Generate())
.RuleFor(x => x.Email, f => f.Internet.Email())
.RuleFor(x => x.Image, f => f.Internet.Url())
.RuleFor(x => x.IsActive, f => f.PickRandom(isActive))
.RuleFor(x => x.Characters, f => character.Generate(random.Number(1, 10)).ToList());
var users = user.Generate(1000);
//string charsJson = JsonConvert.SerializeObject(users);
ElasticClient client = ElasticClientFactory.GetClient();
//File.WriteAllText(@"c:\dump\users.txt", charsJson);
var result = client.Bulk(b => b.IndexMany(users));
if (!result.IsValid)
{
foreach (var item in result.ItemsWithErrors)
{
Console.WriteLine("Failed to index document {0}: {1}", item.Id, item.Error);
}
Console.WriteLine(result.DebugInformation);
Console.Read();
Environment.Exit(1);
}
Console.WriteLine("Done!");
Console.ReadLine();
}
public IndexQuery(ElasticClient client, ElasticClientFactory clientFactory, SiteConfig siteConfig) : base(client, siteConfig)
{
this.clientFactory = clientFactory;
this.defaultClient = clientFactory.GetClient();
}
protected override void When()
{
_factory = new ElasticClientConfiguration(CloudId, ElasticUsername, ElasticPassword)
.CreateClientFactory() as ElasticClientFactory;
}
public void SetUp()
{
_elasticClient = ElasticClientFactory.CreateClientForTest();
}
public MetadataQuery(ElasticClientFactory elasticClientFactory, IndexQuery indexQuery, SiteConfig siteConfig) :
base(elasticClientFactory, Constants.SlambyMetadataIndex, siteConfig)
{
this.elasticClientFactory = elasticClientFactory;
this.indexQuery = indexQuery;
}
public LicenseServerClient(ElasticClientFactory clientFactory, MPService mpService)
{
this.clientFactory = clientFactory;
this.mpService = mpService;
}
public ChatService(IElasticClient client = null, UserService userService = null)
{
_client = client ?? ElasticClientFactory.Create();
_userService = userService ?? new UserService();
}
public void SetUp()
{
_elasticClient = ElasticClientFactory.CreateOfflineClient();
_elasticConnection = new ElasticConnection(_elasticClient, new HangfireElasticSettings());
}
protected ElasticRepository()
{
_esClient = ElasticClientFactory.Create();
}
