naifa 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1329fb6a9bb4e66cdda6324051f3e96db9c580a4
-  data.tar.gz: 728f6f2db1382efb334a7401735d7612b8628f1f
+  metadata.gz: b7dd8770b81f31bf68ccefd8075c47684e96e673
+  data.tar.gz: 83d07884667956748f511303493df74252d1f69b
 SHA512:
-  metadata.gz: 5d5bd7b6421a6c83d74dae4f4dc4c5c13717e7b4fb6e87531ee4398d72e688f8296acaaac693052aeb214230825beedaaea3cb292b1442faffa7c411932107db
-  data.tar.gz: a6767db22a22bdc2bfe3bf3c9e5f600520e854a6b97aef24ab5516b0f7d7dd5db5d5192eb44b87ef217af9a30eab59de88a26364edb843efb4b2fa0179caad52
+  metadata.gz: 16f3c9bbbde9428b2687903b42652d49ce459999d3b33718787292446c0dd939f7b0fa84988bf164731313b6a43d4c5086e83e3ba28154385ee612b6dcabf363
+  data.tar.gz: 796136b7e1980256f88b147e0b92acd52e09b796a988c35690d8efd059f66a9c5db2085eca5ed6fcd5e2e14197534c94b1cf06ceb701c5379b8c1f0e9c640272

data/README.md

@@ -34,79 +34,104 @@ You should now update some of the settings to meet your app configurations.
 
 The .naifa file contains settings that will have an influence in the available command options.
 
-The current default settings are the following:
+The current default generated settings are the following:
 ```
 ---
-version: 1.0
+version: 1.1
 db:
   plugin: :postgres
   settings:
     filename: db_backup
-    backup:
-      path: "./data/db_dumps"
-      db_name: ''
-      environment: :staging
+    path: "./data/db_dumps"
+    environments:
       production:
         type: :heroku
+        remote: production
       staging:
         type: :heroku
+        remote: staging
       development:
         type: :docker
         app_name: db
         database: ''
         username: "\\$POSTGRES_USER"
         path: "/db_dumps/"
+    backup:
+      environment: :staging
     restore:
-      path: "./data/db_dumps"
       environment: :development
+s3:
+  plugin: :s3
+  settings:
+    environments:
+      production:
+        bucket: s3://production_bucket_name/
       staging:
-        type: :heroku
+        bucket: s3://staging_bucket_name/
       development:
-        type: :docker
-        app_name: db
-        database: ''
-        username: "\\$POSTGRES_USER"
-        path: "/db_dumps/"
+        bucket: s3://development_bucket_name/
+    sync:
+      origin: :staging
+      destination: :development
+      sync_options:
+      - "--delete"
+      - "--acl public-read"
 ```
 
 Taking this into account, you'll be able to run the following commands
 
-### sync
+### postgres sync
 
 ```
-$ naifa sync db
+$ naifa db sync
 ```
 
 This will sync your staging postgres db in heroku to your development postgres in docker
 
 ```
-$ naifa sync db production
+$ naifa db sync production
 ```
 
 This will sync your production postgres db in heroku to your development postgres in docker
 
-### backup
+### postgres backup
 
 ```
-$ naifa backup db
+$ naifa db backup
 ```
 
 This will backup your staging postgres db in heroku to './data/db_dumps/db_backup'
 
 ```
-$ naifa backup db production
+$ naifa db backup production
 ```
 
 This will backup your postgres postgres db in heroku to './data/db_dumps/db_backup'
 
-### restore
+### postgres restore
 
 ```
-$ naifa restore db
+$ naifa db restore
 ```
 
 This will restore the backup in './data/db_dumps/db_backup' to your development postgres
 
