s3_backup 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8b77cce74b179a0fe9c7945f85f624d4fb324bc2
+  data.tar.gz: acd5fe987b7c72884114d3a3f59f7fd3c4431ed4
+SHA512:
+  metadata.gz: e65aefb84a61bdc2f227724913495eef7321d978356028b575356d4f4aabc1ca358d7d3efe8bc434aa6a2940c9e65c12444dc38f6fc7d080937d6c3058595ba6
+  data.tar.gz: 9602297c7b55861cbfdfbb2d1a07dfa9f15b1c842b56f0e19fd6c57067236b5844165521edd3baac9f49f955353c43f76dabdfd34ceb21573c738281129f2cd6

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,56 @@
+# S3 Backup
+
+## Postgres
+
+#### Backup
+```
+rake s3_backup:pg:backup[db_staging]
+```
+
+#### Import
+```
+rake s3_backup:pg:import[db_staging]
+```
+
+## Redis
+
+#### Backup
+```
+rake s3_backup:redis:backup
+```
+
+#### Import
+```
+rake s3_backup:redis:import[staging]
+```
+
+## Configuration file
+
+```yaml
+---
+
+pg_database:
+  host: <%= ENV['DATABASE_HOST'] %>
+  user: <%= ENV['DATABASE_USER'] %>
+  password: <%= ENV['DATABASE_PASSWORD'] %>
+
+redis:
+  dump_path: /var/lib/redis/6379/dump.rdb
+
+s3:
+  aws_access_key_id: <%= ENV['AWS_ACCESS_KEY_ID'] %>
+  aws_secret_access_key: <%= ENV['AWS_SECRET_ACCESS_KEY'] %>
+  bucket: <%= ENV['S3_BUCKET'] %>
+  aws_region: <%= ENV['AWS_REGION'] %>
+  pg_path: rds_backup
+  redis_path: redis_backup
+  keep: 5
+
+tables:
+  users:
+    columns:
+      first_name: first_name
+      last_name: last_name
+      email: email
+    exception: '@mycompany.me'
+```

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+
+spec = Gem::Specification.find_by_name 's3_backup'
+load "#{spec.gem_dir}/lib/tasks/pg.rake"
+load "#{spec.gem_dir}/lib/tasks/redis.rake"

data/lib/s3_backup/config.rb

@@ -0,0 +1,60 @@
+require 'pry'
+require 'erb'
+require 'yaml'
+
+module S3Backup
+  class Config
+    class << self
+
+      attr_accessor :pg_host
+      attr_accessor :pg_user
+      attr_accessor :pg_password
+      attr_accessor :redis_dump_path
+      attr_accessor :aws_access_key_id
+      attr_accessor :aws_secret_access_key
+      attr_accessor :bucket
+      attr_accessor :aws_region
+      attr_accessor :s3_pg_path
+      attr_accessor :s3_redis_path
+      attr_accessor :s3_keep
+      attr_accessor :tables
+
+      def load!(file_path)
+        template       = ERB.new File.new(file_path).read
+        @configuration = YAML.load(template.result(binding))
+
+        self.pg_host     = config('pg_database', 'host')
+        self.pg_user     = config('pg_database', 'user')
+        self.pg_password = config('pg_database', 'password')
+
+        self.redis_dump_path = config('redis', 'dump_path')
+
+        self.aws_access_key_id     = config('s3', 'aws_access_key_id')
+        self.aws_secret_access_key = config('s3', 'aws_secret_access_key')
+        self.bucket                = config('s3', 'bucket')
+        self.aws_region            = config('s3', 'aws_region')
+        self.s3_keep               = config('s3', 'keep')
+        self.s3_pg_path            = config('s3', 'pg_path')
+        self.s3_redis_path         = config('s3', 'redis_path')
+
+        self.tables = config('tables') || {}
+
+        true
+      end
+
+      def requires!(*args)
+        args.each do |argv|
+          raise "Configuration missing: #{argv}" unless Config.send(argv)
+        end
+        true
+      end
+
+      def config(*args)
+        args.inject(@configuration) do |hash, key|
+          (hash.is_a?(Hash) && hash[key]) || nil
+        end
+      end
+
+    end
+  end
+end

