postgresql-backup 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f34190c8ce07b53f5b82d3b310f5da641112088d7c951163dcb846be9724a00a
-  data.tar.gz: d905f4743ceaa94f37ec7e3fbe17bc6e0928cd3ba15800c029705a32bfc8db4f
+  metadata.gz: 1e7a2f09d1cbc28e1fcb21aba0bd72b9770f17db9d70bf80b9c0d4205fd97ee6
+  data.tar.gz: ff5ef7a6a7f05e3e306034537c9d8cd7681b59968e96e0567a0d5ce76926819d
 SHA512:
-  metadata.gz: 0e2227f822a916e585d7378155a351c09b2d1c4a6d533ac6e2eb09d1cd6113b92e1cae3482342958d59be4c703136c40d3cb7f9f29dce5e122ee1c7503e4c014
-  data.tar.gz: 2932a78f48433e93da8e0e3c04bb79dc4f0710fc847e49eb619fc1c2f95c30bda3e5628c31a5985c409b84a53e9a8424cd42931de0bf495ae968e3dffe183524
+  metadata.gz: 8e3a92f37969d423dec46d9ba9a5afc8ff76fda398521f89cdcd64f576a6b1e6c8f5facd837053f76fabb1c06a9ac205550c0fb4de01c316023dbbe8094ef418
+  data.tar.gz: 620695bd227ca25beeb6cb746df745f9051d8a0297e65dc496f55dd35ffa53bfbda928b2bf94457ce367b1847376d3767ff23c8a4f9b725f9100b196525cfecd

data/README.md

