potluck-postgres 0.0.2 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48714348049e78a70647696184c95db2198c2de377c72934ab9b935be5b0dfc8
-  data.tar.gz: fcaab8a6ecf0e62e39dee99863f769da0c7da33398887ac55edbe24a0634ff85
+  metadata.gz: e2dc9b254c8fd0d0bd4c7fee8d03705c1fe054577addaacf874286bfb32d0a2a
+  data.tar.gz: b995b1b64aa3bca01392fcf874eaf71a7fae58bf0a5d0da54cc1e42269ed0499
 SHA512:
-  metadata.gz: 6b1acaa045587d18246278775619e472736069b73e8939fa4bf594327307a00f5ab3b2fa00f162b3e804412892bc1f3b8e652e8fd5c258c85f5bff3260df3ebd
-  data.tar.gz: dc1e1845ca72d509624ecc0fd2d3886b2cfbcc105822a5591e7626a4ef5e7557ee567498583e1765d8a551b2e87ab5af76824a28eb0f8d6587b96319d76d2ee7
+  metadata.gz: 734fc97cfe75c7c0af39b2fb65db31dc6fe7d8355995fd339c7ec3808ffb2ee2f01de2b4852753b8ad45acde92a508126eef475725db2327c2482721c0a3b1d2
+  data.tar.gz: 108749ea87986e3af08ef7f392b381880a5b391f44a3e86c237620c52a60c67bd591c8784d59a27c8b75ac88e3016ebb4987d0bb33054b28d7712312d705f357

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2021 Nate Pickens
+Copyright 2021-2022 Nate Pickens
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 documentation files (the "Software"), to deal in the Software without restriction, including without

data/lib/potluck/postgres.rb

@@ -4,79 +4,122 @@ require('potluck')
 require('sequel')
 
 module Potluck
-  class Postgres < Dish
+  ##
+  # Error class used to wrap errors encountered while connecting to or setting up a database.
+  #
+  class PostgresError < ServiceError
+    attr_reader(:wrapped_error)
+
+    ##
+    # Creates a new instance.
+    #
+    # * +message+ - Error message.
+    # * +wrapped_error+ - Original error that was rescued and is being wrapped by this one (optional).
+    #
+    def initialize(message, wrapped_error = nil)
+      super(message)
+
+      @wrapped_error = wrapped_error
+    end
+  end
+
+  ##
+  # A Ruby interface for controlling and connecting to Postgres. Uses
+  # [Sequel](https://github.com/jeremyevans/sequel) to connect and perform automatic role and database
+  # creation, as well as for utility methods such as database schema migration.
+  #
+  class Postgres < Service
+    ROLE_NOT_FOUND_REGEX = /role .* does not exist/.freeze
+    DATABASE_NOT_FOUND_REGEX = /database .* does not exist/.freeze
+
+    STARTING_UP_STRING = 'the database system is starting up'
+    STARTING_UP_TIMEOUT = 30
+
+    CONNECTION_REFUSED_STRING = 'connection refused'
+    CONNECTION_REFUSED_TIMEOUT = 3
+
     attr_reader(:database)
 
+    ##
+    # Creates a new instance.
+    #
+    # * +config+ - Configuration hash to pass to <tt>Sequel.connect</tt>.
+    # * +args+ - Arguments to pass to Potluck::Service.new (optional).
+    #
     def initialize(config, **args)
       super(**args)
 
       @config = config
     end
 
