public Task <IWaitResult> SendToProcessManagers(IFault message, IMessageMetadata metadata = null)
{
var task = _waiter.Start();
_commandPipe.ProcessesPipeActor.Tell(new MessageMetadataEnvelop <IFault>(message, metadata ?? MessageMetadata.Empty));
return(task);
}
public static Message Error(IFault fault)
{
var resut = new Message();
resut.Body = null;
resut.Fault = fault;
resut.IsSuccess = false;
return(resut);
}
public void OnError(IMessageType message, IFault fault)
{
BaseEventArgs args = new BaseEventArgs();
if (ErrorEvent != null)
{
args.Message = message;
args.ErrorCode = fault.ErrorCode;
args.Description = fault.ErrorMessage;
ErrorEvent(this, args);
}
}
public void WriteSoapFault(XmlWriter writer, IFault fault)
{
var soapFault = (ISoap12Fault)fault;
writer.WriteStartDocument();
WriteStartEnvelope(writer);
writer.WriteAttributeString(PrefixConstants.XMLNS, envPrefix, NamespaceConstants.XMLNS, @namespace);
WriteStartBody(writer);
writer.WriteStartElement("Fault", @namespace);
WriteSoapFaultCode(writer, soapFault.Code);
WriteSoapFaultReason(writer, soapFault.Reason);
if (!string.IsNullOrWhiteSpace(soapFault.Node))
{
writer.WriteStartElement(faultNodeName);
writer.WriteString(soapFault.Node);
writer.WriteEndElement();
}
if (!string.IsNullOrWhiteSpace(soapFault.Role))
{
writer.WriteStartElement(faultRoleName);
writer.WriteString(soapFault.Role);
writer.WriteEndElement();
}
if (!string.IsNullOrWhiteSpace(soapFault.Detail))
{
writer.WriteStartElement(faultDetailName);
writer.WriteValue(soapFault.Detail);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteEndElement();
writer.Flush();
}
public void When_saga_receives_a_message_that_case_saga_exception()
{
var sagaId = Guid.NewGuid();
//prepare initial saga state
var sagaData = new SoftwareProgrammingSagaData(nameof(SoftwareProgrammingSaga.MakingCoffee))
{
PersonId = Guid.NewGuid()
};
var sagaDataEvent = new SagaCreatedEvent <SoftwareProgrammingSagaData>(sagaData, sagaId);
SaveInJournal <SagaDataAggregate <SoftwareProgrammingSagaData> >(sagaId, sagaDataEvent);
var waiter = GridNode.NewWaiter(TimeSpan.FromSeconds(5))
.Expect <IFault <CoffeMakeFailedEvent> >()
.Create();
GridNode.Transport.Publish(new CoffeMakeFailedEvent(Guid.Empty, sagaData.PersonId).CloneWithSaga(sagaId));
_fault = waiter.Result.Message <IFault <CoffeMakeFailedEvent> >();
}
public async Task When_saga_receives_a_message_that_case_saga_exception()
{
var sagaId = Guid.NewGuid();
var personId = Guid.NewGuid();
//prepare initial saga state
var sagaDataEvent = new SagaCreatedEvent <SoftwareProgrammingSaga.States>(SoftwareProgrammingSaga.States.MakingCoffee, sagaId);
SaveInJournal <SoftwareProgrammingSagaState>(sagaId, sagaDataEvent);
var sagaTransitEvent = new CoffeMakeFailedEvent(Guid.Empty, personId).CloneWithSaga(sagaId);
var waitResults = await GridNode.NewDebugWaiter()
.Expect <IFault <CoffeMakeFailedEvent> >()
.Create()
.Publish(sagaTransitEvent);
_fault = waitResults.Message <IFault <CoffeMakeFailedEvent> >();
}
public void WriteSoapFault(XmlWriter writer, IFault fault)
{
var soapFault = (ISoapFault)fault;
writer.WriteStartDocument();
WriteStartEnvelope(writer);
writer.WriteAttributeString(PrefixConstants.XMLNS, soapPrefix, NamespaceConstants.XMLNS, @namespace);
WriteStartBody(writer);
writer.WriteStartElement("Fault", @namespace);
writer.WriteStartElement("faultcode");
writer.WriteString(soapFault.FaultCode);
writer.WriteEndElement();
writer.WriteStartElement("faultstring");
writer.WriteString(soapFault.FaultString);
writer.WriteEndElement();
if (!string.IsNullOrWhiteSpace(soapFault.FaultActor))
{
writer.WriteStartElement("faultactor");
writer.WriteString(soapFault.FaultActor);
writer.WriteEndElement();
}
if (!string.IsNullOrWhiteSpace(soapFault.Details))
{
writer.WriteStartElement("detail");
writer.WriteValue(soapFault.Details);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteEndElement();
writer.Flush();
}
/// <summary>
/// Initializes a new instance of FaultRule class with the specified method, condition and fault.
/// </summary>
/// <param name="method">The signature of the method where the fault should be injected.</param>
/// <param name="condition">The condition that defines when the fault should occur.</param>
/// <param name="fault">The fault to be injected.</param>
public FaultRule(MethodBase method, ICondition condition, IFault fault)
: this(MethodSignatureTranslator.GetCSharpMethodString(method), condition, fault)
{
// Nothing
}
public void createFaultInDB(IFault fault)
{
try
{
DataSet ds = new DataSet();
string sql = "SELECT * From Faults";
SqlDataAdapter da = new SqlDataAdapter(sql, con);
SqlCommandBuilder cb = new SqlCommandBuilder(da); //Generates
da.Fill(ds, "FaultsData");
totalFaults = ds.Tables["FaultsData"].Rows.Count;
DataRow dRow = ds.Tables["FaultsData"].NewRow();
dRow[0] = Convert.ToInt16(fault.FaultID);
dRow[1] = Convert.ToDateTime(fault.FaultDate);
dRow[2] = fault.RoomNumber;
dRow[3] = fault.Description;
dRow[4] = Convert.ToBoolean(fault.Resolved);
ds.Tables["FaultsData"].Rows.Add(dRow);
da.Update(ds, "FaultsData");
}
catch (System.Exception excep)
{
if (con.State.ToString() == "Open")
con.Close();
Application.Exit();
//Environment.Exit(0); //Force the application to close
}
}
/// <summary>
/// Handles all exceptions as technical SOAP faults.
/// </summary>
protected virtual void OnExceptionOccurred(XRoadContext context, Exception exception, IFault fault)
{
using (var writer = new XmlTextWriter(context.HttpContext.Response.OutputStream, XRoadEncoding.Utf8))
context.MessageFormatter.WriteSoapFault(writer, fault);
}
/// <summary>
/// Initializes a new instance of FaultRule class with the specified method, condition and fault.
/// </summary>
/// <param name="method">The signature of the method where the fault should be injected.</param>
/// <param name="condition">The condition that defines when the fault should occur.</param>
/// <param name="fault">The fault to be injected.</param>
public FaultRule(string method, ICondition condition, IFault fault)
: this(method)
{
this.Condition = condition;
this.Fault = fault;
}
public void Update(IFault fault)
{
throw new NotImplementedException();
}
public void Handle(IFault msg)
{
Handle((object)msg);
}
private SagaFault(Guid sagaId, IFault commandFault, TState state)
{
SagaId = sagaId;
CommandFault = commandFault;
State = state;
}
public void Save(IFault fault)
{
throw new NotImplementedException("interaction with data storage (database), save the fault to db.");
}
public SagaFault(IDomainStateSaga <TState> saga, IFault fault) : this(saga.State.Id, fault, saga.State)
{
}
public bool resolveFault(IFault fault)
{
DataLayer.resolveFaultInDB(fault);
return true;
}
public bool resolveFaultInDB(IFault fault)
{
try
{
ds = new DataSet();
string sql = "SELECT * From Faults";
da = new SqlDataAdapter(sql, con);
da.MissingSchemaAction = MissingSchemaAction.AddWithKey;
cb = new SqlCommandBuilder(da); //Generates
da.Fill(ds, "FaultsData");
DataRow findRow = ds.Tables["FaultsData"].Rows.Find(fault.FaultID);
if (findRow != null)
{
findRow[4] = fault.Resolved;
}
da.Update(ds, "FaultsData"); //remove row from database table
}
catch (System.Exception excep)
{
MessageBox.Show(excep.Message);
if (getConnection().ToString() == "Open")
closeConnection();
Application.Exit();
}
return true;
}
public static void SetFault(IFault afault)
{
fault = afault;
}
/// <inheritdoc />
public virtual Task HandleExceptionAsync(WebServiceContext context, Exception exception, IFault fault)
{
using (var writer = XmlWriter.Create(new StreamWriter(context.HttpContext.Response.Body, XRoadEncoding.Utf8)))
context.MessageFormatter.WriteSoapFault(writer, fault);
return(Task.CompletedTask);
}
