postmodern 0.0.11 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 15bd95a1daf5a24f06fcfa1645094b3bd1a76c0c
-  data.tar.gz: 60aeb0096180e784f4e13e812075319523609823
+  metadata.gz: 1bc358882bdb3ac6f246d3967ac261076b4c334d
+  data.tar.gz: 9a3cf7820f70f5271f9ee570be8444bd8305d7e4
 SHA512:
-  metadata.gz: fac44addd806dc9688c1cf5a076c2bed5b6ebf6aa44c58d1c78357a9c4046b3735aa13317b0fa890546f6202d054c3a2971bfb7806c09b4cfa5f13a78a16b0f0
-  data.tar.gz: bc2afb31d22804a418ed917b5bae2d1422cf4740b41ab3cdab0508a4edbaa2a12566afde2c6c445e16fc6f3e5c51504e4d211230baa59e0281c0a6be8adcb836
+  metadata.gz: 619b48a8a1b7b6c250455c143dbe2ac9465066269aea935760e51f7ac6ca9393aacb92a4234a39000fa230de7edb6a5261916e4ccb20c50af8b75ae329ba4e6b
+  data.tar.gz: 3e98b9eeaaa9e57886b00c653e871d2b9816024a17c4c96089abe22cdc6b582a4c8762b7490a5acff54483674296a0170e17dd3f092dfa4cd5429b2e3ef3924e

data/ATTRIBUTION.md

@@ -0,0 +1,5 @@
+Attribution
+===========
+
+This gem would not have been possible without the contributions,
+code samples and consultation of PostgreSQL Experts Inc.

data/Gemfile

@@ -13,5 +13,6 @@ group :test do
   gem 'aruba-rspec'
   gem 'guard-bundler'
   gem 'guard-rspec'
+  gem 'timecop'
   gem 'terminal-notifier-guard', require: RUBY_PLATFORM.include?('darwin')
 end

data/README.md

@@ -7,6 +7,11 @@ Tools for managing PostgreSQL databases.
 
 * WAL archiving and restoration
 
