uff_db_loader 1.4.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b64fcfeeeda9c2895262cabcf104828511ae1a17abe6c906c040f5b132c48bc3
-  data.tar.gz: 166953900412522babe8958ddbadef253b8e3558c487d67c53962679252dbd29
+  metadata.gz: 28a567bb65dcdcc545605a5b8b921abe6fb6b4b666d97928e659bf535a1675ed
+  data.tar.gz: 4deffc2f8bad009cd16d04f08280765be75042da0f6e6e97d488addd22a51065
 SHA512:
-  metadata.gz: bf80b9b22d70bf31fe2b8f2d4c9d2f84e9b23a5448e2a94fcdbfe43fdd5a4155a06da935846f3df41cf34528b1e71a17dcc697bce68a5263e09becad424ae31c
-  data.tar.gz: 74b533e7f45a5b5292d74c7660709f14b60f2a3c8dfa61f390314c4145f7cdcc00f079cd3c253f24f44599518b16eb00ea6edcb37640139f2e1ae9b214b64c19
+  metadata.gz: 22b2e2a27364e1afccda77edf18218c9c0862ee0ef389126e745848fceb08fb9fb73b042e07a71a9bddacc2818262d36c9ba109cadc5840c1c3b6175190ccfb5
+  data.tar.gz: d8ddddf06be94aa6d2799e7beaeff371c2897cbb7cf6e83855ed112325cc2796732c23082214aa9aa938be023f881e354d2607197dd01a9923777962068c555f

data/README.md

@@ -6,7 +6,7 @@
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add this line to your application's `Gemfile`:
 
 ```ruby
 gem 'uff_db_loader'
@@ -20,14 +20,16 @@ Or install it yourself as:
 
     $ gem install uff_db_loader
 
+Run the installation script: 
+
+    $ bin/rails uff_db_loader:install
+
 ## Configuration
 
 You can configure the gem by running the following during the initialization of the Rails app:
 ```ruby
-# frozen_string_literal: true
-
 UffDbLoader.configure do |config|
-  config.environments = ['sandbox', 'production'] # default is "['staging', 'production']"
+  config.environments = ['staging', 'production']
   config.ssh_user = 'Francina'
   config.ssh_host = 'host.of.yoursite'
   config.db_name = 'twotter'
@@ -43,10 +45,13 @@ Make sure the app's database user has the superuser role. Otherwise the app will
 
 ## Usage
 
-`uff_db_loader` provides `rails uff_db_loader:dump` and `rails uff_db_loader:load` which will prompt for a configured environment.
-`dump` will only create and download a current database dump, while `load`, will do the same and restore the database content into a new database and gives instructions on how to use it in development.
-
+`uff_db_loader` can be called like `bin/rails uff_db_loader:<task>` where `<task>` is one of the following:
 
+- `dump`: Dumps a remote database from a selected environment and downloads it
+- `restore`: Restores a downloaded dump into a local database
+- `switch`: Selects a restored local database to use
+- `load`: Dumps a remote database from a selected environment and downloads it then restores and selects the database
+- `prune`: Delete all downloaded db dumps and removes all databases created by UffDbLoader
 
 ## Development
 

data/lib/configuration.rb

@@ -8,7 +8,7 @@ module UffDbLoader
     attr_accessor :environments, :ssh_host, :ssh_user, :db_name, :db_system, :app_name, :dumps_directory, :database_config_file
 
     def initialize
-      @environments = %w[staging production]
+      @environments = nil
       @ssh_host = nil
       @ssh_user = nil
       @db_name = nil

data/lib/uff_db_loader/tasks/uff_db_loader.rake

@@ -3,9 +3,11 @@
 require "tty-prompt"
 
 namespace :uff_db_loader do
-  desc "Install uff_db_loader"
+  desc "Set up UffDbLoader"
   task install: :environment do
-    UffDbLoader.remember_database_name("") # ensure database file exists
+    UffDbLoader.create_initializer
+
+    puts "👶 Created a Rails initializer file at #{UffDbLoader.initializer_path}."
 
     if UffDbLoader.setup_dynamic_database_name_in_config
       puts "🤖 Updated #{UffDbLoader.config.database_config_file}. Happy hacking, beep boop!"
