// TODO: // Hardcode a time out value for cancellation token. // For some time consuming operations, this time out needs to be tuned. public static Task BatchProcess <T>(IList <T> source, Func <T, Task> f, int max) { var initial = (max >> 1); var s = new System.Threading.SemaphoreSlim(initial, max); _ = Task.Run(async() => { for (int i = initial; i < max; i++) { await Task.Delay(100); s.Release(); } }); return(Task.WhenAll(from item in source select Task.Run(async() => { await s.WaitAsync(); try { await f(item); } catch (Exception e) { Log.Warning($"see exception in {f.Method.Name}: {e.Message}"); } finally { s.Release(); } }))); }
public void ProducerShouldReportCorrectAmountOfAsyncRequests() { var semaphore = new SemaphoreSlim(0); var routerProxy = new FakeBrokerRouter(); //block the second call returning from send message async routerProxy.BrokerConn0.ProduceResponseFunction = () => { semaphore.Wait(); return new ProduceResponse(); }; var router = routerProxy.Create(); using (var producer = new Producer(router, maximumAsyncRequests: 1) { BatchSize = 1 }) { var messages = new[] { new Message("1") }; Assert.That(producer.AsyncCount, Is.EqualTo(0)); var sendTask = producer.SendMessageAsync(BrokerRouterProxy.TestTopic, messages); TaskTest.WaitFor(() => producer.AsyncCount > 0); Assert.That(producer.AsyncCount, Is.EqualTo(1), "One async operation should be sending."); semaphore.Release(); sendTask.Wait(TimeSpan.FromMilliseconds(500)); Assert.That(sendTask.IsCompleted, Is.True, "Send task should be marked as completed."); Assert.That(producer.AsyncCount, Is.EqualTo(0), "Async should now show zero count."); } }
private static void TaskMain(SemaphoreSlim semaphore) { bool isCompleted = false; while (!isCompleted) { if (semaphore.Wait(600)) { try { WriteLine($"Task {Task.CurrentId} locks the semaphore"); Task.Delay(2000).Wait(); } finally { WriteLine($"Task {Task.CurrentId} releases the semaphore"); semaphore.Release(); isCompleted = true; } } else { WriteLine($"Timeout for task {Task.CurrentId}; wait again"); } } }
private async Task ExclusiveTask(SemaphoreSlim s, Integer count, int seed, int iteration, bool due) { var r = new Random(seed); if (due) { try { await Delay(r).ConfigureAwait(false); } catch { } } for (int i = 0; i < iteration; i++) { int localCount = 0; try { await s.WaitAsync(); localCount = count.Value; await Delay(r).ConfigureAwait(false); } catch (TestException) { } finally { count.Value = localCount + 1; s.Release(); } } }
public void Execute(IJobExecutionContext context) { var stopwatch = new Stopwatch(); stopwatch.Start(); Logger.Info("开始抓取一号店数据"); var downloadedCategories = new YhdCategoryExtractor().Extract().Result; var needProcessCategories = _CategoryArchiveService.Archive(downloadedCategories).OrderBy(c => c.ProductsUpdateTime); var taskLock = new SemaphoreSlim(initialCount: 1); var tasks = needProcessCategories.Select(async (category, index) => { await taskLock.WaitAsync(); try { var result = await ProcessCategoryAsync(category); //■◆▲●□◇△○ Logger.Info(string.Join(" ", new[]{ string.Format("{0}", index + 1), string.Format("[{0}]{1}", category.Number, category.Name), string.Format("□{0} △{1}", result.Total, result.Changed) })); } catch (Exception e) { Logger.ErrorFormat("处理分类{0}{1}失败", e, category.Name, category.Number); } finally { taskLock.Release(); } }); Task.WaitAll(tasks.ToArray()); Logger.InfoFormat("抓取一号店数据完成,用时{0:0.#}分", stopwatch.Elapsed.TotalMinutes); }
internal BufferStream() { _readLock = new SemaphoreSlim(1, 1); _writeLock = new SemaphoreSlim(1, 1); _bufferedData = new ConcurrentQueue<byte[]>(); _readWaitingForData = new TaskCompletionSource<object>(); }
static void Main(string[] args) { // initialize the semaphores semA = new SemaphoreSlim(2); semB = new SemaphoreSlim(2); // define the number of tasks we will use int taskCount = 10; // initialize the barrier cdEvent = new CountdownEvent(taskCount); Task[] tasks = new Task[10]; for (int i = 0; i < taskCount; i++) { tasks[i] = Task.Factory.StartNew((stateObject) => { InitialMethod((int)stateObject); Console.WriteLine("Task {0} completed", Task.CurrentId); }, i); } // wait for all of the tasks to have reached a terminal method cdEvent.Wait(); // throw an exception to force the debugger to break throw new Exception(); }
public FriendRequestsViewModel() { Items = new ObservableCollection<OneFriendRequestViewModel>(); Items.CollectionChanged += FriendRequestsCollectionChangedHandler; ToxModel.Instance.FriendRequestReceived += FriendRequestReceivedHandler; _semaphore = new SemaphoreSlim(1); }
private async Task TestCancelWaitAsyncInternal() { var r = new Random(); var s = new SemaphoreSlim(1); await Task.WhenAll(Enumerable.Range(0, 100).Select(async i => { var ct = CancellationToken.None; if ((i % 5) == 0) { var cts = new CancellationTokenSource(); var t = Task.Delay(1).ContinueWith(_ => cts.Cancel()); ct = cts.Token; } try { await s.WaitAsync(ct); await Delay(r, ct).ConfigureAwait(false); } catch (TestException) { } catch (OperationCanceledException) { } finally { s.Release(); } })); }
/// <summary> /// Initialises a new instance of the <see cref="BaseClient"/> class. /// </summary> /// <param name="byteStream">The byte stream.</param> /// <param name="token">The token.</param> protected BaseClient(IByteStream byteStream, CancellationToken token) { this.ByteStream = byteStream; this.SendRateLimit = new SemaphoreSlim(1); this.InternalCancellation = new CancellationTokenSource(); token.Register(() => this.InternalCancellation.Cancel()); }
internal AudioPlayer() { this.audioPlayerCallback = new DummyMediaPlayerCallback(); this.videoPlayerCallback = new DummyMediaPlayerCallback(); this.currentCallback = new DummyMediaPlayerCallback(); this.finishSubscription = new SerialDisposable(); this.gate = new SemaphoreSlim(1, 1); this.playbackState = new BehaviorSubject<AudioPlayerState>(AudioPlayerState.None); this.PlaybackState = this.playbackState.DistinctUntilChanged(); this.loadedSong = new BehaviorSubject<Song>(null); this.TotalTime = this.loadedSong.Select(x => x == null ? TimeSpan.Zero : x.Duration); this.currentTimeChangedFromOuter = new Subject<TimeSpan>(); var conn = Observable.Interval(TimeSpan.FromMilliseconds(300), RxApp.TaskpoolScheduler) .CombineLatest(this.PlaybackState, (l, state) => state) .Where(x => x == AudioPlayerState.Playing) .Select(_ => this.CurrentTime) .Merge(this.currentTimeChangedFromOuter) .DistinctUntilChanged(x => x.TotalSeconds) .Publish(TimeSpan.Zero); conn.Connect(); this.CurrentTimeChanged = conn; }
static void TaskMain(SemaphoreSlim semaphore) { bool isCompleted = false; while (!isCompleted) { if (semaphore.Wait(600)) { try { Console.WriteLine("Task {0} locks the semaphore", Task.CurrentId); Thread.Sleep(2000); } finally { Console.WriteLine("Task {0} releases the semaphore", Task.CurrentId); semaphore.Release(); isCompleted = true; } } else { Console.WriteLine("Timeout for task {0}; wait again", Task.CurrentId); } } }
public AwaitingConnectedSpheroRunner(IStreamSocketWrapper streamSpheroWrapper) { _streamSpheroWrapper = streamSpheroWrapper; _itemsToSendEvent = new SemaphoreSlim(1); _itemsToSendEvent.Wait(); _commandsToSend = new Queue<CommandWithActions>(); }
public void ExtremeDisposal() { using (var context = CreateContext()) { Assert.AreEqual(-1, context.Publisher.MySettings.MaxConnectionRetry, "For this test, we want the worst situation"); context.Publisher.Start(0); Assert.IsTrue(context.Publisher.Started); var message = new byte[] { 0, 1, 1 }; var connectionFail = new SemaphoreSlim(0); context.Model.Setup(m => m.BasicPublish(It.IsAny<string>(), It.IsAny<string>(), context.Publisher.Props, message)).Throws(new Exception("I don't want your message anymore")); context.Connection.Setup(c => c.CreateModel()).Callback(() => connectionFail.Release(1)).Throws(new Exception("And I don't want to accept your connection either")); context.Publisher.Publish("test", message); /* The way callbacks are implemented on exception throwing mocks does not garantee * that the callback is called "after" the exception is thrown. * If we wait for two, we are sure at least one has been finished ! */ Assert.IsTrue(connectionFail.Wait(1000)); Assert.IsTrue(connectionFail.Wait(1000)); context.Publisher.Dispose(); context.Publisher = null; //to avoid the double dispose of Publisher //The real test here is that eventually the Dispose method returns Assert.Pass(); } }
public static async Task <T> DeserializeAsync <T>(Windows.Storage.StorageFile f, System.Threading.SemaphoreSlim semaphore) where T : class { await semaphore.WaitAsync(); try { if (f is null) { return(null); } using var s1 = await f.OpenAsync(Windows.Storage.FileAccessMode.Read); using var s2 = s1.AsStream(); var serializer = new System.Xml.Serialization.XmlSerializer(typeof(T)); return(serializer.Deserialize(s2) as T); } catch { return(null); } finally { semaphore.Release(); } }
public static bool CancelAfterWait() { TestHarness.TestLog("* SemaphoreSlimCancellationTests.CancelAfterWait()"); bool passed = true; CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); CancellationToken cancellationToken = cancellationTokenSource.Token; SemaphoreSlim semaphoreSlim = new SemaphoreSlim(0); // semaphore that will block all waiters ThreadPool.QueueUserWorkItem( (args) => { Thread.Sleep(1000); cancellationTokenSource.Cancel(); } ); //Now wait.. the wait should abort and an exception should be thrown passed &= TestHarnessAssert.EnsureOperationCanceledExceptionThrown( () => semaphoreSlim.Wait(cancellationToken), cancellationToken, "An OCE(null) should have been thrown that references the cancellationToken."); // the token should not have any listeners. // currently we don't expose this.. but it was verified manually return passed; }
/// <summary> /// Initializes a new instance of the <see cref="FFImageLoading.Cache.DiskCache"/> class. /// </summary> /// <param name="basePath">Base path.</param> /// <param name="version">Version.</param> public DiskCache(string basePath, string version) { // Can't use minilogger here, we would have too many dependencies System.Diagnostics.Debug.WriteLine("DiskCache path: " + basePath); this.basePath = basePath; if (!Directory.Exists(basePath)) Directory.CreateDirectory(basePath); this.journalPath = Path.Combine(basePath, JournalFileName); this.version = version; this.lockJournal = new object(); this.fileWriteLock = new SemaphoreSlim(initialCount: 1); this.fileWritePendingTasks = new ConcurrentDictionary<string, byte>(); try { InitializeWithJournal (); } catch { Directory.Delete (basePath, true); Directory.CreateDirectory (basePath); } ThreadPool.QueueUserWorkItem(CleanCallback); }
public async Task<TokenPair> Authorize(string clientId, string clientSecret, IEnumerable<string> scopes) { string uri = string.Format("/LoginPage.xaml?authEndpoint={0}&clientId={1}&scope={2}", authEndpoint, clientId, string.Join(" ", scopes)); SemaphoreSlim semaphore = new SemaphoreSlim(0, 1); Observable.FromEvent<NavigatingCancelEventHandler, NavigatingCancelEventArgs>( h => new NavigatingCancelEventHandler(h), h => this.frame.Navigating += h, h => this.frame.Navigating -= h) .SkipWhile(h => h.EventArgs.NavigationMode != NavigationMode.Back) .Take(1) .Subscribe(e => semaphore.Release()); frame.Navigate(new Uri(uri, UriKind.Relative)); await semaphore.WaitAsync(); string authorizationCode = (string)PhoneApplicationService.Current.State["OAuth_Demo.AuthorizationCode"]; return await RequestAccessToken(authorizationCode, clientId, clientSecret); }
internal WebSocketConnectionRfc6455(Stream clientStream, WebSocketListenerOptions options) { if (clientStream == null) throw new ArgumentNullException("clientStream"); if (options == null) throw new ArgumentNullException("options"); _writeSemaphore = new SemaphoreSlim(1); _options = options; _clientStream = clientStream; if (options.BufferManager != null) _buffer = options.BufferManager.TakeBuffer(14 + 125 + 125 + 8 + 10 + _options.SendBufferSize + 4 + 2); else _buffer = new Byte[14 + 125 + 125 + 8 + 10 + _options.SendBufferSize + 4 + 2]; _headerBuffer = new ArraySegment<Byte>(_buffer, 0, 14); _controlBuffer = new ArraySegment<Byte>(_buffer, 14, 125); _pongBuffer = new ArraySegment<Byte>(_buffer, 14 + 125, 125); _pingBuffer = new ArraySegment<Byte>(_buffer, 14 + 125 + 125, 8); SendBuffer = new ArraySegment<Byte>(_buffer, 14 + 125 + 125 + 8 + 10, _options.SendBufferSize); _keyBuffer = new ArraySegment<Byte>(_buffer, 14 + 125 + 125 + 8 + 10 + _options.SendBufferSize, 4); _closeBuffer = new ArraySegment<Byte>(_buffer, 14 + 125 + 125 + 8 + 10 + _options.SendBufferSize + 4, 2); _pingTimeout = _options.PingTimeout; _pingInterval = TimeSpan.FromMilliseconds(Math.Min(500, _options.PingTimeout.TotalMilliseconds / 2)); }
public async Task<AuthorizationResult> AcquireAuthorizationAsync(Uri authorizationUri, Uri redirectUri, IDictionary<string, string> additionalHeaders, CallState callState) { returnedUriReady = new SemaphoreSlim(0); Authenticate(authorizationUri, redirectUri, additionalHeaders, callState); await returnedUriReady.WaitAsync().ConfigureAwait(false); return authorizationResult; }
// constructors public ExclusiveConnectionPool( ServerId serverId, EndPoint endPoint, ConnectionPoolSettings settings, IConnectionFactory connectionFactory, IEventSubscriber eventSubscriber) { _serverId = Ensure.IsNotNull(serverId, nameof(serverId)); _endPoint = Ensure.IsNotNull(endPoint, nameof(endPoint)); _settings = Ensure.IsNotNull(settings, nameof(settings)); _connectionFactory = Ensure.IsNotNull(connectionFactory, nameof(connectionFactory)); Ensure.IsNotNull(eventSubscriber, nameof(eventSubscriber)); _connectionHolder = new ListConnectionHolder(eventSubscriber); _poolQueue = new WaitQueue(settings.MaxConnections); _waitQueue = new SemaphoreSlim(settings.WaitQueueSize); _maintenanceCancellationTokenSource = new CancellationTokenSource(); _state = new InterlockedInt32(State.Initial); eventSubscriber.TryGetEventHandler(out _checkingOutConnectionEventHandler); eventSubscriber.TryGetEventHandler(out _checkedOutConnectionEventHandler); eventSubscriber.TryGetEventHandler(out _checkingOutConnectionFailedEventHandler); eventSubscriber.TryGetEventHandler(out _checkingInConnectionEventHandler); eventSubscriber.TryGetEventHandler(out _checkedInConnectionEventHandler); eventSubscriber.TryGetEventHandler(out _addingConnectionEventHandler); eventSubscriber.TryGetEventHandler(out _addedConnectionEventHandler); eventSubscriber.TryGetEventHandler(out _openingEventHandler); eventSubscriber.TryGetEventHandler(out _openedEventHandler); eventSubscriber.TryGetEventHandler(out _closingEventHandler); eventSubscriber.TryGetEventHandler(out _closedEventHandler); eventSubscriber.TryGetEventHandler(out _addingConnectionEventHandler); eventSubscriber.TryGetEventHandler(out _addedConnectionEventHandler); }
public ConcurrentRunner(int maxThread, int loopEach, AutoResetEvent signal = null) { this.maxThread = maxThread; this.loopEach = loopEach; this.semaphore = new SemaphoreSlim(0, maxThread); this.signal = signal; }
//#################################################################################################################################################################### public GitHubUtils() { _settingsHelper = new SettingsHelper(this.GetType().Assembly); GitHubReleases.CollectionChanged += GitHubReleases_CollectionChanged; SemaphoreGetReleases = new System.Threading.SemaphoreSlim(0, 1); Task.Run(async() => await GetAllGitHubReleases()); }
// WIP, not producing useful numbers yet. Assumes one partition. public static async Task<long> Consume(string broker, string topic) { long n = 0; var topicConfig = new TopicConfig(); topicConfig["auto.offset.reset"] = "smallest"; var config = new Config() { GroupId = "benchmark-consumer", DefaultTopicConfig = topicConfig }; using (var consumer = new EventConsumer(config, broker)) { var signal = new SemaphoreSlim(0, 1); consumer.OnMessage += (obj, msg) => { n += 1; }; consumer.OnEndReached += (obj, end) => { Console.WriteLine($"End reached"); signal.Release(); }; consumer.Subscribe(new List<string>{topic}); consumer.Start(); await signal.WaitAsync(); Console.WriteLine($"Shutting down"); } return n; }
public ConcurrentRunner(int maxThread, int loopEach) { this.maxThread = maxThread; this.loopEach = loopEach; this.semaphore = new SemaphoreSlim(0, maxThread); this.countdown = new CountdownEvent(maxThread); }
public QueueProcessor(int maxConcurrentJobs, JobQueue jobQueue) { _semaphore = new SemaphoreSlim(maxConcurrentJobs); _jobQueue = jobQueue; Task.Factory.StartNew(TaskStartLoop, _cancellationTokenSource.Token); _jobQueue.JobAdded += JobQueueOnJobAdded; }
public HttpNegotiationQueue(WebSocketFactoryCollection standards, WebSocketConnectionExtensionCollection extensions, WebSocketListenerOptions options) { Guard.ParameterCannotBeNull(standards, "standards"); Guard.ParameterCannotBeNull(extensions, "extensions"); Guard.ParameterCannotBeNull(options, "options"); _options = options; _extensions = extensions; _cancel = new CancellationTokenSource(); _semaphore = new SemaphoreSlim(options.ParallelNegotiations); _sockets = new BufferBlock<Socket>(new DataflowBlockOptions() { BoundedCapacity = options.NegotiationQueueCapacity, CancellationToken = _cancel.Token }); _negotiations = new BufferBlock<WebSocketNegotiationResult>(new DataflowBlockOptions() { BoundedCapacity = options.NegotiationQueueCapacity, CancellationToken = _cancel.Token, }); _cancel.Token.Register(_sockets.Complete); _cancel.Token.Register(_negotiations.Complete); _handShaker = new WebSocketHandshaker(standards, _options); Task.Run((Func<Task>)WorkAsync); }
public static async Task<HttpResponseMessage> GetWithRetryAsync(this HttpClient client, string url, SemaphoreSlim semaphore, params int[] retryDelay) { if (retryDelay.Any(delay => delay <= 0)) { throw new ArgumentException("Delay should be greate than 0.", nameof(retryDelay)); } await semaphore.WaitAsync(); try { int retryCount = 0; while (true) { try { return await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead); } catch (TaskCanceledException) { if (retryCount >= retryDelay.Length) { throw; } } await Task.Delay(retryDelay[retryCount]); retryCount++; } } finally { semaphore.Release(); } }
static int Main(string[] args) { SemaphoreSlim s = new SemaphoreSlim(initialCount: 1); var cts = new CancellationTokenSource(); s.Wait(); var t = s.WaitAsync(cts.Token); s.Release(); cts.Cancel(); if (t.Status != TaskStatus.Canceled && s.CurrentCount == 0) { Console.WriteLine("PASS"); return 100; } else { Console.WriteLine("FAIL"); Console.WriteLine("Expected task status to not be Canceled and s.CurrentCount == 0"); Console.WriteLine("Actual: Task: " + t.Status + "; CurrentCount: " + s.CurrentCount); return 101; } }
/// <summary> /// Ensures the list. /// </summary> /// <param name="url">The URL.</param> /// <param name="file">The file.</param> /// <param name="httpClient">The HTTP client.</param> /// <param name="fileSystem">The file system.</param> /// <param name="semaphore">The semaphore.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>Task.</returns> public static async Task EnsureList(string url, string file, IHttpClient httpClient, IFileSystem fileSystem, SemaphoreSlim semaphore, CancellationToken cancellationToken) { var fileInfo = fileSystem.GetFileInfo(file); if (!fileInfo.Exists || (DateTime.UtcNow - fileSystem.GetLastWriteTimeUtc(fileInfo)).TotalDays > 1) { await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false); try { var temp = await httpClient.GetTempFile(new HttpRequestOptions { CancellationToken = cancellationToken, Progress = new Progress<double>(), Url = url }).ConfigureAwait(false); fileSystem.CreateDirectory(Path.GetDirectoryName(file)); fileSystem.CopyFile(temp, file, true); } finally { semaphore.Release(); } } }
private ServiceContext() { _Slots = new List<ServiceSlot>(); _StartSemaphore = new SemaphoreSlim(0); _StopSemaphore = new SemaphoreSlim(0); }
/// <summary> /// Construct a Producer class. /// </summary> /// <param name="brokerRouter">The router used to direct produced messages to the correct partition.</param> /// <param name="maximumAsyncQueue">The maximum async calls allowed before blocking new requests. -1 indicates unlimited.</param> /// <remarks> /// The maximumAsyncQueue parameter provides a mechanism for blocking an async request return if the amount of requests queue is /// over a certain limit. This is usefull if a client is trying to push a large stream of documents through the producer and /// wants to block downstream if the producer is overloaded. /// /// A message will start its timeout countdown as soon as it is added to the producer async queue. If there are a large number of /// messages sitting in the async queue then a message may spend its entire timeout cycle waiting in this queue and never getting /// attempted to send to Kafka before a timeout exception is thrown. /// </remarks> public Producer(IBrokerRouter brokerRouter, int maximumAsyncQueue = -1) { _router = brokerRouter; _metadataQueries = new MetadataQueries(_router); _maximumAsyncQueue = maximumAsyncQueue == -1 ? int.MaxValue : maximumAsyncQueue; _sendSemaphore = new SemaphoreSlim(_maximumAsyncQueue, _maximumAsyncQueue); }
public void AsyncLockShouldAllowOnlyOneThread() { var block = new SemaphoreSlim(0, 2); var count = 0; var alock = new AsyncLock(); var firstCall = Task.Factory.StartNew(async () => { using (await alock.LockAsync()) { Interlocked.Increment(ref count); block.Wait(); } block.Wait();//keep this thread busy }); TaskTest.WaitFor(() => count > 0); alock.LockAsync().ContinueWith(t => Interlocked.Increment(ref count)); Assert.That(count, Is.EqualTo(1), "Only one task should have gotten past lock."); Assert.That(firstCall.IsCompleted, Is.False, "Task should still be running."); block.Release(); TaskTest.WaitFor(() => count > 1); Assert.That(count, Is.EqualTo(2), "Second call should get past lock."); Assert.That(firstCall.IsCompleted, Is.False, "First call should still be busy."); block.Release(); }
public static Task <TOut[]> BatchProcess <T, TOut>(IList <T> source, Func <T, Task <TOut> > f, int max) { var initial = (max >> 1); var s = new System.Threading.SemaphoreSlim(initial, max); _ = Task.Run(async() => { for (int i = initial; i < max; i++) { await Task.Delay(100); s.Release(); } }); return(Task.WhenAll(from item in source select Task.Run(async() => { TOut ret = default; var retry = 0; var maxRetry = 5; while (retry < maxRetry) { try { using (var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(60))) { await s.WaitAsync(cancellationTokenSource.Token); try { ret = await f(item); break; } catch (System.OperationCanceledException e) { Log.Warning($"see cancellation in {f.Method.Name}: {e.Message}"); } finally { s.Release(); } } } catch (System.OperationCanceledException) { Log.Warning($"Waiting too long time to obtain the semaphore: current: {s.CurrentCount}, max: {max}"); } var rand = new Random(); var randomDelay = TimeSpan.FromMilliseconds(rand.Next(1, 500)); await Task.Delay(randomDelay); retry++; } if (retry == maxRetry) { Log.Error($"The operation {f.Method.Name} was canceled because of reaching max retry {maxRetry}"); } return ret; }))); }
public async Task <object> RoundtripMethodCallAsync(string connectionId, string methodName, MethodRequestAndResponse requestAndResponse) { Console.WriteLine("RoundtripMethodCallAsync received for {0} and methodName {1}", connectionId, methodName); Console.WriteLine(JsonConvert.SerializeObject(requestAndResponse)); var client = objectMap[connectionId]; var mutex = new System.Threading.SemaphoreSlim(1); await mutex.WaitAsync().ConfigureAwait(false); // Grab the mutex. The handler will release it later MethodCallback callback = async(methodRequest, userContext) => { Console.WriteLine("Method invocation received"); object request = JsonConvert.DeserializeObject(methodRequest.DataAsJson); string received = JsonConvert.SerializeObject(new JRaw(request)); string expected = ((Newtonsoft.Json.Linq.JToken)requestAndResponse.RequestPayload)["payload"].ToString(); Console.WriteLine("request expected: " + expected); Console.WriteLine("request received: " + received); if (expected != received) { Console.WriteLine("request did not match expectations"); Console.WriteLine("Releasing the method mutex"); mutex.Release(); return(new MethodResponse(500)); } else { int status = 200; if (requestAndResponse.StatusCode != null) { status = (int)requestAndResponse.StatusCode; } byte[] responseBytes = GlueUtils.ObjectToBytes(requestAndResponse.ResponsePayload); Console.WriteLine("Releasing the method mutex"); mutex.Release(); Console.WriteLine("Returning the result"); return(new MethodResponse(responseBytes, status)); } }; Console.WriteLine("Setting the handler"); await client.SetMethodHandlerAsync(methodName, callback, null).ConfigureAwait(false); Console.WriteLine("Waiting on the method mutex"); await mutex.WaitAsync().ConfigureAwait(false); Console.WriteLine("Method mutex released. Waiting for a tiny bit."); // Otherwise, the connection might close before the response is actually sent await Task.Delay(100).ConfigureAwait(false); Console.WriteLine("Nulling the handler"); await client.SetMethodHandlerAsync(methodName, null, null).ConfigureAwait(false); Console.WriteLine("RoundtripMethodCallAsync is complete"); return(new object()); }
public async Task <EventBody> WaitForInputMessageAsync(string connectionId, string inputName) { Console.WriteLine("WaitForInputMessageAsync received for {0} with inputName {1}", connectionId, inputName); var mutex = new System.Threading.SemaphoreSlim(1); await mutex.WaitAsync().ConfigureAwait(false); // Grab the mutex. The handler will release it later byte[] bytes = null; var client = objectMap[connectionId]; MessageHandler handler = async(msg, context) => { Console.WriteLine("message received"); bytes = msg.GetBytes(); await client.SetInputMessageHandlerAsync(inputName, null, null).ConfigureAwait(false); Console.WriteLine("releasing inputMessage mutex"); mutex.Release(); return(MessageResponse.Completed); }; Console.WriteLine("Setting input handler"); await client.SetInputMessageHandlerAsync(inputName, handler, null).ConfigureAwait(false); Console.WriteLine("Waiting for inputMessage mutex to release"); await mutex.WaitAsync().ConfigureAwait(false); Console.WriteLine("mutex triggered."); string s = Encoding.UTF8.GetString(bytes); Console.WriteLine("message = {0}", s as object); object result; try { result = JsonConvert.DeserializeObject(s); } catch (JsonReaderException) { result = s; } return(new Models.EventBody { Body = result }); }
static async Task Main(string[] args) { // Create the semaphore. semaphore = new System.Threading.SemaphoreSlim(0, 3); Console.WriteLine("{0} tasks can enter the semaphore.", semaphore.CurrentCount); Task[] tasks = new Task[5]; // Create and start five numbered tasks. for (int i = 0; i <= 4; i++) { tasks[i] = Task.Run(() => { // Each task begins by requesting the semaphore. Console.WriteLine("Task {0} begins and waits for the semaphore.", Task.CurrentId); semaphore.Wait(); Interlocked.Add(ref padding, 100); Console.WriteLine("Task {0} enters the semaphore.", Task.CurrentId); // The task just sleeps for 1+ seconds. Thread.Sleep(1000 + padding); Console.WriteLine("Task {0} releases the semaphore; previous count: {1}.", Task.CurrentId, semaphore.Release()); }); } // Wait for half a second, to allow all the tasks to start and block. Thread.Sleep(500); // Restore the semaphore count to its maximum value. Console.WriteLine("Main thread calls Release(3) --> "); semaphore.Release(3); Console.WriteLine(" {0} tasks can enter the semaphore.", semaphore.CurrentCount); // Main thread waits for the tasks to complete. await Task.WhenAll(tasks); Console.WriteLine("Main thread exits."); Console.ReadLine(); }
/// <summary> /// Constructor of SemaphoreSlim class /// </summary> /// <param name="context">Specify a context to have different contexts in different domains</param> /// <param name="name">Name of the new SemaphoreSlim</param> /// <param name="initialCount">The initial number of requests for the semaphoreSlim that can be granted concurrently.</param> /// <param name="maximumCount">The maximum number of requests for the semaphoreSlim that can be granted concurrently.</param> public SemaphoreSlim(Context.SemaphoreSlim context, string name, int initialCount, int maximumCount) : base(context) { ContextMapper = ctx => ctx ?? _defaultContext; if (!ContextMapper.Invoke(context).ObjectDictionary.TryGetValue(name, out var tempSemaphoreSlim)) { lock (ContextMapper.Invoke(context).LockerObject) { if (!ContextMapper.Invoke(context).ObjectDictionary.TryGetValue(name, out tempSemaphoreSlim)) { _currentObject = new System.Threading.SemaphoreSlim(initialCount, maximumCount); ContextMapper.Invoke(context).ObjectDictionary.TryAdd(name, _currentObject); } } } if (tempSemaphoreSlim != null) { _currentObject = (System.Threading.SemaphoreSlim)tempSemaphoreSlim; } }
public async Task <object> WaitForDesiredPropertyPatchAsync(string connectionId) { // Since there's no way to un-register for a patch, we have a global patch handler. We keep the // "last desired props received" in a member varaible along with a mutex to trigger when this changes. // Not very cool and not very thread safe :( Console.WriteLine("WaitForDesiredPropertyPatchAsync received for " + connectionId); var client = objectMap[connectionId]; var mutex = new System.Threading.SemaphoreSlim(1); await mutex.WaitAsync().ConfigureAwait(false); // Grab the mutex. The handler will release it later desiredPropMutex = mutex; Console.WriteLine("Waiting for patch"); await mutex.WaitAsync().ConfigureAwait(false); Console.WriteLine("mutex triggered."); Console.WriteLine("Returning patch:"); Console.WriteLine(JsonConvert.SerializeObject(lastDesiredProps)); return(lastDesiredProps); }
public void ScpToRemote(List <string> files, string dir_path, string dir, IVsOutputWindowPane outputWindowPane) { try { lock (lock_obj) { // ThreadHelper.ThrowIfNotOnUIThread(); var dte = Package.GetGlobalService(typeof(DTE)) as EnvDTE80.DTE2; dte.Windows.Item(EnvDTE.Constants.vsWindowKindOutput).Activate(); if (files.Count == 0) { outputWindowPane.OutputStringThreadSafe("No file can be copied"); return; } ConnectionInfoStore connectionInfoStore = new ConnectionInfoStore(); connectionInfoStore.Load(); if (connectionInfoStore.Connections.Count < 1) { outputWindowPane.OutputStringThreadSafe("No connection found. Add connection in [Tools] / [Options] / [Cross Platform]"); return; } outputWindowPane.OutputStringThreadSafe("Connecting...\n"); if (remoteSystem == null) { remoteSystem = new RemoteSystem((ConnectionInfo)connectionInfoStore.Connections[0]); directory = remoteSystem.FileSystem.GetDirectory(SpecialDirectory.Home); } using (var concurrencySemaphore = new System.Threading.SemaphoreSlim(8)) { int num = 0; int length = files.Count; List <Task> tasks = new List <Task>(); foreach (string file in files) { concurrencySemaphore.Wait(); var t = Task.Run(() => { string str2 = file.Substring(dir_path.Length); string remoteFileName = directory.FullPath + "/projects/" + dir + str2.Replace('\\', '/'); string remotePath = remoteFileName.Substring(0, remoteFileName.LastIndexOf('/')); try { if (File.Exists(file)) { remoteSystem.FileSystem.UploadFile(file, remoteFileName); outputWindowPane.OutputStringThreadSafe("[" + Interlocked.Increment(ref num) + "/" + length + "] " + remoteFileName + "\n"); } else { Interlocked.Increment(ref num); outputWindowPane.OutputStringThreadSafe("Skip " + file + " (file not exists)\n"); } } catch (liblinux.IO.IOException ex1) { if (ex1.Message.Contains("No such file")) { remoteSystem.FileSystem.CreateDirectories(remotePath); remoteSystem.FileSystem.UploadFile(file, remoteFileName); outputWindowPane.OutputStringThreadSafe("[" + Interlocked.Increment(ref num) + "/" + length + "] " + remoteFileName + "\n"); } else { Interlocked.Increment(ref num); outputWindowPane.OutputStringThreadSafe("Upload failed: " + file + "\n"); } } catch (Exception ex) { Interlocked.Increment(ref num); outputWindowPane.OutputStringThreadSafe("Upload failed: " + file + ", ex: " + ex.ToString() + "\n"); } finally { concurrencySemaphore.Release(); } }); tasks.Add(t); } Task.WaitAll(tasks.ToArray()); } remoteSystem.Disconnect(); remoteSystem.Dispose(); outputWindowPane.OutputStringThreadSafe("Copy to " + remoteSystem.ConnectionInfo.HostNameOrAddress + " done.\n"); // prepare for next time remoteSystem = new RemoteSystem((ConnectionInfo)connectionInfoStore.Connections[0]); directory = remoteSystem.FileSystem.GetDirectory(SpecialDirectory.Home); } } catch (Exception ex) { remoteSystem = null; throw ex; } }
public static async Task <T> DeserializeAsync <T>(Windows.Storage.StorageFolder folder, string fileName, System.Threading.SemaphoreSlim semaphore) where T : class { try { return(await DeserializeAsync <T>((await folder.GetItemAsync(fileName)) as Windows.Storage.StorageFile, semaphore)); } catch { return(null); } }
public static async Task SerializeAsync <T>(T content, Windows.Storage.StorageFolder folder, string fileName, System.Threading.SemaphoreSlim semaphore) { await semaphore.WaitAsync(); try { var f = await folder.CreateFileAsync(fileName, Windows.Storage.CreationCollisionOption.ReplaceExisting); using var s = (await f.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite)).AsStream(); var serializer = new System.Xml.Serialization.XmlSerializer(typeof(T)); serializer.Serialize(s, content); } catch { } finally { semaphore.Release(); } }
/// <summary> /// Creates grouping subscriptions and waits for the notification events to flow /// </summary> /// <param name="impersonationId"></param> /// <returns></returns> async public System.Threading.Tasks.Task CreateStreamingSubscriptionGroupingAsync(string impersonationId) { var database = EWSConstants.Config.Database; using (EWSDbContext context = new EWSDbContext(database)) { var smtpAddresses = await context.RoomListRoomEntities.ToListAsync(); foreach (var sMailbox in smtpAddresses) { var addedBox = _mailboxes.AddMailbox(sMailbox.SmtpAddress); if (!addedBox) { _traceListener.Trace("SyncProgram", $"Failed to add SMTP {sMailbox.SmtpAddress}"); } MailboxInfo mailboxInfo = _mailboxes.Mailbox(sMailbox.SmtpAddress); if (mailboxInfo != null) { GroupInfo groupInfo = null; if (_groups.ContainsKey(mailboxInfo.GroupName)) { groupInfo = _groups[mailboxInfo.GroupName]; } else { groupInfo = new GroupInfo(mailboxInfo.GroupName, mailboxInfo.SMTPAddress, mailboxInfo.EwsUrl, EwsToken, _traceListener); _groups.Add(mailboxInfo.GroupName, groupInfo); } if (groupInfo.Mailboxes.Count > 199) { // We already have enough mailboxes in this group, so we rename it and create a new one // Renaming it means that we can still put new mailboxes into the correct group based on GroupingInformation int i = 1; while (_groups.ContainsKey($"{groupInfo.Name}-{i}")) { i++; } // Remove previous grouping name from stack _groups.Remove(groupInfo.Name); // Add the grouping back with the new grouping name [keep the GroupInfo with previous name] _groups.Add($"{groupInfo.Name}-{i}", groupInfo); // Provision a new GroupInfo with the GroupName groupInfo = new GroupInfo(mailboxInfo.GroupName, mailboxInfo.SMTPAddress, mailboxInfo.EwsUrl, EwsToken, _traceListener); // Add GroupInfo to stack _groups.Add(mailboxInfo.GroupName, groupInfo); } // Add the mailbox to the collection groupInfo.Mailboxes.Add(sMailbox.SmtpAddress); } } // Enable the Grouping foreach (var _group in _groups) { _traceListener.Trace("SyncProgram", $"Opening connections for {_group.Key}"); var groupName = _group.Key; var groupInfo = _group.Value; // Create a streaming connection to the service object, over which events are returned to the client. // Keep the streaming connection open for 30 minutes. if (AddGroupSubscriptions(context, groupName)) { _traceListener.Trace("SyncProgram", $"{groupInfo.Mailboxes.Count()} mailboxes primed for StreamingSubscriptions."); } else { _traceListener.Trace("SyncProgram", $"Group {groupInfo.Name} failed in StreamingSubscription events."); } } } using (var semaphore = new System.Threading.SemaphoreSlim(1)) { // Block the Thread semaphore.Wait(); // Establish the StreamingSubscriptionConnections based on the GroupingInfo foreach (var connection in _connections) { var _group = _groups[connection.Key]; var _connection = connection.Value; if (_connection.IsOpen) { _group.IsConnectionOpen = true; return; } try { _connection.Open(); _group.IsConnectionOpen = true; } catch (Exception ex) { _traceListener.Trace("SyncProgram", $"Error opening streamingsubscriptionconnection for group {_group.Name} MSG {ex.Message}"); } } // Lock the Thread Until its cancelled or fails await semaphore.WaitAsync(CancellationTokenSource.Token); } }
private async Task <(int, int)> Scrape(Func <CancellationToken, Task <int> > process, System.Threading.SemaphoreSlim complete, TimeSpan interval, CancellationToken cancellation) { var success = 0; var error = 0; var delay = interval; while (!cancellation.IsCancellationRequested) { if (await complete.WaitAsync(delay, cancellation)) { complete.Release(); break; } try { var start = DateTimeOffset.UtcNow; await process(cancellation); var elapsed = DateTimeOffset.UtcNow - start; delay = elapsed > interval ? TimeSpan.Zero : (interval - elapsed); ++success; } catch { ++error; } } return(success, error); }
public static async Task <IDisposable> Lock(this System.Threading.SemaphoreSlim semaphore) { await semaphore.WaitAsync(); return(new LockRelease(semaphore)); }
public ThrottledTaskPool(int maxConcurrentTasks) { _semaphore = new System.Threading.SemaphoreSlim(maxConcurrentTasks, maxConcurrentTasks); }
public static void RunWithController(TestHelper helper, IControllerPrx controller) { Communicator?communicator = helper.Communicator; TestHelper.Assert(communicator != null); var timeout = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), communicator); System.IO.TextWriter output = helper.Output; output.Write("testing connect timeout... "); output.Flush(); { Dictionary <string, string>?properties = communicator.GetProperties(); properties["Ice.ConnectTimeout"] = "100ms"; using var comm = new Communicator(properties); var to = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), comm); // Expect ConnectTimeoutException. controller.HoldAdapter(-1); try { to.Op(); TestHelper.Assert(false); } catch (ConnectTimeoutException) { // Expected. } controller.ResumeAdapter(); timeout.Op(); // Ensure adapter is active. } { // Expect success. controller.HoldAdapter(100); timeout.Op(); } output.WriteLine("ok"); // The sequence needs to be large enough to fill the write/recv buffers byte[] seq = new byte[2000000]; output.Write("testing connection timeout... "); output.Flush(); { // Expect TimeoutException. controller.HoldAdapter(-1); timeout.GetConnection() !.Acm = new Acm(TimeSpan.FromMilliseconds(50), AcmClose.OnInvocationAndIdle, AcmHeartbeat.Off); try { timeout.SendData(seq); TestHelper.Assert(false); } catch (ConnectionTimeoutException) { // Expected. } controller.ResumeAdapter(); timeout.Op(); // Ensure adapter is active. } { // Expect success. controller.HoldAdapter(100); try { timeout.SendData(new byte[1000000]); } catch (ConnectionTimeoutException) { TestHelper.Assert(false); } } output.WriteLine("ok"); output.Write("testing invocation timeout... "); output.Flush(); { timeout.IcePing(); // Makes sure a working connection is associated with the proxy Connection?connection = timeout.GetConnection(); try { using var timeoutTokenSource = new CancellationTokenSource(TimeSpan.FromMilliseconds(100)); timeout.SleepAsync(1000, cancel: timeoutTokenSource.Token).Wait(); TestHelper.Assert(false); } catch (AggregateException ex) when(ex.InnerException is OperationCanceledException) { } timeout.IcePing(); TestHelper.Assert(connection == timeout.GetConnection()); try { using var timeoutTokenSource = new CancellationTokenSource(TimeSpan.FromMilliseconds(1000)); timeout.SleepAsync(100, cancel: timeoutTokenSource.Token).Wait(); } catch (AggregateException ex) when(ex.InnerException is OperationCanceledException) { TestHelper.Assert(false); } TestHelper.Assert(connection == timeout.GetConnection()); } output.WriteLine("ok"); output.Write("testing close timeout... "); output.Flush(); { Dictionary <string, string> properties = communicator.GetProperties(); properties["Ice.CloseTimeout"] = "100ms"; using var comm = new Communicator(properties); var to = ITimeoutPrx.Parse(helper.GetTestProxy("timeout", 0), comm); Connection?connection = to.GetConnection(); Connection?connection2 = timeout.GetConnection(); // No close timeout TestHelper.Assert(connection != null && connection2 != null); controller.HoldAdapter(-1); // Make sure there's no ReadAsync pending _ = to.IcePingAsync(); _ = timeout.IcePingAsync(); var semaphore = new System.Threading.SemaphoreSlim(0); connection.Closed += (sender, args) => semaphore.Release(); connection.Close(ConnectionClose.Gracefully); TestHelper.Assert(semaphore.Wait(500)); connection2.Closed += (sender, args) => semaphore.Release(); connection2.Close(ConnectionClose.Gracefully); TestHelper.Assert(!semaphore.Wait(500)); controller.ResumeAdapter(); timeout.Op(); // Ensure adapter is active. } output.WriteLine("ok"); output.Write("testing invocation timeouts with collocated calls... "); output.Flush(); { communicator.SetProperty("TimeoutCollocated.AdapterId", "timeoutAdapter"); ObjectAdapter adapter = communicator.CreateObjectAdapter("TimeoutCollocated"); adapter.Activate(); ITimeoutPrx proxy = adapter.AddWithUUID(new Timeout(), ITimeoutPrx.Factory); try { using var timeoutTokenSource = new CancellationTokenSource(TimeSpan.FromMilliseconds(100)); proxy.SleepAsync(500, cancel: timeoutTokenSource.Token).Wait(); TestHelper.Assert(false); } catch (AggregateException ex) when(ex.InnerException is OperationCanceledException) { } adapter.Dispose(); } output.WriteLine("ok"); controller.Shutdown(); }