/// <summary>
/// complex ctor expecting service settings
/// </summary>
/// <param name="domainManagerServiceSettings">ClientSettings for RecordRetrieval Service related data</param>
public DnsRecordStorageService(ClientSettings recordRetrievalServiceSettings)
{
if (recordRetrievalServiceSettings == null)
{
throw new ArgumentNullException("recordRetrievalServiceSettings not supplied to constructor");
}
m_recordRetrievalServiceSettings = recordRetrievalServiceSettings;
}
/// <summary>
/// Create a new resolver
/// </summary>
/// <param name="certClientSettings">Resolve certificates from this certificate service</param>
/// <param name="addressClientSettings">Optional Address Service. If NOT null, then before returning certificates, check if addresses exist by calling the address service</param>
public ConfigCertificateResolver(ClientSettings certClientSettings, ClientSettings addressClientSettings)
{
if (certClientSettings == null)
{
throw new ArgumentNullException("certClientSettings");
}
m_certClientSettings = certClientSettings;
m_addressClientSettings = addressClientSettings;
}
/// <summary>
/// Create a resolver that resolvers anchors from the middle tier
/// </summary>
/// <param name="clientSettings">Settings to set up WCF connections to the middle tier</param>
/// <param name="cacheSettings">Optional: if caching is enabled. Else null</param>
public ConfigAnchorResolver(ClientSettings clientSettings, CacheSettings cacheSettings)
{
if (clientSettings == null)
{
throw new ArgumentNullException("clientSettings");
}
CacheSettings incomingCacheSettings = new CacheSettings(cacheSettings) { Name = "AnchorCache.incoming" };
CacheSettings outgoingCacheSettings = new CacheSettings(cacheSettings) { Name = "AnchorCache.outgoing" };
m_incomingResolver = new CertificateResolver(new AnchorIndex(clientSettings, true), incomingCacheSettings);
m_outgoingResolver = new CertificateResolver(new AnchorIndex(clientSettings, false), outgoingCacheSettings);
}
private bool AddressDomainSearchEnabled(ClientSettings addressManager)
{
if (addressManager.HasSettings)
{
using (XmlNodeReader reader = new XmlNodeReader(addressManager.Settings))
{
XmlSerializer serializer = new XmlSerializer(typeof(AddressManagerSettings), new XmlRootAttribute(addressManager.Settings.LocalName));
AddressManagerSettings addressManagerSettings = (AddressManagerSettings)serializer.Deserialize(reader);
return addressManagerSettings.EnableDomainSearch;
}
}
return false;
}
/// <summary>
/// Create a new resolver
/// </summary>
/// <param name="certClientSettings">Settings for the certificate service to use for certificate resolution</param>
public ConfigCertificateResolver(ClientSettings certClientSettings)
: this(certClientSettings, null)
{
}
internal AnchorIndex(ClientSettings clientSettings, bool incoming)
{
m_clientSettings = clientSettings;
m_incoming = incoming;
}
void Validate(ClientSettings settings, string name, bool required)
{
if (settings == null && !required)
{
return;
}
if (settings == null)
{
throw new ArgumentException(string.Format("Invalid {0} Config", name));
}
try
{
settings.Validate();
}
catch(Exception ex)
{
throw new ArgumentException(name, ex);
}
}
public ClientSettingsSection()
{
m_settings = new ClientSettings();
}
internal CertPolicyIndex(ClientSettings clientSettings, bool incoming, CertPolicyUse use)
{
m_clientSettings = clientSettings;
m_incoming = incoming;
m_use = use;
}