data/lib/s3_backup/pg/backup.rb

@@ -0,0 +1,57 @@
+module S3Backup
+  module Pg
+    class Backup
+      attr_reader :db_name
+
+      def initialize(db_name)
+        @db_name = db_name
+      end
+
+      def now!
+        puts 'Setup environement'
+        set_pg_password_env
+        puts 'Starting downloading dump ...'
+        dump_database
+        puts 'Dump downloaded.'
+        puts 'Starting obfuscation ...'
+        Obfuscate.new(pg_dump_file.path, obfuscated_file.path).obfuscate_dump!
+        puts 'Obfuscation done.'
+        puts 'Upload to S3 ...'
+        S3Backup::S3.new.upload!(obfucated_file_name, Config.s3_pg_path, obfuscated_file.path)
+        puts 'Uploaded.'
+        puts 'Clean environement.'
+        clean_env
+        S3Backup::S3.new.clean!(db_name, Config.s3_pg_path)
+      end
+
+      private
+
+      def set_pg_password_env
+        ENV['PGPASSWORD'] = Config.pg_password
+      end
+
+      def dump_database
+        `pg_dump -h #{Config.pg_host} -U #{Config.pg_user} -d #{db_name} > #{pg_dump_file.path}`
+      end
+
+      def pg_dump_file
+        @pg_dump_file ||= Tempfile.new(db_name)
+      end
+
+      def obfucated_file_name
+        @obfucated_file_name ||= "#{db_name}-#{Time.now.to_i}.gz"
+      end
+
+      def obfuscated_file
+        @obfuscated_file ||= Tempfile.new(obfucated_file_name)
+      end
+
+      def clean_env
+        pg_dump_file.unlink
+        obfuscated_file.unlink
+        ENV['PGPASSWORD'] = ''
+      end
+
+    end
+  end
+end

data/lib/s3_backup/pg/import.rb

@@ -0,0 +1,62 @@
+require 'zlib'
+
+module S3Backup
+  module Pg
+    class Import
+      attr_reader :pg_database_name, :database
+
+      def initialize(pg_database_name)
+        @pg_database_name = pg_database_name
+
+        config = Rails.configuration.database_configuration
+        @database = config[Rails.env]['database']
+      end
+
+      def now!
+        puts 'Setup local database ...'
+        setup_local_database
+        puts 'Downloading pg database ...'
+        S3Backup::S3.new.download!(pg_database_name, Config.s3_pg_path, pg_dump_s3_file.path)
+        umcompress_file
+        puts "Loading data in #{database} ..."
+        load_file
+        clean_env
+        puts '🍺  Done!'
+      end
+
+      private
+
+      def pg_dump_s3_file
+        @pg_dump_s3_file ||= Tempfile.new(pg_database_name + '_compressed')
+      end
+
+      def pg_dump_file
+        @pg_dump_file ||= Tempfile.new(pg_database_name)
+      end
+
+      def umcompress_file
+        file = File.open(pg_dump_file.path, 'w')
+
+        Zlib::GzipReader.open(pg_dump_s3_file.path) do |gz|
+          file.write gz.read
+        end
+        file.close
+      end
+
+      def load_file
+        `psql -d #{database} -f #{pg_dump_file.path} 2> /dev/null`
+      end
+
+      def setup_local_database
+        Rake::Task['db:drop'].invoke
+        Rake::Task['db:create'].invoke
+      end
+
+      def clean_env
+        pg_dump_file.unlink
+        pg_dump_s3_file.unlink
+      end
+
+    end
+  end
+end

data/lib/s3_backup/pg/obfuscate.rb

