wyrm 0.4.1 → 0.4.2

data/lib/wyrm/pump_maker.rb

@@ -1,32 +1,33 @@
 require 'wyrm/pump'
 require 'wyrm/module'
 
-module Wyrm::PumpMaker
-  def call_or_self( maybe_callable )
-    if maybe_callable.respond_to? :call
-      maybe_callable.call( self )
-    else
-      maybe_callable
+module Wyrm
+  module PumpMaker
+    def call_or_self( maybe_callable )
+      if maybe_callable.respond_to? :call
+        maybe_callable.call( self )
+      else
+        maybe_callable
+      end
     end
-  end
 
-  def make_pump( db, pump_thing )
-    call_or_self(pump_thing) || Pump.new( db: db )
-  end
+    def make_pump( db, pump_thing )
+      call_or_self(pump_thing) || Wyrm::Pump.new( db: db )
+    end
 
-  def maybe_deebe( db_or_string )
-    case db_or_string
-    when String
-      begin
-        Sequel.connect db_or_string
-      rescue Sequel::AdapterNotFound
-        puts "\nCan't find db driver for #{db_or_string}. It might work to do\n\n  gem install #{db_or_string.split(?:).first}\n\n"
-        exit(1)
+    def maybe_deebe( db_or_string )
+      case db_or_string
+      when String
+        begin
+          Sequel.connect db_or_string
+        rescue Sequel::AdapterNotFound
+          raise "\nCan't find db driver for #{db_or_string}. It might work to do\n\n  gem install #{db_or_string.split(?:).first}\n\n"
+        end
+      when Sequel::Database
+        db_or_string
+      else
+        raise "Don't know how to db-ify #{db_or_string.inspect}"
       end
-    when Sequel::Database
-      db_or_string
-    else
-      raise "Don't know how to db-ify #{db_or_string.inspect}"
     end
   end
 end

data/lib/wyrm/restore.rb

@@ -8,105 +8,119 @@ require 'wyrm/schema_tools'
 
 # Load a schema from a set of dump files (from DumpSchema)
 # and restore the table data.
-#  dst_db = Sequel.connect "postgres://localhost:5454/lots"
-#  rs = RestoreSchema.new dst_db, '/var/data/lots'
-#  rs.call
+#
+#  Restore["postgres://localhost:5454/lots", '/var/data/lots']
+#
 # TODO the problem with lazy loading the schema files is that
 # errors in indexes and foreign keys will only be picked up at the
 # end of they probably lengthy table restore process.
 # TODO check if table has been restored already, and has the correct rows,
-class Wyrm::Restore
-  include Wyrm::PumpMaker
-  include Wyrm::SchemaTools
-  include Wyrm::Logger
+module Wyrm
+  class Restore
+    include PumpMaker
+    include SchemaTools
+    include Logger
+
+    def self.[]( *args )
+      new(*args).call
+    end
 
-  def initialize( container, dst_db, pump: nil, drop_tables: false )
-    @container = Pathname.new container
-    fail "#{@container} does not exist" unless @container.exist?
+    def call
+      drop_tables(table_names) if options.drop_tables
+      create_tables
+      restore_tables
+      create_indexes
+    end
 
-    @dst_db = maybe_deebe dst_db
-    @pump = make_pump( @dst_db, pump )
+    def initialize( container, dst_db, pump: nil, drop_tables: false )
+      @container = Pathname.new container
+      fail "#{@container} does not exist" unless @container.exist?
 
-    options.drop_tables = drop_tables
-  end
+      @dst_db = maybe_deebe dst_db
+      @pump = make_pump( @dst_db, pump )
 
-  attr_reader :pump
-  attr_reader :dst_db
-  attr_reader :container
+      options.drop_tables = drop_tables
+    end
 
-  def options
-    @options ||= OpenStruct.new
-  end
+    attr_reader :pump
+    attr_reader :dst_db
+    attr_reader :container
 