+## Dependencies
+
+* libpq
+* [pg gem](http://rubygems.org/gems/pg)
+
 ## Installation
 
 ```bash
@@ -18,10 +23,62 @@ the system's ruby, however that is installed.
 
 ## Usage
 
+### Vacuuming and Vacuum Freezing
+
+Postmodern's vacuum scripts run table by table, with various constraints
+to limit the overhead of the process.
+
+```
+Usage: postmodern (vacuum|freeze) <options>
+    -U, --user USER                  Defaults to postgres
+    -p, --port PORT                  Defaults to 5432
+    -H, --host HOST                  Defaults to 127.0.0.1
+    -W, --password PASS
+
+    -t, --timeout TIMEOUT            Halt after timeout minutes -- default 120
+    -d, --database DB                Database to vacuum. Required.
+
+    -B, --tablesize BYTES            minimum table size to vacuum -- default 1000000
+    -F, --freezeage AGE              minimum freeze age -- default 10000000
+    -D, --costdelay DELAY            vacuum_cost_delay setting in ms -- default 20
+    -L, --costlimit LIMIT            vacuum_cost_limit setting -- default 2000
+
+    -h, --help                       Show this message
+        --version                    Show version
+```
+
+To run a vacuum:
+
+```
+postmodern vacuum -U postgres -p 5432 -d my_database
+```
+
+In order to run vacuum freeze:
+
+```
+postmodern freeze -U postgres -p 5432 -d my_database
+```
+
+These tasks are designed to be run regularly during a window of lower
+database activity. They vacuum or vacuum freeze each table that requires
+it (based on command line options). Before each operation, the scripts check
+to make sure they have not gone longer than `--timeout` seconds.
+
 ### WAL archives
 
 The wal archiving scripts packaged in this gem are intended to serve as
-wrappers for YOUR archiving mechanism.
+wrappers for YOUR archiving mechanism. Changing the settings for WAL
+archiving in `postgresql.conf` or in `recovery.conf` require full restarts
+of PostgreSQL—using Postmodern, you can configure PostgreSQL once and swap
+in local scripts to do the actual work.
+
+```
+Usage: postmodern (archive|restore) <options>
+    -f, --filename FILE              File name of xlog
+    -p, --path PATH                  Path of xlog file
+    -h, --help                       Show this message
+        --version                    Show version
+```
 
 In postgresql.conf
 
@@ -51,6 +108,13 @@ the relevant arguments either as $1, $2 or using the variables listed above.
 `archive` will attempt to call a `postmodern_archive.local` script.
 `restore` will attempt to call a `postmodern_restore.local` script.
 
+see the [examples](https://github.com/wanelo/postmodern/tree/master/examples)
+directory for example local scripts.
+
+## Attribution & Thanks
+
+Please see the [attribution](https://github.com/wanelo/postmodern/blob/master/ATTRIBUTION.md)
+file for proper attribution and thanks.
 
 ## Contributing
 
@@ -59,3 +123,13 @@ the relevant arguments either as $1, $2 or using the variables listed above.
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+Contributions will not be accepted without tests. What should be a
+feature and what a unit test is highly open to interpretation, however.
+In some cases, a unit test may be easier and acceptable. In general,
+at least one feature should be written for each new subcommand, even
+if it just runs `--help`.
+
+If in doubt, open an issue. If you don't receive a response to an issue
+or a pull request, please mention one of the core committers of this
+gem in a comment to make sure it doesn't get swallowed in an email abyss.

data/examples/postmodern_archive.local

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+# Local file for running postgres wal log archiving.
+# Variables are set by postmodern and map to
+# the following wal archiving conventions:
+#
+#   WAL_ARCHIVE_PATH = %p
+#   WAL_ARCHIVE_FILE = %f
+#
+
+WAL_ARCHIVE_PATH=$1
+WAL_ARCHIVE_FILE=$2
+
+mkdir -p /var/pgsql/wal_archive && find /var/pgsql/wal_archive/ -mtime +1 \
+  | xargs rm -f \
+  && test ! -f /var/pgsql/wal_archive/$WAL_ARCHIVE_FILE \
+  && cp $WAL_ARCHIVE_PATH /var/pgsql/wal_archive/$WAL_ARCHIVE_FILE

data/examples/postmodern_restore.local

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+# Local file for running postgres wal log archiving.
+# Variables are set by postmodern and map to
+# the following wal archiving conventions:
+#
+#   WAL_ARCHIVE_PATH = %p
+#   WAL_ARCHIVE_FILE = %f
+#
+
+WAL_ARCHIVE_PATH=$1
+WAL_ARCHIVE_FILE=$2
+
+cp /var/pgsql/wal_archive/$WAL_ARCHIVE_FILE $WAL_ARCHIVE_PATH

data/lib/postmodern.rb

@@ -1,4 +1,8 @@
 require "postmodern/version"
+require 'logger'
 
 module Postmodern
+  def self.logger
+    @logger ||= ::Logger.new(STDOUT)
+  end
 end

data/lib/postmodern/command.rb

@@ -2,18 +2,38 @@ require 'optparse'
 
 module Postmodern
   class Command
-    def self.required_options
-      @required_options ||= []
+    class << self
+      def inherited(subclass)
+        subclass.instance_variable_set(:@required_options, @required_options)
+        subclass.instance_variable_set(:@default_options, @default_options)
+      end
+
+      def required_options
+        @required_options ||= []
+      end
+
+      def required_option(*options)
+        required_options.concat(options)
+        required_options.uniq!
+      end
+
+      def default_options
+        @default_options ||= {}
+      end
+
+      def default_option(key, value)
+        default_options[key] = value
+      end
     end
 
     def parser
-      OptionParser.new
+      raise "Command needs to define an OptionParser"
     end
 
     attr_reader :options
 
     def initialize(args)
-      @options = {}
+      @options = self.class.default_options.dup
 
       parse_args(args)
       validate!
@@ -23,15 +43,23 @@ module Postmodern
     end
 
     def validate!
-      if (self.class.required_options - self.options.keys).any?
-        puts parser
-        exit 1
+      if missing_params.any?
+        puts "Missing #{missing_params.join(', ')}"
+        usage!
       end
     end
 
+    def missing_params
+      self.class.required_options - self.options.keys
+    end
+
     def parse_args(args)
       parser.parse!(args)
-      self.options
+    end
+
+    def usage!
+      puts parser.to_s
+      exit 1
     end
   end
 end

data/lib/postmodern/db/adapter.rb

@@ -0,0 +1,30 @@
+require 'pg'
+
+module Postmodern
+  module DB
+    class Adapter
+
+      attr_reader :config
+
+      def initialize(config)
+        @config = config
+      end
+
+      def pg_adapter
+        @pg_adapter ||= PG.connect(db_configuration)
+      end
+
+      def execute(sql)
+        pg_adapter.exec(sql)
+      end
+
+      private
+
+      def db_configuration
+        db_configuration = {}.merge(config)
+        db_configuration.delete(:password) unless config[:password]
+        db_configuration
+      end
+    end
+  end
+end

data/lib/postmodern/dummy.rb

@@ -2,6 +2,11 @@ require 'postmodern/command'
 
 module Postmodern
   class Dummy < Command
+    def run
+      puts parser
+      exit 1
+    end
+
     def parser
       @parser ||= OptionParser.new do |opts|
         opts.banner = "Usage: postmodern <command> <options>"
@@ -10,6 +15,7 @@ module Postmodern
         opts.separator "Available commands:"
         opts.separator "    archive"
         opts.separator "    restore"
+        opts.separator "    vacuum"
         opts.separator ""
         opts.separator "Options:"
 

data/lib/postmodern/runner.rb

@@ -1,4 +1,8 @@
-require 'postmodern/wal'
+require 'postmodern'
+require 'postmodern/wal/archive'
+require 'postmodern/wal/restore'
+require 'postmodern/vacuum/vacuum'
+require 'postmodern/vacuum/freeze'
 require 'postmodern/dummy'
 
 module Postmodern
@@ -8,7 +12,9 @@ module Postmodern
     DEFAULT_COMMAND = Dummy
     COMMAND_MAP = {
       'archive' => WAL::Archive,
-      'restore' => WAL::Restore
+      'restore' => WAL::Restore,
+      'vacuum' => Vacuum::Vacuum,
+      'freeze' => Vacuum::Freeze
     }.freeze
 
     def self.run(args)

data/lib/postmodern/vacuum/freeze.rb

@@ -0,0 +1,33 @@
+require 'postmodern/vacuum/vacuum'
+
+module Postmodern
+  module Vacuum
+    class Freeze < Postmodern::Vacuum::Vacuum
+
+      def vacuum_statement table_name
+        "VACUUM FREEZE ANALYZE %s" % table_name
+      end
+
+      protected
+
+      def table_sql
+        <<-SQL.gsub(/^\s{8}/, '')
+        WITH tabfreeze AS (
+            SELECT pg_class.oid::regclass AS full_table_name,
+            age(relfrozenxid)as freeze_age,
+            pg_relation_size(pg_class.oid)
+        FROM pg_class JOIN pg_namespace ON relnamespace = pg_namespace.oid
+        WHERE nspname not in ('pg_catalog', 'information_schema')
+            AND nspname NOT LIKE 'pg_temp%'
+            AND relkind = 'r'
+        )
+        SELECT full_table_name
+        FROM tabfreeze
+        WHERE freeze_age > #{options[:freezeage]}
+        ORDER BY freeze_age DESC
+        LIMIT 1000;
+        SQL
+      end
+    end
+  end
+end

data/lib/postmodern/vacuum/vacuum.rb

@@ -0,0 +1,155 @@
+require 'postmodern/command'
+require 'postmodern/db/adapter'
+
+module Postmodern
+  module Vacuum
+    class Vacuum < Postmodern::Command
+      default_option :timeout, 120
+      default_option :pause, 10
+      default_option :tablesize, 1000000
+      default_option :freezeage, 10000000
+      default_option :costdelay, 20
+      default_option :costlimit, 2000
+      default_option :user, 'postgres'
+      default_option :port, 5432
+      default_option :host, '127.0.0.1'
+
+      required_option :database
+
+      def parser
+        @parser ||= OptionParser.new do |opts|
+          opts.banner = "Usage: postmodern (vacuum|freeze) <options>"
+
+          opts.on('-U', '--user USER', 'Defaults to postgres') do |opt|
+            self.options[:user] = opt
+          end
+
+          opts.on('-p', '--port PORT', 'Defaults to 5432') do |opt|
+            self.options[:port] = opt
+          end
+
+          opts.on('-H', '--host HOST', 'Defaults to 127.0.0.1') do |opt|
+            self.options[:host] = opt
+          end
+
+          opts.on('-W', '--password PASS') do |opt|
+            self.options[:password] = opt
+          end
+
+          opts.separator ''
+
+          opts.on('-t', '--timeout TIMEOUT', 'Halt after timeout minutes -- default 120') do |opt|
+            self.options[:timeout] = opt
+          end
+
+          opts.on('-d', '--database DB', 'Database to vacuum. Required.') do |opt|
+            self.options[:database] = opt
+          end
+
+          opts.separator ''
+
+          opts.on('-B', '--tablesize BYTES', 'minimum table size to vacuum -- default 1000000') do |opt|
+            self.options[:tablesize] = opt
+          end
+
+          opts.on('-F', '--freezeage AGE', 'minimum freeze age -- default 10000000') do |opt|
+            self.options[:freezeage] = opt
+          end
+
+          opts.on('-D', '--costdelay DELAY', 'vacuum_cost_delay setting in ms -- default 20') do |opt|
+            self.options[:costdelay] = opt
+          end
+
+          opts.on('-L', '--costlimit LIMIT', 'vacuum_cost_limit setting -- default 2000') do |opt|
+            self.options[:costlimit] = opt
+          end
+
+          opts.separator ''
+
+          opts.on_tail("-h", "--help", "Show this message") do
+            puts opts
+            exit
+          end
+
+          opts.on_tail("--version", "Show version") do
+            require 'postmodern/version'
+            puts Postmodern::VERSION
+            exit
+          end
+        end
+      end
+
+      attr_reader :adapter, :start_time
+
+      def initialize(args)
+        @start_time = Time.now
+        super(args)
+      end
+
+      def run
+        configure_vacuum_cost
+        vacuum
+      end
+
+      def configure_vacuum_cost
+        adapter.execute("SET vacuum_cost_delay = '%d ms'" % options[:costdelay])
+        adapter.execute("SET vacuum_cost_limit = '%d'" % options[:costlimit])
+      end
+
+      def vacuum
+        tables_to_vacuum.each do |table|
+          Postmodern.logger.info "Vacuuming #{table}"
+          adapter.execute(vacuum_statement(table))
+          if timedout?
+            Postmodern.logger.warn "Vacuuming timed out"
+            break
+          end
+        end
+      end
+
+      def vacuum_statement table_name
+        "VACUUM ANALYZE %s" % table_name
+      end
+
+      def timedout?
+        Time.now >= start_time + (options[:timeout].to_i * 60)
+      end
+
+      def tables_to_vacuum
+        table_res = adapter.execute(table_sql)
+        table_res.map{|f| f['full_table_name']}
+      end
+
+      def adapter
+        @adapter ||= Postmodern::DB::Adapter.new({
+          dbname: options[:database],
+          port: options[:port],
+          host: options[:host],
+          user: options[:user],
+          password: options[:password]
+        })
+      end
+
+      protected
+
+      def table_sql
+        <<-SQL.gsub(/^\s{8}/, '')
+        WITH deadrow_tables AS (
+            SELECT relid::regclass as full_table_name,
+                ((n_dead_tup::numeric) / ( n_live_tup + 1 )) as dead_pct,
+                pg_relation_size(relid) as table_bytes
+            FROM pg_stat_user_tables
+            WHERE n_dead_tup > 100
+            AND ( (now() - last_autovacuum) > INTERVAL '1 hour'
+                OR last_autovacuum IS NULL )
+        )
+        SELECT full_table_name
+        FROM deadrow_tables
+        WHERE dead_pct > 0.05
+        AND table_bytes > #{options[:tablesize]}
+        ORDER BY dead_pct DESC, table_bytes DESC;
+        SQL
+      end
+    end
+  end
+end

data/lib/postmodern/version.rb

@@ -1,3 +1,3 @@
 module Postmodern
-  VERSION = "0.0.11"
+  VERSION = "0.1.0"
 end

data/lib/postmodern/wal/archive.rb

@@ -3,15 +3,14 @@ require 'postmodern/command'
 module Postmodern
   module WAL
     class Archive < Postmodern::Command
-      required_options << :file
-      required_options << :path
+      required_option :filename, :path
 
       def parser
         @parser ||= OptionParser.new do |opts|
           opts.banner = "Usage: postmodern (archive|restore) <options>"
 
           opts.on('-f', '--filename FILE', 'File name of xlog') do |o|
-            self.options[:file] = o
+            self.options[:filename] = o
           end
 
           opts.on('-p', '--path PATH', 'Path of xlog file') do |o|
@@ -49,7 +48,7 @@ module Postmodern
       end
 
       def filename
-        @options[:file]
+        @options[:filename]
       end
 
       def local_script_exists?

data/postmodern.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^spec/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "pg"
+
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
 end

data/spec/features/archive_spec.rb

@@ -37,7 +37,11 @@ Usage: postmodern (archive|restore) <options>
       end
 
       it 'prints usage' do
-        expect(command).to eq(usage)
+        expect(command).to match(Regexp.escape(usage))
+      end
+
+      it 'includes missing params' do
+        expect(command).to match('Missing path')
       end
     end
 
@@ -49,7 +53,11 @@ Usage: postmodern (archive|restore) <options>
       end
 
       it 'prints usage' do
-        expect(command).to eq(usage)
+        expect(command).to match(Regexp.escape(usage))
+      end
+
+      it 'includes missing params' do
+        expect(command).to match('Missing filename')
       end
     end
   end

data/spec/features/dummy_spec.rb

@@ -1,24 +1,43 @@
 require 'spec_helper'
 require 'postmodern/version'
 
-describe 'dummy help' do
-  it 'responds with usage info' do
-    expect(`bin/postmodern --help`).to eq <<-END
+describe 'dummy' do
+  let(:usage) {
+    <<-END
 Usage: postmodern <command> <options>
 
 Available commands:
     archive
     restore
+    vacuum
 
 Options:
     -h, --help                       Show this message
         --version                    Show version
     END
+  }
+
+  describe 'help' do
+    it 'responds with usage info' do
+      expect(`bin/postmodern --help`).to eq(usage)
+    end
   end
-end
 
-describe 'dummy version' do
-  it 'responds with the Postmodern version' do
-    expect(`bin/postmodern --version`).to match(Postmodern::VERSION)
+  describe 'version' do
+    it 'responds with the Postmodern version' do
+      expect(`bin/postmodern --version`).to match(Postmodern::VERSION)
+    end
+  end
+
+  describe 'argument catchall' do
+    let(:command) { `bin/postmodern dlaskfjdflf` }
+
+    it 'exits 1' do
+      expect { command }.to have_exit_status(1)
+    end
+
+    it 'prints usage' do
+      expect(command).to eq(usage)
+    end
   end
 end

data/spec/features/freeze_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe 'freeze help' do
+  it 'responds' do
+    expect(`bin/postmodern freeze --help`).to eq <<-END
+Usage: postmodern (vacuum|freeze) <options>
+    -U, --user USER                  Defaults to postgres
+    -p, --port PORT                  Defaults to 5432
+    -H, --host HOST                  Defaults to 127.0.0.1
+    -W, --password PASS
+
+    -t, --timeout TIMEOUT            Halt after timeout minutes -- default 120
+    -d, --database DB                Database to vacuum. Required.
+
+    -B, --tablesize BYTES            minimum table size to vacuum -- default 1000000
+    -F, --freezeage AGE              minimum freeze age -- default 10000000
+    -D, --costdelay DELAY            vacuum_cost_delay setting in ms -- default 20
+    -L, --costlimit LIMIT            vacuum_cost_limit setting -- default 2000
+
+    -h, --help                       Show this message
+        --version                    Show version
+    END
+  end
+end

data/spec/features/restore_spec.rb

@@ -15,10 +15,54 @@ end
 describe 'restore' do
   let(:command) { `bin/postmodern restore --path filepath --filename filename` }
 
+  let(:usage) { <<-END
+Usage: postmodern (archive|restore) <options>
+    -f, --filename FILE              File name of xlog
+    -p, --path PATH                  Path of xlog file
+    -h, --help                       Show this message
+        --version                    Show version
+                END
+  }
+
+
   before do
     double_cmd('postmodern_restore.local')
   end
 
+  describe 'validations' do
+    context 'with no --path' do
+      let(:command) { `bin/postmodern restore --filename filename` }
+
+      it 'fails' do
+        expect { command }.to have_exit_status(1)
+      end
+
+      it 'prints usage' do
+        expect(command).to match(Regexp.escape(usage))
+      end
+
+      it 'includes missing params' do
+        expect(command).to match('Missing path')
+      end
+    end
+
+    context 'with no --filename' do
+      let(:command) { `bin/postmodern restore --path path` }
+
+      it 'fails' do
+        expect { command }.to have_exit_status(1)
+      end
+
+      it 'prints usage' do
+        expect(command).to match(Regexp.escape(usage))
+      end
+
+      it 'includes missing params' do
+        expect(command).to match('Missing filename')
+      end
+    end
+  end
+
   context 'when local script is present' do
     before { double_cmd('which', exit: 0) }
 

data/spec/features/vacuum_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe 'vacuum help' do
+  it 'responds' do
+    expect(`bin/postmodern vacuum --help`).to eq <<-END
+Usage: postmodern (vacuum|freeze) <options>
+    -U, --user USER                  Defaults to postgres
+    -p, --port PORT                  Defaults to 5432
+    -H, --host HOST                  Defaults to 127.0.0.1
+    -W, --password PASS
+
+    -t, --timeout TIMEOUT            Halt after timeout minutes -- default 120
+    -d, --database DB                Database to vacuum. Required.
+
+    -B, --tablesize BYTES            minimum table size to vacuum -- default 1000000
+    -F, --freezeage AGE              minimum freeze age -- default 10000000
+    -D, --costdelay DELAY            vacuum_cost_delay setting in ms -- default 20
+    -L, --costlimit LIMIT            vacuum_cost_limit setting -- default 2000
+
+    -h, --help                       Show this message
+        --version                    Show version
+    END
+  end
+end

data/spec/postmodern/command_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'postmodern/command'
+
+describe Postmodern::Command do
+  let(:option_parser) { double(parse!: true, to_s: nil) }
+  subject(:command_class) { Class.new(Postmodern::Command) }
+
+  before do
+    local_scope_option_parser = option_parser
+    command_class.send(:define_method, :parser) { local_scope_option_parser }
+  end
+
+
+  describe '#usage!' do
+    it 'exits 1' do
+      expect { command_class.new([]).usage! }.to raise_error(SystemExit)
+    end
+
+    it 'prints parser' do
+      expect { command_class.new([]).usage! }.to raise_error(SystemExit)
+      expect(option_parser).to have_received(:to_s)
+    end
+  end
+end

data/spec/postmodern/db/adapter_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'postmodern/db/adapter'
+
+describe Postmodern::DB::Adapter do
+  subject(:adapter) { Postmodern::DB::Adapter.new(configuration) }
+
+  let(:password) { 'secure...' }
+  let(:configuration) do
+    {
+      stuff: 'things'
+    }
+  end
+
+  describe '#adapter' do
+    context 'with password' do
+      let(:configuration) { {stuff: 'things', password: 'password'} }
+
+      it 'initializes a PG adapter' do
+        expect(PG).to receive(:connect).with({stuff: 'things', password: 'password'})
+        adapter.pg_adapter
+      end
+    end
+
+    context 'without password' do
+      let(:configuration) { {stuff: 'things', password: nil} }
+
+      it 'initializes a PG adapter without password params' do
+        expect(PG).to receive(:connect).with({stuff: 'things'})
+        adapter.pg_adapter
+      end
+    end
+  end
+
+  describe '#execute' do
+    let(:pg_adapter) { double }
+
+    before do
+      allow(adapter).to receive(:pg_adapter).and_return(pg_adapter)
+    end
+
+    it 'delegates to PG adapter' do
+      expect(pg_adapter).to receive(:exec).with('blah;')
+      adapter.execute('blah;')
+    end
+  end
+end

data/spec/postmodern/postmodern_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'postmodern'
+
+describe Postmodern do
+  describe '.logger' do
+    it 'is a Logger' do
+      expect(Postmodern.logger).to be_a Logger
+    end
+  end
+end

data/spec/postmodern/runner_spec.rb

@@ -12,6 +12,11 @@ describe Postmodern::Runner do
       expect(Postmodern::Runner.command_for('restore')).to be Postmodern::WAL::Restore
     end
 
+
+    it 'chooses vacuumer' do
+      expect(Postmodern::Runner.command_for('vacuum')).to be Postmodern::Vacuum::Vacuum
+    end
+
     it 'defaults to dummy' do
       expect(Postmodern::Runner.command_for('ljfaldf')).to be Postmodern::Dummy
     end

data/spec/postmodern/vacuum/freeze_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'postmodern/vacuum/freeze'
+
+describe Postmodern::Vacuum::Freeze do
+  let(:adapter) { double }
+  let(:args) { %w(-d db) }
+  subject(:command) { Postmodern::Vacuum::Freeze.new(args) }
+
+  before do
+    allow(Postmodern).to receive(:logger).and_return(FakeLogger.new)
+    allow(adapter).to receive(:execute)
+    allow(command).to receive(:adapter).and_return(adapter)
+  end
+
+  describe '#tables_to_vacuum' do
+    let(:args) { %w(-d mydb -F 12345) }
+
+    it 'finds list of tables to vacuum' do
+      result = [
+        {'full_table_name' => 'table1'},
+        {'full_table_name' => 'table2'},
+      ]
+      allow(command).to receive(:adapter).and_return(adapter)
+      expect(adapter).to receive(:execute).with(%Q{WITH tabfreeze AS (
+    SELECT pg_class.oid::regclass AS full_table_name,
+    age(relfrozenxid)as freeze_age,
+    pg_relation_size(pg_class.oid)
+FROM pg_class JOIN pg_namespace ON relnamespace = pg_namespace.oid
+WHERE nspname not in ('pg_catalog', 'information_schema')
+    AND nspname NOT LIKE 'pg_temp%'
+    AND relkind = 'r'
+)
+SELECT full_table_name
+FROM tabfreeze
+WHERE freeze_age > 12345
+ORDER BY freeze_age DESC
+LIMIT 1000;
+}).and_return(result)
+
+      expect(command.tables_to_vacuum).to eq(%w(table1 table2))
+    end
+  end
+
+  describe '#vacuum' do
+    let(:tables_to_vacuum) { %w(table1 table2 table3) }
+
+    before do
+      allow(Postmodern::DB::Adapter).to receive(:new).and_return(adapter)
+      allow(command).to receive(:tables_to_vacuum).and_return(tables_to_vacuum)
+    end
+
+    it "vacuums each table" do
+      command.vacuum
+      tables_to_vacuum.each do |table|
+        expect(adapter).to have_received(:execute).with("VACUUM FREEZE ANALYZE %s" % table)
+      end
+    end
+  end
+end

data/spec/postmodern/vacuum/vacuum_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+require 'postmodern/vacuum/vacuum'
+require 'timecop'
+
+describe Postmodern::Vacuum::Vacuum do
+  let(:args) { %w(-d mydb) }
+  let(:adapter) { double }
+  subject(:command) { Postmodern::Vacuum::Vacuum.new(args) }
+
+  before do
+    allow(Postmodern).to receive(:logger).and_return(FakeLogger.new)
+    allow(adapter).to receive(:execute)
+  end
+
+  describe "#options" do
+    {
+      user: 'postgres',
+      port: 5432,
+      host: '127.0.0.1',
+      timeout: 120,
+      pause: 10,
+      tablesize: 1000000,
+      freezeage: 10000000,
+      costdelay: 20,
+      costlimit: 2000
+    }.each do |option, default|
+      it "defaults on #{option}" do
+        expect(command.options[option]).to eq(default)
+      end
+    end
+  end
+
+  describe 'validations' do
+    let(:usage) { double(usage!: '') }
+
+    before do
+      allow_any_instance_of(Postmodern::Vacuum::Vacuum).
+        to receive(:usage!) { usage.usage! }
+    end
+
+    describe 'database' do
+      it 'requires database' do
+        Postmodern::Vacuum::Vacuum.new([])
+        expect(usage).to have_received(:usage!)
+      end
+    end
+  end
+
+  describe "#run" do
+    let(:args) { %w(--database mydb) }
+
+    before do
+      allow(command).to receive(:adapter).and_return(adapter)
+    end
+
+    it 'executes vacuum operations in order' do
+      expect(command).to receive(:configure_vacuum_cost).once
+      expect(command).to receive(:vacuum).once
+      command.run
+    end
+  end
+
+  describe '#adapter' do
+    before { allow(adapter).to receive(:execute) }
+
+    it 'instantiates a DB::Adapter' do
+      expect(Postmodern::DB::Adapter).to receive(:new).once.with({
+        dbname: 'mydb',
+        port: 5432,
+        host: '127.0.0.1',
+        user: 'postgres',
+        password: nil
+      }).and_return(adapter)
+      command.adapter
+    end
+
+    context 'when password is present' do
+      let(:args) { %w(--password mypass --database mydb) }
+      it 'passes through to adapter' do
+        expect(Postmodern::DB::Adapter).to receive(:new).once.with({
+          dbname: 'mydb',
+          port: 5432,
+          host: '127.0.0.1',
+          user: 'postgres',
+          password: 'mypass'
+        }).and_return(adapter)
+        command.adapter
+      end
+    end
+  end
+
+  describe '#configure_vacuum_cost' do
+    before do
+      allow(command).to receive(:adapter).and_return(adapter)
+      command.configure_vacuum_cost
+    end
+
+    it 'sets vacuum cost delay' do
+      expect(adapter).to have_received(:execute).with("SET vacuum_cost_delay = '#{command.options[:costdelay]} ms'")
+    end
+
+    it 'sets vacuum cost limit' do
+      expect(adapter).to have_received(:execute).with("SET vacuum_cost_limit = '#{command.options[:costlimit]}'")
+    end
+  end
+
+  describe '#tables_to_vacuum' do
+    let(:args) { %w(-d mydb -B 12345) }
+
+    it 'finds list of tables to vacuum' do
+      result = [
+        { 'full_table_name' => 'table1'},
+        { 'full_table_name' => 'table2'},
+      ]
+      allow(command).to receive(:adapter).and_return(adapter)
+      expect(adapter).to receive(:execute).with(%Q{WITH deadrow_tables AS (
+    SELECT relid::regclass as full_table_name,
+        ((n_dead_tup::numeric) / ( n_live_tup + 1 )) as dead_pct,
+        pg_relation_size(relid) as table_bytes
+    FROM pg_stat_user_tables
+    WHERE n_dead_tup > 100
+    AND ( (now() - last_autovacuum) > INTERVAL '1 hour'
+        OR last_autovacuum IS NULL )
+)
+SELECT full_table_name
+FROM deadrow_tables
+WHERE dead_pct > 0.05
+AND table_bytes > 12345
+ORDER BY dead_pct DESC, table_bytes DESC;
+}).and_return(result)
+
+      expect(command.tables_to_vacuum).to eq(%w(table1 table2))
+    end
+  end
+
+  describe "#vacuum" do
+    before do
+      allow(Postmodern::DB::Adapter).to receive(:new).and_return(adapter)
+      allow(command).to receive(:tables_to_vacuum).and_return(tables_to_vacuum)
+    end
+
+    let(:tables_to_vacuum) { %w(table1 table2 table3) }
+
+    it "vacuums each table" do
+      command.vacuum
+      tables_to_vacuum.each do |table|
+        expect(adapter).to have_received(:execute).with("VACUUM ANALYZE %s" % table)
+      end
+    end
+
+    it "exits prematurely with a timeout and analyzes first table" do
+      allow(command).to receive(:timedout?).and_return(true)
+      command.vacuum
+      expect(adapter).to have_received(:execute).with("VACUUM ANALYZE %s" % tables_to_vacuum[0])
+      expect(adapter).not_to have_received(:execute).with("VACUUM ANALYZE %s" % tables_to_vacuum[1])
+      expect(adapter).not_to have_received(:execute).with("VACUUM ANALYZE %s" % tables_to_vacuum[2])
+    end
+  end
+
+  describe '#timedout?' do
+    let(:time) { Time.now }
+    let(:args) { %w(--d db -t 15) }
+
+    before do
+      Timecop.freeze time do
+        command # ensure command is initialized Now
+      end
+    end
+
+    context 'current time is greater than timeout threshold since initialization' do
+      it 'is true' do
+        Timecop.freeze time + (15 * 60) do
+          expect(command.timedout?).to be true
+        end
+      end
+    end
+
+    context 'current time is less than timeout threshold since initialization' do
+      it 'is false' do
+        Timecop.freeze time + (15 * 60 - 1) do
+          expect(command.timedout?).to be false
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,8 @@
 require 'aruba/rspec'
 require 'pry'
+require 'timecop'
+
+require 'support/logger'
 
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
@@ -16,5 +19,6 @@ RSpec.configure do |config|
 
   config.after :each do
     Aruba::RSpec.teardown
+    Timecop.return
   end
 end

data/spec/support/logger.rb

@@ -0,0 +1,9 @@
+class FakeLogger
+  def info(*args)
+
+  end
+
+  def warn(*args)
+
+  end
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: postmodern
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.1.0
 platform: ruby
 authors:
 - Eric Saxby
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-29 00:00:00.000000000 Z
+date: 2014-05-30 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -49,28 +63,41 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- ATTRIBUTION.md
 - Gemfile
 - Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/postmodern
+- examples/postmodern_archive.local
+- examples/postmodern_restore.local
 - lib/postmodern.rb
 - lib/postmodern/command.rb
+- lib/postmodern/db/adapter.rb
 - lib/postmodern/dummy.rb
 - lib/postmodern/runner.rb
+- lib/postmodern/vacuum/freeze.rb
+- lib/postmodern/vacuum/vacuum.rb
 - lib/postmodern/version.rb
-- lib/postmodern/wal.rb
 - lib/postmodern/wal/archive.rb
 - lib/postmodern/wal/restore.rb
 - postmodern.gemspec
 - spec/features/archive_spec.rb
 - spec/features/dummy_spec.rb
+- spec/features/freeze_spec.rb
 - spec/features/restore_spec.rb
+- spec/features/vacuum_spec.rb
+- spec/postmodern/command_spec.rb
+- spec/postmodern/db/adapter_spec.rb
+- spec/postmodern/postmodern_spec.rb
 - spec/postmodern/runner_spec.rb
+- spec/postmodern/vacuum/freeze_spec.rb
+- spec/postmodern/vacuum/vacuum_spec.rb
 - spec/postmodern/wal/archive_spec.rb
 - spec/postmodern/wal/restore_spec.rb
 - spec/spec_helper.rb
+- spec/support/logger.rb
 homepage: https://github.com/wanelo/postmodern
 licenses:
 - MIT
@@ -98,9 +125,17 @@ summary: Tools for managing PostgreSQL
 test_files:
 - spec/features/archive_spec.rb
 - spec/features/dummy_spec.rb
+- spec/features/freeze_spec.rb
 - spec/features/restore_spec.rb
+- spec/features/vacuum_spec.rb
+- spec/postmodern/command_spec.rb
+- spec/postmodern/db/adapter_spec.rb
+- spec/postmodern/postmodern_spec.rb
 - spec/postmodern/runner_spec.rb
+- spec/postmodern/vacuum/freeze_spec.rb
+- spec/postmodern/vacuum/vacuum_spec.rb
 - spec/postmodern/wal/archive_spec.rb
 - spec/postmodern/wal/restore_spec.rb
 - spec/spec_helper.rb
+- spec/support/logger.rb
 has_rdoc: 

data/lib/postmodern/wal.rb

@@ -1,3 +0,0 @@
-require 'postmodern/wal/archive'
-require 'postmodern/wal/restore'
-