@@ -15,7 +17,7 @@ namespace :uff_db_loader do
     end
   end
 
-  desc "Dumps a remote database to #{UffDbLoader.config.dumps_directory}"
+  desc "Dumps a remote database from a selected environment to #{UffDbLoader.config.dumps_directory}"
   task dump: :environment do
     prompt = TTY::Prompt.new
     environment = prompt.select("Which environment should we get the dump from?", UffDbLoader.config.environments)
@@ -23,22 +25,7 @@ namespace :uff_db_loader do
     UffDbLoader.dump_from(environment)
   end
 
-  desc "Gets a dump from remote and loads it into the local database"
-  task load: :environment do
-    UffDbLoader.ensure_installation!
-
-    prompt = TTY::Prompt.new
-    environment = prompt.select("Which environment should we get the dump from?", UffDbLoader.config.environments)
-    UffDbLoader.ensure_valid_environment!(environment)
-    result_file_path = UffDbLoader.dump_from(environment)
-
-    puts "🤓 Reading from to #{result_file_path}"
-
-    database_name = File.basename(result_file_path, ".*")
-    UffDbLoader.load_dump_into_database(database_name)
-  end
-
-  desc "Loads an existing dump into the local database"
+  desc "Restores a downloaded dump into a local database"
   task restore: :environment do
     UffDbLoader.ensure_installation!
 
@@ -49,7 +36,7 @@ namespace :uff_db_loader do
     UffDbLoader.load_dump_into_database(database_name)
   end
 
-  desc "Switches to an existing database"
+  desc "Selects a restored local database to use"
   task switch: :environment do
     UffDbLoader.ensure_installation!
 
@@ -58,13 +45,32 @@ namespace :uff_db_loader do
     new_database = prompt.select("Which database do you want to switch to?", databases)
 
     UffDbLoader.remember_database_name(new_database)
-    system("bin/rails restart")
+    UffDbLoader.restart_rails_server
 
     puts "♻️  Restarted rails server with new database."
   end
 
-  desc "Delete all downloaded db dumps and remove all databases created by UffDbLoader"
+  desc "Dumps a remote database from a selected environment to #{UffDbLoader.config.dumps_directory}, then restores and selects the database"
+  task load: :environment do
+    UffDbLoader.ensure_installation!
+
+    prompt = TTY::Prompt.new
+    environment = prompt.select("Which environment should we get the dump from?", UffDbLoader.config.environments)
+    UffDbLoader.ensure_valid_environment!(environment)
+    result_file_path = UffDbLoader.dump_from(environment)
+
+    puts "🤓 Reading from to #{result_file_path}"
+
+    database_name = File.basename(result_file_path, ".*")
+    UffDbLoader.load_dump_into_database(database_name)
+  end
+
+  desc "Delete all downloaded db dumps and removes all databases created by UffDbLoader"
   task prune: :environment do
+    # switch to default db so we can also drop the currently connected database
+    UffDbLoader.remember_database_name("")
+    ActiveRecord::Base.connection.reconnect!
+
     UffDbLoader.databases.each do |database_name|
       puts "Dropping #{database_name}"
       UffDbLoader.drop_database(database_name)

data/lib/uff_db_loader/templates/uff_db_loader_initializer.erb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Check out our README: https://github.com/rmehner/uff_db_loader/blob/main/README.md
+
+if defined?(UffDbLoader)
+  UffDbLoader.configure do |config|
+    config.ssh_user = 'SSH_USER'
+    config.ssh_host = 'HOST_OF_YOUR_SITE'
+    config.db_name = 'YOUR_DATABASE_NAME'
+    config.db_system = <%= used_database_system %> # Possible values are :postgresql and :mysql
+    config.environments = <%= environments %>
+
+    # Optional settings:
+    # config.app_name = 'my_app' # Defaults to the Rails app name
+    # config.dumps_directory = '/path/to/dumps' # Defaults to Rails.root.join('dumps')
+    # config.database_config_file = 'path/to/database.yml' # Defaults to Rails.root.join('config', 'database.yml')
+  end
+end

data/lib/uff_db_loader/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module UffDbLoader
-  VERSION = "1.4.0"
+  VERSION = "2.0.0"
 end

data/lib/uff_db_loader.rb