@@ -0,0 +1,97 @@
+require 'zlib'
+require 'faker'
+
+module S3Backup
+  module Pg
+    class Obfuscate
+
+      LINE_SEPARATOR   = "\t".freeze
+      END_OF_STATEMENT = '\.'.freeze
+
+      attr_reader :dump_file, :file_path
+
+      def initialize(dump_file, file_path)
+        @dump_file = dump_file
+        @file_path = file_path
+      end
+
+      def obfuscate_dump!
+        file = Zlib::GzipWriter.open(file_path)
+
+        File.open(dump_file).each do |line|
+          file.write(obfuscate_line(line.chomp) + "\n")
+        end
+        file.close
+      end
+
+      private
+
+      def obfuscate_line(line)
+        if line == END_OF_STATEMENT
+          @inside_copy_statement = false
+        elsif table_to_obfuscate(line)
+          pepare_statement_line_to_replace(line)
+        elsif @inside_copy_statement && !line.include?(@exception)
+          line_split = line.split(LINE_SEPARATOR)
+
+          @replacements.each do |position, type|
+            line_split[position] = replace_value(type)
+          end
+
+          return line_split.join(LINE_SEPARATOR)
+        end
+
+        line
+      end
+
+      # INFO:
+      # Test if the line start with COPY
+      # return false if the table is not in the configration file
+      # return the name of the table
+      #
+      def table_to_obfuscate(line)
+        return false if line[0..3] != 'COPY'
+
+        Config.tables.keys.each do |table_name|
+          return table_name if line.include?("COPY #{table_name} (")
+        end
+
+        false
+      end
+
+      # INFO:
+      # Pepare variables for the next insert lines
+      #
+      def pepare_statement_line_to_replace(line)
+        @table_name   = table_to_obfuscate(line)
+        column_names  = line[/\(([^)]+)\)/].tr('(),', '').split
+        @replacements = {}
+
+        column_names.each_with_index do |column_name, index|
+          if Config.tables[@table_name]['columns'].key?(column_name)
+            @replacements[index] = Config.tables[@table_name]['columns'][column_name]
+            @exception           = Config.tables[@table_name]['exception']
+          end
+        end
+
+        @inside_copy_statement = true
+      end
+
+      def replace_value(type)
+        case type
+        when 'email'
+          Faker::Internet.email("#{Faker::Name.name}_#{rand(100_000)}")
+        when 'first_name'
+          Faker::Name.first_name
+        when 'last_name'
+          Faker::Name.last_name
+        when 'name'
+          Faker::Name.name
+        else
+          'not defined'
+        end
+      end
+
+    end
+  end
+end

data/lib/s3_backup/railtie.rb

@@ -0,0 +1,12 @@
+require 'rails'
+
+module S3Backup
+  class Railtie < Rails::Railtie
+    railtie_name :s3_backup
+
+    rake_tasks do
+      load 'tasks/pg.rake'
+      load 'tasks/redis.rake'
+    end
+  end
+end

data/lib/s3_backup/redis/backup.rb

@@ -0,0 +1,48 @@
+require 'zlib'
+
+module S3Backup
+  module Redis
+    class Backup
+
+      def now!
+        puts 'Compressing dump ...'
+        compress_file
+        puts 'Compressed.'
+        puts 'Upload to S3 ...'
+        S3Backup::S3.new.upload!(compressed_file_name, Config.s3_redis_path, compressed_file.path)
+        puts 'Uploaded.'
+        puts 'Clean environement.'
+        clean_env
+        S3Backup::S3.new.clean!(base_s3_name, Config.s3_redis_path)
+      end
+
+      private
+
+      def compress_file
+        file = Zlib::GzipWriter.open(compressed_file.path)
+
+        File.open(Config.redis_dump_path).each do |line|
+          file.write(line)
+        end
+        file.close
+      end
+
+      def base_s3_name
+        "redis-#{Rails.env}"
+      end
+
+      def compressed_file_name
+        @compressed_file_name ||= "#{base_s3_name}-#{Time.now.to_i}.gz"
+      end
+
+      def compressed_file
+        @compressed_file ||= Tempfile.new(compressed_file_name)
+      end
+
+      def clean_env
+        compressed_file.unlink
+      end
+
+    end
+  end
+end

