public override void Initialize(string name, System.Collections.Specialized.NameValueCollection config) { if (config == null) { throw new ArgumentNullException("config"); } if (name == null || name.Length == 0) { name = "MyCacheStore"; } if (String.IsNullOrEmpty(config["description"])) { config.Remove("description"); config.Add("description", "Redis as a session data store"); } base.Initialize(name, config); // If configuration exists then use it otherwise read from config file and create one if (configuration == null) { lock (configurationCreationLock) { if (configuration == null) { configuration = ProviderConfiguration.ProviderConfigurationForSessionState(config); redisUtility = new RedisUtility(configuration); } } } }
internal static ISessionStateItemCollection GetSessionDataStatic(object rowDataFromRedis) { RedisResult rowDataAsRedisResult = (RedisResult)rowDataFromRedis; RedisResult[] lockScriptReturnValueArray = (RedisResult[])rowDataAsRedisResult; Debug.Assert(lockScriptReturnValueArray != null); ISessionStateItemCollection sessionData = null; if (lockScriptReturnValueArray.Length > 1 && lockScriptReturnValueArray[1] != null) { RedisResult[] data = (RedisResult[])lockScriptReturnValueArray[1]; // LUA script returns data as object array so keys and values are store one after another // This list has to be even because it contains pair of <key, value> as {key, value, key, value} if (data != null && data.Length != 0 && data.Length % 2 == 0) { sessionData = new ChangeTrackingSessionStateItemCollection(); // In every cycle of loop we are getting one pair of key value and putting it into session items // thats why increment is by 2 because we want to move to next pair for (int i = 0; (i + 1) < data.Length; i += 2) { string key = (string)data[i]; object val = RedisUtility.GetObjectFromBytes((byte[])data[i + 1]); if (key != null) { sessionData[key] = val; } } } } return(sessionData); }
private bool TryUpdateIfLockIdMatchPrepare(object lockId, ISessionStateItemCollection data, int sessionTimeout, out string[] keyArgs, out object[] valueArgs) { keyArgs = null; valueArgs = null; if (data != null) { List <object> list = new List <object>(); ChangeTrackingSessionStateItemCollection sessionItems = (ChangeTrackingSessionStateItemCollection)data; int noOfItemsRemoved = RedisUtility.AppendRemoveItemsInList(sessionItems, list); int noOfItemsUpdated = RedisUtility.AppendUpdatedOrNewItemsInList(sessionItems, list); keyArgs = new string[] { Keys.LockKey, Keys.DataKey, Keys.InternalKey }; valueArgs = new object[list.Count + 8]; // this +8 is for first wight values in ARGV that we will add now valueArgs[0] = lockId; valueArgs[1] = sessionTimeout; valueArgs[2] = noOfItemsRemoved; valueArgs[3] = 9; // In Lua index starts from 1 so first item deleted will be 9th. valueArgs[4] = noOfItemsRemoved + 8; // index for last removed item valueArgs[5] = noOfItemsUpdated; valueArgs[6] = noOfItemsRemoved + 9; // first item updated will be next to last item removed valueArgs[7] = list.Count + 8; // index for last item in list in LUA // if nothing is changed in session then also execute update script to update session timeout if (list.Count != 0) { list.CopyTo(valueArgs, 8); } return(true); } return(false); }
public object Add(string key, object entry, DateTime utcExpiry) { key = GetKeyForRedis(key); TimeSpan expiryTime = utcExpiry - DateTime.UtcNow; string[] keyArgs = new string[] { key }; object[] valueArgs = new object[] { RedisUtility.GetBytesFromObject(entry), expiryTime.TotalMilliseconds }; object rowDataFromRedis = redisConnection.Eval(addScript, keyArgs, valueArgs); return(RedisUtility.GetObjectFromBytes(redisConnection.GetOutputCacheDataFromResult(rowDataFromRedis))); }
public StackExchangeClientConnection(ProviderConfiguration configuration) { this.configuration = configuration; this.redisUtility = new RedisUtility(configuration); ConfigurationOptions configOption; // If connection string is given then use it otherwise use individual options if (!string.IsNullOrEmpty(configuration.ConnectionString)) { configOption = ConfigurationOptions.Parse(configuration.ConnectionString); // Setting explicitly 'abortconnect' to false. It will overwrite customer provided value for 'abortconnect' // As it doesn't make sense to allow to customer to set it to true as we don't give them access to ConnectionMultiplexer // in case of failure customer can not create ConnectionMultiplexer so right choice is to automatically create it by providing AbortOnConnectFail = false configOption.AbortOnConnectFail = false; } else { configOption = new ConfigurationOptions(); if (configuration.Port == 0) { configOption.EndPoints.Add(configuration.Host); } else { configOption.EndPoints.Add(configuration.Host + ":" + configuration.Port); } configOption.Password = configuration.AccessKey; configOption.Ssl = configuration.UseSsl; configOption.AbortOnConnectFail = false; if (configuration.ConnectionTimeoutInMilliSec != 0) { configOption.ConnectTimeout = configuration.ConnectionTimeoutInMilliSec; } if (configuration.OperationTimeoutInMilliSec != 0) { configOption.SyncTimeout = configuration.OperationTimeoutInMilliSec; } } if (LogUtility.logger == null) { redisMultiplexer = ConnectionMultiplexer.Connect(configOption); } else { redisMultiplexer = ConnectionMultiplexer.Connect(configOption, LogUtility.logger); } this.connection = redisMultiplexer.GetDatabase(configOption.DefaultDatabase ?? configuration.DatabaseId); }
public StackExchangeClientConnection(ProviderConfiguration configuration) { _configuration = configuration; _configOption = ParseConfiguration(_configuration); if (!string.IsNullOrEmpty(_configOption.ServiceName)) { _sentinelConfiguration = CreateSentinellConfiguration(_configOption); ModifyEndpointsForSentinelConfiguration(_configOption); } ConnectToRedis(_configuration); this.redisUtility = new RedisUtility(configuration); this.configuration = configuration; ConfigurationOptions configOption; }
public StackExchangeClientConnection(ProviderConfiguration configuration) { this.configuration = configuration; this.redisUtility = new RedisUtility(configuration); ConfigurationOptions configOption; // If connection string is given then use it otherwise use individual options if (!string.IsNullOrEmpty(configuration.ConnectionString)) { configOption = ConfigurationOptions.Parse(configuration.ConnectionString); // Setting explicitly 'abortconnect' to false. It will overwrite customer provided value for 'abortconnect' // As it doesn't make sense to allow to customer to set it to true as we don't give them access to ConnectionMultiplexer // in case of failure customer can not create ConnectionMultiplexer so right choice is to automatically create it by providing AbortOnConnectFail = false configOption.AbortOnConnectFail = false; } else { configOption = new ConfigurationOptions(); if (configuration.Port == 0) { configOption.EndPoints.Add(configuration.Host); } else { configOption.EndPoints.Add(configuration.Host + ":" + configuration.Port); } configOption.Password = configuration.AccessKey; configOption.Ssl = configuration.UseSsl; configOption.AbortOnConnectFail = false; if (configuration.ConnectionTimeoutInMilliSec != 0) { configOption.ConnectTimeout = configuration.ConnectionTimeoutInMilliSec; } if (configuration.OperationTimeoutInMilliSec != 0) { configOption.SyncTimeout = configuration.OperationTimeoutInMilliSec; } } if (LogUtility.logger == null) { redisMultiplexer = ConnectionMultiplexer.Connect(configOption); } else { redisMultiplexer = ConnectionMultiplexer.Connect(configOption, LogUtility.logger); } this.connection = redisMultiplexer.GetDatabase(configuration.DatabaseId); }
public RedisOutputCacheConnectionWrapper(ProviderConfiguration configuration) { this.configuration = configuration; // only single object of RedisSharedConnection will be created and then reused if (sharedConnection == null) { lock (lockForSharedConnection) { if (sharedConnection == null) { sharedConnection = new RedisSharedConnection(configuration); redisUtility = new RedisUtility(configuration); } } } redisConnection = new StackExchangeClientConnection(configuration, redisUtility, sharedConnection); }
public RedisOutputCacheConnectionWrapper(ProviderConfiguration configuration) { this.configuration = configuration; // Shared connection is created by server when it starts. don't want to lock everytime when check == null. // so that is why pool == null exists twice. if (sharedConnection == null) { lock (lockForSharedConnection) { if (sharedConnection == null) { sharedConnection = new RedisSharedConnection(configuration, () => new StackExchangeClientConnection(configuration)); redisUtility = new RedisUtility(configuration); } } } redisConnection = sharedConnection.TryGetConnection(); }
public RedisConnectionWrapper(ProviderConfiguration configuration, string id) { this.configuration = configuration; Keys = new KeyGenerator(id, configuration.ApplicationName); // only single object of RedisSharedConnection will be created and then reused if (sharedConnection == null) { lock (lockForSharedConnection) { if (sharedConnection == null) { sharedConnection = new RedisSharedConnection(configuration); redisUtility = new RedisUtility(configuration); } } } redisConnection = new StackExchangeClientConnection(configuration, redisUtility, sharedConnection); }
public RedisOutputCacheConnectionWrapper(ProviderConfiguration configuration) { this.configuration = configuration; // Shared connection is created by server when it starts. don't want to lock everytime when check == null. // so that is why pool == null exists twice. if (sharedConnection == null) { lock (lockForSharedConnection) { if (sharedConnection == null) { sharedConnection = new RedisSharedConnection(configuration,() => new StackExchangeClientConnection(configuration)); redisUtility = new RedisUtility(configuration); } } } redisConnection = sharedConnection.TryGetConnection(); }
public RedisConnectionWrapper(ProviderConfiguration configuration, string id) { this.configuration = configuration; Keys = new KeyGenerator(id, configuration.ApplicationName); // Pool is created by server when it starts. don't want to lock everytime when check pool == null. // so that is why pool == null exists twice. if (sharedConnection == null) { lock (lockForSharedConnection) { if (sharedConnection == null) { sharedConnection = new RedisSharedConnection(configuration, () => new StackExchangeClientConnection(configuration)); redisUtility = new RedisUtility(configuration); } } } redisConnection = sharedConnection.TryGetConnection(); }
private bool SetPrepare(ISessionStateItemCollection data, int sessionTimeout, out string[] keyArgs, out object[] valueArgs) { keyArgs = null; valueArgs = null; if (data != null && data.Count > 0) { ChangeTrackingSessionStateItemCollection sessionItems = (ChangeTrackingSessionStateItemCollection)data; List <object> list = RedisUtility.GetNewItemsAsList(sessionItems); if (list.Count > 0) { keyArgs = new string[] { Keys.DataKey, Keys.InternalKey }; valueArgs = new object[list.Count + 2]; // this +2 is for first 2 values in ARGV that we will add now valueArgs[0] = list.Count + 2; valueArgs[1] = sessionTimeout; list.CopyTo(valueArgs, 2); return(true); } } return(false); }
public ChangeTrackingSessionStateItemCollection(RedisUtility redisUtility) { this.redisUtility = redisUtility; innerCollection = new SessionStateItemCollection(); }
/*-------End of Add operation-----------------------------------------------------------------------------------------------------------------------------------------------*/ public void Set(string key, object entry, DateTime utcExpiry) { key = GetKeyForRedis(key); byte[] data = RedisUtility.GetBytesFromObject(entry); redisConnection.Set(key, data, utcExpiry); }
public RedisConnectionWrapper(ProviderConfiguration configuration, string id) { this.configuration = configuration; Keys = new KeyGenerator(id, configuration.ApplicationName); // Pool is created by server when it starts. don't want to lock everytime when check pool == null. // so that is why pool == null exists twice. if (sharedConnection == null) { lock (lockForSharedConnection) { if (sharedConnection == null) { sharedConnection = new RedisSharedConnection(configuration,() => new StackExchangeClientConnection(configuration)); redisUtility = new RedisUtility(configuration); } } } redisConnection = sharedConnection.TryGetConnection(); }
public object Get(string key) { key = GetKeyForRedis(key); byte[] data = redisConnection.Get(key); return(RedisUtility.GetObjectFromBytes(data)); }
public StackExchangeClientConnection(ProviderConfiguration configuration, RedisUtility redisUtility, RedisSharedConnection sharedConnection) { _configuration = configuration; _redisUtility = redisUtility; _sharedConnection = sharedConnection; }
public ChangeTrackingSessionStateItemCollection(RedisUtility utility) { _utility = utility; innerCollection = new SessionStateItemCollection(); }