public void translates_max_attempts()
{
var message = new OutgoingMessage();
message.Headers.Add(LightningQueuesChannel.MaxAttemptsHeader, 1.ToString());
message.TranslateHeaders();
message.MaxAttempts.ShouldBe(1);
}
private OutgoingMessage Subscribe(IncomingMessage requestMessage)
{
var toHeader = requestMessage.GetHeader<ToHeader>();
var subscriptionManagerReference = new EndpointReference(toHeader.Uri);
var request = requestMessage.GetPayload<SubscribeRequest>();
var responseMessage = new OutgoingMessage()
.AddHeader(new ActionHeader(Constants.SubscribeResponseAction), false);
var expiration = CalculateExpiration(request.Expires);
var filterInstance = GetFilterInstance(request);
var identifier = GenerateUniqueSubscriptionIdentifier();
var subscription = new Subscription(expiration, _requestHandler, filterInstance, subscriptionManagerReference, requestMessage);
_activeSubscriptions.Add(identifier, subscription);
OnSubscribed(identifier, subscription);
//R7.2.4-1
var body = new SubscribeResponse
{
SubscriptionManager = subscriptionManagerReference,
EnumerationContext = request.Delivery.Mode == Delivery.DeliveryModePull
? new EnumerationContextKey(
identifier)
: null,
Expires = expiration
};
responseMessage.SetBody(new SerializerBodyWriter(body));
return responseMessage;
}
public void empty_when_headers_arent_present()
{
var message = new OutgoingMessage();
message.TranslateHeaders();
message.MaxAttempts.ShouldBeNull();
message.DeliverBy.ShouldBeNull();
}
public RoutingContext(OutgoingMessage messageToDispatch, RoutingStrategy routingStrategy, IBehaviorContext parentContext)
: this(messageToDispatch, new[]
{
routingStrategy
}, parentContext)
{
}
static public bool ReplyBadPacket( IController ctrl, uint flags )
{
//What is this for? Nack + Ping? What can the TinyCLR possibly do with this information?
OutgoingMessage msg = new OutgoingMessage( ctrl, new WireProtocol.Converter(), Commands.c_Monitor_Ping, Flags.c_NonCritical | Flags.c_NACK | flags, null );
return msg.Send();
}
public async Task<int> Retry(IncomingMessage message, TimeSpan delay, TransportTransaction transportTransaction)
{
var outgoingMessage = new OutgoingMessage(message.MessageId, new Dictionary<string, string>(message.Headers), message.Body);
var currentDelayedRetriesAttempt = message.GetDelayedDeliveriesPerformed() + 1;
outgoingMessage.SetCurrentDelayedDeliveries(currentDelayedRetriesAttempt);
outgoingMessage.SetDelayedDeliveryTimestamp(DateTime.UtcNow);
UnicastAddressTag messageDestination;
List<DeliveryConstraint> deliveryConstraints = null;
if (timeoutManagerAddress == null)
{
// transport supports native deferred messages, directly send to input queue with delay constraint:
deliveryConstraints = new List<DeliveryConstraint>(1)
{
new DelayDeliveryWith(delay)
};
messageDestination = new UnicastAddressTag(endpointInputQueue);
}
else
{
// transport doesn't support native deferred messages, reroute to timeout manager:
outgoingMessage.Headers[TimeoutManagerHeaders.RouteExpiredTimeoutTo] = endpointInputQueue;
outgoingMessage.Headers[TimeoutManagerHeaders.Expire] = DateTimeExtensions.ToWireFormattedString(DateTime.UtcNow + delay);
messageDestination = new UnicastAddressTag(timeoutManagerAddress);
}
var transportOperations = new TransportOperations(new TransportOperation(outgoingMessage, messageDestination, deliveryConstraints: deliveryConstraints));
await dispatcher.Dispatch(transportOperations, transportTransaction, new ContextBag()).ConfigureAwait(false);
return currentDelayedRetriesAttempt;
}
public ForwardingContext(OutgoingMessage messageToForward, string address, IBehaviorContext parentContext) : base(parentContext)
{
Guard.AgainstNull(nameof(messageToForward), messageToForward);
Guard.AgainstNullAndEmpty(nameof(address), address);
Message = messageToForward;
Address = address;
}
public void Should_set_label_when_convention_configured()
{
var queueName = "labelTest";
var path = $@"{RuntimeEnvironment.MachineName}\private$\{queueName}";
try
{
MsmqHelpers.DeleteQueue(path);
MsmqHelpers.CreateQueue(path);
var messageSender = new MsmqMessageDispatcher(new MsmqSettings(), _ => "mylabel");
var bytes = new byte[]
{
1
};
var headers = new Dictionary<string, string>();
var outgoingMessage = new OutgoingMessage("1", headers, bytes);
var transportOperation = new TransportOperation(outgoingMessage, new UnicastAddressTag(queueName), DispatchConsistency.Default);
messageSender.Dispatch(new TransportOperations(transportOperation), new TransportTransaction(), new ContextBag());
var messageLabel = ReadMessageLabel(path);
Assert.AreEqual("mylabel", messageLabel);
}
finally
{
MsmqHelpers.DeleteQueue(path);
}
}
public async Task Invoke(MessageContext context)
{
var timeoutId = context.Headers["Timeout.Id"];
var timeoutData = await persister.Peek(timeoutId, context.Context).ConfigureAwait(false);
if (timeoutData == null)
{
return;
}
timeoutData.Headers[Headers.TimeSent] = DateTimeExtensions.ToWireFormattedString(DateTime.UtcNow);
timeoutData.Headers["NServiceBus.RelatedToTimeoutId"] = timeoutData.Id;
var outgoingMessage = new OutgoingMessage(context.MessageId, timeoutData.Headers, timeoutData.State);
var transportOperation = new TransportOperation(outgoingMessage, new UnicastAddressTag(timeoutData.Destination), dispatchConsistency);
await dispatcher.Dispatch(new TransportOperations(transportOperation), context.TransportTransaction, context.Context).ConfigureAwait(false);
var timeoutRemoved = await persister.TryRemove(timeoutId, context.Context).ConfigureAwait(false);
if (!timeoutRemoved)
{
// timeout was concurrently removed between Peek and TryRemove. Throw an exception to rollback the dispatched message if possible.
throw new Exception($"timeout '{timeoutId}' was concurrently processed.");
}
}
public void Should_use_string_empty_label_when_no_convention_configured()
{
var queueName = "emptyLabelTest";
var path = $@".\private$\{queueName}";
try
{
MsmqHelpers.DeleteQueue(path);
MsmqHelpers.CreateQueue(path);
var messageSender = new MsmqMessageDispatcher(new MsmqSettings(), pairs => string.Empty);
var bytes = new byte[]
{
1
};
var headers = new Dictionary<string, string>();
var outgoingMessage = new OutgoingMessage("1", headers, bytes);
var transportOperation = new TransportOperation(outgoingMessage, new UnicastAddressTag(queueName), DispatchConsistency.Default);
messageSender.Dispatch(new TransportOperations(transportOperation), new TransportTransaction(), new ContextBag());
var messageLabel = ReadMessageLabel(path);
Assert.IsEmpty(messageLabel);
}
finally
{
MsmqHelpers.DeleteQueue(path);
}
}
public IEnumerable<object> Enumerate(IEnumerationContext context, IncomingMessage incomingMessage, OutgoingMessage outgoingMessage)
{
var name = context.Selectors.ExtractObjectName();
if (_server.IsRegistered(name))
{
yield return ObjectNameSelector.CreateEndpointAddress(name);
}
}
public AuditContext(OutgoingMessage message, string auditAddress, IBehaviorContext parent)
: base(parent)
{
Guard.AgainstNull(nameof(message), message);
Guard.AgainstNullAndEmpty(nameof(auditAddress), auditAddress);
Message = message;
AuditAddress = auditAddress;
}
/// <summary>
/// Creates a <see cref="IRoutingContext" /> based on the current context.
/// </summary>
public static IRoutingContext CreateRoutingContext(this StageConnector<IOutgoingPhysicalMessageContext, IRoutingContext> stageConnector, OutgoingMessage outgoingMessage, IReadOnlyCollection<RoutingStrategy> routingStrategies, IOutgoingPhysicalMessageContext sourceContext)
{
Guard.AgainstNull(nameof(outgoingMessage), outgoingMessage);
Guard.AgainstNull(nameof(routingStrategies), routingStrategies);
Guard.AgainstNull(nameof(sourceContext), sourceContext);
return new RoutingContext(outgoingMessage, routingStrategies, sourceContext);
}
public void translates_deliver_by()
{
var now = DateTime.Now;
var message = new OutgoingMessage();
message.Headers.Add(LightningQueuesChannel.DeliverByHeader, now.ToString("o"));
message.TranslateHeaders();
message.DeliverBy.ShouldBe(now);
}
/// <summary>
/// Creates a <see cref="IRoutingContext" /> based on the current context.
/// </summary>
public static IRoutingContext CreateRoutingContext(this ForkConnector<ITransportReceiveContext, IRoutingContext> forkConnector, OutgoingMessage outgoingMessage, string localAddress, ITransportReceiveContext sourceContext)
{
Guard.AgainstNull(nameof(outgoingMessage), outgoingMessage);
Guard.AgainstNullAndEmpty(nameof(localAddress), localAddress);
Guard.AgainstNull(nameof(sourceContext), sourceContext);
return new RoutingContext(outgoingMessage, new UnicastRoutingStrategy(localAddress), sourceContext);
}
/// <summary>
/// Creates a <see cref="IRoutingContext" /> based on the current context.
/// </summary>
public static IRoutingContext CreateRoutingContext(this StageConnector<IAuditContext, IRoutingContext> stageConnector, OutgoingMessage outgoingMessage, RoutingStrategy routingStrategy, IAuditContext sourceContext)
{
Guard.AgainstNull(nameof(outgoingMessage), outgoingMessage);
Guard.AgainstNull(nameof(routingStrategy), routingStrategy);
Guard.AgainstNull(nameof(sourceContext), sourceContext);
return new RoutingContext(outgoingMessage, routingStrategy, sourceContext);
}
public async Task Invoke(MessageContext context)
{
var sagaId = Guid.Empty;
string sagaIdString;
if (context.Headers.TryGetValue(Headers.SagaId, out sagaIdString))
{
sagaId = Guid.Parse(sagaIdString);
}
if (context.Headers.ContainsKey(TimeoutManagerHeaders.ClearTimeouts))
{
if (sagaId == Guid.Empty)
{
throw new InvalidOperationException("Invalid saga id specified, clear timeouts is only supported for saga instances");
}
await persister.RemoveTimeoutBy(sagaId, context.Context).ConfigureAwait(false);
}
else
{
string expire;
if (!context.Headers.TryGetValue(TimeoutManagerHeaders.Expire, out expire))
{
throw new InvalidOperationException("Non timeout message arrived at the timeout manager, id:" + context.MessageId);
}
var destination = GetReplyToAddress(context);
string routeExpiredTimeoutTo;
if (context.Headers.TryGetValue(TimeoutManagerHeaders.RouteExpiredTimeoutTo, out routeExpiredTimeoutTo))
{
destination = routeExpiredTimeoutTo;
}
var data = new TimeoutData
{
Destination = destination,
SagaId = sagaId,
State = context.Body,
Time = DateTimeExtensions.ToUtcDateTime(expire),
Headers = context.Headers,
OwningTimeoutManager = owningTimeoutManager
};
if (data.Time.AddSeconds(-1) <= DateTime.UtcNow)
{
var outgoingMessage = new OutgoingMessage(context.MessageId, data.Headers, data.State);
var transportOperation = new TransportOperation(outgoingMessage, new UnicastAddressTag(data.Destination));
await dispatcher.Dispatch(new TransportOperations(transportOperation), context.TransportTransaction, context.Context).ConfigureAwait(false);
return;
}
await persister.Add(data, context.Context).ConfigureAwait(false);
poller.NewTimeoutRegistered(data.Time);
}
}
public IEnumerable<object> Enumerate(IEnumerationContext context, IncomingMessage requestMessage, OutgoingMessage responseMessage)
{
Console.WriteLine("Server: Returning item");
yield return new EndpointReference("http://tempuri-1.org");
Console.WriteLine("Server: Returning item");
yield return new EndpointReference("http://tempuri-2.org");
Console.WriteLine("Server: Returning item");
yield return new EndpointReference("http://tempuri-3.org");
}
static OutgoingMessage InvokeBehavior(Dictionary<string, string> headers = null)
{
var message = new OutgoingMessage("id", headers ?? new Dictionary<string, string>(), null);
new AttachSenderRelatedInfoOnMessageBehavior()
.Invoke(new TestableRoutingContext {Message = message, RoutingStrategies = new List<UnicastRoutingStrategy> { new UnicastRoutingStrategy("_") }}, _ => TaskEx.CompletedTask);
return message;
}
public IEnumerable<object> Enumerate(IEnumerationContext context, IncomingMessage incomingMessage, OutgoingMessage outgoingMessage)
{
var filterExpr = context.Filter != null
? ExpressionParser.Parse<bool>((string)context.Filter)
: null;
return _server
.QueryNames(context.Selectors.ExtractObjectName(), filterExpr)
.Select(ObjectNameSelector.CreateEndpointAddress);
}
public IncomingMessage SendRequest(OutgoingMessage requestMessage)
{
requestMessage.AddHeader(new ToHeader("http://example.com"), true);
var serverReceivedMessage = Receive(requestMessage);
var serverResponse = Handle(serverReceivedMessage);
var clientReceivedMessage = Receive(serverResponse);
return clientReceivedMessage;
}
private static IncomingMessage Receive(OutgoingMessage outgoingMessage)
{
var buffer = new StringBuilder();
using (var writer = XmlWriter.Create(buffer))
{
outgoingMessage.Write(writer);
writer.Flush();
}
var reader = XmlReader.Create(new StringReader(buffer.ToString()));
return new IncomingMessage(reader);
}
public static OutgoingMessage Create(string action, string reason, XmlQualifiedName code, IEnumerable<XmlQualifiedName> subcodes)
{
var message = new OutgoingMessage();
message.AddHeader(new ActionHeader(action), false);
var fault = new Fault
{
Code = CreateCode(code, subcodes),
Detail = new FaultDetail(),
Reason = CreateReason(reason)
};
message.SetBody(new SerializerBodyWriter(fault));
return message;
}
public void It_writes_body()
{
var bodyWriter = new XElementWriter(new XElement("Body"));
var message = new OutgoingMessage();
message.SetBody(bodyWriter);
var envelope = XElementExtensions.ParseGeneratedXml(message.Write);
Assert.AreEqual(SOAP.Constants.Envelope, envelope.Name);
var bodySectionElement = envelope.Element(SOAP.Constants.Body);
var bodyElement = (XElement) bodySectionElement.FirstNode;
Assert.AreEqual("Body", bodyElement.Name.LocalName);
}
public void Send(OutgoingMessage message)
{
var destination = _addressing.DecodeAddress(message.ReceiverId);
Bus.SendLocal(new InternalMessage
{
MessageId = message.MessageId,
Payload = message.Payload,
ProcessingRequirements = message.ProcessingRequirements,
ReceiverId = destination.Id,
ReceiverType = destination.Type,
RelatedMessageId = message.RelatedMessageId,
SenderId = message.SenderId,
SenderType = message.SenderType
});
}
public async Task Should_not_dispatch_by_default()
{
var dispatched = false;
var behavior = new RoutingToDispatchConnector();
var message = new OutgoingMessage("ID", new Dictionary<string, string>(), new byte[0]);
await behavior.Invoke(new RoutingContext(message,
new UnicastRoutingStrategy("Destination"), CreateContext(new SendOptions(), true)), c =>
{
dispatched = true;
return TaskEx.CompletedTask;
});
Assert.IsFalse(dispatched);
}
public async Task RawSending()
{
IDispatchMessages dispatcher = null;
#region DispatcherRawSending
var headers = new Dictionary<string, string>();
var outgoingMessage = new OutgoingMessage("MessageId", headers, new byte[] { });
var constraints = new[] { new NonDurableDelivery() };
UnicastAddressTag address = new UnicastAddressTag("Destination");
var options = new DispatchOptions(address, DispatchConsistency.Default, constraints);
TransportOperation transportOperation = new TransportOperation(outgoingMessage, options);
await dispatcher.Dispatch(new[] { transportOperation }, new ContextBag());
#endregion
}
public void Send(Envelope envelope)
{
var uri = new LightningUri(envelope.Destination);
var message = new OutgoingMessage
{
Id = MessageId.GenerateRandom(),
Data = envelope.Data,
Headers = envelope.Headers.ToDictionary(),
SentAt = DateTime.UtcNow,
Destination = envelope.Destination,
Queue = uri.QueueName
};
message.TranslateHeaders();
_context.Send(message);
}
private static void WriteResponse(HttpContext ctx, OutgoingMessage outgoingMessage)
{
using (var memoryStream = new MemoryStream())
{
var settings = new XmlWriterSettings
{
Encoding = Encoding.UTF8
};
using (var writer = XmlWriter.Create(memoryStream, settings))
{
Log.Debug("Writing response to stream.");
outgoingMessage.Write(writer);
writer.Flush();
}
var buffer = memoryStream.GetBuffer();
ctx.Response.OutputStream.Write(buffer, 0, (int)memoryStream.Length);
}
}
public async Task Should_dispatch_immediately_if_user_requested()
{
var options = new SendOptions();
options.RequireImmediateDispatch();
var dispatched = false;
var behavior = new RoutingToDispatchConnector();
var message = new OutgoingMessage("ID", new Dictionary<string, string>(), new byte[0]);
await behavior.Invoke(new RoutingContext(message,
new UnicastRoutingStrategy("Destination"), CreateContext(options, true)), c =>
{
dispatched = true;
return TaskEx.CompletedTask;
});
Assert.IsTrue(dispatched);
}
protected override async Task FlushMessageAsync(OutgoingMessage message, CancellationToken cancellationToken)
{
await _outboxMessageSet.AddAsync(message, cancellationToken);
}
public void Send(IModel channel, string address, OutgoingMessage message, IBasicProperties properties)
{
channel.BasicPublish(string.Empty, address, true, properties, message.Body);
}
public override void _Dispatch(IncomingMessage im, OutgoingMessage om)
{
switch (im.CommandId)
{
case 0: { // Unknown0
Unknown0(null, im.GetBuffer <byte>(0x6, 0));
om.Initialize(0, 0, 0);
break;
}
case 1: { // Unknown1
Unknown1(im.GetBuffer <byte>(0x6, 0));
om.Initialize(0, 0, 0);
break;
}
case 2: { // Unknown2
Unknown2(null, im.GetBuffer <byte>(0x6, 0));
om.Initialize(0, 0, 0);
break;
}
case 3: { // Unknown3
Unknown3(null, im.GetBuffer <byte>(0x5, 0));
om.Initialize(0, 0, 0);
break;
}
case 4: { // Unknown4
Unknown4(null, im.GetBuffer <byte>(0x6, 0));
om.Initialize(0, 0, 0);
break;
}
case 5: { // Unknown5
Unknown5(null);
om.Initialize(0, 0, 0);
break;
}
case 6: { // Unknown6
Unknown6(im.GetBuffer <byte>(0x6, 0));
om.Initialize(0, 0, 0);
break;
}
case 7: { // Unknown7
Unknown7(null);
om.Initialize(0, 0, 0);
break;
}
case 8: { // Unknown8
Unknown8(null, im.GetBuffer <byte>(0x6, 0));
om.Initialize(0, 0, 0);
break;
}
case 9: { // Unknown9
Unknown9(null, im.GetBuffer <byte>(0x5, 0));
om.Initialize(0, 0, 0);
break;
}
case 10: { // Unknown10
var ret = Unknown10();
om.Initialize(0, 1, 0);
om.Copy(0, CreateHandle(ret, copy: true));
break;
}
case 11: { // Unknown11
Unknown11();
om.Initialize(0, 0, 0);
break;
}
case 12: { // Unknown12
var ret = Unknown12(null, im.GetBuffer <byte>(0x5, 0));
om.Initialize(0, 0, 0);
break;
}
default:
throw new NotImplementedException($"Unhandled command ID to ICtrlSession: {im.CommandId}");
}
}
public IMessagingMessage CreateMessage(ILogger logger, Stream stream, OutgoingMessage outgoingMessage)
{
var factory = FindNextFactory(logger);
return(factory.CreteMessage(stream, outgoingMessage));
}
static OutgoingMessage Copy(OutgoingMessage message)
{
return(new OutgoingMessage(message.MessageId, new Dictionary <string, string>(message.Headers), message.Body));
}
public void Send(OutgoingMessage message)
{
Bus.SendLocal(new LocalMessage {
Message = message
});
}
public override Task Invoke(IOutgoingPhysicalMessageContext context, Func <IRoutingContext, Task> stage)
{
var message = new OutgoingMessage(context.MessageId, context.Headers, context.Body);
return(stage(this.CreateRoutingContext(message, context.RoutingStrategies, context)));
}
void SpeakerThread()
{
bool waiting_for_line = false;
string message_waited_for = "";
TTSCallback callback_waited_for = null;
SetIsRunning(true);
while (IsClosing() == false) {
if(waiting_for_line) {
if(Client.VoiceFinished()) {
byte[] new_voice = Client.PopVoice();
float[] voice_float = new float[new_voice.Length/2];
for(int i = 0; i < voice_float.Length; i++) {
//if(BitConverter.IsLittleEndian)
voice_float[i] = (float)BitConverter.ToInt16(new_voice, i*2)/(float)short.MaxValue;
}
OutgoingMessage om = new OutgoingMessage();
om.type = OutgoingMessageType.VoiceLineFinished;
om.data = voice_float;
om.message = message_waited_for;
om.callback = callback_waited_for;
outgoing_message_mutex.WaitOne();
outgoing_messages.Enqueue(om);
outgoing_message_mutex.ReleaseMutex();
waiting_for_line = false;
message_waited_for = "";
callback_waited_for = null;
}
} else if (HasMessage()) {
try
{
IncomingMessage msg = PopMessage();
switch(msg.type) {
case IncomingMessageType.Say:
Client.Speak(msg.message);
//Client.SpeakSSML(msg);
message_waited_for = msg.message;
callback_waited_for = msg.callback;
waiting_for_line = true;
break;
case IncomingMessageType.SetPitch:
Client.SetPitch(msg.param1);
break;
case IncomingMessageType.SetRange:
Client.SetRange(msg.param1);
break;
case IncomingMessageType.SetRate:
Client.SetRate(msg.param1);
break;
case IncomingMessageType.SetVolume:
Client.SetVolume(msg.param1);
break;
case IncomingMessageType.SetWordGap:
Client.SetWordgap(msg.param1);
break;
case IncomingMessageType.SetCapitals:
Client.SetCapitals(msg.param1);
break;
case IncomingMessageType.SetIntonation:
Client.SetIntonation(msg.param1);
break;
case IncomingMessageType.SetVoice:
Client.SetVoiceByName(msg.message);
break;
}
}
catch (System.Exception e)
{
Debug.LogException(e);
}
}
Thread.Sleep(8);
}
isRunning = false;
}
/// <summary>
/// Create an [[https://www.rabbitmq.com/tutorials/tutorial-six-java.html RPC style flow]] for processing and communicating
/// over a rabbitmq message bus. This will create a private queue, and add the reply-to header to messages sent out.
///
/// This stage materializes to a <see cref="Task{String}"/>, which is the name of the private exclusive queue used for RPC communication.
/// </summary>
/// <param name="settings"></param>
/// <param name="repliesPerMessage">The number of responses that should be expected for each message placed on the queue. This
/// can be overridden per message by including <code>expectedReplies</code> in the the header of the <see cref="OutgoingMessage"/></param>
/// <returns>TBD</returns>
public static Flow <ByteString, ByteString, Task <string> > CreateSimple(AmqpSinkSettings settings,
int repliesPerMessage = 1)
{
return(Flow.Create <ByteString, Task <string> >().Select(bytes => OutgoingMessage.Create(bytes, false, false))
.Via(Create(settings, 1, repliesPerMessage)).Select(_ => _.Bytes));
}
public override void _Dispatch(IncomingMessage im, OutgoingMessage om)
{
switch (im.CommandId)
{
case 0: { // Unknown0
Unknown0();
om.Initialize(0, 0, 0);
break;
}
case 1: { // Unknown1
Unknown1();
om.Initialize(0, 0, 0);
break;
}
case 2: { // Unknown2
Unknown2(null);
om.Initialize(0, 0, 0);
break;
}
case 3: { // Unknown3
var ret = Unknown3();
om.Initialize(0, 0, 0);
break;
}
case 4: { // Unknown4
Unknown4();
om.Initialize(0, 0, 0);
break;
}
case 5: { // Unknown5
var ret = Unknown5();
om.Initialize(0, 0, 0);
break;
}
case 6: { // TurnOnBacklight
TurnOnBacklight(null);
om.Initialize(0, 0, 0);
break;
}
case 7: { // TurnOffBacklight
TurnOffBacklight(null);
om.Initialize(0, 0, 0);
break;
}
case 8: { // GetBacklightStatus
var ret = GetBacklightStatus();
om.Initialize(0, 0, 0);
break;
}
case 9: { // Unknown9
Unknown9();
om.Initialize(0, 0, 0);
break;
}
case 10: { // Unknown10
Unknown10();
om.Initialize(0, 0, 0);
break;
}
case 11: { // Unknown11
var ret = Unknown11();
om.Initialize(0, 0, 0);
break;
}
case 12: { // Unknown12
Unknown12();
om.Initialize(0, 0, 0);
break;
}
case 13: { // Unknown13
Unknown13();
om.Initialize(0, 0, 0);
break;
}
case 14: { // Unknown14
var ret = Unknown14();
om.Initialize(0, 0, 0);
break;
}
case 15: { // Unknown15
Unknown15(null);
om.Initialize(0, 0, 0);
break;
}
case 16: { // ReadRawLightSensor
var ret = ReadRawLightSensor();
om.Initialize(0, 0, 0);
break;
}
case 17: { // Unknown17
Unknown17(null);
om.Initialize(0, 0, 0);
break;
}
case 18: { // Unknown18
var ret = Unknown18(null);
om.Initialize(0, 0, 0);
break;
}
case 19: { // Unknown19
Unknown19(null);
om.Initialize(0, 0, 0);
break;
}
case 20: { // Unknown20
var ret = Unknown20();
om.Initialize(0, 0, 0);
break;
}
case 21: { // Unknown21
Unknown21(null);
om.Initialize(0, 0, 0);
break;
}
case 22: { // Unknown22
var ret = Unknown22();
om.Initialize(0, 0, 0);
break;
}
case 23: { // Unknown23
var ret = Unknown23();
om.Initialize(0, 0, 0);
break;
}
case 24: { // Unknown24
Unknown24(null);
om.Initialize(0, 0, 0);
break;
}
case 25: { // Unknown25
var ret = Unknown25();
om.Initialize(0, 0, 0);
break;
}
case 26: { // EnableVrMode
EnableVrMode();
om.Initialize(0, 0, 0);
break;
}
case 27: { // DisableVrMode
DisableVrMode();
om.Initialize(0, 0, 0);
break;
}
case 28: { // GetVrMode
var ret = GetVrMode();
om.Initialize(0, 0, 0);
break;
}
default:
throw new NotImplementedException($"Unhandled command ID to ILblController: {im.CommandId}");
}
}
protected override Task FlushMessageAsync(OutgoingMessage message, CancellationToken cancellationToken)
{
return(_messageBroker.PostMessageAsync(message, cancellationToken));
}
public override void _Dispatch(IncomingMessage im, OutgoingMessage om)
{
switch (im.CommandId)
{
case 0: { // InitializeDebug
InitializeDebug(im.GetData <ulong>(8), im.GetData <ulong>(16), im.Pid, im.GetBuffer <byte>(0x5, 0));
om.Initialize(0, 0, 0);
break;
}
case 1: { // FinalizeDebug
FinalizeDebug();
om.Initialize(0, 0, 0);
break;
}
case 2: { // ListDevices
ListDevices(out var _0, im.GetBuffer <byte>(0xA, 0));
om.Initialize(0, 0, 4);
om.SetData(8, _0);
break;
}
case 3: { // StartDetection
StartDetection(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 0);
break;
}
case 4: { // StopDetection
StopDetection(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 0);
break;
}
case 5: { // Mount
Mount(im.GetBytes(8, 0x8), im.GetData <uint>(16), im.GetData <uint>(20));
om.Initialize(0, 0, 0);
break;
}
case 6: { // Unmount
Unmount(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 0);
break;
}
case 7: { // OpenApplicationArea
OpenApplicationArea(im.GetBytes(8, 0x8), im.GetData <uint>(16));
om.Initialize(0, 0, 0);
break;
}
case 8: { // GetApplicationArea
GetApplicationArea(im.GetBytes(8, 0x8), out var _0, im.GetBuffer <byte>(0x6, 0));
om.Initialize(0, 0, 4);
om.SetData(8, _0);
break;
}
case 9: { // SetApplicationArea
SetApplicationArea(im.GetBytes(8, 0x8), im.GetBuffer <byte>(0x5, 0));
om.Initialize(0, 0, 0);
break;
}
case 10: { // Flush
Flush(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 0);
break;
}
case 11: { // Restore
Restore(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 0);
break;
}
case 12: { // CreateApplicationArea
CreateApplicationArea(im.GetBytes(8, 0x8), im.GetData <uint>(16), im.GetBuffer <byte>(0x5, 0));
om.Initialize(0, 0, 0);
break;
}
case 13: { // GetTagInfo
GetTagInfo(im.GetBytes(8, 0x8), im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 14: { // GetRegisterInfo
GetRegisterInfo(im.GetBytes(8, 0x8), im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 15: { // GetCommonInfo
GetCommonInfo(im.GetBytes(8, 0x8), im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 16: { // GetModelInfo
GetModelInfo(im.GetBytes(8, 0x8), im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 17: { // AttachActivateEvent
var ret = AttachActivateEvent(im.GetBytes(8, 0x8));
om.Initialize(0, 1, 0);
om.Copy(0, CreateHandle(ret, copy: true));
break;
}
case 18: { // AttachDeactivateEvent
var ret = AttachDeactivateEvent(im.GetBytes(8, 0x8));
om.Initialize(0, 1, 0);
om.Copy(0, CreateHandle(ret, copy: true));
break;
}
case 19: { // GetState
var ret = GetState();
om.Initialize(0, 0, 4);
om.SetData(8, ret);
break;
}
case 20: { // GetDeviceState
var ret = GetDeviceState(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 4);
om.SetData(8, ret);
break;
}
case 21: { // GetNpadId
var ret = GetNpadId(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 4);
om.SetData(8, ret);
break;
}
case 22: { // GetApplicationArea2
var ret = GetApplicationArea2(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 4);
om.SetData(8, ret);
break;
}
case 23: { // AttachAvailabilityChangeEvent
var ret = AttachAvailabilityChangeEvent();
om.Initialize(0, 1, 0);
om.Copy(0, CreateHandle(ret, copy: true));
break;
}
case 24: { // RecreateApplicationArea
RecreateApplicationArea(im.GetBytes(8, 0x8), im.GetData <uint>(16), im.GetBuffer <byte>(0x5, 0));
om.Initialize(0, 0, 0);
break;
}
case 100: { // Format
Format(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 0);
break;
}
case 101: { // GetAdminInfo
GetAdminInfo(im.GetBytes(8, 0x8), im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 102: { // GetRegisterInfo2
GetRegisterInfo2(im.GetBytes(8, 0x8), im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 103: { // SetRegisterInfo
SetRegisterInfo(im.GetBytes(8, 0x8), im.GetBuffer <byte>(0x19, 0));
om.Initialize(0, 0, 0);
break;
}
case 104: { // DeleteRegisterInfo
DeleteRegisterInfo(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 0);
break;
}
case 105: { // DeleteApplicationArea
DeleteApplicationArea(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 0);
break;
}
case 106: { // ExistsApplicationArea
var ret = ExistsApplicationArea(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 1);
om.SetData(8, ret);
break;
}
case 200: { // GetAll
GetAll(im.GetBytes(8, 0x8), im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 201: { // SetAll
SetAll(im.GetBytes(8, 0x8), im.GetBuffer <byte>(0x19, 0));
om.Initialize(0, 0, 0);
break;
}
case 202: { // FlushDebug
FlushDebug(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 0);
break;
}
case 203: { // BreakTag
BreakTag(im.GetBytes(8, 0x8), im.GetData <uint>(16));
om.Initialize(0, 0, 0);
break;
}
case 204: { // ReadBackupData
ReadBackupData(out var _0, im.GetBuffer <byte>(0x6, 0));
om.Initialize(0, 0, 4);
om.SetData(8, _0);
break;
}
case 205: { // WriteBackupData
WriteBackupData(im.GetBuffer <byte>(0x5, 0));
om.Initialize(0, 0, 0);
break;
}
case 206: { // WriteNtf
WriteNtf(im.GetBytes(8, 0x8), im.GetData <uint>(16), im.GetBuffer <byte>(0x5, 0));
om.Initialize(0, 0, 0);
break;
}
case 300: { // Unknown300
Unknown300(im.GetData <ulong>(8), im.GetData <ulong>(16), im.Pid, im.GetBuffer <byte>(0x5, 0));
om.Initialize(0, 0, 0);
break;
}
case 301: { // Unknown301
Unknown301();
om.Initialize(0, 0, 0);
break;
}
case 302: { // Unknown302
Unknown302(out var _0, im.GetBuffer <byte>(0xA, 0));
om.Initialize(0, 0, 4);
om.SetData(8, _0);
break;
}
case 303: { // Unknown303
Unknown303(im.GetBytes(8, 0x8), im.GetData <uint>(16));
om.Initialize(0, 0, 0);
break;
}
case 304: { // Unknown304
Unknown304(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 0);
break;
}
case 305: { // Unknown305
Unknown305(im.GetBytes(8, 0x8), im.GetData <ulong>(16), im.GetBuffer <byte>(0x5, 0), out var _0, im.GetBuffer <byte>(0x6, 0));
om.Initialize(0, 0, 4);
om.SetData(8, _0);
break;
}
case 306: { // Unknown306
Unknown306(im.GetBytes(8, 0x8), im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 307: { // Unknown307
var ret = Unknown307(im.GetBytes(8, 0x8));
om.Initialize(0, 1, 0);
om.Copy(0, CreateHandle(ret, copy: true));
break;
}
case 308: { // Unknown308
var ret = Unknown308(im.GetBytes(8, 0x8));
om.Initialize(0, 1, 0);
om.Copy(0, CreateHandle(ret, copy: true));
break;
}
case 309: { // Unknown309
var ret = Unknown309();
om.Initialize(0, 0, 4);
om.SetData(8, ret);
break;
}
case 310: { // Unknown310
var ret = Unknown310(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 4);
om.SetData(8, ret);
break;
}
case 311: { // Unknown311
var ret = Unknown311(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 4);
om.SetData(8, ret);
break;
}
case 312: { // Unknown312
Unknown312(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 0);
break;
}
case 313: { // Unknown313
Unknown313(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 0);
break;
}
case 314: { // Unknown314
var ret = Unknown314();
om.Initialize(0, 1, 0);
om.Copy(0, CreateHandle(ret, copy: true));
break;
}
default:
throw new NotImplementedException($"Unhandled command ID to IDebug: {im.CommandId}");
}
}
public override void _Dispatch(IncomingMessage im, OutgoingMessage om)
{
switch (im.CommandId)
{
case 0: { // Initialize
Initialize(im.GetData <ulong>(8), im.GetData <ulong>(16), im.Pid, im.GetBuffer <byte>(0x5, 0));
om.Initialize(0, 0, 0);
break;
}
case 1: { // Finalize
Finalize();
om.Initialize(0, 0, 0);
break;
}
case 2: { // ListDevices
ListDevices(out var _0, im.GetBuffer <byte>(0xA, 0));
om.Initialize(0, 0, 4);
om.SetData(8, _0);
break;
}
case 3: { // StartDetection
StartDetection(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 0);
break;
}
case 4: { // StopDetection
StopDetection(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 0);
break;
}
case 5: { // Mount
Mount(im.GetBytes(8, 0x8), im.GetData <uint>(16), im.GetData <uint>(20));
om.Initialize(0, 0, 0);
break;
}
case 6: { // Unmount
Unmount(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 0);
break;
}
case 7: { // OpenApplicationArea
OpenApplicationArea(im.GetBytes(8, 0x8), im.GetData <uint>(16));
om.Initialize(0, 0, 0);
break;
}
case 8: { // GetApplicationArea
GetApplicationArea(im.GetBytes(8, 0x8), out var _0, im.GetBuffer <byte>(0x6, 0));
om.Initialize(0, 0, 4);
om.SetData(8, _0);
break;
}
case 9: { // SetApplicationArea
SetApplicationArea(im.GetBytes(8, 0x8), im.GetBuffer <byte>(0x5, 0));
om.Initialize(0, 0, 0);
break;
}
case 10: { // Flush
Flush(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 0);
break;
}
case 11: { // Restore
Restore(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 0);
break;
}
case 12: { // CreateApplicationArea
CreateApplicationArea(im.GetBytes(8, 0x8), im.GetData <uint>(16), im.GetBuffer <byte>(0x5, 0));
om.Initialize(0, 0, 0);
break;
}
case 13: { // GetTagInfo
GetTagInfo(im.GetBytes(8, 0x8), im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 14: { // GetRegisterInfo
GetRegisterInfo(im.GetBytes(8, 0x8), im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 15: { // GetCommonInfo
GetCommonInfo(im.GetBytes(8, 0x8), im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 16: { // GetModelInfo
GetModelInfo(im.GetBytes(8, 0x8), im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 17: { // AttachActivateEvent
var ret = AttachActivateEvent(im.GetBytes(8, 0x8));
om.Initialize(0, 1, 0);
om.Copy(0, CreateHandle(ret, copy: true));
break;
}
case 18: { // AttachDeactivateEvent
var ret = AttachDeactivateEvent(im.GetBytes(8, 0x8));
om.Initialize(0, 1, 0);
om.Copy(0, CreateHandle(ret, copy: true));
break;
}
case 19: { // GetState
var ret = GetState();
om.Initialize(0, 0, 4);
om.SetData(8, ret);
break;
}
case 20: { // GetDeviceState
var ret = GetDeviceState(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 4);
om.SetData(8, ret);
break;
}
case 21: { // GetNpadId
var ret = GetNpadId(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 4);
om.SetData(8, ret);
break;
}
case 22: { // GetApplicationArea2
var ret = GetApplicationArea2(im.GetBytes(8, 0x8));
om.Initialize(0, 0, 4);
om.SetData(8, ret);
break;
}
case 23: { // AttachAvailabilityChangeEvent
var ret = AttachAvailabilityChangeEvent();
om.Initialize(0, 1, 0);
om.Copy(0, CreateHandle(ret, copy: true));
break;
}
case 24: { // RecreateApplicationArea
RecreateApplicationArea(im.GetBytes(8, 0x8), im.GetData <uint>(16), im.GetBuffer <byte>(0x5, 0));
om.Initialize(0, 0, 0);
break;
}
default:
throw new NotImplementedException($"Unhandled command ID to IUser: {im.CommandId}");
}
}
public StateChange(OutgoingMessage message)
{
ChangeMessage = message;
}
/// <summary>Posts a message to the user’s Ping.fm services.</summary>
public PingResponse Post(OutgoingMessage message)
{
string url = "http://api.ping.fm/v1/user.post";
string postdata = "api_key={0}&user_app_key={1}";
string method = message.Method;
EncodeDelegate encoder = UrlEncode;
postdata = string.Format(postdata, api_key, user_application_key, method);
if (message.Encoding == PingEncoding.Base64)
{
postdata += "&encoding=base64";
encoder = Base64Encode;
}
if (string.IsNullOrEmpty(message.Trigger))
{
if (string.IsNullOrEmpty(method))
{
method = "default";
}
postdata += "&post_method=" + UrlEncode(method);
}
else
{
url = "http://api.ping.fm/v1/user.tpost";
postdata += "&trigger=" + UrlEncode(message.Trigger);
}
if (!string.IsNullOrEmpty(message.Title))
{
postdata += "&title=" + encoder(message.Title);
}
if (!string.IsNullOrEmpty(message.Body))
{
postdata += "&body=" + encoder(message.Body);
}
if (!string.IsNullOrEmpty(message.Service))
{
postdata += "&service=" + UrlEncode(message.Service);
}
if (!string.IsNullOrEmpty(message.Exclude))
{
postdata += "&exclude=" + UrlEncode(message.Exclude);
}
if (!string.IsNullOrEmpty(message.Location))
{
postdata += "&location=" + encoder(message.Location);
}
if (!string.IsNullOrEmpty(message.Tags))
{
postdata += "&tags=" + encoder(message.Tags);
}
if (!string.IsNullOrEmpty(message.Mood))
{
postdata += "&mood=" + encoder(message.Mood);
}
if (message.Debug)
{
postdata += "&debug=1";
}
if (message.MediaFilenames != null)
{
foreach (string s in message.MediaFilenames)
{
postdata += "&media=" + Base64Encode(GetMediaContent(s));
}
}
string response = GetWebResponse(url, postdata);
XmlReader xr = XmlReader.Create(new System.IO.StringReader(response));
PingResponse r = (PingResponse)DeserializeObject(xr, typeof(PingResponse));
xr.Close();
mLastResponse = r;
return(r);
}
public override void _Dispatch(IncomingMessage im, OutgoingMessage om)
{
switch (im.CommandId)
{
case 0: { // GetClientProfile
GetClientProfile(im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 10: { // CreateLoginSession
var ret = CreateLoginSession();
om.Initialize(0, 0, 0);
break;
}
case 11: { // GetNetworkServiceAccountId
var ret = GetNetworkServiceAccountId();
om.Initialize(0, 0, 0);
break;
}
case 12: { // GetUserNickname
var ret = GetUserNickname();
om.Initialize(0, 0, 0);
break;
}
case 13: { // GetUserProfileImage
GetUserProfileImage(out var _0, im.GetBuffer <byte>(0x6, 0));
om.Initialize(0, 0, 0);
break;
}
case 100: { // PrepareAsync
var ret = PrepareAsync();
om.Initialize(1, 0, 0);
om.Move(0, CreateHandle(ret));
break;
}
case 101: { // GetConnectionRequirement
var ret = GetConnectionRequirement();
om.Initialize(0, 0, 0);
break;
}
case 200: { // ScanServersAsync
var ret = ScanServersAsync();
om.Initialize(1, 0, 0);
om.Move(0, CreateHandle(ret));
break;
}
case 201: { // ListServers
ListServers(out var _0, im.GetBuffer <byte>(0x6, 0));
om.Initialize(0, 0, 0);
break;
}
case 210: { // ConnectByServerIdAsync
var ret = ConnectByServerIdAsync(null);
om.Initialize(1, 0, 0);
om.Move(0, CreateHandle(ret));
break;
}
case 300: { // GetStorageShortfall
var ret = GetStorageShortfall();
om.Initialize(0, 0, 0);
break;
}
case 301: { // GetTotalTransferInfo
var ret = GetTotalTransferInfo();
om.Initialize(0, 0, 0);
break;
}
case 302: { // GetImmigrantUid
var ret = GetImmigrantUid();
om.Initialize(0, 0, 0);
break;
}
case 310: { // GetCurrentTransferInfo
var ret = GetCurrentTransferInfo();
om.Initialize(0, 0, 0);
break;
}
case 311: { // GetCurrentRelatedApplications
GetCurrentRelatedApplications(out var _0, im.GetBuffer <byte>(0x6, 0));
om.Initialize(0, 0, 0);
break;
}
case 320: { // TransferNextAsync
var ret = TransferNextAsync();
om.Initialize(1, 0, 0);
om.Move(0, CreateHandle(ret));
break;
}
case 350: { // SuspendAsync
var ret = SuspendAsync();
om.Initialize(1, 0, 0);
om.Move(0, CreateHandle(ret));
break;
}
case 400: { // CompleteAsync
var ret = CompleteAsync();
om.Initialize(1, 0, 0);
om.Move(0, CreateHandle(ret));
break;
}
case 500: { // Abort
Abort();
om.Initialize(0, 0, 0);
break;
}
case 999: { // DebugSynchronizeStateInFinalizationAsync
var ret = DebugSynchronizeStateInFinalizationAsync();
om.Initialize(1, 0, 0);
om.Move(0, CreateHandle(ret));
break;
}
default:
throw new NotImplementedException($"Unhandled command ID to IClient: {im.CommandId}");
}
}
/// <summary>Send a message to a remote peer.</summary>
/// <param name="peerID">The unique Galaxy ID, derived from <see cref="GalaxyID.ToUint64"/>.</param>
/// <param name="message">The message to send.</param>
private void SendMessageToPeerID(ulong peerID, OutgoingMessage message)
{
this.sendMessage(new GalaxyID(peerID), message);
}
public override void _Dispatch(IncomingMessage im, OutgoingMessage om)
{
switch (im.CommandId)
{
case 0: { // GetUid
var ret = GetUid();
om.Initialize(0, 0, 0);
break;
}
case 1: { // GetServerProfile
GetServerProfile(im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 100: { // PrepareAsync
var ret = PrepareAsync();
om.Initialize(1, 0, 0);
om.Move(0, CreateHandle(ret));
break;
}
case 101: { // GetConnectionRequirement
var ret = GetConnectionRequirement();
om.Initialize(0, 0, 0);
break;
}
case 200: { // WaitConnectionAsync
var ret = WaitConnectionAsync();
om.Initialize(1, 0, 0);
om.Move(0, CreateHandle(ret));
break;
}
case 201: { // GetClientProfile
GetClientProfile(im.GetBuffer <byte>(0x1A, 0));
om.Initialize(0, 0, 0);
break;
}
case 202: { // AcceptConnectionAsync
var ret = AcceptConnectionAsync();
om.Initialize(1, 0, 0);
om.Move(0, CreateHandle(ret));
break;
}
case 203: { // DeclineConnectionAsync
var ret = DeclineConnectionAsync();
om.Initialize(1, 0, 0);
om.Move(0, CreateHandle(ret));
break;
}
case 300: { // ProcessTransferAsync
var ret = ProcessTransferAsync();
om.Initialize(1, 0, 0);
om.Move(0, CreateHandle(ret));
break;
}
case 400: { // CompleteAsync
var ret = CompleteAsync();
om.Initialize(1, 0, 0);
om.Move(0, CreateHandle(ret));
break;
}
case 500: { // Abort
Abort();
om.Initialize(0, 0, 0);
break;
}
default:
throw new NotImplementedException($"Unhandled command ID to IServer: {im.CommandId}");
}
}
/// <summary> /// Writes the synchronize data. /// </summary> /// <param name="writer">The writer.</param> public abstract void WriteSyncData(OutgoingMessage writer);
public override Task Produce(OutgoingMessage outgoingMessage)
{
LastMessage = outgoingMessage;
return(Task.CompletedTask);
}
/// <summary>
/// Sends an outgoing message
/// </summary>
/// <param name="logger"></param>
/// <param name="outgoingMessage">Information about the message to send</param>
/// <param name="queueType">The type of queue that should be used</param>
/// <param name="replyTo">An optional ReplyTo queue that should be used. Only relevant in synchronous messaging</param>
/// <param name="correlationId">The correlation id to use when sending the message. Only relevant in synchronous messaging</param>
/// <returns></returns>
internal async Task Send(ILogger logger, OutgoingMessage outgoingMessage, QueueType queueType, string replyTo = null, string correlationId = null)
{
logger.LogDebug($"Start-ServiceBusCore::Send QueueType: {queueType} replyTo: {replyTo} correlationId: {correlationId}");
if (outgoingMessage == null)
{
throw new ArgumentNullException(nameof(outgoingMessage));
}
if (string.IsNullOrEmpty(outgoingMessage.MessageId))
{
throw new ArgumentNullException(nameof(outgoingMessage.MessageId));
}
if (outgoingMessage.Payload == null)
{
throw new ArgumentNullException(nameof(outgoingMessage.Payload));
}
var hasAgreement = true;
// first we try and find an agreement
var profile = await CollaborationProtocolRegistry.FindAgreementForCounterpartyAsync(logger, outgoingMessage.ToHerId).ConfigureAwait(false);
if (profile == null)
{
hasAgreement = false; // if we don't have an agreement, we try to find the specific profile
profile = await CollaborationProtocolRegistry.FindProtocolForCounterpartyAsync(logger, outgoingMessage.ToHerId).ConfigureAwait(false);
}
logger.LogDebug($"ServiceBusCore::Send - Start retrieving and valiating certificates - correlationId: {correlationId}");
var signature = Settings.SigningCertificate.Certificate;
var encryption = profile.EncryptionCertificate;
var validator = Core.DefaultCertificateValidator;
var encryptionStatus = validator.Validate(encryption, X509KeyUsageFlags.DataEncipherment);
var signatureStatus = validator.Validate(signature, X509KeyUsageFlags.NonRepudiation);
// this is the other parties certificate that may be out of date, not something we can fix
if (encryptionStatus != CertificateErrors.None)
{
if (Core.Settings.IgnoreCertificateErrorOnSend)
{
logger.LogError(EventIds.RemoteCertificate, "Remote encryption certificate is not valid");
}
else
{
throw new MessagingException("Remote encryption certificate is not valid")
{
EventId = EventIds.RemoteCertificate
};
}
}
// this is our certificate, something we can fix
if (signatureStatus != CertificateErrors.None)
{
if (Core.Settings.IgnoreCertificateErrorOnSend)
{
logger.LogError(EventIds.LocalCertificate, "Locally installed signing certificate is not valid");
}
else
{
throw new MessagingException("Locally installed signing certificate is not valid")
{
EventId = EventIds.LocalCertificate
};
}
}
logger.LogDebug($"ServiceBusCore::Send - End retrieving and valiating certificates - correlationId: {correlationId}");
logger.LogDebug($"ServiceBusCore::Send - Start encrypting message - correlationId: {correlationId}");
var protection = Core.DefaultMessageProtection;
var stream = protection.Protect(outgoingMessage.Payload, encryption, signature);
logger.LogDebug($"ServiceBusCore::Send - End encrypting message - correlationId: {correlationId}");
logger.LogDebug($"ServiceBusCore::Send - Start Create and Initialize message - correlationId: {correlationId}");
var messagingMessage = FactoryPool.CreateMessage(logger, stream, outgoingMessage);
if (queueType != QueueType.SynchronousReply)
{
messagingMessage.ReplyTo =
replyTo ?? await ConstructQueueName(logger, Core.Settings.MyHerId, queueType).ConfigureAwait(false);
}
messagingMessage.ContentType = protection.ContentType;
messagingMessage.MessageId = outgoingMessage.MessageId;
// when we are replying to a synchronous message, we need to use the replyto of the original message
messagingMessage.To =
(queueType == QueueType.SynchronousReply) ?
replyTo :
await ConstructQueueName(logger, outgoingMessage.ToHerId, queueType).ConfigureAwait(false);
messagingMessage.MessageFunction = outgoingMessage.MessageFunction;
messagingMessage.CorrelationId = correlationId ?? outgoingMessage.MessageId;
messagingMessage.TimeToLive = (queueType == QueueType.Asynchronous)
? Settings.Asynchronous.TimeToLive
: Settings.Synchronous.TimeToLive;
messagingMessage.ScheduledEnqueueTimeUtc = outgoingMessage.ScheduledSendTimeUtc;
messagingMessage.FromHerId = Core.Settings.MyHerId;
messagingMessage.ToHerId = outgoingMessage.ToHerId;
messagingMessage.ApplicationTimestamp = DateTime.Now;
if (hasAgreement)
{
messagingMessage.CpaId = profile.CpaId.ToString("D");
}
logger.LogDebug($"ServiceBusCore::Send - End Create and Initialize message - correlationId: {correlationId}");
await Send(logger, messagingMessage, queueType, outgoingMessage.PersonalId, (LogPayload)?outgoingMessage.Payload : null).ConfigureAwait(false);
logger.LogDebug($"End-ServiceBusCore::Send QueueType: {queueType} replyTo: {replyTo} correlationId: {correlationId}");
}
public void Publish(IModel channel, Type type, OutgoingMessage message, IBasicProperties properties)
{
}
/// <summary>Send a message to the connected peer.</summary>
public override void sendMessage(OutgoingMessage message)
{
this.OnSendingMessage(message, base.sendMessage, () => base.sendMessage(message));
}
/// <summary>
/// Sends the specified to send message.
/// </summary>
/// <param name="toSendMessage">To send message.</param>
/// <param name="deliveryMethod">The delivery method.</param>
public void Send(OutgoingMessage toSendMessage, DeliveryMethod deliveryMethod)
{
this.client.SendMessage(toSendMessage.Message, (NetDeliveryMethod)deliveryMethod);
}
public void Publish(IModel channel, Type type, OutgoingMessage message, IBasicProperties properties)
{
channel.BasicPublish(exchangeNameConvention(), GetRoutingKeyForPublish(type), false, properties, message.Body);
}
public void Publish(IModel channel, Type type, OutgoingMessage message, IBasicProperties properties)
{
SetupTypeSubscriptions(channel, type);
channel.BasicPublish(ExchangeName(type), String.Empty, false, properties, message.Body);
}
internal void ProcessEndToEnd(SmtpAgent agent, Message msg, out OutgoingMessage outgoing, out IncomingMessage incoming)
{
outgoing = agent.SecurityAgent.ProcessOutgoing(new MessageEnvelope(msg));
incoming = agent.SecurityAgent.ProcessIncoming(new MessageEnvelope(outgoing.SerializeMessage()));
}
public void Send(IModel channel, string address, OutgoingMessage message, IBasicProperties properties)
{
}
public Task Send(OutgoingMessage message, TimeSpan timeToBeReceived, SqlConnection connection, SqlTransaction transaction, CancellationToken cancellationToken = default)
{
var messageRow = MessageRow.From(message.Headers, message.Body, timeToBeReceived);
return(SendRawMessage(messageRow, connection, transaction, cancellationToken));
}
public IMessagingMessage CreteMessage(Stream stream, OutgoingMessage outgoingMessage)
{
return(new MockMessage(stream));
}
