internal RedisMessageBus(IDependencyResolver resolver, RedisScaleoutConfiguration configuration, IRedisConnection connection, bool connectAutomatically)
: base(resolver, configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
_connection = connection;
_connection.ConnectionFailed += OnConnectionFailed;
_connection.ConnectionRestored += OnConnectionRestored;
_connection.ErrorMessage += OnConnectionError;
_connectionString = configuration.ConnectionString;
_db = configuration.Database;
_key = configuration.EventKey;
_traceManager = resolver.Resolve <ITraceManager>();
_messageEncryptor = resolver.Resolve <IMessageEncryptor>();
_trace = _traceManager["SignalR." + nameof(RedisMessageBus)];
ReconnectDelay = TimeSpan.FromSeconds(2);
if (connectAutomatically)
{
ThreadPool.QueueUserWorkItem(_ =>
{
var ignore = ConnectWithRetry();
});
}
}
public HomeController(IMessageEncryptor encryptor, IMessageRepository repository,
IMessageValidator validator, IMessageMapper mapper)
{
this.encryptor = encryptor;
this.repository = repository;
this.validator = validator;
this.mapper = mapper;
}
public static RedisMessage FromBytes(IMessageEncryptor encryptor, byte[] data, TraceSource trace)
{
using (var stream = new MemoryStream(data))
{
var message = new RedisMessage();
// read message id from memory stream until SPACE character
var messageIdBuilder = new StringBuilder(20);
do
{
// it is safe to read digits as bytes because they encoded by single byte in UTF-8
int charCode = stream.ReadByte();
if (charCode == -1)
{
trace.TraceVerbose("Received Message could not be parsed.");
throw new EndOfStreamException(Resources.Error_EndOfStreamRedis);
}
char c = (char)charCode;
if (c == ' ')
{
message.Id = ulong.Parse(messageIdBuilder.ToString(), CultureInfo.InvariantCulture);
messageIdBuilder = null;
}
else
{
messageIdBuilder.Append(c);
}
}while (messageIdBuilder != null);
var encryptedBinaryReader = new BinaryReader(stream);
var encryptedData = encryptedBinaryReader.ReadBytes((int)(stream.Length - stream.Position));
var decryptedData = encryptor.Decrypt(encryptedData);
using (var dataStream = new MemoryStream(decryptedData))
using (var decryptedReader = new BinaryReader(dataStream))
{
int count = decryptedReader.ReadInt32();
byte[] buffer = decryptedReader.ReadBytes(count);
message.ScaleoutMessage = ScaleoutMessage.FromBytes(buffer);
}
return(message);
}
}
public static byte[] ToBytes(IMessageEncryptor encryptor, IList <Message> messages)
{
if (messages == null)
{
throw new ArgumentNullException(nameof(messages));
}
using (var ms = new MemoryStream())
{
var binaryWriter = new BinaryWriter(ms);
var scaleoutMessage = new ScaleoutMessage(messages);
var buffer = scaleoutMessage.ToBytes();
binaryWriter.Write(buffer.Length);
binaryWriter.Write(buffer);
return(encryptor.Encrypt(ms.ToArray()));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageEncryptingForwardingAppender"/> class.
/// </summary>
/// <remarks>
/// Allows the class dependencies to be injected into the class
/// </remarks>
/// <param name="messageEncryption">The message encryption engine to use.</param>
public MessageEncryptingForwardingAppender(IMessageEncryptor messageEncryption, ILoggingEventFactory logEventFactory)
{
this.MessageEncryption = messageEncryption;
this.LogEventFactory = logEventFactory;
}
public RedisConnection(IDependencyResolver resolver, bool webFarmSupport)
{
_messageEncryptor = resolver.Resolve <IMessageEncryptor>();
_webFarmSupport = webFarmSupport;
}
public RedisConnection(IDependencyResolver resolver)
{
_messageEncryptor = resolver.Resolve <IMessageEncryptor>();
}
public UserController(IMessageRepository repository, UserManager <ApplicationUser> userManager, IMessageEncryptor encryptor)
{
this.repository = repository;
this.userManager = userManager;
this.encryptor = encryptor;
}
