public MongoContext(String connectionString, IMongoDBFactory mongoDBFactory, bool useSsl = false)
{
//connectionString = connectionString ?? System.Configuration.ConfigurationManager.ConnectionStrings[this.GetType().Name].ConnectionString;
UseSsl = useSsl;
ConnectionString = MongoUrl.Create(connectionString);
dbFactory = mongoDBFactory ?? new DefaultMongoDBFactory();
this.Database = dbFactory.CreateMongoDatabaseConnection(ConnectionString, useSsl);
this.MongoSets = new Dictionary <Type, IMongoSet>();
this.Trackers = new Dictionary <ObjectId, Tracker>();
this.TrackableTypes = new Dictionary <Type, Type>();
this.InitMongoSets();
}
public IMongoDatabase GetDatabase()
{
if (string.IsNullOrWhiteSpace(ConnectionString))
{
return(BackwardCompatibility.GetDatabase(this));
}
var mongoUrl = MongoUrl.Create(ConnectionString);
var client = new MongoClient(mongoUrl);
var db = client.GetDatabase(mongoUrl.DatabaseName ?? "log4net");
return(db);
}
private MongoDatabase GetDatabase()
{
if (string.IsNullOrEmpty(ConnectionString))//Sudip .IsNullOrWhiteSpace(ConnectionString))
{
return(BackwardCompatibility.GetDatabase(this));
}
MongoUrl url = MongoUrl.Create(ConnectionString);
MongoServer conn = MongoServer.Create(url);
MongoDatabase db = conn.GetDatabase(url.DatabaseName ?? "log4net");
return(db);
}
public static string Censored(string connectionString)
{
var connectionStringUrl = MongoUrl.Create(connectionString);
if (!string.IsNullOrEmpty(connectionStringUrl.Password))
{
connectionString = connectionString
.Replace($"{connectionStringUrl.Username}:{connectionStringUrl.Password}", "<hidden>");
}
return(connectionString);
}
public MongoDbSingleCollectionEventStore(IEventDispatcher eventDispatcher)
: base(eventDispatcher)
{
if (MongoClient == null)
{
var connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["EventStore"].ConnectionString;
var databaseName = MongoUrl.Create(connectionString).DatabaseName;
MongoClient = new MongoClient(connectionString);
MongoDatabase = MongoClient.GetDatabase(databaseName);
MongoCollection = MongoDatabase.GetCollection <BsonDocument>("DomainEvents");
}
}
public MongoService(MongoSettings settings, ILogger logger)
{
this.logger = logger;
_settings = settings;
client = new MongoClient(_settings.ConnectionString);
if (string.IsNullOrEmpty(_settings.DBName))
{
MongoUrl url = MongoUrl.Create(_settings.ConnectionString);
_settings.DBName = url.DatabaseName;
}
}
public void Wipe()
{
string databaseName = MongoUrl.Create(ConnectionString).DatabaseName;
MongoClient client = new MongoClient(ConnectionString);
MongoServer server = client.GetServer();
MongoDatabase database = server.GetDatabase(databaseName);
database.DropCollection(typeof(PageContent).Name);
database.DropCollection(typeof(Page).Name);
database.DropCollection(typeof(User).Name);
database.DropCollection(typeof(SiteConfigurationEntity).Name);
}
public FormMain()
{
InitializeComponent();
//var urlTo = MongoUrl.Create("mongodb://mongodb-endorphin.cloudapp.net:27017");
var urlTo = MongoUrl.Create("mongodb://localhost:27017");
var settingsTo = urlTo.ToServerSettings();
_server = MongoServer.Create(settingsTo);
_databaseCrawler = _server.GetDatabase("SyutkinCrawler");
_pages = _databaseCrawler.GetCollection("Pages");
_posts = _databaseCrawler.GetCollection("Posts");
}
/// <summary>
/// Gets the Mongo database based on the connection string. IF the database name isn't
/// present in the connection string it defaults to 'log4net'.
/// </summary>
/// <returns>The Mongo database</returns>
protected virtual MongoDatabase GetDatabase()
{
string connectionString = GetConnectionString();
var url = MongoUrl.Create(connectionString);
var client = new MongoClient(url);
var conn = client.GetServer();
var db = conn.GetDatabase(url.DatabaseName ?? "log4net");
return(db);
}
public MongoHelper()
{
string uriMongo = ConfigurationManager.AppSettings.Get("MONGOLAB_URI");
var client = new MongoClient(uriMongo);
string databaseName = MongoUrl.Create(uriMongo).DatabaseName;
var database = client.GetDatabase(databaseName);
Collection = database.GetCollection <T>(typeof(T).Name.ToLower());
}
/// <summary>
/// Creates a new instance of the event store
/// </summary>
/// <param name="eventDispatcher">The event dispatcher to be used by the instance</param>
public MongoDbEventStore(IEventDispatcher eventDispatcher, string connectionString)
: base(eventDispatcher)
{
if (MongoClient == null)
{
InitialiseBsonSerializer();
var databaseName = MongoUrl.Create(connectionString).DatabaseName;
MongoClient = new MongoClient(connectionString);
MongoDatabase = MongoClient.GetDatabase(databaseName);
}
}
internal void Validate(string name = null)
{
if (!string.IsNullOrWhiteSpace(ConnectionString))
{
var originalConnectionString = ConnectionString;
if (string.IsNullOrWhiteSpace(DatabaseName))
{
try
{
var mongoUrl = MongoUrl.Create(originalConnectionString);
DatabaseName = mongoUrl.DatabaseName;
}
catch
{
DatabaseName = null;
}
}
try
{
var mongoUrl = new MongoUrlBuilder(originalConnectionString)
{
DatabaseName = null
};
ConnectionString = mongoUrl.ToString();
}
catch
{
ConnectionString = originalConnectionString;
}
}
var typeName = GetType().Name;
if (!string.IsNullOrWhiteSpace(typeName))
{
typeName = $"{typeName} for {name}";
}
if (string.IsNullOrWhiteSpace(ConnectionString))
{
throw new OrleansConfigurationException($"Invalid {typeName} values for {nameof(ConnectionString)}. {nameof(ConnectionString)} is required.");
}
if (string.IsNullOrWhiteSpace(DatabaseName))
{
throw new OrleansConfigurationException($"Invalid {typeName} values for {nameof(DatabaseName)}. {nameof(DatabaseName)} is required.");
}
}
private ConnectionInfo Virtualize(string connectionString, string sshTunnelInfo)
{
lock (Mutex)
{
if (Clients.ContainsKey(connectionString))
{
return(Clients[connectionString]);
}
var virtualizedConnectionString = connectionString;
var url = MongoUrl.Create(connectionString);
IMongoClient client = null;
if (!TunnelClient.GetInstance()
.ForwardedPortInfoExists(url.Server.Host, Convert.ToUInt32(url.Server.Port)))
{
client = new MongoClient(connectionString);
if (!Ping(client))
{
client = null;
}
}
if (client == null)
{
var tunnelRequest = new TunnelRequest
{
RemoteHost = url.Server.Host,
RemotePort = Convert.ToUInt32(url.Server.Port), SshTunnelInfo = sshTunnelInfo
};
var portInfo = TunnelClient.GetInstance().GetForwardedPortInfo(tunnelRequest);
var newConnectionString = string.Format("mongodb://{2}{3}:{0}/{1}", portInfo.BoundPort,
url.DatabaseName,
string.IsNullOrWhiteSpace(url.Username)
? string.Empty
: string.Concat(url.Username, ":", url.Password, "@"), portInfo.BoundHost);
virtualizedConnectionString = newConnectionString;
client = new MongoClient(newConnectionString);
if (!Ping(client))
{
throw new Exception("Can't connect to MongoDb");
}
}
var connectionInfo =
new ConnectionInfo
{
VirtualizedConnectionString = virtualizedConnectionString,
Client = client
};
Clients[connectionString] = connectionInfo;
return(connectionInfo);
}
}
public void SetUp()
{
_apprenticeshipApplicationReadRepository = Container.GetInstance <IApprenticeshipApplicationReadRepository>();
_apprenticeshipApplicationWriteRepository = Container.GetInstance <IApprenticeshipApplicationWriteRepository>();
var mongoConnectionString = MongoConfiguration.ApplicationsDb;
var mongoDbName = MongoUrl.Create(mongoConnectionString).DatabaseName;
_database = new MongoClient(mongoConnectionString)
.GetServer()
.GetDatabase(mongoDbName);
_collection = _database.GetCollection <MongoApprenticeshipApplicationDetail>("apprenticeships");
}
public void TestCacheEmptyAfterClear()
{
var target = MongoUrl.Create("mongodb://host1");
Dictionary <string, MongoUrl> cache = getCacheReference(target);
Assert.AreEqual(1, cache.Count);
MongoUrl.ClearCache();
cache = getCacheReference(target);
Assert.AreEqual(0, cache.Count);
}
/// <summary>
/// Initializes a new instance of the <see cref="MongoRepository{T}"/> class.
/// </summary>
/// <param name="connectionString">The connection string.</param>
/// <exception cref="System.ArgumentException">Missing MongoDB connection string</exception>
public MongoRepository(string connectionString)
{
if (connectionString == null)
{
throw new ArgumentException("Missing MongoDB connection string");
}
var client = new MongoClient(connectionString);
MongoUrl mongoUrl = MongoUrl.Create(connectionString);
this._database = client.GetDatabase(mongoUrl.DatabaseName);
this._collection = this.SetupCollection();
}
public static ApplicationIdentityContext Create()
{
string connectionString = ConfigurationManager.ConnectionStrings["Mongo"].ConnectionString;
// init db
var dbName = MongoUrl.Create(connectionString).DatabaseName;
var server = new MongoClient(connectionString).GetServer();
var database = server.GetDatabase(dbName);
var users = database.GetCollection <IdentityUser>("users");
var roles = database.GetCollection <IdentityRole>("roles");
return(new ApplicationIdentityContext(users, roles));
}
public void SetUp()
{
var mongoConnectionString = MongoConfiguration.ApplicationsDb;
var mongoDbName = MongoUrl.Create(mongoConnectionString).DatabaseName;
var database = new MongoClient(mongoConnectionString)
.GetServer()
.GetDatabase(mongoDbName);
var collection = database.GetCollection <MongoApprenticeshipApplicationDetail>("apprenticeships");
collection.Remove(Query.EQ("LegacyApplicationId", LegacyApplicationId));
}
/// <summary>
/// Opens connection to MongoDB Server
/// </summary>
public MongoJournalServer(String connectionString)
{
_databaseName = MongoUrl.Create(connectionString).DatabaseName;
_server = MongoServer.Create(connectionString);
_journalMessagesSettings = Database.CreateCollectionSettings <BsonDocument>(_journalMessagesCollectionName);
_journalMessagesSettings.SafeMode = SafeMode.True;
_journalMessagesSettings.AssignIdOnInsert = false;
_journalHeadSettings = Database.CreateCollectionSettings <BsonDocument>(_journalHeadCollectionName);
_journalHeadSettings.SafeMode = SafeMode.True;
_journalHeadSettings.AssignIdOnInsert = false;
}
public DefaultMongoDbReader(string connectionString)
{
if (connectionString == null)
{
throw new ArgumentNullException(nameof(connectionString));
}
var mongoUrl = MongoUrl.Create(connectionString);
var clientSettings = MongoClientSettings.FromUrl(mongoUrl);
var client = new MongoClient(clientSettings);
_database = client.GetDatabase(mongoUrl.DatabaseName);
}
public ApplicationDbContext(string connectionString)
{
if (connectionString == null)
{
throw new ArgumentNullException(nameof(connectionString), "MongoDBConfiguration cannot be null.");
}
var mongoDbMementoDatabaseName = MongoUrl.Create(connectionString).DatabaseName;
var databaseName = MongoUrl.Create(connectionString).DatabaseName;
_client = new MongoClient(connectionString);
_database = _client.GetDatabase(databaseName);
}
/// <summary>
/// Gets the name of the database.
/// </summary>
/// <param name="connectionString">The connection string.</param>
/// <param name="config">The config.</param>
/// <returns></returns>
internal static string GetDatabaseName(MongoDbWebSection mongoDbWebSection, string connectionString, NameValueCollection config)
{
MongoUrl mongoUrl = MongoUrl.Create(connectionString);
if (!string.IsNullOrEmpty(mongoUrl.DatabaseName))
{
return(mongoUrl.DatabaseName);
}
return((mongoDbWebSection != null)
? mongoDbWebSection.DatabaseName
: config["database"] ?? "ASPNETDB");
}
public void Connect()
{
MongoClientSettings clientSettings = MongoClientSettings.FromUrl(MongoUrl.Create(this._serverUrl));
clientSettings.UseSsl = this._clientConfiguration.UseSsl;
clientSettings.ConnectTimeout = this._clientConfiguration.ConnectTimeout;
this._client = new MongoClient(clientSettings);
this._database = this._client.GetDatabase(this._databaseName);
this.Migrate();
}
public void ConnectToServer(string name)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException(nameof(name), "Server name cannot be null or empty.");
}
string connectionString = $"mongodb://{name}:27017/";
var url = MongoUrl.Create(connectionString);
_client = new MongoClient(url);
}
/// <summary>
/// Opens connection to MongoDB Server
/// </summary>
public MongoTransitionServer(string connectionString)
{
_databaseName = MongoUrl.Create(connectionString).DatabaseName;
_client = new MongoClient(connectionString);
_transitionSettings = new MongoCollectionSettings {
AssignIdOnInsert = false
};
_snapshotSettings = new MongoCollectionSettings {
AssignIdOnInsert = false
};
}
protected void Initialise(string connectionString, string collectionName)
{
Condition.Requires(connectionString);
Condition.Requires(collectionName);
CollectionName = collectionName;
var mongoDbName = MongoUrl.Create(connectionString).DatabaseName;
_database = new MongoClient(connectionString)
.GetServer()
.GetDatabase(mongoDbName);
}
private void InitializeDatabaseWithVacancy(MongoVacancy vacancy)
{
var mongoConnectionString = MongoConfiguration.VacancyDb;
var mongoDbName = MongoUrl.Create(mongoConnectionString).DatabaseName;
var database = new MongoClient(mongoConnectionString)
.GetServer()
.GetDatabase(mongoDbName);
Collection = database.GetCollection <MongoVacancy>("apprenticeshipVacancies");
Collection.Save(vacancy);
}
public void SetUp()
{
_expiringDraftRepository = Container.GetInstance <IExpiringApprenticeshipApplicationDraftRepository>();
var mongoConnectionString = MongoConfiguration.CommunicationsDb;
var mongoDbName = MongoUrl.Create(mongoConnectionString).DatabaseName;
_database = new MongoClient(mongoConnectionString)
.GetServer()
.GetDatabase(mongoDbName);
_collection = _database.GetCollection <MongoApprenticeshipApplicationExpiringDraft>("expiringdraftapplications");
_collection.Remove(Query.EQ("VacancyId", TestVacancyId));
}
public MongoDbSingleCollectionEventStore(IEventDispatcher eventDispatcher, string connectionString)
: base(eventDispatcher)
{
if (MongoClient == null)
{
InitialiseBsonSerializer();
var databaseName = MongoUrl.Create(connectionString).DatabaseName;
MongoClient = new MongoClient(connectionString);
MongoDatabase = MongoClient.GetDatabase(databaseName);
MongoCollection = MongoDatabase.GetCollection <BsonDocument>("DomainEvents");
}
}
public MongoCollection <T> GetCollection <T>(string name)
{
var databaseName = MongoUrl.Create(_connectionString).DatabaseName;
var client = new MongoClient(_connectionString);
// "GetServer(MongoClient) is obsolete: 'Use the new API instead.'"
// The new API appears to be stricly asynchronous,
// which is not supported by upstream dependencies
var server = client.GetServer();
var database = server.GetDatabase(databaseName);
return(database.GetCollection <T>(name));
}