public void OmissionValueListViewContextMenuItemClick(object sender, EventArgs e)
{
MenuItem menuItem = sender as MenuItem;
if (menuItem == null)
{
return;
}
OmissionParameter parameter = menuItem.Tag as OmissionParameter;
if (parameter == null)
{
return;
}
if (menuItem.Name.Contains("refresh"))
{
parameter.UserState = Guid.NewGuid();
parameter.StartDC = ConvertHelper.GetDouble(this.txtOmissonStartDC.Text, 0.989);
parameter.EndDC = ConvertHelper.GetDouble(this.txtOmissonEndDC.Text, 0.9999);
parameter.Precision = (int)this.nudOmissonPrecision.Value;
TaskArguments arguments = new TaskArguments(new OmissionValueTask(), parameter);
this.asyncEventWorker.RunAsync(parameter.UserState, arguments);
this.SetProgressBar();
return;
}
}
private void btnOmisson_Click(object sender, EventArgs e)
{
this.btnOmisson.Enabled = false;
Category category = this.cbxOmissonCategory.SelectedItem as Category;
NumberType numberType = this.cbxOmissonNumberType.SelectedItem as NumberType;
Dimension dimension = this.cbxOmissonDimesion.SelectedItem as Dimension;
OmissionParameter parameter = new OmissionParameter();
parameter.Sender = sender as Button;
parameter.Worker = this.asyncEventWorker;
parameter.CategoryName = category.Name;
parameter.NumberTypeName = numberType.Name;
parameter.DimensionName = dimension.Name;
parameter.DbName = category.DbName;
parameter.RuleType = category.RuleType;
parameter.NumberType = numberType.Code;
parameter.Dimension = dimension.Code;
parameter.StartDC = ConvertHelper.GetDouble(this.txtOmissonStartDC.Text, 0.989);
parameter.EndDC = ConvertHelper.GetDouble(this.txtOmissonEndDC.Text, 0.9999);
parameter.Precision = (int)this.nudOmissonPrecision.Value;
parameter.Target = this.rightTab;
parameter.OrderByColName = "CurrentSpans";
parameter.SortType = "DESC";
parameter.Filter = string.Empty;
parameter.UserState = Guid.NewGuid();
parameter.Owner = this;
TaskArguments arguments = new TaskArguments(new OmissionValueTask(), parameter);
this.asyncEventWorker.RunAsync(parameter.UserState, arguments);
this.SetProgressBar();
}
public void OmissionValueListViewColumnClick(object sender, ColumnClickEventArgs e)
{
ListView listView = sender as ListView;
if (listView == null)
{
return;
}
OmissionParameter parameter = listView.Tag as OmissionParameter;
if (parameter == null)
{
return;
}
parameter.UserState = Guid.NewGuid();
parameter.StartDC = ConvertHelper.GetDouble(this.txtOmissonStartDC.Text, 0.989);
parameter.EndDC = ConvertHelper.GetDouble(this.txtOmissonEndDC.Text, 0.9999);
parameter.Precision = (int)this.nudOmissonPrecision.Value;
parameter.OrderByColName = listView.Columns[e.Column].Name;
parameter.SortType = parameter.SortType.Equals("DESC") ? "ASC" : "DESC";
TaskArguments arguments = new TaskArguments(new OmissionValueTask(), parameter);
this.asyncEventWorker.RunAsync(parameter.UserState, arguments);
this.SetProgressBar();
}
public async Task RunDistributedCalculation()
{
var mre = new ManualResetEvent(false);
_hubProxy.On <long>("CalculationCompleted", (id) =>
{
mre.Set();
});
await _signalRConnection.Start();
var task = new TaskArguments()
{
A = 2,
B = 1,
IsReady = true,
};
var createdTask = _apiService.Calculate(task);
mre.WaitOne(TimeSpan.FromSeconds(20));
var result = _apiService.GetResult(createdTask.Id);
Assert.Equal(task.A + task.B, result.Result);
}
private void Handle(TaskArguments taskArguments)
{
if (_finishedProductService.IsReady(taskArguments))
{
//if product ready publish it
_bus.Publish(_finishedProductsExchange, String.Empty, false, new Message <TaskArguments>(taskArguments));
}
}
/// <summary>
/// Parses the command line for tasks and adds them to run immediately
/// using the <see cref="RemoveExecutor"/> class.
/// </summary>
/// <param name="arg">The command line parameters passed to the program.</param>
private static void CommandErase(ConsoleArguments arg)
{
TaskArguments arguments = new TaskArguments((EraseArguments)arg)
{
Schedule = "NOW"
};
CommandAddTask(arguments);
}
/// <summary>
/// Parses the command line for tasks and adds them using the
/// <see cref="RemoteExecutor"/> class.
/// </summary>
/// <param name="arg">The command line parameters passed to the program.</param>
private static void CommandAddTask(ConsoleArguments arg)
{
TaskArguments arguments = (TaskArguments)arg;
Task task = TaskFromCommandLine(arguments);
//Send the task out.
using (eraserClient = CommandConnect())
eraserClient.Tasks.Add(task);
}
public void ConsumeAndProcess(TaskArguments taskArguments)
{
if (taskArguments == null)
{
throw new ArgumentNullException(nameof(taskArguments));
}
Handle(taskArguments);
}
private void asyncEventWorker_DoWork(object sender, DoWorkEventArgs args)
{
TaskArguments arguments = args.Argument as TaskArguments;
if (arguments == null)
{
return;
}
arguments.Task.Start(arguments.Parameter);
}
public void Process(TaskArguments taskArguments)
{
Log.Verbose($"RecievedMessage with id={taskArguments.Id}");
var result = new TaskCalculationResult()
{
Id = taskArguments.Id,
Result = taskArguments.A + taskArguments.B
};
Log.Verbose($"Calculation started for task id={taskArguments.Id}");
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(result.Result));
Log.Verbose($"Calculation finished for task id={taskArguments.Id}");
_apiService.SendResults(result);
}
public void OmissionValueListViewColumnClick(object sender, ColumnClickEventArgs e)
{
ListView listView = sender as ListView;
if (listView == null) return;
OmissionParameter parameter = listView.Tag as OmissionParameter;
if (parameter == null) return;
parameter.UserState = Guid.NewGuid();
parameter.StartDC = ConvertHelper.GetDouble(this.txtOmissonStartDC.Text, 0.989);
parameter.EndDC = ConvertHelper.GetDouble(this.txtOmissonEndDC.Text, 0.9999);
parameter.Precision = (int)this.nudOmissonPrecision.Value;
parameter.OrderByColName = listView.Columns[e.Column].Name;
parameter.SortType = parameter.SortType.Equals("DESC") ? "ASC" : "DESC";
TaskArguments arguments = new TaskArguments(new OmissionValueTask(), parameter);
this.asyncEventWorker.RunAsync(parameter.UserState, arguments);
this.SetProgressBar();
}
public void OmissionValueListViewContextMenuItemClick(object sender, EventArgs e)
{
MenuItem menuItem = sender as MenuItem;
if (menuItem == null) return;
OmissionParameter parameter = menuItem.Tag as OmissionParameter;
if (parameter == null) return;
if (menuItem.Name.Contains("refresh"))
{
parameter.UserState = Guid.NewGuid();
parameter.StartDC = ConvertHelper.GetDouble(this.txtOmissonStartDC.Text, 0.989);
parameter.EndDC = ConvertHelper.GetDouble(this.txtOmissonEndDC.Text, 0.9999);
parameter.Precision = (int)this.nudOmissonPrecision.Value;
TaskArguments arguments = new TaskArguments(new OmissionValueTask(), parameter);
this.asyncEventWorker.RunAsync(parameter.UserState, arguments);
this.SetProgressBar();
return;
}
}
private void asyncEventWorker_Completed(object sender, WorkerCompletedEventArgs args)
{
TaskArguments arguments = args.Argument as TaskArguments;
if (arguments == null)
{
return;
}
arguments.Parameter.Sender.Enabled = true;
try
{
arguments.Task.Complete(arguments.Parameter);
}
catch (Exception ex)
{
MessageBoxHelper.DisplayFailure(ex.Message);
}
this.pictureBoxLoading.Visible = false;
this.progressBar.Visible = false;
}
/// <summary>
/// 读取Response 头部信息
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
string ReadHeaderProcess(object args)
{
TaskArguments argument = args as TaskArguments;
StringBuilder bulider = new StringBuilder();
if (argument != null)
{
Stream sm = argument.Stream;
while (!argument.CancelSource.IsCancellationRequested)
{
try
{
int read = sm.ReadByte();
if (read != -1)
{
byte b = (byte)read;
bulider.Append((char)b);
string temp = bulider.ToString();
//Http协议头尾
if (temp.EndsWith("\r\n\r\n"))
{
break;
}
}
else
{
break;
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
break;
}
}
}
return(bulider.ToString());
}
public void ShouldBeAbleToCreateJobModelTypes()
{
var created = from simpleCommand in Command.NewSimpleCommand("echo 'Hello, World!'").Lift("simple-command")
from parameterizedCommand in
Command.NewParametrizedCommand(
new ParametrizedCommand(
"echo 'Hello, %user%'",
new[]
{
"user"
}.ToFSharpList())).Lift()
from tryWithCatch in
new CommandWithErrorHandler(parameterizedCommand, FSharpOption <Command> .Some(simpleCommand)).Lift(
"try-with-catch")
from tryWithoutCatch in
new CommandWithErrorHandler(simpleCommand, FSharpOption <Command> .None).Lift("try-without-catch")
from commandSet0 in CommandSet.Zero.Lift()
from commandSet in new CommandSet(
new[]
{
tryWithCatch
}.ToFSharpList(),
new[]
{
simpleCommand
}.ToFSharpList()).Lift()
from localFiles0 in LocalFiles.Zero.Lift()
from localFiles in LocalFiles.NewLocalFiles(
new[]
{
new FileInfo("temp.txt")
}.ToFSharpList()).Lift()
from uploadedFiles0 in UploadedFiles.Zero.Lift()
from uploadedFiles in UploadedFiles.NewUploadedFiles(
new[]
{
new ResourceFile("blobSource", "blobPath")
}.ToFSharpList()).Lift("uploaded-files")
from workloadUnitTemplate0 in WorkloadUnitTemplate.Zero.Lift()
from workloadUnitTemplate in new WorkloadUnitTemplate(commandSet, localFiles, false).Lift()
from workloadArguments0 in WorkloadArguments.Zero.Lift()
from workloadArguments in
WorkloadArguments.NewWorkloadArguments(
new Dictionary <string, FSharpList <string> >
{
{
"users", new[]
{
"john",
"pradeep"
}.ToFSharpList()
}
}.ToFSharpMap()).Lift()
from workloadSpecification in new WorkloadSpecification(
new[]
{
workloadUnitTemplate
}.ToFSharpList(),
LocalFiles.Zero,
workloadArguments).Lift()
from taskName in TaskName.NewTaskName("simple-task").Lift()
from taskArguments0 in TaskArguments.Zero.Lift()
from taskArguments in TaskArguments.NewTaskArguments(
new Dictionary <string, string>
{
{ "name", "john" }
}.ToFSharpMap()).Lift()
from defaultTaskSpecification in TaskSpecification.Zero.Lift()
from jobName in JobName.NewJobName("simple-job").Lift()
from nullJobPriority in JobPriority.NewJobPriority(null).Lift()
from jobPriority in JobPriority.NewJobPriority(10).Lift()
from defaultJobSpecification in JobSpecification.Zero.Lift()
select "done";
Assert.AreEqual("done", created.Value);
}
public async Task <IHttpActionResult> Create(TaskArguments taskArguments)
{
return(Ok(await Mediator.SendAsync(new RequestCalculationRequest(taskArguments))));
}
public CreateCalcualtionRestRequest(TaskArguments task)
: base(HttpMethod.Post)
{
AddJsonBody(task);
}
/// <summary>
/// Parses the command line for erasure targets and returns them as
/// a Task object.
/// </summary>
/// <param name="arguments">The arguments specified on the command line.</param>
/// <returns>The task represented on the command line.</returns>
private static Task TaskFromCommandLine(TaskArguments arguments)
{
//Create the task
Task task = new Task();
//Get the erasure method the user wants to use
IErasureMethod method = string.IsNullOrEmpty(arguments.ErasureMethod) ?
ErasureMethodRegistrar.Default :
ErasureMethodFromNameOrGuid(arguments.ErasureMethod);
//Define the schedule
if (!string.IsNullOrEmpty(arguments.Schedule))
{
switch (arguments.Schedule.ToUpperInvariant())
{
case "NOW":
task.Schedule = Schedule.RunNow;
break;
case "MANUALLY":
task.Schedule = Schedule.RunManually;
break;
case "RESTART":
task.Schedule = Schedule.RunOnRestart;
break;
default:
throw new ArgumentException(
S._("Unknown schedule type: {0}", arguments.Schedule), "/schedule");
}
}
//Parse the rest of the command line parameters as target expressions.
foreach (string argument in arguments.PositionalArguments)
{
IErasureTarget selectedTarget = null;
//Iterate over every defined erasure target
foreach (IErasureTarget target in Host.Instance.ErasureTargetFactories)
{
//See if this argument can be handled by the target's configurer
IErasureTargetConfigurer configurer = target.Configurer;
if (configurer.ProcessArgument(argument))
{
//Check whether a target has been set (implicitly: check whether two
//configurers can process the argument)
if (selectedTarget == null)
{
configurer.SaveTo(target);
selectedTarget = target;
}
else
{
//Yes, it is an ambiguity. Throw an error.
throw new ArgumentException(S._("Ambiguous argument: {0} can be " +
"handled by more than one erasure target.", argument));
}
}
}
//Check whether a target has been made from parsing the entry.
if (selectedTarget == null)
{
Console.WriteLine(S._("Unknown argument: {0}, skipped.", argument));
}
else
{
selectedTarget.Method = method;
task.Targets.Add(selectedTarget);
}
}
//Check the number of tasks in the task.
if (task.Targets.Count == 0)
{
throw new ArgumentException(S._("Tasks must contain at least one erasure target."));
}
return(task);
}
public TaskArguments Calculate(TaskArguments result)
{
return(_client.Request <TaskArguments>(new CreateCalcualtionRestRequest(result)));
}
private void btnOmisson_Click(object sender, EventArgs e)
{
this.btnOmisson.Enabled = false;
Category category = this.cbxOmissonCategory.SelectedItem as Category;
NumberType numberType = this.cbxOmissonNumberType.SelectedItem as NumberType;
Dimension dimension = this.cbxOmissonDimesion.SelectedItem as Dimension;
OmissionParameter parameter = new OmissionParameter();
parameter.Sender = sender as Button;
parameter.Worker = this.asyncEventWorker;
parameter.CategoryName = category.Name;
parameter.NumberTypeName = numberType.Name;
parameter.DimensionName = dimension.Name;
parameter.DbName = category.DbName;
parameter.RuleType = category.RuleType;
parameter.NumberType = numberType.Code;
parameter.Dimension = dimension.Code;
parameter.StartDC = ConvertHelper.GetDouble(this.txtOmissonStartDC.Text, 0.989);
parameter.EndDC = ConvertHelper.GetDouble(this.txtOmissonEndDC.Text, 0.9999);
parameter.Precision = (int)this.nudOmissonPrecision.Value;
parameter.Target = this.rightTab;
parameter.OrderByColName = "CurrentSpans";
parameter.SortType = "DESC";
parameter.Filter = string.Empty;
parameter.UserState = Guid.NewGuid();
parameter.Owner = this;
TaskArguments arguments = new TaskArguments(new OmissionValueTask(), parameter);
this.asyncEventWorker.RunAsync(parameter.UserState, arguments);
this.SetProgressBar();
}
