Drop EFCore in prod since we're not using it for anything more than migrations

OoLunar · OoLunar · commit bfd6e03a513e · 2023-05-04T11:45:21.000-05:00
diff --git a/src/CookieTracker.cs b/src/CookieTracker.cs
@@ -6,7 +6,6 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using Npgsql;
@@ -18,52 +17,50 @@ namespace OoLunar.CookieClicker
 {
     public sealed class CookieTracker : IAsyncDisposable
     {
-        private readonly Dictionary<Ulid, CachedCookie> UnbakedCookies = new();
-        private readonly CookieDatabaseContext DatabaseContext;
+        private readonly Dictionary<Ulid, CachedCookie> _unbakedCookies = new();
+        private readonly NpgsqlConnection _databaseConnection;
         private readonly ILogger<CookieTracker> _logger;
-        private readonly SemaphoreSlim Semaphore = new(1, 1);
-        private readonly PeriodicTimer Timer;
-        private readonly Task BakingTask;
-        private readonly FrozenDictionary<DatabaseOperation, NpgsqlCommand> DatabaseCommands;
+        private readonly SemaphoreSlim _semaphore = new(1, 1);
+        private readonly PeriodicTimer _timer;
+        private readonly Task _bakingTask;
+        private readonly FrozenDictionary<DatabaseOperation, NpgsqlCommand> _databaseCommands;
 
-        public CookieTracker(CookieDatabaseContext databaseContext, IConfiguration configuration, ILogger<CookieTracker> logger)
+        public CookieTracker(IConfiguration configuration, ILogger<CookieTracker> logger)
         {
-            ArgumentNullException.ThrowIfNull(databaseContext, nameof(databaseContext));
             ArgumentNullException.ThrowIfNull(configuration, nameof(configuration));
             ArgumentNullException.ThrowIfNull(logger, nameof(logger));
 
             _logger = logger;
-            Timer = new PeriodicTimer(TimeSpan.FromSeconds(configuration.GetValue("CookieTracker:Period", 30)));
+            _timer = new PeriodicTimer(TimeSpan.FromSeconds(configuration.GetValue("CookieTracker:Period", 30)));
 
-            DatabaseContext = databaseContext;
-            NpgsqlConnection connection = (NpgsqlConnection)DatabaseContext.Database.GetDbConnection();
-            connection.Open();
-            DatabaseCommands = new Dictionary<DatabaseOperation, NpgsqlCommand>
+            _databaseConnection = NpgsqlDataSource.Create(CookieDatabaseContext.GetConnectionString(configuration)).CreateConnection();
+            _databaseConnection.Open();
+            _databaseCommands = new Dictionary<DatabaseOperation, NpgsqlCommand>
             {
-                [DatabaseOperation.Create] = GetInsertCommand(connection),
-                [DatabaseOperation.Read] = GetSelectCommand(connection),
-                [DatabaseOperation.Update] = GetUpdateCommand(connection),
-                [DatabaseOperation.Delete] = GetDeleteCommand(connection)
+                [DatabaseOperation.Create] = GetInsertCommand(_databaseConnection),
+                [DatabaseOperation.Read] = GetSelectCommand(_databaseConnection),
+                [DatabaseOperation.Update] = GetUpdateCommand(_databaseConnection),
+                [DatabaseOperation.Delete] = GetDeleteCommand(_databaseConnection)
             }.ToFrozenDictionary();
 
-            BakingTask = StartBakingAsync();
+            _bakingTask = StartBakingAsync();
         }
 
         public void CreateCookie(Cookie cookie)
         {
             ArgumentNullException.ThrowIfNull(cookie, nameof(cookie));
-            UnbakedCookies.Add(cookie.Id, new(cookie, false));
+            _unbakedCookies.Add(cookie.Id, new(cookie, false));
         }
 
         public ulong Click(Ulid cookieId)
         {
             // Check if the cookie is in the cache. If it isn't, pull it from the database.
-            if (!UnbakedCookies.TryGetValue(cookieId, out CachedCookie? unbakedCookie))
+            if (!_unbakedCookies.TryGetValue(cookieId, out CachedCookie? unbakedCookie))
             {
-                Semaphore.Wait();
+                _semaphore.Wait();
                 try
                 {
-                    DbCommand command = DatabaseCommands[DatabaseOperation.Read];
+                    DbCommand command = _databaseCommands[DatabaseOperation.Read];
                     command.Parameters[0].Value = cookieId.ToGuid();
                     using DbDataReader reader = command.ExecuteReader(CommandBehavior.SingleRow);
                     if (!reader.Read())
@@ -76,11 +73,11 @@ public ulong Click(Ulid cookieId)
                         Id = new Ulid(reader.GetFieldValue<Guid>(0)),
                         Clicks = (ulong)reader.GetFieldValue<decimal>(1)
                     }, true);
-                    UnbakedCookies.Add(cookieId, unbakedCookie);
+                    _unbakedCookies.Add(cookieId, unbakedCookie);
                 }
                 finally
                 {
-                    Semaphore.Release();
+                    _semaphore.Release();
                 }
             }
 
@@ -90,18 +87,18 @@ public ulong Click(Ulid cookieId)
 
         private async Task StartBakingAsync()
         {
-            DbCommand createCommand = DatabaseCommands[DatabaseOperation.Create];
-            DbCommand updateCommand = DatabaseCommands[DatabaseOperation.Update];
-            foreach (DbCommand command in DatabaseCommands.Values)
+            DbCommand createCommand = _databaseCommands[DatabaseOperation.Create];
+            DbCommand updateCommand = _databaseCommands[DatabaseOperation.Update];
+            foreach (DbCommand command in _databaseCommands.Values)
             {
                 await command.PrepareAsync();
             }
 
-            while (await Timer.WaitForNextTickAsync())
+            while (await _timer.WaitForNextTickAsync())
             {
-                await Semaphore.WaitAsync();
-                CachedCookie[] unbakedCookies = UnbakedCookies.Values.ToArray();
-                Semaphore.Release();
+                await _semaphore.WaitAsync();
+                CachedCookie[] unbakedCookies = _unbakedCookies.Values.ToArray();
+                _semaphore.Release();
 
                 List<Guid> updatedCookieIds = new();
                 List<decimal> updatedCookieCount = new();
@@ -120,7 +117,7 @@ private async Task StartBakingAsync()
                     }
 
                     // Remove the cookie from the unbaked cookies dictionary. Prefer the returned result over the current result.
-                    if (!UnbakedCookies.Remove(cookie.Cookie.Id, out CachedCookie? unbakedCookie))
+                    if (!_unbakedCookies.Remove(cookie.Cookie.Id, out CachedCookie? unbakedCookie))
                     {
                         unbakedCookie = cookie;
                     }
@@ -143,7 +140,7 @@ private async Task StartBakingAsync()
                     continue;
                 }
 
-                await Semaphore.WaitAsync();
+                await _semaphore.WaitAsync();
                 try
                 {
                     if (newCookieIds.Count != 0)
@@ -162,17 +159,17 @@ private async Task StartBakingAsync()
                 }
                 finally
                 {
-                    Semaphore.Release();
+                    _semaphore.Release();
                 }
             }
         }
 
         public async ValueTask DisposeAsync()
         {
-            Timer.Dispose();
-            await BakingTask;
-            await DatabaseContext.DisposeAsync();
-            Semaphore.Dispose();
+            _timer.Dispose();
+            await _bakingTask;
+            await _databaseConnection.DisposeAsync();
+            _semaphore.Dispose();
         }
 
         private static NpgsqlCommand GetSelectCommand(NpgsqlConnection connection)
