duple 0.0.1 → 0.0.2

data/CHANGES.md

@@ -0,0 +1,13 @@
+## 0.0.2 (October 21, 2012) - Fix local db config
+
+  * Load db connection details from the config file.
+  * Added some minimal class-level documentation.
+
+## 0.0.1 (October 19, 2012) - Initial release
+
+  * Implemented refresh from local to heroku and from heroku to local
+  * Implemented heroku to heroku refresh
+  * Implemented structure command
+  * Implemented config tasks
+  * Implemented copy command
+  * Added dry-run flag

data/README.md

@@ -26,31 +26,31 @@ figure the application. Read and modify it, or clear it out and write your own.
 
     # Resets the stage database
     # Loads the latest production snapshot into the stage database
-    $ duple refresh production stage
+    $ duple refresh -s production -t stage
 
     # Downloads the latest full snapshot from production
     # Resets the development database
     # Loads the snapshot into the development database
-    $ duple refresh production development
+    $ duple refresh -s production -t development
 
     # Captures a new production database snapshot
     # Downloads the latest full snapshot from production
     # Resets the development database
     # Loads the snapshot into the development database
-    $ duple refresh production development --capture
+    $ duple refresh -s production -t development --capture
 
     # Downloads the schema and a subset of data from stage
     # Resets the backstage database
     # Loads the structure and the subset into the backstage database
-    $ duple refresh stage backstage --group minimal
+    $ duple refresh -s stage -t backstage --group minimal
 
     # Downloads the data from the specified tables from the stage database
     # Loads the data into the backstage database
-    $ duple copy stage backstage --tables products categories
+    $ duple copy -s stage -t backstage --tables products categories
 
 ## Future
 
-  * Everything.
+  * Pre- and post- refresh hooks
   * Support for skipping pre- and post- refresh steps.
   * Support for running pre- and post- refresh steps by themselves.
   * Support for other data stores.

data/lib/duple/cli/config.rb

@@ -1,5 +1,25 @@
 module Duple
   module CLI
+
+    # Usage:
+    #   duple config [COMMAND]
+    #
+    # Options:
+    #   -c, [--config=CONFIG]  # The location of the config file.
+    #
+    # Manage your configuration.
+    #
+    # Tasks:
+    #   duple config all             # Prints the current configuration.
+    #   duple config environments    # Prints the environment configurations.
+    #   duple config groups          # Prints the group configurations.
+    #   duple config help [COMMAND]  # Describe subcommands or one specific subcommand
+    #   duple config other           # Prints other options.
+    #   duple config post-refresh    # Prints the post-refresh tasks.
+    #   duple config pre-refresh     # Prints the pre-refresh tasks.
+
+    # Options:
+    #   -c, [--config=CONFIG]  # The location of the config file.
     class Config < Thor
       include Duple::CLI::Helpers
 

data/lib/duple/cli/copy.rb

@@ -1,5 +1,19 @@
 module Duple
   module CLI
+
+    # Usage:
+    #   duple copy
+    #
+    # Options:
+    #   -c, [--config=CONFIG]         # The location of the config file.
+    #   -s, [--source=SOURCE]         # The name of the source environment.
+    #   -t, [--target=TARGET]         # The name of the target environment.
+    #   -g, [--group=GROUP]           # The group configuration to use when dumping source data.
+    #       [--capture]               # Capture a new source snapshot before refreshing.
+    #   --dry-run, [--dry-run]        # Perform a dry run of the command. No data will be moved.
+    #   -t, [--tables=one two three]  # A list of tables to include when dumping source data.
+    #
+    # Copies data from a source to a target database.
     class Copy < Thor::Group
       include Duple::CLI::Helpers
 
@@ -18,11 +32,11 @@ module Duple
       end
 
       def dump_data
-        postgres.pg_dump(dump_flags, data_file_path, source_credentials)
+        postgres.pg_dump(dump_flags, data_file_path, source_db_config)
       end
 
       def restore_data
-        postgres.pg_restore('-e -v --no-acl -O -a', data_file_path, target_credentials)
+        postgres.pg_restore('-e -v --no-acl -O -a', data_file_path, target_db_config)
       end
     end
   end

data/lib/duple/cli/helpers.rb

@@ -38,7 +38,7 @@ module Duple
 
         def group_option
           class_option :group,
-            desc: 'Name of the group configuration to use when dumping source data.',
+            desc: 'The group configuration to use when dumping source data.',
             type: :string,
             aliases: '-g'
         end
@@ -119,16 +119,40 @@ module Duple
           @structure_file_path ||= File.join(dump_dir_path, filename)
         end
 
