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();
}
