/// <summary>
/// Searches the list of registered location providers and asks if
/// any claim ownership of the specified domain.
/// </summary>
/// <param name="domainID">Identifier of domain to claim ownership for.</param>
/// <returns>An IDomainProvider object for the provider that claims
/// the specified domain. A null is returned if no provider claims the
/// domain.</returns>
static private IDomainProvider GetDomainProvider(string domainID)
{
IDomainProvider provider = null;
log.Debug("domainID {0}", domainID);
lock (typeof(DomainProvider))
{
// See if there is a provider mapping for this domain.
string idpName = domainProviderTable[domainID] as string;
if (idpName != null)
{
// There is a domain mapping already set.
provider = registeredProviders[idpName] as IDomainProvider;
}
else
{
// Search for an owner for this domain.
foreach (IDomainProvider idp in registeredProviders.Values)
{
// See if the provider claims this domain.
if (idp.OwnsDomain(domainID))
{
domainProviderTable.Add(domainID, idp.Name);
provider = idp;
break;
}
}
}
}
return(provider);
}
public SeleniumService(IOptions <SeleniumConfiguration> options, ILogger <SeleniumService> logger, IDomainProvider domainServiceProvider, IAzureStorage azureStorage)
{
this.options = options;
this.logger = logger;
this.domainServiceProvider = domainServiceProvider;
this.azureStorage = azureStorage;
}
/// <summary>
/// Registers the specified domain provider with the domain provider service.
/// </summary>
/// <param name="provider">An ILocationProvider interface object.</param>
static public void RegisterProvider(IDomainProvider provider)
{
lock (typeof(DomainProvider))
{
log.Debug("Registering provider {0}.", provider.Name);
registeredProviders.Add(provider.Name, provider);
}
}
public static IDomainProvider GetInstance()
{
if (obj == null)
{
obj = new DomainProvider();
}
return(obj);
}
/// <summary>
/// Informs the domain provider that the specified member object is about to be
/// committed to the domain's member list. This allows an opportunity for the
/// domain provider to add any domain specific attributes to the member object.
/// </summary>
/// <param name="domainID">Identifier of a domain.</param>
/// <param name="member">Member object that is about to be committed to the domain's member list.</param>
static public void PreCommit(string domainID, Member member)
{
IDomainProvider idp = GetDomainProvider(domainID);
if (idp != null)
{
idp.PreCommit(domainID, member);
}
}
/// <summary>
/// Sets a new host address for the domain.
/// </summary>
/// <param name="domainID">Identifier of the domain for network address
/// to be changed.</param>
/// <param name="hostLocation">A Uri object containing the new network
/// address for the domain.</param>
static public void SetHostLocation(string domainID, Uri hostLocation)
{
IDomainProvider idp = GetDomainProvider(domainID);
if (idp != null)
{
idp.SetHostLocation(domainID, hostLocation);
}
}
/// <summary>
/// End the search for domain members.
/// </summary>
/// <param name="domainID">The identifier of the domain.</param>
/// <param name="searchContext">Domain provider specific search context returned by
/// FindFirstDomainMembers or FindNextDomainMembers methods.</param>
static public void FindCloseDomainMembers(string domainID, string searchContext)
{
IDomainProvider idp = GetDomainProvider(domainID);
if (idp != null)
{
log.Debug("Closing search on domain {0}.", domainID);
idp.FindCloseDomainMembers(searchContext);
}
}
/// <summary>
/// Indicates to the provider that the specified collection has
/// been deleted and a mapping is no longer required.
/// </summary>
/// <param name="collection">Collection that is being deleted.</param>
static public void DeleteLocation(Collection collection)
{
IDomainProvider idp = GetDomainProvider(collection.Domain);
if (idp != null)
{
log.Debug("Deleting location for collection {0}.", collection.Name);
idp.DeleteLocation(collection.Domain, collection.ID);
}
}
/// <summary>
/// Performs authentication to the specified domain.
/// </summary>
/// <param name="domain">Domain to authenticate to.</param>
/// <param name="httpContext">HTTP-specific request information. This is passed as a parameter so that a domain
/// provider may modify the HTTP request by adding special headers as necessary.
///
/// NOTE: The domain provider must NOT end the HTTP request.
/// </param>
/// <returns>The status from the authentication.</returns>
static public Authentication.Status Authenticate(Domain domain, HttpContext httpContext)
{
IDomainProvider idp = GetDomainProvider(domain.ID);
if (idp == null)
{
throw new DoesNotExistException("The specified domain does not exist.");
}
return(idp.Authenticate(domain, httpContext));
}
/// <summary>
/// Returns the network location of the specified host.
/// </summary>
/// <param name="domainID">Identifier of the domain where a
/// collection is to be created.</param>
/// <param name="hostID">The host to resolve.</param>
/// <returns>A Uri object that contains the network location.
/// </returns>
static public Uri ResolveHostAddress(string domainID, string hostID)
{
Uri networkLocation = null;
IDomainProvider idp = GetDomainProvider(domainID);
if (idp != null)
{
networkLocation = idp.ResolveHostAddress(domainID, hostID);
}
return(networkLocation);
}
/// <summary>
/// Returns the network location of where to the specified user's POBox is located.
/// </summary>
/// <param name="domainID">Identifier of the domain where a
/// collection is to be created.</param>
/// <param name="userID">The member that will owns the POBox.</param>
/// <returns>A Uri object that contains the network location.
/// </returns>
static public Uri ResolvePOBoxLocation(string domainID, string userID)
{
Uri networkLocation = null;
IDomainProvider idp = GetDomainProvider(domainID);
if (idp != null)
{
networkLocation = idp.ResolvePOBoxLocation(domainID, userID);
}
return(networkLocation);
}
/// <summary>
/// Returns the network location for the the specified
/// domain.
/// </summary>
/// <param name="domainID">Identifier for the domain.</param>
/// <returns>A Uri object that contains the network location.
/// </returns>
static public Uri ResolveLocation(string domainID)
{
Uri networkLocation = null;
IDomainProvider idp = GetDomainProvider(domainID);
if (idp != null)
{
// See if the provider already knows about this collection.
networkLocation = idp.ResolveLocation(domainID);
}
return(networkLocation);
}
/// <summary>
/// Continues the search for domain members from the specified record location.
/// </summary>
/// <param name="domainID">The identifier of the domain to search for members in.</param>
/// <param name="searchContext">Domain provider specific search context returned by FindFirstDomainMembers method.</param>
/// <param name="offset">Record offset to return members from.</param>
/// <param name="count">Maximum number of member objects to return.</param>
/// <param name="memberList">Receives an array object that contains the domain Member objects.</param>
/// <returns>True if there are more domain members. Otherwise false is returned.</returns>
static public bool FindSeekDomainMembers(string domainID, ref string searchContext, int offset, int count, out Member[] memberList)
{
bool moreEntries = false;
// Initialize the outputs.
memberList = null;
IDomainProvider idp = GetDomainProvider(domainID);
if (idp != null)
{
moreEntries = idp.FindSeekDomainMembers(ref searchContext, offset, count, out memberList);
}
return(moreEntries);
}
/// <summary>
/// Returns the network location for the the specified
/// collection.
/// </summary>
/// <param name="collection">Collection to find the network
/// location for.</param>
/// <returns>A Uri object that contains the network location.
/// If the network location could not be determined, a null
/// is returned.</returns>
static public Uri ResolveLocation(Collection collection)
{
Uri networkLocation = null;
IDomainProvider idp = GetDomainProvider(collection.Domain);
if (idp != null)
{
// See if the provider already knows about this collection.
networkLocation = idp.ResolveLocation(collection.Domain, collection.ID);
if ((networkLocation == null) && !collection.IsHosted)
{
// This is a new collection, resolve the location that it should be created.
networkLocation = idp.ResolveLocation(collection.Domain, collection.Owner.UserID, collection.ID);
}
}
return(networkLocation);
}
/// <summary>
/// Starts a search for a specific set of domain members.
/// </summary>
/// <param name="domainID">The identifier of the domain to search for members in.</param>
/// <param name="attributeName">Attribute name to search.</param>
/// <param name="searchString">String that contains a pattern to search for.</param>
/// <param name="operation">Type of search operation to perform.</param>
/// <param name="count">Maximum number of member objects to return.</param>
/// <param name="searchContext">Receives a provider specific search context object.</param>
/// <param name="memberList">Receives an array object that contains the domain Member objects.</param>
/// <param name="total">Receives the total number of objects found in the search.</param>
/// <returns>True if there are more domain members. Otherwise false is returned.</returns>
static public bool FindFirstDomainMembers(string domainID, string attributeName, string searchString, SearchOp operation, int count, out string searchContext, out Member[] memberList, out int total)
{
bool moreEntries = false;
// Initialize the outputs.
searchContext = null;
memberList = null;
total = 0;
IDomainProvider idp = GetDomainProvider(domainID);
if (idp != null)
{
moreEntries = idp.FindFirstDomainMembers(domainID, attributeName, searchString, operation, count, out searchContext, out memberList, out total);
}
return(moreEntries);
}
public DomainProducer(IDomainProvider domainProvider, IRateLimiter domainRetrievalRateLimiter, CrawlDaddyConfig config)
{
if (domainProvider == null)
{
throw new ArgumentNullException("domainProvider");
}
if (domainRetrievalRateLimiter == null)
{
throw new ArgumentNullException("domainRetrievalRateLimiter");
}
if (config == null)
{
throw new ArgumentNullException("config");
}
_domainProvider = domainProvider;
_domainRetrievalRateLimiter = domainRetrievalRateLimiter;
_config = config;
}
/// <summary>
/// Unregisters this domain provider from the domain provider service.
/// </summary>
/// <param name="provider">Domain provider to unregister.</param>
static public void Unregister(IDomainProvider provider)
{
lock (typeof(DomainProvider))
{
log.Debug("Unregistering domain provider {0}.", provider.Name);
// Remove the domain provider from the list.
registeredProviders.Remove(provider.Name);
// Remove all domain mappings for this provider.
string[] domainList = new string[domainProviderTable.Count];
domainProviderTable.Keys.CopyTo(domainList, 0);
foreach (string domainID in domainList)
{
// Is this mapping for the specified provider?
if (domainProviderTable[domainID] as string == provider.Name)
{
domainProviderTable.Remove(domainID);
}
}
}
}
public ScheduleBacktrackingAlgorithm(
IDomainProvider domainProvider, IScheduleManager scheduleManager)
{
this.domainProvider = domainProvider;
this.scheduleManager = scheduleManager;
}
public WebPageProvider(IDomainProvider domainProvider)
{
this.domainProvider = domainProvider;
}
public CommerceStorefront(IDomainProvider domainProvider, ICurrencyProvider currencyProvider)
: base(domainProvider, currencyProvider)
{
}