-  # sequel wants migrations numbered, but it's a bit of an annoyance for this.
-  def find_single( glob )
-    candidates = Pathname.glob container + glob
-    raise "no candidates for #{glob}. Probably #{container} does not have wyrm files." unless candidates.size == 1
-    raise "too many #{candidates.inspect} for #{glob}" unless candidates.size == 1
-    candidates.first
-  end
+    def options
+      @options ||= OpenStruct.new
+    end
 
-  def schema_migration
-    @schema_migration ||= find_single( '*schema.rb' ).read
-  end
+    class None < RuntimeError; end
 
-  def index_migration
-    @index_migration ||= find_single( '*indexes.rb' ).read
-  end
+    # sequel wants migrations numbered, but it's a bit of an annoyance for this.
+    def find_single( glob )
+      candidates = Pathname.glob container + glob
+      raise None, "No restore files found for #{glob}" if candidates.size == 0
+      raise "too many #{candidates.inspect} for #{glob}" if candidates.size > 1
+      candidates.first
+    end
 
-  def fk_migration
-    @fk_migration ||= find_single( '*foreign_keys.rb' ).read
-  end
+    def schema_migration
+      @schema_migration ||= find_single( '*schema.rb' ).read
+    rescue None
+      ''
+    end
 
-  def reload_migrations
-    @fk_migration = nil
-    @index_migration = nil
-    @schema_migration = nil
-  end
+    def index_migration
+      @index_migration ||= find_single( '*indexes.rb' ).read
+    rescue None
+      ''
+    end
 
-  # assume the table name is the base name of table_file pathname
-  def restore_table( table_file )
-    logger.info "restoring from #{table_file}"
-    pump.table_name = table_file.basename.sub_ext('').sub_ext('').to_s.to_sym
-    open_bz2 table_file do |io|
-      pump.io = io
-      pump.restore filename: table_file
+    def fk_migration
+      @fk_migration ||= find_single( '*foreign_keys.rb' ).read
+    rescue None
+      ''
     end
-  end
 
-  # open a dbp.bz2 file and either yield or return an io of the uncompressed contents
-  def open_bz2( table_name, &block )
-    table_file =
-    case table_name
-    when Symbol
-      container + "#{table_name}.dbp.bz2"
-    when Pathname
-      table_name
-    else
-      raise "Don't know what to do with #{table_name.inspect}"
+    def reload_migrations
+      @fk_migration = nil
+      @index_migration = nil
+      @schema_migration = nil
     end
 
-    IO.popen "#{STREAM_DCMP} #{table_file}", &block
-  end
+    # assume the table name is the base name of table_file pathname
+    def restore_table( table_file )
+      logger.info "restoring from #{table_file}"
+      pump.table_name = table_file.basename.sub_ext('').sub_ext('').to_s.to_sym
+      open_bz2 table_file do |io|
+        pump.io = io
+        pump.restore filename: table_file
+      end
+    end
 
-  def table_files
-    Pathname.glob container + '*.dbp.bz2'
-  end
+    # open a dbp.bz2 file and either yield or return an io of the uncompressed contents
+    def open_bz2( table_name, &block )
+      table_file =
+      case table_name
+      when Symbol
+        container + "#{table_name}.dbp.bz2"
+      when Pathname
+        table_name
+      else
+        raise "Don't know what to do with #{table_name.inspect}"
+      end
+
+      IO.popen "#{STREAM_DCMP} #{table_file}", &block
+    end
 
-  def restore_tables
-    table_files.sort_by{|tf| tf.stat.size}.each{|table_file| restore_table table_file}
-  end
+    def table_files
+      Pathname.glob container + '*.dbp.bz2'
+    end
 
-  def table_names
-    table_files.map do |path|
-      path.basename.to_s.split(?.)[0...-2].last.to_sym
+    def restore_tables
+      table_files.sort_by{|tf| tf.stat.size}.each{|table_file| restore_table table_file}
     end