data/lib/s3_backup/redis/import.rb

@@ -0,0 +1,72 @@
+require 'zlib'
+
+module S3Backup
+  module Redis
+    class Import
+      STOP_REDIS_COMMAND  = 'brew services stop redis'.freeze
+      START_REDIS_COMMAND = 'brew services start redis'.freeze
+
+      attr_reader :redis_evironement, :redis_s3_file_name, :redis_dump_file_path
+
+      def initialize(redis_evironement)
+        @redis_evironement    = redis_evironement
+        @redis_s3_file_name   = "redis-#{redis_evironement}"
+        @redis_dump_file_path = '/usr/local/var/db/redis/dump.rdb'
+      end
+
+      def now!
+        puts 'Stop redis database ...'
+        stop_redis_database
+        puts 'Downloading redis database ...'
+        S3Backup::S3.new.download!(redis_s3_file_name, Config.s3_redis_path, redis_dump_s3_file.path)
+        umcompress_file
+        copy_file
+        puts 'Start redis database ...'
+        start_redis_database
+        clean_env
+        puts '🍺  Done!'
+      end
+
+      private
+
+      def redis_dump_s3_file
+        @redis_dump_s3_file ||= Tempfile.new("#{redis_s3_file_name}_compressed")
+      end
+
+      def redis_dump_file
+        @redis_dump_file ||= Tempfile.new(redis_s3_file_name)
+      end
+
+      def umcompress_file
+        file = File.open(redis_dump_file.path, 'w')
+
+        Zlib::GzipReader.open(redis_dump_s3_file.path) do |gz|
+          file.write gz.read
+        end
+        file.close
+      end
+
+      def copy_file
+        `mv #{redis_dump_file.path} #{redis_dump_file_path}`
+      end
+
+      def stop_redis_database
+        Bundler.with_clean_env do
+          `#{STOP_REDIS_COMMAND} 2> /dev/null`
+        end
+      end
+
+      def start_redis_database
+        Bundler.with_clean_env do
+          `#{START_REDIS_COMMAND} 2> /dev/null`
+        end
+      end
+
+      def clean_env
+        redis_dump_file.unlink
+        redis_dump_s3_file.unlink
+      end
+
+    end
+  end
+end

data/lib/s3_backup/s3.rb

@@ -0,0 +1,79 @@
+require 'fog'
+require 'zlib'
+require 'ruby-progressbar'
+
+module S3Backup
+  class S3
+
+    attr_reader :connection
+
+    def initialize
+      @connection = Fog::Storage.new(
+        provider:              'AWS',
+        aws_access_key_id:     Config.aws_access_key_id,
+        aws_secret_access_key: Config.aws_secret_access_key,
+        region:                Config.aws_region
+      )
+    end
+
+    def upload!(file_name, bucket_path, file_path)
+      directory = @connection.directories.get(Config.bucket)
+
+      directory.files.create(
+        key:    File.join(bucket_path, file_name),
+        body:   File.open(file_path),
+        public: false
+      )
+
+      true
+    end
+
+    def download!(database_name, bucket_path, file_path)
+      progress_bar
+      prefix = File.join(bucket_path, database_name)
+      directory = connection.directories.get(Config.bucket, prefix: prefix)
+
+      s3_backup_file = directory.files.sort_by(&:last_modified).reverse.first
+
+      raise "#{database_name} file not found on s3" unless s3_backup_file
+
+      file = File.open(file_path, 'wb')
+      directory.files.get(s3_backup_file.key) do |chunk, remaining_bytes, total_bytes|
+        update_progress_bar(total_bytes, remaining_bytes)
+        file.write chunk
+      end
+      file.close
+
+      true
+    end
+
+    def clean!(base_name, bucket_path)
+      prefix = File.join(bucket_path, base_name)
+      directory = connection.directories.get(Config.bucket, prefix: prefix)
+
+      s3_files = directory.files.sort_by(&:last_modified).reverse
+      files_to_remove = s3_files[Config.s3_keep..-1]
+
+      return true if files_to_remove.blank?
+
+      files_to_remove.each(&:destroy)
+
+      true
+    end
+
+    private
+
+    def progress_bar
+      @progress_bar ||= ProgressBar.create(
+        format:         "%a %b\u{15E7}%i %p%% %t",
+        progress_mark:  ' ',
+        remainder_mark: "\u{FF65}"
+      )
+    end
+
+    def update_progress_bar(total, remaining)
+      progress_bar.progress = (((total - remaining) * 100) / total).to_i
+    end
+
+  end
+end

