protected AbstractProcess(ITopic topic, string name)
{
Topic = topic ?? throw new ProcessParameterNullException(this, nameof(topic));
Name = name ?? GetType().GetFriendlyTypeName();
Topic = topic;
Kind = GetProcessKind(this);
}
public ProcessKind ParseDefinition(string xml)
{
// var result = new SimulationModelDefinition();
var doc = XDocument.Parse(xml);
var processId = int.Parse(doc.Root.Attribute(XmlParsersConfig.AttributeId).Value);
var processName = doc.Root.Attribute(XmlParsersConfig.AttributeName).Value;
var processKind = new ProcessKind
{
Id = processId,
Name = processName,
ActorRoles = ParseActorRoles(doc.Root)
};
ParseTransactions(doc.Root).ForEach(x => processKind.AddTransaction(x));
ParseTransactionLinks(doc.Root).ForEach(x => processKind.AddTransactionLink(x));
// result.ProcessKind = processKind;
// return result;
return(processKind);
}
public XDocument CreateDocument(ProcessKind process, List <ActorRole> actors)
{
var processElement = new XElement(XmlParsersConfig.ElementProcessKind);
processElement.Add(new XAttribute(XmlParsersConfig.AttributeId, process.Id));
processElement.Add(new XAttribute(XmlParsersConfig.AttributeFirstName, process.Name));
// actors
var actorsElement = new XElement(XmlParsersConfig.ElementActorRoles,
from actor in actors
select new XElement(XmlParsersConfig.ElementActorRole,
new XAttribute(XmlParsersConfig.AttributeId, actor.Id),
new XAttribute(XmlParsersConfig.AttributeName, actor.Name)));
processElement.Add(actorsElement);
// transactions
var transactionsElement = new XElement(XmlParsersConfig.ElementTransactions);
CreateTransactionElements(process, transactionsElement);
processElement.Add(transactionsElement);
// links
var linksElement = new XElement(XmlParsersConfig.ElementLinks);
CreateLinkElements(process, linksElement);
processElement.Add(linksElement);
return(new XDocument(processElement));
}
private static void CreateLinkElements(ProcessKind process, XElement linksElement)
{
foreach (var link in process.GetLinks())
{
var linkElement = new XElement(XmlParsersConfig.ElementTransactionLink);
linkElement.Add(new XAttribute(XmlParsersConfig.AttributeId, link.Id));
linkElement.Add(new XAttribute(XmlParsersConfig.AttributeType, link.Type));
linkElement.Add(new XAttribute(XmlParsersConfig.AttributeSourceTransactionId, link.SourceTransactionKindId));
linkElement.Add(new XAttribute(XmlParsersConfig.AttributeDestinationTransactionId, link.DestinationTransactionKindId));
linkElement.Add(new XAttribute(XmlParsersConfig.AttributeSourceCompletion, link.SourceCompletion));
linkElement.Add(new XAttribute(XmlParsersConfig.AttributeDestinationCompletion, link.DestinationCompletion));
var sourceCardinality = new XElement(XmlParsersConfig.ElementSourceCardinality, new XAttribute(XmlParsersConfig.AttributeCardinality, link.SourceCardinality));
var destinationCardinality = new XElement(XmlParsersConfig.ElementDestinationCardinality, new XAttribute(XmlParsersConfig.AttributeCardinality, link.DestinationCardinality));
if (link.SourceCardinality == TransactionLinkCardinality.Interval)
{
sourceCardinality.Add(new XElement(XmlParsersConfig.ElementInterval,
new XAttribute(XmlParsersConfig.AttributeMin, link.SourceCardinalityInterval.Min),
new XAttribute(XmlParsersConfig.AttributeMax, link.SourceCardinalityInterval.Max)));
}
if (link.DestinationCardinality == TransactionLinkCardinality.Interval)
{
destinationCardinality.Add(new XElement(XmlParsersConfig.ElementInterval,
new XAttribute(XmlParsersConfig.AttributeMin, link.DestinationCardinalityInterval.Min),
new XAttribute(XmlParsersConfig.AttributeMax, link.DestinationCardinalityInterval.Max)));
}
linkElement.Add(sourceCardinality);
linkElement.Add(destinationCardinality);
linksElement.Add(linkElement);
}
}
public ProcessKind GetDefinition()
{
var process = new ProcessKind("Rental contract");
var transactionsTreeRoots = GetTransactionDefinitions(process);
transactionsTreeRoots.ForEach(root => process.AddTransaction(root));
return(process);
}
private static void CreateTransactionElements(ProcessKind process, XElement transactionsElement)
{
foreach (var kind in process.GetTransactions())
{
var rootElement = CreateTransactionKindElement(kind);
TreeStructureHelper.Traverse(kind, rootElement, (node, element) =>
{
var childElement = CreateTransactionKindElement(node);
element.Add(childElement);
});
transactionsElement.Add(rootElement);
}
}
private List <TransactionKind> GetTransactionDefinitions(ProcessKind process)
{
var t1 = new TransactionKind("T1", "Rental contracting", process.Id, actorRenter.Id, actorRentalContracter.Id);
var t2 = new TransactionKind("T2", "Rental payment", process.Id, actorRentalContracter.Id, actorRenter.Id);
var t3 = new TransactionKind("T3", "Car pick up", process.Id, actorDriver.Id, actorCarIssuer.Id);
var t4 = new TransactionKind("T4", "Car drop off", process.Id, actorCarIssuer.Id, actorDriver.Id);
var t5 = new TransactionKind("T5", "Penalty payment", process.Id, actorCarIssuer.Id, actorDriver.Id);
t1.AddChild(t2);
t3.AddChild(t4);
t3.AddChild(t5);
process.AddTransactionLink(t1, t2, TransactionCompletion.Requested, TransactionCompletion.Promised, TransactionLinkType.Response);
process.AddTransactionLink(t2, t1, TransactionCompletion.Promised, TransactionCompletion.Promised, TransactionLinkType.Waiting);
process.AddTransactionLink(t2, t1, TransactionCompletion.Accepted, TransactionCompletion.Executed, TransactionLinkType.Waiting);
process.AddTransactionLink(t3, t4, TransactionCompletion.Promised, TransactionCompletion.Requested, TransactionLinkType.Response);
process.AddTransactionLink(t4, t3, TransactionCompletion.Promised, TransactionCompletion.Executed, TransactionLinkType.Waiting);
var linkT4T5Reject = new TransactionLink()
{
SourceTransactionKindId = t4.Id,
DestinationTransactionKindId = t5.Id,
SourceCompletion = TransactionCompletion.Rejected,
DestinationCompletion = TransactionCompletion.Requested,
SourceCardinality = TransactionLinkCardinality.ZeroToOne,
Type = TransactionLinkType.Response
};
process.AddTransactionLink(linkT4T5Reject);
var linkT5T4Ac = new TransactionLink()
{
SourceTransactionKindId = t5.Id,
DestinationTransactionKindId = t4.Id,
SourceCompletion = TransactionCompletion.Accepted,
DestinationCompletion = TransactionCompletion.Accepted,
DestinationCardinality = TransactionLinkCardinality.ZeroToOne,
Type = TransactionLinkType.Waiting
};
process.AddTransactionLink(linkT5T4Ac);
return(new List <TransactionKind> {
t1, t3
});
}
private string GetArguments(ProcessKind processKind, bool isLaunchedProc64)
{
switch (processKind)
{
case ProcessKind.Cmd:
return(isLaunchedProc64 ? "cmd64" : "cmd32");
case ProcessKind.Self:
return(isLaunchedProc64 ? "self64" : "self32");
case ProcessKind.SelfChild32:
return((isLaunchedProc64 ? "self64 " : "self32 ") + "selfChild32");
case ProcessKind.SelfChild64:
return((isLaunchedProc64 ? "self64 " : "self32 ") + "selfChild64");
}
return(string.Empty);
}
private int StartProcess(bool isProc64, ProcessKind procKind, bool isLaunchedProc64)
{
int exitCode = -1;
string currentCodeFolder = Path.GetDirectoryName(AssemblyHelper.GetAssemblyLocation(Assembly.GetExecutingAssembly()));
if (currentCodeFolder != null)
{
currentCodeFolder = Path.Combine(currentCodeFolder, "DetoursCrossBitTests");
string executable = Path.Combine(currentCodeFolder, isProc64 ? TestExecutableX64 : TestExecutableX86);
string workingDirectory = Path.GetDirectoryName(executable);
Contract.Assume(workingDirectory != null);
string arguments = GetArguments(procKind, isLaunchedProc64);
using (var process = new Process
{
StartInfo =
{
FileName = executable,
WorkingDirectory = workingDirectory,
Arguments = arguments,
CreateNoWindow = true,
UseShellExecute = false,
RedirectStandardError = true
}
})
{
process.Start();
// On test failure, we want stderr output from the test process as context.
string line;
while ((line = process.StandardError.ReadLine()) != null)
{
_output.WriteLine("stderr from DetoursCrossBitTests: {0}", line);
}
process.WaitForExit();
exitCode = process.ExitCode;
process.Close();
}
}
return(exitCode);
}
public async Task Start()
{
if (timer == null)
{
timer = new Timer(NotifySimulationNextStep);
}
// var caseParser = new SimulationCaseParser();
var parser = new ProcessKindXmlParser();
var xml = await SimulationCases.LoadXmlAsync(SimulationCases.ModelDefinition);
processKind = parser.ParseDefinition(xml);
var caseXml = await SimulationCases.LoadXmlAsync(SimulationCases.Case01);
simulation = new RentalContractSimulationFromXml(caseXml);
simulation.Prepare();
//send model definition
await Hub.Clients.All.NotifyStart(processKind);
timer.Change(TimeSpan.FromSeconds(0), TimeSpan.FromSeconds(1));
}