+### s3 sync
+
+```
+$ naifa s3 sync
+```
+
+This will sync your staging s3 bucket with your development s3 bucket
+
+```
+$ naifa s3 sync production staging
+```
+
+This will sync your production s3 bucket with your staging s3 bucket
+
+NOTE: sync_options allow you to specify [aws s3 sync](http://docs.aws.amazon.com/cli/latest/reference/s3/sync.html) command options.
+
 ## Advanced
 
 Imagine that you have 2 databases with different settings and configurations
@@ -114,78 +139,68 @@ You can update you configuration file by adding another entry like in the exampl
 
 ```
 ---
-version: 1.0
+version: 1.1
 db:
   plugin: :postgres
   settings:
     filename: db_backup
-    backup:
-      path: "./data/db_dumps"
-      db_name: ''
-      environment: :staging
+    path: "./data/db_dumps"
+    environments:
       production:
         type: :heroku
+        remote: production
       staging:
         type: :heroku
+        remote: staging
       development:
         type: :docker
         app_name: db
-        database: dev_db
+        database: ''
         username: "\\$POSTGRES_USER"
         path: "/db_dumps/"
+    backup:
+      environment: :staging
     restore:
-      path: "./data/db_dumps"
       environment: :development
-      staging:
-        type: :heroku
-      development:
-        type: :docker
-        app_name: db
-        database: dev_db
-        username: "\\$POSTGRES_USER"
-        path: "/db_dumps/"
 db_local:
   plugin: :postgres
   settings:
     filename: db_backup
-    backup:
-      path: "./data/db_dumps"
-      db_name: ''
-      environment: :staging
+    path: "./data/db_dumps"
+    environments:
       production:
         type: :heroku
+        remote: production
       staging:
         type: :heroku
+        remote: staging
       development:
         type: :local
         database: dev_db1
-        username: postgres
+        username: "\\$POSTGRES_USER"
+        password: pass
+        path: "/db_dumps/"
+    backup:
+      environment: :staging
     restore:
-      path: "./data/db_dumps"
       environment: :development
-      staging:
-        type: :heroku
-      development:
-        type: :local
-        database: dev_db1
-        username: postgres
 ```
 
 This configuration will allow you to run the commands like this:
 
 ```
-$ naifa sync db
-$ naifa sync db_local
+$ naifa db sync
+$ naifa db_local sync
 ```
 
 ## Roadmap
 
 * Add tests
 * Add documentation
-* Add AWS S3 sync between environments
+* -Add AWS S3 sync between environments-
 * Add MySQL sync, backup and restore
 * Add MongoDB sync, backup and restore
-* Rethink the commands to more dynamic depending on the plugin
+* -Rethink the commands to more dynamic depending on the plugin-
 * Add logs and better error handling
 
 ## Development

data/lib/naifa/cli.rb

@@ -1,46 +1,28 @@
 module Naifa
   require 'thor'
-  class CLI < Thor
-
-    desc "init <filename>", "Initializes <filename=.naifa> config file with all default settings"
-    def init(filename='.naifa')
-      File.write(filename, Naifa::Config.generate_full_default_settings.to_h.to_yaml)
-    end
-
-    desc "sync <what> <from> <to>", "Syncs <what> from <from> to <to>"
-    def sync(what, from=nil, to=nil)
-      what_config = Naifa::Config.settings[what.to_sym] || {}
 
-      options = {backup: {}, restore: {}}
-      options[:backup][:environment] = from unless from.nil?
-      options[:restore][:environment] = to unless to.nil?
-
-      case what_config[:plugin]
-      when :postgres
-        Naifa::Postgres.sync(what_config.fetch(:settings,{}).deep_merge(options))
-      end
+  module PluginsCLI
+    Naifa::Config.settings.each do |sub_comm, settings|
+      class_eval <<-EORUBY
+        class #{sub_comm.to_s.capitalize} < #{Naifa::Plugins::registry[settings[:plugin]][:cli].to_s}
+          @settings_key = :#{sub_comm}
+        end
+      EORUBY
     end
+  end
 
-    desc "backup <what> <from>", "Backup <what> from <from>"
-    def backup(what, from=nil)
-      what_config = Naifa::Config.settings[what.to_sym] || {}
-      options = from.nil? ? {} : {backup: {environment: from}}
+  class CLI < Thor
 
-      case what_config[:plugin]
-      when :postgres
-        Naifa::Postgres.backup(what_config.fetch(:settings,{}).deep_merge(options))
-      end
+    desc "init <filename>", "Initializes <filename=.naifa> config file with all default settings"
+    def init(filename='.naifa')
+      File.write(filename, Naifa::Config.generate_example_settings.to_h.to_yaml)
     end
 
-    desc "restore <what> <to>", "Restore <what> to <to>"
-    def restore(what, to=nil)
-      what_config = Naifa::Config.settings[what.to_sym] || {}
-      options = to.nil? ? {} : {restore: {environment: to}}
-
-      case what_config[:plugin]
-      when :postgres
-        Naifa::Postgres.restore(what_config.fetch(:settings,{}).deep_merge(options))
-      end
+    Naifa::Config.settings.each do |sub_comm, settings|
+      class_eval <<-EORUBY
+        desc "#{sub_comm} SUBCOMMAND ...ARGS", "#{Naifa::Plugins::registry[settings[:plugin]][:description].to_s}"
+        subcommand "#{sub_comm}", PluginsCLI::#{sub_comm.to_s.capitalize}
+      EORUBY
     end
   end
 end

data/lib/naifa/config.rb

@@ -3,27 +3,31 @@ module Naifa
     require 'yaml'
     require 'active_support/core_ext/hash/indifferent_access'
 
-    SETTINGS_VERSION = 1.0
+    SETTINGS_VERSION = 1.1
     DEFAULT_SETTINGS = {
       db: {
         :plugin => :postgres
+      },
+      s3: {
+        :plugin => :s3
       }
     }.with_indifferent_access.freeze
 
     def self.settings
       @settings ||= begin
         loaded_settings = YAML.load(File.read('.naifa')).with_indifferent_access if File.exists?('.naifa')
-        if !loaded_settings.nil? && loaded_settings[:version] != SETTINGS_VERSION
+        if !loaded_settings.nil? && loaded_settings.delete(:version) != SETTINGS_VERSION
           raise 'Configuration file version is not supported. Please upgrade!'
         end
         loaded_settings
-      end || DEFAULT_SETTINGS
+      end || {}
     end
 
-    def self.generate_full_default_settings
+    def self.generate_example_settings
       full_settings = {'version' => SETTINGS_VERSION}.with_indifferent_access
         .merge(DEFAULT_SETTINGS)
-      full_settings[:db][:settings] = Naifa::Postgres::DEFAULT_SETTINGS
+      full_settings[:db][:settings] = Naifa::Plugins::Postgres::DEFAULT_SETTINGS
+      full_settings[:s3][:settings] = Naifa::Plugins::S3::DEFAULT_SETTINGS
       full_settings.to_hash
     end
 

data/lib/naifa/heroku.rb

@@ -9,9 +9,7 @@ module Naifa
       end
 
       def self.sync(from=:production, to=:staging)
-        puts "Heroku Sync from: #{from} to: #{to}"
         res = capture(from)
-        # puts build_restore_command("`#{build_public_url_command(from)}`", to)
         Kernel.system(build_restore_command("`#{build_public_url_command(from)}`", to)) if res
       end
 

data/lib/naifa/plugins/postgres/cli.rb

@@ -0,0 +1,47 @@
+module Naifa
+  module Plugins
+    class Postgres
+      require 'thor'
+
+      class CLI < Thor
+        @settings_key = nil
+        class << self
+          attr_reader :settings_key
+        end
+
+        desc "sync <from> <to>", "Syncs from <from> to <to>"
+        def sync(from=nil, to=nil)
+          config = Naifa::Config.settings[settings_key] || {}
+
+          options = {backup: {}, restore: {}}
+          options[:backup][:environment] = from unless from.nil?
+          options[:restore][:environment] = to unless to.nil?
+
+          Postgres.sync(config.fetch(:settings,{}).deep_merge(options))
+        end
+
+        desc "backup <from>", "Backup from <from>"
+        def backup(from=nil)
+          config = Naifa::Config.settings[settings_key] || {}
+          options = from.nil? ? {} : {backup: {environment: from}}
+
+          Postgres.backup(config.fetch(:settings,{}).deep_merge(options))
+        end
+
+        desc "restore <to>", "Restore to <to>"
+        def restore(to=nil)
+          config = Naifa::Config.settings[settings_key] || {}
+          options = to.nil? ? {} : {restore: {environment: to}}
+
+          Postgres.restore(config.fetch(:settings,{}).deep_merge(options))
+        end
+
+        no_commands do
+          def settings_key
+            self.class.settings_key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/naifa/plugins/postgres/settings.rb

@@ -0,0 +1,70 @@
+module Naifa
+  module Plugins
+    class Postgres
+      DEFAULT_FILENAME = 'db_backup'.freeze
+      DEFAULT_SETTINGS = {
+        filename: DEFAULT_FILENAME,
+        path: './data/db_dumps',
+        environments: {
+          production: {
+            type: :heroku,
+            remote: 'production'
+          },
+          staging: {
+            type: :heroku,
+            remote: 'staging'
+          },
+          development: {
+            type: :docker,
+            app_name: 'db',
+            database: '',
+            username: '\$POSTGRES_USER',
+            path: '/db_dumps/'
+          }
+        },
+        backup: {
+          environment: :staging
+        },
+        restore: {
+          environment: :development
+        }
+      }.with_indifferent_access.freeze
+
+      # DEFAULT_SETTINGS = {
+      #   filename: DEFAULT_FILENAME,
+      #   backup: {
+      #     path: './data/db_dumps',
+      #     db_name: '',
+      #     environment: :staging,
+      #     production: {
+      #       type: :heroku
+      #     },
+      #     staging: {
+      #       type: :heroku
+      #     },
+      #     development: {
+      #       type: :docker,
+      #       app_name: 'db',
+      #       database: '',
+      #       username: '\$POSTGRES_USER',
+      #       path: '/db_dumps/'
+      #     }
+      #   },
+      #   restore: {
+      #     path: './data/db_dumps',
+      #     environment: :development,
+      #     staging: {
+      #       type: :heroku
+      #     },
+      #     development: {
+      #       type: :docker,
+      #       app_name: 'db',
+      #       database: '',
+      #       username: '\$POSTGRES_USER',
+      #       path: '/db_dumps/'
+      #     }
+      #   }
+      # }.with_indifferent_access.freeze
+    end
+  end
+end

data/lib/naifa/plugins/postgres.rb

@@ -0,0 +1,240 @@
+module Naifa
+
+  module Plugins
+    class Postgres
+      require 'naifa/plugins/postgres/cli'
+      require 'naifa/plugins/postgres/settings'
+      require 'active_support'
+      require 'active_support/core_ext/hash/deep_merge'
+      require 'active_support/core_ext/object/blank'
+      require 'naifa/utils'
+
+      def self.restore(options={})
+        filename = options.fetch(:filename, DEFAULT_FILENAME)
+
+        _restore(filename, options)
+      end
+
+      def self.backup(options={})
+        filename = options.fetch(:filename, DEFAULT_FILENAME)
+
+        _backup(filename, options)
+      end
+
+      def self.sync(options={})
+        options ||= {}
+        filename = options.fetch(:filename, DEFAULT_FILENAME)
+
+        backup_settings = options.fetch(:backup, {})
+        restore_settings = options.fetch(:restore, {})
+        environments_settings = options.fetch(:environments, {})
+
+        if backup_settings[:environment].blank? ||
+            environments_settings[backup_settings[:environment]].blank? ||
+            restore_settings[:environment].blank? ||
+            environments_settings[restore_settings[:environment]].blank?
+
+          raise Thor::Error, "Sync (Backup and Restore) environments are not defined"
+        end
+
+        if environments_settings[backup_settings[:environment]][:type] == :heroku &&
+           environments_settings[restore_settings[:environment]][:type] == :heroku
+
+           Heroku::Postgres.sync(
+             environments_settings[backup_settings[:environment]][:remote].presence || backup_settings[:environment],
+             environments_settings[restore_settings[:environment]][:remote].presence || restore_settings[:environment]
+           )
+        else
+          _backup(filename, options)
+          _restore(filename, options)
+        end
+      end
+
+      def self._backup(filename, options={})
+        options ||= {}
+        backup_settings = options[:backup]
+        environments_settings = options[:environments]
+
+        if backup_settings[:environment].blank? ||
+          environments_settings[backup_settings[:environment]].blank?
+
+          raise Thor::Error, "Backup environment is not defined"
+        end
+
+        environment_settings = environments_settings[backup_settings[:environment]]
+
+        case environment_settings[:type]
+        when :remote
+          if environment_settings[:host].blank? ||
+              environment_settings[:username].blank? ||
+              environment_settings[:database].blank? ||
+              (environment_settings[:path].presence || options[:path].presence).blank?
+
+            raise Thor::Error, "Backup remote environment #{backup_settings[:environment]} is not correctly configured"
+          end
+
+          command_line = build_backup_command(
+            environment_settings[:host],
+            environment_settings[:username],
+            environment_settings[:database],
+            File.join(
+              environment_settings[:path].presence || options[:path].presence,
+              filename
+            )
+          )
+          Kernel.system(command_line)
+        when :local
+          if environment_settings[:username].blank? ||
+              environment_settings[:database].blank? ||
+              (environment_settings[:path].presence || options[:path].presence).blank?
+
+            raise Thor::Error, "Backup local environment #{backup_settings[:environment]} is not correctly configured"
+          end
+
+          command_line = build_backup_command(
+            'localhost',
+            environment_settings[:username],
+            environment_settings[:database],
+            File.join(
+              environment_settings[:path].presence || options[:path].presence,
+              filename
+            )
+          )
+          Kernel.system(command_line)
+        when :heroku
+          if (environment_settings[:path].presence || options[:path].presence).blank?
+            raise Thor::Error, "Backup heroku environment #{backup_settings[:environment]} is not correctly configured"
+          end
+
+          Heroku::Postgres.backup(
+            File.join(
+              environment_settings[:path].presence || options[:path].presence,
+              filename
+            ),
+            environment_settings[:remote].presence || backup_settings[:environment]
+          )
+        when :docker
+          if environment_settings[:username].blank? ||
+              environment_settings[:database].blank? ||
+              (environment_settings[:path].presence || options[:path].presence).blank? ||
+              environment_settings[:app_name].blank?
+
+            raise Thor::Error, "Restore docker environment #{backup_settings[:environment]} is not correctly configured"
+          end
+
+          command_line = build_backup_command(
+            'localhost',
+            environment_settings[:username],
+            environment_settings[:database],
+            File.join(
+              environment_settings[:path].presence || options[:path].presence,
+              filename
+            )
+          )
+          Utils.docker_compose_exec_command(
+            environment_settings[:app_name].presence,
+            command_line
+          )
+        else
+          raise Thor::Error, "Backup unsupported type"
+        end
+      end
+
+      private_class_method :_backup
+
+      def self._restore(filename, options={})
+        options ||= {}
+
+        restore_settings = options[:restore]
+        environments_settings = options[:environments]
+
+        if restore_settings[:environment].blank? ||
+          environments_settings[restore_settings[:environment]].blank?
+
+          raise Thor::Error, "Restore environment is not defined"
+        end
+
+        environment_settings = environments_settings[restore_settings[:environment]]
+
+        case environment_settings[:type]
+        when :remote
+          if environment_settings[:host].blank? ||
+              environment_settings[:username].blank? ||
+              environment_settings[:database].blank? ||
+              (environment_settings[:path].presence || options[:path].presence).blank?
+
+            raise Thor::Error, "Restore remote environment #{restore_settings[:environment]} is not correctly configured"
+          end
+
+          command_line = build_restore_command(
+            environment_settings[:host],
+            environment_settings[:username],
+            environment_settings[:database],
+            File.join(
+              environment_settings[:path].presence || options[:path].presence,
+              filename
+            )
+          )
+          Kernel.system(command_line)
+        when :local
+          if environment_settings[:username].blank? ||
+              environment_settings[:database].blank? ||
+              (environment_settings[:path].presence || options[:path].presence).blank?
+
+            raise Thor::Error, "Restore local environment #{restore_settings[:environment]} is not correctly configured"
+          end
+
+          command_line = build_restore_command(
+            'localhost',
+            environment_settings[:username],
+            environment_settings[:database],
+            File.join(
+              environment_settings[:path] || options[:path],
+              filename
+            )
+          )
+          Kernel.system(command_line)
+        when :docker
+          if environment_settings[:username].blank? ||
+              environment_settings[:database].blank? ||
+              (environment_settings[:path].presence || options[:path].presence).blank? ||
+              environment_settings[:app_name].blank?
+
+            raise Thor::Error, "Restore docker environment #{restore_settings[:environment]} is not correctly configured"
+          end
+
+          command_line = build_restore_command(
+            'localhost',
+            environment_settings[:username],
+            environment_settings[:database],
+            File.join(
+              environment_settings[:path].presence || options[:path].presence,
+              filename
+            )
+          )
+          Utils.docker_compose_exec_command(
+            environment_settings[:app_name],
+            command_line
+          )
+        else
+          raise Thor::Error, "Restore unsupported type"
+        end
+      end
+
+      private_class_method :_restore
+
+      def self.build_restore_command(host, username, database, filename)
+        "pg_restore --verbose --clean --no-acl --no-owner -h #{host} -U #{username} -d #{database} #{filename}"
+      end
+
+      private_class_method :build_restore_command
+
+      def self.build_backup_command(host, username, database, filename)
+        "pg_dump -Fc -h #{host} -U #{username} -d #{database} > #{filename}"
+      end
+
+      private_class_method :build_backup_command
+
+    end
+  end
+end

data/lib/naifa/plugins/s3/cli.rb

@@ -0,0 +1,31 @@
+module Naifa
+  module Plugins
+    class S3
+      require 'thor'
+
+      class CLI < Thor
+        @settings_key = nil
+        class << self
+          attr_reader :settings_key
+        end
+
+        desc "sync <from> <to>", "Syncs from <from> to <to>"
+        def sync(from=nil, to=nil)
+          config = Naifa::Config.settings[settings_key] || {}
+
+          options = {sync: {}}
+          options[:sync][:origin] = from unless from.nil?
+          options[:sync][:destination] = to unless to.nil?
+
+          S3.sync(config.fetch(:settings,{}).deep_merge(options))
+        end
+
+        no_commands do
+          def settings_key
+            self.class.settings_key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/naifa/plugins/s3/settings.rb

@@ -0,0 +1,24 @@
+module Naifa
+  module Plugins
+    class S3
+      DEFAULT_SETTINGS = {
+        environments: {
+          production: {
+            bucket: 's3://production_bucket_name/'
+          },
+          staging: {
+            bucket: 's3://staging_bucket_name/'
+          },
+          development: {
+            bucket: 's3://development_bucket_name/'
+          }
+        },
+        sync: {
+          origin: :staging,
+          destination: :development,
+          sync_options: ['--delete', '--acl public-read']
+        }
+      }.with_indifferent_access.freeze
+    end
+  end
+end

data/lib/naifa/plugins/s3.rb

@@ -0,0 +1,51 @@
+module Naifa
+
+  module Plugins
+    class S3
+      require 'naifa/plugins/s3/cli'
+      require 'naifa/plugins/s3/settings'
+      require 'active_support'
+      require 'active_support/core_ext/hash/deep_merge'
+      require 'active_support/core_ext/object/blank'
+      require 'naifa/utils'
+
+      def self.sync(options={})
+        options ||= {}
+
+        sync_settings = options[:sync]
+        environments_settings = options[:environments]
+
+        if sync_settings.blank? ||
+          sync_settings[:origin].blank? ||
+          sync_settings[:destination].blank?
+
+          raise Thor::Error, "Sync settings are not defined"
+        end
+
+        origin = sync_settings[:origin]
+        destination = sync_settings[:destination]
+
+        if environments_settings.blank? ||
+          environments_settings[origin].blank? || environments_settings[origin][:bucket].blank? ||
+          environments_settings[destination].blank? || environments_settings[destination][:bucket].blank?
+
+          raise Thor::Error, "Sync environments not set"
+        end
+
+        command = build_sync_command(
+                    environments_settings[origin][:bucket],
+                    environments_settings[destination][:bucket],
+                    sync_settings.fetch(:sync_options, [])
+                  )
+
+        Kernel.system(command)
+      end
+
+      def self.build_sync_command(from_bucket, to_bucket, sync_options=[])
+        command = "aws s3 sync #{from_bucket} #{to_bucket}"
+        command << " #{sync_options.join(' ')}" if sync_options.present?
+        command
+      end
+    end
+  end
+end

data/lib/naifa/plugins.rb

@@ -0,0 +1,23 @@
+module Naifa
+  require 'naifa/plugins/postgres'
+  require 'naifa/plugins/s3'
+
+  module Plugins
+    REGISTRY = {
+      postgres: {
+        cli: Naifa::Plugins::Postgres::CLI,
+        description: 'Sync, backup and restore postgres dbs'
+      },
+      s3: {
+        cli: Naifa::Plugins::S3::CLI,
+        description: 'Syncs s3 buckets'
+      }
+    }.with_indifferent_access.freeze
+
+    def registry
+      REGISTRY
+    end
+
+    module_function :registry
+  end
+end

data/lib/naifa/version.rb

@@ -1,3 +1,3 @@
 module Naifa
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/naifa.rb

@@ -1,7 +1,7 @@
 require 'naifa/version'
 require 'naifa/config'
 require 'naifa/heroku'
-require 'naifa/postgres'
+require 'naifa/plugins'
 
 module Naifa
   # Your code goes here...

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: naifa
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Filipe Dias
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-07 00:00:00.000000000 Z
+date: 2017-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,8 +94,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.19'
-description: |2
-      Naifa is a tool aimed at providing a collection of commands that simplify the development workflow.
+description: "    Naifa is a tool aimed at providing a collection of commands that
+  simplify the development workflow.\n"
 email:
 - f.dias@runtime-revolution.com
 executables:
@@ -118,7 +118,13 @@ files:
 - lib/naifa/cli.rb
 - lib/naifa/config.rb
 - lib/naifa/heroku.rb
-- lib/naifa/postgres.rb
+- lib/naifa/plugins.rb
+- lib/naifa/plugins/postgres.rb
+- lib/naifa/plugins/postgres/cli.rb
+- lib/naifa/plugins/postgres/settings.rb
+- lib/naifa/plugins/s3.rb
+- lib/naifa/plugins/s3/cli.rb
+- lib/naifa/plugins/s3/settings.rb
 - lib/naifa/utils.rb
 - lib/naifa/version.rb
 - naifa.gemspec
@@ -142,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Naifa is a tool aimed at providing a collection of commands that simplify

data/lib/naifa/postgres.rb

@@ -1,180 +0,0 @@
-module Naifa
-  require 'naifa/utils'
-
-  class Postgres
-    require 'active_support/core_ext/hash/deep_merge'
-
-    DEFAULT_SETTINGS = {
-      filename: 'db_backup',
-      backup: {
-        path: './data/db_dumps',
-        db_name: '',
-        environment: :staging,
-        production: {
-          type: :heroku
-        },
-        staging: {
-          type: :heroku
-        },
-        development: {
-          type: :docker,
-          app_name: 'db',
-          database: '',
-          username: '\$POSTGRES_USER',
-          path: '/db_dumps/'
-        }
-      },
-      restore: {
-        path: './data/db_dumps',
-        environment: :development,
-        staging: {
-          type: :heroku
-        },
-        development: {
-          type: :docker,
-          app_name: 'db',
-          database: '',
-          username: '\$POSTGRES_USER',
-          path: '/db_dumps/'
-        }
-      }
-    }.with_indifferent_access.freeze
-
-    def self.restore(options={})
-      filename = options.fetch(:filename, DEFAULT_SETTINGS[:filename])
-      restore_settings = DEFAULT_SETTINGS[:restore].deep_merge(options.fetch(:restore, {}))
-
-      _restore(filename, restore_settings)
-    end
-
-    def self.backup(options={})
-      filename = options.fetch(:filename, DEFAULT_SETTINGS[:filename])
-      backup_settings = DEFAULT_SETTINGS[:backup].deep_merge(options.fetch(:backup, {}))
-
-      _backup(filename, backup_settings)
-    end
-
-    def self.sync(options={})
-      filename = options.fetch(:filename, DEFAULT_SETTINGS[:filename])
-
-      backup_settings = DEFAULT_SETTINGS[:backup].deep_merge(options.fetch(:backup, {}))
-      restore_settings = DEFAULT_SETTINGS[:restore].deep_merge(options.fetch(:restore, {}))
-
-      return false if backup_settings[:environment].nil? ||
-                      backup_settings[backup_settings[:environment]].nil? ||
-                      restore_settings[:environment].nil? ||
-                      restore_settings[restore_settings[:environment]].nil?
-
-      if backup_settings[backup_settings[:environment]][:type] == :heroku &&
-         restore_settings[restore_settings[:environment]][:type] == :heroku
-
-         Heroku::Postgres.sync(
-           backup_settings[:environment],
-           restore_settings[:environment]
-         )
-      else
-        res = _backup(filename, backup_settings)
-        _restore(filename, restore_settings) if res
-      end
-    end
-
-    def self._backup(filename, options)
-      environment = options[:environment]
-      return false if environment.nil? || options[environment].nil?
-
-      case options[environment][:type]
-      when :remote
-        command_line = build_backup_command(
-          options[environment][:host],
-          options[environment][:username] || options[:username],
-          options[environment][:database] || options[:database],
-          File.join(
-            options[environment][:path] || options[:path],
-            filename
-          )
-        )
-        Kernel.system(command_line)
-      when :local
-        command_line = build_backup_command(
-          'localhost',
-          options[environment][:username] || options[:username],
-          options[environment][:database] || options[:database],
-          File.join(
-            options[environment][:path] || options[:path],
-            filename
-          )
-        )
-        Kernel.system(command_line)
-      when :heroku
-        Heroku::Postgres.backup(
-          File.join(
-            options[environment][:path] || options[:path],
-            filename
-          ),
-          environment
-        )
-      end
-    end
-
-    private_class_method :_backup
-
-    def self._restore(filename, options={})
-      environment = options[:environment]
-      return false if environment.nil? || options[environment].nil?
-
-      case options[environment][:type]
-      when :remote
-        command_line = build_restore_command(
-          options[environment][:host],
-          options[environment][:username] || options[:username],
-          options[environment][:database] || options[:database],
-          File.join(
-            options[environment][:path] || options[:path],
-            filename
-          )
-        )
-        Kernel.system(command_line)
-      when :local
-        command_line = build_restore_command(
-          'localhost',
-          options[environment][:username] || options[:username],
-          options[environment][:database] || options[:database],
-          File.join(
-            options[environment][:path] || options[:path],
-            filename
-          )
-        )
-        Kernel.system(command_line)
-      when :docker
-        command_line = build_restore_command(
-          'localhost',
-          options[environment][:username] || options[:username],
-          options[environment][:database] || options[:database],
-          File.join(
-            options[environment][:path] || options[:path],
-            filename
-          )
-        )
-        Utils.docker_compose_exec_command(
-          options[environment][:app_name],
-          command_line
-        )
-      end
-    end
-
-    private_class_method :_restore
-
-    def self.build_restore_command(host, username, database, filename)
-      "pg_restore --verbose --clean --no-acl --no-owner -h #{host} -U #{username} -d #{database} #{filename}"
-    end
-
-    private_class_method :build_restore_command
-
-    def self.build_backup_command(host, username, database, filename)
-      "pg_dump -Fc -h #{host} -U #{username} -d #{database} > #{filename}"
-    end
-
-    private_class_method :build_backup_command
-
-  end
-end