public OAuth2AuthFilter(
OAuth2AccessToken accessToken,
IHttpFilter filter)
{
this.accessToken = accessToken;
this.filter = filter;
}
public static AuthFilters.OAuth2Filter MakeFacebook(string clientId, IHttpFilter innerFilter)
{
var f = new AuthFilters.OAuth2Filter(innerFilter);
var config = new AuthFilters.AuthConfigurationData();
config.ClientId = clientId;
config.TechnicalName = "facebook.com";
config.ApiUriPrefix = "https://graph.facebook.com/";
config.SampleUri = "https://graph.facebook.com/me";
config.RedirectUri = "https://www.facebook.com/connect/login_success.html";
config.ClientSecret = "";
config.Scope = "read_stream";
config.Display = "popup";
config.State = "";
config.AdditionalParameterName = "";
config.AdditionalParameterValue = "";
config.ResponseType = ""; // blank==default "token". null doesn't marshall.
config.AccessTokenLocation = ""; // blank=default "query";
config.AccessTokenQueryParameterName = ""; // blank=default "access_token";
config.AuthorizationUri = "https://www.facebook.com/dialog/oauth";
config.AuthorizationCodeToTokenUri = "";
f.AuthConfiguration = config;
return(f);
}
/// <summary>
/// Add a IHttpFilter instance.
///
/// Filters are applied in the order they are added.
/// </summary>
/// <param name="filter"></param>
public void AddHttpFilter(IHttpFilter filter)
{
lock(m_filters)
{
m_filters.Add(filter);
}
}
/// <summary>
/// Установить заголовки.
/// </summary>
/// <param name="services">Сервисы.</param>
/// <param name="client">HTTP клиент.</param>
/// <param name="filer"></param>
/// <returns>Таск.</returns>
public static async Task SetClientHeaders(IServiceProvider services, HttpClient client, IHttpFilter filer)
{
var httpFilter = filer as HttpBaseProtocolFilter;
if (httpFilter != null)
{
var makabaEngineConfig = services.GetServiceOrThrow<INetworkEngines>().GetEngineById(CoreConstants.Engine.Makaba).Configuration as IMakabaEngineConfig;
if (makabaEngineConfig != null)
{
var baseUri = makabaEngineConfig.BaseUri;
var cookies = httpFilter.CookieManager.GetCookies(baseUri);
foreach (var kv in cookies)
{
client.DefaultRequestHeaders.Cookie.Add(new HttpCookiePairHeaderValue(kv.Name, kv.Value));
}
}
}
var engines = services.GetServiceOrThrow<INetworkEngines>();
var makaba = engines.GetEngineById(CoreConstants.Engine.Makaba);
var config = (IMakabaEngineConfig)makaba.Configuration;
var agent = config.BrowserUserAgent;
if (!string.IsNullOrWhiteSpace(agent))
{
client.DefaultRequestHeaders["User-Agent"] = agent;
}
}
public static IHttpFilter CreatePipeline(IHttpFilter innerFilter, IEnumerable <HttpFilter> filters)
{
if (innerFilter == null)
{
throw new ArgumentNullException(nameof(innerFilter));
}
if (filters == null)
{
return(innerFilter);
}
IHttpFilter pipeline = innerFilter;
foreach (HttpFilter filter in filters.Reverse())
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filters), "Http filter array contains null item.");
}
filter.InnerFilter = pipeline;
pipeline = filter;
}
return(pipeline);
}
/// <summary>
/// Add a IHttpFilter instance.
///
/// Filters are applied in the order they are added.
/// </summary>
/// <param name="filter"></param>
public void AddHttpFilter(IHttpFilter filter)
{
lock (m_filters)
{
m_filters.Add(filter);
}
}
internal IHttpFilter GetFilterChain()
{
if (this._filterChainStart == null)
{
LinkedListNode <IHttpFilter> currentNode = _filtersCollection.First;
while (currentNode != null && currentNode.Next != null)
{
currentNode.Value.SetNextFilter(currentNode.Next.Value);
currentNode = currentNode.Next;
}
if (_filtersCollection.Last != null)
{
// Set terminatorFilter as the _filtersCollection.Last nest
_filterChainStart = _filtersCollection.First.Value;
_filtersCollection.Last.Value.SetNextFilter(_terminatorFilter);
}
else
{
_filterChainStart = _terminatorFilter;
}
}
return(_filterChainStart);
}
public void AddAfter(IHttpFilter filter, string previousFilterName)
{
this.RemoveFilterIfExistsAndInvalidateFilterChain(filter);
LinkedListNode <IHttpFilter> referenceFilter = GetFilterByName(previousFilterName);
this._filtersCollection.AddAfter(referenceFilter, filter);
}
public AuthFilter(IHttpFilter innerFilter)
{
if (null == innerFilter)
{
throw new ArgumentException("innerFilter cannot be null.");
}
_innerFilter = innerFilter;
}
public PlugInFilter(IHttpFilter innerFilter)
{
if (innerFilter == null)
{
throw new ArgumentException("innerFilter cannot be null.");
}
this.innerFilter = innerFilter;
}
public AddAuthorizationHeaderFilter(IHttpFilter innerFilter)
{
if (innerFilter == null)
{
throw new ArgumentException("innerFilter cannot be null.");
}
this.innerFilter = innerFilter;
}
public PlugInFilter(IHttpFilter innerFilter)
{
if (innerFilter == null)
{
throw new ArgumentException("innerFilter cannot be null.");
}
this.innerFilter = innerFilter;
}
internal void SetTerminatorFilter(IHttpFilter terminatorFilter)
{
if (_terminatorFilter != null)
{
throw new ArgumentException("Already exists a termination filter", "lastFilter");
}
_terminatorFilter = terminatorFilter;
this._filterChainStart = null;
}
public OAuthGetTokenAuthFilter(
string consumerKey,
string consumerSecret,
IHttpFilter filter)
{
this.consumerKey = consumerKey;
this.consumerSecret = consumerSecret;
this.filter = filter;
}
internal void SetTerminatorFilter(IHttpFilter terminatorFilter)
{
if (_terminatorFilter != null)
{
throw new ArgumentException("Already exists a termination filter", "lastFilter");
}
_terminatorFilter = terminatorFilter;
this._filterChainStart = null;
}
public static void SetupClient(IUrlService urlService, HttpClient client, IHttpFilter filter) {
var baseFilter = filter as HttpBaseProtocolFilter;
if (baseFilter == null)
return;
HttpCookieCollection cookies = baseFilter.CookieManager.GetCookies(urlService.GetFullUrl("/"));
foreach (HttpCookie cookie in cookies) {
client.DefaultRequestHeaders.Cookie.Add(new HttpCookiePairHeaderValue(cookie.Name, cookie.Value));
}
}
public SoapDigestHttpFilter(IHttpFilter innerFilter)
{
if (innerFilter == null)
{
throw new ArgumentNullException("innerFilter");
}
InnerFilter = innerFilter;
Rand = new Random();
}
/// <summary>
/// Full constructor.
/// </summary>
/// <param name="innerFilter">The next handler in the pipeline to pass requests through.</param>
/// <param name="requestCondition">A <see cref="IWebHttpRequestCondition"/> that controls whether any individual request is compressed or not. If null, all requests are compressed.</param>
public CompressedRequestFilter(IHttpFilter innerFilter, IWebHttpRequestCondition requestCondition)
{
if (innerFilter == null)
{
throw new ArgumentNullException(nameof(innerFilter));
}
_InnerFilter = innerFilter;
_RequestCondition = requestCondition;
}
public static string Append(this string source, IHttpFilter filter)
{
if (filter == null)
{
return(source);
}
var query = filter.ToQueryString();
return(source.Append(query));
}
private void RemoveFilterIfExistsAndInvalidateFilterChain(IHttpFilter filter)
{
var existantFilter = GetFilterByName(filter.Name);
if (existantFilter != null)
{
this._filtersCollection.Remove(existantFilter);
}
this._filterChainStart = null;
}
/// <summary>
/// Initializes a new instance of the <see cref="WindowsHttpMessageHandler"/> class.
/// </summary>
/// <param name="httpFilter">The HTTP filter to use for handling response messages.</param>
public WindowsHttpMessageHandler(IHttpFilter httpFilter = null)
{
if (httpFilter == null)
{
httpFilter = new HttpBaseProtocolFilter();
}
// Initialize the HTTP client
this.client = new Windows.Web.Http.HttpClient(httpFilter);
this.disposed = false;
}
private bool disposedValue = false; // 要检测冗余调用
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
inner.Dispose();
}
inner = null;
disposedValue = true;
}
}
private bool disposedValue = false; // 要检测冗余调用
protected virtual void Dispose(bool disposing)
{
if (!this.disposedValue)
{
if (disposing)
{
this.inner.Dispose();
}
this.inner = null;
this.disposedValue = true;
}
}
public GetMessageFilter(TwitterExecute exe, IDictionary<string, string> parameters, string url, IHttpFilter innerFilter)
{
this.exe = exe;
this.parameters = parameters;
this.url = url;
if (innerFilter == null)
{
throw new ArgumentException("innerFilter cannot be null.");
}
this.innerFilter = innerFilter;
}
public PostMessageFilter(TwitterExecute exe, IDictionary<string, string> parameters, string url, IHttpFilter innerFilter, CancellationToken cancellationToken)
{
this.exe = exe;
this.parameters = parameters;
this.url = url;
if (innerFilter == null)
{
throw new ArgumentException("innerFilter cannot be null.");
}
this.innerFilter = innerFilter;
this.cancellationToken = cancellationToken;
}
/// <summary>
/// Full constructor.
/// </summary>
/// <param name="maxConcurrentRequests">The maximum number of concurrent requests allowed. Must be greater than zero</param>
/// <param name="innerHandler">The next handler in the pipeline to pass the request onto.</param>
/// <exception cref="System.ArgumentOutOfRangeException">Thrown if <paramref name="maxConcurrentRequests"/> is less than or equal to zero.</exception>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="innerHandler"/> parameter is null.</exception>
public ThrottledConcurrentRequestsFilter(int maxConcurrentRequests, IHttpFilter innerHandler)
{
if (maxConcurrentRequests <= 0)
{
throw new ArgumentOutOfRangeException(nameof(maxConcurrentRequests));
}
if (innerHandler == null)
{
throw new ArgumentNullException(nameof(innerHandler));
}
_ThrottlingSemaphore = new System.Threading.Semaphore(maxConcurrentRequests, maxConcurrentRequests);
_InnerHandler = innerHandler;
}
private AuthHeaderFilter(
ConsumerInfo consumerInfo,
RequestTokenResponse requestToken,
AccessTokenResponse accessToken,
string requestUrl,
IDictionary <string, string> requestParameters,
IHttpFilter filter)
{
this.consumerInfo = consumerInfo;
this.requestToken = requestToken;
this.accessToken = accessToken;
this.requestUrl = requestUrl;
this.requestParameters = requestParameters;
this.filter = filter;
}
/// <summary>
/// Full constructor.
/// </summary>
/// <param name="innerFilter">The next handler in the pipeline to process requests.</param>
/// <param name="maxRedirects">The maximum number of automatic redirections for the handler to follow per request.</param>
/// <param name="redirectCache">A <see cref="RedirectCache"/> instance to use for caching known redirects.</param>
/// <exception cref="System.ArgumentNullException">Thrown if the <paramref name="innerFilter"/> is null.</exception>
/// <exception cref="System.ArgumentOutOfRangeException">Thrown if <paramref name="maxRedirects"/> is less than zero.</exception>
public InsecureRedirectionFilter(IHttpFilter innerFilter, int maxRedirects, IRedirectCache redirectCache)
{
if (innerFilter == null)
{
throw new ArgumentNullException(nameof(innerFilter));
}
if (maxRedirects < 0)
{
throw new ArgumentOutOfRangeException(nameof(maxRedirects));
}
_InnerFilter = innerFilter;
MaxRedirects = maxRedirects;
_RedirectCache = redirectCache ?? new RedirectCache();
}
private static IHttpFilter CreateFilter(string filterName, Type filterType)
{
if (String.IsNullOrEmpty(filterName))
{
throw new ArgumentException("Filters must have a name", "filterName");
}
if (typeof(IHttpFilter).IsAssignableFrom(filterType) == false)
{
throw new ArgumentException("The filter type does not implement IHttpFilter", "filterType");
}
IHttpFilter filter = (IHttpFilter)Activator.CreateInstance(filterType, new object[] { filterName });
return(filter);
}
public AdaptiveMediaSourceHttpFilterLogger(LogView _logView, IHttpFilter _innerFilter)
{
if (_logView == null)
{
throw new ArgumentNullException(nameof(_logView));
}
this.logView = _logView;
if (_innerFilter == null)
{
throw new ArgumentNullException(nameof(_innerFilter));
}
this.innerFilter = _innerFilter;
this.timeToResponseComplete = new Stopwatch();
}
public Session( IServerDispatcher dispatcher, IHttpFilter filter )
{
Contract.Ensures( dispatcher != null );
Contract.Ensures(filter!=null);
Id = Guid.NewGuid().ToString();
_filter = filter;
_serverConnectingEvent = new Semaphore( 1, 1 );
_logger = new SessionLogger( Id );
_serverDispatcher = dispatcher;
_serverDispatcher.ActiveServerClosedConnection += new EventHandler(_serverDispatcher_ActiveServerClosedConnection);
_serverDispatcher.ServerDataAvailable += ServerDispatcherServerDataAvailable;
_serverDispatcher.Logger = _logger;
_logger.Verbose( "Creating session" );
}
// https://dev.twitter.com/docs/auth/authorizing-request
private async Task <string> PostRequest(
string requestUrl,
SortedDictionary <string, string> requestParams,
IHttpFilter handler)
{
string response = String.Empty;
using (var client = new HttpClient(handler))
{
IHttpContent content = new HttpFormUrlEncodedContent(requestParams);
// var contentType = "application/x-www-form-urlencoded";
// var content = new HttpStringContent(this.CreateRequestString(requestParams), Windows.Storage.Streams.UnicodeEncoding.Utf8, contentType);
var httpResponse = await client.PostAsync(new Uri(requestUrl), content);
response = httpResponse.Content.ToString();
}
return(response);
}
internal IHttpFilter GetFilterChain()
{
if (this._filterChainStart == null)
{
LinkedListNode<IHttpFilter> currentNode = _filtersCollection.First;
while(currentNode != null && currentNode.Next != null)
{
currentNode.Value.SetNextFilter(currentNode.Next.Value);
currentNode = currentNode.Next;
}
if(_filtersCollection.Last != null) {
// Set terminatorFilter as the _filtersCollection.Last nest
_filterChainStart = _filtersCollection.First.Value;
_filtersCollection.Last.Value.SetNextFilter(_terminatorFilter);
}
else {
_filterChainStart = _terminatorFilter;
}
}
return _filterChainStart;
}
public void SetNextFilter(IHttpFilter nextFilter)
{
// This method should never be called on thoi instance, because it is the
// Pipeline terminator
throw new NotImplementedException();
}
public void SetDefaultRoute(IHttpFilter Route)
{
this.DefaultRoute = Route.FilterAsync;
}
public WinRtHttpClientHandler(IHttpFilter httpFilter)
{
_client = new rt.HttpClient(httpFilter);
}
public RedirectFilter(IHttpFilter innerFilter)
{
this.inner = innerFilter;
}
public void AddRoute(string Path, IHttpFilter Route)
{
AddRoute(Path, Route.FilterAsync);
}
public WinRtHttpClientHandler(IHttpFilter httpFilter)
{
_client = new rt.HttpClient(httpFilter);
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpHelper"/> class.
/// </summary>
/// <param name="poolSize">number of HttpClient instances allowed</param>
/// <param name="httpFilter">HttpFilter to use when instances of HttpClient are created</param>
public HttpHelper(int poolSize, IHttpFilter httpFilter)
{
_httpFilter = httpFilter;
_semaphore = new SemaphoreSlim(poolSize);
_httpClientQueue = new ConcurrentQueue <HttpClient>();
}
public void AddFilterFirst(IHttpFilter Filter)
{
FilterList.Insert(0, Filter);
}
public HttpFilter()
{
InnerFilter = new HttpBaseProtocolFilter();
}
/// <summary>
/// Full constructor.
/// </summary>
/// <param name="innerFilter">The next handler in the chain to pass requests onto.</param>
/// <param name="maxRetries">The maximum number of retries per initial request.</param>
/// <param name="maxPerRequestWaitTime">The maximum time to wait between retries. If the server requests a retry time greater than this the 429 response is returned an no wait/retry is performed. Specify <see cref="System.TimeSpan.Zero"/> for no limit.</param>
public TooManyRequestsRetryFilter(IHttpFilter innerFilter, int maxRetries, TimeSpan maxPerRequestWaitTime) : base(innerFilter, maxRetries, maxPerRequestWaitTime)
{
}
public HttpFilterPipeline(IHttpFilter lastFilter)
{
this._filtersCollection.SetTerminatorFilter(lastFilter);
}
public void AddFilterLast(IHttpFilter Filter)
{
FilterList.Add(Filter);
}
private void RemoveFilterIfExistsAndInvalidateFilterChain(IHttpFilter filter)
{
var existantFilter = GetFilterByName(filter.Name);
if (existantFilter != null)
{
this._filtersCollection.Remove(existantFilter);
}
this._filterChainStart = null;
}
public void AddLast(IHttpFilter filter)
{
this.RemoveFilterIfExistsAndInvalidateFilterChain(filter);
this._filtersCollection.AddLast(filter);
}
protected override void ConfigureHttpClient(HttpClient client, IHttpFilter filter) {
base.ConfigureHttpClient(client, filter);
HttpClientUtils.SetupClient(UrlService, client, filter);
}
public static AuthFilters.OAuth2Filter MakeFacebook(string clientId, IHttpFilter innerFilter)
{
var f = new AuthFilters.OAuth2Filter(innerFilter);
var config = new AuthFilters.AuthConfigurationData();
config.ClientId = clientId;
config.TechnicalName = "facebook.com";
config.ApiUriPrefix = "https://graph.facebook.com/";
config.SampleUri = "https://graph.facebook.com/me";
config.RedirectUri = "https://www.facebook.com/connect/login_success.html";
config.ClientSecret = "";
config.Scope = "read_stream";
config.Display = "popup";
config.State = "";
config.AdditionalParameterName = "";
config.AdditionalParameterValue = "";
config.ResponseType = ""; // blank==default "token". null doesn't marshall.
config.AccessTokenLocation = ""; // blank=default "query";
config.AccessTokenQueryParameterName = ""; // blank=default "access_token";
config.AuthorizationUri = "https://www.facebook.com/dialog/oauth";
config.AuthorizationCodeToTokenUri = "";
f.AuthConfiguration = config;
return f;
}
public AddAuthorizationHeaderFilter(IHttpFilter innerFilter)
{
if (innerFilter == null)
{
throw new ArgumentException("innerFilter cannot be null.");
}
this.innerFilter = innerFilter;
}
public void SetNextFilter(IHttpFilter nextFilter)
{
_nextFilter = nextFilter;
}
public void AddBefore(IHttpFilter filter, string nextFilterName)
{
this.RemoveFilterIfExistsAndInvalidateFilterChain(filter);
LinkedListNode<IHttpFilter> referenceFilter = GetFilterByName(nextFilterName);
this._filtersCollection.AddBefore(referenceFilter, filter);
}
