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 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"); }
static void CleanRedis() { connection = Redis.ConnectionMultiplexer.Connect("localhost,allowAdmin=true"); server = connection.GetServer("localhost", 6379); server.FlushDatabase(); db = connection.GetDatabase(); }
private static IEnumerable<RedisKey> FetchAllKeys(ConnectionMultiplexer multiplexer, EndPoint endpoint) { var server = multiplexer.GetServer(endpoint); var allKeys = server.Keys() .ToArray(); return allKeys; }
/// <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); } }
internal static IServer TryGetServer(ConnectionMultiplexer muxer, bool checkConnected = true) { if (muxer != null) { var eps = muxer.GetEndPoints(true); foreach (var ep in eps) { var server = muxer.GetServer(ep); if (server.IsSlave) continue; if (checkConnected && !server.IsConnected) continue; // that'll do return server; } } return null; }
internal static IServer GetServer(ConnectionMultiplexer conn) { return conn.GetServer(conn.GetEndPoints()[0]); }
private void Initialize() { var options = new ConfigurationOptions() { AllowAdmin = true, ConnectTimeout = 1000, }; var endpoint = new DnsEndPoint(_redisConfig.Host, _redisConfig.Port, AddressFamily.InterNetwork); options.EndPoints.Add(endpoint); if (!string.IsNullOrEmpty(_redisConfig.Password)) options.Password = _redisConfig.Password; try { // create the connection _connectionMultiplexer = ConnectionMultiplexer.ConnectAsync(options).Result; // access to database. _database = _connectionMultiplexer.GetDatabase(_redisConfig.DatabaseId); // get the configured server. _server = _connectionMultiplexer.GetServer(endpoint); // check the version var version = GetVersion(); if (version < _requiredMinimumVersion) throw new Exception(string.Format("You are using redis version {0}, minimum required version is 2.6", version)); _logger.Information("Storage initialized: {0:l}:{1}, v{2:l}.", endpoint.Host, endpoint.Port, version); } catch (Exception e) { IsEnabled = false; _logger.Error(string.Format("Storage initialization failed: {0:l}:{1}.", endpoint.Host, endpoint.Port)); } }
public RedisTests() { _multiplexer = new RedisDatabase().GetDatabase().Multiplexer; _server = _multiplexer.GetServer("localhost", 6379); }
/// <summary> /// Flushes the database that the connection belongs to. /// </summary> /// <param name="connection"> /// The connection. /// </param> public void FlushDatabase(ConnectionMultiplexer connection) { EndPoint[] endPoints = connection.GetEndPoints(); foreach (var endPoint in endPoints) { connection.GetServer(endPoint).FlushDatabase(this.Db); } }
/// <summary> /// Provide an alternate ConnectionMultiplexer to use for INFO command /// </summary> /// <param name="Connection"></param> /// <param name="title">Title to appear on the dashboard</param> /// <param name="key">Redis INFO key</param> /// <returns></returns> public DashboardMetric GetDashboardInfo(ConnectionMultiplexer Connection, string title, string key) { return GetDashboardInfo(Connection.GetServer(Connection.GetDatabase(Db).IdentifyEndpoint()), title, key); }
private void ReconfigureConnection(List<RedisInstanceBase> toConnect) { var config = ConfigurationOptions.Parse(muxerInstance.Configuration); foreach (var ins in toConnect) { config.EndPoints.Add(ins.EndPoint); } lock (muxerSyncLock) { muxerInstance.Dispose(); muxerInstance = ConnectionMultiplexer.Connect(config); RefreshAll(); muxerInstance.ConnectionRestored += MuxerInstanceOnConnectionRestored; } foreach (var ins in toConnect) { ins.Server = muxerInstance.GetServer(ins.EndPoint); } }
private void Initialize() { var options = new ConfigurationOptions(); var endpoint = new DnsEndPoint(Config.Host, Config.Port, AddressFamily.InterNetwork); options.EndPoints.Add(endpoint); options.AllowAdmin = true; if (!string.IsNullOrEmpty(Config.Password)) options.Password = Config.Password; try { // create the connection _connectionMultiplexer = ConnectionMultiplexer.ConnectAsync(options).Result; // access to database. _database = _connectionMultiplexer.GetDatabase(Config.DatabaseId); // get the configured server. _server = _connectionMultiplexer.GetServer(endpoint); // check the version var info = _server.Info(); Version version = null; foreach (var pair in info[0]) { if (pair.Key == "redis_version") { version = new Version(pair.Value); if (version < _requiredMinimumVersion) throw new Exception(string.Format("You are using redis version {0}, minimum required version is 2.6", version)); break; } } Log.ForContext<Redis>().Information("Storage initialized: {0}, v{1}.", endpoint, version); } catch (Exception e) { IsEnabled = false; Log.ForContext<Redis>().Error(e, string.Format("Storage initialization failed: {0}", endpoint)); } }