-  end
 
-  def call
-    drop_tables(table_names) if options.drop_tables
-    create_tables
-    restore_tables
-    create_indexes
+    def table_names
+      table_files.map do |path|
+        path.basename.to_s.split(?.)[0...-2].last.to_sym
+      end
+    end
   end
 end

data/lib/wyrm/schema_tools.rb

@@ -4,86 +4,93 @@ require 'wyrm/module'
 # needs dst_db for mutate operations
 # and src_db for fetch operations
 # src_db must have extension(:schema_dumper)
-module Wyrm::SchemaTools
-  # some includers will need to provide a different implementation for this.
-  def same_db
-    respond_to?( :dst_db ) && respond_to?( :src_db ) && dst_db&.database_type == src_db&.database_type
-  end
+module Wyrm
+  module SchemaTools
+    # some includers will need to provide a different implementation for this.
+    def same_db
+      respond_to?( :dst_db ) && respond_to?( :src_db ) && dst_db&.database_type == src_db&.database_type
+    end
 
-  def schema_migration
-    @schema_migration ||= src_db.dump_schema_migration(:indexes=>false, :same_db => same_db)
-  end
+    def schema_migration
+      @schema_migration ||= src_db.dump_schema_migration indexes: false, :same_db => same_db
+    end
 
-  def index_migration
-    @index_migration ||= src_db.dump_indexes_migration(:same_db => same_db)
-  end
+    # dump single table including indexes, but ignore foreign keys
+    def table_migration( table )
+      src_db.dump_table_schema table, indexes: true, :same_db => same_db
+    end
 
-  def fk_migration
-    @fk_migration ||= src_db.dump_foreign_key_migration(:same_db => same_db)
-  end
+    def index_migration
+      @index_migration ||= src_db.dump_indexes_migration :same_db => same_db
+    end
 
-  def drop_table_options
-    @drop_table_options ||=
-    begin
-      if dst_db.database_type == :postgres
-        {cascade: true}
-      else
-        {}
-      end
+    def fk_migration
+      @fk_migration ||= src_db.dump_foreign_key_migration :same_db => same_db
     end
-  end
 
-  # Delete given tables.
-  # Recurse if there are foreign keys preventing table deletion.
-  # This implementation will fail for tables with mutual foreign keys.
-  # TODO maybe this should use the schema down migration?
-  def drop_tables( tables )
-    foreign_keyed_tables = []
-    tables.each do |table_name|
+    def drop_table_options
+      @drop_table_options ||=
       begin
-        logger.debug "dropping #{table_name}"
-        dst_db.drop_table? table_name, drop_table_options
+        if dst_db.database_type == :postgres
+          {cascade: true}
+        else
+          {}
+        end
+      end
+    end
 
-      rescue Sequel::ForeignKeyConstraintViolation => ex
-        foreign_keyed_tables << table_name
+    # Delete given tables.
+    # Recurse if there are foreign keys preventing table deletion.
+    # This implementation will fail for tables with mutual foreign keys.
+    # TODO maybe this should use the schema down migration?
+    def drop_tables( tables )
+      foreign_keyed_tables = []
+      tables.each do |table_name|
+        begin
+          logger.debug "dropping #{table_name}"
+          dst_db.drop_table? table_name, drop_table_options
 
-      rescue Sequel::DatabaseError => ex
-        # Mysql2::Error: Cannot delete or update a parent row: a foreign key constraint fails
-        # SQLite3::ConstraintException: FOREIGN KEY constraint failed==
-        if ex.message =~ /foreign key constraint fail/i
+        rescue Sequel::ForeignKeyConstraintViolation => ex
           foreign_keyed_tables << table_name
-        else
-          raise
+
+        rescue Sequel::DatabaseError => ex
+          # Mysql2::Error: Cannot delete or update a parent row: a foreign key constraint fails
+          # SQLite3::ConstraintException: FOREIGN KEY constraint failed==
+          if ex.message =~ /foreign key constraint fail/i
+            foreign_keyed_tables << table_name
+          else
+            raise
+          end
         end
       end
