public async Task <string> ComputeQueries(string className, string methodPrefix, int machines, int numberOfMethods, int repetitions, string assemblyName, string expID)
{
var resultStr = "";
try
{
var solutionGrain = GrainClient.GrainFactory.GetGrain <ISolutionGrain>("Solution");
var analysisClient = new AnalysisClient(solutionGrain, machines);
//var result = await analysisClient.ComputeRandomQueries(className, methodPrefix, numberOfMethods, repetitions, assemblyName, expID);
var result = await analysisClient.ComputeRandomQueries(repetitions, expID);
var avgTime = result.Item1;
var minTime = result.Item2;
var maxTime = result.Item3;
}
catch (Exception exc)
{
while (exc is AggregateException)
{
exc = exc.InnerException;
}
resultStr = "Error connecting to Orleans: " + exc + " at " + DateTime.Now;
}
return(resultStr);
}
public Task <string> AnalyzeSolutionAsync(string drive, string solutionPath, string solutionName, int machines, string expID, string rootKind = "Default")
{
var result = string.Empty;
try
{
if (string.IsNullOrEmpty(expID))
{
expID = solutionName;
}
solutionPath = Path.Combine(drive + ":\\" + solutionPath, solutionName + ".sln");
var analyzer = SolutionAnalyzer.CreateFromSolution(GrainClient.Instance, solutionPath);
var analysisClient = new AnalysisClient(analyzer, machines);
//var results = await analysisClient.RunExperiment(GrainClient.GrainFactory, expID);
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
analysisClient.StartRunningExperiment(GrainClient.GrainFactory, expID, Utils.ToAnalysisRootKind(rootKind));
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
//result = string.Format("Ready for queries. Time: {0} ms", results.ElapsedTime);
result = string.Format("Analyzing solution {0}.", solutionName);
}
catch (Exception exc)
{
while (exc is AggregateException)
{
exc = exc.InnerException;
}
result = "Error connecting to Orleans: " + exc + " at " + DateTime.Now;
}
return(Task.FromResult(result));
}
public Task <string> RunTestAsync(string testName, int machines, int numberOfMethods, string expID, string rootKind = "Default")
{
var result = string.Empty;
try
{
var analyzer = SolutionAnalyzer.CreateFromTest(GrainClient.Instance, testName);
var analysisClient = new AnalysisClient(analyzer, machines);
//var results = await analysisClient.RunExperiment(GrainClient.GrainFactory, expID);
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
analysisClient.StartRunningExperiment(GrainClient.GrainFactory, expID, Utils.ToAnalysisRootKind(rootKind));
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
//result = string.Format("Ready for queries. Time: {0} ms", results.ElapsedTime);
result = string.Format("Running test {0}.", testName);
}
catch (Exception exc)
{
while (exc is AggregateException)
{
exc = exc.InnerException;
}
result = "Error connecting to Orleans: " + exc + " at " + DateTime.Now;
}
return(Task.FromResult(result));
}
private static async Task <ISet <MethodDescriptor> > RunAnalysisFromSourceAsync(int machines, string source)
{
var analyzer = SolutionAnalyzer.CreateFromSource(GrainClient.Instance, source);
var analysisClient = new AnalysisClient(analyzer, machines);
var callgraph = await analysisClient.Analyze();
var reachableMethods = callgraph.GetReachableMethods();
return(await Task.FromResult(reachableMethods));
}
protected void ButtonTestSolution_Click(object sender, EventArgs e)
{
try
{
this.TextBox1.Text = "Accessing Grains...";
var solutionPath = TextBoxPath.Text;
var pathPrefix = TextBoxPathPrefix.Text;
try
{
var tokens = TextRandomQueryInput.Text.Split(';');
var className = tokens[0];
var methodPrejix = tokens[1];
var numberOfMethods = int.Parse(tokens[2]);
var repetitions = int.Parse(tokens[3]);
var machines = int.Parse(tokens[4]);
var rootKind = Utils.ToAnalysisRootKind(tokens[5]);
var solutionFileName = Path.Combine(pathPrefix, solutionPath);
var analyzer = SolutionAnalyzer.CreateFromSolution(GrainClient.Instance, solutionFileName);
var analysisClient = new AnalysisClient(analyzer, machines);
//await analysisClient.Analyze();
//await analysisClient.RunExperiment(GrainClient.GrainFactory, solutionPath.Replace('\\','-').Replace('.','-'));
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
analysisClient.StartRunningExperiment(GrainClient.GrainFactory, solutionPath.Replace('\\', '-').Replace('.', '-'), rootKind);
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
//var reachableMethods = await RunAnalysisAsync(machines, pathPrefix, solutionPath);
//string methods = String.Join("\n", reachableMethods);
//this.TextBox1.Text = string.Format("Reachable methods={0} \n{1}", reachableMethods.Count, methods);
this.TextBox1.Text = "Done";
}
catch (Exception exc)
{
while (exc is AggregateException)
{
exc = exc.InnerException;
}
System.Diagnostics.Trace.TraceError("Error dutring initialization of WorkerRole {0}", exc.ToString());
this.TextBox1.Text = exc.ToString();
}
}
catch (Exception exc)
{
while (exc is AggregateException)
{
exc = exc.InnerException;
}
this.TextBox1.Text = "Error connecting to Orleans: " + exc + " at " + DateTime.Now;
}
}
protected async void ButtonStats_Click(object sender, EventArgs e)
{
//var analysisClient = (AnalysisClient)Application.Get("AnalysisClient");
//if (analysisClient != null)
//{
// var res = await OrleansManager.Program.RunCommand("fullgrainstats", new string[] { });
var res = await AnalysisClient.PrintGrainStatistics(GrainClient.GrainFactory);
this.TextBox1.Text = res;
//}
}
protected async void ButtonRemoveGrains_Click(object sender, EventArgs e)
{
// This doesn't work. I need to move OrleansSolutionManager no another project
// var solutionGrain = OrleansSolutionManager.GetSolutionGrain(GrainClient.GrainFactory);
var solutionGrain = GrainClient.GrainFactory.GetGrain <ISolutionGrain>("Solution");
// var analysisClient = (AnalysisClient)Application.Get("AnalysisClient");
//if (analysisClient != null && analysisClient.SolutionManager is ISolutionGrain)
{
await AnalysisClient.PerformDeactivation(GrainClient.GrainFactory, solutionGrain);
this.TextBox1.Text = "All Grains Deactivated!";
}
}
private static async Task <ISet <MethodDescriptor> > RunAnalysisAsync(int machines, string pathPrefix, string solutionRelativePath)
{
var currentSolutionPath = pathPrefix;
var solutionFileName = Path.Combine(currentSolutionPath, solutionRelativePath);
var analyzer = SolutionAnalyzer.CreateFromSolution(GrainClient.Instance, solutionFileName);
var analysisClient = new AnalysisClient(analyzer, machines);
var callgraph = await analysisClient.Analyze();
var reachableMethods = callgraph.GetReachableMethods();
return(await Task.FromResult(reachableMethods));
}
protected void ButtonTestTest_Click(object sender, EventArgs e)
{
try
{
var testName = TextBoxPath.Text;
var tokens = TextRandomQueryInput.Text.Split(';');
var className = tokens[0];
var methodPrejix = tokens[1];
var numberOfMethods = int.Parse(tokens[2]);
var repetitions = int.Parse(tokens[3]);
var machines = int.Parse(tokens[4]);
var analyzer = SolutionAnalyzer.CreateFromTest(GrainClient.Instance, testName);
var analysisClient = new AnalysisClient(analyzer, machines);
//var stopWatch = Stopwatch.StartNew();
//var results = await analysisClient.RunExperiment(GrainClient.GrainFactory);
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
analysisClient.StartRunningExperiment(GrainClient.GrainFactory);
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
//stopWatch.Stop();
Application["AnalysisClient"] = analysisClient;
//this.TextBox1.Text = string.Format("Ready for queries. Time: {0} ms", results.ElapsedTime);
this.TextBox1.Text = string.Format("Running test {0}.", testName);
//Logger.LogInfo(GrainClient.Logger, "Stats", "Query", "Analyzing {0} took:{1} ms", testName, results.ElapsedTime);
Logger.LogInfo(GrainClient.Logger, "Stats", "Query", "Analyzing {0}.", testName);
//var result = await analysisClient.ComputeRandomQueries(className, methodPrejix, numberOfMethods, repetitions);
//var result = await analysisClient.ComputeRandomQueries(repetitions);
//program.RetriveInfoFromAnalysis();
//System.Diagnostics.Trace.TraceInformation("Analyzing {0} took:{1} ms", testName, stopWatch.ElapsedMilliseconds);
}
catch (Exception exc)
{
while (exc is AggregateException)
{
exc = exc.InnerException;
}
this.TextBox1.Text = "Error connecting to Orleans: " + exc + " at " + DateTime.Now;
}
}
public static IClient GenorateClient(int input)
{
IClient client = null;
switch (input)
{
case 1:
client = new ItemClient();
break;
case 2:
client = new MaterialClient();
break;
case 3:
client = new AnalysisClient();
break;
}
return(client);
}
//[HttpGet]
public async Task <string> PerformDeactivationAsync()
{
var result = string.Empty;
try
{
var solutionGrain = GrainClient.GrainFactory.GetGrain <ISolutionGrain>("Solution");
await AnalysisClient.PerformDeactivation(GrainClient.GrainFactory, solutionGrain);
result = string.Format("All grains are deactivated");
}
catch (Exception exc)
{
while (exc is AggregateException)
{
exc = exc.InnerException;
}
result = "Error connecting to Orleans: " + exc + " at " + DateTime.Now;
}
return(result);
}
public async Task <string> ExecuteCmd(string command)
{
var result = string.Empty;
try
{
switch (command)
{
case "Deactivate":
result = await PerformDeactivationAsync();
break;
case "RemoveGrainState":
result = AnalysisClient.EmptyTable("OrleansGrainState").ToString();
break;
case "RemoveStats":
result = AnalysisClient.EmptyTable("OrleansSiloStatistics").ToString() + " " + AnalysisClient.EmptyTable("OrleansClientStatistics").ToString();
break;
case "Stats":
result = await AnalysisClient.PrintGrainStatistics(GrainClient.GrainFactory);
break;
case "Status":
result = Convert.ToString(AnalysisClient.ExperimentStatus);
if (AnalysisClient.ExperimentStatus != ExperimentStatus.None &&
AnalysisClient.ExperimentStatus != ExperimentStatus.Ready)
{
result += "\nMessage:" + await AnalysisClient.LastMessage + "\n" + AnalysisClient.ErrorMessage; // + await AnalysisClient.CurrentAnalyzedMethodsCount;
}
break;
case "OperationsCount":
result = await AnalysisClient.GetOperationsCount(GrainClient.GrainFactory);
break;
case "Cancel":
await AnalysisClient.CancelExperimentAsync();
result = "Cancelled";
break;
// Unfortunately I cannot run the following scripts from a WebRole
// I can run scripts from Azure PowerShell on the development machine
// or use the Azure Web API
//case "Restart":
// result = RunScript("Stop-Start-CloudService.ps1").ToString();
// break;
//case "Instances":
// result = RunScript("ChangeNumberOfInstances.ps1", "-Instances", "2").ToString();
// break;
}
}
catch (Exception exc)
{
while (exc is AggregateException)
{
exc = exc.InnerException;
}
result = "Error connecting to Orleans: " + exc + " at " + DateTime.Now;
}
return(result);
}
