story-teller 1.1.3

data/lib/story_teller/database.rb

@@ -0,0 +1,527 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# Copyright Nels Nelson 2008-2025 but freely usable (see license)
+#
+# This file is part of the StoryTeller.
+#
+# The StoryTeller is free software: you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# The StoryTeller is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with the StoryTeller.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'open3'
+require 'sequel'
+require 'uri'
+
+# The Sequel module
+module Sequel
+  # The Sequel::Migration class
+  class Migration
+    def self.up
+      self.apply(Sequel::Model.db, :up)
+    end
+    def self.down
+      self.apply(Sequel::Model.db, :down)
+    end
+    def self.table_exists?(table)
+      Sequel::Model.db.table_exists?(table)
+    end
+  end
+end
+
+# The Databases module
+module Databases
+  # The Databases::Helpers module
+  module Helpers
+    MigrationMethods = %i[down up].freeze
+    NamespaceDelimiterPattern = /::/.freeze
+    DatabasePattern = /Database/.freeze
+
+    def class_derived_database_name
+      self.class.name.split(NamespaceDelimiterPattern).last.sub(DatabasePattern, '')
+    end
+
+    def implicit_database_name
+      implicit_database_name = self.class.name
+      begin
+        implicit_database_name = underscore(demodulize(class_derived_database_name)).to_sym
+      rescue StandardError => e
+        log.warn "Failed to get implicit database name: #{e.message}"
+      end
+      implicit_database_name
+    end
+
+    def database
+      # implicit_database_name
+      underscore(Inform::Databases.instances.keys.first).to_sym
+    end
+
+    def execute(sql)
+      Sequel::Model.db[sql]
+    end
+
+    def run(sql)
+      Sequel::Model.db.run(sql)
+    end
+
+    def database_exist?(database_name = database)
+      result = execute("select count(*) > 0 from pg_catalog.pg_database where datname = '#{database_name}';")&.first
+      result&.values&.first == true
+    end
+
+    def user_exist?(username = database)
+      result = execute("select count(*) > 0 from pg_shadow where usename = '#{username}';")&.first
+      result&.values&.first == true
+    end
+
+    def connected_database
+      return nil unless Sequel::Model.db
+      Sequel::Model.db.opts[:uri].to_s.scan(/:\/\/\w+(:\d+|\/)(\w+)/).last
+    end
+
+    def connected_username
+      return nil unless Sequel::Model.db
+      Sequel::Model.db.opts[:uri].to_s.scan(/user=(\w+)/).first
+    end
+  end
+end
+
+if defined? GlobalSequelIdentityMap
+  # The Sequel module
+  module Sequel
+    # The Sequel::Plugins module
+    module Plugins
+      # The Sequel::Plugins::IdentityMap module
+      module IdentityMap
+        # The Sequel::Plugins::IdentityMap::ClassMethods module
+        module ClassMethods
+          # Returns the global thread-safe identity map.
+          def identity_map
+            log.debug "Getting identity map"
+            GlobalSequelIdentityMap
+          end
+
+          private
+
+          # Set the thread local identity map to the given value.
+          def identity_map=(v)
+            silence_warnings do
+              log.warn "Setting identity map"
+              Object.instance_eval { const_set :GlobalSequelIdentityMap, v }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# The DatabaseConnectionHelpers module
+module DatabaseConnectionHelpers
+  DefaultConnectionOptions = { loggerLevel: 'OFF' }.freeze
+  DefaultConnectionPoolSize = 4
+  DefaultConnectionValidationTimeoutSeconds = 240
+  URLTemplate = '%<scheme>s://%<host>s%<colon>s%<port>s'.freeze
+  KeyValueTemplate = '%<key>s=%<value>s'.freeze
+  EmptyString = ''.freeze
+  AmpersandString = '&'.freeze
+  ColonString = ':'.freeze
+  ForwardSlashString = '/'.freeze
+  QuestionMarkString = '?'.freeze
+  JavaPattern = /java/i.freeze
+
+  @connection_attempts = 0
+
+  def self.connection_attempts
+    @connection_attempts
+  end
+
+  def self.increment_connection_attempts
+    @connection_attempts += 1
+  end
+
+  # Previously:
+  # url = "#{adapter}://#{host}/#{database}?user=#{username}"
+  # url << "&password=#{password}" unless password.nil? || password.empty?
+  # url << "&loggerLevel=OFF"
+  # rubocop: disable Metrics/AbcSize
+  # rubocop: disable Metrics/CyclomaticComplexity
+  # rubocop: disable Metrics/MethodLength
+  # rubocop: disable Metrics/PerceivedComplexity
+  def assemble_url
+    adapter = config.fetch('adapter')
+    adapter.gsub!(/^postgres/, 'jdbc:postgresql') if JavaPattern.match?(RUBY_PLATFORM)
+    host = config.fetch('host', nil)
+    port = config.fetch('port', nil)
+    colon = port.nil? ? EmptyString : ColonString
+    database = config.fetch('database', nil)
+    username = config.fetch('username', nil)
+    password = config.fetch('password', nil)
+    parameters = DefaultConnectionOptions.dup
+    parameters.merge!(user: username) unless username.nil?
+    parameters.merge!(password: password) unless password.nil? || password.empty?
+    parameter_values = parameters.map { |key, value| format(KeyValueTemplate, key: key, value: value) }
+    query = parameter_values.join(AmpersandString)
+    url = [format(URLTemplate, scheme: adapter, host: host, colon: colon, port: port)]
+    url << database unless database.nil? || database.empty?
+    url = [url.join(ForwardSlashString)]
+    url << query unless query.nil? || query.empty?
+    url.join(QuestionMarkString)
+  end
+  # rubocop: enable Metrics/AbcSize
+  # rubocop: enable Metrics/CyclomaticComplexity
+  # rubocop: enable Metrics/MethodLength
+  # rubocop: enable Metrics/PerceivedComplexity
+
+  DatabaseOrRoleDoesNotExistPattern = /(database|role) ".*" does not exist/.freeze
+
+  # rubocop: disable Metrics/AbcSize
+  # rubocop: disable Metrics/MethodLength
+  def connect(database = config.fetch('database', nil), url = assemble_url, connection_options = {})
+    log.debug "Connecting to database #{sanitize_url(url)}" if defined? log
+    DatabaseConnectionHelpers.increment_connection_attempts
+    connection_options[:max_connections] = config.fetch('pool', DefaultConnectionPoolSize)
+    connection = Sequel.connect(url, **connection_options)
+    connection.extension(:connection_validator)
+    connection.pool.connection_validation_timeout = DefaultConnectionValidationTimeoutSeconds
+    connection.test_connection
+    log.debug "Connected to database #{database}" if defined? log
+    Sequel::Model.require_valid_table = false
+    Sequel::Model.db = connection
+  rescue Sequel::DatabaseConnectionError => e
+    raise if e.cause.is_a?(PG::ConnectionBad) && DatabaseOrRoleDoesNotExistPattern.match?(e.cause.to_s)
+    error_message = e.message.gsub(/Java::OrgPostgresqlUtil::PSQLException: /, '')
+    error_message = "Error connecting to database: #{error_message}"
+    log.error error_message
+    abort
+  rescue Sequel::AdapterNotFound => e
+    error_message = "Adapter not found: #{e.message}"
+    log.error error_message
+    abort
+  rescue StandardError => e
+    error_message = "Unexpected error connecting to database: #{e.message}"
+    log.error error_message, e
+    abort
+  end
+  # rubocop: enable Metrics/AbcSize
+  # rubocop: enable Metrics/MethodLength
+
+  def sanitize_url(url)
+    url.gsub(/&?(password|loggerLevel)=[^&]+&?/, '').gsub(/\?$/, '')
+  end
+end
+# module DatabaseConnectionHelpers
+
+# The Databases module
+module Databases
+  # The Databases::Management module
+  module Management
+    include DatabaseConnectionHelpers
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/MethodLength
+    def reconnect_database(url)
+      log.debug "Reconnecting to database #{sanitize_url(url)}"
+      begin
+        Sequel::Model.db&.disconnect
+      rescue StandardError => e
+        log.warn "Encountered unexpected error disconnecting from database: #{e.message}"
+      end
+      Sequel::Model.db = Sequel.connect(url)
+      Sequel::Model.descendants.each do |model|
+        model_dataset = begin
+          model.dataset
+        rescue Sequel::Error => e
+          nil
+        end
+        model.db = Sequel::Model.db if model_dataset.nil?
+      end
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/MethodLength
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/MethodLength
+    def create_database(database_name = database, username = database)
+      return false if database_exist?(database_name)
+      begin
+        log.info "Creating database: #{database_name}"
+        create_user username unless user_exist?(username)
+        run "create database #{database_name} owner #{username}"
+      rescue StandardError => e
+        database_already_exists_error_pattern = /ERROR: database "#{database_name}" already exists/
+        if database_already_exists_error_pattern.match?(e.to_s)
+          unless defined? tried_once_already
+            drop_database database_name
+            tried_once_already = true # rubocop: disable Lint/UselessAssignment
+            retry
+          end
+        end
+        log.error "Unexpected error creating database: #{e.inspect}"
+        e.backtrace.each { |t| log.error t }
+        return false
+      end
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/MethodLength
+
+    CannotDropOpenDatabaseErrorPattern = /ERROR: cannot drop the currently open database/.freeze
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/MethodLength
+    def drop_database(database_name = database)
+      return false unless database_exist?(database_name)
+      begin
+        log.info "Dropping database: #{database_name}"
+        run "drop database #{database_name}"
+      rescue Sequel::DatabaseError => e
+        log.error "Unexpected error creating database: #{e.inspect}"
+        e.backtrace.each { |t| log.error t }
+        return false
+      rescue StandardError => e
+        if CannotDropOpenDatabaseErrorPattern.match?(e.to_s)
+          results = execute "select procpid from pg_stat_activity where datname = '#{database_name}'"
+          results.each do |row|
+            log.debug "You must first kill process with pid #{row['procpid']}"
+            command = format('sudo kill -9 %<procpid>s', procpid: row['procpid'])
+            log.debug "Execute: #{command}"
+            # `#{command}`
+          end
+        end
+        log.error "Unexpected error creating database: #{e.inspect}"
+        e.backtrace.each { |t| log.error t }
+        return false
+      end
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/MethodLength
+  end
+  # module Management
+end
+# module Databases
+
+# The Databases module
+module Databases
+  # The Utilities module
+  module Utilities
+    DefaultSchema = if JavaPattern.match?(RUBY_PLATFORM)
+      'jdbc:postgresql'
+    else
+      'postgresql'
+    end.freeze
+    DatabaseURITemplate = '%<schema>s://%<host>s%<port>s/%<database_name>s'.freeze
+    PortTemplate = ':%<port>s'.freeze
+    URITemplate = '%<uri>s?%<query_string>s'.freeze
+    EmptyString = ''.freeze
+    DatabaseConfig = Struct.new(
+      :schema, :host, :port, :database, :user, :password, :logger_level
+    )
+
+    def switch_database(database_name = database)
+      reconnect_database(database_url({database_name: database_name}))
+      true
+    end
+
+    def switch_user(username = database, database_name = nil)
+      url = database_url({username: username, database_name: database_name})
+      reconnect_database(url)
+      true
+    end
+
+    # Build a JDBC URL string from config + overrides.
+    #
+    # overrides: hash of config keys (schema, host, port, database, user, password, logger_level)
+    # exclude: array of query param keys as *external* names, e.g. [:loggerLevel]
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/MethodLength
+    def database_url(overrides = {}, exclude: [])
+      config = connection_config.merge(overrides)
+      base_url = format(
+        DatabaseURITemplate,
+        schema: config[:schema] || DefaultSchema,
+        host: config[:host],
+        port: config[:port] ? format(PortTemplate, port: config[:port]) : EmptyString,
+        database_name: config[:database]
+      )
+
+      query = {}
+      query[:user] = config[:user]
+      query[:password] = config[:password]
+      query[:loggerLevel] = config[:loggerLevel]
+      query.reject! { |k, v| v.nil? || exclude.include?(k) }
+
+      return base_url if query.empty?
+      query_string = URI.encode_www_form(query.transform_keys(&:to_s))
+      format(URITemplate, uri: base_url, query_string: query_string)
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/MethodLength
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/CyclomaticComplexity
+    def connection_config
+      opts = Sequel::Model.db.opts
+
+      DatabaseConfig.new(
+        schema: opts[:adapter] && opts[:adapter].to_s || DEFAULT_SCHEMA,
+        host: opts[:host] || "localhost",
+        port: opts[:port],
+        database: opts[:database] || database,
+        user: opts[:user] || database,
+        password: opts[:password] || opts[:user] || database,
+        logger_level: "OFF"
+      ).to_h
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/CyclomaticComplexity
+
+    # rubocop: disable Metrics/MethodLength
+    def create_user(username = database)
+      return false if user_exist?(username)
+      begin
+        log.debug "Creating user: #{username}"
+        run "create user #{username}"
+        run "alter role #{username} with password '#{username}'"
+        return true
+      rescue Sequel::DatabaseError => e
+        log.error e.inspect
+        return false
+      rescue StandardError => e
+        log.error e.inspect
+        return false
+      end
+    end
+    # rubocop: enable Metrics/MethodLength
+
+    # rubocop: disable Metrics/MethodLength
+    def delete_user(username = database)
+      return false unless user_exist?(username)
+      begin
+        log.debug "Dropping user: #{username}"
+        run "reassign owned by #{username} to postgres"
+        run "drop user #{username}"
+      rescue Sequel::DatabaseError => e
+        log.error e.inspect
+        return false
+      rescue StandardError => e
+        log.error e.inspect
+        return false
+      end
+    end
+    # rubocop: enable Metrics/MethodLength
+  end
+  # module Utilities
+end
+# module Databases
+
+# The Sequel module
+module Sequel
+  # The Sequel::Postgres module
+  module Postgres
+    if defined?(Sequel::Migration)
+      # The Sequel::Postgres::Bootstrap class
+      class Bootstrap < Sequel::Migration
+        include Sequel::Inflections
+        include Databases::Helpers
+        include Databases::Management
+        include Databases::Utilities
+
+        def up
+          create_user
+          create_database
+          switch_database
+          switch_user
+        end
+
+        def down
+          switch_database :postgres
+          drop_database
+          delete_user
+        end
+
+        def self.migrate
+          MigrationMethods.each do |method_name|
+            Inform::Databases.instances.each_value { |db| db.send(method_name) }
+          end
+        end
+
+        def self.up
+          Inform::Databases.instances.each_value { |db| db.send(:up) }
+        end
+      end
+      # class Bootstrap
+    end
+    # defined?(Sequel::Migration)
+  end
+  # module Postgres
+end
+# module Sequel
+
+# The Inform module
+module Inform
+  # The Databases module
+  module Databases
+    @instances = {}
+    def instances
+      @instances
+    end
+    module_function :instances
+  end
+end
+
+if defined?(Sequel::Postgres::Bootstrap)
+# The Greenfield module
+module Greenfield
+  # The Database abstraction class
+  class Database
+    attr_reader :bootstrap
+
+    def self.init(database_name)
+      Greenfield::Database.instance(database_name)
+    end
+
+    @instance_mutex = Mutex.new
+
+    def self.instance(*args)
+      return @instance unless @instance.nil?
+      @instance_mutex.synchronize do
+        @instance ||= new(*args)
+      end
+      @instance
+    end
+
+    private_class_method :new
+
+    def initialize(env = Game.environment)
+      log.debug "Initializing persistence layer for environment: #{env}"
+      log.debug caller[0..4]
+      env ||= environment
+      @config = database_config.fetch(env.to_s, {})
+      establish_database_connection
+      enable_plugins
+    end
+    REGISTRY = Struct.new(:memo).new(defined?(Java) ? java.util.concurrent.ConcurrentHashMap.new : {})
+    def initialize(database_name)
+      @bootstrap = Sequel::Postgres::Bootstrap.new(Sequel::Model.db)
+      Inform::Databases.instances[database_name] = self
+    end
+
+    private
+
+    def ensure_game_state_flushed
+      Sequel::Model.db.synchronize {} # rubocop: disable Lint/EmptyBlock
+    end
+  end
+end
+# module Greenfield
+end
+# defined?(Sequel::Postgres::Bootstrap)