scalingo_backups_manager 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '0098acfcaa51bcbcd0ab7675849a739bdf6617f970968c975ea6eaf9d218b7dd'
+  data.tar.gz: fe08d492ab01f1495b733d5dcbccd1004f1d78ae930ea5db0fb700640f91a969
+SHA512:
+  metadata.gz: da90a3650e78a0b00960dbdad25c6493ea475803c31ad7cdb70ea8b86638520c02a65b0d4bbe99272716918eb9f2b73de4a8f79a5dfc276ffe5af51aac1545b1
+  data.tar.gz: 7ea91ada14e91ac0e4ec23c73eac3ba929ad3d099aee8463d47d0f4feb2af3a7fae4b4b4e2ab8bbe6045d73eb53e19c610871851dbef73f24deb7cfd3b67e94d

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+scalingo-backups-config.yml
+/backups/
+.idea

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.6
+before_install: gem install bundler -v 2.1.4

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at kevin@9troisquarts.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [https://contributor-covenant.org/version/1/4][version]
+
+[homepage]: https://contributor-covenant.org
+[version]: https://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in scalingo_backups_manager.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -0,0 +1,69 @@
+PATH
+  remote: .
+  specs:
+    scalingo_backups_manager (0.3.0)
+      httparty (~> 0.18)
+      scalingo (~> 3.0)
+      thor (~> 1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (6.1.3.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    concurrent-ruby (1.1.8)
+    diff-lcs (1.4.4)
+    faraday (1.0.1)
+      multipart-post (>= 1.2, < 3)
+    faraday_middleware (1.0.0)
+      faraday (~> 1.0)
+    httparty (0.18.1)
+      mime-types (~> 3.0)
+      multi_xml (>= 0.5.2)
+    i18n (1.8.10)
+      concurrent-ruby (~> 1.0)
+    mime-types (3.3.1)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2021.0225)
+    minitest (5.14.4)
+    multi_json (1.15.0)
+    multi_xml (0.6.0)
+    multipart-post (2.1.1)
+    rake (12.3.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    scalingo (3.0.0)
+      activesupport (>= 5, < 7)
+      faraday (~> 1.0.1)
+      faraday_middleware (~> 1.0.0)
+      multi_json (~> 1.0, >= 1.0.3)
+    thor (1.1.0)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake (~> 12.0)
+  rspec (~> 3.0)
+  scalingo_backups_manager!
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Kevin Clercin
+
+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 limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+# THIS GEM IS A WORK IN PROGRESS
+# Scalingo backups manager
+
+This gem allow to download backups of multiple scalingo applications and addons in order to be restore in local database or be send to an SFTP server
+
+
+## TODO
+
+- Mysql
+- Postgresql
+
+## Installation
+
+Add this line to your application's Gemfile (not hosted on Rubygems):
+
+```ruby
+gem 'scalingo_backups_manager', git: "https://github.com/9troisquarts/scalingo_backups_manager"
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install scalingo_backups_manager
+
+## Usage
+
+In order to use this gem, you need to define an environment variable named SCALINGO_API_TOKEN which can be created on your [scalingo profile](https://dashboard-prev.osc-fr1.scalingo.com/profile)
+
+`bundle exec scalingo_backups_manager`
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/scalingo_backups_manager. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/scalingo_backups_manager/blob/master/CODE_OF_CONDUCT.md).
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the ScalingoBackupsManager project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/scalingo_backups_manager/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "scalingo_backups_manager"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/scalingo_backups_manager

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "scalingo_backups_manager"
+
+ScalingoBackupsManager::Cli.start(ARGV)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/scalingo_backups_manager.rb

@@ -0,0 +1,6 @@
+require "scalingo_backups_manager/version"
+require 'scalingo_backups_manager/cli'
+module ScalingoBackupsManager
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/scalingo_backups_manager/addon.rb

@@ -0,0 +1,64 @@
+require 'scalingo_backups_manager/configuration'
+require 'scalingo_backups_manager/backup'
+
+module ScalingoBackupsManager
+
+  class Addon
+
+    attr_accessor :application, :addon, :config
+
+    DEFAULT_DATABASE_API_ROOT_URL = "https://db-api.osc-fr1.scalingo.com"
+
+    def self.find(app, id, config: {})
+      addon = Configuration.client.addons.find(app.id, id).data
+      self.new(app, addon, config: config)
+    end
+
+    def initialize(app, addon, config: {})
+      raise "Application must be set" unless app && app.is_a?(ScalingoBackupsManager::Application)
+      @application = app
+      @addon = addon
+      @config = config
+    end
+
+    def database_api_url(options: {})
+      return @database_api_url if @database_api_url
+      @database_api_url = "#{options[:database_api_root_url] || DEFAULT_DATABASE_API_ROOT_URL}/api/databases/#{id}"
+    end
+
+    def client(options: {})
+      return @client if @client
+      scalingo = Scalingo::Client.new
+      scalingo.authenticate_with(access_token: ENV["SCALINGO_API_TOKEN"])
+      response = scalingo.addons.token(application.id, id).data
+      if response.try(:[], :token)
+        bearer_token = response[:token]
+      else
+        raise "An error occured during addon authentication"
+      end
+
+      addon_cli_config = Scalingo::Client.new
+      addon_cli_config.token = bearer_token
+      @client = Scalingo::API::Client.new(database_api_url(options), scalingo: addon_cli_config)
+    end
+
+
+    [:id, :resource_id, :addon_provider].each do |attr_name|
+      define_method attr_name do
+        addon[attr_name]
+      end
+    end
+
+    def backups
+      response = client.authenticated_connection.get("#{database_api_url}/backups").body
+      return [] unless response[:database_backups] && response[:database_backups].size > 0
+      bcks = []
+      response[:database_backups].each do |backup|
+        bcks.push ScalingoBackupsManager::Backup.new(self, backup[:id])
+      end
+      bcks
+    end
+
+  end
+
+end

data/lib/scalingo_backups_manager/application.rb

@@ -0,0 +1,43 @@
+require 'scalingo_backups_manager/configuration'
+
+module ScalingoBackupsManager
+  class Application
+
+    class << self
+      def client
+        Configuration.client
+      end
+
+      def all
+        client.apps.all&.data || []
+      end
+
+      def find(id)
+        app = client.apps.find(id)&.data
+        self.new(app)
+      end
+
+    end
+
+    attr_accessor :application
+
+    def initialize(app)
+      @application = app
+    end
+
+    [:id, :name].each do |attr_name|
+      define_method attr_name do
+        application[attr_name]
+      end
+    end
+
+    def client
+      self.class.client
+    end
+
+    def addons
+      self.class.client.addons.for(application[:id])&.data || []
+    end
+
+  end
+end

data/lib/scalingo_backups_manager/backup.rb

@@ -0,0 +1,19 @@
+module ScalingoBackupsManager
+
+  class Backup
+    attr_accessor :addon, :id
+
+    def initialize(add, id)
+      @addon = add
+      @id = id
+    end
+
+    def download_link
+      response = addon.client.authenticated_connection.get("#{addon.database_api_url}/backups/#{id}/archive").body
+      return nil unless response[:download_url]
+      response[:download_url]
+    end
+
+  end
+
+end

data/lib/scalingo_backups_manager/cli.rb

@@ -0,0 +1,129 @@
+require 'thor'
+require 'scalingo_backups_manager/configuration'
+require 'scalingo_backups_manager/application'
+require 'scalingo_backups_manager/addon'
+require 'scalingo_backups_manager/restore/mongodb'
+require 'scalingo_backups_manager/restore/postgres'
+require 'scalingo_backups_manager/restore/mysql'
+
+module ScalingoBackupsManager
+
+  DATABASE_PROVIDER_IDS = %w(mongodb postgresql mysql)
+  class Cli < Thor
+    desc "install", "It will guide you in the configuration process"
+    method_options all: :boolean
+    def install
+      all = options[:all]
+      unless Configuration.file_exists?
+        puts "Configuration file not found"
+        puts "Creating file..."
+        Configuration.create_file
+      end
+      unless ENV["SCALINGO_API_TOKEN"]
+        puts "The environment variable SCALINGO_API_TOKEN is not set, Exiting..."
+        return
+      end
+      configuration = Configuration.new
+      applications = ScalingoBackupsManager::Application.all
+      if applications.empty?
+        puts "You do not have access to any scalingo application"
+        return
+      end
+      if all
+        puts "Fetching scalingo app"
+        applications.each do |app|
+          application = ScalingoBackupsManager::Application.find(app[:id])
+          application.addons.each do |addon|
+            addon = ScalingoBackupsManager::Addon.find(application, addon[:id])
+            configuration.add_addon_to_app(application, addon) if addon.addon_provider[:id] && DATABASE_PROVIDER_IDS.include?(addon.addon_provider[:id])
+          end
+        end
+      else
+        application = nil
+        while application.nil?
+          applications.each_with_index do |application, index|
+            puts "#{index + 1} - #{application[:name]}"
+          end
+          application_choice = ask("Select an application :").to_i
+          application = ScalingoBackupsManager::Application.find(applications[application_choice - 1][:id]) if application_choice > 0 && applications[application_choice - 1]
+        end
+
+        addons = application.addons
+        if addons.empty?
+          puts "This application have no addons"
+          return
+        end
+        addon = nil
+        while addon.nil?
+          p "#### Selecting #{application.name} addon ####"
+          addons.each_with_index do |addon, index|
+            puts "#{index + 1} - #{addon[:addon_provider][:name]} #{addon[:plan][:display_name]}"
+          end
+          addon_choice = ask("Select addon :").to_i
+          addon = ScalingoBackupsManager::Addon.find(application, addons[addon_choice - 1][:id]) if addon_choice > 0 && addons[addon_choice - 1]
+        end
+        configuration.add_addon_to_app(application, addon)
+      end
+    end
+
+    desc "download", "Download last backup all of application in configuration"
+    method_options application: :string, addon: :string
+    def download
+      searched_application = options[:application]
+      searched_addon = options[:addon]
+      configuration = Configuration.new
+      unless configuration
+        puts "No configuration found, invoking install"
+        invoke :install
+      end
+
+      configuration.for_each_addons(searched_application, searched_addon) do |application, addon|
+        backups = addon.backups
+        next unless backups.size > 0
+        backup = backups.first
+        download_link = backup.download_link
+        if download_link
+          path = ("#{addon.config[:path]}" || "backups/#{addon.addon_provider[:id]}") + "/#{Time.now.strftime("%Y%m%d")}.tar.gz"
+          if File.exist?(path)
+            puts "Backup already download, skipping..."
+          else
+            system "curl #{download_link} -o #{path} --create-dirs"
+          end
+        else
+          puts "No download link found for #{addon.addon_provider[:id]}, Skipping..."
+        end
+      end
+    end
+
+    desc "restore", "Restore application backup to database"
+    method_option :application, type: :string, aliases: "-A", desc: "Application of addons to restore"
+    method_option :addon, :type => :string, aliases: "-a", desc: "Addon to restore"
+    method_option :port, type: :string, aliases: "-p", desc: "Port of database"
+    method_option :host, type: :string, aliases: "-h", desc: "Host of your database server, useful when you are running your database in docker"
+    method_option :remote_database, type: :string, aliases: "-rdb", desc: "Name of remote database to restore"
+    method_option :database, type: :string, aliases: "-db", desc: "Name of local database, default is the database set in your database.yml/mongoid.yml"
+    method_option :skip_backup_delete, type: :boolean, aliases: "-skip-rm", desc: "Skip the deletion of folder after restore is complete"
+    def restore
+      invoke :download, [], application: options[:application], addon: options[:addon]
+      configuration = Configuration.new
+      configuration.for_each_addons(options[:application], options[:addon]) do |application, addon|
+        path = ("#{addon.config[:path]}" || "backups/#{addon.addon_provider[:id]}") + "/#{Time.now.strftime("%Y%m%d")}.tar.gz"
+        opts = { port: options[:port], host: options[:host], remote_database_name: options[:remote_database], local_database_name: options[:database], skip_rm: options[:skip_backup_delete] }
+        case addon.addon_provider[:id]
+        when 'mongodb'
+          ScalingoBackupsManager::Restore::Mongodb.restore(path, opts)
+        when 'postgresql'
+          ScalingoBackupsManager::Restore::Postgres.restore(path, opts)
+        when 'mysql'
+          ScalingoBackupsManager::Restore::Mysql.restore(path, opts)
+        else
+          puts "Restore of #{addon.addon_provider[:id]} is not handle yet"
+        end
+      end
+    end
+
+  end
+
+  private
+
+end

data/lib/scalingo_backups_manager/configuration.rb

@@ -0,0 +1,74 @@
+require 'scalingo'
+require 'yaml'
+require 'scalingo_backups_manager/application'
+require 'scalingo_backups_manager/addon'
+
+module ScalingoBackupsManager
+
+  class Configuration
+    attr_accessor :config
+    FILE_NAME = "scalingo-backups-config.yml"
+
+    def self.file_exists?
+      File.exist?(FILE_NAME)
+    end
+
+    def self.create_file
+      File.open(FILE_NAME, 'w+') do |f|
+        f.flock(File::LOCK_EX)
+        content = f.read
+        f.rewind
+        f.write({ region: 'osc-fr-1', apps: []}.to_yaml)
+        f.flush
+      end
+    end
+
+    def self.client
+      return @client if @client
+      @client = Scalingo::Client.new
+      @client.authenticate_with(access_token: ENV["SCALINGO_API_TOKEN"])
+      @client
+    end
+
+    def self.write_config(config)
+      File.open(FILE_NAME, "w+") do |f|
+        f.flock(File::LOCK_EX)
+        f.truncate(0)
+        f.write(config.to_yaml)
+        f.flush
+      end
+    end
+
+    def initialize
+      @file = File.open(FILE_NAME)
+      unless @file
+        puts "Configuration file does not exist"
+        return
+      end
+      @config = YAML.load(@file.read) || { apps: [] }
+    end
+
+    def add_addon_to_app(application, addon)
+      @config.deep_merge!({ apps: { "#{application.name}": { id: application.id, addons: { "#{addon.addon_provider[:id]}": { id: addon.id, path: "backups/#{application.name}/#{addon.addon_provider[:id]}/" } } } } })
+      self.class.write_config(@config)
+    end
+
+    def for_each_addons(application_uid, addon_uid)
+      @config[:apps].each do |application_name, application_config|
+        next if application_uid && application_uid != application_name.to_s
+        next unless application_config[:id]
+        application = ScalingoBackupsManager::Application.find(application_config[:id])
+        next unless application_config[:addons] && application_config[:addons].size > 0
+        application_config[:addons].each do |addon_name, addon_config|
+          next if addon_uid && addon_uid != addon_name.to_s
+          next unless addon_config[:id]
+          addon = ScalingoBackupsManager::Addon.find(application, addon_config[:id], config: addon_config)
+          yield(application, addon) if block_given?
+        end
+      end
+    end
+
+
+  end
+
+end

data/lib/scalingo_backups_manager/restore/mongodb.rb

@@ -0,0 +1,66 @@
+require 'yaml'
+require 'erb'
+module ScalingoBackupsManager
+  module Restore
+    class Mongodb
+
+      def self.restore(filename, options = {})
+        opts = options.reverse_merge({
+          database_config_file: 'mongoid.yml',
+          env: 'development',
+          host: nil,
+          remote_database_name: nil,
+          local_database_name: nil,
+          skip_rm: false
+        })
+        destination_path = filename.split("/")
+        backup_name = destination_path.pop.gsub(".tar.gz", "")
+        destination_path = destination_path.join("/") + backup_name + "/"
+        p destination_path
+        if Dir.exist?(destination_path)
+          puts "Unzipped backup is already present, skipping..."
+        else
+          Dir.mkdir(destination_path) unless Dir.exist?(destination_path)
+          untar_cmd = "tar zxvf #{filename} -C #{destination_path}"
+          system untar_cmd
+        end
+
+        rails_db_config = YAML.load(ERB.new(File.read("config/#{opts[:database_config_file]}")).result)[opts[:env]]["clients"]["default"]
+        config = {
+          host: rails_db_config["hosts"].first,
+          database: rails_db_config["database"],
+          password: rails_db_config["options"]["password"],
+          user: rails_db_config["options"]["user"],
+          auth_source: rails_db_config["options"]["auth_source"]
+        }
+
+        restore_cmd = "/usr/bin/env mongorestore --drop -h #{opts[:host] || config[:host]}"
+        if opts[:local_database_name].present?
+          restore_cmd << " --db #{opts[:local_database_name]}"
+        end
+
+        if opts[:remote_database_name].present?
+          restore_cmd << " --dir \"#{destination_path}/#{opts[:remote_database_name]}\""
+        else
+          restore_cmd << " --dir \"#{destination_path}/\""
+        end
+
+        if config[:auth_source].present?
+          restore_cmd << " --authenticationDatabase #{config[:auth_source]}"
+        end
+        if config[:user].present?
+          restore_cmd << " -u #{config[:user]}"
+          if config[:password].present?
+            restore_cmd << " --password"
+            restore_cmd << " #{config[:password]}"
+          end
+        end
+
+        puts "*** Restoring backup to Mongodb database ***"
+        system(restore_cmd)
+        FileUtils.rm_r destination_path unless opts[:skip_rm]
+      end
+
+    end
+  end
+end

data/lib/scalingo_backups_manager/restore/mysql.rb

@@ -0,0 +1,71 @@
+require 'yaml'
+require 'erb'
+module ScalingoBackupsManager
+  module Restore
+    class Mysql
+
+      def self.restore(filename, options = {})
+        opts = options.reverse_merge({
+          database_config_file: 'database.yml',
+          env: 'development',
+          host: nil,
+          remote_database_name: nil,
+          local_database_name: nil,
+          skip_rm: false,
+          port: nil,
+        })
+        destination_path = filename.split("/")
+        backup_name = destination_path.pop.gsub(".tar.gz", "")
+        destination_path = destination_path.join("/") + backup_name + "/"
+        if Dir.exist?(destination_path)
+          puts "Unzipped backup is already present, skipping..."
+        else
+          unless Dir.exist?(destination_path)
+            p "Creating destination folder..."
+            Dir.mkdir(destination_path)
+          end
+          untar_cmd = "tar zxvf #{filename} -C #{destination_path}"
+          p "Untar file with command #{untar_cmd}"
+          system untar_cmd
+        end
+
+        rails_db_config = YAML.load(ERB.new(File.read("config/#{opts[:database_config_file]}")).result)[opts[:env]]
+        config = {
+          host: rails_db_config["host"],
+          database: rails_db_config["database"],
+          password: rails_db_config["password"],
+          user: rails_db_config["username"],
+        }
+
+        restore_cmd = "/usr/bin/env mysql -h #{opts[:host] || config[:host]}"
+
+        if config[:user].present?
+          restore_cmd << " -u #{config[:user]}"
+          if config[:password].present?
+            restore_cmd << " --password="
+            restore_cmd << "#{config[:password]}"
+          end
+        end
+
+        if config[:port].present? || opts[:port].present?
+          restore_cmd << " -P #{opts[:port] || config[:port] || 5432}"
+        end
+
+        restore_cmd << " #{config[:database]}"
+
+        file_path = Dir["#{destination_path}*.sql"]
+        if file_path.empty?
+          puts "*** No SQL file found in tar ***"
+          return
+        end
+        restore_cmd << " < #{file_path.first}"
+
+        puts "*** Restoring backup to mysql database ***"
+        puts "Command: #{restore_cmd}"
+        system(restore_cmd)
+        #FileUtils.rm_r destination_path unless opts[:skip_rm]
+      end
+
+    end
+  end
+end

data/lib/scalingo_backups_manager/restore/postgres.rb

@@ -0,0 +1,60 @@
+require 'yaml'
+require 'erb'
+module ScalingoBackupsManager
+  module Restore
+    class Postgres
+
+      def self.restore(filename, options = {})
+        opts = options.reverse_merge({
+          database_config_file: 'database.yml',
+          env: 'development',
+          host: nil,
+          remote_database_name: nil,
+          local_database_name: nil,
+          skip_rm: false,
+          port: nil,
+        })
+        destination_path = filename.split("/")
+        backup_name = destination_path.pop.gsub(".tar.gz", "")
+        destination_path = destination_path.join("/") + backup_name + "/"
+        p destination_path
+        if Dir.exist?(destination_path)
+          puts "Unzipped backup is already present, skipping..."
+        else
+          Dir.mkdir(destination_path) unless Dir.exist?(destination_path)
+          untar_cmd = "tar zxvf #{filename} -C #{destination_path}"
+          system untar_cmd
+        end
+
+        rails_db_config = YAML.load(ERB.new(File.read("config/#{opts[:database_config_file]}")).result)[opts[:env]]
+        config = {
+          host: rails_db_config["host"],
+          database: rails_db_config["database"],
+          password: rails_db_config["password"],
+          user: rails_db_config["user"],
+        }
+
+        restore_cmd = "/usr/bin/env psql #{config[:database]} -h #{opts[:host] || config[:host]}"
+
+        if config[:user].present?
+          restore_cmd << " --u #{config[:user]}"
+          if config[:password].present?
+            restore_cmd << " --password"
+            restore_cmd << " #{config[:password]}"
+          end
+        end
+
+        if config[:port].present?
+          restore_cmd << " -p #{opts[:port] || config[:port] || 5432}"
+        end
+
+        restore_cmd << " < #{destination_path}"
+
+        puts "*** Restoring backup to Postgres database ***"
+        system(restore_cmd)
+        FileUtils.rm_r destination_path unless opts[:skip_rm]
+      end
+
+    end
+  end
+end

data/lib/scalingo_backups_manager/version.rb

@@ -0,0 +1,3 @@
+module ScalingoBackupsManager
+  VERSION = "0.3.0"
+end

data/scalingo_backups_manager.gemspec

@@ -0,0 +1,31 @@
+require_relative 'lib/scalingo_backups_manager/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "scalingo_backups_manager"
+  spec.version       = ScalingoBackupsManager::VERSION
+  spec.authors       = ["Kevin Clercin"]
+  spec.email         = ["kevin@9troisquarts.com"]
+
+  spec.summary       = %q{Gem allowing to download backups from scalingo}
+  spec.homepage      = "https://github.com/9troisquarts/scalingo_backups_manager"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/9troisquarts/scalingo_backups_manager"
+  spec.metadata["changelog_uri"] = "https://github.com/9troisquarts/scalingo_backups_manager/CHANGELOG.md"
+
+  spec.add_dependency "thor", '~> 1.1'
+  spec.add_dependency 'httparty', "~> 0.18"
+  spec.add_dependency 'scalingo', '~> 3.0'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.executables   << "scalingo_backups_manager"
+  spec.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: scalingo_backups_manager
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Kevin Clercin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-05-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: scalingo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- kevin@9troisquarts.com
+executables:
+- scalingo_backups_manager
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/scalingo_backups_manager
+- bin/setup
+- lib/scalingo_backups_manager.rb
+- lib/scalingo_backups_manager/addon.rb
+- lib/scalingo_backups_manager/application.rb
+- lib/scalingo_backups_manager/backup.rb
+- lib/scalingo_backups_manager/cli.rb
+- lib/scalingo_backups_manager/configuration.rb
+- lib/scalingo_backups_manager/restore/mongodb.rb
+- lib/scalingo_backups_manager/restore/mysql.rb
+- lib/scalingo_backups_manager/restore/postgres.rb
+- lib/scalingo_backups_manager/version.rb
+- scalingo_backups_manager.gemspec
+homepage: https://github.com/9troisquarts/scalingo_backups_manager
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/9troisquarts/scalingo_backups_manager
+  source_code_uri: https://github.com/9troisquarts/scalingo_backups_manager
+  changelog_uri: https://github.com/9troisquarts/scalingo_backups_manager/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Gem allowing to download backups from scalingo
+test_files: []