private bool IsPacketAllowed(IMessageReader message, bool hostOnly)
{
if (Player == null)
{
return(false);
}
Game?game = Player.Game;
// GameCode must match code of the current game assigned to the player.
if (message.ReadInt32() != game.Code)
{
return(false);
}
// Some packets should only be sent by the host of the game.
if (hostOnly)
{
if (game.HostId == Id)
{
return(true);
}
_logger.LogWarning("[{0}] Client sent packet only allowed by the host ({1}).", Id, game.HostId);
return(false);
}
return(true);
}
public Vector3 ReadByteAngles(IMessageReader reader)
{
float angleX = AngleByteToFloat(reader.ReadByte());
float angleY = (reader.ReadByte());
return new Vector3(angleX, angleY, 0);
}
/// <summary>
/// Create messageReader accroding to file extension
/// </summary>
/// <param name="CaptureFile">Capture file path</param>
/// <returns></returns>
IMessageReader CreateMessageReader(string CaptureFile)
{
IMessageReader reader = null;
//Create and Initialize Message Meta data loader catalog
MessageMetadataLoaderCatalog messageMetadataLoaderCatalog = new MessageMetadataLoaderCatalog();
messageMetadataLoaderCatalog.Initialize(monitor.Settings.ExtensionLoadPath);
if (PersistUtils.IsUnparsedProjectFile(CaptureFile))
{
//If capture file is an uncompressed project file
reader = FileMessageReader.CreateReaderFromProjectFile(CaptureFile, messageMetadataLoaderCatalog);
}
else if (PersistUtils.IsCompressedUnparsedProjectFile(CaptureFile) || PersistUtils.IsCompressedProjectFile(CaptureFile))
{
//If capture file is a compressed project file
reader = FileMessageReader.CreateReaderFromCompressedFile(CaptureFile, messageMetadataLoaderCatalog);
}
else
{
//other file type, such as netmon capture file
FileReaderCatalog fileReaderCatalog = new FileReaderCatalog();
fileReaderCatalog.Initialize(monitor.Settings.ExtensionLoadPath);
IFileLoader fileLoader = fileReaderCatalog.GetRegisteredFileLoaders(CaptureFile).First();
reader = fileLoader.OpenFile(CaptureFile, fileLoader.CreateDefaultConfig(null));
}
return(reader);
}
public IPart Parse(IMessageReader reader, ContentType contentType, ContentDisposition contentDisposition, EContentTransferEncoding contentTransferEncoding, string boundary, string uid, string attachmentDirectory)
{
BoundedMessageReader reader2;
MessagePart part = new MessagePart();
if (contentTransferEncoding == EContentTransferEncoding.Base64)
{
reader2 = new Base64MessageReader(reader, boundary);
}
else if (contentTransferEncoding == EContentTransferEncoding.QuotedPrintable)
{
reader2 = new QuotedPrintableMessageReader(reader, boundary);
}
else
{
reader2 = new UnencodedMessageReader(reader, boundary);
}
PopMessage message = new MailMessageParser().Parse(reader2, uid, attachmentDirectory);
part.Message = message;
if (reader2.FinalBoundaryReached)
{
this.RaiseFinalBoundaryReached();
}
return(part);
}
internal Message(string eventName, byte[] body, IBasicProperties basicProperties)
{
this.Body = body;
this.BasicProperties = basicProperties;
this.messageReader = null;
this.EventName = eventName;
}
public StoreMessages(IMessageReader messageReader, IMessageSender messageSender, ICosmosDbClient cosmosClient, IHealthTester healthTester)
{
_messageReader = messageReader;
_messageSender = messageSender;
_cosmosClient = cosmosClient;
_healthTester = healthTester;
}
public static void Deserialize(IMessageReader reader, out uint netId, out string id, out string version, out PluginSide side)
{
netId = reader.ReadPackedUInt32();
id = reader.ReadString();
version = reader.ReadString();
side = (PluginSide)reader.ReadByte();
}
public virtual void ParseUnencoded(IMessageReader reader, ContentType contentType, ContentDisposition contentDisposition, string boundary)
{
byte[] buffer;
bool flag = false;
byte[] data = new byte[] { 13, 10 };
Label_0019:
buffer = reader.ReadLine();
if (!reader.EndOfMessage)
{
switch (BoundaryChecker.CheckBoundary(buffer, boundary))
{
case EBoundaryType.NotBoundary:
if (flag)
{
this.ContentWriter.Write(data);
}
this.ContentWriter.Write(buffer);
flag = true;
goto Label_0019;
case EBoundaryType.Final:
this.RaiseFinalBoundaryReached();
break;
}
}
}
private static void HandleToServer(string source, IMessageReader packet)
{
var tagName = TagMap.ContainsKey(packet.Tag) ? TagMap[packet.Tag] : "Unknown";
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine($"{source,-15} Server received: {packet.Tag,-2} {tagName}");
switch (packet.Tag)
{
case 0:
Console.WriteLine("- GameInfo length " + packet.ReadBytesAndSize().Length);
break;
case 1:
Console.WriteLine("- GameCode " + packet.ReadInt32());
Console.WriteLine("- Unknown " + packet.ReadByte());
break;
case 5:
case 6:
Console.WriteLine("- GameCode " + packet.ReadInt32());
Console.WriteLine(HexUtils.HexDump(packet.Buffer.ToArray().Take(packet.Length).ToArray()));
// packet.Position = packet.Length;
break;
}
}
protected override byte PacketProperty => 0x08; // LiteNetLib.PacketProperty.UnconnectedMessage
public MasterServerMessageSource(
MessagingConfiguration configuration,
IMessageReader messageReader,
IEncryptedMessageReader encryptedMessageReader)
: base(configuration, messageReader, encryptedMessageReader)
{
}
public FrmTip(IMessageReader IReader)
{
InitializeComponent();
reader = IReader;
TrasenClasses.GeneralControls.ListViewEx lstMessage = new TrasenClasses.GeneralControls.ListViewEx();
lstMessage.View = View.Details;
lstMessage.Dock = DockStyle.Fill;
lstMessage.FullRowSelect = true;
lstMessage.HideSelection = false;
this.plContent.Controls.Add(lstMessage);
if (reader is LISMessageReader)
{
lstMessage.Columns.Add("验单号");
lstMessage.Columns.Add("内容");
lstMessage.Columns.Add("状态");
lstMessage.Columns[0].Width = 0;
lstMessage.Columns[1].Width = 300;
foreach (MessageStruct message in reader.Messages)
{
ListViewItem item = new ListViewItem();
item.Text = message.KeyFieldValue.ToString();
item.SubItems.Add(message.Content);
item.SubItems.Add(message.IsRead ? "已阅" : "未读");
item.Tag = message;
lstMessage.Items.Add(item);
}
}
lstMessage.DoubleClick += new EventHandler(lstMessage_DoubleClick);
}
public static void Deserialize(IMessageReader reader, out int announcementVersion, out int id, out Language language)
{
reader.ReadByte(); // SendOption header, probably added by accident
announcementVersion = reader.ReadPackedInt32();
id = reader.ReadPackedInt32();
language = (Language)reader.ReadPackedInt32();
}
public QueueMonitor(IMessageReader reader, IMessageConverter converter, MessageValidator validator, IValidationOutput output)
{
_reader = reader;
_converter = converter;
_validator = validator;
_output = output;
}
private static void WritePacket(PacketSerializationContext context, IMessageReader reader, MessageType messageType)
{
context.Writer.Write((byte)messageType);
context.Writer.Write((byte)reader.Tag);
context.Writer.Write((int)reader.Length);
context.Writer.Write(reader.Buffer, reader.Offset, reader.Length);
}
private SlotMachineEngine()
{
this.symbolFactory = new SymbolFactory();
this.messageWriter = new ConsoleMessageWriter();
this.messageReader = new ConsoleMessageReader();
this.player = new Player();
}
/// <summary>
/// Reads the equipment data from a message reader
/// </summary>
/// <param name="reader"></param>
protected override void readData(IMessageReader reader)
{
int numArmorSlots = reader.ReadInt();
for (int i = 0; i < numArmorSlots; i++)
{
ArmorType type = (ArmorType)reader.ReadByte();
string frameId = reader.ReadString();
Frame frame = Frame.FindFrameById(frameId);
if (frame != null)
{
StartCoroutine(equipAmorDeferred(frame));
}
}
int numCombatItemSlots = reader.ReadInt();
for (int i = 0; i < numCombatItemSlots; i++)
{
int index = reader.ReadInt();
Frame frame = Frame.FindFrameById(reader.ReadString());
if (frame != null)
{
StartCoroutine(equipCombatItemDeferred(index, frame));
}
}
}
public ValueTask HandleMessageAsync(IClient client, IMessageReader reader, MessageType messageType)
{
var clientInfo = client.GetReactor();
if (clientInfo == null)
{
return(default);
public void MessageHandlerFactoryCreatorWriteTestMethod()
{
IMessageHandlerFactory _nmf = new MyMessageHandlerFactory(Guid.NewGuid());
Assert.IsNotNull(_nmf);
IMessageReader _nmr = _nmf.GetIMessageReader("UDP", null, null);
}
private static Vector2 ReadVector2(IMessageReader reader)
{
var v1 = reader.ReadUInt16() / (float)ushort.MaxValue;
var v2 = reader.ReadUInt16() / (float)ushort.MaxValue;
return(new Vector2(XRange.Lerp(v1), YRange.Lerp(v2)));
}
/// <summary>
/// Initialises a new instance of the <see cref="RecordingMessageReader"/> class and
/// specified the inner message reader, the output stream and a value indicating if the
/// decorator owns the output.
/// </summary>
/// <param name="inner">The inner message reader.</param>
/// <param name="output">The output stream.</param>
/// <param name="ownsOutput"><see langword="true"/> if the decorator owns the specified output
/// stream, otherwise; <see langword="false"/>.</param>
/// <exception cref="System.ArgumentNullException">
/// Thrown when <paramref name="inner"/> or <paramref name="output"/> is
/// <see langword="null"/>.
/// </exception>
public RecordingMessageReader(IMessageReader inner, Stream output, bool ownsOutput)
{
Guard.NotNull(inner, "inner");
Guard.NotNull(output, "output");
Initialise(inner, output, ownsOutput);
}
/// <summary>
/// Deserialize a packet/message to a new GameOptionsData object.
/// </summary>
/// <param name="reader">Message reader object containing the raw message.</param>
/// <returns>GameOptionsData object.</returns>
public static GameOptionsData DeserializeCreate(IMessageReader reader)
{
var options = new GameOptionsData();
options.Deserialize(reader.ReadBytesAndSize());
return(options);
}
public static void TestReadMessages(IMessageReader messageReader)
{
IMessageReader _messageReader = messageReader;
_messageReader.ReadMessage();
XmlDocument messageXML = new XmlDocument();
messageXML.Load(@"C:\Temp\RequestMessage_1423572802_File187E1E8A7F16147A6B87962E07933B406_acknowledgement_20150210125836_.xml");
string[] results = _messageReader.GetMessageResults <string[]>();
foreach (var s in results)
{
Console.WriteLine(s);
}
// GovTalkMessage message = _messageReader.Message(messageXML.ToXDocument());
string bodytype = _messageReader.GetBodyType();
Console.WriteLine(bodytype);
ErrorResponse err = _messageReader.GetBody <ErrorResponse>();
}
public static void Deserialize(IMessageReader reader, out int gameCode, out byte unknown)
{
var slice = reader.ReadBytes(sizeof(Int32) + sizeof(byte)).Span;
gameCode = slice.ReadInt32();
unknown = slice.ReadByte();
}
public static void Deserialize(IMessageReader reader, out AlterGameTags gameTag, out bool isPublic)
{
var slice = reader.ReadBytes(sizeof(byte) + sizeof(byte)).Span;
gameTag = (AlterGameTags)slice.ReadByte();
isPublic = slice.ReadBoolean();
}
public void Deserialize(IMessageReader reader)
{
PlayerName = reader.ReadString();
Color = (ColorType)reader.ReadPackedInt32();
Hat = (HatType)reader.ReadPackedUInt32();
Pet = (PetType)reader.ReadPackedUInt32();
Skin = (SkinType)reader.ReadPackedUInt32();
var flag = reader.ReadByte();
Disconnected = (flag & 1) > 0;
IsImpostor = (flag & 2) > 0;
IsDead = (flag & 4) > 0;
var taskCount = reader.ReadByte();
if (Tasks.Count != taskCount)
{
Tasks = new List <InnerGameData.TaskInfo>(taskCount);
}
for (var i = 0; i < taskCount; i++)
{
Tasks[i] ??= new InnerGameData.TaskInfo();
Tasks[i].Deserialize(reader);
}
}
public Enumerator(Session session, MessageQueue messageQueue,
IMessageReader reader)
{
this.session = session;
this.innerEnumerator = messageQueue.GetMessageEnumerator2();
this.reader = reader;
}
/// <summary>
/// Deserialize a packet.
/// </summary>
/// <param name="reader"><see cref="IMessageReader" /> with <see cref="IMessageReader.Tag" /> 0.</param>
/// <param name="chatMode">The chat type selected in the client of the player.</param>
/// <returns>Deserialized <see cref="GameOptionsData" />.</returns>
public static GameOptionsData Deserialize(IMessageReader reader, out QuickChatModes chatMode)
{
var gameOptionsData = GameOptionsData.DeserializeCreate(reader);
chatMode = (QuickChatModes)reader.ReadByte();
return(gameOptionsData);
}
/// <summary>
/// Deserialize a packet.
/// </summary>
/// <param name="reader"><see cref="IMessageReader" /> with <see cref="IMessageReader.Tag" /> 0.</param>
/// <param name="chatType">The chat type selected in the client of the player.</param>
/// <returns>Deserialized <see cref="GameOptionsData" />.</returns>
public static GameOptionsData Deserialize(IMessageReader reader, out ChatType chatType)
{
var gameOptionsData = GameOptionsData.DeserializeCreate(reader);
chatType = (ChatType)reader.ReadByte();
return(gameOptionsData);
}
/// <summary>Initializes a new instance of the <see cref="TextMessageProvider"/> class.</summary>
/// <param name="name">The name.</param>
/// <param name="path">The path.</param>
/// <param name="format">The message format.</param>
public TextMessageProvider(string name, string path, MessageFormat format)
{
Name = name;
Path = path;
MessageFormat messageFormat = format;
IMessageParser messageParser = messageFormat == MessageFormat.Motorola ? (IMessageParser) new MotorolaTextMessageParser() : new NokiaTextMessageParser();
textMessageReader = new TextMessageReader { MessageParser = messageParser };
}
public Controller(IMessageReader messageReader, SCG.IEnumerable <IMessageWriter> messageWriters, IOrderBookWriter orderBookWriter, ILogger logger)
{
_messageReader = messageReader;
_messageWriters = messageWriters;
_orderBookWriter = orderBookWriter;
_logger = logger;
_orderPool = new OrderPool(logger);
}
internal void RemoveMessageReader(IMessageReader messageReader)
{
if (messageReader == null)
{
throw new ArgumentNullException("messageReader");
}
messageReader.ReadMessageCompleted -= MessageHandler;
}
public Vector3 ReadVector3(IMessageReader reader)
{
float x = reader.ReadFloat();
float y = reader.ReadFloat();
float z = reader.ReadFloat();
return new Vector3(x, y, z);
}
/// <summary>
/// Handles the receiving of data.
/// </summary>
/// <param name="message">The buffer containing the bytes received.</param>
internal virtual async ValueTask HandleReceive(MessageReader message, int bytesReceived)
{
// Check if the first message received is the hello packet.
if (_isFirst)
{
_isFirst = false;
// Slice 4 bytes to get handshake data.
if (_listener != null)
{
using (IMessageReader handshake = message.Copy(4))
{
await _listener.InvokeNewConnection(handshake, this);
}
}
}
switch (message.Buffer[0])
{
//Handle reliable receives
case (byte)MessageType.Reliable:
await ReliableMessageReceive(message, bytesReceived);
break;
//Handle acknowledgments
case (byte)UdpSendOption.Acknowledgement:
AcknowledgementMessageReceive(message.Buffer, bytesReceived);
break;
//We need to acknowledge hello and ping messages but dont want to invoke any events!
case (byte)UdpSendOption.Ping:
await ProcessReliableReceive(message.Buffer, 1);
Statistics.LogHelloReceive(bytesReceived);
break;
case (byte)UdpSendOption.Hello:
await ProcessReliableReceive(message.Buffer, 1);
Statistics.LogHelloReceive(bytesReceived);
break;
case (byte)UdpSendOption.Disconnect:
message.Offset = 1;
message.Position = 0;
await DisconnectRemote("The remote sent a disconnect request", message);
break;
//Treat everything else as unreliable
default:
await InvokeDataReceived(MessageType.Unreliable, message, 1, bytesReceived);
Statistics.LogUnreliableReceive(bytesReceived - 1, bytesReceived);
break;
}
}
public override async ValueTask HandleMessageAsync(IMessageReader reader, MessageType messageType)
{
var flag = reader.Tag;
Logger.Verbose("Server got {0}.", flag);
switch (flag)
{
case MessageFlags.HostGame:
{
using var packet = MessageWriter.Get(MessageType.Reliable);
Message13RedirectS2C.Serialize(packet, false, _nodeProvider.Get());
await Connection.SendAsync(packet);
break;
}
case MessageFlags.JoinGame:
{
Message01JoinGameC2S.Deserialize(
reader,
out var gameCode,
out _);
using var packet = MessageWriter.Get(MessageType.Reliable);
var endpoint = await _nodeLocator.FindAsync(GameCodeParser.IntToGameName(gameCode));
if (endpoint == null)
{
Message01JoinGameS2C.SerializeError(packet, false, DisconnectReason.GameMissing);
}
else
{
Message13RedirectS2C.Serialize(packet, false, endpoint);
}
await Connection.SendAsync(packet);
break;
}
case MessageFlags.GetGameListV2:
{
// TODO: Implement.
using var packet = MessageWriter.Get(MessageType.Reliable);
Message01JoinGameS2C.SerializeError(packet, false, DisconnectReason.Custom, DisconnectMessages.NotImplemented);
await Connection.SendAsync(packet);
break;
}
default:
{
Logger.Warning("Received unsupported message flag on the redirector ({0}).", flag);
break;
}
}
}
public void Send(IMessageReader reader)
{
int bytesRead = 0;
byte[] buffer = new byte[1024];
do
{
bytesRead = reader.Read(buffer, 0, buffer.Length);
} while (bytesRead > 0);
}
public async Task SendAsync(IMessageReader reader)
{
int bytesRead = 0;
byte[] buffer = new byte[1024];
do
{
bytesRead = await reader.ReadAsync(buffer, 0, buffer.Length);
} while (bytesRead > 0);
}
public void Deserialize(IMessageReader reader)
{
var num = reader.ReadByte();
VotedFor = (sbyte)((num & VoteMask) - 1);
IsDead = (num & DeadBit) > 0;
DidVote = (num & VotedBit) > 0;
DidReport = (num & ReportedBit) > 0;
}
private void ConvertHeaders(IMessageReader input, IMessageBuilder output)
{
var headerCount = input.ItemCount;
output.BeginHeaders(headerCount);
for (; headerCount > 0; headerCount--)
{
input.Read();
output.WriteHeader(input.PropertyName, input.StringValue);
}
output.EndHeaders();
}
/// <summary>
/// Initilises a new instance of the <see cref="AK.F1.Timing.Server.Proxy.ProxySessionManager"/>
/// class and specified the source <see cref="AK.F1.Timing.IMessageReader"/>.
/// </summary>
/// <param name="reader">The source <see cref="AK.F1.Timing.IMessageReader"/>.</param>
/// <exception cref="System.ArgumentNullException">
/// Thrown when <paramref name="reader"/> is <see langword="null"/>.
/// </exception>
public ProxySessionManager(IMessageReader reader)
{
Guard.NotNull(reader, "reader");
_messageReader = reader;
_cancellationToken = _cancellationTokenSource.Token;
_readMessagesTask = new Task(ReadMessagesTask, _cancellationToken);
_readMessagesTask.ContinueFaultWith(_ => Dispose());
_readMessagesTask.Start();
_mainTask = new Task(MainTask, _cancellationToken);
_mainTask.ContinueFaultWith(_ => Dispose());
_mainTask.Start();
}
public ErrorMessageRecoveryHandler(
IQueueRetrieval queueRetreival,
IMessageWriter messageWriter,
IMessageReader messageReader,
IErrorRetry errorRetry,
IDeleteFiles errorDelete,
IPurgeQueue errorPurge)
{
_queueRetreival = queueRetreival;
_messageWriter = messageWriter;
_messageReader = messageReader;
_errorRetry = errorRetry;
_errorDelete = errorDelete;
_errorPurge = errorPurge;
}
public Program(
ArgParser argParser,
IQueueRetreival queueRetreival,
IMessageWriter messageWriter,
IMessageReader messageReader,
IQueueInsertion queueInsertion,
IErrorRetry errorRetry)
{
this.argParser = argParser;
this.queueRetreival = queueRetreival;
this.messageWriter = messageWriter;
this.messageReader = messageReader;
this.queueInsertion = queueInsertion;
this.errorRetry = errorRetry;
}
private void ConvertArrayContent(IMessageReader reader, IObjectBuilder builder)
{
var itemCount = reader.ItemCount;
builder.BeginArray(itemCount);
for (; itemCount > 0; itemCount--)
{
builder.BeginItem();
reader.Read();
ConvertValue(reader, builder);
builder.EndItem();
}
builder.EndArray();
}
private void ConvertStructContent(IMessageReader reader, IObjectBuilder builder)
{
var elementCount = reader.ItemCount;
builder.BeginStruct(reader.ItemCount);
for (; elementCount > 0; elementCount--)
{
builder.BeginItem();
reader.Read();
builder.WritePropertyName(reader.PropertyName);
ConvertValue(reader, builder);
builder.EndItem();
}
builder.EndStruct();
}
public void Convert(IMessageReader input, IMessageBuilder output)
{
if (!input.Read())
{
throw new ProtocolException("Packet Header not recognized.");
}
output.BeginMessage(input.MessageType);
input.Read();
if (input.ReadState == ReadState.Headers)
{
ConvertHeaders(input, output);
input.Read();
}
output.BeginContent();
if (input.MessageType == MessageType.Request)
{
input.Read();
output.SetMethod(input.StringValue);
input.Read();
ConvertArrayContent(input, output);
}
else
{
while(input.Read() && input.ReadState == ReadState.Body)
{
ConvertValue(input, output);
}
}
output.EndContent();
output.EndMessage();
input.Read();
if (input.ReadState != ReadState.EndOfFile)
{
throw new ProtocolException("Expected EndOfFile");
}
}
public ConsumerCallbackEventArgs(IMessageReader reader)
{
this.reader = reader;
}
private static void Read(IMessageReader reader)
{
Log.Info("connecting...");
try
{
using(reader)
{
Message message;
while((message = reader.Read()) != null)
{
Log.Info(message.ToString());
}
}
Log.Info("disconnected");
}
catch(Exception exc)
{
Log.Error(exc);
}
}
public void SetUp()
{
conventions = new Conventions(new TypeNameSerializer());
messageReader = new MessageReader();
}
public static void TestReadMessages(IMessageReader messageReader)
{
IMessageReader _messageReader = messageReader;
_messageReader.ReadMessage();
XmlDocument messageXML = new XmlDocument();
messageXML.Load(@"C:\Temp\RequestMessage_1423572802_File187E1E8A7F16147A6B87962E07933B406_acknowledgement_20150210125836_.xml");
string[] results = _messageReader.GetMessageResults<string[]>();
foreach (var s in results)
{
Console.WriteLine(s);
}
// GovTalkMessage message = _messageReader.Message(messageXML.ToXDocument());
string bodytype = _messageReader.GetBodyType();
Console.WriteLine(bodytype);
ErrorResponse err = _messageReader.GetBody<ErrorResponse>();
}
private void Initialise(IMessageReader inner, Stream output, bool ownsOutput)
{
Inner = inner;
Output = output;
OwnsOutput = ownsOutput;
Writer = new DecoratedObjectWriter(output);
Stopwatch = new Stopwatch();
}
public CallbackExceptionEventArgs(Exception exception, IMessageReader reader)
{
this.exception = exception;
this.detail = new Hashtable();
this.reader = reader;
}
/// <summary>
/// Initialises a new instance of the <see cref="RecordingMessageReader"/> class and
/// specified the inner message reader and the output file path.
/// </summary>
/// <param name="inner">The inner message reader.</param>
/// <param name="path">The output file path.</param>
/// <exception cref="System.ArgumentNullException">
/// Thrown when <paramref name="inner"/> or <paramref name="path"/> is
/// <see langword="null"/>.
/// </exception>
/// <exception cref="System.IO.IOException">
/// Thrown when an IO error occurs whilst creating the internal
/// <see cref="System.IO.FileStream"/> using the supplied arguments.
/// </exception>
public RecordingMessageReader(IMessageReader inner, string path)
{
Guard.NotNull(inner, "inner");
Initialise(inner, new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None), true);
}
public void Send(IMessageReader reader)
{
throw new NotImplementedException();
}
public void SetUp()
{
messageReader = new MessageReader();
}
internal void RemoveMessageReader(IMessageReader messageReader)
{
if (messageReader == null)
throw new ArgumentNullException("messageReader");
messageReader.ReadMessageCompleted -= MessageHandler;
}
public BrokerNackEventArgs(IMessageReader reader, IHeaderProperties properties)
{
this.reader = reader;
this.properties = properties;
}
public void SetUp()
{
conventions = new Conventions();
messageReader = new MessageReader();
}
private void RunCore(IMessageReader reader, IPEndPoint endpoint, int connectionBacklog)
{
using(var server = new TcpServer(
endpoint: endpoint ?? new IPEndPoint(IPAddress.Any, ProxyMessageReader.DefaultPort),
handler: new ProxySessionManager(reader),
backlog: connectionBacklog))
{
server.Start();
CmdLineCancelKey.WaitFor().Dispose();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageEventArg" /> class.
/// </summary>
/// <param name="newMessage">The new message to be processed by the consumer or a producer outcome to be
/// sent over the network by the underlying message transport protocol.</param>
/// <param name="dataSetId">The data set identifier.</param>
/// <param name="producerId">The producer identifier.</param>
public MessageEventArg(IMessageReader newMessage, UInt16 dataSetId, Guid producerId)
{
MessageContent = newMessage;
DataSetId = dataSetId;
ProducerId = producerId;
}
private void ConvertValue(IMessageReader reader, IObjectBuilder builder)
{
switch (reader.ValueType)
{
case ContentType.Array:
ConvertArrayContent(reader, builder);
break;
case ContentType.Struct:
ConvertStructContent(reader, builder);
break;
case ContentType.Int:
builder.WriteInt32Value(reader.IntValue);
break;
case ContentType.Boolean:
builder.WriteBooleanValue(reader.BooleanValue);
break;
case ContentType.String:
builder.WriteStringValue(reader.StringValue);
break;
case ContentType.Float:
builder.WriteDoubleValue(reader.DoubleValue);
break;
case ContentType.Base64:
builder.WriteBase64String(reader.StringValue);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public Task SendAsync(IMessageReader reader)
{
throw new NotImplementedException();
}
