public MongoGridFsProviderTest() { _runner = MongoDbRunner.Start(); _mongoClientSettings = MongoClientSettings.FromConnectionString(_runner.ConnectionString); _client = new MongoClient(_mongoClientSettings); _db = _client.GetDatabase("foo"); // Create db and gridfs collections var bucket = new GridFSBucket(_db); var createDb = bucket.UploadFromBytes("someData", new byte[1]); }
public RestaurantDBContext(IOptions <RestaurantDatabaseSettings> options) { this._restaurantDatabaseSettings = options.Value; MongoClientSettings clientSettings = MongoClientSettings.FromConnectionString(_restaurantDatabaseSettings.ConnectionString); MongoClient client = new MongoClient(clientSettings); if (client != null) { this.database = client.GetDatabase(_restaurantDatabaseSettings.DatabaseName.Trim()); } //_restaurant = database.GetCollection<Restaurant>(settings.RestaurantCollectionName); }
public void AddMongoClientWithMongoSettings() { var services = CreateServices(); var clientSettings = MongoClientSettings.FromConnectionString("mongodb://localhost"); services.AddMongoClient(clientSettings); var sp = services.BuildServiceProvider(); var client = sp.GetRequiredService <IMongoClient>(); client.Settings.Server.Should().BeEquivalentTo( new MongoServerAddress("localhost", 27017)); }
public static IIdentityServerBuilder AddMongoPersistedGrantStore(this IIdentityServerBuilder builder, string connection_string, string database_name) { var client = new MongoClient(MongoClientSettings.FromConnectionString(connection_string)); builder.Services.AddDisposableSingleInstanceService(new IdsMongoConnectionWrapper(client, database_name)); builder.Services.AddTransient(typeof(IIdsRepository <>), typeof(IdsRepository <>)); builder.Services.AddTransient <IIdentityServerDatabaseHelper, IdsMongoDatabaseHelper>(); builder.Services.RemoveAll <IPersistedGrantStore>(); builder.AddPersistedGrantStore <MongoPersistedGrantStore>(); return(builder); }
public CatalogContext(IConfiguration configuration) { this.configuration = configuration; var connectionString = configuration.GetValue <String>("MongoSettings:ConnectionString"); MongoClientSettings settings = MongoClientSettings.FromConnectionString(connectionString); MongoClient client = new MongoClient(settings); if (client != null) { // database with NAME catalogDb is created this.database = client.GetDatabase(configuration.GetValue <string>("MongoSettings:Database")); } }
public CatalogDbContext(IConfiguration configuration) { this.configuration = configuration; var connectionString = configuration.GetValue <string>("MongoSettings:ConnectionString"); MongoClientSettings mongoClientSetting = MongoClientSettings.FromConnectionString(connectionString); MongoClient mongoClient = new MongoClient(); if (mongoClient != null) { var databaseString = configuration.GetValue <string>("MongoSettings:Database"); this.mongoDatabase = mongoClient.GetDatabase(databaseString); } }
private void ConfigureConnections() { var connectionString = Configuration.GetConnectionString("stringConexaoBanco"); var configurations = MongoClientSettings.FromConnectionString(connectionString); configurations.MaxConnectionIdleTime = TimeSpan.FromSeconds(30); configurations.UseTls = false; configurations.RetryWrites = false; var client = new MongoClient(configurations); MongoConnection = client.GetDatabase(DatabaseName); }
private void SetDefaultClient() { string connectionString = this.mongoConfiguration.ConnectionString; MongoClientSettings settings = MongoClientSettings.FromConnectionString(connectionString); if (this.mongoConfiguration.MaxConnectionsPerPool > 0) { settings.MaxConnectionPoolSize = this.mongoConfiguration.MaxConnectionsPerPool; } this.DefaultClient = new MongoClient(settings); clientsRepository.Add("default", this.DefaultClient); }
public static MongoClient getMongoDBClient() { try { string connectionString = System.Environment.GetEnvironmentVariable("MONGO_URI"); var settings = MongoClientSettings.FromConnectionString(connectionString); return(new MongoClient(settings)); } catch (Exception ex) { throw new MongoException("It was not possible to connect to MongoDB", ex); } }
public MongoContext(IOptions <MongoSettings> options) { var mongoClientSettings = MongoClientSettings.FromConnectionString(options.Value.ConnectionString); Client = new MongoClient(mongoClientSettings); DatabaseName = options.Value.DatabaseName; Database = Client.GetDatabase(options.Value.DatabaseName); _collectionNames = Database.ListCollectionNames().ToList().ToHashSet(); Appointments = GetCreatedCollection <Appointment>("appointments"); }
private static MongoClient CreateMongoClient() { MongoClientSettings settings = MongoClientSettings.FromConnectionString($"mongodb://{SettingsProvider.GetMongoDbHost()}:27017"); settings.ClusterConfigurator = (cb) => { cb.Subscribe <CommandStartedEvent>(e => { Trace.WriteLine($"{e.CommandName} - {e.Command.ToJson()}"); }); }; return(new MongoClient(settings)); }
public BookingHistoryService(IOptions <MongoSettings> options) { this.mongosettings = options.Value; MongoClientSettings clientsettings = MongoClientSettings.FromConnectionString(mongosettings.ConnectionString); MongoClient client = new MongoClient(clientsettings); if (client != null) { this.database = client.GetDatabase(mongosettings.Database.Trim()); } }
public MongoDbContext(AggregateSettings settings = default, bool destroy = true, IDateTime dateTime = default, string databaseId = default) { _databaseId = databaseId ?? "v" + Guid.NewGuid().ToString().Replace("-", ""); _dateTime = dateTime ?? new StaticDateTime(); _destroy = destroy; var connectionSettings = MongoClientSettings.FromConnectionString("mongodb://localhost:27017"); _client = new MongoClient(connectionSettings); _database = _client.GetDatabase(_databaseId); _factory = new AggregateCollectionFactory(_database); _settings = settings; _repository = new AggregateRepository <T>(_factory, _dateTime, _settings); }
static async Task Main(string[] args) { var mongoSettings = MongoClientSettings.FromConnectionString(args[0]); var client = new MongoClient(mongoSettings); var mongoDatabase = client.GetDatabase("dr-move-public-api"); var bucket = new GridFSBucket(mongoDatabase, new GridFSBucketOptions { BucketName = "packages", }); if (!int.TryParse(args[1], out var numberOfDays)) { Console.WriteLine($"Could not parse {args[1]} to an int."); return; } if (numberOfDays < 30) { Console.WriteLine("Minimum number of days = 30"); return; } var mongoFilter = Builders <GridFSFileInfo <ObjectId> > .Filter.Lt(x => x.UploadDateTime, DateTime.UtcNow.AddDays(-numberOfDays)); var options = new GridFSFindOptions { BatchSize = 50, }; var batchnum = 0; var numFiles = 0; using (var cursor = await bucket.FindAsync(mongoFilter, options)) { while (await cursor.MoveNextAsync()) { var batch = cursor.Current; Console.WriteLine($"Deleting from batch {++batchnum}"); foreach (var item in batch) { numFiles++; await bucket.DeleteAsync(item.Id); } } } Console.WriteLine($"Deleted {numFiles} number of files"); }
/// <summary> /// Configure the Database context for the database. /// There is one context per database and collections per context! /// </summary> /// <typeparam name="TContext"></typeparam> /// <param name="services"></param> /// <param name="configuration"></param> /// <param name="connectionStringKey"></param> public static void AddMongoDatabase <TContext>(this IServiceCollection services, IConfiguration configuration, string connectionStringKey) where TContext : DbContext, new() { var connectionString = configuration.GetConnectionString(connectionStringKey); var mongoUrl = new MongoUrl(connectionString); services.Configure <MongoClientSettings>(mongoUrl.DatabaseName.ToLowerInvariant(), options => { var c = MongoClientSettings.FromConnectionString(configuration.GetConnectionString(connectionStringKey)); options.AllowInsecureTls = c.AllowInsecureTls; options.ApplicationName = c.ApplicationName; options.AutoEncryptionOptions = c.AutoEncryptionOptions; options.ClusterConfigurator = c.ClusterConfigurator; options.ConnectTimeout = c.ConnectTimeout; options.Credential = c.Credential; options.HeartbeatInterval = c.HeartbeatInterval; options.IPv6 = c.IPv6; options.LocalThreshold = c.LocalThreshold; options.MaxConnectionIdleTime = c.MaxConnectionIdleTime; options.MaxConnectionLifeTime = c.MaxConnectionLifeTime; options.MaxConnectionPoolSize = c.MaxConnectionPoolSize; options.MinConnectionPoolSize = c.MinConnectionPoolSize; options.ReadConcern = c.ReadConcern; options.ReadEncoding = c.ReadEncoding; options.ReadPreference = c.ReadPreference; options.ReplicaSetName = c.ReplicaSetName; options.RetryReads = c.RetryReads; options.RetryWrites = c.RetryWrites; options.Scheme = c.Scheme; options.SdamLogFilename = c.SdamLogFilename; options.Server = c.Server; options.Servers = c.Servers; options.ServerSelectionTimeout = c.ServerSelectionTimeout; options.SocketTimeout = c.SocketTimeout; options.SslSettings = c.SslSettings; options.UseTls = c.UseTls; options.WaitQueueTimeout = c.WaitQueueTimeout; options.WriteConcern = c.WriteConcern; options.WriteEncoding = c.WriteEncoding; }); var contextBuilder = new DbContextBuilder(services, mongoUrl.DatabaseName, connectionStringKey); var dbContext = new TContext(); services.TryAddSingleton(typeof(TContext), (provider) => dbContext); services.TryAddSingleton(typeof(IMongoClientFactory <TContext>), typeof(DefaultMongoClientFactory <TContext>)); dbContext.Configure(contextBuilder); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddSingleton <IMongoClient>(sp => { var settings = MongoClientSettings.FromConnectionString(Configuration.GetValue <string>("MongoConnectionString")); settings.ClusterConfigurator = builder => builder.Subscribe(new MongoEventSubscriber()); return(new MongoClient(settings)); }); services.AddControllers(); }
private MongoClient CreateClient(string connectionString) { void SocketConfigurator(Socket s) => s.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true); var settings = MongoClientSettings.FromConnectionString(connectionString); settings.SocketTimeout = TimeSpan.FromSeconds(60); settings.MaxConnectionIdleTime = TimeSpan.FromSeconds(60); settings.ClusterConfigurator = builder => builder.ConfigureTcp(tcp => tcp.With(socketConfigurator: (Action <Socket>)SocketConfigurator)); var mongoclient = new MongoDB.Driver.MongoClient(settings); return(mongoclient); }
public MongoBirdSearch(IBirdSearch birdSearch, TimeSpan expiration, string databaseName) { _birdSearch = birdSearch; Expiration = expiration; var mongoClientSettings = MongoClientSettings.FromConnectionString("mongodb://localhost"); mongoClientSettings.ServerSelectionTimeout = TimeSpan.FromSeconds(5); _client = new MongoClient(mongoClientSettings); _database = _client.GetDatabase(databaseName); _flights = _database.GetCollection <FlightModel>("flights"); _records = _database.GetCollection <RecordInfo>("records"); }
public MongoRepository(IOptions <MongoDbConfiguration> options) { lock (_lock) { var settings = MongoClientSettings.FromConnectionString(options.Value.ConnectionString); settings.ServerSelectionTimeout = TimeSpan.FromMilliseconds(options.Value.ConnectionTimeoutMs); var mongoClient = new MongoClient(settings); _database = mongoClient.GetDatabase(options.Value.Database); var collectionName = typeof(TEntity).Name; Collection = _database.GetCollection <TEntity>(collectionName); Options = options; } }
public MongoRepository(IOptions <MongoSettings> mongoOption) { var mongoSetting = MongoClientSettings.FromConnectionString(mongoOption.Value.ConnectionString); BsonSerializer.RegisterSerializer(new GuidSerializer(GuidRepresentation.Standard)); #pragma warning disable CS0618 // Required since guid representation is not respected in filter definition https://jira.mongodb.org/projects/CSHARP/issues/CSHARP-3179?filter=allopenissues // Thread explaining work around: https://www.mongodb.com/community/forums/t/c-driver-2-11-1-allegedly-use-different-guid-representation-for-insert-and-for-find/8536/3 BsonDefaults.GuidRepresentationMode = GuidRepresentationMode.V3; #pragma warning restore CS0618 var client = new MongoClient(mongoSetting); this._database = client.GetDatabase(mongoOption.Value.DatabaseName); }
/// <summary> /// Temporary patch until SERVER-39704 is resolved. /// </summary> public void PrimeShardRoutersWithDistinctCommand() { var connectionString = CoreTestConfiguration.ConnectionStringWithMultipleShardRouters; foreach (var endPoint in connectionString.Hosts.Cast <DnsEndPoint>()) { var clientSettings = MongoClientSettings.FromConnectionString(connectionString.ToString()); clientSettings.Server = new MongoServerAddress(endPoint.Host, endPoint.Port); var client = new MongoClient(clientSettings); var database = client.GetDatabase(_databaseName); var collection = database.GetCollection <BsonDocument>(_collectionName); collection.Distinct <BsonValue>("_id", "{ }"); } }
public void ConfigureServices(IServiceCollection services) { services.AddControllers() .ConfigureApiBehaviorOptions(opts => { opts.SuppressModelStateInvalidFilter = true; opts.SuppressMapClientErrors = true; }); services.AddSwaggerGen(c => c.SwaggerDoc("v1", new OpenApiInfo { Title = "InvestmentReporting.ImportService", Version = "v1" })); services.AddSharedAuthentication(); services.AddMemoryCache(); services.AddSingleton <IMongoDatabase>(_ => { var mongoSettings = MongoClientSettings.FromConnectionString(MongoConnectionString.Create()); var client = new MongoClient(mongoSettings); return(client.GetDatabase("InvestmentReporting")); }); services.AddSingleton <IIdGenerator, ObjectIdGenerator>(); services.AddSingleton <IStateRepository, MongoStateRepository>(); services.AddSingleton <CurrencyConfiguration>(); services.AddSingleton <StateManager>(); services.AddScoped <TransactionStateManager>(); services.AddScoped <IStateManager>(sp => sp.GetRequiredService <TransactionStateManager>()); services.AddScoped(sp => { var factory = new ImportUseCaseFactory(t => (IImportUseCase)sp.GetRequiredService(t)); factory.Register <AlphaDirectImportUseCase>("AlphaDirectMyBroker"); factory.Register <TinkoffImportUseCase>("TinkoffBrokerReport"); return(factory); }); services.AddScoped <AlphaDirectImportUseCase>(); services.AddScoped <AlphaBrokerMoneyMoveParser>(); services.AddScoped <AlphaTradeParser>(); services.AddScoped <TinkoffImportUseCase>(); services.AddScoped <TinkoffBrokerMoneyMoveParser>(); services.AddScoped <AssetParser>(); services.AddScoped <TinkoffTradeParser>(); services.AddScoped <AlphaDirectCouponParser>(); services.AddScoped <TinkoffCouponParser>(); services.AddScoped <DividendParser>(); services.AddScoped <AssetMoveParser>(); services.AddScoped <SplitDetector>(); services.AddScoped <TransferParser>(); services.AddScoped <AddIncomeUseCase>(); services.AddScoped <AddExpenseUseCase>(); services.AddScoped <BuyAssetUseCase>(); services.AddScoped <SellAssetUseCase>(); services.AddScoped <ReduceAssetUseCase>(); services.AddSingleton <BackgroundImportService>(); }
public MongoDB(IConfiguration configuration) { try { var settings = MongoClientSettings.FromConnectionString(configuration["ConnectionString"]); var client = new MongoClient(settings); DB = client.GetDatabase(configuration["NomeBD"]); MapClasses(); } catch (Exception e) { throw new MongoException("It was not possible to connect to MongoDB", e); } }
public void ConfigureServices(IServiceCollection services) { services.AddControllers(); services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new OpenApiInfo { Title = "WebApi", Version = "v1" }); }); services.AddTransient <ExampleJob>(); var connectionString = Configuration.GetValue <string>("Mongo:ConnectionString"); var dbName = Configuration.GetValue <string>("Mongo:DbName"); var mongoClientSettings = MongoClientSettings.FromConnectionString(connectionString); services.AddHangfire(c => { c.UseMongoStorage(mongoClientSettings, dbName, new MongoStorageOptions { MigrationOptions = new MongoMigrationOptions { MigrationStrategy = new MigrateMongoMigrationStrategy(), BackupStrategy = new CollectionMongoBackupStrategy() } }); c.UseOpenTracingFilter(); }); services.AddHangfireServer(); services.AddSingleton <ITracer>(sp => { var loggerFactory = sp.GetRequiredService <ILoggerFactory>(); var serviceName = sp.GetRequiredService <IWebHostEnvironment>().ApplicationName; var reporter = new RemoteReporter.Builder() .WithLoggerFactory(loggerFactory) .WithSender(new UdpSender(string.Empty, 6831, 0)) .Build(); var tracer = new Tracer.Builder(serviceName) .WithLoggerFactory(loggerFactory) .WithSampler(new ConstSampler(true)) .WithReporter(reporter) .Build(); GlobalTracer.Register(tracer); return(tracer); }); }
public void CamelCaseConvention_HangfireMongoDtos_StillInPascal() { // ARRANGE var mongoStorage = new MongoStorage( MongoClientSettings.FromConnectionString(ConnectionUtils.GetConnectionString()), ConnectionUtils.GetDatabaseName(), new MongoStorageOptions { MigrationOptions = new MongoMigrationOptions { Strategy = MongoMigrationStrategy.Drop, BackupStrategy = MongoBackupStrategy.None } } ); var id = Guid.NewGuid(); var dbContext = ConnectionUtils.CreateDbContext(); JobStorage.Current = mongoStorage; bool jobScheduled; var conventionPack = new ConventionPack { new CamelCaseElementNameConvention() }; ConventionRegistry.Register("CamelCase", conventionPack, t => true); // ACT using (new BackgroundJobServer(new BackgroundJobServerOptions { SchedulePollingInterval = TimeSpan.FromMilliseconds(100) })) { BackgroundJob.Enqueue(() => Signal.Set(id)); jobScheduled = Signal.WaitOne(id, TimeSpan.FromSeconds(1)); } // ASSERT var jobGraphCollectionName = dbContext.JobGraph.CollectionNamespace.CollectionName; var jobDto = dbContext .Database .GetCollection <BsonDocument>(jobGraphCollectionName) .Find(new BsonDocument("expireAt", new BsonDocument("$exists", true))) .FirstOrDefault(); Assert.Null(jobDto); Assert.True(jobScheduled, "Expected job to be scheduled"); }
public async Task InitializeAsync(GameRepositorySettings settings) { var mongoClientSettings = MongoClientSettings.FromConnectionString(settings.ConnectionString); mongoClientSettings.SslSettings = new SslSettings() { EnabledSslProtocols = SslProtocols.Tls12 }; mongoClientSettings.ClusterConfigurator = builder => { //builder.Subscribe(new SingleEventSubscriber<CommandSucceededEvent>(CommandSucceededEventHandler)); //builder.Subscribe(new SingleEventSubscriber<CommandStartedEvent>(CommandStartedEventHandler)); }; mongoClientSettings.ConnectTimeout = TimeSpan.FromSeconds(5); mongoClientSettings.ServerSelectionTimeout = TimeSpan.FromSeconds(5); var client = new MongoClient(mongoClientSettings); var db = client.GetDatabase(settings.Database); _reservationCollection = db.GetCollection <Reservation>(Constants.ReservationCollection); await _reservationCollection.Indexes.CreateOneAsync( new CreateIndexModel <Reservation>(Builders <Reservation> .IndexKeys.Ascending(reservation => reservation.Player.PlayerId))); _gameStateCollection = db.GetCollection <GameState>(Constants.GameStateCollection); await _gameStateCollection.Indexes.CreateManyAsync(new[] { new CreateIndexModel <GameState>(Builders <GameState> .IndexKeys.Ascending(state => state.Player1State.Player.PlayerId)), new CreateIndexModel <GameState>(Builders <GameState> .IndexKeys.Ascending(state => state.Player2State.Player.PlayerId)) }); if (!Directory.Exists(settings.InitialSetupsFolderPath)) { throw new DirectoryNotFoundException($"Folder {settings.InitialSetupsFolderPath} does not exist."); } var initialSetups = new List <InitialSetup>(); foreach (var layoutFilePath in Directory.EnumerateFiles(settings.InitialSetupsFolderPath, "*.json")) { try { initialSetups.Add(JsonConvert.DeserializeObject <InitialSetup>(File.ReadAllText(layoutFilePath))); } catch (Exception e) { Logger.Warn(e); } } _initialSetups = initialSetups.AsReadOnly(); }
/// <summary> /// Configure Hangfire to use MongoDB storage /// </summary> /// <param name="configuration">Configuration</param> /// <param name="connectionString">Connection string for Mongo database, for example 'mongodb://*****:*****@host:port/database'</param> /// <param name="storageOptions">Storage options</param> /// <exception cref="ArgumentException">Thrown if the connection string does not include the database name</exception> /// <returns></returns> public static MongoStorage UseMongoStorage(this IGlobalConfiguration configuration, string connectionString, MongoStorageOptions storageOptions) { var mongoUrlBuilder = new MongoUrlBuilder(connectionString); var databaseName = mongoUrlBuilder.DatabaseName; if (string.IsNullOrEmpty(databaseName)) { throw new ArgumentException("The connection string must include the database name, see https://docs.mongodb.com/manual/reference/connection-string/", nameof(connectionString)); } var mongoClientSettings = MongoClientSettings.FromConnectionString(connectionString); return(UseMongoStorage(configuration, mongoClientSettings, databaseName, storageOptions)); }
public BaseTestContext() { new DB(MongoClientSettings.FromConnectionString( "mongodb://*****:*****@localhost:27025/"), "test"); ClearUsers(); ClearTeams(); ClearPages(); ClearAttachments(); UserModel.CreateIndices(); TeamModel.CreateIndices(); PageModel.CreateIndices(); }
public Mocks(bool createTelemetry = true, MongoApplicationInsightsSettings settings = null) { StubTelemetry = new StubTelemetry(); if (createTelemetry) { var mongoClientSettings = MongoClientSettings.FromConnectionString( "mongodb://localhost:27017/"); Telemetry = new MongoApplicationInsightsTelemetry( mongoClientSettings, TelemetryClient, settings ?? new MongoApplicationInsightsSettings()); } }
// TODO Add MongoDb settings in appsettings public void ConfigureServices(IServiceCollection services) { services.AddControllers(); #region Swagger Configurations var assemblyPath = typeof(Startup).Assembly.Location; services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new OpenApiInfo { Title = "Sample Api MongoDB v1", Version = "v1", Description = "Sample Api MongoDB v1" }); c.ExampleFilters(); c.MapType <Guid>(() => new OpenApiSchema { Type = "string", Format = "uuid" }); c.UseInlineDefinitionsForEnums(); c.IncludeXmlComments($"{Path.GetDirectoryName(assemblyPath)}{Path.DirectorySeparatorChar}{Path.GetFileNameWithoutExtension(assemblyPath)}.xml"); }); services.AddSwaggerExamplesFromAssemblyOf <Startup>(); #endregion #region Mongo Configurations var mongoClientSettings = MongoClientSettings.FromConnectionString(_configuration.GetConnectionString("Mongo")); services.AddSingleton(mongoClientSettings); services.AddSingleton <IConventionPack>(new ConventionPack { new EnumRepresentationConvention(BsonType.String), new IgnoreExtraElementsConvention(true), new IgnoreIfNullConvention(true) }); services.AddSingleton <IMongoClient>(new MongoClient(mongoClientSettings)); services.AddScoped(typeof(IMongoBaseRepository <>), typeof(MongoBaseRepository <>)); #endregion }