@@ -6,143 +6,183 @@ require "configuration"
 module UffDbLoader
   require "railtie"
 
-  def self.config
-    @configuration ||= Configuration.new
-  end
+  class << self
+    def config
+      @configuration ||= Configuration.new
+    end
 
-  def self.database_name_file
-    Rails.root.join("tmp", "uff_db_loader_database_name")
-  end
+    def reset
+      @configuration = Configuration.new
+    end
 
-  def self.reset
-    @configuration = Configuration.new
-  end
+    def configure
+      yield(config)
+    end
 
-  def self.configure
-    yield(config)
-  end
+    def restart_rails_server
+      system("bin/rails restart")
+    end
 
-  def self.dump_filename(environment)
-    File.join(
-      config.dumps_directory,
-      Time.now.strftime("#{config.app_name}_#{environment}_%Y_%m_%d_%H_%M_%S.#{config.database_system.dump_extension}")
-    )
-  end
+    def dump_from(environment)
+      FileUtils.mkdir_p(config.dumps_directory)
 
-  def self.dump_from(environment)
-    FileUtils.mkdir_p(config.dumps_directory)
+      puts "⬇️  Creating dump ..."
 
-    puts "⬇️  Creating dump ..."
+      target = dump_file_path(Time.now.strftime("#{config.app_name}_#{environment}_%Y_%m_%d_%H_%M_%S)"))
 
-    target = dump_filename(environment)
+      command_successful = system(dump_command(environment, target))
+      raise "Command did not run succesful: #{dump_command(environment, target)}" unless command_successful
 
-    command_successful = system(dump_command(environment, target))
-    raise "Command did not run succesful: #{dump_command(environment, target)}" unless command_successful
+      puts "✅ Succesfully dumped to #{target}"
 
-    puts "✅ Succesfully dumped to #{target}"
+      target
+    end
 
-    target
-  end
+    def ensure_valid_environment!(environment)
+      unless config.environments.include?(environment)
+        raise ForbiddenEnvironmentError, "Invalid environment: #{environment}."
+      end
+    end
 
-  def self.create_database(database_name)
-    config.database_system.create_database(database_name)
-  end
+    def prune_dump_directory
+      FileUtils.rm_rf("#{config.dumps_directory}/.", secure: true)
+    end
 
-  def self.dump_command(environment, target)
-    config
-      .database_system
-      .dump_command_template
-      .gsub("%environment%", environment)
-      .gsub("%host%", config.ssh_host)
-      .gsub("%user%", config.ssh_user)
-      .gsub("%database%", config.database)
-      .gsub("%target%", target)
-      .gsub("%app_name%", config.app_name)
-  end
+    def create_database(database_name)
+      config.database_system.create_database(database_name)
+    end
 
-  def self.ensure_valid_environment!(environment)
-    unless config.environments.include?(environment)
-      raise ForbiddenEnvironmentError, "Invalid environment: #{environment}."
+    def drop_database(database_name)
+      config.database_system.drop_database(database_name)
     end
-  end
 
-  def self.restore_command(database_name, result_file_path)
-    config.database_system.restore_command(database_name, result_file_path)
-  end
+    def databases
+      config.database_system.list_databases.select do |line|
+        line =~ /#{config.app_name}_(#{config.environments.join("|")})_(\d|_)+/
+      end
+    end
 
-  def self.prune_dump_directory
-    FileUtils.rm_rf("#{config.dumps_directory}/.", secure: true)
-  end
+    def setup_dynamic_database_name_in_config
+      old_database_name = Rails.configuration.database_configuration["development"]["database"]
 
-  def self.drop_database(database_name)
-    config.database_system.drop_database(database_name)
-  end
+      return false if old_database_name.nil?
 
-  def self.databases
-    config.database_system.list_databases.select do |line|
-      line =~ /#{config.app_name}_(#{config.environments.join("|")})_(\d|_)+/
+      old_config = File.read(UffDbLoader.config.database_config_file)
+      new_config = old_config.sub(old_database_name, database_name_template(old_database_name))
+      File.write(UffDbLoader.config.database_config_file, new_config)
     end
-  end
 