-        def fetch_heroku_credentials(appname)
+        def source_db_config
+          @source_db_config ||= if config.heroku_source?
+                                  fetch_heroku_db_config(source_appname)
+                                else
+                                  config.db_config(config.source_name)
+                                end
+        end
+
+        def target_db_config
+          @target_db_config ||= if config.heroku_target?
+                                  fetch_heroku_db_config(target_appname)
+                                else
+                                  config.db_config(config.target_name)
+                                end
+        end
+
+        def fetch_heroku_db_config(appname)
+          # Run the heroku config command first, even if it's a dry run. So
+          # that the command to get the config will show up in the dry run log.
           config_vars = heroku.capture(appname, "config")
 
-          return config.dry_run_credentials(appname) if config.dry_run?
+          if config.dry_run?
+            config.db_config(appname, dry_run: true)
+          else
+            parse_heroku_config(config_vars)
+          end
+        end
 
+        def parse_heroku_config(config_vars)
           db_url = config_vars.split("\n").detect { |l| l =~ /DATABASE_URL/ }
           raise ArgumentError.new("Missing DATABASE_URL variable for #{appname}") if db_url.nil?
 
           db_url.match(
-            /postgres:\/\/(?<user>.*):(?<password>.*)@(?<host>.*):(?<port>\d*)\/(?<db>.*)/
+            /postgres:\/\/(?<username>.*):(?<password>.*)@(?<host>.*):(?<port>\d*)\/(?<database>.*)/
           )
         end
 
@@ -159,22 +183,6 @@ module Duple
           flags = [ '-Fc -a', include_flags, exclude_flags ].flatten.compact.join(' ')
         end
 
-        def source_credentials
-          @source_credentials ||= if config.heroku_source?
-                                    fetch_heroku_credentials(source_appname)
-                                  else
-                                    config.local_credentials
-                                  end
-        end
-
-        def target_credentials
-          @target_credentials ||= if config.heroku_target?
-                                    fetch_heroku_credentials(target_appname)
-                                  else
-                                    config.local_credentials
-                                  end
-        end
-
         def config
           @config ||= parse_config
         end

data/lib/duple/cli/init.rb

@@ -1,5 +1,13 @@
 module Duple
   module CLI
+
+    # Usage:
+    #   duple init
+    #
+    # Options:
+    #   -c, [--config=CONFIG]  # The location of the config file.
+    #
+    # Generates a sample configuration file.
     class Init < Thor::Group
       include Duple::CLI::Helpers
 

data/lib/duple/cli/refresh.rb

@@ -1,5 +1,18 @@
 module Duple
   module CLI
+
+    # Usage:
+    #   duple refresh
+    #
+    # Options:
+    #   -c, [--config=CONFIG]         # The location of the config file.
+    #   -s, [--source=SOURCE]         # The name of the source environment.
+    #   -t, [--target=TARGET]         # The name of the target environment.
+    #   -g, [--group=GROUP]           # The group configuration to use when dumping source data.
+    #       [--capture]               # Capture a new source snapshot before refreshing.
+    #   -t, [--tables=one two three]  # A list of tables to include when dumping source data.
+    #
+    # Resets and copies schema and data from a source to a target database
     class Refresh < Thor::Group
       include Duple::CLI::Helpers
 
@@ -54,7 +67,7 @@ module Duple
       def dump_data
         return unless dump_data?
 
-        postgres.pg_dump(dump_flags, data_file_path, source_credentials)
+        postgres.pg_dump(dump_flags, data_file_path, source_db_config)
       end
 
       def reset_target
@@ -63,9 +76,9 @@ module Duple
 
       def restore_database
         if download_snapshot?
-          postgres.pg_restore('-e -v --no-acl -O -a', @snapshot_path, target_credentials)
+          postgres.pg_restore('-e -v --no-acl -O -a', @snapshot_path, target_db_config)
         elsif dump_data?
-          postgres.pg_restore('-e -v --no-acl -O -a', data_file_path, target_credentials)
+          postgres.pg_restore('-e -v --no-acl -O -a', data_file_path, target_db_config)
         else
           heroku.run(target_appname, "pgbackups:restore DATABASE #{@source_snapshot_url}")
         end

data/lib/duple/cli/root.rb

@@ -12,6 +12,8 @@ require 'duple/heroku_runner'
 
 module Duple
   module CLI
+
+    # Configures the high-level structure of the CLI sub-commands.
     class Root < Thor
       include Duple::CLI::Helpers
 

data/lib/duple/cli/structure.rb

@@ -1,5 +1,15 @@
 module Duple
   module CLI
+
+    # Usage:
+    #   duple structure
+    #
+    # Options:
+    #   -c, [--config=CONFIG]  # The location of the config file.
+    #   -s, [--source=SOURCE]  # The name of the source environment.
+    #   -t, [--target=TARGET]  # The name of the target environment.
+    #
+    # Copies structure from a source to a target database.
     class Structure < Thor::Group
       include Duple::CLI::Helpers
 
