public void GetTest4()
{
InitDomainRecords();
DomainManager target = CreateManager();
string name = BuildDomainName(GetRndDomainID());
using (ConfigDatabase db = CreateConfigDatabase())
{
Domain actual = target.Get(db, name);
Assert.Equal(name, actual.Name);
}
}
public void RemoveTest2()
{
using (ConfigDatabase db = CreateConfigDatabase())
{
AnchorManager target = CreateManager();
Assert.Equal(MAXDOMAINCOUNT * MAXCERTPEROWNER, target.Get(-1, MAXDOMAINCOUNT * MAXCERTPEROWNER + 1).Count());
string ownerName = string.Format("CN={0}", BuildDomainName(GetRndDomainID()));
target.Remove(db, ownerName);
db.SubmitChanges();
Assert.Equal(MAXDOMAINCOUNT * MAXCERTPEROWNER - MAXCERTPEROWNER, target.Get(-1, MAXDOMAINCOUNT * MAXCERTPEROWNER + 1).Count());
}
}
public void RemoveTest()
{
CertificateManager target = CreateManager();
const long certID = 1;
Assert.NotNull(target.Get(certID));
using (ConfigDatabase db = CreateConfigDatabase())
{
target.Remove(db, certID);
}
Assert.Null(target.Get(certID));
}
public void GetTest6()
{
CertificateManager target = CreateManager();
long certID = GetRndCertID();
using (ConfigDatabase db = CreateConfigDatabase())
{
Certificate cert = target.Get(db, certID);
Assert.NotNull(cert);
Assert.Equal(certID, cert.ID);
}
}
public void RemoveAllTest()
{
InitDomainRecords();
DomainManager target = CreateManager();
Assert.Equal(MAXDOMAINCOUNT, target.Get(string.Empty, MAXDOMAINCOUNT + 1).Count());
using (ConfigDatabase db = CreateConfigDatabase())
{
target.RemoveAll(db);
}
Assert.Equal(0, target.Get(string.Empty, MAXDOMAINCOUNT + 1).Count());
}
public void GetTest9()
{
InitAddressRecords();
AddressManager mgr = CreateManager();
string emailAddress = BuildEmailAddress(1, 1);
using (ConfigDatabase db = CreateConfigDatabase())
{
Address add = mgr.Get(db, emailAddress);
Assert.Equal(emailAddress, add.EmailAddress);
}
}
public void GetTest6()
{
AnchorManager target = CreateManager();
using (ConfigDatabase db = CreateConfigDatabase())
{
const long lastCertID = 0;
const int maxResults = MAXCERTPEROWNER * MAXDOMAINCOUNT + 1;
IEnumerable <Anchor> actual = target.Get(db, lastCertID, maxResults);
Assert.Equal(MAXCERTPEROWNER * MAXDOMAINCOUNT, actual.Count());
}
}
/// <summary>
/// This method will clean, load and verify MDN records in the DB for testing purposes
/// </summary>
/// <param name="mgr">MdnManager instance used for controlling the Mdn records</param>
/// <param name="db">ConfigDatabase instance used as the target storage mechanism for the records</param>
protected void InitOldMdnRecords(MdnManager mgr, ConfigDatabase db)
{
mgr.RemoveAll();
mgr.Start(db, TestOldMdns.ToArray());
//----------------------------------------------------------------------------------------------------
//---submit changes to db and verify existence of records
db.SubmitChanges();
foreach (KeyValuePair <long, KeyValuePair <int, string> > kp in TestAddressNames)
{
//Assert.NotNull(mgr.Get(kp.Value.Value));
}
}
public void Add(ConfigDatabase db, Bundle bundle)
{
if (db == null)
{
throw new ArgumentNullException("db");
}
if (bundle == null)
{
throw new ConfigStoreException(ConfigStoreError.InvalidBundle);
}
db.Bundles.InsertOnSubmit(bundle);
}
public void RemoveTest5()
{
CertificateManager target = CreateManager();
Assert.Equal(MAXDOMAINCOUNT * MAXCERTPEROWNER, target.Get(-1, MAXDOMAINCOUNT * MAXCERTPEROWNER + 1).Count());
using (ConfigDatabase db = CreateConfigDatabase())
{
string ownerName = string.Format("{0}", BuildDomainName(1));
target.Remove(db, ownerName);
}
Assert.Equal(MAXDOMAINCOUNT * MAXCERTPEROWNER - MAXCERTPEROWNER, target.Get(-1, MAXDOMAINCOUNT * MAXCERTPEROWNER + 1).Count());
}
public void AddTest3()
{
using (ConfigDatabase db = CreateConfigDatabase())
{
DomainManager target = CreateManager();
target.RemoveAll();
Assert.Equal(0, target.Count());
string name = BuildDomainName(GetRndDomainID());
target.Add(db, name);
db.SubmitChanges();
Assert.NotNull(target.Get(name));
}
}
public void Add(ConfigDatabase db, Anchor anchor)
{
if (db == null)
{
throw new ArgumentNullException("db");
}
if (anchor == null)
{
throw new ConfigStoreException(ConfigStoreError.InvalidAnchor);
}
db.Anchors.InsertOnSubmit(anchor);
}
private bool SaveToFile(object node, string path)
{
try
{
ConfigDatabase.SaveToFile(node, path);
}
catch (Exception e)
{
LastApplyException = e;
return(false);
}
return(true);
}
public void RemoveTest()
{
using (ConfigDatabase db = CreateConfigDatabase())
{
AnchorManager target = CreateManager();
List <Anchor> certs = this.GetCleanEnumerable <Anchor>(TestAnchors);
string owner = certs[0].Owner;
string thumbprint = certs[0].Thumbprint;
Assert.NotNull(target.Get(owner, thumbprint));
target.Remove(db, owner, thumbprint);
Assert.Null(target.Get(owner, thumbprint));
}
}
public void Add(ConfigDatabase db, DnsRecord record)
{
if (db == null)
{
throw new ArgumentNullException("db");
}
if (record == null)
{
throw new ConfigStoreException(ConfigStoreError.InvalidDnsRecord);
}
db.DnsRecords.InsertOnSubmit(record);
}
/// <summary>
/// 读取所有表信息
/// </summary>
public void LoadAllConfig()
{
string resName = "Config/ConfigDatabase";
TextAsset ta = Resources.Load <TextAsset>(resName);
if (null != ta)
{
//初始化所有配置
ConfigDatabase data = ProtoBuf.Meta.RuntimeTypeModel.Default.Deserialize(new MemoryStream(ta.bytes), null, typeof(ConfigDatabase)) as ConfigDatabase;
mGetCfg = new GetConfig();
mGetCfg.InitConfig(data);
}
LoadContent();
}
public ConfigData?GetLanguageData(string language)
{
if (_configData == null || _configDataJsonNode == null)
{
_errorOutput.WriteLine("Error: Database not loaded");
return(null);
}
if (!_configDataTranslateJsonNodes.TryGetValue(language, out var translationJsonNode))
{
_errorOutput.WriteLine("Error: Language not found");
return(null);
}
return(ConfigDatabase.Build(_configDataJsonNode, translationJsonNode));
}
/// <summary>
/// This method will clean, load and verify Certificate records based on the certs stored in the
/// metadata\certs folder into the db for testing purposes
/// </summary>
/// <param name="mgr">CertificateManager instance used for controlling the Certificate records</param>
/// <param name="db">ConfigDatabase instance used as the target storage mechanism for the records</param>
/// <remarks>
/// this approach goes out to db each time it is called, however it ensures that clean records
/// are present for every test that is execute, if it is taking too long, simply cut down on the
/// number of items using the consts above
/// </remarks>
protected void InitCertRecords(CertificateManager mgr
, ConfigDatabase db)
{
mgr.RemoveAll(db);
for (int i = 1; i <= MAXDOMAINCOUNT; i++)
{
//----------------------------------------------------------------------------------------------------
//---cheezy but will add MAXCERTPEROWNER certs per each relative domain
for (int t = 1; t <= MAXCERTPEROWNER; t++)
{
mgr.Add(GetCertificateFromTestCertPfx(i, t));
}
}
}
public void GetTest6()
{
InitMXRecords();
MXManager mgr = new MXManager(new ConfigStore(CONNSTR));
List <string> lst = AllMXDomainNames();
Assert.Equal(MAXDOMAINCOUNT * MAXSMTPCOUNT, lst.Count());
using (ConfigDatabase db = new ConfigDatabase(CONNSTR))
{
IEnumerable <MX> mxs = mgr.Get(db, lst.ToArray());
Assert.Equal(mgr.Count(), mxs.Count());
}
}
/// <summary>
/// Creates columns for the devices table.
/// </summary>
private static DataGridViewColumn[] CreateDeviceTableColumns(ConfigDatabase configDatabase)
{
return(TranslateHeaders("DeviceTable", new DataGridViewColumn[]
{
NewTextBoxColumn("DeviceNum", new ColumnOptions(ColumnKind.PrimaryKey)),
NewTextBoxColumn("Name", new ColumnOptions(ColumnLength.Name)),
NewTextBoxColumn("Code", new ColumnOptions(ColumnLength.Code)),
NewComboBoxColumn("DevTypeID", "Name", configDatabase.DevTypeTable, true),
NewTextBoxColumn("NumAddress"),
NewTextBoxColumn("StrAddress", new ColumnOptions(ColumnLength.Default)),
NewComboBoxColumn("CommLineNum", "Name", configDatabase.CommLineTable, true),
NewTextBoxColumn("Descr", new ColumnOptions(ColumnLength.Description))
}));
}
public void RemoveTest()
{
InitDomainRecords();
DomainManager target = CreateManager();
string name = BuildDomainName(GetRndDomainID());
Assert.NotNull(target.Get(name));
using (ConfigDatabase db = CreateConfigDatabase())
{
target.Remove(name);
db.SubmitChanges();
}
Assert.Null(target.Get(name));
}
public void AddTest(Certificate cert)
{
using (ConfigDatabase db = CreateConfigDatabase())
{
CertificateManager target = CreateManager();
target.RemoveAll();
target.Add(db, cert);
db.SubmitChanges();
Certificate certNew = target.Get(1); //---should always be 1 (table was truncated above);
Assert.NotNull(cert);
Assert.Equal(cert.Owner, certNew.Owner);
Assert.Equal(cert.Thumbprint, certNew.Thumbprint);
}
}
public void GetTest1()
{
using (ConfigDatabase db = CreateConfigDatabase())
{
AnchorManager target = CreateManager();
List <Anchor> certs = this.GetCleanEnumerable <Anchor>(TestAnchors);
string owner = certs[GetRndCertID()].Owner;
string thumbprint = certs[GetRndCertID()].Thumbprint;
Anchor expected = certs[GetRndCertID()];
Anchor actual = target.Get(db, owner, thumbprint);
Assert.Equal(expected.Owner, actual.Owner);
Assert.Equal(expected.Thumbprint, actual.Thumbprint);
}
}
public void GetTest()
{
using (ConfigDatabase db = CreateConfigDatabase())
{
AnchorManager target = CreateManager();
string owner = string.Format("CN={0}", BuildDomainName(GetRndDomainID()));
Anchor[] actual = target.Get(db, owner).ToArray();
Assert.Equal(MAXCERTPEROWNER, actual.Count());
foreach (Anchor cert in actual)
{
Assert.Equal(owner, cert.Owner);
}
}
}
public bool Save()
{
if (_configData == null || _configDataJsonNode == null)
{
_errorOutput.WriteLine("Error: Database not loaded");
return(false);
}
ConfigDatabase.SaveToFile(_configDataJsonNode, _fileSourceSettings.DatabaseFilePath);
foreach (var pair in _configDataTranslateJsonNodes)
{
var path = _fileSourceSettings.DatabaseTranslateFilePath(pair.Key);
ConfigDatabase.SaveToFile(pair.Value, path);
}
return(true);
}
public void Add(ConfigDatabase db, Certificate cert)
{
if (db == null)
{
throw new ArgumentNullException("db");
}
if (cert == null)
{
throw new ConfigStoreException(ConfigStoreError.InvalidCertificate);
}
cert.ValidateHasData();
db.Certificates.InsertOnSubmit(cert);
}
public void AddTest(Anchor anc)
{
AnchorManager target = CreateManager();
using (ConfigDatabase db = CreateConfigDatabase())
{
target.RemoveAll();
target.Add(db, anc);
db.SubmitChanges();
Anchor certNew = target.Get(anc.Owner, anc.Thumbprint); //---should always be 1 (table was truncated above);
Assert.NotNull(anc);
Assert.Equal(anc.Owner, certNew.Owner);
Assert.Equal(anc.Thumbprint, certNew.Thumbprint);
}
}
public void SetStatusTest1()
{
using (ConfigDatabase db = CreateConfigDatabase())
{
for (long i = 1; i <= MAXCERTPEROWNER * MAXDOMAINCOUNT; i++)
{
CertificateManager target = CreateManager();
Certificate cert = target.Get(i);
Dump(string.Format("SetStatusTest1 Subject[{0}] Status:[{1}]", cert == null ? "null cert" : cert.Owner, cert?.Status.ToString() ?? "null cert"));
Assert.Equal(EntityStatus.New, cert.Status);
target.SetStatus(db, i, EntityStatus.Enabled);
cert = target.Get(i);
Assert.Equal(EntityStatus.Enabled, cert.Status);
}
}
}
/// <summary>
/// Creates columns for the view table.
/// </summary>
private static DataGridViewColumn[] CreateViewTableColumns(ConfigDatabase configDatabase)
{
return(TranslateHeaders("ViewTable", new DataGridViewColumn[]
{
NewTextBoxColumn("ViewID", new ColumnOptions(ColumnKind.PrimaryKey)),
NewTextBoxColumn("Path", new ColumnOptions(ColumnKind.Path, ColumnLength.Long)),
NewButtonColumn("Path", new ColumnOptions(ColumnKind.SelectFolderButton)),
NewButtonColumn("Path", new ColumnOptions(ColumnKind.SelectFileButton)),
NewComboBoxColumn("ViewTypeID", "Name", configDatabase.ViewTypeTable, true),
NewComboBoxColumn("ObjNum", "Name", configDatabase.ObjTable, true),
NewTextBoxColumn("Args", new ColumnOptions(ColumnLength.Default)),
NewTextBoxColumn("Title", new ColumnOptions(ColumnLength.Long)),
NewTextBoxColumn("Ord"),
NewCheckBoxColumn("Hidden"),
}));
}
public void GetByDomainTest()
{
InitAddressRecords();
using (ConfigDatabase db = CreateConfigDatabase())
{
InitAddressRecords();
AddressManager mgr = CreateManager();
string domainName = BuildDomainName(1);
Address[] addrs = mgr.GetAllForDomain(db, domainName.ToUpper(), int.MaxValue).ToArray();
Assert.Equal(MAXADDRESSCOUNT, addrs.Length);
foreach (Address addr in addrs)
{
Assert.Equal(1, addr.DomainID);
}
}
}
public void GetTest7()
{
InitAddressRecords();
AddressManager mgr = CreateManager();
using (ConfigDatabase db = CreateConfigDatabase())
{
long[] addressIDs = new long[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
IEnumerable <Address> actual = mgr.Get(db, addressIDs);
Assert.Equal(addressIDs.Length, actual.Count());
for (int t = 0; t < addressIDs.Length; t++)
{
Assert.True(addressIDs.Contains(actual.ToArray()[t].ID));
}
}
}
public void GetTest6()
{
InitDomainRecords();
DomainManager target = CreateManager();
string[] names = TestDomainNames.ToArray();
using (ConfigDatabase db = CreateConfigDatabase())
{
Domain[] actual = target.Get(db, names).ToArray();
Assert.Equal(names.Length, actual.Length);
foreach (Domain dom in actual)
{
Assert.True(names.Contains(dom.Name));
}
}
}
public void GetTest13()
{
InitAddressRecords();
AddressManager mgr = CreateManager();
using (ConfigDatabase db = CreateConfigDatabase())
{
string[] emailAddresses = new[] { BuildEmailAddress(1, 1), BuildEmailAddress(2, 1), BuildEmailAddress(3, 1) };
IEnumerable <Address> actual = mgr.Get(db, emailAddresses);
Assert.Equal(emailAddresses.Length, actual.Count());
for (int t = 0; t < actual.Count(); t++)
{
Assert.True(emailAddresses.Contains(actual.ToArray()[t].EmailAddress));
}
}
}
public void Add(ConfigDatabase db
, DnsRecord[] dnsRecords)
{
if (db == null)
{
throw new ArgumentNullException("db");
}
if (dnsRecords == null || dnsRecords.Length.Equals(0))
{
return;
}
foreach (DnsRecord dnsRecord in dnsRecords)
{
db.DnsRecords.InsertOnSubmit(dnsRecord);
}
}
public void RemoveDomainTest()
{
InitAddressRecords();
AddressManager mgr = CreateManager();
const long domainID = 1;
using (ConfigDatabase db = CreateConfigDatabase())
{
//----------------------------------------------------------------------------------------------------
//---make sure that we have max addresses for the given domain
Address[] adds = mgr.Get(db, domainID, string.Empty, MAXADDRESSCOUNT + 1).ToArray();
Assert.Equal(MAXADDRESSCOUNT, adds.Count());
mgr.RemoveDomain(db, domainID);
adds = mgr.Get(db, domainID, string.Empty, MAXADDRESSCOUNT + 1).ToArray();
Assert.Equal(0, adds.Count());
}
}
public DnsRecord[] Get(ConfigDatabase db
, string domainName)
{
return db.DnsRecords.Get(domainName
, null).ToArray();
}
public void Remove(ConfigDatabase db, long[] certificateIDs)
{
if (db == null)
{
throw new ArgumentNullException("db");
}
if (certificateIDs.IsNullOrEmpty())
{
throw new ConfigStoreException(ConfigStoreError.InvalidIDs);
}
//
// Todo: this in a single query
//
for (int i = 0; i < certificateIDs.Length; ++i)
{
db.Anchors.ExecDelete(certificateIDs[i]);
}
}
private void UpdateLastCheckedForDbObjectDefinition(ConfigDatabase db, string dbObjName, string dbObjType)
{
List<SqlParameter> sqlParamList = new List<SqlParameter>();
sqlParamList.Add(new SqlParameter("dbObjName", dbObjName));
sqlParamList.Add(new SqlParameter("dbObjType", dbObjType));
string query = @"UPDATE {0} SET lastChecked=getdate() WHERE dbObjectName=@dbObjName AND dbObjectType=@dbObjType";
query = string.Format(query, DbObjDefTableName);
ExecuteNonQuery(db.name, db.conn, query, sqlParamList, false);
}
private void UpdateDbObjectDefinition(ConfigDatabase db, string dbObjName, string dbObjType, string dbObjDef)
{
List<SqlParameter> sqlParamList = new List<SqlParameter>();
sqlParamList.Add(new SqlParameter("dbObjName", dbObjName));
sqlParamList.Add(new SqlParameter("dbObjType", dbObjType));
sqlParamList.Add(new SqlParameter("dbObjDef", dbObjDef));
string query = @"
IF EXISTS(SELECT * FROM {0} WHERE dbObjectName=@dbObjName AND dbObjectType=@dbObjType)
BEGIN
UPDATE {0} SET dbObjectDefinition=@dbObjDef, lastUpdated=getdate()
WHERE dbObjectName=@dbObjName AND dbObjectType=@dbObjType
END
ELSE
BEGIN
INSERT {0}(dbObjectName,dbObjectType,dbObjectDefinition,lastUpdated,lastChecked) values(@dbObjName,@dbObjType,@dbObjDef,getdate(),getdate())
END
";
query = string.Format(query, DbObjDefTableName);
ExecuteNonQuery(db.name, db.conn, query, sqlParamList, false);
}
private bool HasDbObjectDefinitionChanged(ConfigDatabase db, string dbObjName, string dbObjType, string dbObjDef)
{
List<SqlParameter> sqlParamList = new List<SqlParameter>();
sqlParamList.Add(new SqlParameter("dbObjName", dbObjName));
sqlParamList.Add(new SqlParameter("dbObjType", dbObjType));
string query = @"SELECT dbObjectDefinition FROM {0} WHERE dbObjectName=@dbObjName AND dbObjectType=@dbObjType";
query = string.Format(query, DbObjDefTableName);
object result = ExecuteScalar(db, query, sqlParamList);
bool hasChanged = true;
if (result != null)
{
string dbObjDefFromDb = (string)result;
hasChanged = !dbObjDefFromDb.Equals(dbObjDef);
}
UpdateLastCheckedForDbObjectDefinition(db, dbObjName, dbObjType);
return hasChanged;
}
public IEnumerable<DnsRecord> Get(ConfigDatabase db, long lastRecordID, int maxResults)
{
return db.DnsRecords.Get(lastRecordID, maxResults);
}
public void SetStatus(ConfigDatabase db, string owner, EntityStatus status)
{
if (db == null)
{
throw new ArgumentNullException("db");
}
db.Anchors.ExecUpdateStatus(owner, status);
}
private void CheckSnapShotDbConnections(ConfigDatabase db)
{
DataReader.DbConnections dbConns = GetDbConnections(db);
if (dbConns.Count > 0)
{
string msg = "Can't continue because there are connections open on database " + db.name + " that supports snapshot recreation. Connections:";
msg += System.Environment.NewLine + dbConns.OutputConnections();
throw new Exception(msg);
}
}
/// <summary>
/// simple method to remove an dns record by ID
/// </summary>
/// <param name="db">database context to use</param>
/// <param name="recordID">long holding the id of the record to be deleted</param>
public void Remove(ConfigDatabase db
, long recordID)
{
db.DnsRecords.ExecDelete(recordID);
}
public void Update(ConfigDatabase db, DnsRecord dnsRecord)
{
if (db == null)
{
throw new ArgumentNullException("db");
}
if (dnsRecord == null)
{
throw new ConfigStoreException(ConfigStoreError.InvalidDnsRecord);
}
DnsRecord update = Get(db, dnsRecord.ID);
update.ApplyChanges(dnsRecord);
}
public void Remove(ConfigDatabase db, string ownerName)
{
if (db == null)
{
throw new ArgumentNullException("db");
}
if (string.IsNullOrEmpty(ownerName))
{
throw new ConfigStoreException(ConfigStoreError.InvalidOwnerName);
}
db.Anchors.ExecDelete(ownerName);
}
public void RemoveAll(ConfigDatabase db)
{
db.Anchors.ExecTruncate();
}
public IEnumerable<Anchor> Get(ConfigDatabase db, long lastCertID, int maxResults)
{
if (db == null)
{
throw new ArgumentNullException("db");
}
return db.Anchors.Get(lastCertID, maxResults);
}
public DnsRecord[] Get(ConfigDatabase db
, string domainName
, Common.DnsResolver.DnsStandard.RecordType typeID)
{
return db.DnsRecords.Get(domainName
, (int)typeID).ToArray();
}
private object ExecuteScalar(ConfigDatabase db, string SQL, List<SqlParameter> sqlParamList)
{
object result;
string connstr = db.conn.makeConnectionString(db.name);
SqlConnection MySqlConn = new SqlConnection(connstr);
MySqlConn.Open();
try
{
using (SqlCommand MySqlCmd = new SqlCommand(SQL, MySqlConn))
{
AddParamsToCmd(MySqlCmd, sqlParamList);
result = MySqlCmd.ExecuteScalar();
MySqlCmd.Parameters.Clear();
}
}
finally
{
MySqlConn.Close();
}
return result;
}
public IEnumerable<DnsRecord> Get(ConfigDatabase db
, long lastRecordID
, int maxResults
, Common.DnsResolver.DnsStandard.RecordType typeID)
{
return db.DnsRecords.Get(lastRecordID
, maxResults
, (int)typeID);
}
private DbConnections GetDbConnections(ConfigDatabase db)
{
DbConnections dbConns = new DbConnections();
dbConns.dbName = db.name;
string SQL = "SELECT * FROM master..sysprocesses where dbid=db_id('"+db.name+"') AND SPID >= 50";
using (SqlDataReader dataReader = Execute("master", db.conn, SQL, false))
{
while (dataReader.Read())
{
DbConnection dbConn = new DbConnection();
dbConn.spid = dataReader.GetInt16(dataReader.GetOrdinal("spid"));
dbConn.hostName = dataReader.GetString(dataReader.GetOrdinal("hostname")).Trim();
dbConn.program_name = dataReader.GetString(dataReader.GetOrdinal("program_name")).Trim();
dbConns.dbConnList.Add(dbConn);
}
}
return dbConns;
}
/// <summary>
/// simple method to remove an dns record by ID
/// </summary>
/// <param name="db">database context to use</param>
/// <param name="dnsRecord">DnsRecord instance to be removed</param>
public void Remove(ConfigDatabase db
, DnsRecord dnsRecord)
{
db.DnsRecords.DeleteOnSubmit(dnsRecord);
}
public IEnumerable<Anchor> Get(ConfigDatabase db, string owner)
{
if (db == null)
{
throw new ArgumentNullException("db");
}
if (string.IsNullOrEmpty(owner))
{
throw new ConfigStoreException(ConfigStoreError.InvalidOwnerName);
}
return db.Anchors.Get(owner);
}
/// <summary>
/// removes all dnsrecords from the store
/// </summary>
/// <param name="db">ConfigDatabase instance context</param>
public void RemoveAll(ConfigDatabase db)
{
db.DnsRecords.DeleteAll();
}
public void RemoveAll(ConfigDatabase db)
{
db.Bundles.ExecTruncate();
}
private void ReadConfigDatabases(XmlDocument doc)
{
XmlNodeList nodes = doc.SelectNodes("/updatesp/database");
if (nodes.Count == 0)
{
throw new Exception("Unable to read database configuration: can't find any /updatesp/database nodes");
}
foreach (XmlNode node in nodes)
{
ConfigDatabase db = new ConfigDatabase();
db.name = node.SelectSingleNode("name").InnerText;
string connName = node.SelectSingleNode("connection").InnerText;
db.conn = (ConfigConnection)_configConnections[connName];
if (node.SelectSingleNode("snapshot") != null)
{
db.snapshot = node.SelectSingleNode("snapshot").InnerText;
db.snapshotfilename = node.SelectSingleNode("snapshotfilename").InnerText;
}
_configDatabases.Add(db);
}
}
public Anchor Get(ConfigDatabase db, string owner, string thumbprint)
{
if (db == null)
{
throw new ArgumentNullException("db");
}
if (string.IsNullOrEmpty(owner))
{
throw new ConfigStoreException(ConfigStoreError.InvalidOwnerName);
}
if (string.IsNullOrEmpty(thumbprint))
{
throw new ConfigStoreException(ConfigStoreError.InvalidThumbprint);
}
return db.Anchors.Get(owner, thumbprint);
}
public DnsRecord Get(ConfigDatabase db, long recordID)
{
if (db == null)
{
throw new ArgumentNullException("db");
}
return db.DnsRecords.Get(recordID);
}
public void SetStatus(ConfigDatabase db, long BundleID, EntityStatus status)
{
if (db == null)
{
throw new ArgumentNullException("db");
}
db.Bundles.ExecUpdateStatus(BundleID, status);
}