-    def connect
-      (tries ||= 0) && (tries += 1)
-      @database = Sequel.connect(@config, logger: @logger)
-    rescue Sequel::DatabaseConnectionError => e
-      if (dud = Sequel::DATABASES.last)
-        dud.disconnect
-        Sequel.synchronize { Sequel::DATABASES.delete(dud) }
-      end
-
-      if e.message =~ /role .* does not exist/ && tries == 1
-        create_database_role
-        create_database
-        retry
-      elsif e.message =~ /database .* does not exist/ && tries == 1
-        create_database
-        retry
-      elsif (@is_local && tries < 3) && (e.message.include?('could not connect') ||
-          e.message.include?('the database system is starting up'))
-        sleep(1)
-        retry
-      elsif e.message.include?('could not connect')
-        abort("#{e.class}: #{e.message.strip}")
-      else
-        abort("#{e.class}: #{e.message.strip}\n  #{e.backtrace.join("\n  ")}")
-      end
-    end
-
-    def disconnect
-      @database&.disconnect
+    ##
+    # Disconnects and stops the Postgres process.
+    #
+    def stop
+      disconnect
+      super
     end
 
-    def create_database_role
-      tmp_config = @config.dup
-      tmp_config[:database] = 'postgres'
-      tmp_config[:username] = ENV['USER']
-      tmp_config[:password] = nil
+    ##
+    # Connects to the configured Postgres database.
+    #
+    def connect
+      role_created = false
+      database_created = false
 
       begin
-        Sequel.connect(tmp_config, logger: @logger) do |database|
-          database.execute("CREATE ROLE #{@config[:username]} WITH LOGIN CREATEDB REPLICATION PASSWORD "\
-            "'#{@config[:password]}'")
+        (tries ||= 0) && (tries += 1)
+        @database = Sequel.connect(@config, logger: @logger)
+      rescue Sequel::DatabaseConnectionError => e
+        if (dud = Sequel::DATABASES.last)
+          dud.disconnect
+          Sequel.synchronize { Sequel::DATABASES.delete(dud) }
         end
-      rescue => e
-        @logger.error("#{e.class}: #{e.message.strip}\n  #{e.backtrace.join("\n  ")}\n")
-        abort("Could not create role '#{@config[:username]}'. Make sure database user '#{ENV['USER']}' "\
-          'has permission to do so, or create it manually.')
-      end
-    end
 
-    def create_database
-      tmp_config = @config.dup
-      tmp_config[:database] = 'postgres'
-
-      begin
-        Sequel.connect(tmp_config, logger: @logger) do |database|
-          database.execute("CREATE DATABASE #{@config[:database]}")
+        message = e.message.downcase
+
+        if message =~ ROLE_NOT_FOUND_REGEX && !role_created && manage?
+          role_created = true
+          create_role
+          retry
+        elsif message =~ DATABASE_NOT_FOUND_REGEX && !database_created && manage?
+          database_created = true
+          create_database
+          retry
+        elsif message.include?(STARTING_UP_STRING) && tries < STARTING_UP_TIMEOUT
+          sleep(1)
+          retry
+        elsif message.include?(CONNECTION_REFUSED_STRING) && tries < CONNECTION_REFUSED_TIMEOUT
+          sleep(1)
+          retry
+        elsif message.include?(CONNECTION_REFUSED_STRING)
+          raise(PostgresError.new(e.message.strip, e))
+        else
+          raise
         end
-      rescue => e
-        @logger.error("#{e.class}: #{e.message.strip}\n  #{e.backtrace.join("\n  ")}\n")
-        abort("Could not create database '#{@config[:database]}'. Make sure database user "\
-          "'#{@config[:username]}' has permission to do so, or create it manually.")
       end
+
+      # Only grant permissions if the database already existed but the role did not. Automatic database
+      # creation (via #create_database) is performed as the configured role, which means explicit permission
+      # granting is not necessary.
+      grant_permissions if role_created && !database_created
+    end
+
+    ##
+    # Disconnects from the database if a connection was made.
+    #
+    def disconnect
+      @database&.disconnect
     end
 
+    ##
+    # Runs database migrations by way of Sequel's migration extension. Migration files must use the
+    # timestamp naming strategy as opposed to integers.
+    #
+    # * +dir+ - Directory where migration files are located.
+    # * +steps+ - Number of steps forward or backward to migrate from the current migration, otherwise will
+    #   migrate to latest (optional).
+    #
     def migrate(dir, steps = nil)
       return unless File.directory?(dir)
 
