public async Task TestThatExceptionIsThrownIfMaxRetryCountIsReached() { string appId = "appId"; IUpdateBlob updateBlob = new StubIUpdateBlob(); var sequence = StubsUtils.Sequence <StubIUpdateBlobFactory.TryLockUpdateBlob_String_Delegate>() .Twice(id => AsyncUtils.AsyncTaskThatThrows <IUpdateBlob>(new UpdateBlobUnavailableException())) .Once(id => AsyncUtils.AsyncTaskWithResult(updateBlob)); var updateBlobFactoryStub = new StubIUpdateBlobFactory { TryLockUpdateBlob_String = id => sequence.Next(appId) }; UpdateBlobFactoryRetryLockDecorator retryDecorator = new UpdateBlobFactoryRetryLockDecorator(updateBlobFactoryStub, new FixedInterval(1, TimeSpan.Zero)); await Assert.ThrowsAsync <UpdateBlobUnavailableException>( async() => await retryDecorator.TryLockUpdateBlob(appId)); }
public async Task TestSuccessfullRetry() { string appId = "appId"; IUpdateBlob updateBlob = new StubIUpdateBlob(); var sequence = StubsUtils.Sequence <StubIUpdateBlobFactory.TryLockUpdateBlob_String_Delegate>() .Twice(id => AsyncUtils.AsyncTaskThatThrows <IUpdateBlob>(new UpdateBlobUnavailableException())) .Once(id => AsyncUtils.AsyncTaskWithResult(updateBlob)); var updateBlobFactoryStub = new StubIUpdateBlobFactory { TryLockUpdateBlob_String = id => sequence.Next(appId) }; UpdateBlobFactoryRetryLockDecorator retryDecorator = new UpdateBlobFactoryRetryLockDecorator(updateBlobFactoryStub, new FixedInterval(2, TimeSpan.Zero)); Assert.Equal(updateBlob, await retryDecorator.TryLockUpdateBlob(appId)); }
public override void OnApplyTemplate() { base.OnApplyTemplate(); IEventAggregator _events = new EventAggregator(); IWindowManager _windowManager = new AppWindowManager(); IProfile _exProfile = new FileSystemInfoExProfile(_events, _windowManager); IProfile _ioProfile = new FileSystemInfoProfile(_events); IProfile[] _profiles = new IProfile[] { _exProfile, _ioProfile }; IEntryModel[] _rootDirs = new IEntryModel[] { AsyncUtils.RunSync(() => _exProfile.ParseAsync("")) }; explorer.WindowManager = _windowManager; explorer.ViewModel.Initializer = new ScriptCommandInitializer() { OnModelCreated = ScriptCommands.Run("{OnModelCreated}"), OnViewAttached = ScriptCommands.Run("{OnViewAttached}"), RootModels = _rootDirs, WindowManager = _windowManager, StartupParameters = new ParameterDic() { { "Profiles", _profiles }, { "RootDirectories", _rootDirs }, { "GlobalEvents", _events }, { "WindowManager", _windowManager }, { "StartupPath", "" }, { "ViewMode", "List" }, { "ItemSize", 16 }, { "EnableDrag", true }, { "EnableDrop", true }, { "FileListNewWindowCommand", NullScriptCommand.Instance }, //Disable NewWindow Command. { "EnableMultiSelect", true }, { "ShowToolbar", true }, { "ShowGridHeader", true }, { "OnModelCreated", IOInitializeHelpers.Explorer_Initialize_Default }, { "OnViewAttached", UIScriptCommands.ExplorerGotoStartupPathOrFirstRoot() } } }; cbCommand.ItemsSource = ScriptCommandDictionary.CommandList; }
public void CancelBeforeOthersDontWaitForCancellation() { // 1 task canceled, others basically wait for cancellation and wait a bit after receiving cancellation, // cancel occurs before successes, waitForCancellation false // -> TaskCanceledException with Task == canceled task, other tasks are not completed yet CancellableTask[] tasks = new CancellableTask[] { GetEarlyCancellingCancellableTask(), GetSuccessfulCancellableTask(), GetSuccessfulCancellableTask() }; try { Task waitTask = AsyncUtils.WhenAllCancelOnFirstExceptionDontWaitForCancellations(tasks); bool taskCanceledCaught = false; try { waitTask.ConfigureAwait(false).GetAwaiter().GetResult(); } catch (TaskCanceledException ex) { taskCanceledCaught = true; ex.CancellationToken.Should().Be(tasks[0].CancellationTokenSource.Token); } Assert.True(taskCanceledCaught, "TaskCanceledException was not thrown."); TaskStatus task1Status = tasks[1].Task.Status; TaskStatus task2Status = tasks[2].Task.Status; Assert.Equal(TaskStatus.Canceled, tasks[0].Task.Status); Assert.True(task1Status == TaskStatus.Running || task1Status == TaskStatus.WaitingForActivation, string.Format("Second task has status {0} instead of Running or WaitingForActivation.", task1Status)); Assert.True(task2Status == TaskStatus.Running || task2Status == TaskStatus.WaitingForActivation, string.Format("Third task has status {0} instead of Running or WaitingForActivation.", task2Status)); } finally { foreach (CancellableTask task in tasks) { task.CancellationTokenSource.Dispose(); } } }
internal static void createMenu() { MelonLogger.Msg("Creating BP client"); SetupBP(); MelonLogger.Msg("Creating Menu"); search = new ToggleButton((state) => { if (state) { search.Text = "Scanning..."; bpClient.StartScanningAsync(); } else { search.Text = "Scan for toys"; bpClient.StopScanningAsync(); } }, CreateSpriteFromTexture2D(logo), null, "Scan for toys", "BPToggle", "Scan for connected toys", "Scaning for connected toys"); networkStatus = new Label("Network", Client.ClientAvailable() ? "Connected" : "Not\nConnected", "networkstatus"); networkStatus.TextComponent.fontSize = 24; buttplugError = new Label("B******g", "No Error", "status"); buttplugError.TextComponent.fontSize = 24; Client.GetClient().ConnectRecieved += async() => { await AsyncUtils.YieldToMainThread(); networkStatus.SubtitleText = Client.ClientAvailable() ? "Connected" : "Not\nConnected"; }; TabButton = new TabButton(CreateSpriteFromTexture2D(logo), "Vibrator Controller", "VibratorControllerMenu", "Vibrator Controller", "Vibrator Controller Menu"); TabButton.SubMenu .AddButtonGroup(new ButtonGroup("ControlsGrp", "Controls", new List <IButtonGroupElement>() { search, networkStatus, buttplugError })); //Control all toys (vibrate only) new Toy("All Toys", 1000, "all", 20, 0, 0, false, TabButton.SubMenu); //activate scroll TabButton.SubMenu.ToggleScrollbar(true); }
static async Task AsyncAwaitFct() { var now = DateTime.UtcNow; Console.WriteLine("Regular async await..."); Console.WriteLine($"[{now.ToShortDateString()} {now.ToLongTimeString()}]"); foreach (var n in await AsyncUtils.GetNamesStdAsync()) { Console.WriteLine("Std Async Hello World!"); Console.WriteLine($"[{now.ToShortDateString()} {now.ToLongTimeString()}]"); } Console.WriteLine("Now streams..."); Console.WriteLine($"[{now.ToShortDateString()} {now.ToLongTimeString()}]"); await foreach (var n in AsyncUtils.GetNamesAsyncStream()) { Console.WriteLine("Std Async Hello World!"); Console.WriteLine($"[{now.ToShortDateString()} {now.ToLongTimeString()}]"); } }
public async Task TestThatStartUpdateSessionIsRetried() { string appId = "appId"; var sequence = StubsUtils.Sequence <StubIUpdateSessionManager.TryStartUpdateSession_String_Delegate>() .Once(id => AsyncUtils.AsyncTaskThatThrows <bool>(new StorageException())) .Once(id => AsyncUtils.AsyncTaskWithResult(true)); var updateSessionStub = new StubIUpdateSessionManager { TryStartUpdateSession_String = id => sequence.Next(id) }; IUpdateSessionManager retryDecorator = new UpdateSessionManagerRetryDecorator( updateSessionStub, new FixedInterval(1, TimeSpan.Zero), new StorageExceptionErrorDetectionStrategy()); Assert.True(await retryDecorator.TryStartUpdateSession(appId)); }
public void FaultsBeforeSuccessesDontWaitForCancellation() { // 2 tasks fault, others basically wait for cancellation and wait a bit after receiving cancellation, // fault occurs before successes, waitForCancellations false // -> AggregateException with at least 1 fault inside, at least one of first two tasks in faulted state, other tasks are not completed yet CancellableTask[] tasks = new CancellableTask[] { GetEarlyFaultingCancellableTask(), GetEarlyFaultingCancellableTask(), GetSuccessfulCancellableTask(), GetSuccessfulCancellableTask() }; try { Task waitTask = AsyncUtils.WhenAllCancelOnFirstExceptionDontWaitForCancellations(tasks); Assert.Throws <Exception>(() => waitTask.ConfigureAwait(false).GetAwaiter().GetResult()); Assert.Equal(1, waitTask.Exception.InnerExceptions.Count); Assert.Equal("Early Fault", waitTask.Exception.InnerException.Message); TaskStatus task0Status = tasks[0].Task.Status; TaskStatus task1Status = tasks[1].Task.Status; TaskStatus task2Status = tasks[2].Task.Status; TaskStatus task3Status = tasks[3].Task.Status; int numFaulted = (task0Status == TaskStatus.Faulted ? 1 : 0) + (task1Status == TaskStatus.Faulted ? 1 : 0); numFaulted.Should().BeGreaterOrEqualTo(1); Assert.True(task0Status == TaskStatus.Faulted || task0Status == TaskStatus.Running || task0Status == TaskStatus.WaitingForActivation, string.Format("First task has status {0} instead of Faulted, Running, or WaitingForActivation.", task0Status)); Assert.True(task1Status == TaskStatus.Faulted || task1Status == TaskStatus.Running || task1Status == TaskStatus.WaitingForActivation, string.Format("Second task has status {0} instead of Faulted, Running, or WaitingForActivation.", task1Status)); Assert.True(task2Status == TaskStatus.Running || task2Status == TaskStatus.WaitingForActivation, string.Format("Third task has status {0} instead of Running or WaitingForActivation.", task2Status)); Assert.True(task3Status == TaskStatus.Running || task3Status == TaskStatus.WaitingForActivation, string.Format("Fourth task has status {0} instead of Running or WaitingForActivation.", task3Status)); } finally { foreach (CancellableTask task in tasks) { task.CancellationTokenSource.Dispose(); } } }
public void TypeOfExceptionWhenAwaitingIsNotAggregateException() { CancellableTask[] tasks = new CancellableTask[] { GetLateFaultingCancellableTask() }; try { Task waitTask = AsyncUtils.WhenAllCancelOnFirstExceptionWaitForCancellations(tasks); Exception exceptionWhenAwaiting = GetExceptionWhenAwaiting(waitTask).ConfigureAwait(false).GetAwaiter().GetResult(); Assert.IsType <Exception>(exceptionWhenAwaiting); } finally { foreach (CancellableTask task in tasks) { task.CancellationTokenSource.Dispose(); } } }
public static async Task <WebFileStream> OpenReadWriteAsync(IEntryModel entryModel, CancellationToken ct) { byte[] bytes = new byte[] { }; var profile = entryModel.Profile as SzsProfile; ISzsItemModel entryItemModel = entryModel as ISzsItemModel; IEntryModel rootModel = entryItemModel.Root.ReferencedFile; using (Stream stream = await(rootModel.Profile as IDiskProfile).DiskIO.OpenStreamAsync(rootModel, Defines.FileAccess.Read, ct)) { MemoryStream ms = new MemoryStream(); if (profile.Wrapper.ExtractOne(stream, entryItemModel.RelativePath, null, ms)) { bytes = ms.ToByteArray(); } } return(new WebFileStream(entryModel, bytes, (m, s) => { AsyncUtils.RunSync(() => updateSourceAsync(s)); })); }
public async Task TestThatStorageExceptionsAreRetried() { string appId = "appId"; var flushAndReleaseSequence = StubsUtils.Sequence <Func <Task> >() .Once(() => AsyncUtils.AsyncTaskThatThrows(new StorageException())) .Once(() => Task.CompletedTask) .Once(() => AsyncUtils.AsyncTaskThatThrows(new StorageException())) .Once(() => Task.CompletedTask); IUpdateBlob updateBlobStub = new StubIUpdateBlob { FlushAndRelease = () => flushAndReleaseSequence.Next(), IDisposable_Dispose = () => { }, GetUpdateDomain = () => "1", SetUpdateDomain_String = domain => { }, AddInstance_String = id => { }, RemoveInstance_String = id => { } }; var updateBlobFactoryStub = new StubIUpdateBlobFactory { TryLockUpdateBlob_String = id => AsyncUtils.AsyncTaskWithResult(updateBlobStub) }; ContainerBuilder builder = AzureBlobStorageUpdateSessionDiModule.RegisterTypes("deploymentId", "instanceId", "1", EmulatorConnectionString); builder.RegisterInstance(updateBlobFactoryStub).As <IUpdateBlobFactory>(); IUpdateSessionManager updateSessionManager = new AzureBlobStorageUpdateSessionDiModule(builder.Build()).UpdateSessionManager; Assert.True(await updateSessionManager.TryStartUpdateSession(appId)); await updateSessionManager.EndUpdateSession(appId); Assert.Equal(4, flushAndReleaseSequence.CallCount); }
public void CancelBeforeOthersWaitForCancellation() { // 1 task canceled, others basically wait for cancellation and wait a bit after receiving cancellation, // cancel occurs before successes, waitForCancellation true // -> TaskCanceledException with CancellationToken == canceled task's cancellation token CancellableTask[] tasks = new CancellableTask[] { GetEarlyCancellingCancellableTask(), GetSuccessfulCancellableTask(), GetSuccessfulCancellableTask() }; try { Task waitTask = AsyncUtils.WhenAllCancelOnFirstExceptionWaitForCancellations(tasks); bool taskCanceledCaught = false; try { waitTask.ConfigureAwait(false).GetAwaiter().GetResult(); } catch (TaskCanceledException ex) { taskCanceledCaught = true; ex.CancellationToken.Should().Be(tasks[0].CancellationTokenSource.Token); } Assert.True(taskCanceledCaught, "TaskCanceledException was not thrown."); Assert.Equal(TaskStatus.Canceled, tasks[0].Task.Status); Assert.Equal(TaskStatus.Canceled, tasks[1].Task.Status); Assert.Equal(TaskStatus.Canceled, tasks[2].Task.Status); } finally { foreach (CancellableTask task in tasks) { task.CancellationTokenSource.Dispose(); } } }
internal async void UpdateBattery() { try { while (isActive) { battery = await device.SendBatteryLevelCmd(); await AsyncUtils.YieldToMainThread(); if (label != null) { label.SubtitleText = $"Battery: {battery * 100}"; } await Task.Delay(1000 * 10); } } catch (Exception) { //maybe device dissconnected during cmd } }
public async Task WaitFutureTimeoutTest() { var task1 = new Func <Task <int> >(async() => { await Task.Delay(500); return(2); }); var task2 = new Func <Task>(async() => { await Task.Delay(500); }); var r = await AsyncUtils.WaitFutureTimeout(task1(), TimeSpan.FromMilliseconds(2000)); Assert.Equal(2, r); await AsyncUtils.WaitFutureTimeout(task2(), TimeSpan.FromMilliseconds(2000)); await Assert.ThrowsAsync <TimeoutException>(async() => await AsyncUtils.WaitFutureTimeout(task1(), TimeSpan.FromMilliseconds(100))); await Assert.ThrowsAsync <TimeoutException>(async() => await AsyncUtils.WaitFutureTimeout(task2(), TimeSpan.FromMilliseconds(100))); }
// Loads all configured rec sources into the rec service in parallel. // Does not return until complete or serviceStopToken is signaled. private static void LoadRecSources(TcpRecService recService, Config config, CancellationToken serviceStopToken) { if (config.RecSources.Count == 0) { Logging.Log.Info("No rec sources configured."); return; } Logging.Log.InfoFormat("Loading {0} rec sources.", config.RecSources.Count); List <ICancellableTask> recSourceLoadTasks = new List <ICancellableTask>(config.RecSources.Count); using (CancellationTokenSource anyTaskFaultedOrCanceled = new CancellationTokenSource()) using (CancellationTokenSource cancelTokenSource = CancellationTokenSource.CreateLinkedTokenSource(serviceStopToken, anyTaskFaultedOrCanceled.Token)) { foreach (DTO.LoadRecSourceRequest recSourceConfigX in config.RecSources) { DTO.LoadRecSourceRequest recSourceConfig = recSourceConfigX; // Don't capture the loop variable Task loadRecSourceTask = Task.Factory.StartNew(() => { recService.LoadRecSource(recSourceConfig, cancelTokenSource.Token); }, cancelTokenSource.Token); recSourceLoadTasks.Add(new CancellableTask(loadRecSourceTask, anyTaskFaultedOrCanceled)); } try { AsyncUtils.WhenAllCancelOnFirstExceptionDontWaitForCancellations(recSourceLoadTasks).ConfigureAwait(false).GetAwaiter().GetResult(); } catch (OperationCanceledException) { Logging.Log.Info("Canceled loading rec sources."); throw; } } recService.FinalizeRecSources(serviceStopToken); }
public override void OnApplicationStart() { VRCUtils.Init(); Harmony.Patch(AccessTools.Method(typeof(MenuController), "Method_Public_Void_APIUser_0"), postfix: new HarmonyMethod(typeof(UserInfoExtensionsMod).GetMethod("OnUserInfoOpen", BindingFlags.Static | BindingFlags.Public))); Harmony.Patch(AccessTools.Method(typeof(PageUserInfo), "Back"), postfix: new HarmonyMethod(typeof(UserInfoExtensionsMod).GetMethod("OnUserInfoClose", BindingFlags.Static | BindingFlags.Public))); UIExpansionKit.API.LayoutDescription popupLayout = new UIExpansionKit.API.LayoutDescription { RowHeight = 80, NumColumns = 3, NumRows = 5 }; menu = UIExpansionKit.API.ExpansionKitApi.CreateCustomFullMenuPopup(popupLayout); userDetailsMenu = UIExpansionKit.API.ExpansionKitApi.GetExpandedMenu(UIExpansionKit.API.ExpandedMenu.UserDetailsMenu); menu.AddLabel("General Things"); menu.AddSpacer(); menu.AddSimpleButton("Back", () => menu.Hide()); userDetailsMenu.AddSimpleButton("UserInfoExtensions", async() => { await AsyncUtils.YieldToMainThread(); HideAllPopups(); menu.Show(); foreach (ModuleBase module in modules) { module.OnUIEMenuOpen(); } }); AddModule(new QuickMenuFromSocial()); AddModule(new GetAvatarAuthor()); AddModule(new OpenInWorldMenu()); AddModule(new BioButtons()); AddModule(new OpenInBrowser()); AddModule(new UserInformation()); MelonLogger.Msg("Initialized!"); }
public void CancelAfterSuccessesDontWaitForCancellation() { // 1 task canceled, others succeed, cancel occurs after successes, waitForCancellations false // -> TaskCanceledException with CancellationToken == canceled task's cancellation token CancellableTask[] tasks = new CancellableTask[] { GetLateCancellingCancellableTask(), GetSuccessfulCancellableTask(), GetSuccessfulCancellableTask() }; try { Task waitTask = AsyncUtils.WhenAllCancelOnFirstExceptionDontWaitForCancellations(tasks); bool taskCanceledCaught = false; try { waitTask.ConfigureAwait(false).GetAwaiter().GetResult(); } catch (TaskCanceledException ex) { taskCanceledCaught = true; ex.CancellationToken.Should().Be(tasks[0].CancellationTokenSource.Token); } Assert.True(taskCanceledCaught, "TaskCanceledException was not thrown."); Assert.Equal(TaskStatus.Canceled, tasks[0].Task.Status); Assert.Equal(TaskStatus.RanToCompletion, tasks[1].Task.Status); Assert.Equal(TaskStatus.RanToCompletion, tasks[2].Task.Status); } finally { foreach (CancellableTask task in tasks) { task.CancellationTokenSource.Dispose(); } } }
public void AllCompleteSuccessfullyDontWaitForCancellations() { CancellableTask[] tasks = new CancellableTask[3] { GetSuccessfulCancellableTask(), GetSuccessfulCancellableTask(), GetSuccessfulCancellableTask() }; try { Task waitTask = AsyncUtils.WhenAllCancelOnFirstExceptionDontWaitForCancellations(tasks); waitTask.ConfigureAwait(false).GetAwaiter().GetResult(); Assert.All(tasks, task => Assert.Equal(TaskStatus.RanToCompletion, task.Task.Status)); } finally { foreach (CancellableTask task in tasks) { task.CancellationTokenSource.Dispose(); } } }
// Loads training data and prerequisites from the database in parallel and does not return until they are loaded. private static (MalTrainingData trainingData, IDictionary <int, IList <int> > prereqs) LoadInitialData(IMalTrainingDataLoaderFactory trainingDataLoaderFactory, CancellationToken serviceStopToken) { using (IMalTrainingDataLoader initialTrainingDataLoader = trainingDataLoaderFactory.GetTrainingDataLoader()) using (CancellationTokenSource trainingDataOtherFaultOrCancellation = new CancellationTokenSource()) using (CancellationTokenSource trainingDataCancel = CancellationTokenSource.CreateLinkedTokenSource(serviceStopToken, trainingDataOtherFaultOrCancellation.Token)) using (CancellationTokenSource prereqsOtherFaultOrCancellation = new CancellationTokenSource()) using (CancellationTokenSource prereqsCancel = CancellationTokenSource.CreateLinkedTokenSource(serviceStopToken, prereqsOtherFaultOrCancellation.Token)) { CancellableAsyncFunc <MalTrainingData> trainingDataAsyncFunc = new CancellableAsyncFunc <MalTrainingData>( () => LoadTrainingDataOnInitAsync(initialTrainingDataLoader, trainingDataCancel.Token), trainingDataOtherFaultOrCancellation); CancellableTask <MalTrainingData> trainingDataTask = trainingDataAsyncFunc.StartTaskEnsureExceptionsWrapped(); CancellableAsyncFunc <IDictionary <int, IList <int> > > prereqsAsyncFunc = new CancellableAsyncFunc <IDictionary <int, IList <int> > >( () => LoadPrereqsOnInit(initialTrainingDataLoader, prereqsCancel.Token), prereqsOtherFaultOrCancellation); CancellableTask <IDictionary <int, IList <int> > > prereqsTask = prereqsAsyncFunc.StartTaskEnsureExceptionsWrapped(); AsyncUtils.WhenAllCancelOnFirstExceptionDontWaitForCancellations(trainingDataTask, prereqsTask).ConfigureAwait(false).GetAwaiter().GetResult(); return(trainingDataTask.Task.Result, prereqsTask.Task.Result); } }
public void CancelBeforeOthersFaultAfterCancellationWaitForCancellation() { // 1 task canceled, others basically wait for cancellation and wait a bit after receiving cancellation, // 2 others fault after cancellation, cancel occurs before successes and faults, waitForCancellation true // -> AggregateException with faults inside, first task in canceled state, faulting tasks in faulted state, other tasks in canceled state CancellableTask[] tasks = new CancellableTask[] { GetEarlyCancellingCancellableTask(), GetLateFaultingCancellableTask(), GetLateFaultingCancellableTask(), GetSuccessfulCancellableTask(), GetSuccessfulCancellableTask() }; try { Task waitTask = AsyncUtils.WhenAllCancelOnFirstExceptionWaitForCancellations(tasks); Assert.Throws <Exception>(() => waitTask.ConfigureAwait(false).GetAwaiter().GetResult()); Assert.Equal(2, waitTask.Exception.InnerExceptions.Count); Assert.All(waitTask.Exception.InnerExceptions, ex => Assert.Equal("Late Fault", ex.Message)); Assert.Equal(TaskStatus.Canceled, tasks[0].Task.Status); Assert.Equal(TaskStatus.Faulted, tasks[1].Task.Status); Assert.Equal(TaskStatus.Faulted, tasks[2].Task.Status); Assert.Equal(TaskStatus.Canceled, tasks[3].Task.Status); Assert.Equal(TaskStatus.Canceled, tasks[4].Task.Status); } finally { foreach (CancellableTask task in tasks) { task.CancellationTokenSource.Dispose(); } } }
public override void OnApplyTemplate() { base.OnApplyTemplate(); //Install-Package Google.Apis.Authentication.OAuth2 -Version 1.2.4696.27634 //Install-Package DotNetOpenAuth -Version 4.3.4.13329 var provider = new NativeApplicationClient(WindowsLiveDescription); provider.ClientIdentifier = "0000000040112888"; //provider.ClientSecret = "qIueVYvFCKEQ0-43jC9qkVzbXAkHwnMr"; var auth = new OAuth2Authenticator <NativeApplicationClient>(provider, GetAuthorization); //var plus = new PlusService(auth); //plus.Key = "BLAH"; //var me = plus.People.Get("me").Fetch(); //Console.WriteLine(me.DisplayName); // var client = new WindowsLiveClient() // { // //ClientIdentifier = "0000000040112888", // //ClientCredentialApplicator = ClientCredentialApplicator.PostParameter("qIueVYvFCKEQ0-43jC9qkVzbXAkHwnMr"), // }; // //client.ClientCredentialApplicator = ClientCredentialApplicator.NetworkCredential( // //client.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter("0000000040112888"); // var state = client.ExchangeUserCredentialForToken("*****@*****.**", "p@ssw0rd123", // new[] { WindowsLiveClient.Scopes.Basic }); AsyncUtils.RunSync(() => testUpload()); //SkyDriveLogin login; //lc.LoginInfo = login = new SkyDriveLogin( "0000000040112888"); //lc.AddHandler(LoginControl.CompletedEvent, (RoutedEventHandler)((o, e) => // { // //login.AuthCode // initAuth(login.AuthCode); // })); }
/// <summary> /// Gets an AudioClip for a song /// </summary> /// <remarks> /// Run this from the main thread and only from the main thread! /// </remarks> public async Task <RefCountedClip> GetSongClip(string song, CancellationToken token) { if (!AsyncUtils.IsOnMainThread()) { throw new InvalidOperationException("GetSongClip must be run from the main thread. I don't make the rules, sorry."); } if (State.ClipCache.ContainsKey(song)) { return(State.ClipCache[song]); } //request the server transcode var request = new RestRequest($"library/song/{song}", HttpMethod.Get, null, new KeyValuePair <string, string>("transcode", "wave"), new KeyValuePair <string, string>("return", "path")); RestResponse response = default; await Task.Run(async() => response = await DoRestRequest(request, 100000, token)); var jroot = JToken.Parse(response.Body); if (jroot.IsNullOrEmpty() || jroot["data"].IsNullOrEmpty() || jroot["data"]["transcodedPath"].IsNullOrEmpty()) { return(null); } string path = jroot["data"]["transcodedPath"].ToString(); //load the clip var clip = WaveLoader.WaveLoader.LoadWaveToAudioClip(path, song); //will probably stutter, we'll optimize it later var rClip = new RefCountedClip(clip); State.ClipCache.Add(song, rClip); return(rClip); }
public void FaultsAfterSuccessesDontWaitForCancellations() { // 2 tasks fault, others succeed, faults occur after successes, waitForCancellations false // -> AggregateException with at least one fault inside CancellableTask[] tasks = new CancellableTask[] { GetLateFaultingCancellableTask(), GetLateFaultingCancellableTask(), GetSuccessfulCancellableTask(), GetSuccessfulCancellableTask() }; try { Task waitTask = AsyncUtils.WhenAllCancelOnFirstExceptionDontWaitForCancellations(tasks); Assert.Throws <Exception>(() => waitTask.ConfigureAwait(false).GetAwaiter().GetResult()); Assert.Equal(1, waitTask.Exception.InnerExceptions.Count); Assert.Equal("Late Fault", waitTask.Exception.InnerException.Message); TaskStatus task0Status = tasks[0].Task.Status; TaskStatus task1Status = tasks[1].Task.Status; int numFaulted = (task0Status == TaskStatus.Faulted ? 1 : 0) + (task1Status == TaskStatus.Faulted ? 1 : 0); numFaulted.Should().BeGreaterOrEqualTo(1); Assert.True(task0Status == TaskStatus.Faulted || task0Status == TaskStatus.Running || task0Status == TaskStatus.WaitingForActivation, string.Format("First task has status {0} instead of Faulted, Running, or WaitingForActivation.", task0Status)); Assert.True(task1Status == TaskStatus.Faulted || task1Status == TaskStatus.Running || task1Status == TaskStatus.WaitingForActivation, string.Format("Second task has status {0} instead of Faulted, Running, or WaitingForActivation.", task1Status)); Assert.Equal(TaskStatus.RanToCompletion, tasks[2].Task.Status); Assert.Equal(TaskStatus.RanToCompletion, tasks[3].Task.Status); } finally { foreach (CancellableTask task in tasks) { task.CancellationTokenSource.Dispose(); } } }
public async void DownloadTexture(int index) { MemoryStream stream; try { linkTexts[index].text = BioButtons.bioLinks[index].OriginalString.Length >= 43 ? BioButtons.bioLinks[index].OriginalString.Substring(0, 43) : BioButtons.bioLinks[index].OriginalString; WebRequest iconRequest = WebRequest.Create($"http://www.google.com/s2/favicons?domain_url={BioButtons.bioLinks[index].Host}&sz=64"); WebResponse response = await iconRequest.GetResponseAsync(); stream = new MemoryStream(); response.GetResponseStream().CopyTo(stream); } finally { await AsyncUtils.YieldToMainThread(); } Texture2D tex = new Texture2D(2, 2); ImageConversion.LoadImage(tex, stream.ToArray()); icons[index].texture = tex; }
/// <summary> /// Utility function used by async tests /// </summary> /// <param name="rnd"> Used to randomize reader.Read() call, whether it should continue or break, and is passed down to ConsumeReaderAsync</param> /// <param name="result"> The Async result from Begin operation.</param> /// <param name="com"> The Sql Command to Execute</param> /// <param name="query">Indicates if data is being queried and where ExecuteQuery or Non-query to be used with the reader</param> /// <param name="xml">Indicates if the query should be executed as an Xml</param> /// <param name="cancelled">Indicates if command was cancelled and is used to throw exception if a Command cancellation related exception is encountered</param> /// <param name="cts">The Cancellation Token Source</param> private void SqlCommandEndExecute(Random rnd, IAsyncResult result, SqlCommand com, bool query, bool xml, bool cancelled, CancellationTokenSource cts = null) { try { bool closeReader = ShouldCloseDataReader(); if (xml) { XmlReader reader = null; if (result != null && result is Task <XmlReader> ) { reader = AsyncUtils.GetResult <XmlReader>(result); } else { reader = AsyncUtils.ExecuteXmlReader(com); } while (reader.Read()) { if (rnd.Next(10) == 0) { break; } if (rnd.Next(2) == 0) { continue; } reader.ReadElementContentAsString(); } if (closeReader) { reader.Dispose(); } } else if (query) { DataStressReader reader = null; if (result != null && result is Task <SqlDataReader> ) { reader = new DataStressReader(AsyncUtils.GetResult <SqlDataReader>(result)); } else { reader = new DataStressReader(AsyncUtils.ExecuteReader(com)); } CancellationToken token = (cts != null) ? cts.Token : CancellationToken.None; AsyncUtils.WaitAndUnwrapException(ConsumeReaderAsync(reader, false, token, rnd)); if (closeReader) { reader.Close(); } } else { if (result != null && result is Task <int> ) { int temp = AsyncUtils.GetResult <int>(result); } else { AsyncUtils.ExecuteNonQuery(com); } } } catch (Exception e) { if (cancelled && IsCommandCancelledException(e)) { // expected exception, ignore } else { throw; } } }
protected override void Upload(string virtualPath, MemoryStream memoryStream, NameValueCollection queryString) { AsyncUtils.RunSync(() => UploadAsync(virtualPath, memoryStream, queryString)); }
protected IBlobMetadata FetchMetadata(string virtualPath, NameValueCollection queryString) { return(AsyncUtils.RunSync(() => FetchMetadataAsync(virtualPath, queryString))); }
private ICloudBlob GetBlobRef(string virtualPath) { return(AsyncUtils.RunSync(() => GetBlobRefAsync(virtualPath))); }
public override async Task <IEnumerable <IMetadata> > GetMetadataAsync(IEnumerable <IEntryModel> selectedModels, int modelCount, IEntryModel parentModel) { List <IMetadata> retList = new List <IMetadata>(); if (selectedModels.Count() == 1) { #region addExifVal Action <ExifReader, ExifTags> addExifVal = (reader, tag) => { object val = null; switch (tag) { case ExifTags.FNumber: case ExifTags.FocalLength: case ExifTags.XResolution: case ExifTags.YResolution: int[] rational; if (reader.GetTagValue(tag, out rational)) { val = rational[0]; } break; case ExifTags.DateTime: case ExifTags.DateTimeDigitized: case ExifTags.DateTimeOriginal: if (reader.GetTagValue <object>(tag, out val)) { val = DateTime.ParseExact((string)val, "yyyy:MM:dd HH:mm:ss", CultureInfo.InvariantCulture); } break; default: reader.GetTagValue <object>(tag, out val); break; } if (val != null) { DisplayType displayType = DisplayType.Auto; switch (val.GetType().Name) { case "DateTime": displayType = DisplayType.TimeElapsed; break; case "Double": case "Float": val = Math.Round(Convert.ToDouble(val), 2).ToString(); displayType = DisplayType.Text; break; default: displayType = DisplayType.Text; val = val.ToString(); break; } retList.Add(new Metadata(displayType, MetadataStrings.strImage, tag.ToString(), val) { IsVisibleInSidebar = true }); } }; #endregion try { var diskModel = selectedModels.First() as DiskEntryModelBase; if (diskModel != null) { if (diskModel.IsFileWithExtension(FileExtensions.ExifExtensions)) { using (var stream = await diskModel.DiskProfile.DiskIO.OpenStreamAsync(diskModel, FileExplorer.Defines.FileAccess.Read, CancellationToken.None)) using (ExifReader reader = new ExifReader(stream)) { var thumbnailBytes = reader.GetJpegThumbnailBytes(); if (thumbnailBytes != null && thumbnailBytes.Length > 0) { retList.Add(new Metadata(DisplayType.Image, MetadataStrings.strImage, MetadataStrings.strThumbnail, W32ConverterUtils.ToBitmapImage(thumbnailBytes)) { IsVisibleInSidebar = true }); } else { retList.Add(new Metadata(DisplayType.Image, MetadataStrings.strImage, MetadataStrings.strThumbnail, W32ConverterUtils.ToBitmapImage(stream.ToByteArray())) { IsVisibleInSidebar = true }); } UInt16 width, height; if (reader.GetTagValue(ExifTags.PixelXDimension, out width) && reader.GetTagValue(ExifTags.PixelYDimension, out height)) { string dimension = String.Format("{0} x {1}", width, height); retList.Add(new Metadata(DisplayType.Text, MetadataStrings.strImage, MetadataStrings.strDimension, dimension) { IsVisibleInSidebar = true }); } //foreach (var tag in RecognizedExifTags) // addExifVal(reader, tag); } } } } catch { return(AsyncUtils.RunSync(() => (new ImageMetadataProvider() .GetMetadataAsync(selectedModels, modelCount, parentModel)))); } } return(retList); }
public AppViewModel(IEventAggregator events, IWindowManager windowManager) { //FileExplorer.Models.Bookmark.BookmarkSerializeTest.Test(); _windowManager = windowManager; _events = events; _events.Subscribe(this); _profile = new FileSystemInfoProfile(_events); _profileEx = new FileSystemInfoExProfile(_events, _windowManager, new FileExplorer.Models.SevenZipSharp.SzsProfile(_events)); Func <string> loginSkyDrive = () => { var login = new SkyDriveLogin(AuthorizationKeys.SkyDrive_Client_Id); if (_windowManager.ShowDialog(new LoginViewModel(login)).Value) { return(login.AuthCode); } return(null); }; if (AuthorizationKeys.SkyDrive_Client_Secret != null) { _profileSkyDrive = new SkyDriveProfile(_events, AuthorizationKeys.SkyDrive_Client_Id, loginSkyDrive, skyDriveAliasMask); } Func <UserLogin> loginDropBox = () => { var login = new DropBoxLogin(AuthorizationKeys.DropBox_Client_Id, AuthorizationKeys.DropBox_Client_Secret); if (_windowManager.ShowDialog(new LoginViewModel(login)).Value) { return(login.AccessToken); } return(null); }; if (AuthorizationKeys.DropBox_Client_Secret != null) { _profileDropBox = new DropBoxProfile(_events, AuthorizationKeys.DropBox_Client_Id, AuthorizationKeys.DropBox_Client_Secret, loginDropBox); } if (System.IO.File.Exists("gapi_client_secret.json")) { using (var gapi_secret_stream = System.IO.File.OpenRead("gapi_client_secret.json")) //For demo only. { _profileGoogleDrive = new GoogleDriveProfile(_events, gapi_secret_stream); } } string appDataPath = Environment.ExpandEnvironmentVariables("%AppData%\\FileExplorer3"); System.IO.Directory.CreateDirectory(appDataPath); string bookmarkPath = Path.Combine(appDataPath, "Bookmarks.xml"); _profileBm = new BookmarkProfile(_profileEx as IDiskProfile, bookmarkPath, new IProfile[] { _profileEx, _profileSkyDrive, _profileDropBox, _profileGoogleDrive }); RootModels.Add((_profileBm as BookmarkProfile).RootModel); RootModels.Add(AsyncUtils.RunSync(() => _profileEx.ParseAsync(System.IO.DirectoryInfoEx.DesktopDirectory.FullName))); _profiles = new IProfile[] { _profileBm, _profileEx, _profileSkyDrive, _profileDropBox, _profileGoogleDrive }.Where(p => p != null).ToArray(); }