private MemcachedClientApiConfiguration( IEnumerable<IPEndPoint> servers, ISocketPoolConfiguration socketPoolConfiguration, IMemcachedKeyTransformer keyTransformer, IMemcachedNodeLocator nodeLocator, Func<IMemcachedNodeLocator> nodeLocatorFactory, ITranscoder transcoder, IAuthenticationConfiguration authentication, MemcachedProtocol protocol, IPerformanceMonitor performanceMonitor) { Condition.Requires(socketPoolConfiguration, "socket pool configuration").IsNotNull(); Condition.Requires(keyTransformer, "key transformer").IsNotNull(); Condition.Requires(transcoder, "transcoder").IsNotNull(); Condition.Requires(authentication, "authentication").IsNotNull(); Condition.Requires(nodeLocator, "node locator") .Evaluate(!(nodeLocator == null && nodeLocatorFactory == null), "Both node locator and node locator factory are not set. Requires only one to be set."); Condition.Requires(nodeLocator, "node locator") .Evaluate(!(nodeLocator == null && nodeLocatorFactory == null), "Both node locator and node locator are set. Requires only one to be set."); Condition.Requires(servers, "servers").IsNotNull(); _socketPoolConfiguration = socketPoolConfiguration; _keyTransformer = keyTransformer; _nodeLocator = nodeLocator; _nodeLocatorFactory = nodeLocatorFactory; _transcoder = transcoder; _authentication = authentication; PerformanceMonitor = performanceMonitor; Protocol = protocol; _servers = servers.ToList(); }
private static async Task MemcachedProtocol(IServiceProvider serviceProvider) { var loggerFactory = LoggerFactory.Create(builder => { builder.SetMinimumLevel(LogLevel.Error); builder.AddConsole(); }); var client = new ClientBuilder(serviceProvider) .UseSockets() .UseConnectionLogging(loggerFactory: loggerFactory) .Build(); var ipAddress = IPAddress.Parse("127.0.0.1"); var connection = await client.ConnectAsync(new IPEndPoint(ipAddress, 11211)); MemcachedProtocol memcachedProtocol = new MemcachedProtocol(connection); await memcachedProtocol.Set("Hello", Encoding.UTF8.GetBytes("World"), TimeSpan.FromMinutes(30)); var checkSet = await memcachedProtocol.Get("Hello"); Console.WriteLine($"checkSet result :{Encoding.UTF8.GetString(checkSet)}"); await memcachedProtocol.Replace("Hello", Encoding.UTF8.GetBytes("World replaced"), TimeSpan.FromMinutes(30)); var checkReplace = await memcachedProtocol.Get("Hello"); Console.WriteLine($"checkReplace result :{Encoding.UTF8.GetString(checkReplace)}"); }
protected virtual MemcachedClient GetClient(MemcachedProtocol protocol = MemcachedProtocol.Binary, bool useBinaryFormatterTranscoder = false) { IServiceCollection services = new ServiceCollection(); services.AddEnyimMemcached(options => { options.AddServer("memcached", 11211); options.Protocol = protocol; //if (useBinaryFormatterTranscoder) //{ // options.Transcoder = "BinaryFormatterTranscoder"; //} }); if (useBinaryFormatterTranscoder) { services.AddSingleton <ITranscoder, BinaryFormatterTranscoder>(); } services.AddLogging(builder => builder.SetMinimumLevel(LogLevel.Information).AddConsole()); IServiceProvider serviceProvider = services.BuildServiceProvider(); var client = serviceProvider.GetService <IMemcachedClient>() as MemcachedClient; client.Remove("VALUE"); return(client); }
private MemcachedClientApiConfiguration( IEnumerable <IPEndPoint> servers, ISocketPoolConfiguration socketPoolConfiguration, IMemcachedKeyTransformer keyTransformer, IMemcachedNodeLocator nodeLocator, Func <IMemcachedNodeLocator> nodeLocatorFactory, ITranscoder transcoder, IAuthenticationConfiguration authentication, MemcachedProtocol protocol, IPerformanceMonitor performanceMonitor) { Condition.Requires(socketPoolConfiguration, "socket pool configuration").IsNotNull(); Condition.Requires(keyTransformer, "key transformer").IsNotNull(); Condition.Requires(transcoder, "transcoder").IsNotNull(); Condition.Requires(authentication, "authentication").IsNotNull(); Condition.Requires(nodeLocator, "node locator") .Evaluate(!(nodeLocator == null && nodeLocatorFactory == null), "Both node locator and node locator factory are not set. Requires only one to be set."); Condition.Requires(nodeLocator, "node locator") .Evaluate(!(nodeLocator == null && nodeLocatorFactory == null), "Both node locator and node locator are set. Requires only one to be set."); Condition.Requires(servers, "servers").IsNotNull(); _socketPoolConfiguration = socketPoolConfiguration; _keyTransformer = keyTransformer; _nodeLocator = nodeLocator; _nodeLocatorFactory = nodeLocatorFactory; _transcoder = transcoder; _authentication = authentication; PerformanceMonitor = performanceMonitor; Protocol = protocol; _servers = servers.ToList(); }
static Task LaneCaching() { return(Task.WhenAll(Enumerable.Range(0, Sockets).Select(async x => { var builder = new ClientBuilder().UseSockets().Build(); var connection = builder.ConnectAsync(new IPEndPoint(IPAddress.Parse(Destination), 11211)).GetAwaiter().GetResult(); await using (var client = new MemcachedProtocol(new LowLatencyMessageProtocol <MemcachedRequest, IMemcachedResponse>(connection, new MemcachedMessageWriter(), new MemcachedMessageReader()))) { client.Start(); var list = new List <Task>(); for (var i = 0; i < Threads; i++) { list.Add(Task.Run(async() => { await client.Set(Key, Value, null); foreach (var batch in Enumerable.Range(0, Iterations).Batch(200)) { await Task.WhenAll(batch.Select(x => client.Get <string, StringResponseDeserializer>(Key, new StringResponseDeserializer()))); } })); } await Task.WhenAll(list); } }))); }
private static IMemcachedClient GetConfiguredClient(string host, int port, MemcachedProtocol protocol) { Guard.NotEmpty(host, nameof(host)); var config = new MemcachedClientConfiguration(); config.AddServer(host, port); config.Protocol = protocol; return(new MemcachedClient(config)); }
public async Task SetAndGetValue() { var builder = new ClientBuilder().UseSockets().Build(); await using var connection = await builder.ConnectAsync(TestConstants.MemcachedServer); await using var client = new MemcachedProtocol(new LowLatencyMessageProtocol <MemcachedRequest, IMemcachedResponse>(connection, new MemcachedMessageWriter(), new MemcachedMessageReader())); client.Start(); await client.Set("key", "value", null); var value = await client.Get <string, StringResponseDeserializer>("key", new StringResponseDeserializer()); Assert.Equal("value", value); }
public static void AddMemcached( string ip, string port, MemcachedProtocol protocol = MemcachedProtocol.Binary, bool openAuth = false, Dictionary <string, object> authPara = null) { CacheConfiguration.DefaultCacheType = CacheEnum.Memcached; MemcachedAssembleConfig.Ip = ip; MemcachedAssembleConfig.Port = port; MemcachedAssembleConfig.Protocol = protocol; MemcachedAssembleConfig.AuthPara = authPara; MemcachedAssembleConfig.OpenAuth = openAuth; }
protected virtual MemcachedClient GetClient(MemcachedProtocol protocol = MemcachedProtocol.Binary) { IServiceCollection services = new ServiceCollection(); services.AddEnyimMemcached(options => { options.AddServer("memcached", 11211); options.Protocol = protocol; }); services.AddLogging(); IServiceProvider serviceProvider = services.BuildServiceProvider(); var client = serviceProvider.GetService <IMemcachedClient>() as MemcachedClient; client.Remove("VALUE"); return(client); }
public MemCachedProvider(MemcachedProtocol protocol = MemcachedProtocol.Binary) { MemcachedClientConfiguration config = new MemcachedClientConfiguration() { Protocol = protocol }; foreach (string s in readHosts) { config.AddServer(s); } foreach (string s in writeHosts) { config.AddServer(s); } client = new MemcachedClient(config); }
public MemcachedClientConfiguration CreateConfig(List <IPEndPoint> ips, MemcachedProtocol pol) { MemcachedClientConfiguration memConfig = new MemcachedClientConfiguration(); foreach (var ip in ips) { memConfig.Servers.Add(ip); //服务器 } memConfig.Protocol = MemcachedProtocol.Binary; //协议 //文件权限 memConfig.Authentication.Type = typeof(PlainTextAuthenticator); memConfig.Authentication.Parameters["zone"] = ""; //memConfig.Authentication.Parameters["userName"] = "******"; //memConfig.Authentication.Parameters["password"] = "******"; memConfig.SocketPool.MinPoolSize = 5; memConfig.SocketPool.MaxPoolSize = 200; return(memConfig); }
private static async Task MemcachedProtocol(IServiceProvider serviceProvider) { var loggerFactory = LoggerFactory.Create(builder => { builder.SetMinimumLevel(LogLevel.Debug); builder.AddConsole(); }); var client = new ClientBuilder(serviceProvider) .UseSockets() /* .UseConnectionLogging(loggerFactory: loggerFactory)*/ .Build(); var ipAddress = IPAddress.Parse("127.0.0.1"); var connection = await client.ConnectAsync(new IPEndPoint(ipAddress, 11211)); MemcachedProtocol memcachedProtocol = new MemcachedProtocol(connection); var largeString = String.Empty; var tasks = new List <Task <byte[]> >(); for (int i = 0; i < 10; i++) { largeString += i + "_"; } //await memcachedProtocol.Set("Hello", Encoding.UTF8.GetBytes(largeString), TimeSpan.FromMinutes(30)); /*for (int i = 0; i < 10; i++) * { * tasks.Add(memcachedProtocol.Get("Hello")); * } * * await memcachedProtocol.Set("Hello", Encoding.UTF8.GetBytes("World!!"), TimeSpan.FromMinutes(30)); * await Task.WhenAll(tasks); * * foreach (var item in tasks) * { * Console.WriteLine(Encoding.UTF8.GetString(item.Result)); * Console.WriteLine("-------------------------------"); * } */ Console.WriteLine("Complete"); //var byteResult = await memcachedProtocol.Get("Hello"); //var result = Encoding.UTF8.GetString(byteResult); }
public async Task DeleteAKey() { var builder = new ClientBuilder().UseSockets().Build(); await using var connection = await builder.ConnectAsync(TestConstants.MemcachedServer); await using var client = new MemcachedProtocol(new LowLatencyMessageProtocol <MemcachedRequest, IMemcachedResponse>(connection, new MemcachedMessageWriter(), new MemcachedMessageReader())); client.Start(); var key = "ToDelete"; await client.Set(key, "value", null); var value = await client.Get <string, StringResponseDeserializer>(key, new StringResponseDeserializer()); Assert.Equal("value", value); await client.Delete(key); await Assert.ThrowsAsync <KeyNotFoundException>(() => client.Get <string, StringResponseDeserializer>(key, new StringResponseDeserializer())); }
protected virtual MemcachedClient GetClient(IServiceCollection services, MemcachedProtocol protocol = MemcachedProtocol.Binary, bool useBinaryFormatterTranscoder = false) { services.AddEnyimMemcached(options => { options.AddServer("memcached", 11211); options.Protocol = protocol; //if (useBinaryFormatterTranscoder) //{ // options.Transcoder = "BinaryFormatterTranscoder"; //} }); if (useBinaryFormatterTranscoder) { services.AddSingleton <ITranscoder, BinaryFormatterTranscoder>(); } IServiceProvider serviceProvider = services.BuildServiceProvider(); var client = serviceProvider.GetService <IMemcachedClient>() as MemcachedClient; client.Remove("VALUE"); return(client); }
private async Task RunLaneCache(Func <ConnectionContext, IMessageProtocol <MemcachedRequest, IMemcachedResponse> > protocol) { var builder = new ClientBuilder().UseSockets().Build(); var connection = await builder.ConnectAsync(new IPEndPoint(IPAddress.Parse("10.0.0.21"), 11211)); await using var client = new MemcachedProtocol(protocol(connection)); client.Start(); var list = new List <Task>(); for (var i = 0; i < Threads; i++) { list.Add(Task.Run(async() => { await client.Set(Key, Value, null); foreach (var batch in Enumerable.Range(0, Iterations).Batch(200)) { await Task.WhenAll(batch.Select(x => client.Get <string, StringResponseDeserializer>(Key, new StringResponseDeserializer()))); } })); } await Task.WhenAll(list); }
public async Task ReplaceValue() { var builder = new ClientBuilder().UseSockets().Build(); await using var connection = await builder.ConnectAsync(TestConstants.MemcachedServer); await using var client = new MemcachedProtocol(new LowLatencyMessageProtocol <MemcachedRequest, IMemcachedResponse>(connection, new MemcachedMessageWriter(), new MemcachedMessageReader())); client.Start(); var key = "ToReplace"; await client.Set(key, "firstValue", null); var value = await client.Get <string, StringResponseDeserializer>(key, new StringResponseDeserializer()); Assert.Equal("firstValue", value); await client.Replace(new StringWritable(key), new StringWritable("newValue"), null); var replaced = await client.Get <string, StringResponseDeserializer>(key, new StringResponseDeserializer()); Assert.Equal("newValue", replaced); }
public async Task ExpireQuickly() { var builder = new ClientBuilder().UseSockets().Build(); await using var connection = await builder.ConnectAsync(TestConstants.MemcachedServer); await using var client = new MemcachedProtocol(new LowLatencyMessageProtocol <MemcachedRequest, IMemcachedResponse>(connection, new MemcachedMessageWriter(), new MemcachedMessageReader())); client.Start(); var key = "ToExpire"; var expirationTime = TimeSpan.FromSeconds(2); await client.Set(key, "firstValue", expirationTime); var value = await client.Get <string, StringResponseDeserializer>(key, new StringResponseDeserializer()); Assert.Equal("firstValue", value); // memcached expires entries on 1-second boundaries, so setting this to n+1 seconds expiration may cause the test to fail some of the time await Task.Delay(expirationTime.Add(TimeSpan.FromSeconds(2))); await Assert.ThrowsAsync <KeyNotFoundException>(() => client.Get <string, StringResponseDeserializer>(key, new StringResponseDeserializer())); }
/// <summary> /// Initializes a new instance of the <see cref="MemcachedCacheProvider" /> class. /// </summary> /// <param name="host">The host name.</param> /// <param name="port">The port.</param> /// <param name="username">The username to use to authenticate with the server.</param> /// <param name="password">The password to use to authenticate with the server.</param> /// <param name="protocol">The type of the communication between client and server.</param> public MemcachedCacheProvider([NotNull] string host, int port, [NotNull] string username, [NotNull] string password, MemcachedProtocol protocol) : this(host, port, username, password, protocol, (TimeSpan?)null) { }
private static IMemcachedClientConfiguration GetClientConfiguration(string host, string username, string password, MemcachedProtocol protocol, Type authType = null) { var config = new MemcachedClientConfiguration(); if (!string.IsNullOrEmpty(host)) { config.AddServer(host); } config.Protocol = protocol; config.Authentication.Type = authType; if (!string.IsNullOrEmpty(username)) { config.Authentication.Parameters["userName"] = username; } if (!string.IsNullOrEmpty(password)) { config.Authentication.Parameters["password"] = password; } return(config); }
public MemcachedCacheProvider(string host, string username, string password, MemcachedProtocol protocol, Type authType, TimeSpan?expiry, JsonSerializerSettings serializerSettings) : this(GetClientConfiguration(host, username, password, protocol, authType), expiry, serializerSettings) { }
private static IMemcachedClient GetConfiguredClient(string host, int port, string username, string password, MemcachedProtocol protocol) { Guard.NotEmpty(host, nameof(host)); Guard.NotEmpty(username, nameof(username)); Guard.NotEmpty(password, nameof(password)); var config = new MemcachedClientConfiguration(); config.AddServer(host, port); config.Protocol = protocol; config.Authentication.Type = typeof(PlainTextAuthenticator); config.Authentication.Parameters["userName"] = username; config.Authentication.Parameters["password"] = password; return(new MemcachedClient(config)); }
/// <summary> /// Initializes a new instance of the <see cref="MemcachedCacheProvider" /> class. /// </summary> /// <param name="host">The host name.</param> /// <param name="port">The port.</param> /// <param name="protocol">The type of the communication between client and server.</param> public MemcachedCacheProvider([NotNull] string host, int port, MemcachedProtocol protocol) : this(host, port, protocol, (TimeSpan?)null) { }
/// <summary> /// Adds the giving protocal to the options. /// </summary> /// <param name="protocal">The protocal to be added.</param> public MemcachedCacheOptions WithProtocal([NotNull] MemcachedProtocol protocal) { _protocal = Guard.NotNull(protocal, nameof(protocal)); return(this); }
/// <summary> /// Initializes a new instance of the <see cref="MemcachedCacheProvider" /> class. /// </summary> /// <param name="host">The host name.</param> /// <param name="port">The port.</param> /// <param name="protocol">The type of the communication between client and server.</param> /// <param name="expiry">The caching expiration time.</param> public MemcachedCacheProvider([NotNull] string host, int port, MemcachedProtocol protocol, [CanBeNull] TimeSpan?expiry) : this(GetConfiguredClient(host, port, protocol), expiry) { }