diff --git a/src/Database/CookieDatabaseContext.cs b/src/Database/CookieDatabaseContext.cs
@@ -35,21 +35,18 @@ protected override void OnModelCreating(ModelBuilder modelBuilder) => modelBuild
                 .ValueGeneratedOnAdd();
         });
 
-        internal static void ConfigureOptions(DbContextOptionsBuilder optionsBuilder, IConfiguration configuration)
+        internal static NpgsqlConnectionStringBuilder GetConnectionString(IConfiguration configuration) => new()
         {
-            NpgsqlConnectionStringBuilder connectionBuilder = new()
-            {
-                ApplicationName = configuration.GetValue("Database:ApplicationName", "Cookie Clicker"),
-                Database = configuration.GetValue("Database:DatabaseName", "cookie_clicker"),
-                Host = configuration.GetValue("Database:Host", "localhost"),
-                Username = configuration.GetValue("Database:Username", "cookie_clicker"),
-                Port = configuration.GetValue("Database:Port", 5432),
-                Password = configuration.GetValue<string>("Database:Password")
-            };
+            ApplicationName = configuration.GetValue("Database:ApplicationName", "Cookie Clicker"),
+            Database = configuration.GetValue("Database:DatabaseName", "cookie_clicker"),
+            Host = configuration.GetValue("Database:Host", "localhost"),
+            Username = configuration.GetValue("Database:Username", "cookie_clicker"),
+            Port = configuration.GetValue("Database:Port", 5432),
+            Password = configuration.GetValue<string>("Database:Password")
+        };
 
