/// <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);
}
}
}
private static ConnectionMultiplexer GetRedisConnection()
{
ConnectionMultiplexer connection;
string isLocal = ConfigurationManager.AppSettings["IsLocal"];
if (isLocal == "1")
{
connection = ConnectionMultiplexer.Connect(ConfigurationManager.AppSettings["RedisServer"]);
}
else
{
var options = new ConfigurationOptions();
options.EndPoints.Add(ConfigurationManager.AppSettings["RedisKeyDns"], 6380);
options.Ssl = true;
options.Password = ConfigurationManager.AppSettings["RedisPassword"];
options.AllowAdmin = true;
// necessary?
options.KeepAlive = 30;
options.ConnectTimeout = 15000;
options.SyncTimeout = 15000;
connection = ConnectionMultiplexer.Connect(options);
}
return connection;
}
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 async Task Can_start_slave()
{
using (var redis = new Redis())
using (var redis2 = new Redis())
{
////Arrange
// configure slave
var config = new ConfigurationOptions { AllowAdmin = true };
config.EndPoints.Add(redis.Endpoint);
config.EndPoints.Add(redis2.Endpoint);
using (var client = ConnectionMultiplexer.Connect(config))
await client.GetServer(redis.Endpoint).SlaveOfAsync(redis2.Endpoint);
// new single-node client
string actualValue;
using (var client = ConnectionMultiplexer.Connect(redis2.Endpoint.ToString()))
{
await client.GetDatabase().StringSetAsync("key", "value");
////Act
actualValue = await client.GetDatabase().StringGetAsync("key");
}
////Assert
Assert.That(actualValue, Is.EqualTo("value"));
}
}
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);
}
}
static RedisUtils()
{
connection = new Lazy<ConnectionMultiplexer>(() =>
{
ExceptionDispatchInfo lastError = null;
ConfigurationOptions options = new ConfigurationOptions();
options.EndPoints.Add(GetHostAndPort());
options.AllowAdmin = true;
for (int i = 0; i < 5; i++)
{
try
{
var cnn = ConnectionMultiplexer.Connect(options);
if (cnn.IsConnected)
return cnn;
}
catch (Exception ex)
{
lastError = ExceptionDispatchInfo.Capture(ex);
Console.WriteLine(ex.Message);
Thread.Sleep(10);
}
}
lastError.Throw();
return null;
}
);
}
public RedisCommon(string host="127.0.0.1", int port = 6379, string password = "") {
options = new ConfigurationOptions {
AllowAdmin = true,
EndPoints = {new IPEndPoint(IPAddress.Parse(host), port)},
Password = password
};
}
public HttpResponseMessage Get(string deviceId)
{
if (String.IsNullOrEmpty(deviceId))
return new HttpResponseMessage(HttpStatusCode.NoContent);
ConfigurationOptions configurationOptions = new ConfigurationOptions();
configurationOptions.EndPoints.Add("<< add your Redis cache name here >>.redis.cache.windows.net");
configurationOptions.Ssl = true;
configurationOptions.Password = "******";
ConnectionMultiplexer connectionMultiplexer = ConnectionMultiplexer.Connect(configurationOptions);
IDatabase commandQueue = connectionMultiplexer.GetDatabase();
RedisValue redisValue = commandQueue.ListRightPop(deviceId);
if (redisValue.HasValue)
return new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(redisValue.ToString()),
};
else
return new HttpResponseMessage()
{
StatusCode = HttpStatusCode.NoContent,
Content = new StringContent(""),
};
}
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);
}
}
private static IList<RedisConnection> CreateRedisCaches(ICollection<RedisLockEndPoint> redisEndPoints)
{
var caches = new List<RedisConnection>(redisEndPoints.Count);
foreach (var endPoint in redisEndPoints)
{
var configuration = new ConfigurationOptions
{
AbortOnConnectFail = false,
ConnectTimeout = endPoint.ConnectionTimeout ?? DefaultConnectionTimeout,
Ssl = endPoint.Ssl,
Password = endPoint.Password,
};
configuration.EndPoints.Add(endPoint.EndPoint);
caches.Add(new RedisConnection
{
ConnectionMultiplexer = ConnectionMultiplexer.Connect(configuration),
RedisDatabase = endPoint.RedisDatabase ?? DefaultRedisDatabase,
RedisKeyFormat = string.IsNullOrEmpty(endPoint.RedisKeyFormat) ? RedisLock.DefaultRedisKeyFormat : endPoint.RedisKeyFormat
});
}
return caches;
}
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");
}
protected RedisTest()
{
var config = new ConfigurationOptions() { AllowAdmin = true };
config.EndPoints.Add(testHost, testPort);
Multiplexer = ConnectionMultiplexer.Connect(config);
Redis = GetFlushedRedis();
}
public static IGlobalConfiguration<RedisStorage> UseRedisStorage(this IGlobalConfiguration configuration, ConfigurationOptions Options, int db, string Prefix)
{
if (configuration == null) throw new ArgumentNullException("configuration");
if (Options == null) throw new ArgumentNullException("Options");
var storage = new RedisStorage(Options, db, Prefix);
return configuration.UseStorage(storage);
}
public static void Connect()
{
ConfigurationOptions options = new ConfigurationOptions();
options.EndPoints.Add("localhost:6379");
Connection = ConnectionMultiplexer.Connect(options);
}
public static ConnectionMultiplexer RetrieveMultiplexer(ConfigurationOptions config)
{
if(_multiplexer != null) return _multiplexer;
_multiplexer = ConnectionMultiplexer.Connect(config);
return _multiplexer;
}
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);
}
private static ConnectionMultiplexer ConnectWithConfiguration()
{
ConnectionMultiplexer redisConnection;
if (string.IsNullOrWhiteSpace(configuration.ConnectionString))
{
var options = new ConfigurationOptions
{
ClientName = configuration.ApplicationName,
ConnectTimeout = configuration.ConnectionTimeoutInMilliSec,
SyncTimeout = configuration.OperationTimeoutInMilliSec,
ResolveDns = true,
AbortOnConnectFail = false // Important for shared usage
};
if (!string.IsNullOrWhiteSpace(configuration.AccessKey))
options.Password = configuration.AccessKey;
if (configuration.RetryCount > 0)
options.ConnectRetry = configuration.RetryCount;
if (configuration.UseSsl)
{
options.Ssl = configuration.UseSsl;
options.SslHost = configuration.Host;
}
var hosts = configuration.Host.Split(new[] {SPLITTER}, StringSplitOptions.RemoveEmptyEntries);
foreach (var host in hosts)
{
options.EndPoints.Add(host);
}
redisConnection = ConnectionMultiplexer.Connect(options);
}
else
{
redisConnection = ConnectionMultiplexer.Connect(configuration.ConnectionString);
}
return redisConnection;
}
public RedisManager()
{
var configurationOptions = new ConfigurationOptions {Password = "******"};
configurationOptions.EndPoints.Add(HostAndPort);
_redisConn = ConnectionMultiplexer.Connect(configurationOptions);
}
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 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 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 void SetUp()
{
var config = new ConfigurationOptions() { EndPoints = { { _host, _port } }, Password = _password, DefaultDatabase = _database, AllowAdmin = true };
_state = SchedulerFunc.Create(config, "Test", _database);
var server = _state.Connection.GetServer(_state.Connection.GetEndPoints().First());
server.FlushDatabase(_state.Database);
}
public RedisHelper(string host = "192.168.1.78", int port = 6379, string password = "") {
options = new ConfigurationOptions {
AllowAdmin = true,
EndPoints = {new IPEndPoint(IPAddress.Parse(host), port)},
Password = password
};
ServerEndPoint = options.EndPoints[0];
}
public static IGlobalConfiguration<RedisStorage> UseRedisStorage(this IGlobalConfiguration configuration, ConfigurationOptions Options, RedisStorageOptions HangfireOptions)
{
if (configuration == null) throw new ArgumentNullException("configuration");
if (Options == null) throw new ArgumentNullException("Options");
if (HangfireOptions == null) throw new ArgumentNullException("HangfireOptions");
var storage = new RedisStorage(Options, HangfireOptions);
return configuration.UseStorage(storage);
}
//string host = "192.168.1.78", int port = 6379, string password = ""
static RedisHelper() {
options = new ConfigurationOptions {
AllowAdmin = true,
EndPoints = { new IPEndPoint(IPAddress.Parse(host), port) },
Password = password
};
ServerEndPoint = options.EndPoints[0];
}
public async static Task<IConnection> ConnectAsync(EndPoint[] endpoints)
{
var configuration = new ConfigurationOptions { ClientName = "ScarletLock" };
foreach (var endpoint in endpoints)
configuration.EndPoints.Add(endpoint);
return new RedisConnection(await ConnectionMultiplexer.ConnectAsync(configuration));
}
static RedisStore()
{
var configurationOptions = new ConfigurationOptions
{
EndPoints = { ConfigurationManager.AppSettings["redis.connection"] }
};
LazyConnection = new Lazy<ConnectionMultiplexer>(() => ConnectionMultiplexer.Connect(configurationOptions));
}
public RedisConnection(string host, int port = 6379, string password = null)
{
var options = new ConfigurationOptions();
options.Password = password;
options.EndPoints.Add(host, port);
options.AbortOnConnectFail = false;
this.connectionManager = ConnectionMultiplexer.Connect(options);
}
/// <summary>
/// Initializes a new instance of the RedisConnectionWrapper class, which contains methods for accessing
/// a static concurrentdictionary of already created and open RedisConnection instances
/// </summary>
/// <param name="serverAddress">The ip address of the redis instance</param>
/// <param name="serverPort">The port number of the redis instance</param>
public RedisConnectionWrapper(string srvAddr, int srvPort)
{
this.connData = ConfigurationOptions.Parse(srvAddr + ":" + srvPort);
this.ConnectionID = string.Format(
"{0}_%_{1}",
srvAddr,
srvPort);
}
public InvitationProvider()
{
var config = new ConfigurationOptions
{
Ssl = true,
Password = "******",
EndPoints = { { "bizexperiments.redis.cache.windows.net", 6380 } }
};
_connection = ConnectionMultiplexer.Connect(config);
}
public static ConnectionMultiplexer Connect(RedisConfiguration configuration)
{
string connectionString = configuration.ConnectionString;
if (string.IsNullOrWhiteSpace(configuration.ConnectionString))
{
Func<RedisConfiguration, string> createConfigurationOptions = (config) =>
{
var configurationOptions = new ConfigurationOptions()
{
AllowAdmin = config.AllowAdmin,
ConnectTimeout = config.ConnectionTimeout,
Password = config.Password,
Ssl = config.IsSsl,
SslHost = config.SslHost,
ConnectRetry = 10,
AbortOnConnectFail = false
};
foreach (var endpoint in configuration.Endpoints)
{
configurationOptions.EndPoints.Add(endpoint.Host, endpoint.Port);
}
return configurationOptions.ToString();
};
connectionString = createConfigurationOptions(configuration);
}
ConnectionMultiplexer connection;
lock (connectLock)
{
if (!connections.TryGetValue(connectionString, out connection))
{
var builder = new StringBuilder();
using (var log = new StringWriter(builder, CultureInfo.InvariantCulture))
{
connection = ConnectionMultiplexer.Connect(connectionString, log);
}
connection.ConnectionFailed += (sender, args) =>
{
connections.Remove(connectionString);
};
if (!connection.IsConnected)
{
throw new InvalidOperationException("Connection failed.\n" + builder.ToString());
}
connection.PreserveAsyncOrder = false;
connections.Add(connectionString, connection);
}
}
return connection;
}
public RedisSubscriber(RedisOptions configurationOptions)
{
_logger = Logger.CreateLogger <RedisSubscriber>();
if (configurationOptions == null)
{
throw new ArgumentNullException(nameof(configurationOptions));
}
CreateConnection(configurationOptions);
}
public RedisSubscriber(string configuration)
{
_logger = Logger.CreateLogger <RedisSubscriber>();
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
_options = RedisOptions.Parse(configuration);
}
public void OnBeforeTestExecute()
{
_redisConfigOpts = ConfigurationOptions.Parse(REDIS_SERVER);
RedisConnectionConfig.GetSERedisServerConfigDbIndex = @base => new Tuple<string, int, ConfigurationOptions>(
"SessionConnection", REDIS_DB, _redisConfigOpts);
RedisSessionConfig.SessionTimeout = TIMEOUT;
// StackExchange Redis client
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect(REDIS_SERVER);
db = redis.GetDatabase(REDIS_DB);
}
private void CreateConnection(RedisOptions configurationOptions)
{
using (var writer = new StringWriter())
{
_connection = ConnectionMultiplexer.Connect(configurationOptions, writer);
_logger.LogDebug(writer.ToString());
}
_connection.ErrorMessage += (sender, args) => { _logger.LogError(args.Message); };
_connection.ConnectionFailed += (sender, args) => { _logger.LogError(args.Exception, "Redis connection failed."); };
_connection.ConnectionRestored += (sender, args) => { _logger.LogInformation("Redis connection restored."); };
}
public static ConnectionMultiplexer GetInstance(string host, int port)
{
if (conn == null)
{
var configOptions = new StackExchange.Redis.ConfigurationOptions
{
ConnectTimeout = 5000,
ConnectRetry = 5,
SyncTimeout = 5000,
AbortOnConnectFail = false,
};
configOptions.EndPoints.Add(host, port);
conn = ConnectionMultiplexer.Connect(configOptions);
}
return(conn);
}
private static StackRedis.ConfigurationOptions CreateConfigurationOptions(RedisConfiguration configuration)
{
var configurationOptions = new StackRedis.ConfigurationOptions()
{
AllowAdmin = configuration.AllowAdmin,
ConnectTimeout = configuration.ConnectionTimeout,
Password = configuration.Password,
Ssl = configuration.IsSsl,
SslHost = configuration.SslHost,
ConnectRetry = 10,
AbortOnConnectFail = false
};
foreach (var endpoint in configuration.Endpoints)
{
configurationOptions.EndPoints.Add(endpoint.Host, endpoint.Port);
}
return(configurationOptions);
}
public static void SignalRConfiguration(this IServiceCollection services, IConfiguration configuration)
{
services.AddSignalR()
.AddJsonProtocol(x =>
{
x.PayloadSerializerOptions.IgnoreNullValues = false;
x.PayloadSerializerOptions.PropertyNameCaseInsensitive = false;
x.PayloadSerializerOptions.WriteIndented = false;
})
.AddMessagePackProtocol()
.AddStackExchangeRedis(o =>
{
o.ConnectionFactory = async writer =>
{
var config = new StackExchange.Redis.ConfigurationOptions
{
AbortOnConnectFail = false,
ResolveDns = true
};
config.EndPoints.Add(configuration.GetConnectionString("Redis"), 6379);
config.SetDefaultPorts();
var connection = await ConnectionMultiplexer.ConnectAsync(config, writer);
connection.ConnectionFailed += (_, e) =>
{
Console.WriteLine("Connection to Redis failed.");
};
if (!connection.IsConnected)
{
Console.WriteLine("Did not connect to Redis.");
}
return(connection);
};
});
}
partial void OnCreateReaderWriter(ConfigurationOptions configuration)
{
SocketManager = configuration.SocketManager ?? GetDefaultSocketManager();
}
public RedisSubscriber(RedisOptions configurationOptions)
{
_logger = Logger.CreateLogger <RedisSubscriber>();
_options = configurationOptions ?? throw new ArgumentNullException(nameof(configurationOptions));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddOptions();
services.AddControllers();
services.AddMvc(config =>
{
config.Filters.Add(new ProducesAttribute("application/json"));
//config.Filters.Add(new ConsumesAttribute("application/json"));
})
.AddFluentValidation()
.AddJsonOptions(x =>
{
x.JsonSerializerOptions.WriteIndented = false;
x.JsonSerializerOptions.PropertyNameCaseInsensitive = false;
x.JsonSerializerOptions.IgnoreNullValues = false;
});
services.Configure <GzipCompressionProviderOptions>(options => options.Level = CompressionLevel.Optimal);
services.AddResponseCompression(options => options.Providers.Add <GzipCompressionProvider>());
services.AddSignalR()
.AddJsonProtocol(x =>
{
x.PayloadSerializerOptions.IgnoreNullValues = false;
x.PayloadSerializerOptions.PropertyNameCaseInsensitive = false;
x.PayloadSerializerOptions.WriteIndented = false;
})
.AddMessagePackProtocol()
.AddStackExchangeRedis(o =>
{
o.ConnectionFactory = async writer =>
{
var config = new StackExchange.Redis.ConfigurationOptions
{
AbortOnConnectFail = false,
ResolveDns = true
};
config.EndPoints.Add(Configuration.GetConnectionString("Redis"), 6379);
config.SetDefaultPorts();
var connection = await ConnectionMultiplexer.ConnectAsync(config, writer);
connection.ConnectionFailed += (_, e) =>
{
Console.WriteLine("Connection to Redis failed.");
};
if (!connection.IsConnected)
{
Console.WriteLine("Did not connect to Redis.");
}
return(connection);
};
});
services.AddCors();
services.AddEntityFrameworkSqlServer()
.AddDbContext <ChatContext>((serviceProvider, options) =>
{
options.UseApplicationServiceProvider(serviceProvider);
options.UseInternalServiceProvider(serviceProvider);
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddScoped <ChatContext>();
// Health Checks
services.AddHealthChecks()
.AddSqlServer(Configuration.GetConnectionString("DefaultConnection"), name: "MSSQL")
.AddRedis(Configuration.GetConnectionString("Redis"), name: "REDIS");
services
.AddHealthChecksUI();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "Chat API", Version = "v1"
});
c.EnableAnnotations();
});
}