public void OperationRunnerTwoOperationsSuccess()
{
OperationRunner runner = new OperationRunner(
null,
_wizardPage);
int execution = 0;
for (int i = 0; i < 2; i++)
{
runner.Operations.Enqueue(new Operation()
{
Name = $"Operation_{i}",
OperationFunction = (context) =>
{
execution++;
return(null);
},
ValidateFunction = (context) =>
{
return(context.LastOperationStatusCode == 0);
},
});
}
runner.RunOperations();
Assert.AreEqual(2, execution, $"Unexpected number of operations executed ('1' != '{execution}')!");
}
public void OperationRunnerSingleOperationSuccess()
{
OperationRunner runner = new OperationRunner(
null,
_wizardPage);
int execution = 0;
runner.Operations.Enqueue(new Operation()
{
Name = "SingleOperation",
OperationFunction = (context) =>
{
execution++;
return(null);
},
ValidateFunction = (context) =>
{
return(context.LastOperationStatusCode == 0);
},
});
runner.RunOperations();
Assert.AreEqual(1, execution, $"Unexpected number of operations executed ('1' != '{execution}')!");
}
public void OperationRunnerTest_negative_number()
{
var op = Operation.Parse("+ -1 2");
var result = OperationRunner.Run(op);
var expected = 1;
Assert.AreEqual(expected, result);
}
public void OperationRunnerTest1()
{
var op = Operation.Parse("/ + 10 2 4");
var result = OperationRunner.Run(op);
var expected = 9;
Assert.AreEqual(expected, result);
}
public void OperationRunnerTest()
{
var op = Operation.Parse("* + 2 3 4");
var result = OperationRunner.Run(op);
var expected = 20;
Assert.AreEqual(expected, result);
}
public void OutputsExpectedExpression(int value, string expr)
{
var ary = new Rational[] { 2, 0, 1, 7 };
var runner = new OperationRunner(new[] { ary });
IEnumerable <OpResult> rslt = runner.Run();
Assert.Contains(expr, rslt.Select(r => r.ToString()));
}
public AnimalController(ITransactionManager transactionManager, IRepository <Animal> animals, IRepository <Ruleset> rulesets, RulesetScheduleProvider scheduleProvider, OperationRunner operationRunner)
{
_transactionManager = transactionManager;
_animals = animals;
_rulesets = rulesets;
_scheduleProvider = scheduleProvider;
_operationRunner = operationRunner;
}
public void OperationRunnerFiveOperationsExceptionOnThird()
{
OperationRunner runner = new OperationRunner(
null,
_wizardPage);
int execution = 0;
bool handledException = false;
for (int i = 0; i < 5; i++)
{
if (i == 2)
{
runner.Operations.Enqueue(new Operation()
{
Name = $"Operation_{i}",
OperationFunction = (context) =>
{
execution++;
throw new Exception("Halt here!");
},
ValidateFunction = (context) =>
{
return(context.LastOperationStatusCode == 0);
},
ExceptionHandler = (ex) =>
{
handledException = true;
},
});
}
else
{
runner.Operations.Enqueue(new Operation()
{
Name = $"Operation_{i}",
OperationFunction = (context) =>
{
execution++;
return(null);
},
ValidateFunction = (context) =>
{
return(context.LastOperationStatusCode == 0);
},
});
}
}
runner.RunOperations();
Assert.AreEqual(3, execution, $"Unexpected number of operations executed ('1' != '{execution}')!");
Assert.IsTrue(handledException, "Operation should have been passed exception thrown!");
}
public void TestSingleInputNoOutput()
{
var operation = new Operation(
GetType().GetMethod(nameof(DoSomethingWith), BindingFlags.Static | BindingFlags.NonPublic)
);
var inputs = new object[] { " hello" };
var outputs = new OperationRunner().Run(operation, inputs);
Assert.Empty(outputs);
}
public async Task RunAsync_executes_the_task_succesfully_only_once()
{
// Arrange
int count = 0;
var target = new OperationRunner(_logger.Object, new Mock <IServiceProvider>().Object, _transactionManagerMock.Object);
// Act
await target.RunAsync(async (context) => { count++; });
// Assert
Assert.Equal(1, count);
}
public async Task Cancelled_if_the_context_on_timeout()
{
// Arrange
var target = new OperationRunner(_logger.Object, new Mock <IServiceProvider>().Object, _transactionManagerMock.Object);
var task = target.RunAsync((context) => Task.Delay(int.MaxValue, context.CancellationToken), timeout: 1);
// Act
await Task.WhenAny(task, Task.Delay(1000000));
// Assert
Assert.True(task.IsCanceled);
}
/// <summary>
/// Creates the instance core.
/// </summary>
/// <param name="loggerFactory">The logger factory.</param>
/// <param name="fileSystem">The file system.</param>
/// <returns>ICommonServices.</returns>
/// <exception cref="ArgumentNullException">loggerFactory</exception>
/// <autogeneratedoc />
private static ICommonServices CreateInstanceCore(IPureLoggerFactory loggerFactory, IFileSystem fileSystem)
{
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
var processRunner = new ProcessRunner(loggerFactory.CreatePureLogger <ProcessRunner>());
var operationRunner = new OperationRunner(loggerFactory.CreatePureLogger <OperationRunner>());
var networkingSystem = new NetworkingSystem(loggerFactory.CreatePureLogger <NetworkingSystem>());
return(new CommonServices(processRunner, fileSystem, networkingSystem, fileSystem.OperatingSystem, operationRunner, loggerFactory));
}
public void Cancelled_if_the_provided_token_is_cancelled()
{
// Arrange
var target = new OperationRunner(_logger.Object, new Mock <IServiceProvider>().Object, _transactionManagerMock.Object);
var cancellationSource = new CancellationTokenSource();
// Act
var task = target.RunAsync((context) => Task.Delay(int.MaxValue, context.CancellationToken), cancellationSource.Token);
cancellationSource.Cancel();
// Assert
Assert.True(task.IsCanceled);
}
public void OperationRunnerFiveOperationsValidationFailOnFourth()
{
OperationRunner runner = new OperationRunner(
null,
_wizardPage);
int execution = 0;
for (int i = 0; i < 5; i++)
{
if (i == 3)
{
runner.Operations.Enqueue(new Operation()
{
Name = $"Operation_{i}",
OperationFunction = (context) =>
{
execution++;
return(null);
},
ValidateFunction = (context) =>
{
return(context.LastOperationStatusCode == -1);
},
});
}
else
{
runner.Operations.Enqueue(new Operation()
{
Name = $"Operation_{i}",
OperationFunction = (context) =>
{
execution++;
return(null);
},
ValidateFunction = (context) =>
{
return(context.LastOperationStatusCode == 0);
},
});
}
}
runner.RunOperations();
Assert.AreEqual(4, execution, $"Unexpected number of operations executed ('1' != '{execution}')!");
}
public void TestSingleInputReturn()
{
var operation = new Operation(
GetType().GetMethod(nameof(Trim), BindingFlags.Static | BindingFlags.NonPublic)
);
var inputs = new object[] { " hello" };
var outputs = new OperationRunner().Run(operation, inputs);
Assert.Equal(" hello", inputs[0].ToString());
Assert.Single(outputs);
Assert.NotNull(outputs[0]);
Assert.Equal(inputs[0].ToString().Trim(), outputs[0].ToString());
}
public async Task RunAsync_repeatedly_executes_failed_task()
{
// Arrange
int count = 0;
var target = new OperationRunner(_logger.Object, new Mock <IServiceProvider>().Object, _transactionManagerMock.Object);
// Act
await target.RunAsync(async (context) => { count++; if (count < 2)
{
throw new Exception();
}
});
// Assert
Assert.Equal(2, count);
}
public void TestSingleInputOutput()
{
var operation = new Operation(
GetType().GetMethod(nameof(TrimOut), BindingFlags.Static | BindingFlags.NonPublic)
);
string sourceValue = " hello";
var inputs = new object[] { sourceValue };
var outputs = new OperationRunner().Run(operation, inputs);
Assert.Equal(" hello", sourceValue);
Assert.Single(outputs);
Assert.NotNull(outputs[0]);
Assert.Equal(inputs[0].ToString().Trim(), outputs[0].ToString());
}
async Task AuthorizeRequestAsync(Object sender, EventArgs e)
{
if (!await OperationRunner.DoActionAsync("App.AuthorizeRequestAsync",
async() => await RequestAuthorization.IsRequestAuthorizedAsync(DashHttpRequestWrapper.Create(this.Request, true))))
{
this.Response.StatusCode = (int)HttpStatusCode.Forbidden;
// Details lifted directly from Storage Service auth failure responses
this.Response.ContentType = "application/xml";
this.Response.StatusDescription = "Server failed to authenticate the request. Make sure the value of Authorization header is formed correctly including the signature.";
this.Response.Write(String.Format(@"
<?xml version='1.0' encoding='utf-8'?>
<Error>
<Code>AuthenticationFailed</Code>
<Message>Server failed to authenticate the request. Make sure the value of Authorization header is formed correctly including the signature. Time:{0:o}</Message>
</Error>", DateTime.UtcNow));
this.CompleteRequest();
}
}
public void TestSingleInputOutputReturn()
{
var operation = new Operation(
GetType().GetMethod(nameof(TrimOutReturnDifference), BindingFlags.Static | BindingFlags.NonPublic)
);
string sourceValue = " hello";
var inputs = new object[] { sourceValue };
var outputs = new OperationRunner().Run(operation, inputs);
Assert.Equal(" hello", sourceValue);
Assert.Equal(2, outputs.Length);
Assert.IsType <int>(outputs[0]);
Assert.IsType <string>(outputs[1]);
Assert.Equal(sourceValue.Length - sourceValue.Trim().Length, outputs[0]);
Assert.Equal(inputs[0].ToString().Trim(), outputs[1].ToString());
}
/// <summary>
/// Initializes a new instance of the <see cref="OperationRunnerUnitTests"/> class.
/// </summary>
/// <param name="testOutputHelper">The test output helper.</param>
/// <autogeneratedoc />
public OperationRunnerUnitTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
{
_operationRunner = new OperationRunner(TestLoggerFactory.CreatePureLogger <OperationRunner>());
}
static void Main(string[] args)
{
var projectPath = args[0];
var registry = new OperationRegistry();
var factory = new OperationFactory(registry);
var runner = new OperationRunner<RunContext>(registry);
var context = new RunContext();
factory.LoadOperations(projectPath);
runner.RunOperation(args[1], context);
/*var collection = new ProjectCollection();
collection.DefaultToolsVersion = "4.0";
var project = collection.LoadProject(projectPath);
var projectInstance = project.CreateProjectInstance();
ConsoleLogger logger = new ConsoleLogger(LoggerVerbosity.Normal);
var result = projectInstance.Build("Rebuild", new[] { logger });
if (result)
{
var targetPath = projectInstance.GetPropertyValue("TargetPath");
var targetDir = projectInstance.GetPropertyValue("TargetDir");
Console.WriteLine("TargetPath: " + targetPath);
ResolveEventHandler resolver = (object sender, ResolveEventArgs eventArgs) =>
{
var dependency = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(x => x.FullName == eventArgs.Name);
if (dependency == null)
{
var length = eventArgs.Name.IndexOf(',');
if (length > 0)
{
dependency = Assembly.LoadFrom(Path.Combine(targetDir, eventArgs.Name.Substring(0, length) + ".dll"));
}
}
return dependency;
};
AppDomain.CurrentDomain.AssemblyResolve += resolver;
AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += resolver;
var assembly = Assembly.LoadFrom(targetPath);
var projectType = typeof(Framework.Operation);
var buildProjects = assembly.GetTypes().Where(x => projectType.IsAssignableFrom(x)).ToList();
foreach (var buildProject in buildProjects)
{
Console.WriteLine("Run: " + buildProject.FullName);
var task = Activator.CreateInstance(buildProject) as Framework.Operation;
task.Run(new RunContext());
}
}*/
/*var pathToMsBuildBin = Microsoft.Win32.Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\4.0", "MSBuildToolsPath", String.Empty).ToString();
var p = Process.Start(new ProcessStartInfo
{
UseShellExecute = false,
FileName = Path.Combine(pathToMsBuildBin, "msbuild.exe"),
RedirectStandardOutput = true,
Arguments = projectPath + @" /t:Rebuild"
});
string output = p.StandardOutput.ReadToEnd();
p.WaitForExit();
Console.Write(output);*/
}
static void Main(string[] args)
{
uint total = 0;
var opts = new OperationRunnerOptions(withFactorials: true);
var inputs = new List <Rational[]> {
new Rational[] { 2, 0, 1, 7 }
};
/*
* choose 2:
* 2 0
* 2 1
* 2 7
* 0 1
* 0 7
* 1 7
*/
inputs.Add(new Rational[] { 12, 70 });
inputs.Add(new Rational[] { 17, 20 });
inputs.Add(new Rational[] { 20, 17 });
inputs.Add(new Rational[] { 20, 71 });
inputs.Add(new Rational[] { 21, 70 });
/*
* choose 3:
* 2 0 1
* 2 0 7
* 2 1 7
* 0 1 7
*/
inputs.Add(new Rational[] { 102, 7 });
inputs.Add(new Rational[] { 120, 7 });
inputs.Add(new Rational[] { 127, 0 });
inputs.Add(new Rational[] { 170, 2 });
inputs.Add(new Rational[] { 172, 0 });
inputs.Add(new Rational[] { 201, 7 });
inputs.Add(new Rational[] { 207, 1 });
inputs.Add(new Rational[] { 271, 0 });
inputs.Add(new Rational[] { 710, 2 });
inputs.Add(new Rational[] { 701, 2 });
inputs.Add(new Rational[] { 712, 0 });
inputs.Add(new Rational[] { 721, 0 });
Rational r = Rational.Get(2, 10);
inputs.Add(new Rational[] { r, 1, 7 });
r = Rational.Get(1, 10);
inputs.Add(new Rational[] { 2, r, 7 });
r = Rational.Get(7, 10);
inputs.Add(new Rational[] { 2, 1, r });
var runner = new OperationRunner(inputs, opts);
string outputFile = Path.GetTempFileName();
Console.WriteLine("Output: {0}", outputFile);
using (var sw = new StreamWriter(outputFile))
{
foreach (var rslt in runner.Run())
{
++total;
sw.WriteLine("{0} = {1}", rslt.Value, rslt);
}
}
Console.WriteLine("Done! Total: {0}", total);
}
public static async Task ImportAccountAsync(string accountName)
{
await OperationRunner.DoActionAsync(String.Format("Importing data account: {0}", accountName), async() =>
{
// This method will only import the blobs into the namespace. A future task may be
// to redistribute the blobs to balance the entire virtual account.
var account = DashConfiguration.GetDataAccountByAccountName(accountName);
if (account == null)
{
DashTrace.TraceWarning("Failure importing storage account: {0}. The storage account has not been configured as part of this virtual account",
accountName);
return;
}
// Check if we've already imported this account
var accountClient = account.CreateCloudBlobClient();
var namespaceClient = DashConfiguration.NamespaceAccount.CreateCloudBlobClient();
var accountContainers = await ListContainersAsync(accountClient);
var status = await AccountStatus.GetAccountStatus(accountName);
await status.UpdateStatusInformation(AccountStatus.States.Healthy, "Importing storage account: {0} into virtual account", accountName);
bool alreadyImported = false;
await GetAccountBlobs(accountClient, async(blobItem) =>
{
var blob = (ICloudBlob)blobItem;
var namespaceBlob = await NamespaceBlob.FetchForBlobAsync(
(CloudBlockBlob)NamespaceHandler.GetBlobByName(DashConfiguration.NamespaceAccount, blob.Container.Name, blob.Name, blob.IsSnapshot ? blob.SnapshotTime.ToString() : String.Empty));
alreadyImported = await namespaceBlob.ExistsAsync(true) &&
namespaceBlob.DataAccounts.Contains(accountName, StringComparer.OrdinalIgnoreCase);
return(false);
});
if (alreadyImported)
{
await status.UpdateStatusWarning("Importing storage account: {0} has already been imported. This account cannot be imported again.", accountName);
return;
}
// Sync the container structure first - add containers in the imported account to the virtual account
await status.UpdateStatusInformation("Importing storage account: {0}. Synchronizing container structure", accountName);
int containersAddedCount = 0, containersWarningCount = 0;
var namespaceContainers = await ListContainersAsync(namespaceClient);
await ProcessContainerDifferencesAsync(accountContainers, namespaceContainers, async(newContainerName, accountContainer) =>
{
var createContainerResult = await ContainerHandler.DoForAllContainersAsync(newContainerName,
HttpStatusCode.Created,
async newContainer => await CopyContainer(accountContainer, newContainer),
true,
new[] { account });
if (createContainerResult.StatusCode < HttpStatusCode.OK || createContainerResult.StatusCode >= HttpStatusCode.Ambiguous)
{
await status.UpdateStatusWarning("Importing storage account: {0}. Failed to create container: {1} in virtual account. Details: {2}, {3}",
accountName,
newContainerName,
createContainerResult.StatusCode.ToString(),
createContainerResult.ReasonPhrase);
containersWarningCount++;
}
else
{
containersAddedCount++;
}
},
(newContainerName, ex) =>
{
status.UpdateStatusWarning("Importing storage account: {0}. Error processing container {1}. Details: {2}",
accountName,
newContainerName,
ex.ToString()).Wait();
containersWarningCount++;
});
// Sync the other way
await ProcessContainerDifferencesAsync(namespaceContainers, accountContainers, async(newContainerName, namespaceContainer) =>
{
await CopyContainer(namespaceContainer, accountClient.GetContainerReference(newContainerName));
},
(newContainerName, ex) =>
{
status.UpdateStatusWarning("Importing storage account: {0}. Error replicating container {1} to imported account. Details: {2}",
accountName,
newContainerName,
ex.ToString()).Wait();
containersWarningCount++;
});
DashTrace.TraceInformation("Importing storage account: {0}. Synchronized containers structure. {1} containers added to virtual account. {2} failures/warnings.",
accountName,
containersAddedCount,
containersWarningCount);
// Start importing namespace entries
await status.UpdateStatusInformation("Importing storage account: {0}. Adding blob entries to namespace", accountName);
int blobsAddedCount = 0, warningCount = 0, duplicateCount = 0;
await GetAccountBlobs(accountClient, async(blobItem) =>
{
var blob = (ICloudBlob)blobItem;
try
{
var namespaceBlob = await NamespaceBlob.FetchForBlobAsync(
(CloudBlockBlob)NamespaceHandler.GetBlobByName(DashConfiguration.NamespaceAccount, blob.Container.Name, blob.Name, blob.IsSnapshot ? blob.SnapshotTime.ToString() : String.Empty));
if (await namespaceBlob.ExistsAsync())
{
if (!String.Equals(namespaceBlob.PrimaryAccountName, accountName, StringComparison.OrdinalIgnoreCase))
{
await status.UpdateStatusWarning("Importing storage account: {0}. Adding blob: {1}/{2} would result in a duplicate blob entry. This blob will NOT be imported into the virtual account. Manually add the contents of this blob to the virtual account.",
accountName,
blob.Container.Name,
blob.Name);
duplicateCount++;
}
}
else
{
namespaceBlob.PrimaryAccountName = accountName;
namespaceBlob.Container = blob.Container.Name;
namespaceBlob.BlobName = blob.Name;
namespaceBlob.IsMarkedForDeletion = false;
await namespaceBlob.SaveAsync();
blobsAddedCount++;
}
}
catch (StorageException ex)
{
status.UpdateStatusWarning("Importing storage account: {0}. Error importing blob: {0}/{1} into virtual namespace. Details: {3}",
accountName,
blob.Container.Name,
blob.Name,
ex.ToString()).Wait();
warningCount++;
}
return(true);
});
if (status.State < AccountStatus.States.Warning)
{
await status.UpdateStatus(String.Empty, AccountStatus.States.Unknown, TraceLevel.Off);
}
DashTrace.TraceInformation("Successfully imported the contents of storage account: '{0}' into the virtual namespace. Blobs added: {1}, duplicates detected: {2}, errors encountered: {3}",
accountName, blobsAddedCount, duplicateCount, warningCount);
},
ex =>
{
var status = AccountStatus.GetAccountStatus(accountName).Result;
status.UpdateStatusWarning("Error importing storage account: {0} into virtual account. Details: {1}", accountName, ex.ToString()).Wait();
}, false, true);
}
public AdminController(OperationRunner operationRunner, IServiceHttpClientFactory serviceClientFactory)
{
_operationRunner = operationRunner;
}