@@ -0,0 +1,141 @@
+# PostgreSQL backup
+
+This gem automates PostgreSQL's backup and restore in your Rails project. It will inject two rake tasks that you can use to manage your data, either by using the local system or AWS S3 storage.
+
+## Getting started
+
+Add the gem to your Rails project:
+
+```ruby
+gem 'postgresql-backup'
+```
+
+Go to the terminal and update your gems using bundler:
+
+```
+bundle install
+```
+
+Right now, your project already has two new rake tasks: `backup` and `restore`.
+
+## Configuration
+
+If you intend to use the local file system to store the backup files, there is nothing more you need to do. Postgresql-backup has default configuration values and it uses the file system by default.
+
+However, if you want to change the defaul values, like the name of the backup files or the folder where they are going to be stored, or if you prefer to use Amazon S3 service as a storage, you can do it.
+
+Create a file inside the `config/initializers` folder. The name is not important, but it is a good practice to name it after with something related to what it does, like `database_backup.rb` or something like that.
+
+Here is an example with all available options you can change:
+
+```ruby
+PostgresqlBackup.configure do |config|
+  # This gem works with two possible repositories:
+  #
+  # * S3: use S3 instead of the file system by setting `S3` to the
+  #   repository. Make sure you also set `aws_access_key_id` and
+  #   `aws_secret_access_key` or an error will be raised when you try
+  #   to execute the rake tasks. The `bucket` and `region` attributes
+  #   can also be defined, but they have default values and can also
+  #   be overriden (or set by the first time) when the rake is
+  #   called.
+  #
+  # * File System: this is the default value. Files will be stored
+  #   in the disk, into the folder defined in the `backup_folder`.
+  config.repository = 'S3'
+
+  # The folder where files will be stored in the file system.
+  # The default is `db/backups` and it will be ignored if you set
+  # `repository` to 'S3'.
+  config.backup_folder = ''
+
+  # Get your access key and secret key from AWS console:
+  # IAM -> Users -> Security Credentials tab -> access keys
+  config.aws_access_key_id = ''
+  config.aws_secret_access_key = ''
+
+  # The name of the bucket where the backup files will be stored
+  # (and from where they will be retrieved). The default value
+  # is `postgresql-backups`, but this will be ignored unless the
+  # repository is set to S3.
+  config.bucket = ''
+
+  # This is the region where your storage is. The default value
+  # is `us-east-1`. It will also be ignored unless the repository
+  # is set to S3.
+  config.region = ''
+
+  # Backup files are created using a pattern made by the current date
+  # and time. If you want to add a sufix to the files, change this
+  # attribute.
+  config.file_suffix = ''
+
+  # If you use S3 to upload the backup files, you need to provide a
+  # path where they are going to be stored. The remote path is the
+  # place to do that. The default value is `_backups/database/`
+  config.remote_path = ''
+end
+```
+
+## Backing up your database
+
+If you followed the steps above, you are ready to go. The simplest way to backup your data is by running the `dump` rake task:
+
+```
+bundle exec rake postgresql_backup:dump
+```
+
+However, you can set (or override) a few things when executing the rake:
+
+- repository: `BKP_REPOSITORY='File System' bundle exec rake postgresql_backup:dump`
+- bucket: `BKP_BUCKET='my-bucket' bundle exec rake postgresql_backup:dump`
+- region: `BKP_REGION='us-east-1' bundle exec rake postgresql_backup:dump`
+- remote_path: `BKP_REMOTE_PATH='_backups/database' bundle exec rake postgresql_backup:dump`
+
+Be aware that, if the gem is configured to use the file system and you force the task to use S3, AWS related attributes must be set, like the access key and the secret key.
+
+You can combine these variables above any way you want:
+
+```
+BKP_REPOSITORY='S3' BKP_BUCKET='my-bucket' BKP_REGION='us-east-1' BKP_REMOTE_PATH='_backups/database' bundle exec rake postgresql_backup:dump
+```
+
+Important note: config/database.yml is used for database configuration,
+but you may be prompted for the database user's password.
+
+## Restoring data into your database
+
+The basic way of restoring the database is by running the `restore` take task:
+
+```
+bundle exec rake postgresql_backup:restore
+```
+
+It will respect the configuration set during initialization or use default values when available. Just like in the `dump` task, you can override (or set) configuration values:
+
+```
+REPOSITORY='S3' S3_BUCKET_NAME='my-bucket' bundle exec rake db:restore
+```
+
+Again, you can use these environment variables:
+
+- repository: `BKP_REPOSITORY='File System' bundle exec rake postgresql_backup:restore`
+- bucket: `BKP_BUCKET='my-bucket' bundle exec rake postgresql_backup:restore`
+- region: `BKP_REGION='us-east-1' bundle exec rake postgresql_backup:restore`
+- remote_path: `BKP_REMOTE_PATH='_backups/database' bundle exec rake postgresql_backup:dump`
+
+Or make any combination you want with them:
+
+```
+BKP_REPOSITORY='S3' BKP_BUCKET='my-bucket' BKP_REGION='us-east-1' BKP_REMOTE_PATH='_backups/database' bundle exec rake postgresql_backup:restore
+```
+
+This is useful when you are trying to restore a production database into your local machine. Even though you configured the gem to use a development bucket, it is necessary to read the backup file from a production bucket.
+
+When you run the rake task to restore a database, it will list all available files for you to choose.
+
+Important note: if you are trying to locally restore a backup that was created in a production environment, there is a trick you need to know. There is a table called `ar_internal_metadata` that stores the Rails environment the project is using. If you simply restore a production backup in a development database, Rails will think you are in production.
+
+Everything will work just fine, but you may come across some strange warnings, like when you try to drop the database: it will say you are droping a production database to double check if this is your intended purpose.
+
+To prevent this, every time the rake restores a backup file it tries to replace the environment being copied into the ar_internal_metadata table with the current Rails environment. Thus, `environment production` will become `environment development`.

data/lib/Rakefile

@@ -0,0 +1,4 @@
+require 'postgresql_backup'
+
+path = File.expand_path(__dir__)
+Dir.glob("#{path}/tasks/*.rake").each { |f| import f }

data/lib/railtie.rb

@@ -0,0 +1,11 @@
+require 'postgresql_backup'
+require 'rails'
+
+class Railtie < Rails::Railtie
+  railtie_name 'postgresql-backup'
+
+  rake_tasks do
+    path = File.expand_path(__dir__)
+    Dir.glob("#{path}/tasks/*.rake").each { |f| load f }
+  end
+end

data/lib/tasks/backup.rake

