public async Task Init(IPEndPoint endpoint, CancellationToken cancel)
{
var options = new RedisClientOptions();
options.MultiplexPool.CommandConnections = 1;
options.MultiplexPool.SubscriptionOptions = 1;
_client = new RedisClient(endpoint, options);
await _client.ConnectAsync(cancel).ConfigureAwait(false);
using (var channel = _client.CreateChannel())
{
channel.Dispatch("flushdb");
var data = Enumerable.Range(0, 10).Select(i => i.ToString("0000000000"));
await channel.ExecuteAsync(@"
sadd @key @data
sadd @key2 @data
set @key3 'hi this is a test'"
, new
{
key = "testkeyRC",
key2 = "testkeyRC2",
key3 = "testkeyRC3",
data
}).ConfigureAwait(false);
}
}
protected override RedisClientOptions GetOptions()
{
var options = new RedisClientOptions();
var scripts = options.Procedures;
scripts.Load(GetScript());
return(options);
}
public void DetectMissingResponseErrors()
{
var options = new RedisClientOptions();
options.InitializationCommands.Add(new PreInitializationCommand("auth vtortola"));
var initializer = new ConnectionInitializer(options);
var writtingStream = new MemoryStream();
var reader = new DummySocketReader(null);
var writer = new DummySocketWriter(writtingStream);
initializer.Initialize(reader, writer);
}
protected virtual RedisClientOptions GetOptions()
{
var options = new RedisClientOptions()
{
UseExecutionPlanCaching = true,
PreventPingIfActive = false,
Logger = new TraceRedisClientLogger()
};
//if (!Debugger.IsAttached)
// options.PingTimeout = TimeSpan.FromMilliseconds(500);
return(options);
}
public async Task Init(IPEndPoint endpoint, CancellationToken cancel)
{
var options = new RedisClientOptions();
options.MultiplexPool.CommandConnections = 1;
options.MultiplexPool.SubscriptionOptions = 1;
_client = new RedisClient(endpoint, options);
await _client.ConnectAsync(cancel).ConfigureAwait(false);
using (var channel = _client.CreateChannel())
{
channel.Dispatch("flushdb");
await channel.ExecuteAsync("incr @key", new { key = "whatever" }).ConfigureAwait(false);
}
}
public void InitializesWithCommands()
{
var options = new RedisClientOptions();
options.InitializationCommands.Add(new PreInitializationCommand("auth vtortola"));
var initializer = new ConnectionInitializer(options);
var writtingStream = new MemoryStream();
var reader = new DummySocketReader("+OK\r\n");
var writer = new DummySocketWriter(writtingStream);
initializer.Initialize(reader, writer);
writtingStream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual("*2\r\n$4\r\nAUTH\r\n$8\r\nvtortola\r\n", new StreamReader(writtingStream).ReadToEnd());
}
public Tuple <Int64, TimeSpan> Test(Int32 threads, Int32 loops)
{
var options = new RedisClientOptions()
{
Logger = new ConsoleLogger(false)
};
options.MultiplexPool.CommandConnections = 1;
options.MultiplexPool.SubscriptionOptions = 1;
using (var client = new RedisClient(_endpoint, options))
{
client.ConnectAsync(CancellationToken.None).Wait();
using (var channel = client.CreateChannel())
channel.Execute("flushall");
var cancel = new CancellationTokenSource();
var taskList = new List <Thread>();
var total = threads * loops;
var progress = 0;
var bars = 0;
var sw = new Stopwatch();
sw.Start();
for (int threadId = 0; threadId < threads; threadId++)
{
var ts = new ThreadStart(() =>
{
try
{
for (int loop = 0; loop < loops; loop++)
{
using (var channel = client.CreateChannel())
RunClient(threadId.ToString() + "_" + loop.ToString(), channel, cancel.Token).Wait();
var p = Interlocked.Increment(ref progress);
var percentage = (Int32)((p * 100D) / total);
while (bars < percentage)
{
Interlocked.Increment(ref bars);
Console.Write("|");
}
}
}
catch (Exception ex)
{
Console.Write("[{0}]", ex.GetType());
}
});
var thread = new Thread(ts);
thread.Start();
taskList.Add(thread);
}
foreach (var t in taskList)
{
t.Join();
}
sw.Stop();
cancel.Cancel();
return(new Tuple <Int64, TimeSpan>(progress, sw.Elapsed));
}
}
public static void Configure(Container container, IPEndPoint endpoint, Boolean withLogging)
{
var options = new RedisClientOptions()
{
//PingTimeout = TimeSpan.FromSeconds(1),
//PreventPingIfActive = false,
Logger = withLogging? new RedisLogger() : null
};
options.Procedures.LoadFromAssembly(Assembly.GetExecutingAssembly());
var client = new RedisClient(endpoint, options);
var connect = client.ConnectAsync(CancellationToken.None);
container.RegisterSingleton <RedisClient>(client);
container.Register <IRedisChannel>(() => client.CreateChannel(), Lifestyle.Scoped);
container.Register <IMessaging>(() => new RedisClientMessaging(client.CreateChannel()));
container.Register <ICommandExecuter <VisitQuestionCommand, VisitQuestionCommandResult>, VisitQuestionCommandExecuter>();
container.Register <ICommandExecuter <AnswerEditCommand, AnswerEditCommandResult>, AnswerEditCommandExecuter>();
container.Register <ICommandExecuter <AnswerDeleteCommand, AnswerDeleteCommandResult>, AnswerDeleteCommandExecuter>();
container.Register <ICommandExecuter <AnswerVoteCommand, AnswerVoteCommandResult>, AnswerVoteCommandExecuter>();
container.Register <ICommandExecuter <AnswerCreateCommand, AnswerCreateCommandResult>, AnswerCreateCommandExecuter>();
container.Register <ICommandExecuter <QuestionDeleteCommand, QuestionDeleteCommandResult>, QuestionDeleteCommandExecutor>();
container.Register <ICommandExecuter <QuestionCloseCommand, QuestionCloseCommandResult>, QuestionCloseCommandExecuter>();
container.Register <ICommandExecuter <QuestionEditCommand, QuestionEditCommandResult>, QuestionEditCommandExecuter>();
container.Register <ICommandExecuter <QuestionVoteCommand, QuestionVoteCommandResult>, QuestionVoteCommandExecuter>();
container.Register <ICommandExecuter <QuestionCreateCommand, QuestionCreateCommandResult>, QuestionCreateCommandExecuter>();
container.Register <ICommandExecuter <EndSessionCommand, EndSessionCommandResult>, EndSessionCommandExecuter>();
container.Register <ICommandExecuter <ValidateSessionCommand, ValidateSessionCommandResult>, ValidateSessionCommandExecuter>();
container.Register <ICommandExecuter <AuthenticateCommand, AuthenticateCommandResult>, AuthenticateCommandExecuter>();
container.Register <IModelBuilder <UserModelRequest, UserModel>, UserModelBuilder>();
container.Register <IModelBuilder <UserInboxRequest, UserInboxModel>, UserInboxModelBuilder>();
container.Register <IModelBuilder <AnswerRequest, AnswerViewModel>, AnswerRequestBuilder>();
container.Register <IModelBuilder <AnswerEditFormRequest, AnswerEditFormViewModel>, AnswerEditFormRequestBuilder>();
container.Register <IModelBuilder <AnswerDeleteFormRequest, AnswerDeleteFormViewModel>, AnswerDeleteFormRequestBuilder>();
container.Register <IModelBuilder <HomeByTagRequest, HomeByTagViewModel>, HomeByTagRequestBuilder>();
container.Register <IModelBuilder <HomeRequest, HomeViewModel>, HomeRequestBuilder>();
container.Register <IModelBuilder <QuestionDeleteFormRequest, QuestionDeleteFormViewModel>, QuestionDeleteFormRequestBuilder>();
container.Register <IModelBuilder <QuestionCloseFormRequest, QuestionCloseFormViewModel>, QuestionCloseFormRequestBuilder>();
container.Register <IModelBuilder <QuestionEditFormRequest, QuestionEditFormViewModel>, QuestionEditFormRequestBuilder>();
container.Register <IModelBuilder <QuestionRequest, QuestionViewModel>, QuestionRequestBuilder>();
container.Register <IModelBuilder <TagSuggestionRequest, TagSuggestionsModel>, TagSuggestionRequestBuilder>();
container.Register <IModelBuilder <PopularTagsRequest, PopularTagsViewModel>, PopularTagsRequestBuilder>();
Registration registration = container.GetRegistration(typeof(IMessaging)).Registration;
registration.SuppressDiagnosticWarning(DiagnosticType.DisposableTransientComponent, "Manually disposed");
connect.Wait();
}