data/lib/s3_backup/version.rb

@@ -0,0 +1,3 @@
+module S3Backup # :nodoc:
+  VERSION = '0.0.2'.freeze
+end

data/lib/s3_backup.rb

@@ -0,0 +1,61 @@
+require 's3_backup/config'
+require 's3_backup/s3'
+
+require 's3_backup/pg/obfuscate'
+require 's3_backup/pg/backup'
+require 's3_backup/pg/import'
+
+require 's3_backup/redis/backup'
+require 's3_backup/redis/import'
+
+require 's3_backup/railtie' if defined?(Rails)
+
+module S3Backup
+  class << self
+
+    def pg_backup!(database_name)
+      require_s3_params
+      Config.requires!(:pg_host, :pg_user, :s3_pg_path, :tables)
+
+      backup = Pg::Backup.new(database_name)
+      backup.now!
+    end
+
+    def pg_import!(pg_database_name)
+      raise 'Need to be run in a rails project' unless defined?(Rails)
+
+      require_s3_params
+      Config.requires!(:s3_pg_path)
+
+      import = Pg::Import.new(pg_database_name)
+      import.now!
+    end
+
+    def redis_backup!
+      require_s3_params
+      Config.requires!(:redis_dump_path, :s3_redis_path)
+
+      backup = Redis::Backup.new
+      backup.now!
+    end
+
+    def redis_import!(redis_evironement)
+      raise 'Import only work with redis installed by brew' if Dir['/usr/local/Cellar/redis/*'].blank?
+
+      require_s3_params
+      Config.requires!(:s3_redis_path)
+
+      import = Redis::Import.new(redis_evironement)
+      import.now!
+    end
+
+    private
+
+    def require_s3_params
+      Config.load!('config/s3_backup_obfuscate.yml')
+
+      Config.requires!(:aws_access_key_id, :aws_secret_access_key, :bucket, :aws_region, :s3_keep)
+    end
+
+  end
+end

data/lib/tasks/pg.rake

@@ -0,0 +1,22 @@
+require 'pry'
+require 's3_backup'
+
+namespace :s3_backup do
+  namespace :pg do
+
+    desc 'Backup, obfuscate & compress Postgres database to s3'
+    task :backup, [:database] do |_task, args|
+      raise 'You need to specify a database' unless args[:database]
+
+      S3Backup.pg_backup! args[:database]
+    end
+
+    desc 'Import Postgres database from s3'
+    task :import, [:pg_database] do |_task, args|
+      raise 'You need to specify a pg database' unless args[:pg_database]
+
+      S3Backup.pg_import! args[:pg_database]
+    end
+
+  end
+end

data/lib/tasks/redis.rake

@@ -0,0 +1,19 @@
+require 's3_backup'
+
+namespace :s3_backup do
+  namespace :redis do
+
+    desc 'Backup & compress Redis database to s3'
+    task :backup do |_task, _args|
+      S3Backup.redis_backup!
+    end
+
+    desc 'Import Redis database from s3'
+    task :import, [:redis_environement] do |_task, args|
+      raise 'You need to specify a redis environement' unless args[:redis_environement]
+
+      S3Backup.redis_import! args[:redis_environement]
+    end
+
+  end
+end