-  def self.database_name_template(old_database_name)
-    "<%= UffDbLoader.current_database_name || '#{old_database_name}' %>"
-  end
+    def current_database_name
+      File.read(database_name_file).strip.presence
+    rescue IOError, Errno::ENOENT => e
+      puts "Could not read #{database_name_file}. #{e.message} – Falling back to default database. 🥱"
+    end
+
+    def remember_database_name(database_name)
+      File.write(database_name_file, database_name)
+    end
 
-  def self.setup_dynamic_database_name_in_config
-    old_database_name = Rails.configuration.database_configuration["development"]["database"]
+    def ensure_installation!
+      unless File.read(UffDbLoader.config.database_config_file).include?("UffDbLoader.current_database_name")
+        raise InstallationDidNotRunError, "Please run bin/rails uff_db_loader:install"
+      end
+    end
 
-    return false if old_database_name.nil?
+    def load_dump_into_database(database_name)
+      UffDbLoader.drop_database(database_name)
+      UffDbLoader.create_database(database_name)
 
-    old_config = File.read(UffDbLoader.config.database_config_file)
-    new_config = old_config.sub(old_database_name, database_name_template(old_database_name))
-    File.write(UffDbLoader.config.database_config_file, new_config)
-  end
+      puts "🗂  Created database #{database_name}"
 
-  def self.current_database_name
-    File.read(database_name_file).strip.presence
-  rescue IOError, Errno::ENOENT => e
-    puts "Could not read #{database_name_file}. #{e.message}"
-  end
+      dump_file_path = dump_file_path(database_name)
 
-  def self.remember_database_name(database_name)
-    File.write(database_name_file, database_name)
-  end
+      command_successful = system(restore_command(database_name, dump_file_path))
+      raise "Command did not run succesful: #{restore_command(database_name, dump_file_path)}" unless command_successful
+
+      puts "✅ Succesfully loaded #{dump_file_path} into #{database_name}"
+
+      remember_database_name(database_name)
+      restart_rails_server
 
-  def self.ensure_installation!
-    unless File.read(UffDbLoader.config.database_config_file).include?("UffDbLoader.current_database_name")
-      raise InstallationDidNotRunError, "Please run bin/rails uff_db_loader:install"
+      puts "♻️  Restarted rails server with new database."
     end
-  end
 
-  def self.dump_file_path(database_name)
-    File.join(
-      config.dumps_directory,
-      "#{database_name}.#{config.database_system.dump_extension}"
-    )
-  end
+    def initializer_path
+      File.join(__dir__, "uff_db_loader", "templates", "uff_db_loader_initializer.erb")
+    end
 
-  def self.load_dump_into_database(database_name)
-    UffDbLoader.drop_database(database_name)
-    UffDbLoader.create_database(database_name)
+    def create_initializer
+      template = ERB.new(File.read(initializer_path))
 
-    puts "🗂  Created database #{database_name}"
+      File.write(
+        Rails.root.join("config", "initializers", "uff_db_loader.rb"),
+        template.result_with_hash(
+          used_database_system: used_database_system,
+          environments: environments
+        )
+      )
+    end
 
-    dump_file_path = dump_file_path(database_name)
+    private
 
-    command_successful = system(restore_command(database_name, dump_file_path))
-    raise "Command did not run succesful: #{restore_command(database_name, dump_file_path)}" unless command_successful
+    def database_name_file
+      Rails.root.join("tmp", "uff_db_loader_database_name")
+    end
 
-    puts "✅ Succesfully loaded #{dump_file_path} into #{database_name}"
+    def dump_filename(environment)
+      File.join(
+        config.dumps_directory,
+        Time.now.strftime("#{config.app_name}_#{environment}_%Y_%m_%d_%H_%M_%S.#{config.database_system.dump_extension}")
+      )
+    end
 
-    remember_database_name(database_name)
-    system("bin/rails restart")
+    def dump_command(environment, target)
+      config
+        .database_system
+        .dump_command_template
+        .gsub("%environment%", environment)
+        .gsub("%host%", config.ssh_host)
+        .gsub("%user%", config.ssh_user)
+        .gsub("%database%", config.database)
+        .gsub("%target%", target)
+        .gsub("%app_name%", config.app_name)
+    end
 