@@ -0,0 +1,120 @@
+require_relative '../tools/disclaimer'
+require_relative '../tools/terminal'
+require_relative '../tools/database'
+require_relative '../tools/s3_storage'
+require 'tty-prompt'
+require 'tty-spinner'
+require 'pastel'
+
+namespace :postgresql_backup do
+  desc 'Dumps the database'
+  task dump: :environment do
+    title = pastel.yellow.bold('POSTGRESQL BACKUP')
+    text = 'You are about to backup your database. Relax on your seat, this process is usually fast and you don\'t need to do anything except wait for the process to end. Here is the current configuration for this backup:'
+    texts = [text, ' ', configuration_to_text].flatten
+    disclaimer.show(title: title, texts: texts)
+
+    file_path = Tools::Terminal.spinner('Backing up database') { db.dump }
+
+    if configuration.s3?
+      Tools::Terminal.spinner('Uploading file') { storage.upload(file_path) }
+      Tools::Terminal.spinner('Deleting local file') { File.delete(file_path) }  if File.exist?(file_path)
+    end
+
+    puts ''
+    puts pastel.green('All done.')
+  end
+
+  desc 'Restores a database backup into the database'
+  task restore: :environment do
+    title = pastel.green('POSTGRESQL DATABASE RESTORE')
+    text = 'Let\'s get your data back. You will be prompted to choose the file to restore, but that\'s all, you can leave the rest to us. Here is the current configuration for this restore:'
+    texts = [text, ' ', configuration_to_text].flatten
+    disclaimer.show(title: title, texts: texts)
+    local_file_path = ''
+
+    files = Tools::Terminal.spinner('Loading backups list') { list_backup_files }
+
+    if files.present?
+      puts ''
+      file_name = prompt.select("Choose the file to restore", files)
+      puts ''
+
+      if configuration.s3?
+        local_file_path = Tools::Terminal.spinner('Downloading file') { storage.download(file_name) }
+      end
+
+      db.reset
+
+      Tools::Terminal.spinner('Restoring data') { db.restore(file_name) }
+
+      if configuration.s3?
+        Tools::Terminal.spinner('Deleting local file') { File.delete(local_file_path) }
+      end
+
+      puts ''
+      puts pastel.green('All done.')
+    else
+      spinner = TTY::Spinner.new("#{pastel.yellow("[:spinner] ")}Restoring data...")
+      error_message = "#{pastel.red.bold('failed')}. Backup files not found."
+      spinner.success(error_message)
+    end
+  end
+
+  private
+
+  def configuration
+    @configuration ||= begin
+      config = PostgresqlBackup.configuration.dup
+      config.repository = ENV['BKP_REPOSITORY'] if ENV['BKP_REPOSITORY'].present?
+      config.bucket = ENV['BKP_BUCKET'] if ENV['BKP_BUCKET'].present?
+      config.region = ENV['BKP_REGION'] if ENV['BKP_REGION'].present?
+      config.remote_path = ENV['BKP_REMOTE_PATH'] if ENV['BKP_REMOTE_PATH'].present?
+      config
+    end
+  end
+
+  def db
+    @db ||= Tools::Database.new(configuration)
+  end
+
+  def storage
+    @storage ||= Tools::S3Storage.new(configuration)
+  end
+
+  def disclaimer
+    @disclaimer ||= Tools::Disclaimer.new
+  end
+
+  def pastel
+    @pastel ||= Pastel.new
+  end
+
+  def prompt
+    @prompt ||= TTY::Prompt.new
+  end
+
+  def configuration_to_text
+    [
+      show_config_for('Repository', configuration.repository),
+      configuration.s3? ? nil : show_config_for('Folder', configuration.backup_folder),
+      show_config_for('File suffix', configuration.file_suffix),
+      configuration.s3? ? show_config_for('Bucket', configuration.bucket) : nil,
+      configuration.s3? ? show_config_for('Region', configuration.region) : nil,
+      configuration.s3? ? show_config_for('Remote path', configuration.remote_path) : nil
+    ].compact
+  end
+
+  def show_config_for(text, value)
+    return if value.empty?
+
+    "* #{pastel.yellow.bold(text)}: #{value}"
+  end
+
+  def list_backup_files
+    @list_backup_files ||= begin
+      source = configuration.s3? ? storage : db
+      source.list_files
+    end
+  end
+end

data/lib/tools/database.rb

