private Redis() { try { redis = ConnectionMultiplexer.Connect("localhost"); DB = redis.GetDatabase(); } catch (RedisConnectionException rce) { ProcessStartInfo startInfo = new ProcessStartInfo(); startInfo.Arguments = Environment.CurrentDirectory + @"\redis\redis.windows.conf"; startInfo.FileName = Environment.CurrentDirectory + @"\redis\redis-server.exe"; startInfo.WorkingDirectory = Environment.CurrentDirectory + @"\redis\"; Process p = Process.Start(startInfo); Thread.Sleep(200); for (int i = 0; i < 3; ++i) { try { redis = ConnectionMultiplexer.Connect("localhost"); DB = redis.GetDatabase(); break; } catch (RedisConnectionException rce2) { Thread.Sleep(1000); } } } }
/// <summary> /// Initializes a new instance of the <see cref="RedisCache"/> class. /// </summary> /// <param name="configuration">The configuration.</param> public RedisCache(ConfigurationOptions configuration) { if (RedisCache.connection == null) { try { connectionTask = ConnectionMultiplexer.ConnectAsync(configuration); connectionTask.ContinueWith(t => { lock (syncronizationObject) { if (RedisCache.connection == null) RedisCache.connection = t.Result; } this.cache = RedisCache.connection.GetDatabase(); Trace.TraceInformation("Redis Cache Provider connection complete - Correlation Id = {0}", Trace.CorrelationManager.ActivityId); }); } catch (AggregateException age) { age.Handle(e => { Trace.TraceError("Redis Cache Provider error - Correlation Id = {0}\n {1}\n {2}", Trace.CorrelationManager.ActivityId, e.Message, e.StackTrace); return true; }); } catch (Exception ex) { Trace.TraceError("Redis Cache Provider exception - Correlation Id = {0}\n {1}\n {2}", Trace.CorrelationManager.ActivityId, ex.Message, ex.StackTrace); } } }
public MessagesController(ApplicationDbContext context, UserManager<ApplicationUser> userManager, MapperConfiguration mapperConfiguration, ConnectionMultiplexer redis) { _context = context; _userManager = userManager; _mapperConfiguration = mapperConfiguration; _redis = redis; }
public RedisCache(string regionName, IDictionary<string, string> properties, RedisCacheElement element, ConnectionMultiplexer connectionMultiplexer, RedisCacheProviderOptions options) { this.connectionMultiplexer = connectionMultiplexer.ThrowIfNull("connectionMultiplexer"); this.options = options.ThrowIfNull("options").ShallowCloneAndValidate(); RegionName = regionName.ThrowIfNull("regionName"); if (element == null) { expiry = TimeSpan.FromSeconds( PropertiesHelper.GetInt32(Cfg.Environment.CacheDefaultExpiration, properties, DefaultExpiry) ); } else { expiry = element.Expiration; } log.DebugFormat("using expiration : {0} seconds", expiry.TotalSeconds); var @namespace = CacheNamePrefix + RegionName; CacheNamespace = new RedisNamespace(@namespace); SyncInitialGeneration(); }
public static ConnectionMultiplexer RetrieveMultiplexer(ConfigurationOptions config) { if(_multiplexer != null) return _multiplexer; _multiplexer = ConnectionMultiplexer.Connect(config); return _multiplexer; }
public static ConnectionMultiplexer RetrieveMultiplexer(string connectionString) { if(_multiplexer != null) return _multiplexer; _multiplexer = ConnectionMultiplexer.Connect(connectionString); return _multiplexer; }
public StackExchange.Redis.ConnectionMultiplexer Create() { Logger.Info("Connect to Redis."); if (instance != null && instance.IsConnected) { Logger.Info("Redis is connected 1"); return instance; } lock (LockObject) { if (instance != null && instance.IsConnected) { Logger.Info("Redis is connected 2"); return instance; } if (instance != null) { instance.Dispose(); Logger.Info("Connection disconnected. Disposing connection..."); } instance = ConnectionMultiplexer.Connect(redisConnectionString); Logger.Info("Creating new instance of Redis Connection"); } return instance; }
public RedisStorage(string connectionString, RedisStorageOptions options = null) { if (connectionString == null) throw new ArgumentNullException("connectionString"); if (options == null) options = new RedisStorageOptions(); _connectionMultiplexer = ConnectionMultiplexer.Connect(connectionString); _invisibilityTimeout = options.InvisibilityTimeout; var endpoint = _connectionMultiplexer.GetEndPoints()[0]; if (endpoint is IPEndPoint) { var ipEp = endpoint as IPEndPoint; ConnectionString = string.Format("{0}:{1}", TryGetHostName(ipEp.Address), ipEp.Port); } else { var dnsEp = endpoint as DnsEndPoint; ConnectionString = string.Format("{0}:{1}", dnsEp.Host, dnsEp.Port); } Db = options.Db; if (Prefix != options.Prefix) { Prefix = options.Prefix; } identity = Guid.NewGuid().ToString(); }
public RedisSubscriptionBroker(ConnectionMultiplexer connection, string prefix) { this.connection = connection; this.subscriptionChannel = string.Format("{0}.subscriptions.broker", prefix); this.handlers = new ConcurrentBag<Action<SubscriptionChange, Subscription>>(); this.initializationTask = new Lazy<Task>(() => this.Initialize()); }
static RedisCacheConfig() { string isLocal = WebConfigReader.Read("IsLocal"); if (isLocal == "1") { connection = ConnectionMultiplexer.Connect(WebConfigReader.Read("RedisServer")); } else { var options = new ConfigurationOptions(); options.EndPoints.Add(WebConfigReader.Read("RedisKeyDns"), 6380); options.Ssl = true; options.Password = WebConfigReader.Read("RedisPassword"); options.AllowAdmin = true; // necessary? options.KeepAlive = 30; options.ConnectTimeout = 15000; options.SyncTimeout = 15000; connection = ConnectionMultiplexer.Connect(options); } }
/// <summary> /// Construct a new redis connection (which will be actually setup on demand) /// with an object to synchronize access on. /// </summary> public AsyncRedisConnection(string tier, string delimitedConfiguration, Func<bool> shouldPromoteSlaveToMaster, string tieBreakerKey, string name, bool preserveAsyncOrder = false, bool shareSocketManager = false, TextWriter log = null) { if (log != null) log.WriteLine("{0} > AsyncRedisConnection", DateTime.UtcNow.ToShortDateString()); var options = ConfigurationOptions.Parse(delimitedConfiguration, true); muxer = Create(tier, options, tieBreakerKey, name, preserveAsyncOrder, shareSocketManager, log, out subscriber); if (log != null) log.WriteLine("{0} < AsyncRedisConnection", DateTime.UtcNow.ToShortDateString()); }
public async Task OpenAsync(PartitionContext context) { if (!WebJobsHelper.RunAsWebJobs) Console.WriteLine(string.Format("EventProcessor initialization. Partition: '{0}', Offset: '{1}'", context.Lease.PartitionId, context.Lease.Offset)); partitionContext = context; var retries = 3; while (retries > 0) { try { retries--; hubClient = EventHubClient.CreateFromConnectionString( ConfigurationManager.ConnectionStrings["SigfoxDemoAlertSender"].ConnectionString, "alert"); cacheConnection = await ConnectionMultiplexer.ConnectAsync(ConfigurationManager.ConnectionStrings["SigfoxDemoCache"].ConnectionString); cacheDatabase = cacheConnection.GetDatabase(); sqlConnection = new SqlConnection(ConfigurationManager.ConnectionStrings["SigfoxDemoDatabase"].ConnectionString); //sqlConnection.Open(); //sqlCommand = new SqlCommand("InsertAlert", sqlConnection) { CommandType = CommandType.StoredProcedure }; //sqlCommand.Parameters.Add(new SqlParameter("@Device", SqlDbType.VarChar)); retries = 0; } catch (Exception e) { Console.Error.WriteLine("Error opening destination Event Hub: " + e.Message); if (retries == 0) throw; } } checkpointStopWatch = new Stopwatch(); checkpointStopWatch.Start(); }
public static void Init(string sHost, int iPort, string sPassword) { CacheDatabase._Host = sHost; CacheDatabase._Port = iPort; CacheDatabase._Password = sPassword; if (CacheDatabase._Password.Length > 0) { CacheDatabase._AuthRequired = true; } else { CacheDatabase._AuthRequired = false; } _oConectionOptions = new ConfigurationOptions(); if (CacheDatabase._AuthRequired) { CacheDatabase._oConectionOptions.Password = CacheDatabase._Password; } CacheDatabase._oConectionOptions.EndPoints.Add(CacheDatabase._Host + ":" + CacheDatabase._Port.ToString()); CacheDatabase._oCacheConnection = ConnectionMultiplexer.Connect(CacheDatabase._oConectionOptions); CacheDatabase._oCommand = CacheDatabase._oCacheConnection.GetDatabase(); //Check to make sure the Key Exists and if not then set it to 0 if (!_oCommand.KeyExists(CacheDatabase._ObjectCounterKeyName)) { CacheDatabase._oCommand.StringSet(CacheDatabase._ObjectCounterKeyName, 0); } }
public RedisAdaptor(List<EndPoint> endPoints) { var config = new ConfigurationOptions() { AllowAdmin = true, }; foreach (var endPoint in endPoints) { config.EndPoints.Add(endPoint); } muxerInstance = ConnectionMultiplexer.Connect(config); Handle = muxerInstance.GetDatabase(); var script = Load("update_multikeys_multifields.lua"); //todo a hack way .. to be changed later foreach (var endPoint in muxerInstance.GetEndPoints()) { var server = muxerInstance.GetServer(endPoint); updateScriptSha = server.ScriptLoad(script); } Handle.StringSet("test", "111"); }
internal WorkflowManagement(ConnectionMultiplexer mux, ITaskHandler taskHandler, WorkflowHandler workflowHandler, string identifier, IEnumerable<string> typesProcessed, ILua lua, EventHandler<Exception> exceptionHandler = null, Behaviours behaviours = Behaviours.All) { _taskHandler = taskHandler; _workflowHandler = workflowHandler; if (exceptionHandler != null) { ExceptionThrown += exceptionHandler; } _typesProcessed = typesProcessed; _db = mux.GetDatabase(); _sub = mux.GetSubscriber(); if (_typesProcessed == null || _typesProcessed.Count() == 0) { _sub.Subscribe("submittedTask", (c, v) => { ProcessNextTask(); }); } else { foreach(var t in _typesProcessed) { _sub.Subscribe("submittedTask:" + t, (c, v) => { ProcessNextTask(t); }); } } _sub.Subscribe("workflowFailed", (c, v) => { ProcessNextFailedWorkflow(); }); _sub.Subscribe("workflowComplete", (c, v) => { ProcessNextCompleteWorkflow(); }); _lua = lua; _lua.LoadScripts(_db, mux.GetServer("localhost:6379")); _identifier = identifier; if (behaviours.HasFlag(Behaviours.AutoRestart)) { var resubmittedTasks = ResubmitTasks(); foreach (var item in resubmittedTasks) { Console.WriteLine("Resubmitted {0}", item); } } }
public WatcherManager(IEnumerable<WatchGroup> groups) { var groupList = groups.ToList(); var config = new ConfigurationOptions() { AllowAdmin = true, }; foreach (var group in groupList) { config.EndPoints.Add(group.Master.EndPoint); } muxerInstance = ConnectionMultiplexer.Connect(config); muxerInstance.ConnectionRestored += MuxerInstanceOnConnectionRestored; foreach (var group in groupList) { var server = muxerInstance.GetServer(group.Master.EndPoint); var epStr = server.EndPoint.ToString(); group.Master.Server = server; group.Master.OnPing(TimeSpan.Zero); Program.zkAdaptor.Identity(group.Master.EndPoint.ToString()); this.groups.Add(epStr, group); redisInstancesDict.Add(epStr, group.Master); } }
public RedisManager() { var configurationOptions = new ConfigurationOptions {Password = "******"}; configurationOptions.EndPoints.Add(HostAndPort); _redisConn = ConnectionMultiplexer.Connect(configurationOptions); }
public static void Connect() { ConfigurationOptions options = new ConfigurationOptions(); options.EndPoints.Add("localhost:6379"); Connection = ConnectionMultiplexer.Connect(options); }
/// <summary> /// Use Redis as the messaging backplane for scaling out of ASP.NET SignalR applications in a web farm. /// </summary> /// <param name="resolver">The dependency resolver</param> /// <param name="configuration">The Redis scale-out configuration options.</param> /// <param name="sharedMultiplexer">shared multiplexer</param> /// <returns>The dependency resolver.</returns> public static IDependencyResolver UseRedis(this IDependencyResolver resolver, RedisScaleoutConfiguration configuration, ConnectionMultiplexer sharedMultiplexer) { var bus = new Lazy<RedisMessageBus>(() => new RedisMessageBus(resolver, configuration, new RedisConnection(sharedMultiplexer))); resolver.Register(typeof(IMessageBus), () => bus.Value); return resolver; }
public MainForm() { InitializeComponent(); var options = new ConfigurationOptions { ConnectTimeout = 5000, SyncTimeout = 2000, KeepAlive = 60, EndPoints = { {Settings.Default.RedisHost, Settings.Default.RedisPort} } }; _redis = ConnectionMultiplexer.Connect(options); var retries = 0; while (!_redis.IsConnected) { var config = _redis.Configuration; _redis.Dispose(); if (retries > 10) { MessageBox.Show(string.Format("Could not connect to the Redis server with configuration: {0}", config)); Application.Exit(); } _redis = ConnectionMultiplexer.Connect(options, Console.Out); retries++; } _red = new LightControlSet(button_RedOn, button_RedOff, button_RedFlash, textBox_RedOnDuty, textBox_RedOffDuty, textBox_RedOffset, textBox_RedPower, button_RedApply); _green = new LightControlSet(button_GreenOn, button_GreenOff, button_GreenFlash, textBox_GreenOnDuty, textBox_GreenOffDuty, textBox_GreenOffset, textBox_GreenPower, button_GreenApply); _blueYellow = new LightControlSet(button_BlueOn, button_BlueOff, button_BlueFlash, textBox_BlueOnDuty, textBox_BlueOffDuty, textBox_BlueOffset, textBox_BluePower, button_BlueApply); }
public RedisEntityTagStore(ConnectionMultiplexer connection, int databaseId = 0, TimeSpan? expiry = null) { _expiry = expiry; Init(connection, databaseId); }
/// <summary> /// Constructor. /// </summary> public AbpRedisCache(string name, IAbpRedisConnectionProvider redisConnectionProvider, AbpRedisCacheConfig config) : base(name) { _config = config; var connectionString = redisConnectionProvider.GetConnectionString(_config.ConnectionStringKey); _connectionMultiplexer = redisConnectionProvider.GetConnection(connectionString); }
public async Task OpenAsync(PartitionContext context) { if (!WebJobsHelper.RunAsWebJobs) Console.WriteLine(string.Format("EventProcessor initialization. Partition: '{0}', Offset: '{1}'", context.Lease.PartitionId, context.Lease.Offset)); partitionContext = context; var retries = 3; while (retries > 0) { var s = string.Empty; try { retries--; s = "storage"; storageAccount = CloudStorageAccount.Parse(ConfigurationManager.ConnectionStrings["SigfoxDemoStorage"].ConnectionString); var blobClient = storageAccount.CreateCloudBlobClient(); blobContainer = blobClient.GetContainerReference("device"); blobContainer.SetPermissions(new BlobContainerPermissions() { PublicAccess = BlobContainerPublicAccessType.Off }); blobContainer.CreateIfNotExists(); s = "cache"; cacheConnection = await ConnectionMultiplexer.ConnectAsync(ConfigurationManager.ConnectionStrings["SigfoxDemoCache"].ConnectionString); cacheDatabase = cacheConnection.GetDatabase(); s = "database"; sqlConnection = new SqlConnection(ConfigurationManager.ConnectionStrings["SigfoxDemoDatabase"].ConnectionString); sqlConnection.Open(); sqlCommand = new SqlCommand("InsertMessage", sqlConnection) { CommandType = CommandType.StoredProcedure }; sqlCommand.Parameters.Add(new SqlParameter("@Device", SqlDbType.VarChar)); sqlCommand.Parameters.Add(new SqlParameter("@Data", SqlDbType.VarChar)); sqlCommand.Parameters.Add(new SqlParameter("@Mode", SqlDbType.TinyInt)); sqlCommand.Parameters.Add(new SqlParameter("@Periode", SqlDbType.TinyInt)); sqlCommand.Parameters.Add(new SqlParameter("@FrameType", SqlDbType.TinyInt)); sqlCommand.Parameters.Add(new SqlParameter("@Battery", SqlDbType.Float)); sqlCommand.Parameters.Add(new SqlParameter("@Temperature", SqlDbType.Float)); sqlCommand.Parameters.Add(new SqlParameter("@Humidity", SqlDbType.Float)); sqlCommand.Parameters.Add(new SqlParameter("@ILS", SqlDbType.Bit)); sqlCommand.Parameters.Add(new SqlParameter("@Light", SqlDbType.Float)); sqlCommand.Parameters.Add(new SqlParameter("@Version", SqlDbType.VarChar)); sqlCommand.Parameters.Add(new SqlParameter("@AlertCount", SqlDbType.Int)); sqlCommand.Parameters.Add(new SqlParameter("@TimeStamp", SqlDbType.DateTime)); sqlCommand.Parameters.Add(new SqlParameter("@Duplicate", SqlDbType.Bit)); sqlCommand.Parameters.Add(new SqlParameter("@Signal", SqlDbType.Float)); sqlCommand.Parameters.Add(new SqlParameter("@Station", SqlDbType.VarChar)); sqlCommand.Parameters.Add(new SqlParameter("@AvgSignal", SqlDbType.Float)); sqlCommand.Parameters.Add(new SqlParameter("@Latitude", SqlDbType.Float)); sqlCommand.Parameters.Add(new SqlParameter("@Longitude", SqlDbType.Float)); sqlCommand.Parameters.Add(new SqlParameter("@Rssi", SqlDbType.Float)); sqlCommand.Parameters.Add(new SqlParameter("@SeqNumber", SqlDbType.Int)); retries = 0; } catch (Exception e) { Console.Error.WriteLine("Error opening destination Event Hub: " + e.Message + "(" + s + ")"); if (retries == 0) throw; } } checkpointStopWatch = new Stopwatch(); checkpointStopWatch.Start(); }
public StackExchange.Redis.ConnectionMultiplexer GetClient() { StackExchange.Redis.ConfigurationOptions option = new StackExchange.Redis.ConfigurationOptions(); option.EndPoints.Add(_redisOption.RedisIP, Int32.Parse(_redisOption.RedisPort)); option.DefaultDatabase = 1; StackExchange.Redis.ConnectionMultiplexer conn = StackExchange.Redis.ConnectionMultiplexer.Connect(option); return(conn); }
public RedisClient(RedisConnectionManager connectionManager) { _connectionectionManager = connectionManager; if (_connection == null) { _connection = _connectionectionManager.GetConnection(); } }
public PhysicalBridge(ServerEndPoint serverEndPoint, ConnectionType type) { this.serverEndPoint = serverEndPoint; this.connectionType = type; this.multiplexer = serverEndPoint.Multiplexer; this.Name = Format.ToString(serverEndPoint.EndPoint) + "/" + connectionType.ToString(); this.completionManager = new CompletionManager(multiplexer, Name); }
public RedisConnectionFactory(ConnectionMultiplexer conn, ConfigurationOptions configuration, JsonSerializerSettings jsonSerializerSettings) { _configurationOptions = configuration; _jsonSerializerSettings = jsonSerializerSettings; _conn = conn; if (!_conn.IsConnected) _conn = ConnectionMultiplexer.Connect(_configurationOptions); //TO DO - add other config options }
public DataService(StackExchange.Redis.ConnectionMultiplexer redis, DistributedLockService distributedLockService, MongoClient mongoClient, string redisDownloadListKey, string mongoDownloadCollectionName) { this.redis = redis; this.distributedLockService = distributedLockService; this.mongoClient = mongoClient; this.redisDownloadListKey = redisDownloadListKey; this.mongoDownloadCollectionName = mongoDownloadCollectionName; }
static RedisSessionStateStoreProvider() { ConnectionMultiplexer = ConnectionMultiplexer.Connect(new ConfigurationOptions { EndPoints = { ConfigurationManager.AppSettings["RedisServer"] }, ConnectTimeout = 30 * 1000 }); }
public async Task ConnectAsync() { if (_connection == null) { _connection = await ConnectionMultiplexer.ConnectAsync(_options.Configuration); _cache = _connection.GetDatabase(); } }
public void Connect() { if (_connection == null) { _connection = ConnectionMultiplexer.Connect(_options.Configuration); _cache = _connection.GetDatabase(); } }
public RedisOutputCacheStorageProvider(ShellSettings shellSettings, IRedisConnectionProvider redisConnectionProvider) { _shellSettings = shellSettings; _redisConnectionProvider = redisConnectionProvider; _connectionString = _redisConnectionProvider.GetConnectionString(ConnectionStringKey); _connectionMultiplexer = _redisConnectionProvider.GetConnection(_connectionString); Logger = NullLogger.Instance; }
static void CleanRedis() { connection = Redis.ConnectionMultiplexer.Connect("localhost,allowAdmin=true"); server = connection.GetServer("localhost", 6379); server.FlushDatabase(); db = connection.GetDatabase(); }
/// <summary> /// Gets the servers. /// </summary> /// <param name="muxer">The muxer.</param> /// <returns>The list of servers.</returns> public IEnumerable <StackRedis.IServer> GetServers(StackRedis.ConnectionMultiplexer muxer) { EndPoint[] endpoints = muxer.GetEndPoints(); foreach (var endpoint in endpoints) { var server = muxer.GetServer(endpoint); yield return(server); } }
static string getTokenDetails(string Key) { Redis.ConnectionMultiplexer connection = Redis.ConnectionMultiplexer.Connect("localhost,password=ZLDe3wse"); Redis.IDatabase db = connection.GetDatabase(); Redis.RedisValue Value = db.StringGet(Key); return(Value); }
private void InitRedisDb() { if (_redisDb == null) { StackExchange.Redis.ConnectionMultiplexer cm = ConnectionMultiplexer.Connect("127.0.0.1:6379"); _redisDb = cm.GetDatabase(1); } }
public async Task Init(IPEndPoint endpoint, System.Threading.CancellationToken cancel) { _connection = await StackExchange.Redis.ConnectionMultiplexer.ConnectAsync(endpoint.ToString()).ConfigureAwait(false); var db = _connection.GetDatabase(); var data = Enumerable.Range(0, 10).Select(i => (RedisValue)i.ToString("0000000000")).ToArray(); db.SetAdd("testkeySER", data); db.SetAdd("testkeySER2", data); db.StringSet("testkeySER3", "hi this is a test"); }
public string Post([FromBody] string value) { var id = Guid.NewGuid().ToString(); try { StackExchange.Redis.ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost"); StackExchange.Redis.IDatabase redisDb = redis.GetDatabase(); this.SaveDataToRedis(redisDb, id, value); this.makeEvent(redis, id, value); } catch (Exception e) { Console.WriteLine(e.Message); } return(id); }
internal static void Run(StackExchange.Redis.ConnectionMultiplexer redis) { Redis = redis; var sub = Redis.GetSubscriber(); Console.Clear(); Refresh(); while ((!Console.KeyAvailable) || (Console.ReadKey().Key != ConsoleKey.Escape)) { Refresh(); Thread.Sleep(1500); } }
internal static void Run(StackExchange.Redis.ConnectionMultiplexer redis) { Console.WriteLine("Hit <ESC> to shutdown this worker."); Redis = redis; while ((!Console.KeyAvailable) || (Console.ReadKey().Key != ConsoleKey.Escape)) { var msg = Redis.GetDatabase().ListLeftPop(Tools.WORKQUEUE); if (!msg.IsNullOrEmpty) { HandleClusterWork(msg); } else { Thread.Sleep(0); } } }
private void UnexpectedResponse(Message message, RawResult result) { ConnectionMultiplexer.TraceWithoutContext("From " + GetType().Name, "Unexpected Response"); ConnectionFail(message, ConnectionFailureType.ProtocolFailure, "Unexpected response to " + (message == null ? "n/a" : message.Command.ToString()) + ": " + result.ToString()); }
public ServerSelectionStrategy(ConnectionMultiplexer multiplexer) { this.multiplexer = multiplexer; }
bool ICompletable.TryComplete(bool isAsync) => ConnectionMultiplexer.TryCompleteHandler(handler, sender, this, isAsync);
internal static Exception Timeout(ConnectionMultiplexer mutiplexer, string baseErrorMessage, Message message, ServerEndPoint server, WriteResult?result = null) { List <Tuple <string, string> > data = new List <Tuple <string, string> > { Tuple.Create("Message", message.CommandAndKey) }; var sb = new StringBuilder(); if (!string.IsNullOrEmpty(baseErrorMessage)) { sb.Append(baseErrorMessage); if (message != null) { sb.Append(", command=").Append(message.Command); // no key here, note } } else { sb.Append("Timeout performing ").Append(message.Command).Append(" (").Append(Format.ToString(mutiplexer.TimeoutMilliseconds)).Append("ms)"); } void add(string lk, string sk, string v) { if (v != null) { if (lk != null) { data.Add(Tuple.Create(lk, v)); } if (sk != null) { sb.Append(", ").Append(sk).Append(": ").Append(v); } } } // Add timeout data, if we have it if (result == WriteResult.TimeoutBeforeWrite) { add("Timeout", "timeout", Format.ToString(mutiplexer.TimeoutMilliseconds)); try { #if DEBUG if (message.QueuePosition >= 0) { add("QueuePosition", null, message.QueuePosition.ToString()); // the position the item was when added to the queue } if ((int)message.ConnectionWriteState >= 0) { add("WriteState", null, message.ConnectionWriteState.ToString()); // what the physical was doing when it was added to the queue } #endif if (message != null && message.TryGetPhysicalState(out var ws, out var rs, out var sentDelta, out var receivedDelta)) { add("Write-State", null, ws.ToString()); add("Read-State", null, rs.ToString()); // these might not always be available if (sentDelta >= 0) { add("OutboundDeltaKB", "outbound", $"{sentDelta >> 10}KiB"); } if (receivedDelta >= 0) { add("InboundDeltaKB", "inbound", $"{receivedDelta >> 10}KiB"); } } } catch { } } if (message != null) { message.TryGetHeadMessages(out var now, out var next); if (now != null) { add("Message-Current", "active", mutiplexer.IncludeDetailInExceptions ? now.CommandAndKey : now.Command.ToString()); } if (next != null) { add("Message-Next", "next", mutiplexer.IncludeDetailInExceptions ? next.CommandAndKey : next.Command.ToString()); } } // Add server data, if we have it if (server != null) { server.GetOutstandingCount(message.Command, out int inst, out int qs, out long @in, out int qu, out bool aw, out long toRead, out long toWrite, out var bs, out var rs, out var ws); add("OpsSinceLastHeartbeat", "inst", inst.ToString()); add("Queue-Awaiting-Write", "qu", qu.ToString()); add("Queue-Awaiting-Response", "qs", qs.ToString()); add("Active-Writer", "aw", aw.ToString()); if (qu != 0) { add("Backlog-Writer", "bw", bs.ToString()); } if (rs != PhysicalConnection.ReadStatus.NA) { add("Read-State", "rs", rs.ToString()); } if (ws != PhysicalConnection.WriteStatus.NA) { add("Write-State", "ws", ws.ToString()); } if (@in >= 0) { add("Inbound-Bytes", "in", @in.ToString()); } if (toRead >= 0) { add("Inbound-Pipe-Bytes", "in-pipe", toRead.ToString()); } if (toWrite >= 0) { add("Outbound-Pipe-Bytes", "out-pipe", toWrite.ToString()); } if (mutiplexer.StormLogThreshold >= 0 && qs >= mutiplexer.StormLogThreshold && Interlocked.CompareExchange(ref mutiplexer.haveStormLog, 1, 0) == 0) { var log = server.GetStormLog(message.Command); if (string.IsNullOrWhiteSpace(log)) { Interlocked.Exchange(ref mutiplexer.haveStormLog, 0); } else { Interlocked.Exchange(ref mutiplexer.stormLogSnapshot, log); } } add("Server-Endpoint", "serverEndpoint", server.EndPoint.ToString()); } add("Manager", "mgr", mutiplexer.SocketManager?.GetState()); add("Client-Name", "clientName", mutiplexer.ClientName); var hashSlot = message.GetHashSlot(mutiplexer.ServerSelectionStrategy); // only add keyslot if its a valid cluster key slot if (hashSlot != ServerSelectionStrategy.NoSlot) { add("Key-HashSlot", "PerfCounterHelperkeyHashSlot", message.GetHashSlot(mutiplexer.ServerSelectionStrategy).ToString()); } int busyWorkerCount = PerfCounterHelper.GetThreadPoolStats(out string iocp, out string worker); add("ThreadPool-IO-Completion", "IOCP", iocp); add("ThreadPool-Workers", "WORKER", worker); data.Add(Tuple.Create("Busy-Workers", busyWorkerCount.ToString())); if (mutiplexer.IncludePerformanceCountersInExceptions) { add("Local-CPU", "Local-CPU", PerfCounterHelper.GetSystemCpuPercent()); } add("Version", "v", GetLibVersion()); sb.Append(" (Please take a look at this article for some common client-side issues that can cause timeouts: "); sb.Append(timeoutHelpLink); sb.Append(")"); var ex = new RedisTimeoutException(sb.ToString(), message?.Status ?? CommandStatus.Unknown) { HelpLink = timeoutHelpLink }; if (data != null) { var exData = ex.Data; foreach (var kv in data) { exData["Redis-" + kv.Item1] = kv.Item2; } } if (mutiplexer.IncludeDetailInExceptions) { AddDetail(ex, message, server, null); } return(ex); }
internal SocketToken BeginConnect(EndPoint endpoint, ISocketCallback callback, ConnectionMultiplexer multiplexer, TextWriter log) { var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); SetFastLoopbackOption(socket); socket.NoDelay = true; try { CompletionType connectCompletionType = CompletionType.Any; this.ShouldForceConnectCompletionType(ref connectCompletionType); var formattedEndpoint = Format.ToString(endpoint); var tuple = Tuple.Create(socket, callback); if (endpoint is DnsEndPoint) { // A work-around for a Mono bug in BeginConnect(EndPoint endpoint, AsyncCallback callback, object state) DnsEndPoint dnsEndpoint = (DnsEndPoint)endpoint; #if CORE_CLR multiplexer.LogLocked(log, "BeginConnect: {0}", formattedEndpoint); socket.ConnectAsync(dnsEndpoint.Host, dnsEndpoint.Port).ContinueWith(t => { multiplexer.LogLocked(log, "EndConnect: {0}", formattedEndpoint); EndConnectImpl(t, multiplexer, log, tuple); multiplexer.LogLocked(log, "Connect complete: {0}", formattedEndpoint); }); #else CompletionTypeHelper.RunWithCompletionType( (cb) => { multiplexer.LogLocked(log, "BeginConnect: {0}", formattedEndpoint); return(socket.BeginConnect(dnsEndpoint.Host, dnsEndpoint.Port, cb, tuple)); }, (ar) => { multiplexer.LogLocked(log, "EndConnect: {0}", formattedEndpoint); EndConnectImpl(ar, multiplexer, log, tuple); multiplexer.LogLocked(log, "Connect complete: {0}", formattedEndpoint); }, connectCompletionType); #endif } else { #if CORE_CLR multiplexer.LogLocked(log, "BeginConnect: {0}", formattedEndpoint); socket.ConnectAsync(endpoint).ContinueWith(t => { multiplexer.LogLocked(log, "EndConnect: {0}", formattedEndpoint); EndConnectImpl(t, multiplexer, log, tuple); }); #else CompletionTypeHelper.RunWithCompletionType( (cb) => { multiplexer.LogLocked(log, "BeginConnect: {0}", formattedEndpoint); return(socket.BeginConnect(endpoint, cb, tuple)); }, (ar) => { multiplexer.LogLocked(log, "EndConnect: {0}", formattedEndpoint); EndConnectImpl(ar, multiplexer, log, tuple); multiplexer.LogLocked(log, "Connect complete: {0}", formattedEndpoint); }, connectCompletionType); #endif } } catch (NotImplementedException ex) { if (!(endpoint is IPEndPoint)) { throw new InvalidOperationException("BeginConnect failed with NotImplementedException; consider using IP endpoints, or enable ResolveDns in the configuration", ex); } throw; } var token = new SocketToken(socket); return(token); }
private void EndConnectImpl(IAsyncResult ar, ConnectionMultiplexer multiplexer, TextWriter log, Tuple <Socket, ISocketCallback> tuple) { try { bool ignoreConnect = false; ShouldIgnoreConnect(tuple.Item2, ref ignoreConnect); if (ignoreConnect) { return; } var socket = tuple.Item1; var callback = tuple.Item2; #if CORE_CLR multiplexer.Wait((Task)ar); // make it explode if invalid (note: already complete at this point) #else socket.EndConnect(ar); #endif var netStream = new NetworkStream(socket, false); var socketMode = callback == null ? SocketMode.Abort : callback.Connected(netStream, log); switch (socketMode) { case SocketMode.Poll: multiplexer.LogLocked(log, "Starting poll"); OnAddRead(socket, callback); break; case SocketMode.Async: multiplexer.LogLocked(log, "Starting read"); try { callback.StartReading(); } catch (Exception ex) { ConnectionMultiplexer.TraceWithoutContext(ex.Message); Shutdown(socket); } break; default: ConnectionMultiplexer.TraceWithoutContext("Aborting socket"); Shutdown(socket); break; } } catch (ObjectDisposedException) { multiplexer.LogLocked(log, "(socket shutdown)"); if (tuple != null) { try { tuple.Item2.Error(); } catch (Exception inner) { ConnectionMultiplexer.TraceWithoutContext(inner.Message); } } } catch (Exception outer) { ConnectionMultiplexer.TraceWithoutContext(outer.Message); if (tuple != null) { try { tuple.Item2.Error(); } catch (Exception inner) { ConnectionMultiplexer.TraceWithoutContext(inner.Message); } } } }
private void CreateEvent(StackExchange.Redis.ConnectionMultiplexer redis, String id, string events, String value = null) { ISubscriber sub = redis.GetSubscriber(); sub.Publish(events, id); }
private void ReadImpl() { List <IntPtr> dead = null, active = new List <IntPtr>(); List <ISocketCallback> activeCallbacks = new List <ISocketCallback>(); IntPtr[] readSockets = EmptyPointers, errorSockets = EmptyPointers; long lastHeartbeat = Environment.TickCount; SocketPair[] allSocketPairs = null; while (true) { managerState = ManagerState.CheckForHeartbeat; active.Clear(); activeCallbacks.Clear(); if (dead != null) { dead.Clear(); } // this check is actually a pace-maker; sometimes the Timer callback stalls for // extended periods of time, which can cause socket disconnect long now = Environment.TickCount; if (unchecked (now - lastHeartbeat) >= 15000) { managerState = ManagerState.ExecuteHeartbeat; lastHeartbeat = now; lock (socketLookup) { if (allSocketPairs == null || allSocketPairs.Length != socketLookup.Count) { allSocketPairs = new SocketPair[socketLookup.Count]; } socketLookup.Values.CopyTo(allSocketPairs, 0); } foreach (var pair in allSocketPairs) { var callback = pair.Callback; if (callback != null) { try { callback.OnHeartbeat(); } catch { } } } } managerState = ManagerState.LocateActiveSockets; lock (socketLookup) { if (isDisposed) { return; } if (socketLookup.Count == 0) { // if empty, give it a few seconds chance before exiting managerState = ManagerState.NoSocketsPause; Monitor.Wait(socketLookup, TimeSpan.FromSeconds(20)); if (socketLookup.Count == 0) { return; // nothing new came in, so exit } } managerState = ManagerState.PrepareActiveSockets; foreach (var pair in socketLookup) { var socket = pair.Value.Socket; if (socket.Handle == pair.Key && socket.Connected) { if (pair.Value.Socket.Connected) { active.Add(pair.Key); activeCallbacks.Add(pair.Value.Callback); } else { (dead ?? (dead = new List <IntPtr>())).Add(pair.Key); } } } if (dead != null && dead.Count != 0) { managerState = ManagerState.CullDeadSockets; foreach (var socket in dead) { socketLookup.Remove(socket); } } } int pollingSockets = active.Count; if (pollingSockets == 0) { // nobody had actual sockets; just sleep managerState = ManagerState.NoActiveSocketsPause; Thread.Sleep(10); continue; } if (readSockets.Length < active.Count + 1) { managerState = ManagerState.GrowingSocketArray; ConnectionMultiplexer.TraceWithoutContext("Resizing socket array for " + active.Count + " sockets"); readSockets = new IntPtr[active.Count + 6]; // leave so space for growth errorSockets = new IntPtr[active.Count + 6]; } managerState = ManagerState.CopyingPointersForSelect; readSockets[0] = errorSockets[0] = (IntPtr)active.Count; active.CopyTo(readSockets, 1); active.CopyTo(errorSockets, 1); int ready; try { var timeout = new TimeValue(1000); managerState = ManagerState.ExecuteSelect; ready = select(0, readSockets, null, errorSockets, ref timeout); managerState = ManagerState.ExecuteSelectComplete; if (ready <= 0) // -ve typically means a socket was disposed just before; just retry { bool hasWorkToDo = false; if (ready == 0) { managerState = ManagerState.CheckForStaleConnections; foreach (var s in activeCallbacks) { if (s.IsDataAvailable) { hasWorkToDo = true; } else { s.CheckForStaleConnection(); } } } else { lastErrorTicks = Environment.TickCount; } if (!hasWorkToDo) { continue; } } ConnectionMultiplexer.TraceWithoutContext((int)readSockets[0] != 0, "Read sockets: " + (int)readSockets[0]); ConnectionMultiplexer.TraceWithoutContext((int)errorSockets[0] != 0, "Error sockets: " + (int)errorSockets[0]); } catch (Exception ex) { // this typically means a socket was disposed just before; just retry Trace.WriteLine(ex.Message); continue; } bool haveWork = false; int queueCount = (int)readSockets[0]; if (queueCount != 0) { managerState = ManagerState.EnqueueRead; lock (readQueue) { for (int i = 1; i <= queueCount; i++) { var callback = GetCallback(readSockets[i]); if (callback != null) { readQueue.Enqueue(callback); haveWork = true; } } } } queueCount = (int)errorSockets[0]; if (queueCount != 0) { managerState = ManagerState.EnqueueError; lock (errorQueue) { for (int i = 1; i <= queueCount; i++) { var callback = GetCallback(errorSockets[i]); if (callback != null) { errorQueue.Enqueue(callback); haveWork = true; } } } } if (!haveWork) { // edge case: select is returning 0, but data could still be available managerState = ManagerState.EnqueueReadFallback; lock (readQueue) { foreach (var callback in activeCallbacks) { if (callback.IsDataAvailable) { readQueue.Enqueue(callback); } } } } if (ready >= 5) // number of sockets we should attempt to process by ourself before asking for help { // seek help, work in parallel, then synchronize var obj = new QueueDrainSyncLock(this); lock (obj) { managerState = ManagerState.RequestAssistance; ThreadPool.QueueUserWorkItem(HelpProcessItems, obj); managerState = ManagerState.ProcessQueues; ProcessItems(true); if (!obj.Consume()) { // then our worker arrived and picked up work; we need // to let it finish; note that if it *didn't* get that far // yet, the Consume() call will mean that it never tries Monitor.Wait(obj); } } } else { // just do it ourself managerState = ManagerState.ProcessQueues; ProcessItems(true); } } }
private void makeEvent(StackExchange.Redis.ConnectionMultiplexer redis, String id, String value) { ISubscriber sub = redis.GetSubscriber(); sub.Publish("events", id); }
internal RedisServer(ConnectionMultiplexer multiplexer, ServerEndPoint server, object asyncState) : base(multiplexer, asyncState) { this.server = server ?? throw new ArgumentNullException(nameof(server)); }
public async Task <ConnectionMultiplexer> Connect(string serverName, int port) { return(_RedisMux ?? (_RedisMux = await ConnectionMultiplexer.ConnectAsync($"{serverName}:{port}"))); }
public async Task Init(IPEndPoint endpoint, System.Threading.CancellationToken cancel) { _connection = await StackExchange.Redis.ConnectionMultiplexer.ConnectAsync(endpoint.ToString()).ConfigureAwait(false); await _connection.GetDatabase().StringIncrementAsync("whatever").ConfigureAwait(false); }
// This is a hack required to get injection working // because Steeltoe's redis connector injected the concrete class as binding // and not the interface. public RedisLocationCache(ILogger <RedisLocationCache> logger, StackExchange.Redis.ConnectionMultiplexer connectionMultiplexer) : this(logger, (IConnectionMultiplexer)connectionMultiplexer) { }