/// <summary>
/// Create a factory for generating tenant queues
/// </summary>
/// <param name="queuePrefix">The prefix to use for the queue in Redis</param>
public RedisTenantQueueFactory(string queuePrefix)
{
_queuePrefix = queuePrefix;
_redisManager = new RedisManager();
_redisManager.Connect();
}
public void TestSync( )
{
const string channelName = "myChannel";
using (var domain1 = new TestAppDomain( ))
{
Func <MessageEventArgs <TestMessage>, bool> predicate = m => m.Message.Action == "myMessage";
var instance1 = domain1.InjectType <SubscriberRefObject <TestMessage> >(channelName, RunAsDefaultTenant.DefaultTenantName, predicate);
using (IDistributedMemoryManager manager = new RedisManager( ))
{
manager.Connect( );
const int count = 1000;
using (IChannel <TestMessage> channel = manager.GetChannel <TestMessage>(channelName))
{
RunSync(channel, count);
instance1.MessageReceived.WaitOne(DefaultTimeout);
Assert.Greater(instance1.ReceivedMessages.Count, 0);
}
}
}
}
public void TestSubscriber( )
{
const string channelName = "myChannel";
using (var domain1 = new TestAppDomain( ))
{
Func <MessageEventArgs <TestMessage>, bool> predicate = m => m.Message.Action == "myMessage";
var instance1 = domain1.InjectType <SubscriberRefObject <TestMessage> >(channelName, RunAsDefaultTenant.DefaultTenantName, predicate);
using (var domain2 = new TestAppDomain( ))
{
var instance2 = domain2.InjectType <SubscriberRefObject <TestMessage> >(channelName, RunAsDefaultTenant.DefaultTenantName, predicate);
using (IDistributedMemoryManager manager = new RedisManager( ))
{
manager.Connect( );
using (IChannel <TestMessage> channel = manager.GetChannel <TestMessage>(channelName))
{
var message = new TestMessage( );
message.Action = "myMessage";
channel.Publish(message);
bool waitOne1 = instance1.MessageReceived.WaitOne(DefaultTimeout);
bool waitOne2 = instance2.MessageReceived.WaitOne(DefaultTimeout);
Assert.IsTrue(waitOne1, "No message received in " + DefaultTimeout + "ms for app domain 1.");
Assert.IsTrue(waitOne2, "No message received in " + DefaultTimeout + "ms for app domain 2.");
instance2.Unsubscribe( );
channel.Publish(message);
waitOne1 = instance1.MessageReceived.WaitOne(DefaultTimeout);
waitOne2 = instance2.MessageReceived.WaitOne(0);
Assert.IsTrue(waitOne1, "No message received in " + DefaultTimeout + "ms for app domain 1.");
Assert.IsFalse(waitOne2, "Message received in app domain 1 when it should not have been.");
instance1.Unsubscribe( );
var channelMessage = new TestMessage( );
channel.Publish(channelMessage);
waitOne1 = instance1.MessageReceived.WaitOne(0);
waitOne2 = instance2.MessageReceived.WaitOne(0);
Assert.IsFalse(waitOne1, "Message received in app domain 1 when it should not have been.");
Assert.IsFalse(waitOne2, "Message received in app domain 2 when it should not have been.");
}
}
}
}
}
public static IServiceCollection AddRedis(this IServiceCollection services,
IConfiguration configuration,
out ConnectionMultiplexer redisConn,
out string redisConnectionString)
{
redisConn = RedisManager.Connect(configuration.GetSection("redis"), out redisConnectionString);
services.AddSingleton(redisConn);
return(services);
}
public static IServiceCollection AddCnblogsAuthentication(
this IServiceCollection services,
IConfigurationSection redisConfiguration,
Action <CookieAuthenticationOptions> configureOption = null)
{
var redisConn = RedisManager.Connect(redisConfiguration, out var redisConnectionString);
return(services.AddCnblogsAuthentication(redisConn, redisConnectionString, configureOption));
}
public void TestBulkPublisher( )
{
const string channelName = "myChannel";
using (var domain = new TestAppDomain( ))
{
Func <MessageEventArgs <TestMessage>, bool> predicate = m => m.Message.Action == PublisherActions.Remove && m.Message.Items.Count == 2 && m.Message.Items.Contains("a,:") && m.Message.Items.Contains("b,:");
var instance = domain.InjectType <SubscriberRefObject <TestMessage> >(channelName, RunAsDefaultTenant.DefaultTenantName, predicate);
using (IDistributedMemoryManager manager = new RedisManager( ))
{
manager.Connect( );
using (DeferredChannelMessageContext context = new DeferredChannelMessageContext())
{
using (IChannel <TestMessage> channel1 = manager.GetChannel <TestMessage>(channelName))
{
var message1 = new TestMessage
{
Action = PublisherActions.Remove
};
message1.Items.Add("a,:");
channel1.Publish(message1, PublishOptions.None, false, (e, n) => e.Items.AddRange(n.Items));
using (IChannel <TestMessage> channel2 = manager.GetChannel <TestMessage>(channelName))
{
var message2 = new TestMessage
{
Action = PublisherActions.Remove
};
message2.Items.Add("b,:");
channel2.Publish(message2, PublishOptions.None, false, (e, n) => e.Items.AddRange(n.Items));
}
}
}
bool waitOne = instance.MessageReceived.WaitOne(DefaultTimeout);
Assert.IsTrue(waitOne, "No message received in " + DefaultTimeout + "ms.");
Assert.GreaterOrEqual(instance.ReceivedMessages.Count, 1, "Received message count is invalid.");
MessageEventArgs <TestMessage> args = instance.ReceivedMessages.FirstOrDefault(predicate);
Assert.IsNotNull(args, "Received message is invalid.");
}
}
}
/// <summary>
/// Loads the registrations.
/// </summary>
/// <param name="builder">The container builder.</param>
protected override void Load(ContainerBuilder builder)
{
builder.Register(cc =>
{
RedisManager redisManager = new RedisManager();
redisManager.Connect();
return(redisManager);
})
.As <IDistributedMemoryManager>()
.SingleInstance();
builder.RegisterType <TaskManager>().As <ITaskManager>().SingleInstance();
}
public void TestConnect( )
{
using (var manager = new RedisManager( ))
{
bool isConnected = manager.IsConnected;
Assert.IsFalse(isConnected, "New redis manager should start disconnected.");
manager.Connect( );
isConnected = manager.IsConnected;
Assert.IsTrue(isConnected, "Failed to connect to redis.");
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddApplicationInsightsTelemetry();
services.AddHttpContextAccessor();
services.AddControllersWithViews().AddFluentValidation();
services.Configure <FileUploadSettings>(Configuration.GetSection("FileUploadSettings"));
services.AddValidationInjection();
services.AddDbContext <MatmazelContext>(option => option.UseNpgsql("Server=167.172.186.80; Database=perdecim; User Id=perdecimuser; Password=H}WuON<QXIIGfX; Port=5432;"));
services.AddIdentity <AppUser, AppRole>(_ =>
{
_.Password.RequiredLength = 5;
_.Password.RequireNonAlphanumeric = false;
_.Password.RequireLowercase = false;
_.Password.RequireUppercase = false;
_.User.RequireUniqueEmail = true;
_.User.AllowedUserNameCharacters = "abcçdefghiıjklmnoöpqrsştuüvwxyzABCÇDEFGHIİJKLMNOÖPQRSŞTUÜVWXYZ0123456789-._@+";
}).AddEntityFrameworkStores <MatmazelContext>()
.AddDefaultTokenProviders();
services.AddScoped <IUserClaimsPrincipalFactory <AppUser>, MyUserClaimsPrincipalFactory>();
services.ConfigureApplicationCookie(_ =>
{
_.LoginPath = new PathString("/Auth/Login");
_.LogoutPath = new PathString("/Auth/Logout");
_.Cookie = new CookieBuilder
{
Name = "AccessToken",
HttpOnly = false,
SameSite = SameSiteMode.Lax,
SecurePolicy = CookieSecurePolicy.Always
};
_.SlidingExpiration = true;
_.ExpireTimeSpan = TimeSpan.FromHours(3);
});
services.AddSignalR();
services.Configure <RedisSettings>(Configuration.GetSection("RedisSettings"));
services.AddSingleton <RedisManager>(sp =>
{
RedisSettings redisSettings = sp.GetRequiredService <IOptions <RedisSettings> >().Value;
RedisManager redis = new RedisManager(redisSettings.Host, redisSettings.Port);
redis.Connect();
return(redis);
});
}
/// <param name="channelName">Name of the channel.</param>
/// <param name="tenantName">Name of the tenant.</param>
/// <param name="filter">The filter.</param>
public SubscriberRefObject(string channelName, string tenantName, Func <MessageEventArgs <T>, bool> filter)
{
Context = new TenantAdministratorContext(tenantName);
Filter = filter;
Manager = new RedisManager( );
Manager.Connect( );
ReceivedMessages = new List <MessageEventArgs <T> >( );
MessageReceived = new AutoResetEvent(false);
Channel = Manager.GetChannel <T>(channelName);
Channel.MessageReceived += Handler;
Channel.Subscribe( );
/////
// Allow time for the server to receive the message and process it.
/////
Thread.Sleep(1000);
}
public void TestReconnect( )
{
using (var manager = new RedisManager( ))
{
bool isConnected = manager.IsConnected;
Assert.IsFalse(isConnected, "New redis manager should start disconnected.");
manager.Connect( );
isConnected = manager.IsConnected;
Assert.IsTrue(isConnected, "Failed to connect to redis.");
ServiceHelper.StopService( );
isConnected = manager.IsConnected;
Assert.IsFalse(isConnected, "Failed to automatically disconnect when redis shutdown.");
ServiceHelper.StartService( );
int retries = 0;
while (retries < 5 && !isConnected)
{
isConnected = manager.IsConnected;
if (!isConnected)
{
Thread.Sleep(1000);
retries++;
}
}
Assert.IsTrue(isConnected, "Failed to automatically reconnect when redis started back up.");
}
}