@@ -8,7 +18,7 @@ module Duple
       target_option
 
       def dump_structure
-        postgres.pg_dump('-Fc --no-acl -O -s', structure_file_path, source_credentials)
+        postgres.pg_dump('-Fc --no-acl -O -s', structure_file_path, source_db_config)
       end
 
       def reset_target
@@ -16,7 +26,7 @@ module Duple
       end
 
       def load_structure
-        postgres.pg_restore('-v --no-acl -O -s', structure_file_path, target_credentials)
+        postgres.pg_restore('-v --no-acl -O -s', structure_file_path, target_db_config)
       end
     end
   end

data/lib/duple/configuration.rb

@@ -125,24 +125,38 @@ module Duple
       tables
     end
 
-    def dry_run_credentials(envname)
+    def db_config(appname, options = nil)
+      options ||= {}
+      options = {dry_run: false}.merge(options)
+
+      if options[:dry_run]
+        db_config_for_dry_run(appname)
+      else
+        db_config_for_app(appname)
+      end
+    end
+
+    def db_config_for_dry_run(appname)
       {
-        user:     "[#{envname}.USER]",
+        username: "[#{envname}.USER]",
         password: "[#{envname}.PASS]",
         host:     "[#{envname}.HOST]",
         port:     "[#{envname}.PORT]",
-        db:       "[#{envname}.DB]"
+        database: "[#{envname}.DB]"
       }
     end
 
-    def local_credentials
-      # TODO: Override these defaults from the config
+    def db_config_for_app(appname)
+      env = environments[appname]
+      if env['database'].nil?
+        raise ArgumentError.new('Invalid config: "database" is required for a local environment.')
+      end
       {
-        user:     'postgres',
-        password: '',
-        host:     'localhost',
-        port:     '5432',
-        db:       'duple_development'
+        username: env['username'] || 'postgres',
+        password: env['password'] || '',
+        host:     env['host'] || 'localhost',
+        port:     env['port'] || '5432',
+        database: env['database']
       }
     end
 

data/lib/duple/heroku_runner.rb

@@ -1,4 +1,7 @@
 module Duple
+
+  # Decorates a Duple::Runner instance with helper methods for executing
+  # Heroku commands.
   class HerokuRunner
     def initialize(runner)
       @runner = runner

data/lib/duple/pg_runner.rb

@@ -1,25 +1,28 @@
 module Duple
+
+  # Decorates a Duple::Runner instance with helper methods for executing
+  # PostgreSQL commands.
   class PGRunner
     def initialize(runner)
       @runner = runner
     end
 
-    def pg_dump(flags, dump_file, credentials)
-      pg_command('pg_dump', flags, credentials, nil, "> #{dump_file}")
+    def pg_dump(flags, dump_file, db_config)
+      pg_command('pg_dump', flags, db_config, nil, "> #{dump_file}")
     end
 
-    def pg_restore(flags, dump_file, credentials)
-      pg_command('pg_restore', flags, credentials, '-d', "< #{dump_file}")
+    def pg_restore(flags, dump_file, db_config)
+      pg_command('pg_restore', flags, db_config, '-d', "< #{dump_file}")
     end
 
-    def pg_command(pg_command, flags, credentials, db_flag, tail = nil)
+    def pg_command(pg_command, flags, db_config, db_flag, tail = nil)
         command = []
-        command << %{PGPASSWORD="#{credentials[:password]}"}
+        command << %{PGPASSWORD="#{db_config[:password]}"}
         command << pg_command
         command << flags