-    end
 
-    # this should be temporary
-    if tables.any? && tables.sort == foreign_keyed_tables.sort
-      raise "can't remove #{tables.inspect} because they have mutual foreign keys"
-    end
+      # this should be temporary
+      if tables.any? && tables.sort == foreign_keyed_tables.sort
+        raise "can't remove #{tables.inspect} because they have mutual foreign keys"
+      end
 
-    # recursively delete tables. Shuffle as kak workaround for dependency loops.
-    drop_tables foreign_keyed_tables.shuffle unless foreign_keyed_tables.empty?
-  end
+      # recursively delete tables. Shuffle as kak workaround for dependency loops.
+      drop_tables foreign_keyed_tables.shuffle unless foreign_keyed_tables.empty?
+    end
 
-  def create_tables
-    logger.info "creating tables"
-    eval( schema_migration ).apply dst_db, :up
-  end
+    def create_tables
+      logger.info "creating tables"
+      eval( schema_migration ).apply dst_db, :up
+    end
 
-  def create_indexes
-    # create indexes and foreign keys, and reset sequences
-    logger.info "creating indexes"
-    eval( index_migration ).apply dst_db, :up
+    def create_indexes
+      # create indexes and foreign keys, and reset sequences
+      logger.info "creating indexes"
+      eval( index_migration ).apply dst_db, :up
 
-    logger.info "creating foreign keys"
-    eval( fk_migration ).apply dst_db, :up
+      logger.info "creating foreign keys"
+      eval( fk_migration ).apply dst_db, :up
 
-    if dst_db.database_type == :postgres
-      logger.info "reset primary key sequences"
-      dst_db.tables.each{|t| dst_db.reset_primary_key_sequence(t)}
-      logger.info "Primary key sequences reset successfully"
+      if dst_db.database_type == :postgres
+        logger.info "reset primary key sequences"
+        dst_db.tables.each{|t| dst_db.reset_primary_key_sequence(t)}
+        logger.info "Primary key sequences reset successfully"
+      end
     end
   end
 end

data/lib/wyrm/version.rb

@@ -1,3 +1,3 @@
 module Wyrm
-  VERSION = '0.4.1'
+  VERSION = '0.4.2'
 end

data/spec/pump_spec.rb

@@ -5,6 +5,8 @@ require Pathname(__dir__) + '../lib/wyrm/pump.rb'
 include Wyrm
 
 describe Pump do
+  include DbConnections
+
   describe '.quacks_like' do
     it 'recognises method' do
       threequal = Pump.quacks_like( :tap )
@@ -27,7 +29,7 @@ describe Pump do
   describe '#db=' do
     it 'invalidates caches' do
       subject.should_receive(:invalidate_cached_members)
-      subject.db = Sequel.sqlite
+      subject.db = sequel_sqlite_db
     end
 
     it 'handles nil db' do
@@ -35,20 +37,21 @@ describe Pump do
     end
 
     it 'adds pagination extension' do
-      db = Sequel.sqlite
+      db = sequel_sqlite_db
       db.should_receive(:extension).with(:pagination)
       subject.db = db
     end
 
     it 'turns on streaming for postgres' do
-      db = Sequel.postgres
+      db = sequel_postgres_db
+      pending "Sequel::Postgres::Database not defined" unless defined?(Sequel::Postgres::Database)
       db.should_receive(:extension).with(:pagination)
       db.should_receive(:extension).with(:pg_streaming)
       subject.db = db
     end
 
     it 'no streaming for non-postgres' do
-      db = Sequel.sqlite
+      db = sequel_sqlite_db
       db.should_receive(:extension).with(:pagination)
       db.should_not_receive(:extension).with(:pg_streaming)
       subject.db = db