-            optionsBuilder.UseNpgsql(connectionBuilder.ToString(), options => options.EnableRetryOnFailure(5).CommandTimeout(5))
-                .UseSnakeCaseNamingConvention()
-                .EnableThreadSafetyChecks(false);
-        }
+        internal static void ConfigureOptions(DbContextOptionsBuilder optionsBuilder, IConfiguration configuration) => optionsBuilder.UseNpgsql(GetConnectionString(configuration).ToString(), options => options.EnableRetryOnFailure(5).CommandTimeout(5))
+            .UseSnakeCaseNamingConvention()
+            .EnableThreadSafetyChecks(false);
     }
 }
diff --git a/src/Program.cs b/src/Program.cs
@@ -17,7 +17,6 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
-using OoLunar.CookieClicker.Database;
 using OoLunar.CookieClicker.GenHttp;
 using OoLunar.CookieClicker.Headers;
 using OoLunar.CookieClicker.Routes;
@@ -30,14 +29,14 @@ public static async Task<int> Main(string[] args)
         {
             ServiceCollection serviceCollection = new();
             ConfigurationBuilder configurationBuilder = new();
+            configurationBuilder.Sources.Clear();
             configurationBuilder.AddJsonFile("config.json", true, true);
             configurationBuilder.AddEnvironmentVariables("CookieClicker_");
             configurationBuilder.AddCommandLine(args);
 
             IConfiguration configuration = configurationBuilder.Build();
             serviceCollection.AddSingleton(configuration);
             serviceCollection.AddLogging(loggingBuilder => HttpLogger.ConfigureLogging(loggingBuilder, configuration));
-            serviceCollection.AddDbContext<CookieDatabaseContext>((services, options) => CookieDatabaseContext.ConfigureOptions(options, services.GetRequiredService<IConfiguration>()), ServiceLifetime.Scoped);
             serviceCollection.AddSingleton<CookieTracker>();
             serviceCollection.AddSingleton<DiscordHeaderAuthentication>();
             serviceCollection.AddSingleton<DiscordSlashCommandHandler>();

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@`
`6`	`6`	`using System.Linq;`
`7`	`7`	`using System.Threading;`
`8`	`8`	`using System.Threading.Tasks;`
`9`		`-using Microsoft.EntityFrameworkCore;`
`10`	`9`	`using Microsoft.Extensions.Configuration;`
`11`	`10`	`using Microsoft.Extensions.Logging;`
`12`	`11`	`using Npgsql;`
`@@ -18,52 +17,50 @@ namespace OoLunar.CookieClicker`
`18`	`17`	`{`
`19`	`18`	`public sealed class CookieTracker : IAsyncDisposable`
`20`	`19`	`{`
`21`		`- private readonly Dictionary<Ulid, CachedCookie> UnbakedCookies = new();`
`22`		`- private readonly CookieDatabaseContext DatabaseContext;`
	`20`	`+ private readonly Dictionary<Ulid, CachedCookie> _unbakedCookies = new();`
	`21`	`+ private readonly NpgsqlConnection _databaseConnection;`
`23`	`22`	`private readonly ILogger<CookieTracker> _logger;`
`24`		`- private readonly SemaphoreSlim Semaphore = new(1, 1);`
`25`		`- private readonly PeriodicTimer Timer;`
`26`		`- private readonly Task BakingTask;`
`27`		`- private readonly FrozenDictionary<DatabaseOperation, NpgsqlCommand> DatabaseCommands;`
	`23`	`+ private readonly SemaphoreSlim _semaphore = new(1, 1);`
	`24`	`+ private readonly PeriodicTimer _timer;`
	`25`	`+ private readonly Task _bakingTask;`
	`26`	`+ private readonly FrozenDictionary<DatabaseOperation, NpgsqlCommand> _databaseCommands;`
`28`	`27`
`29`		`- public CookieTracker(CookieDatabaseContext databaseContext, IConfiguration configuration, ILogger<CookieTracker> logger)`
	`28`	`+ public CookieTracker(IConfiguration configuration, ILogger<CookieTracker> logger)`
`30`	`29`	`{`
`31`		`- ArgumentNullException.ThrowIfNull(databaseContext, nameof(databaseContext));`
`32`	`30`	`ArgumentNullException.ThrowIfNull(configuration, nameof(configuration));`
`33`	`31`	`ArgumentNullException.ThrowIfNull(logger, nameof(logger));`
`34`	`32`
`35`	`33`	`_logger = logger;`
`36`		`- Timer = new PeriodicTimer(TimeSpan.FromSeconds(configuration.GetValue("CookieTracker:Period", 30)));`
	`34`	`+ _timer = new PeriodicTimer(TimeSpan.FromSeconds(configuration.GetValue("CookieTracker:Period", 30)));`
`37`	`35`
`38`		`- DatabaseContext = databaseContext;`
`39`		`- NpgsqlConnection connection = (NpgsqlConnection)DatabaseContext.Database.GetDbConnection();`
`40`		`- connection.Open();`
`41`		`- DatabaseCommands = new Dictionary<DatabaseOperation, NpgsqlCommand>`
	`36`	`+ _databaseConnection = NpgsqlDataSource.Create(CookieDatabaseContext.GetConnectionString(configuration)).CreateConnection();`
	`37`	`+ _databaseConnection.Open();`
	`38`	`+ _databaseCommands = new Dictionary<DatabaseOperation, NpgsqlCommand>`
`42`	`39`	`{`
`43`		`- [DatabaseOperation.Create] = GetInsertCommand(connection),`
`44`		`- [DatabaseOperation.Read] = GetSelectCommand(connection),`
`45`		`- [DatabaseOperation.Update] = GetUpdateCommand(connection),`
`46`		`- [DatabaseOperation.Delete] = GetDeleteCommand(connection)`
	`40`	`+ [DatabaseOperation.Create] = GetInsertCommand(_databaseConnection),`
	`41`	`+ [DatabaseOperation.Read] = GetSelectCommand(_databaseConnection),`
	`42`	`+ [DatabaseOperation.Update] = GetUpdateCommand(_databaseConnection),`
	`43`	`+ [DatabaseOperation.Delete] = GetDeleteCommand(_databaseConnection)`
`47`	`44`	`}.ToFrozenDictionary();`
`48`	`45`
`49`		`- BakingTask = StartBakingAsync();`
	`46`	`+ _bakingTask = StartBakingAsync();`
`50`	`47`	`}`
`51`	`48`
`52`	`49`	`public void CreateCookie(Cookie cookie)`
`53`	`50`	`{`
`54`	`51`	`ArgumentNullException.ThrowIfNull(cookie, nameof(cookie));`
`55`		`- UnbakedCookies.Add(cookie.Id, new(cookie, false));`
	`52`	`+ _unbakedCookies.Add(cookie.Id, new(cookie, false));`
`56`	`53`	`}`
`57`	`54`
`58`	`55`	`public ulong Click(Ulid cookieId)`
`59`	`56`	`{`
`60`	`57`	`// Check if the cookie is in the cache. If it isn't, pull it from the database.`
`61`		`- if (!UnbakedCookies.TryGetValue(cookieId, out CachedCookie? unbakedCookie))`
	`58`	`+ if (!_unbakedCookies.TryGetValue(cookieId, out CachedCookie? unbakedCookie))`
`62`	`59`	`{`
`63`		`- Semaphore.Wait();`
	`60`	`+ _semaphore.Wait();`
`64`	`61`	`try`
`65`	`62`	`{`
`66`		`- DbCommand command = DatabaseCommands[DatabaseOperation.Read];`
	`63`	`+ DbCommand command = _databaseCommands[DatabaseOperation.Read];`
`67`	`64`	`command.Parameters[0].Value = cookieId.ToGuid();`
`68`	`65`	`using DbDataReader reader = command.ExecuteReader(CommandBehavior.SingleRow);`
`69`	`66`	`if (!reader.Read())`
`@@ -76,11 +73,11 @@ public ulong Click(Ulid cookieId)`
`76`	`73`	`Id = new Ulid(reader.GetFieldValue<Guid>(0)),`
`77`	`74`	`Clicks = (ulong)reader.GetFieldValue<decimal>(1)`
`78`	`75`	`}, true);`
`79`		`- UnbakedCookies.Add(cookieId, unbakedCookie);`
	`76`	`+ _unbakedCookies.Add(cookieId, unbakedCookie);`
`80`	`77`	`}`
`81`	`78`	`finally`
`82`	`79`	`{`
`83`		`- Semaphore.Release();`
	`80`	`+ _semaphore.Release();`
`84`	`81`	`}`
`85`	`82`	`}`
`86`	`83`
`@@ -90,18 +87,18 @@ public ulong Click(Ulid cookieId)`
`90`	`87`
`91`	`88`	`private async Task StartBakingAsync()`
`92`	`89`	`{`
`93`		`- DbCommand createCommand = DatabaseCommands[DatabaseOperation.Create];`
`94`		`- DbCommand updateCommand = DatabaseCommands[DatabaseOperation.Update];`
`95`		`- foreach (DbCommand command in DatabaseCommands.Values)`
	`90`	`+ DbCommand createCommand = _databaseCommands[DatabaseOperation.Create];`
	`91`	`+ DbCommand updateCommand = _databaseCommands[DatabaseOperation.Update];`
	`92`	`+ foreach (DbCommand command in _databaseCommands.Values)`
`96`	`93`	`{`
`97`	`94`	`await command.PrepareAsync();`
`98`	`95`	`}`
`99`	`96`
`100`		`- while (await Timer.WaitForNextTickAsync())`
	`97`	`+ while (await _timer.WaitForNextTickAsync())`
`101`	`98`	`{`
`102`		`- await Semaphore.WaitAsync();`
`103`		`- CachedCookie[] unbakedCookies = UnbakedCookies.Values.ToArray();`
`104`		`- Semaphore.Release();`
	`99`	`+ await _semaphore.WaitAsync();`
	`100`	`+ CachedCookie[] unbakedCookies = _unbakedCookies.Values.ToArray();`
	`101`	`+ _semaphore.Release();`
`105`	`102`
`106`	`103`	`List<Guid> updatedCookieIds = new();`
`107`	`104`	`List<decimal> updatedCookieCount = new();`
`@@ -120,7 +117,7 @@ private async Task StartBakingAsync()`
`120`	`117`	`}`
`121`	`118`
`122`	`119`	`// Remove the cookie from the unbaked cookies dictionary. Prefer the returned result over the current result.`
`123`		`- if (!UnbakedCookies.Remove(cookie.Cookie.Id, out CachedCookie? unbakedCookie))`
	`120`	`+ if (!_unbakedCookies.Remove(cookie.Cookie.Id, out CachedCookie? unbakedCookie))`
`124`	`121`	`{`
`125`	`122`	`unbakedCookie = cookie;`
`126`	`123`	`}`
`@@ -143,7 +140,7 @@ private async Task StartBakingAsync()`
`143`	`140`	`continue;`
`144`	`141`	`}`
`145`	`142`
`146`		`- await Semaphore.WaitAsync();`
	`143`	`+ await _semaphore.WaitAsync();`
`147`	`144`	`try`
`148`	`145`	`{`
`149`	`146`	`if (newCookieIds.Count != 0)`
`@@ -162,17 +159,17 @@ private async Task StartBakingAsync()`
`162`	`159`	`}`
`163`	`160`	`finally`
`164`	`161`	`{`
`165`		`- Semaphore.Release();`
	`162`	`+ _semaphore.Release();`
`166`	`163`	`}`
`167`	`164`	`}`
`168`	`165`	`}`
`169`	`166`
`170`	`167`	`public async ValueTask DisposeAsync()`
`171`	`168`	`{`
`172`		`- Timer.Dispose();`
`173`		`- await BakingTask;`
`174`		`- await DatabaseContext.DisposeAsync();`
`175`		`- Semaphore.Dispose();`
	`169`	`+ _timer.Dispose();`
	`170`	`+ await _bakingTask;`
	`171`	`+ await _databaseConnection.DisposeAsync();`
	`172`	`+ _semaphore.Dispose();`
`176`	`173`	`}`
`177`	`174`
`178`	`175`	`private static NpgsqlCommand GetSelectCommand(NpgsqlConnection connection)`