-        command << %{-h #{credentials[:host]} -U #{credentials[:user]} -p #{credentials[:port]}}
+        command << %{-h #{db_config[:host]} -U #{db_config[:username]} -p #{db_config[:port]}}
         command << db_flag if db_flag
-        command << credentials[:db]
+        command << db_config[:database]
         command << tail if tail
         @runner.run(command.join(' '))
     end

data/lib/duple/runner.rb

@@ -1,6 +1,8 @@
 require 'fileutils'
 
 module Duple
+
+  # Helper class for executing shell commands.
   class Runner
 
     def initialize(options = nil)

data/lib/duple/version.rb

@@ -1,3 +1,3 @@
 module Duple
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/duple/cli/copy_spec.rb

@@ -16,7 +16,7 @@ describe Duple::CLI::Copy do
   }
 
   context 'with neither tables nor group option' do
-    it 'fetches the source credentials' do
+    it 'fetches the source db config' do
       expect {
         invoke_copy(tables: nil)
       }.to raise_error(ArgumentError, 'One of --group or --tables options is required.')
@@ -27,7 +27,7 @@ describe Duple::CLI::Copy do
     let(:source) { 'stage' }
     let(:target) { 'development' }
 
-    it 'fetches the source credentials' do
+    it 'fetches the source db config' do
       runner.should_receive(:capture).with("heroku config -a duple-stage")
         .and_return(heroku_config_response)
 
@@ -53,14 +53,14 @@ describe Duple::CLI::Copy do
     let(:source) { 'production' }
     let(:target) { 'stage' }
 
-    it 'fetches the source credentials' do
+    it 'fetches the source db config' do
       runner.should_receive(:capture).with("heroku config -a duple-production")
         .and_return(heroku_config_response)
 
       invoke_copy
     end
 
-    it 'fetches the target credentials' do
+    it 'fetches the target db config' do
       runner.should_receive(:capture).with("heroku config -a duple-stage")
         .and_return(heroku_config_response)
 
@@ -86,7 +86,7 @@ describe Duple::CLI::Copy do
     let(:source) { 'development' }
     let(:target) { 'stage' }
 
-    it 'fetches the target credentials' do
+    it 'fetches the target db config' do
       runner.should_receive(:capture).with("heroku config -a duple-stage")
         .and_return(heroku_config_response)
 

data/spec/duple/cli/structure_spec.rb

@@ -18,7 +18,7 @@ describe Duple::CLI::Structure do
     let(:source) { 'stage' }
     let(:target) { 'development' }
 
-    it 'fetches the source credentials' do
+    it 'fetches the source db config' do
       runner.should_receive(:capture).with("heroku config -a duple-stage")
         .and_return(heroku_config_response)
 
@@ -57,14 +57,14 @@ describe Duple::CLI::Structure do
     let(:source) { 'production' }
     let(:target) { 'stage' }
 
-    it 'fetches the source credentials' do
+    it 'fetches the source db config' do
       runner.should_receive(:capture).with("heroku config -a duple-production")
         .and_return(heroku_config_response)
 
       invoke_structure
     end
 
-    it 'fetches the target credentials' do
+    it 'fetches the target db config' do
       runner.should_receive(:capture).with("heroku config -a duple-stage")
         .and_return(heroku_config_response)
 
@@ -103,7 +103,7 @@ describe Duple::CLI::Structure do
     let(:source) { 'development' }
     let(:target) { 'stage' }
 
-    it 'fetches the target credentials' do
+    it 'fetches the target db config' do
       runner.should_receive(:capture).with("heroku config -a duple-stage")
         .and_return(heroku_config_response)
 

data/spec/duple/configuration_spec.rb

@@ -2,6 +2,54 @@ require 'spec_helper'
 
 describe Duple::Configuration do
 
+
+  describe '#db_config' do
+    let(:config_hash) { YAML.load(File.read('spec/config/simple.yml'))}
+
+    it 'supplies default database values for a local environment' do
+      config = Duple::Configuration.new(config_hash, {})
+      c = config.db_config('development')
+      c[:username].should == 'postgres'
+      c[:password].should == ''
+      c[:host].should == 'localhost'
+      c[:port].should == '5432'
+    end
+
+    context 'with all db config parameters' do
+      let(:db_config_hash) {
+        db_hash = config_hash['environments']['development']
+        db_hash['username'] = 'config_username'
+        db_hash['password'] = 'config_password'
+        db_hash['host'] = 'config_host'
+        db_hash['port'] = '6022'
+        db_hash['database'] = 'config_database'
+        config_hash
+      }
+      let(:config) { Duple::Configuration.new(db_config_hash, {}) }
+      subject(:db_config) { config.db_config('development') }
+
+      it 'loads the options from the config' do
+        db_config[:username].should == 'config_username'
+        db_config[:password].should == 'config_password'
+        db_config[:host].should == 'config_host'
+        db_config[:port].should == '6022'
+        db_config[:database].should == 'config_database'
+      end
+    end
+
+    it 'fails if the database name is missing' do
+      config_hash['environments']['development'].delete('database')
+      config = Duple::Configuration.new(config_hash, {})
+
+      expect {
+        config.db_config('development')
+      }.to raise_error(
+        ArgumentError,
+        'Invalid config: "database" is required for a local environment.'
+      )
+    end
+  end
+
   describe '#excluded_tables' do
     let(:config_hash) { YAML.load(File.read('spec/config/groups.yml'))}
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: duple
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-19 00:00:00.000000000 Z
+date: 2012-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -119,6 +119,7 @@ files:
 - .gitignore
 - .rspec
 - .simplecov
+- CHANGES.md
 - Gemfile
 - LICENSE.txt
 - README.md