@@ -0,0 +1,97 @@
+require 'byebug'
+
+module Tools
+  class Database
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    # Backup the database and save it on the backup folder set in the
+    # configuration.
+    # If you need to make the command more verbose, pass
+    # `debug: true` in the arguments of the function.
+    #
+    # Return the full path of the backup file created in the disk.
+    def dump(debug: false)
+      file_path = File.join(backup_folder, "#{file_name}#{file_suffix}.sql")
+
+      cmd = "PGPASSWORD='#{password}' pg_dump -F p -v -O -U '#{user}' -h '#{host}' -d '#{database}' -f '#{file_path}' -p '#{port}' "
+      debug ? system(cmd) : system(cmd, err: File::NULL)
+
+      file_path
+    end
+
+    # Drop the database and recreate it.
+    #
+    # This is done by invoking two Active Record's rake tasks:
+    #
+    # * rake db:drop
+    # * rake db:create
+    def reset
+      system('bundle exec rake db:drop db:create')
+    end
+
+    # Restore the database from a file in the file system.
+    #
+    # If you need to make the command more verbose, pass
+    # `debug: true` in the arguments of the function.
+    def restore(file_name, debug: false)
+      file_path = File.join(backup_folder, file_name)
+      output_redirection = debug ? '': ' > /dev/null'
+      cmd = "PGPASSWORD='#{password}' psql -U '#{user}' -h '#{host}' -d '#{database}' -f '#{file_path}' -p '#{port}' #{output_redirection}"
+      system(cmd)
+
+      file_path
+    end
+
+    # List all backup files from the local backup folder.
+    #
+    # Return a list of strings containing only the file names.
+    def list_files
+      Dir.glob("#{backup_folder}/*.sql")
+        .reject { |f| File.directory?(f) }
+        .map { |f| Pathname.new(f).basename }
+    end
+
+    private
+
+    attr_reader :configuration
+
+    def host
+      @host ||= ::ActiveRecord::Base.connection_config[:host]
+    end
+
+    def port
+      @port ||= ::ActiveRecord::Base.connection_config[:port]
+    end
+
+    def database
+      @database ||= ::ActiveRecord::Base.connection_config[:database]
+    end
+
+    def user
+      ::ActiveRecord::Base.connection_config[:username]
+    end
+
+    def password
+      @password ||= ::ActiveRecord::Base.connection_config[:password]
+    end
+
+    def file_name
+      @file_name ||= Time.current.strftime('%Y%m%d%H%M%S')
+    end
+
+    def file_suffix
+      return if configuration.file_suffix.empty?
+      @file_suffix ||= "_#{configuration.file_suffix}"
+    end
+
+    def backup_folder
+      @backup_folder ||= begin
+        File.join(Rails.root, configuration.backup_folder).tap do |folder|
+          FileUtils.mkdir_p(folder)
+        end
+      end
+    end
+  end
+end

data/lib/tools/disclaimer.rb