data/spec/fixtures/obfuscate_default.yml

@@ -0,0 +1,20 @@
+---
+
+pg_database:
+  host: my_host
+  user: my_user
+  password: pss
+
+s3:
+  aws_access_key_id: XXX
+  aws_secret_access_key: DSLK
+  bucket: my_bucket
+  aws_region: p-southeast-2
+  pg_path: pg_backup
+
+tables:
+  users:
+    columns:
+      name: name
+      email: email
+    exception: '@mycompany.me'

data/spec/s3_backup/pg/obfuscate_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe S3Backup::Pg::Obfuscate do
+  let(:configuration_file) { 'spec/fixtures/obfuscate_default.yml' }
+
+  before { S3Backup::Config.load!(configuration_file) }
+
+  subject(:obfuscate) { S3Backup::Pg::Obfuscate.new(nil, nil) }
+
+  describe 'private#obfuscate_line' do
+    context 'parse line' do
+      let(:table_header) { "COPY users (id, name, email, created_at, updated_at) FROM stdin;" }
+      let(:line_table)   { "42\tTom Test\ttom@test.me\t2016-06-15 04:23:00.121\t2016-06-23 07:08:02.08" }
+
+      before { obfuscate.send(:obfuscate_line, table_header) }
+
+      it { expect(obfuscate.send(:obfuscate_line, line_table)).to_not include('tom@test.me') }
+      it { expect(obfuscate.send(:obfuscate_line, line_table)).to_not include('Tom Test') }
+    end
+
+    context 'parse with exception line' do
+      let(:table_header) { "COPY users (id, name, email, created_at, updated_at) FROM stdin;" }
+      let(:line_table)   { "42\tTom Test\ttom@mycompany.me\t2016-06-15 04:23:00.121\t2016-06-23 07:08:02.08" }
+
+      before { obfuscate.send(:obfuscate_line, table_header) }
+
+      it { expect(obfuscate.send(:obfuscate_line, line_table)).to include('tom@mycompany.me') }
+      it { expect(obfuscate.send(:obfuscate_line, line_table)).to include('Tom Test') }
+    end
+
+    context 'if table is not difined' do
+      let(:table_header) { "COPY accounts (id, name, email, created_at, updated_at) FROM stdin;" }
+      let(:line_table)   { "42\tTom Test\ttom@test.me\t2016-06-15 04:23:00.121\t2016-06-23 07:08:02.08" }
+
+      before { obfuscate.send(:obfuscate_line, table_header) }
+
+      it { expect(obfuscate.send(:obfuscate_line, line_table)).to include('tom@test.me') }
+      it { expect(obfuscate.send(:obfuscate_line, line_table)).to include('Tom Test') }
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'bundler/setup'
+require 's3_backup'
+require 'rspec'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+  config.mock_with :rspec
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: s3_backup
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Tom Floc'h
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.41'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.41'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: ruby-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.49'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.49'
+description: Postgres, redis backup and restore
+email:
+- thomas.floch@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- README.md
+- Rakefile
+- lib/s3_backup.rb
+- lib/s3_backup/config.rb
+- lib/s3_backup/pg/backup.rb
+- lib/s3_backup/pg/import.rb
+- lib/s3_backup/pg/obfuscate.rb
+- lib/s3_backup/railtie.rb
+- lib/s3_backup/redis/backup.rb
+- lib/s3_backup/redis/import.rb
+- lib/s3_backup/s3.rb
+- lib/s3_backup/version.rb
+- lib/tasks/pg.rake
+- lib/tasks/redis.rake
+- spec/fixtures/obfuscate_default.yml
+- spec/s3_backup/pg/obfuscate_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/arkes/s3_backup
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Postgres, redis backup and restore
+test_files: []