/// <summary>
/// Initializes a new instance of the Database class.
/// </summary>
/// <param name="databaseFilename">Specifies a path to use for creating or opening a database file to use with the engine.</param>
/// <param name="customConfig">A custom config set to use with the engine.</param>
public Database(string databaseFilename, IConfigSet customConfig)
{
if (string.IsNullOrEmpty(databaseFilename) && customConfig == null)
{
throw new ArgumentException("Must specify a valid databaseFilename or customConfig");
}
this.config = new DatabaseConfig();
if (!string.IsNullOrEmpty(databaseFilename))
{
this.config.DatabaseFilename = databaseFilename;
string systemPath = Path.GetDirectoryName(databaseFilename);
this.config.SystemPath = systemPath;
this.config.LogFilePath = systemPath;
this.config.TempPath = systemPath;
this.config.AlternateDatabaseRecoveryPath = systemPath;
}
if (customConfig != null)
{
this.config.Merge(customConfig); // throw on conflicts
}
if (string.IsNullOrEmpty(this.config.Identifier))
{
this.config.Identifier = Guid.NewGuid().ToString();
}
if (string.IsNullOrEmpty(this.config.DisplayName))
{
this.config.DisplayName = string.Format("Database Inst{0:D2}", Interlocked.Increment(ref Database.instanceCounter) - 1);
}
this.Start();
}
public static IEnvironment CreateEnvironment(this IConfigSet configSet, ConfigurationContext context, string name, bool isImport = false)
{
var environment = context.Environments.Create();
environment.ConfigSet = configSet;
environment.ConfigSetNameId = configSet.Id;
environment.Name = name;
foreach (var serviceParameter in ServiceParameters)
{
environment.CreateSubstitutionParameters(context, serviceParameter, isImport);
}
context.SaveChanges();
foreach (var service in configSet.Services)
{
var addressOverride = string.Format("{0}_Address", service.Name);
var overrideProp = environment.SubstitutionParameters.SingleOrDefault(x => string.Equals(x.Name, addressOverride, StringComparison.OrdinalIgnoreCase));
if (overrideProp.IsNull())
{
var subParam = environment.CreateSubstitutionParameters(context, addressOverride);
if (isImport)
{
subParam.ItemValue = "{0}";
}
}
}
configSet.Environments.Add(environment);
context.SaveChanges();
AddToChildren(configSet, context, environment);
return(environment);
}
public static IEnvironment CreateChild(this IEnvironment environment, ConfigurationContext context, ref IConfigSet configSet)
{
var newEnvironment = context.Environments.Create();
newEnvironment.ConfigSetNameId = configSet.Id;
newEnvironment.ConfigSet = configSet;
newEnvironment.ParentEnvironment = environment;
newEnvironment.Name = environment.Name;
configSet.Environments.Add(newEnvironment);
context.SaveChanges();
foreach (var substitutionParameter in environment.SubstitutionParameters)
{
var child = CreateChild(substitutionParameter, context, ref newEnvironment);
if (newEnvironment.SubstitutionParameters.All(sp => !string.Equals(sp.Name, substitutionParameter.Name, StringComparison.OrdinalIgnoreCase)))
newEnvironment.SubstitutionParameters.Add(child);
}
foreach (var service in configSet.Services)
{
var addressOverride = string.Format("{0}_Address", service.Name);
var overrideProp = newEnvironment.SubstitutionParameters.SingleOrDefault(x => string.Equals(x.Name, addressOverride, StringComparison.OrdinalIgnoreCase));
if (overrideProp.IsNull())
newEnvironment.CreateSubstitutionParameters(context, addressOverride);
}
foreach (var environmentParameter in environment.EnvironmentParameters)
{
newEnvironment.EnvironmentParameters.Add(CreateChild(environmentParameter, context, ref newEnvironment));
}
return newEnvironment;
}
public static List <BreadCrumbItem> GetTrail(this IConfigSet self)
{
return(new List <BreadCrumbItem>
{
ConfigSet(self),
});
}
public ActionResult Create(string id1, string id2)
{
IConfigSet parent = null;
if (id1.ContainsCharacters())
{
parent = reader.GetConfigSet(id1, id2);
}
if (parent == null)
{
if (ConfigReaderFactory.CurrentUser.AdministratorType != AdministratorTypes.SystemAdmin)
{
throw new UnauthorizedAccessException("Access denied to configset");
}
ViewBag.IsNew = true;
ViewBag.CreateType = "new";
}
else
{
if (!parent.UserHasAccessTo())
{
throw new UnauthorizedAccessException("Access denied to configset");
}
ViewBag.IsNew = false;
ViewBag.CreateType = string.Format("child for {0}.{1}", id1, id2);
}
return(View(parent));
}
public IEnvironment CreatEnvironment(IConfigSet cs, string environmentName)
{
var env = cs.CreateEnvironment(Repository, environmentName);
cs.LastUpdate = DateTime.UtcNow;
Repository.SaveChanges();
return env;
}
/// <summary>
/// Merges two config sets into one and throws an exception if there are any conflicts.
/// </summary>
/// <param name="source">The source config set to user.</param>
protected void MergeThrowOnConflicts(IConfigSet source)
{
var mergeable = new Dictionary <int, object>();
foreach (var kvp in source)
{
object currValue;
if (this.TryGetValue(kvp.Key, out currValue))
{
if (!currValue.Equals(kvp.Value))
{
throw new ConfigSetMergeException(source, this, string.Format("Conflict on param {0}. Dest = {1}, Source = {2}", kvp.Key, currValue, kvp.Value));
}
}
else
{
mergeable.Add(kvp.Key, kvp.Value);
}
}
foreach (var kvp in mergeable)
{
this.SetParam(kvp.Key, kvp.Value);
}
}
public IEnvironment CreatEnvironment(IConfigSet cs, string environmentName)
{
var env = cs.CreateEnvironment(Repository, environmentName);
cs.LastUpdate = DateTime.UtcNow;
Repository.SaveChanges();
return(env);
}
public IServiceHostSettings CreateServiceHost(IConfigSet configSet, string name)
{
var serviceHost = configSet.CreateServiceHost(Repository, name);
configSet.LastUpdate = DateTime.UtcNow;
Repository.SaveChanges();
return(serviceHost);
}
private static BreadCrumbItem ConfigSet(IConfigSet self)
{
return(new BreadCrumbItem
{
Url = string.Format("/ConfigSet/Details?name={0}&system={1}", self.Name, self.System),
Name = self.Id
});
}
public IServiceDescription CreateService(IConfigSet cs, string servicename)
{
var service = cs.CreateService(Repository, servicename);
service.ConfigSet.LastUpdate = DateTime.UtcNow;
Repository.SaveChanges();
return(service);
}
/// <summary>
/// Merges two config sets into one and throws an exception if there are any conflicts.
/// </summary>
/// <param name="source">The source config set to user.</param>
public void Merge(IConfigSet source)
{
// Merges between different types don't yield anything
if (this.GetType() == source.GetType())
{
this.MergeThrowOnConflicts(source);
}
}
private static BreadCrumbItem ConfigSet(IConfigSet self)
{
return new BreadCrumbItem
{
Url = string.Format("/ConfigSet/Details?name={0}&system={1}", self.Name, self.System),
Name = self.Id
};
}
public bool CreateConfigSet(string name, string systemName, IConfigSet parent)
{
var configSets = from cs in Repository.ConfigSets where cs.Name == name && cs.System == systemName select cs;
if (configSets.Count() != 0)
throw new AmbiguousMatchException(string.Format("Config set '{0}\\{1}' already exists", name, systemName));
if (parent.IsNull())
{
configSets = from cs in Repository.ConfigSets where cs.System == systemName select cs;
if (configSets.Count() != 0)
throw new AmbiguousMatchException(string.Format(
"Config set '{0}\\{1}'... system {1} already exists", name, systemName));
}
var configSet = Repository.ConfigSets.Create();
if (parent.IsInstance())
{
foreach (var administrator in parent.Administrators)
{
configSet.Administrators.Add(administrator);
}
}
else
{
if (ConfigReaderFactory.CurrentUser != null)
configSet.Administrators.Add(ConfigReaderFactory.CurrentUser);
}
configSet.Name = name;
configSet.Created = DateTime.UtcNow;
configSet.System = systemName;
configSet.LastUpdate = DateTime.UtcNow;
Repository.SaveChanges();
if (parent.IsInstance())
{
configSet.ParentConfigSet = parent;
foreach (var serviceDescription in parent.Services)
{
var c = serviceDescription.CreateChild(Repository, ref configSet);
configSet.Services.Add(c);
Repository.SaveChanges();
}
foreach (var serviceHostSettingse in parent.ServiceHosts)
{
var hostChild = serviceHostSettingse.CreateChild(Repository, ref configSet);
configSet.ServiceHosts.Add(hostChild);
Repository.SaveChanges();
}
foreach (var environment in parent.Environments)
{
var child = environment.CreateChild(Repository, ref configSet);
configSet.Environments.Add(child);
Repository.SaveChanges();
}
Repository.SaveChanges();
}
return true;
}
private static void AddToChildren(IConfigSet configSet, ConfigurationContext context, IServiceHostSettings service)
{
foreach (var childConfigSet in configSet.ChildConfigSets)
{
var c = childConfigSet;
var childService = service.CreateChild(context, ref c);
AddToChildren(c, context, childService);
}
}
private static void AddToChildren(IConfigSet configSet, ConfigurationContext context, IServiceDescription service)
{
foreach (var childConfigSet in configSet.ChildConfigSets)
{
var c = childConfigSet;
var child = service.CreateChild(context, ref c);
c.Services.Add(child);
AddToChildren(c, context, child);
}
}
private static void AddToChildren(IConfigSet configSet, ConfigurationContext context, IEnvironment environment)
{
foreach (var childConfigSet in configSet.ChildConfigSets)
{
var c = childConfigSet;
var child = environment.CreateChild(context, ref c);
context.SaveChanges();
AddToChildren(c, context, child);
}
}
private static void AddToChildren(IConfigSet configSet, ConfigurationContext context, IEnvironment environment)
{
foreach (var childConfigSet in configSet.ChildConfigSets)
{
var c = childConfigSet;
var child = environment.CreateChild(context, ref c);
context.SaveChanges();
AddToChildren(c, context, child);
}
}
public static bool UserHasAccessTo(this IConfigSet self)
{
if (ConfigReaderFactory.CurrentUser.AdministratorType == AdministratorTypes.SystemAdmin)
{
return(true);
}
var cnt = (from u in self.Administrators where u.NameId == ConfigReaderFactory.CurrentUser.NameId select u).Count();
return(cnt > 0);
}
public static void GetUris(this IConfigSet configSet, ConfigurationContext context, ConfigurationSettings settings)
{
settings.ReplicationBusUri = string.Format(
configSet.ServiceHosts.Single(s => s.Name == settings.DataCenterServiceHostName)
.GetRawConfigData(settings.Environment)
.GetConfigParameter(settings.ReplicationUriBusKeyName), settings.DataCenterName, "<KEY>");
settings.ServiceBusUri = string.Format(
configSet.ServiceHosts.Single(s => s.Name == settings.DataCenterServiceHostName)
.GetRawConfigData(settings.Environment)
.GetConfigParameter(settings.ServiceBusUriKeyName), settings.DataCenterName, "<KEY>");
settings.DatabaseUri = string.Format(
configSet.ServiceHosts.Single(s => s.Name == settings.DataCenterServiceHostName)
.GetRawConfigData(settings.Environment)
.GetConfigParameter(settings.DatabaseUriKeyName), settings.DataCenterName, "<KEY>");
}
public static IServiceHostSettings CreateServiceHost(this IConfigSet configSet, ConfigurationContext context, string serviceName)
{
var service = context.ServiceHostSettingss.Create();
service.Name = serviceName;
service.ConfigSetNameId = configSet.Id;
service.ConfigSet = configSet;
foreach (var environment in configSet.Environments)
{
var addressOverride = string.Format("{0}_Address", serviceName);
var overrideProp = environment.SubstitutionParameters.SingleOrDefault(x => string.Equals(x.Name, addressOverride, StringComparison.OrdinalIgnoreCase));
if (overrideProp.IsNull())
{
environment.CreateSubstitutionParameters(context, addressOverride);
}
}
AddToChildren(configSet, context, service);
return(service);
}
/// <summary>
/// Initializes a new instance of the Database class.
/// </summary>
/// <param name="instance">An initialized instance to be used with Database. The instance should have a database attached and ready to use.</param>
/// <param name="ownsInstance">True if the instance handle passed into the constructur should be owned by the Database.</param>
/// <param name="customConfig">A custom config set to use with the engine. The config set should atleast contain the attached database filename.</param>
/// <remarks>Database will only manage the handle lifetime if ownsInstance is set to true. If its set to false, the caller is responsible for managing the teardown of the instance.</remarks>
public Database(JET_INSTANCE instance, bool ownsInstance, IConfigSet customConfig)
{
this.config = new DatabaseConfig();
this.config.Merge(customConfig);
this.instance = instance;
this.ownsInstance = ownsInstance;
// Ensure that there is an attached database at a path specified by the config set
using (var session = new Session(this.instance))
{
JET_DBID dbid;
JET_wrn wrn = Api.JetOpenDatabase(session, this.config.DatabaseFilename, null, out dbid, OpenDatabaseGrbit.ReadOnly);
Contract.Ensures(wrn == JET_wrn.Success);
Api.JetCloseDatabase(session, dbid, CloseDatabaseGrbit.None);
}
// The config set is live now
this.config.GetParamDelegate = this.TryGetParam;
this.config.SetParamDelegate = this.SetParam;
}
/// <summary>
/// Merges two config sets into one.
/// </summary>
/// <param name="source">The source config set to user.</param>
/// <param name="mergeRule">The merge rule to use.</param>
public void Merge(IConfigSet source, MergeRules mergeRule)
{
// Merges between different types don't yield anything
if (this.GetType() != source.GetType())
{
return;
}
if (mergeRule == MergeRules.ThrowOnConflicts)
{
this.MergeThrowOnConflicts(source);
return;
}
foreach (var kvp in source)
{
object currValue;
if (this.TryGetValue(kvp.Key, out currValue))
{
if (!currValue.Equals(kvp.Value))
{
switch (mergeRule)
{
case MergeRules.Overwrite:
this.SetParam(kvp.Key, kvp.Value);
break;
case MergeRules.KeepExisting:
break;
default:
throw new ArgumentException("Unsupported merge rule!", "mergeRule");
}
}
}
else
{
this.SetParam(kvp.Key, kvp.Value);
}
}
}
public ActionResult Create(string id1, string id2, ConfigSet model)
{
IConfigSet parent = null;
if (id1.ContainsCharacters())
{
parent = reader.GetConfigSet(id1, id2);
if (!parent.UserHasAccessTo())
{
throw new UnauthorizedAccessException("Access denied to configset");
}
}
else
{
if (ConfigReaderFactory.CurrentUser.AdministratorType != AdministratorTypes.SystemAdmin)
{
throw new UnauthorizedAccessException("Access denied to configset");
}
}
reader.CreateConfigSet(model.Name, string.IsNullOrEmpty(model.System) ? id2 : model.System, parent);
var csId = reader.GetConfigSet(model.Name, string.IsNullOrEmpty(model.System) ? id2 : model.System);
return(RedirectToAction("Details", "ConfigSet", new { name = csId.Name, system = csId.System }));
}
public static IServiceDescription CreateChild(this IServiceDescription service, ConfigurationContext context, ref IConfigSet configSet)
{
var child = context.ServiceDescriptions.Create();
child.Name = service.Name;
child.ConfigSetNameId = configSet.Id;
child.ConfigSet = configSet;
child.PatentServiceDescription = service;
service.ChildServiceDescriptions.Add(child);
context.SaveChanges();
foreach (var endpoint in service.Endpoints)
{
var newEndpoint = endpoint.CreateChild(context, ref child);
child.Endpoints.Add(newEndpoint);
}
foreach (var environment in configSet.Environments)
{
var addressOverride = string.Format("{0}_Address", service.Name);
var overrideProp = environment.SubstitutionParameters.SingleOrDefault(x => String.Equals(x.Name, addressOverride, StringComparison.OrdinalIgnoreCase));
if (overrideProp.IsNull())
environment.CreateSubstitutionParameters(context, addressOverride);
}
return child;
}
public void UpdateConfigSet(IConfigSet configSet)
{
Repository.SaveChanges();
}
/// <summary>
/// Initializes a new instance of the Database class.
/// </summary>
/// <param name="customConfig">A custom config set to use with the engine.</param>
public Database(IConfigSet customConfig) : this(null, customConfig)
{
}
public void DeleteConfigSet(IConfigSet cs)
{
Repository.DeleteObject(cs);
Repository.SaveChanges();
}
public string GenerateReaderKey(IConfigSet configSet)
{
configSet.ReaderKey = UniqueIdGenerator.CreateNewId(20).Encrypt(KeySalt);
return(configSet.ReaderKey);
}
public static IServiceHostSettings CreateChild(this IServiceHostSettings service, ConfigurationContext context, ref IConfigSet configSet)
{
var child = context.ServiceHostSettingss.Create();
child.Name = service.Name;
child.ConfigSetNameId = configSet.Id;
child.ConfigSet = configSet;
child.Parent = service;
foreach (var parameter in service.Parameters)
{
parameter.CreateChild(context, child);
}
return(child);
}
/// <summary>
/// Initializes a new instance of the Database class.
/// </summary>
/// <param name="instance">An initialized instance to be used with Database. The instance should have a database attached and ready to use.</param>
/// <param name="ownsInstance">True if the instance handle passed into the constructur should be owned by the Database.</param>
/// <param name="customConfig">A custom config set to use with the engine. The config set should atleast contain the attached database filename.</param>
/// <remarks>Database will only manage the handle lifetime if ownsInstance is set to true. If its set to false, the caller is responsible for managing the teardown of the instance.</remarks>
public Database(JET_INSTANCE instance, bool ownsInstance, IConfigSet customConfig)
{
this.config = new DatabaseConfig();
this.config.Merge(customConfig);
this.instance = instance;
this.ownsInstance = ownsInstance;
// Ensure that there is an attached database at a path specified by the config set
using (var session = new Session(this.instance))
{
JET_DBID dbid;
JET_wrn wrn = Api.JetOpenDatabase(session, this.config.DatabaseFilename, null, out dbid, OpenDatabaseGrbit.ReadOnly);
Contract.Ensures(wrn == JET_wrn.Success);
Api.JetCloseDatabase(session, dbid, CloseDatabaseGrbit.None);
}
// The config set is live now
this.config.GetParamDelegate = this.TryGetParam;
this.config.SetParamDelegate = this.SetParam;
}
private static void EnsureUriFormat(string format, string propertyName, ConfigurationSettings settings, IConfigSet configSet, ConfigurationContext context)
{
var hostSettings = configSet.ServiceHosts.Single(s => String.Equals(s.Name, settings.DataCenterServiceHostName, StringComparison.OrdinalIgnoreCase));
var param = hostSettings.Parameters.SingleOrDefault(p => string.Equals(p.Name, propertyName, StringComparison.OrdinalIgnoreCase));
if (param.IsNull())
{
param=hostSettings.CreateParameter(context, propertyName, false, true);
param.ItemValue = "{0}";
if (param.IsEnvironmental)
{
foreach (var environment in hostSettings.ConfigSet.Environments)
{
environment.CreateSubstitutionParameters(context, hostSettings.Name + "_" + param.Name);
}
}
}
var env = configSet.Environments.Single(e => e.Name == settings.Environment);
var subPar = env.SubstitutionParameters.SingleOrDefault(sp => sp.Name == hostSettings.Name + "_" + propertyName);
if (subPar.IsNull())
{
subPar = env.CreateSubstitutionParameters(context, hostSettings.Name + "_" + propertyName);
}
subPar.ItemValue = format;
context.SaveChanges();
}
private static void AddToChildren(IConfigSet configSet, ConfigurationContext context, IServiceHostSettings service)
{
foreach (var childConfigSet in configSet.ChildConfigSets)
{
var c = childConfigSet;
var childService = service.CreateChild(context, ref c);
AddToChildren(c, context, childService);
}
}
private static void EnsureUriFormat(string format, string propertyName, ConfigurationSettings settings, IConfigSet configSet, ConfigurationContext context)
{
var hostSettings = configSet.ServiceHosts.Single(s => String.Equals(s.Name, settings.DataCenterServiceHostName, StringComparison.OrdinalIgnoreCase));
var param = hostSettings.Parameters.SingleOrDefault(p => string.Equals(p.Name, propertyName, StringComparison.OrdinalIgnoreCase));
if (param.IsNull())
{
param = hostSettings.CreateParameter(context, propertyName, false, true);
param.ItemValue = "{0}";
if (param.IsEnvironmental)
{
foreach (var environment in hostSettings.ConfigSet.Environments)
{
environment.CreateSubstitutionParameters(context, hostSettings.Name + "_" + param.Name);
}
}
}
var env = configSet.Environments.Single(e => e.Name == settings.Environment);
var subPar = env.SubstitutionParameters.SingleOrDefault(sp => sp.Name == hostSettings.Name + "_" + propertyName);
if (subPar.IsNull())
{
subPar = env.CreateSubstitutionParameters(context, hostSettings.Name + "_" + propertyName);
}
subPar.ItemValue = format;
context.SaveChanges();
}
public IServiceDescription CreateService(IConfigSet cs, string servicename)
{
var service = cs.CreateService(Repository, servicename);
service.ConfigSet.LastUpdate = DateTime.UtcNow;
Repository.SaveChanges();
return service;
}
public void DeleteConfigSet(IConfigSet cs)
{
Repository.DeleteObject(cs);
Repository.SaveChanges();
}
public static IServiceDescription CreateChild(this IServiceDescription service, ConfigurationContext context, ref IConfigSet configSet)
{
var child = context.ServiceDescriptions.Create();
child.Name = service.Name;
child.ConfigSetNameId = configSet.Id;
child.ConfigSet = configSet;
child.PatentServiceDescription = service;
service.ChildServiceDescriptions.Add(child);
context.SaveChanges();
foreach (var endpoint in service.Endpoints)
{
var newEndpoint = endpoint.CreateChild(context, ref child);
child.Endpoints.Add(newEndpoint);
}
foreach (var environment in configSet.Environments)
{
var addressOverride = string.Format("{0}_Address", service.Name);
var overrideProp = environment.SubstitutionParameters.SingleOrDefault(x => String.Equals(x.Name, addressOverride, StringComparison.OrdinalIgnoreCase));
if (overrideProp.IsNull())
{
environment.CreateSubstitutionParameters(context, addressOverride);
}
}
return(child);
}
public void UpdateConfigSet(IConfigSet configSet)
{
Repository.SaveChanges();
}
public bool CreateConfigSet(string name, string systemName, IConfigSet parent)
{
var configSets = from cs in Repository.ConfigSets where cs.Name == name && cs.System == systemName select cs;
if (configSets.Count() != 0)
{
throw new AmbiguousMatchException(string.Format("Config set '{0}\\{1}' already exists", name, systemName));
}
if (parent.IsNull())
{
configSets = from cs in Repository.ConfigSets where cs.System == systemName select cs;
if (configSets.Count() != 0)
{
throw new AmbiguousMatchException(string.Format(
"Config set '{0}\\{1}'... system {1} already exists", name, systemName));
}
}
var configSet = Repository.ConfigSets.Create();
if (parent.IsInstance())
{
foreach (var administrator in parent.Administrators)
{
configSet.Administrators.Add(administrator);
}
}
else
{
if (ConfigReaderFactory.CurrentUser != null)
{
configSet.Administrators.Add(ConfigReaderFactory.CurrentUser);
}
}
configSet.Name = name;
configSet.Created = DateTime.UtcNow;
configSet.System = systemName;
configSet.LastUpdate = DateTime.UtcNow;
Repository.SaveChanges();
if (parent.IsInstance())
{
configSet.ParentConfigSet = parent;
foreach (var serviceDescription in parent.Services)
{
var c = serviceDescription.CreateChild(Repository, ref configSet);
configSet.Services.Add(c);
Repository.SaveChanges();
}
foreach (var serviceHostSettingse in parent.ServiceHosts)
{
var hostChild = serviceHostSettingse.CreateChild(Repository, ref configSet);
configSet.ServiceHosts.Add(hostChild);
Repository.SaveChanges();
}
foreach (var environment in parent.Environments)
{
var child = environment.CreateChild(Repository, ref configSet);
configSet.Environments.Add(child);
Repository.SaveChanges();
}
Repository.SaveChanges();
}
return(true);
}
public static IEnvironment CreateChild(this IEnvironment environment, ConfigurationContext context, ref IConfigSet configSet)
{
var newEnvironment = context.Environments.Create();
newEnvironment.ConfigSetNameId = configSet.Id;
newEnvironment.ConfigSet = configSet;
newEnvironment.ParentEnvironment = environment;
newEnvironment.Name = environment.Name;
configSet.Environments.Add(newEnvironment);
context.SaveChanges();
foreach (var substitutionParameter in environment.SubstitutionParameters)
{
var child = CreateChild(substitutionParameter, context, ref newEnvironment);
if (newEnvironment.SubstitutionParameters.All(sp => !string.Equals(sp.Name, substitutionParameter.Name, StringComparison.OrdinalIgnoreCase)))
{
newEnvironment.SubstitutionParameters.Add(child);
}
}
foreach (var service in configSet.Services)
{
var addressOverride = string.Format("{0}_Address", service.Name);
var overrideProp = newEnvironment.SubstitutionParameters.SingleOrDefault(x => string.Equals(x.Name, addressOverride, StringComparison.OrdinalIgnoreCase));
if (overrideProp.IsNull())
{
newEnvironment.CreateSubstitutionParameters(context, addressOverride);
}
}
foreach (var environmentParameter in environment.EnvironmentParameters)
{
newEnvironment.EnvironmentParameters.Add(CreateChild(environmentParameter, context, ref newEnvironment));
}
return(newEnvironment);
}
public static IServiceHostSettings CreateChild(this IServiceHostSettings service, ConfigurationContext context, ref IConfigSet configSet)
{
var child = context.ServiceHostSettingss.Create();
child.Name = service.Name;
child.ConfigSetNameId = configSet.Id;
child.ConfigSet = configSet;
child.Parent = service;
foreach (var parameter in service.Parameters)
{
parameter.CreateChild(context, child);
}
return child;
}
private static void AddToChildren(IConfigSet configSet, ConfigurationContext context, IServiceDescription service)
{
foreach (var childConfigSet in configSet.ChildConfigSets)
{
var c = childConfigSet;
var child = service.CreateChild(context, ref c);
c.Services.Add(child);
AddToChildren(c, context, child);
}
}
private IEnvironment GetEnvironmentSettings(IConfigSet config, string environment)
{
return (from e in config.Environments where e.Name == environment select e).Single();
}
public string GenerateReaderKey(IConfigSet configSet)
{
configSet.ReaderKey = UniqueIdGenerator.CreateNewId(20).Encrypt(KeySalt);
return configSet.ReaderKey;
}
private IEnvironment GetEnvironmentSettings(IConfigSet config, string environment)
{
return((from e in config.Environments where e.Name == environment select e).Single());
}
public IServiceHostSettings CreateServiceHost(IConfigSet configSet, string name)
{
var serviceHost = configSet.CreateServiceHost(Repository, name);
configSet.LastUpdate = DateTime.UtcNow;
Repository.SaveChanges();
return serviceHost;
}
/// <summary>
/// Initializes a new instance of the Database class.
/// </summary>
/// <param name="customConfig">A custom config set to use with the engine.</param>
public Database(IConfigSet customConfig)
: this(null, customConfig)
{
}
/// <summary>
/// Initializes a new instance of the Database class.
/// </summary>
/// <param name="databaseFilename">Specifies a path to use for creating or opening a database file to use with the engine.</param>
/// <param name="customConfig">A custom config set to use with the engine.</param>
public Database(string databaseFilename, IConfigSet customConfig)
{
if (string.IsNullOrEmpty(databaseFilename) && customConfig == null)
{
throw new ArgumentException("Must specify a valid databaseFilename or customConfig");
}
this.config = new DatabaseConfig();
if (!string.IsNullOrEmpty(databaseFilename))
{
this.config.DatabaseFilename = databaseFilename;
string systemPath = Path.GetDirectoryName(databaseFilename);
this.config.SystemPath = systemPath;
this.config.LogFilePath = systemPath;
this.config.TempPath = systemPath;
this.config.AlternateDatabaseRecoveryPath = systemPath;
}
if (customConfig != null)
{
this.config.Merge(customConfig); // throw on conflicts
}
if (string.IsNullOrEmpty(this.config.Identifier))
{
this.config.Identifier = Guid.NewGuid().ToString();
}
if (string.IsNullOrEmpty(this.config.DisplayName))
{
this.config.DisplayName = string.Format("Database Inst{0:D2}", Interlocked.Increment(ref Database.instanceCounter) - 1);
}
this.Start();
}
private void ConnectToHost(ServiceRegistrationServer.ServiceRegistrationMessage data, IConfigSet cs, IServiceDescription service)
{
if (data.ServiceHost != null)
{
var host = cs.ServiceHosts.SingleOrDefault(s => s.Name == data.ServiceHost);
if (host != null)
{
service.ServiceHost = host;
service.ServiceHostId = host.Id;
configSetTasks.UpdateService(service);
}
}
}
