public MTProtoClientConnection(
[NotNull] IClientTransportConfig clientTransportConfig,
[NotNull] IClientTransportFactory clientTransportFactory,
[NotNull] TLRig tlRig,
[NotNull] IMessageIdGenerator messageIdGenerator,
[NotNull] IMessageCodec messageCodec)
{
Argument.IsNotNull(() => clientTransportConfig);
Argument.IsNotNull(() => clientTransportFactory);
Argument.IsNotNull(() => tlRig);
Argument.IsNotNull(() => messageIdGenerator);
Argument.IsNotNull(() => messageCodec);
_tlRig = tlRig;
_messageIdGenerator = messageIdGenerator;
_messageCodec = messageCodec;
DefaultRpcTimeout = Defaults.RpcTimeout;
DefaultConnectTimeout = Defaults.ConnectTimeout;
_methods = new MTProtoAsyncMethods(this);
InitResponseDispatcher(_responseDispatcher);
// Init transport.
_clientTransport = clientTransportFactory.CreateTransport(clientTransportConfig);
// Connector in/out.
_clientTransport.ObserveOn(DefaultScheduler.Instance).Do(bytes => LogMessageInOut(bytes, "IN")).Subscribe(ProcessIncomingMessageBytes);
}
public void WhenResolveMd5Generator_ThenResult_ShouldBeAsExpectedType()
{
var resolver = new MessageIdGeneratorResolver();
IMessageIdGenerator actual = resolver.Resolve(MessageIdGeneratortype.Md5);
Assert.IsType <Md5MessageIdGenerator>(actual);
}
public ServerSentEvent(int noOfMessagesToRemember, bool generateMessageIds = false, int heartbeatInterval = 0)
{
mHeartbeatInterval = heartbeatInterval;
mMessageHistory = new MemoryMessageHistory(noOfMessagesToRemember);
if (generateMessageIds)
mIdGenerator = new SimpleIdGenerator();
SetupHeartbeat(heartbeatInterval);
}
public void WhenResolveTimeStampGenerator_ThenResult_ShouldBeAsExpectedType()
{
var resolver = new MessageIdGeneratorResolver();
IMessageIdGenerator actual = resolver.Resolve(MessageIdGeneratortype.Timestamp);
Assert.IsType <TimestampMessageIdGenerator>(actual);
}
public MultiplexingSocketClientProtocol(IMultiplexingSocketProtocol <TInbound, TOutbound> innerProtocol, IMessageIdGenerator idGenerator)
{
this.innerProtocol = innerProtocol ?? throw new ArgumentNullException(nameof(innerProtocol));
this.idGenerator = idGenerator ?? throw new ArgumentNullException(nameof(idGenerator));
this.pendings = new ConcurrentDictionary <MessageId, PendingResponse <TInbound> >();
this.sourcePool = new ObjectPool <PooledValueTaskSource <TInbound> >(() => { return(new PooledValueTaskSource <TInbound>()); }, 100);
this.ScheduleRead();
}
public ServerSentEvent(int noOfMessagesToRemember, bool generateMessageIds = false, int heartbeatInterval = 0)
{
mHeartbeatInterval = heartbeatInterval;
mMessageHistory = new MemoryMessageHistory(noOfMessagesToRemember);
if (generateMessageIds)
{
mIdGenerator = new SimpleIdGenerator();
}
SetupHeartbeat(heartbeatInterval);
}
public PeerToPeerSignalBusMessageStore(IMessageIdGenerator messageIdGenerator)
{
if (messageIdGenerator == null)
{
throw new ArgumentNullException("messageIdGenerator");
}
MessageIdGenerator = messageIdGenerator;
Id = Guid.NewGuid();
}
public PeerToPeerSignalBusMessageStore(IMessageIdGenerator messageIdGenerator)
{
if (messageIdGenerator == null)
{
throw new ArgumentNullException("messageIdGenerator");
}
MessageIdGenerator = messageIdGenerator;
Id = Guid.NewGuid();
}
public BrokeredMessageDispatcher(IRouteBrokeredMessages messageRouter,
IForwardMessages forwarder,
IBrokeredMessageAttributeDetailProvider brokeredMessageDetailProvider,
IBodyConverterFactory bodyConverterFactory,
IMessageIdGenerator messageIdGenerator)
{
_messageRouter = messageRouter ?? throw new ArgumentNullException(nameof(messageRouter));
_forwarder = forwarder ?? throw new ArgumentNullException(nameof(forwarder));
_brokeredMessageDetailProvider = brokeredMessageDetailProvider ?? throw new ArgumentNullException(nameof(brokeredMessageDetailProvider));
_bodyConverterFactory = bodyConverterFactory ?? throw new ArgumentNullException(nameof(bodyConverterFactory));
_messageIdGenerator = messageIdGenerator ?? throw new ArgumentNullException(nameof(messageIdGenerator));
}
public ServerSentEvent(IMessageHistory messageHistory, IMessageIdGenerator idGenerator, int heartbeatInterval = 0)
{
if (messageHistory == null)
throw new ArgumentException("messageHistory can not be null.");
if (idGenerator == null)
throw new ArgumentException("idGenerator can not be null.");
mMessageHistory = messageHistory;
mIdGenerator = idGenerator;
mHeartbeatInterval = heartbeatInterval;
SetupHeartbeat(heartbeatInterval);
}
public MTProtoClientConnection(
[NotNull] IClientTransportConfig clientTransportConfig,
[NotNull] IClientTransportFactory clientTransportFactory,
[NotNull] TLRig tlRig,
[NotNull] IMessageIdGenerator messageIdGenerator,
[NotNull] IMessageCodec messageCodec)
{
_tlRig = tlRig;
_messageIdGenerator = messageIdGenerator;
_messageCodec = messageCodec;
DefaultRpcTimeout = Defaults.RpcTimeout;
DefaultConnectTimeout = Defaults.ConnectTimeout;
_methods = new MTProtoAsyncMethods(this);
_updatesHandler = new UpdatesHandler(_tlRig);
InitResponseDispatcher(_responseDispatcher);
// Init transport.
_clientTransport = clientTransportFactory.CreateTransport(clientTransportConfig);
// Connector in/out.
_clientTransport.ObserveOn(DefaultScheduler.Instance).Do(bytes => LogMessageInOut(bytes, "IN")).Subscribe(ProcessIncomingMessageBytes);
_clientTransport.RegisterOnDisconnectInternally(() =>
{
Console.WriteLine("Client has been closed internally.");
if (_onClosedInternally != null)
{
_onClosedInternally(this, null);
}
if (_state == MTProtoConnectionState.Disconnected)
{
return;
}
_state = MTProtoConnectionState.Disconnected;
if (_connectionCts != null)
{
_connectionCts.Cancel();
_connectionCts.Dispose();
_connectionCts = null;
}
});
}
public static async Task <IEnumerable <Message> > ProcessManifestActivity(
[ActivityTrigger] UploadCompleted uploadCompleted,
[Blob(BlobNames.UploadDirectory + "/{uploadCompleted.SessionId}/" + CommunicationManifest.FileName)] CloudBlockBlob manifest,
[Table(TableNames.CommMessage)] CloudTable messageTable,
[Inject] IMessageIdGenerator idGenerator,
[Inject] App app,
ILogger log)
{
var communicationManifest = await manifest.DownloadTextAsAsync <CommunicationManifest>();
var results = await communicationManifest.PrepareCommMessage(uploadCompleted.SessionId, idGenerator, app.DateTimeNow)
.CreateIn(messageTable);
log.Log(LogLevel.Information, communicationManifest.ToJson(Formatting.Indented));
return(results.GetResult <Message>());
}
public ServerSentEvent(IMessageHistory messageHistory, IMessageIdGenerator idGenerator, int heartbeatInterval = 0)
{
if (messageHistory == null)
{
throw new ArgumentException("messageHistory can not be null.");
}
if (idGenerator == null)
{
throw new ArgumentException("idGenerator can not be null.");
}
mMessageHistory = messageHistory;
mIdGenerator = idGenerator;
mHeartbeatInterval = heartbeatInterval;
SetupHeartbeat(heartbeatInterval);
}
public MTProtoClientBuilder(
[NotNull] IClientTransportFactory clientTransportFactory,
[NotNull] TLRig tlRig,
[NotNull] IMessageIdGenerator messageIdGenerator,
[NotNull] IMessageCodec messageCodec,
[NotNull] IHashServices hashServices,
[NotNull] IEncryptionServices encryptionServices,
[NotNull] INonceGenerator nonceGenerator,
[NotNull] IKeyChain keyChain)
{
_clientTransportFactory = clientTransportFactory;
_tlRig = tlRig;
_messageIdGenerator = messageIdGenerator;
_messageCodec = messageCodec;
_hashServices = hashServices;
_encryptionServices = encryptionServices;
_nonceGenerator = nonceGenerator;
_keyChain = keyChain;
}
public MTProtoClientBuilder(
[NotNull] IClientTransportFactory clientTransportFactory,
[NotNull] TLRig tlRig,
[NotNull] IMessageIdGenerator messageIdGenerator,
[NotNull] IMessageCodec messageCodec,
[NotNull] IHashServices hashServices,
[NotNull] IEncryptionServices encryptionServices,
[NotNull] INonceGenerator nonceGenerator,
[NotNull] IKeyChain keyChain)
{
_clientTransportFactory = clientTransportFactory;
_tlRig = tlRig;
_messageIdGenerator = messageIdGenerator;
_messageCodec = messageCodec;
_hashServices = hashServices;
_encryptionServices = encryptionServices;
_nonceGenerator = nonceGenerator;
_keyChain = keyChain;
}
/// <summary>
/// Converts to chunks.
/// </summary>
/// <param name="message">The message.</param>
/// <returns>array of chunks to save</returns>
/// <exception cref="System.ArgumentException">message was too long</exception>
/// <exception cref="ArgumentException">message was too long</exception>
public IList <byte[]> ConvertToChunks(byte[] message)
{
int messageLength = message.Length;
if (messageLength <= ChunkSettings.MaxMessageSizeInUdp)
{
return(new List <byte[]>(1)
{
message
});
}
int chunksCount = messageLength / ChunkSettings.MaxMessageSizeInChunk + 1;
if (chunksCount > ChunkSettings.MaxNumberOfChunksAllowed)
{
throw new ArgumentException("message was too long", nameof(message));
}
//TOD: FixMe
IMessageIdGenerator messageIdGenerator = _generatorResolver.Resolve(_settings.MessageIdGeneratorType, message);
byte[] messageId = messageIdGenerator.GenerateMessageId();
var result = new List <byte[]>();
for (byte i = 0; i < chunksCount; i++)
{
IList <byte> chunkHeader = ConstructChunkHeader(messageId, i, (byte)chunksCount);
int skip = i * ChunkSettings.MaxMessageSizeInChunk;
byte[] chunkData = message.Skip(skip).Take(ChunkSettings.MaxMessageSizeInChunk).ToArray();
var messageChunkFull = new List <byte>(chunkHeader.Count + chunkData.Length);
messageChunkFull.AddRange(chunkHeader);
messageChunkFull.AddRange(chunkData);
result.Add(messageChunkFull.ToArray());
}
return(result);
}
public static bool SetCurrent( IMessageIdGenerator sessionManager )
{
if ( sessionManager == null )
{
throw new ArgumentNullException( "sessionManager" );
}
Contract.EndContractBlock();
try
{
if ( Interlocked.CompareExchange( ref _frozen, _customized, _free ) != _free )
{
return false;
}
}
finally
{
Interlocked.Exchange( ref _current, sessionManager );
}
return true;
}
public MTProtoConnection(TransportConfig transportConfig, [NotNull] ITransportFactory transportFactory, [NotNull] TLRig tlRig,
[NotNull] IMessageIdGenerator messageIdGenerator, [NotNull] IHashServices hashServices, [NotNull] IEncryptionServices encryptionServices)
{
Argument.IsNotNull(() => transportFactory);
Argument.IsNotNull(() => tlRig);
Argument.IsNotNull(() => messageIdGenerator);
Argument.IsNotNull(() => hashServices);
Argument.IsNotNull(() => encryptionServices);
_transportFactory = transportFactory;
_tlRig = tlRig;
_messageIdGenerator = messageIdGenerator;
_hashServices = hashServices;
_encryptionServices = encryptionServices;
DefaultRpcTimeout = Defaults.RpcTimeout;
DefaultConnectTimeout = Defaults.ConnectTimeout;
_tlRig.PrepareSerializersForAllTLObjectsInAssembly(typeof(ITLAsyncMethods).GetAssemblyEx());
_sessionId = GetNextSessionId();
// Init transport.
_transport = _transportFactory.CreateTransport(transportConfig);
// History of messages in/out.
_inMessages.ObserveOn(DefaultScheduler.Instance).Subscribe(_inMessagesHistory);
_outMessages.ObserveOn(DefaultScheduler.Instance).Subscribe(_outMessagesHistory);
// Connector in/out.
_transport.ObserveOn(DefaultScheduler.Instance).Do(bytes => LogMessageInOut(bytes, "IN")).Subscribe(ProcessIncomingMessageBytes);
_outMessages.ObserveOn(DefaultScheduler.Instance)
.Do(message => LogMessageInOut(message.MessageBytes, "OUT"))
.Subscribe(message => _transport.Send(message.MessageBytes));
_inMessages.ObserveOn(DefaultScheduler.Instance).Subscribe(ProcessIncomingMessage);
}
public DefaultMessageFactory(IMessageIdGenerator generator)
{
_generator = generator ?? throw new ArgumentNullException(nameof(generator));
}
public ServerSentEvent(IMessageHistory messageHistory, IMessageIdGenerator idGenerator, int heartbeatInterval = 0)
: base(messageHistory, idGenerator, heartbeatInterval)
{
}
public DefaultMessageFactoryTest()
{
_fixture = new Fixture();
_generator = Substitute.For <IMessageIdGenerator>();
_factory = new DefaultMessageFactory(_generator);
}
/// <summary>
/// Creates a router for sending a brokered message to a brokered message receiver designated by the 'reply to' application property
/// </summary>
/// <param name="router">The strategy used to compensate the a received message</param>
public ReplyRouter(IRouteBrokeredMessages router, IMessageIdGenerator messageIdGenerator)
{
_router = router ?? throw new ArgumentNullException(nameof(router));
_messageIdGenerator = messageIdGenerator ?? throw new ArgumentNullException(nameof(messageIdGenerator));
}
public static IEnumerable <ITableEntity> PrepareCommMessage(this CommunicationManifest cm, string sessionId, IMessageIdGenerator idGenerator, DateTime prepareDateTime)
{
// ParseMessage function
(int order, string type, Recipient recipient, object message)[] ParseMessage(Recipient r)
public MultiplexingSocketProtocol(ConnectionContext connection, IMessageReader <TInbound> messageReader, IMessageWriter <TOutbound> messageWriter, IMessageIdGenerator messageIdGenerator, IMessageIdParser messageIdParser)
{
this.connection = connection ?? throw new ArgumentNullException(nameof(connection));
this.reader = new ProtocolReader(this.connection.Transport.Input);
this.writer = new ProtocolWriter(this.connection.Transport.Output);
this.wrappedReader = new WrappedMessageReader <TInbound>(messageIdParser, messageReader);
this.wrappedWriter = new WrappedMessageWriter <TOutbound>(messageIdParser, messageWriter);
this.sourcePool = new ObjectPool <PooledValueTaskSource <MessageId> >(() => { return(new PooledValueTaskSource <MessageId>()); }, 100);
}
public OutboundBrokeredMessage(IMessageIdGenerator messageIdGenerator, object message, IDictionary <string, object> messageContext, string destination, IBrokeredMessageBodyConverter bodyConverter)
: this(messageIdGenerator, bodyConverter.Convert(message), messageContext, destination, bodyConverter)
{
}
public OutboundBrokeredMessage(IMessageIdGenerator messageIdGenerator, byte[] body, IDictionary <string, object> messageContext, string destination, IBrokeredMessageBodyConverter bodyConverter)
: this(messageIdGenerator?.GenerateId(body).ToString(), body, messageContext, destination, bodyConverter)
{
}
public MessageIdGeneratorTest()
{
_generator = new DefaultIdGenerator();
}