-    puts "♻️  Restarted rails server with new database."
-  end
+    def restore_command(database_name, result_file_path)
+      config.database_system.restore_command(database_name, result_file_path)
+    end
+
+    def database_name_template(old_database_name)
+      "<%= defined?(UffDbLoader) && UffDbLoader.current_database_name || '#{old_database_name}' %>"
+    end
+
+    def dump_file_path(database_name)
+      File.join(
+        config.dumps_directory,
+        "#{database_name}.#{config.database_system.dump_extension}"
+      )
+    end
+
+    def used_database_system
+      case Rails.configuration.database_configuration["development"]["adapter"]
+      when "mysql", "mysql2", "trilogy"
+        ":mysql"
+      when "postgresql"
+        ":postgresql"
+      else
+        puts "🙃 Could not automatically determine your used database system. Please adapt in the initializer."
+        ":unknown"
+      end
+    end
 
-  class ForbiddenEnvironmentError < StandardError; end
+    def environments
+      ActiveRecord::Base.configurations.configurations.to_a.map(&:env_name) - ["test", "development"]
+    end
+
+    class ForbiddenEnvironmentError < StandardError; end
 
-  class UnknownDatabaseSystem < StandardError; end
+    class UnknownDatabaseSystem < StandardError; end
 
-  class InstallationDidNotRunError < StandardError; end
+    class InstallationDidNotRunError < StandardError; end
+  end
 end

data/uff_db_loader.gemspec

@@ -8,6 +8,7 @@ Gem::Specification.new do |spec|
 
   spec.summary = "Allows to dump, download and restore databases from docker servers."
   spec.description = "Allows to dump, download and restore databases from servers with a specific docker setup, that UFF uses commonly."
+  spec.post_install_message = "Please run `bin/rails uff_db_loader:install` to complete the installation."
   spec.homepage = "https://github.com/rmehner/uff_db_loader"
   spec.license = "MIT"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: uff_db_loader
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Andreas Hellwig
 - Fynn Heintz
 - Robin Mehner
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-25 00:00:00.000000000 Z
+date: 2022-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tty-prompt
@@ -79,8 +79,8 @@ files:
 - lib/uff_db_loader.rb
 - lib/uff_db_loader/mysql.rb
 - lib/uff_db_loader/postgresql.rb
-- lib/uff_db_loader/tasks/remote_database.rake
 - lib/uff_db_loader/tasks/uff_db_loader.rake
+- lib/uff_db_loader/templates/uff_db_loader_initializer.erb
 - lib/uff_db_loader/version.rb
 - uff_db_loader.gemspec
 homepage: https://github.com/rmehner/uff_db_loader
@@ -88,10 +88,11 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rmehner/uff_db_loader/issues
-  changelog_uri: https://github.com/rmehner/uff_db_loader/releases/tag/1.4.0
+  changelog_uri: https://github.com/rmehner/uff_db_loader/releases/tag/2.0.0
   homepage_uri: https://github.com/rmehner/uff_db_loader
-  source_code_uri: https://github.com/rmehner/uff_db_loader/tree/1.4.0
-post_install_message: 
+  source_code_uri: https://github.com/rmehner/uff_db_loader/tree/2.0.0
+post_install_message: Please run `bin/rails uff_db_loader:install` to complete the
+  installation.
 rdoc_options: []
 require_paths:
 - lib
@@ -106,8 +107,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.3.8
+signing_key:
 specification_version: 4
 summary: Allows to dump, download and restore databases from docker servers.
 test_files: []

data/lib/uff_db_loader/tasks/remote_database.rake

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require "tty-prompt"
-
-namespace :remote_database do
-  desc "Dumps a remote database to #{UffDbLoader.config.dumps_directory}"
-  task dump: :environment do
-    puts "🧐 Please note this task is called 'uff_db_loader:dump' now."
-    Rake::Task["uff_db_loader:dump"].invoke
-  end
-
-  desc "Gets a dump from remote and loads it into the local database"
-  task load: :environment do
-    puts "🧐 Please note this task is called 'uff_db_loader:load' now."
-    Rake::Task["uff_db_loader:load"].invoke
-  end
-
-  desc "Delete all downloaded db dumps and emove all databases created by UffDbLoader"
-  task prune: :environment do
-    puts "🧐 Please note this task is called 'uff_db_loader:prune' now."
-    Rake::Task["uff_db_loader:prune"].invoke
-  end
-end