/// <summary>
/// This extension method is used to set the response for an inline message.
/// </summary>
/// <param name="c">The incoming context.</param>
/// <param name="status">The response status.</param>
/// <param name="description">The optional response description</param>
public static void ResponseSet(this ICommandRequestContext c, int status, string description = null)
{
TransmissionPayload ars = c.Request.ToResponse();
ars.Message.StatusSet(status, description);
c.Responses.Add(ars);
}
private void ActionSync(TransmissionPayload incoming, List <TransmissionPayload> outgoing)
{
var blahIn = incoming.Message.Holder.Object as Blah;
var rs = incoming.ToResponse();
rs.Message.Holder.SetObject(blahIn.Message);
rs.Message.Status = "204";
rs.Message.StatusDescription = "Hello";
outgoing.Add(rs);
}
private void ActionSync(TransmissionPayload incoming, List <TransmissionPayload> outgoing)
{
var blahIn = PayloadSerializer.PayloadDeserialize <Blah>(incoming);
var rs = incoming.ToResponse();
rs.Message.Blob = PayloadSerializer.PayloadSerialize(blahIn.Message);
rs.Message.Status = "204";
rs.Message.StatusDescription = "Hello";
outgoing.Add(rs);
}
private async Task ActionAsync(TransmissionPayload incoming, List <TransmissionPayload> outgoing)
{
var blahIn = PayloadSerializer.PayloadDeserialize <Blah>(incoming);
var rs = incoming.ToResponse();
rs.Message.Blob.SetObject("Freaky");
rs.Message.Status = "204";
rs.Message.StatusDescription = "Hello";
outgoing.Add(rs);
//return Task.FromResult(0);
}
private async Task ActionAsync(TransmissionPayload incoming, List <TransmissionPayload> outgoing)
{
var blahIn = incoming.Message.Holder.Object as Blah;
var rs = incoming.ToResponse();
rs.Message.Holder.SetObject("Freaky");
rs.Message.Status = "204";
rs.Message.StatusDescription = "Hello";
outgoing.Add(rs);
//return Task.FromResult(0);
}
private async Task ActionAsyncMaster(TransmissionPayload incoming, List <TransmissionPayload> outgoing)
{
var blahIn = incoming.Message.Holder.Object;
var rs = incoming.ToResponse();
//rs.Message.Blob = PayloadSerializer.PayloadSerialize(new Blah { ContentId = blahIn.ContentId, Message = "Howdy" });
rs.Message.Holder.SetObject("Freaky");
rs.Message.Status = "204";
rs.Message.StatusDescription = "Hello";
outgoing.Add(rs);
//return Task.FromResult(0);
}
/// <summary>
/// This extension method is used to set the response for an inline message.
/// </summary>
/// <typeparam name="C">The entity type.</typeparam>
/// <param name="c">The incoming parameters.</param>
/// <param name="status">The response status.</param>
/// <param name="response">The optional response object.</param>
/// <param name="description">The optional response description</param>
public static void ResponseSet <C>(this ICommandRequestContext c, int status, C response = default(C), string description = null)
{
TransmissionPayload ars = c.Request.ToResponse();
ars.Message.StatusSet(status, description);
if (!response.Equals(default(C)))
{
ars.Message.Holder = ServiceHandlerContext.CreateWithObject(response);
}
c.Responses.Add(ars);
}
protected async Task ExecuteJob(Schedule state, CancellationToken token)
{
int currentJob = mCurrentExecutionId++;
//mCollector?.Log(LogLevel.Info, "DelayedProcessingJob - Executing schedule " + currentJob);
state.Context = currentJob;
var payload = new TransmissionPayload("interserv", "do", "something", options: ProcessOptions.RouteExternal);
TaskManager(this, null, payload);
//await Task.Delay(TimeSpan.FromSeconds(40), token);
//mCollector?.Log(LogLevel.Info, "DelayedProcessingJob - Finished executing schedule " + currentJob);
}
private async Task ActionAsync(TransmissionPayload incoming, List <TransmissionPayload> outgoing)
{
var blahIn = PayloadSerializer.PayloadDeserialize <Blah>(incoming);
var rs = incoming.ToResponse();
rs.Message.Blob = PayloadSerializer.PayloadSerialize(new Blah {
ContentId = blahIn.ContentId, Message = "Howdy"
});
rs.MessageObject = "Freaky";
rs.Message.Status = "204";
rs.Message.StatusDescription = "Hello";
outgoing.Add(rs);
}
public void Connector1()
{
var payload = TransmissionPayload.Create <CommunicationBridgeReroute.IContractFinal>();
bool stop = false;
var server = new TcpTlsServer(new IPEndPoint(IPAddress.Any, 9090), SslProtocols.None, null);
var client = new TcpTlsClient(new IPEndPoint(IPAddress.Loopback, 9090), SslProtocols.None, null);
server.Start();
Thread toRun = new Thread(new ThreadStart(() =>
{
while (!stop)
{
if (server.PollRequired)
{
Task.Run(async() => await server.Poll());
}
if (client.PollRequired)
{
Task.Run(async() => await client.Poll());
}
Thread.Sleep(10);
}
}));
toRun.Start();
client.Start();
client.Write(payload).Wait();
server.Poll().Wait();
stop = true;
if (toRun.IsAlive)
{
toRun.Abort();
}
}
public void DispatcherTestSuccess()
{
ManualResetEvent mre = new ManualResetEvent(false);
bool success = false;
var message = new TransmissionPayload(cnChannelIn, "friday", "feeling"
, release: (e, f) =>
{
success = true;
mre.Set();
}
, options: ProcessOptions.RouteInternal
);
mListener.Inject(message);
Wait(mre);
Assert.IsTrue(success);
}
private void ProcessDeadletter(TransmissionPayload inData)
{
Collector.Write(new LogEvent("Hello"), true);
}
/// <summary>
/// Initializes a new instance of the <see cref="DispatcherRequestUnresolvedEventArgs"/> class.
/// </summary>
/// <param name="payload">The payload.</param>
/// <param name="reason">The failure reason.</param>
public DispatcherRequestUnresolvedEventArgs(TransmissionPayload payload, DispatcherRequestUnresolvedReason reason, DispatcherUnhandledAction policy)
{
Payload = payload;
Reason = reason;
Policy = policy;
}
public void Command1(TransmissionPayload inPayload, List <TransmissionPayload> outPayload)
{
}
public async Task Send(EmailTypes emailtype, TransmissionPayload payload)
{
await _emailHelper.SendEmail(emailtype, payload);
}
public void Command2a(TransmissionPayload payload)
{
}
protected async Task <string> Command1([PayloadIn] string inParam, TransmissionPayload inPayload, List <TransmissionPayload> outPayload)
{
var back = await Outgoing.Process <string, string>(("one", "two", "three"), "Hello");
return(back.Response);
}
private async Task DoSomething(TransmissionPayload rq, List <TransmissionPayload> rs)
{
Collector?.LogMessage("all done");
}
private void ActionInSync(TransmissionPayload inPayload)
{
}
private void TestReceive(TransmissionPayload inPayload, List <TransmissionPayload> outCommands)
{
OnTestCommandReceive?.Invoke(this, inPayload);
}
private async Task ActionInAsync(TransmissionPayload inPayload)
{
}
