public static void EnqueueReceiveMessage(IConnection connection, IEncryption decryptor, IRateLimiter rateLimiter, ConnectionMonitor monitor, TorrentManager manager, AsyncMessageReceivedCallback callback, object state)
{
// FIXME: Hardcoded number
int count = 4;
var buffer = ClientEngine.BufferManager.GetBuffer (count);
var data = receiveCache.Dequeue ().Initialise (connection, decryptor, rateLimiter, monitor, manager, buffer, callback, state);
NetworkIO.EnqueueReceive (connection, buffer, 0, count, rateLimiter, monitor, data.ManagerMonitor, MessageLengthReceivedCallback, data);
}
public QueuedIO(IConnection connection, byte [] buffer, int offset, int count, IRateLimiter rateLimiter, TaskCompletionSource <int> tcs)
{
this.connection = connection;
this.buffer = buffer;
this.offset = offset;
this.count = count;
this.rateLimiter = rateLimiter;
this.tcs = tcs;
}
public ThrottlingFilter(
IRateLimiter rateLimiter,
IThrottleService throttleService,
IOptionsSnapshot <ThrottleOptions> throttleOptions)
{
_throttleOptions = throttleOptions.Value;
_rateLimiter = rateLimiter;
_throttleService = throttleService;
}
public void Add(IRateLimiter limiter)
{
if (rateLimiters == null)
{
rateLimiters = new List <IRateLimiter>();
}
rateLimiters.Add(limiter);
}
/// <summary>
/// Creates a new <see cref="RiotClient"/> instance.
/// </summary>
/// <param name="settings">The settings to use.</param>
/// <param name="platformId">The platform ID of the default server to connect to. This should equal one of the <see cref="Models.PlatformId"/> values.</param>
/// <param name="appRateLimiter">The rate limiter to use for proactive rate limiting.</param>
/// <remarks>
/// You should pass the same <see cref="IRateLimiter"/> instance to all <see cref="RiotClient"/> instances. Do not create multiple <see cref="IRateLimiter"/> instances.
/// Reactive rate limiting will always be used, even if a proactive rate limiter is not specified.
/// </remarks>
public RiotClient(RiotClientSettings settings, string platformId, IRateLimiter appRateLimiter)
{
this.settings = settings;
this.platformId = platformId;
this.rateLimiter = appRateLimiter;
client = CreateHttpClient();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
}
public RpcService(RpcActor localActor, IRateLimiter rateLimiter)
: this(localActor)
{
if (rateLimiter == null)
{
throw new ArgumentNullException("rateLimiter");
}
_rateLimiter = rateLimiter;
}
public void Remove(IRateLimiter limiter)
{
if (rateLimiters.Contains(limiter) == false)
{
throw new KeyNotFoundException();
}
rateLimiters.Remove(limiter);
}
public WumpusRequester(HttpClient httpClient, JsonSerializer serializer, IRateLimiter rateLimiter)
: base(httpClient)
{
_serializer = serializer;
_rateLimiter = rateLimiter;
ResponseDeserializer = new WumpusResponseDeserializer(_serializer);
RequestBodySerializer = new WumpusBodySerializer(_serializer);
RequestQueryParamSerializer = new WumpusQueryParamSerializer(_serializer);
}
public static void EnqueueSend(IConnection connection, byte[] buffer, int offset, int count,
IRateLimiter rateLimiter, ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor,
AsyncIOCallback callback, object state)
{
var data = TransferCache.Dequeue()
.Initialise(connection, buffer, offset, count, callback, state, rateLimiter, peerMonitor, managerMonitor);
lock (SendQueue)
SendOrEnqueue(data);
}
public WebAgent(IRateLimiter rateLimiter, IProxyService proxyService)
{
_rateLimiter = rateLimiter;
_proxyService = proxyService;
_acceptedEncoding = new Dictionary <string, Func <Stream, Stream> >
{
{ "gzip", (stream) => new GZipStream(stream, CompressionMode.Decompress) },
{ "deflate", (stream) => new DeflateStream(stream, CompressionMode.Decompress) }
};
}
public XeroHttpClient(string baseUri, IAuthenticator auth, IConsumer consumer, IUser user, IJsonObjectMapper jsonMapper, IXmlObjectMapper xmlMapper, IRateLimiter rateLimiter = null)
{
this.baseUri = new Uri(baseUri);
this.auth = auth;
this.consumer = consumer;
this.user = user;
this.rateLimiter = rateLimiter;
this.jsonMapper = jsonMapper;
this.xmlMapper = xmlMapper;
}
public static void EnqueueSendMessage (IConnection connection, IEncryption encryptor, PeerMessage message, IRateLimiter rateLimiter, ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor, AsyncIOCallback callback, object state)
{
int count = message.ByteLength;
var buffer = ClientEngine.BufferManager.GetBuffer (count);
message.Encode (buffer, 0);
encryptor.Encrypt (buffer, 0, count);
var data = sendCache.Dequeue ().Initialise (buffer, callback, state);
NetworkIO.EnqueueSend (connection, buffer, 0, count, rateLimiter, peerMonitor, managerMonitor, EndSendCallback, data);
}
public BinanceDexApi(IHttp http, string baseUrl, string hrp, IRateLimiter rateLimiter)
{
Throw.IfNull(http, nameof(http));
Throw.IfNullOrWhiteSpace(baseUrl, nameof(baseUrl));
this.http = http;
this.baseUrl = baseUrl;
this.Hrp = hrp;
this.rateLimiterImplementation = rateLimiter;
}
public FetchJustTimeEntriesSinceState(
ITogglApi api,
ISinceParameterRepository since,
ITimeService timeService,
ILeakyBucket leakyBucket,
IRateLimiter limiter)
: base(api, leakyBucket, since, timeService)
{
this.limiter = limiter;
}
public RateLimitingSampler(double maxTracesPerSecond, IRateLimiter rateLimiter)
{
MaxTracesPerSecond = maxTracesPerSecond;
_rateLimiter = rateLimiter ?? throw new ArgumentNullException(nameof(rateLimiter));
_tags = new Dictionary <string, object> {
{ SamplerConstants.SamplerTypeTagKey, SamplerConstants.SamplerTypeRateLimiting },
{ SamplerConstants.SamplerParamTagKey, maxTracesPerSecond }
};
}
public TheStartMethod()
{
sinceParameters = Substitute.For <ISinceParameterRepository>();
api = Substitute.For <ITogglApi>();
timeService = Substitute.For <ITimeService>();
leakyBucket = Substitute.For <ILeakyBucket>();
leakyBucket.TryClaimFreeSlots(Arg.Any <int>(), out _).Returns(true);
rateLimiter = Substitute.For <IRateLimiter>();
rateLimiter.WaitForFreeSlot().Returns(Observable.Return(Unit.Default));
timeService.CurrentDateTime.Returns(now);
state = new FetchAllSinceState(api, sinceParameters, timeService, leakyBucket, rateLimiter);
}
/// <summary>
/// Adds a rate limiter to the client. There are 2 choices, the <see cref="RateLimiterTotal"/> and the <see cref="RateLimiterPerEndpoint"/>.
/// </summary>
/// <param name="limiter">The limiter to add</param>
public void AddRateLimiter(IRateLimiter limiter)
{
if (limiter == null)
{
throw new ArgumentNullException(nameof(limiter));
}
var rateLimiters = RateLimiters.ToList();
rateLimiters.Add(limiter);
RateLimiters = rateLimiters;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="ethereumNetworkRegistry">Ethereum network registry</param>
/// <param name="groupNameGenerator">The group name generator</param>
/// <param name="environment">Execution environment</param>
/// <param name="subscriptionManager">Subscription manager</param>
/// <param name="playerCountManager">Player counter.</param>
/// <param name="rateLimiter">Rate limiter</param>
/// <param name="logger">Logger</param>
public AuthenticatedHub(IEthereumNetworkRegistry ethereumNetworkRegistry,
IGroupNameGenerator groupNameGenerator,
ExecutionEnvironment environment,
ISubscriptionManager subscriptionManager,
IPlayerCountManager playerCountManager,
IRateLimiter rateLimiter,
ILogger <AuthenticatedHub> logger)
: base(ethereumNetworkRegistry: ethereumNetworkRegistry, groupNameGenerator: groupNameGenerator, environment: environment, subscriptionManager: subscriptionManager, logger: logger)
{
this._playerCountManager = playerCountManager ?? throw new ArgumentNullException(nameof(playerCountManager));
this._rateLimiter = rateLimiter ?? throw new ArgumentNullException(nameof(rateLimiter));
}
public ComputerController(IAuthorizationService authorizationService, ILogger <ComputerController> logger, IDirectory directory,
IAuditEventProcessor reporting, IRateLimiter rateLimiter, IOptionsSnapshot <UserInterfaceOptions> userInterfaceSettings, IAuthenticationProvider authenticationProvider, IPasswordProvider passwordProvider, IJitAccessProvider jitAccessProvider)
{
this.authorizationService = authorizationService;
this.logger = logger;
this.directory = directory;
this.reporting = reporting;
this.rateLimiter = rateLimiter;
this.userInterfaceSettings = userInterfaceSettings.Value;
this.authenticationProvider = authenticationProvider;
this.passwordProvider = passwordProvider;
this.jitAccessProvider = jitAccessProvider;
}
/// <summary>
/// Creates an Instance of the TwitchAPI Class.
/// </summary>
/// <param name="loggerFactory">Instance Of LoggerFactory, otherwise no logging is used, </param>
/// <param name="rateLimiter">Instance Of RateLimiter, otherwise no ratelimiter is used.</param>
/// <param name="settings">Instance of ApiSettings, otherwise defaults used, can be changed later</param>
/// <param name="http">Instance of HttpCallHandler, otherwise default handler used</param>
public TwitchAPI(ILoggerFactory loggerFactory = null, IRateLimiter rateLimiter = null, IApiSettings settings = null, IHttpCallHandler http = null)
{
_logger = loggerFactory?.CreateLogger <TwitchAPI>();
var _rateLimiter = rateLimiter ?? BypassLimiter.CreateLimiterBypassInstance();
var _http = http ?? new TwitchHttpClient(loggerFactory?.CreateLogger <TwitchHttpClient>());
Settings = settings ?? new ApiSettings();
Helix = new Helix.Helix(loggerFactory, rateLimiter, Settings, _http);
V5 = new V5.V5(loggerFactory, _rateLimiter, Settings, _http);
ThirdParty = new ThirdParty.ThirdParty(Settings, _rateLimiter, _http);
Undocumented = new Undocumented(Settings, _rateLimiter, _http);
}
public FetchAllSinceState(
ITogglApi api,
ISinceParameterRepository since,
ITimeService timeService,
ILeakyBucket leakyBucket,
IRateLimiter limiter)
{
this.api = api;
this.since = since;
this.timeService = timeService;
this.leakyBucket = leakyBucket;
this.limiter = limiter;
}
public ReceiveMessageState Initialise(IConnection connection, IEncryption decryptor, IRateLimiter limiter, ConnectionMonitor peerMonitor, TorrentManager manager, byte[] buffer, AsyncMessageReceivedCallback callback, object state)
{
Connection = connection;
Decryptor = decryptor;
Manager = manager;
Buffer = buffer;
PeerMonitor = peerMonitor;
RateLimiter = limiter;
ManagerMonitor = manager == null ? null : manager.Monitor;
Callback = callback;
State = state;
return(this);
}
public ReceiveMessageState Initialise (IConnection connection, IEncryption decryptor, IRateLimiter limiter, ConnectionMonitor peerMonitor, TorrentManager manager, byte[] buffer, AsyncMessageReceivedCallback callback, object state)
{
Connection = connection;
Decryptor = decryptor;
Manager = manager;
Buffer = buffer;
PeerMonitor = peerMonitor;
RateLimiter = limiter;
ManagerMonitor = manager == null ? null : manager.Monitor;
Callback = callback;
State = state;
return this;
}
/// <summary>
/// Creates an Instance of the TwitchAPI Class.
/// </summary>
/// <param name="loggerFactory">Instance Of LoggerFactory, otherwise no logging is used, </param>
/// <param name="rateLimiter">Instance Of RateLimiter, otherwise no ratelimiter is used.</param>
/// <param name="settings">Instance of ApiSettings, otherwise defaults used, can be changed later</param>
/// <param name="http">Instance of HttpCallHandler, otherwise default handler used</param>
public TwitchAPI(ILoggerFactory loggerFactory = null, IRateLimiter rateLimiter = null, IApiSettings settings = null, IHttpCallHandler http = null)
{
_logger = loggerFactory?.CreateLogger <TwitchAPI>();
rateLimiter = rateLimiter ?? BypassLimiter.CreateLimiterBypassInstance();
http = http ?? new TwitchHttpClient(loggerFactory?.CreateLogger <TwitchHttpClient>());
Settings = settings ?? new ApiSettings();
Auth = new Auth.Auth(Settings, rateLimiter, http);
Helix = new Helix.Helix(loggerFactory, rateLimiter, Settings, http);
ThirdParty = new ThirdParty.ThirdParty(Settings, rateLimiter, http);
Undocumented = new Undocumented(Settings, rateLimiter, http);
Settings.PropertyChanged += SettingsPropertyChanged;
}
public static void ShouldNotPermitAnExecution(this IRateLimiter rateLimiter, TimeSpan?retryAfter = null)
{
(bool permitExecution, TimeSpan retryAfter)canExecute = rateLimiter.PermitExecution();
canExecute.permitExecution.Should().BeFalse();
if (retryAfter == null)
{
canExecute.retryAfter.Should().BeGreaterThan(TimeSpan.Zero);
}
else
{
canExecute.retryAfter.Should().Be(retryAfter.Value);
}
}
private readonly IRateLimiter _rateLimiter3; // CanExecute will always return false and tokens will not be updated on any iteration
public Single_RateLimiter()
{
_rateLimiter1 = RateLimiter
.WithRateLimit(new RateLimit(Int32.MaxValue, TimeSpan.FromMinutes(1)))
.Build();
_rateLimiter2 = RateLimiter
.WithRateLimit(new RateLimit(Int32.MaxValue, TimeSpan.MaxValue))
.Build();
_rateLimiter3 = RateLimiter
.WithRateLimit(new RateLimit(0, TimeSpan.FromMinutes(1)))
.Build();
}
private readonly IRateLimiter <int> _rateLimiter3; // CanExecute will always return false and tokens will not be updated on any iteration
public Multi_RateLimiter()
{
_rateLimiter1 = RateLimiter
.WithRateLimits(new[] { new KeyValuePair <int, RateLimit>(1, new RateLimit(Int32.MaxValue, TimeSpan.FromMinutes(1))) })
.Build();
_rateLimiter2 = RateLimiter
.WithRateLimits(new[] { new KeyValuePair <int, RateLimit>(1, new RateLimit(Int32.MaxValue, TimeSpan.MaxValue)) })
.Build();
_rateLimiter3 = RateLimiter
.WithRateLimits(new[] { new KeyValuePair <int, RateLimit>(1, new RateLimit(0, TimeSpan.FromMinutes(1))) })
.Build();
}
public RateLimitingFilter(IRateLimiter rateLimiter, HttpFilterCollection httpFilters,
Func <RateLimitingRequest, RateLimitPolicy, RateLimitingResult, HttpActionContext, Task <Decision> > onPostLimit = null,
Func <RateLimitingRequest, RateLimitPolicy, RateLimitingResult, HttpActionContext, Task> onPostLimitRevert = null,
Func <RateLimitingRequest, RateLimitPolicy, RateLimitingResult, HttpActionExecutedContext, Task <Decision> > postOperationDecisionFuncAsync = null,
Func <RateLimitingRequest, HttpActionContext, Task <RateLimitPolicy> > getPolicyFuncAsync = null,
bool simulationMode = false)
{
_rateLimiter = rateLimiter;
httpFilters.Add(new RateLimitingPostActionFilter(_filterId));
OnPostLimit = onPostLimit;
OnPostLimitRevert = onPostLimitRevert;
PostOperationDecisionFuncAsync = postOperationDecisionFuncAsync;
GetPolicyFuncAsync = getPolicyFuncAsync;
SimulationMode = simulationMode;
}
public static void EnqueueSendMessage(IConnection connection, IEncryption encryptor, PeerMessage message,
IRateLimiter rateLimiter, ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor,
AsyncIOCallback callback, object state)
{
var count = message.ByteLength;
var buffer = ClientEngine.BufferManager.GetBuffer(count);
message.Encode(buffer, 0);
encryptor.Encrypt(buffer, 0, count);
var data = SendCache.Dequeue().Initialise(buffer, callback, state);
NetworkIO.EnqueueSend(connection, buffer, 0, count, rateLimiter, peerMonitor, managerMonitor,
EndSendCallback, data);
}
public void RateLimit(Uri uri)
{
if (uri == null)
throw new ArgumentNullException("uri");
IRateLimiter rateLimiter = GetRateLimter(uri, _defaultMinCrawlDelayInMillisecs);
if (rateLimiter == null)
return;
Stopwatch timer = Stopwatch.StartNew();
rateLimiter.WaitToProceed();
timer.Stop();
if(timer.ElapsedMilliseconds > 10)
_logger.DebugFormat("Rate limited [{0}] [{1}] milliseconds", uri.AbsoluteUri, timer.ElapsedMilliseconds);
}
private static void configurePullTimeEntriesTransitions(
ITransitionConfigurator transitions,
ITogglApi api,
ITogglDataSource dataSource,
ITogglDatabase database,
IAnalyticsService analyticsService,
ITimeService timeService,
ILeakyBucket leakyBucket,
IRateLimiter rateLimiter,
ILastTimeUsageStorage lastTimeUsageStorage,
StateResult entryPoint)
{
var fetchTimeEntries = new FetchJustTimeEntriesSinceState(api, database.SinceParameters, timeService, leakyBucket, rateLimiter);
var ensureFetchTimeEntriesSucceeded = new EnsureFetchListSucceededState <ITimeEntry>();
var placeholderStateFactory = new CreatePlaceholdersStateFactory(
dataSource,
analyticsService,
lastTimeUsageStorage,
timeService);
var createWorkspacePlaceholder = placeholderStateFactory.ForWorkspaces();
var createProjectPlaceholder = placeholderStateFactory.ForProjects();
var createTaskPlaceholder = placeholderStateFactory.ForTasks();
var createTagPlaceholder = placeholderStateFactory.ForTags();
var persistTimeEntries =
new PersistListState <ITimeEntry, IDatabaseTimeEntry, IThreadSafeTimeEntry>(dataSource.TimeEntries, TimeEntry.Clean);
var updateTimeEntriesSinceDate = new UpdateSinceDateState <ITimeEntry>(database.SinceParameters);
var timeEntriesAnalytics = new TimeEntriesAnalyticsState(analyticsService);
transitions.ConfigureTransition(entryPoint, fetchTimeEntries);
transitions.ConfigureTransition(fetchTimeEntries.PreventOverloadingServer, new DeadEndState());
transitions.ConfigureTransition(fetchTimeEntries.Done, ensureFetchTimeEntriesSucceeded);
transitions.ConfigureTransition(ensureFetchTimeEntriesSucceeded.ErrorOccured, new FailureState());
transitions.ConfigureTransition(ensureFetchTimeEntriesSucceeded.Done, timeEntriesAnalytics);
transitions.ConfigureTransition(timeEntriesAnalytics.Done, createWorkspacePlaceholder);
transitions.ConfigureTransition(createWorkspacePlaceholder.Done, createProjectPlaceholder);
transitions.ConfigureTransition(createProjectPlaceholder.Done, createTaskPlaceholder);
transitions.ConfigureTransition(createTaskPlaceholder.Done, createTagPlaceholder);
transitions.ConfigureTransition(createTagPlaceholder.Done, persistTimeEntries);
transitions.ConfigureTransition(persistTimeEntries.Done, updateTimeEntriesSinceDate);
transitions.ConfigureTransition(updateTimeEntriesSinceDate.Done, new DeadEndState());
}
/// <summary>
/// Creates an Instance of the Helix Class.
/// </summary>
/// <param name="loggerFactory">Instance Of LoggerFactory, otherwise no logging is used, </param>
/// <param name="rateLimiter">Instance Of RateLimiter, otherwise no ratelimiter is used.</param>
/// <param name="settings">Instance of ApiSettings, otherwise defaults used, can be changed later</param>
/// <param name="http">Instance of HttpCallHandler, otherwise default handler used</param>
public Helix(ILoggerFactory loggerFactory = null, IRateLimiter rateLimiter = null, IApiSettings settings = null, IHttpCallHandler http = null)
{
_logger = loggerFactory?.CreateLogger <Helix>();
rateLimiter = rateLimiter ?? BypassLimiter.CreateLimiterBypassInstance();
http = http ?? new TwitchHttpClient(loggerFactory?.CreateLogger <TwitchHttpClient>());
Settings = settings ?? new ApiSettings();
Analytics = new Analytics(Settings, rateLimiter, http);
Bits = new Bits(Settings, rateLimiter, http);
Clips = new Clips(Settings, rateLimiter, http);
Entitlements = new Entitlements(Settings, rateLimiter, http);
Games = new Games(Settings, rateLimiter, http);
Streams = new Streams(Settings, rateLimiter, http);
Users = new Users(Settings, rateLimiter, http);
Videos = new Videos(Settings, rateLimiter, http);
Webhooks = new Webhooks(Settings, rateLimiter, http);
}
public AsyncIOState Initialise(IConnection connection, byte[] buffer, int offset, int count,
AsyncIOCallback callback,
object state, IRateLimiter limiter,
ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor)
{
Connection = connection;
Buffer = buffer;
Count = count;
Callback = callback;
Offset = offset;
ManagerMonitor = managerMonitor;
PeerMonitor = peerMonitor;
RateLimiter = limiter;
Remaining = count;
State = state;
return this;
}
public AsyncIOState Initialise(IConnection connection, byte[] buffer, int offset, int count,
AsyncIOCallback callback,
object state, IRateLimiter limiter,
ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor)
{
Connection = connection;
Buffer = buffer;
Count = count;
Callback = callback;
Offset = offset;
ManagerMonitor = managerMonitor;
PeerMonitor = peerMonitor;
RateLimiter = limiter;
Remaining = count;
State = state;
return(this);
}
public ThrottlingIntegrationProxy(IIntegrationProxy innerIntegrationProxy, IRateLimiter rateLimiter)
{
_innerIntegrationProxy = innerIntegrationProxy;
_rateLimiter = rateLimiter;
}
protected XeroApi(string baseUri, ICertificateAuthenticator auth, IConsumer consumer, IUser user, IJsonObjectMapper readMapper, IXmlObjectMapper writeMapper, IRateLimiter rateLimiter)
: this(baseUri)
{
Client = new XeroHttpClient(baseUri, auth, consumer, user, readMapper, writeMapper, rateLimiter);
}
public HttpClient(string baseUri, IAuthenticator auth, IConsumer consumer, IUser user, IRateLimiter rateLimiter)
: this(baseUri, auth, consumer, user)
{
_rateLimiter = rateLimiter;
}
protected PayrollApi(string baseUri, IAuthenticator auth, IConsumer consumer, IUser user, IJsonObjectMapper readMapper, IXmlObjectMapper writeMapper, IRateLimiter rateLimiter)
: base(baseUri, auth, consumer, user, readMapper, writeMapper, rateLimiter)
{
}
public void Add(IRateLimiter limiter)
{
Check.Limiter(limiter);
limiters.Add(limiter);
}
public void Remove(IRateLimiter limiter)
{
Check.Limiter(limiter);
limiters.Remove(limiter);
}
public XeroCoreApi(string baseUri, ICertificateAuthenticator auth, IConsumer consumer, IUser user, IRateLimiter rateLimiter)
: this(baseUri, auth, consumer, user, new DefaultMapper(), new DefaultMapper(), rateLimiter)
{
}
public XeroCoreApi(string baseUri, ICertificateAuthenticator auth, IConsumer consumer, IUser user, IJsonObjectMapper readMapper, IXmlObjectMapper writeMapper, IRateLimiter rateLimiter)
: base(baseUri, auth, consumer, user, readMapper, writeMapper, rateLimiter)
{
Connect();
}
public AustralianPayroll(string baseUri, IAuthenticator auth, IConsumer consumer, IUser user, IJsonObjectMapper readMapper, IXmlObjectMapper writeMapper, IRateLimiter rateLimiter)
: base(baseUri, auth, consumer, user, readMapper, writeMapper, rateLimiter)
{
Connect();
}
public static void EnqueueSend(IConnection connection, byte[] buffer, int offset, int count, IRateLimiter rateLimiter, ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor, AsyncIOCallback callback, object state)
{
var data = transferCache.Dequeue ().Initialise (connection, buffer, offset, count, callback, state, rateLimiter, peerMonitor, managerMonitor);
lock (sendQueue)
SendOrEnqueue (data);
}
public GlobalRateLimiter(IRateLimiter limiter)
{
Check.Limiter(limiter);
this.limiter = limiter;
}