@@ -84,9 +127,9 @@ module Potluck
 
       # Suppress Sequel schema migration table queries.
       original_level = @logger.level
-      @logger.level = Logger::WARN
+      @logger.level = Logger::WARN if @logger.level == Logger::INFO
 
-      args = [Sequel::Model.db, dir, {allow_missing_migration_files: true}]
+      args = [@database, dir, {allow_missing_migration_files: true}]
       migrator = Sequel::TimestampMigrator.new(*args)
 
       return if migrator.files.empty?
@@ -107,10 +150,13 @@ module Potluck
       migrator = Sequel::TimestampMigrator.new(*args)
       @logger.level = original_level
       migrator.run
+    ensure
+      @logger.level = original_level if original_level
     end
 
-    private
-
+    ##
+    # Content of the launchctl plist file.
+    #
     def self.plist
       super(
         <<~EOS
@@ -129,5 +175,78 @@ module Potluck
         EOS
       )
     end
+
+    private
+
+    ##
+    # Attempts to connect to the 'postgres' database as the system user with no password and create the
+    # configured role. Useful in development.
+    #
+    def create_role
+      tmp_config = admin_database_config
+      tmp_config[:database] = 'postgres'
+
+      begin
+        Sequel.connect(tmp_config, logger: @logger) do |database|
+          database.execute("CREATE ROLE \"#{@config[:username]}\" WITH LOGIN CREATEDB REPLICATION"\
+            "#{" PASSWORD '#{@config[:password]}'" if @config[:password]}")
+        end
+      rescue => e
+        raise(PostgresError.new("Failed to create database role #{@config[:username].inspect} by "\
+          "connecting to database #{tmp_config[:database].inspect} as role "\
+          "#{tmp_config[:username].inspect}. Please create the role manually.", e))
+      end
+    end
+
+    ##
+    # Attempts to connect to the 'postgres' database with the configured user and password and create the
+    # configured database. Useful in development.
+    #
+    def create_database
+      tmp_config = @config.dup
+      tmp_config[:database] = 'postgres'
+
+      begin
+        Sequel.connect(tmp_config, logger: @logger) do |database|
+          database.execute("CREATE DATABASE \"#{@config[:database]}\"")
+        end
+      rescue => e
+        raise(PostgresError.new("Failed to create database #{@config[:database].inspect} by connecting to "\
+          "database #{tmp_config[:database].inspect} as role #{tmp_config[:username].inspect}. "\
+          'Please create the database manually.', e))
+      end
+    end
+
+    ##
+    # Grants appropriate permissions for the configured database role.
+    #
+    def grant_permissions
+      tmp_config = admin_database_config
+
+      begin
+        Sequel.connect(tmp_config, logger: @logger) do |db|
+          db.execute("GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO \"#{@config[:username]}\"")
+          db.execute("GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO \"#{@config[:username]}\"")
+          db.execute("ALTER DEFAULT PRIVILEGES FOR ROLE \"#{@config[:username]}\" IN SCHEMA public GRANT "\
+            "ALL PRIVILEGES ON TABLES TO \"#{@config[:username]}\"")
+        end
+      rescue => e
+        raise(PostgresError.new("Failed to grant database permissions for role "\
+          "#{@config[:username].inspect} by connecting as role #{tmp_config[:username].inspect}. Please "\
+          'grant appropriate permissions manually.', e))
+      end
+    end
+
+    ##
+    # Returns a configuration hash for connecting to Postgres to perform administrative tasks (i.e. role and
+    # database creation). Uses the system user as the username and no password.
+    #
+    def admin_database_config
+      config = @config.dup
+      config[:username] = ENV['USER']
+      config[:password] = nil
+
+      config
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: potluck-postgres
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.6
 platform: ruby
 authors:
 - Nate Pickens
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-13 00:00:00.000000000 Z
+date: 2022-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: potluck
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.2
+        version: 0.0.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.2
+        version: 0.0.6
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -119,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.32
 signing_key:
 specification_version: 4
 summary: A Ruby manager for Postgres.