@@ -0,0 +1,194 @@
+require 'pastel'
+
+module Tools
+  class Disclaimer
+    def initialize(columns: 80, horizontal_character: '=', vertical_character: '|', print_output: true)
+      @columns = columns
+      @horizontal_character = horizontal_character
+      @vertical_character = vertical_character
+      @print_output = print_output
+    end
+
+    # Prints a box containing a title and an
+    # explanation of the action that will be
+    # performed.
+    #
+    # Example:
+    #
+    # ========================================
+    # |                                      |
+    # |        POSTGRESQL BACKUP GEM         |
+    # |                                      |
+    # ========================================
+    # |                                      |
+    # |  Dolore ipsum sunt amet laborum      |
+    # |  voluptate elit tempor minim         |
+    # |  officia ex amet incididunt.         |
+    # |                                      |
+    # ========================================
+    def show(title: nil, texts: [])
+      output = ['']
+
+      if title
+        output << horizontal_character * columns
+        output << empty_line
+        output << centralized_text(title)
+        output << empty_line
+      end
+
+      output << horizontal_character * columns
+      output << empty_line
+
+      Array(texts).each do |text|
+        paragraphs = break_text_into_paragraphs(text)
+        paragraphs.each do |text|
+          output << left_aligned_text(text)
+        end
+      end
+      output << empty_line
+
+      output << horizontal_character * columns
+      output << ''
+
+      output.each { |line| puts line } if print_output
+
+      output
+    end
+
+    private
+
+    attr_reader :columns, :horizontal_character, :vertical_character, :print_output
+
+    # Create an empty line to give visual space for the text
+    # inside the disclaimer box.
+    #
+    # Example:
+    #
+    # |                                      |
+    #
+    # Returns a string that represents an empty line,
+    # including the vertical characters to close the
+    # disclaimer box.
+    def empty_line
+      spaces = ' ' * (columns - 2 * length_of(vertical_character))
+
+      [
+        vertical_character,
+        spaces,
+        vertical_character
+      ].join
+    end
+
+    # Create a line inside the disclaimer box with a text aligned
+    # in the center of the box. There are cases when the centralized
+    # text needs an extra space to complete the box, if you want to
+    # learn more about how this is calculated, read the documentation
+    # of the method extra_space.
+    #
+    # Example:
+    #
+    # |        POSTGRESQL BACKUP GEM         |
+    #
+    # Return a string with a centralized text inside the disclaimer
+    # box.
+    def centralized_text(text)
+      gap = (columns - length_of(text) - 2 * length_of(vertical_character)) / 2
+      spaces = ' ' * gap
+
+      [
+        vertical_character,
+        spaces,
+        text + extra_space(text),
+        spaces,
+        vertical_character
+      ].join
+    end
+
+    # Create a line inside the disclaimer box with a text aligned
+    # in the left of the box.
+    #
+    # Example:
+    #
+    # |  Dolore ipsum sunt amet laborum      |
+    #
+    # Return a string with a left-aligned text inside the
+    # disclaimer box.
+    def left_aligned_text(text)
+      stripped_text = text.strip
+      spaces_around_text = 2
+      gap = (columns - 2 * spaces_around_text - 2 * length_of(vertical_character)) - length_of(stripped_text)
+      spaces = ' ' * gap
+
+      [
+        vertical_character,
+        ' ' * spaces_around_text,
+        stripped_text,
+        spaces,
+        ' ' * spaces_around_text,
+        vertical_character
+      ].join
+    end
+
+    # When the differente between the number of columns and the lenght
+    # of the text is odd, there will be a missing space to close the
+    # disclaimer box. That's because the division by 2 ceils the result.
+    #
+    # Example:
+    #
+    # Consider a box with 40 columns and the text `text`. To calculate
+    # the spaces around the text, first substract the vertical characters:
+    #
+    # 40 - 2 (we are supposing that the vertical character has length 1)
+    #
+    # Now, substract the length of the text and divide the result by 2 (
+    # each portion will be positioned at one side of the text):
+    #
+    # (38 - 5) / 2 = 16!
+    #
+    # If we add the numbers back, we have: 2 (vertical_character) + 2 * 16 (spaces) + 5 (text length) = 39
+    #
+    # The result is not 40, but it should be. In these cases, the need to
+    # add an extra space to compensate for this mathematical operation.
+    #
+    # Returns either one blank space or an empty space.
+    def extra_space(text)
+      text_length = length_of(text)
+      if (text_length.odd? && columns.even?) || (text_length.even? && columns.odd?)
+        ' '
+      else
+        ''
+      end
+    end
+
+    # Given a long text, this method breaks the text in small
+    # chunks that will fit inside the space delimited by the
+    # `columns` attribute.
+    #
+    # Returns an array of string.
+    def break_text_into_paragraphs(text)
+      paragraphs = []
+      position = 0
+      spaces_around_text = 2
+      paragraph_max_size = columns - 2 * spaces_around_text - 2 * length_of(vertical_character)
+      text_length = length_of(text)
+
+      loop do
+        break paragraphs if position == text_length
+
+        match = text.match(/.{1,#{paragraph_max_size}}(?=[ ]|\z)|.{,#{paragraph_max_size-1}}[ ]/, position)
+        return nil if match.nil?
+
+        paragraphs << match[0]
+        position += length_of(match[0])
+      end
+    end
+
+    def length_of(text)
+      pastel.undecorate(text).map { |part| part[:text] }.join.length
+    end
+
+    def pastel
+      @pastel ||= Pastel.new
+    end
+  end
+end

data/lib/tools/s3_storage.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'fog/aws'
+require 'fileutils'
+require 'pathname'
+
+module Tools
+  class S3Storage
+    def initialize(configuration)
+      @configuration = configuration
+      @s3 = Fog::Storage.new(
+        provider: 'AWS',
+        region: configuration.region,
+        aws_access_key_id: configuration.aws_access_key_id,
+        aws_secret_access_key: configuration.aws_secret_access_key
+      )
+    end
+
+    # Send files to S3.
+    #
+    # To test this, go to the console and execute:
+    #
+    # ```
+    # file_path = "#{Rails.root}/Gemfile"
+    # S3Storage.new.upload(file_path)
+    # ```
+    #
+    # It will send the Gemfile to S3, inside the `remote_path` set in the
+    # configuration. The bucket name and the credentials are also read from
+    # the configuration.
+    def upload(file_path, tags = '')
+      file_name = Pathname.new(file_path).basename
+
+      remote_file.create(
+        key: File.join(remote_path, file_name),
+        body: File.open(file_path),
+        tags: tags
+      )
+    end
+
+    # List all the files in the bucket's remote path. The result
+    # is sorted in the reverse order, the most recent file will
+    # show up first.
+    #
+    # Return an array of strings, containing only the file name.
+    def list_files
+      files = remote_directory.files.map { |file| file.key }
+
+      # The first item in the array is only the path an can be discarded.
+      files = files.slice(1, files.length - 1) || []
+
+      files
+        .map { |file| Pathname.new(file).basename.to_s }
+        .sort
+        .reverse
+    end
+
+    # Create a local file with the contents of the remote file.
+    #
+    # The new file will be saved in the `backup_folder` that was set
+    # in the configuration (the default value is `db/backups`)
+    def download(file_name)
+      remote_file_path = File.join(remote_path, file_name)
+      local_file_path = File.join(backup_folder, file_name)
+
+      file_from_storage = remote_directory.files.get(remote_file_path)
+
+      prepare_local_folder(local_file_path)
+      create_local_file(local_file_path, file_from_storage)
+
+      local_file_path
+    end
+
+    private
+
+    attr_reader :configuration, :s3
+
+    # Force UTF-8 encoding and remove the production environment from
+    # the `ar_internal_metadata` table, unless the current Rails env
+    # is indeed `production`.
+    def file_body(file)
+      body = file.body.force_encoding("UTF-8")
+      return body if Rails.env.production?
+
+      body.gsub('environment	production', "environment	#{Rails.env}")
+    end
+
+    def bucket
+      @bucket ||= configuration.bucket
+    end
+
+    def region
+      @region ||= configuration.region
+    end
+
+    def remote_path
+      @remote_path ||= configuration.remote_path
+    end
+
+    def backup_folder
+      @backup_folder ||= configuration.backup_folder
+    end
+
+    def remote_directory
+      @remote_directory ||= s3.directories.get(bucket, prefix: remote_path)
+    end
+
+    def remote_file
+      @remote_file ||= s3.directories.new(key: bucket).files
+    end
+
+    # Make sure the path exists and that there are no files with
+    # the same name of the one that is being downloaded.
+    def prepare_local_folder(local_file_path)
+      FileUtils.mkdir_p(backup_folder)
+      File.delete(local_file_path) if File.exist?(local_file_path)
+    end
+
+    def create_local_file(local_file_path, file_from_storage)
+      File.open(local_file_path, 'w') do |local_file|
+        body = file_body(file_from_storage)
+        local_file.write(body)
+      end
+    end
+  end
+end

data/lib/tools/terminal.rb

@@ -0,0 +1,17 @@
+require 'pastel'
+require 'tty-spinner'
+
+module Tools
+  class Terminal
+    def self.spinner(text)
+      pastel = Pastel.new
+
+      spinner = TTY::Spinner.new("#{pastel.yellow("[:spinner] ")}#{text}...")
+      spinner.auto_spin
+      result = yield
+      spinner.success(pastel.green.bold("done."))
+
+      result
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: postgresql-backup
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Artur Caliendo Prado
@@ -88,8 +88,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- README.md
+- lib/Rakefile
 - lib/configuration.rb
 - lib/postgresql_backup.rb
+- lib/railtie.rb
+- lib/tasks/backup.rake
+- lib/tools/database.rb
+- lib/tools/disclaimer.rb
+- lib/tools/s3_storage.rb
+- lib/tools/terminal.rb
 homepage: https://rubygems.org/gems/postgresql-backup
 licenses:
 - MIT