taps 0.3.11 → 0.3.12

data/lib/taps/utils.rb

@@ -5,150 +5,150 @@ require 'tempfile'
 
 module Taps
 module Utils
-	extend self
-
-	def windows?
-		return @windows if defined?(@windows)
-		require 'rbconfig'
-		@windows = !!(::Config::CONFIG['host_os'] =~ /mswin|mingw/)
-	end
-
-	def bin(cmd)
-		cmd = "#{cmd}.cmd" if windows?
-		cmd
-	end
-
-	def checksum(data)
-		Zlib.crc32(data)
-	end
-
-	def valid_data?(data, crc32)
-		Zlib.crc32(data) == crc32.to_i
-	end
-
-	def base64encode(data)
-		[data].pack("m")
-	end
-
-	def base64decode(data)
-		data.unpack("m").first
-	end
-
-	def format_data(data, opts={})
-		return {} if data.size == 0
-		string_columns = opts[:string_columns] || []
-
-		header = data[0].keys
-		only_data = data.collect do |row|
-			row = blobs_to_string(row, string_columns)
-			header.collect { |h| row[h] }
-		end
-		{ :header => header, :data => only_data }
-	end
-
-	# mysql text and blobs fields are handled the same way internally
-	# this is not true for other databases so we must check if the field is
-	# actually text and manually convert it back to a string
-	def incorrect_blobs(db, table)
-		return [] if (db.url =~ /mysql:\/\//).nil?
-
-		columns = []
-		db.schema(table).each do |data|
-			column, cdata = data
-			columns << column if cdata[:db_type] =~ /text/
-		end
-		columns
-	end
-
-	def blobs_to_string(row, columns)
-		return row if columns.size == 0
-		columns.each do |c|
-			row[c] = row[c].to_s if row[c].kind_of?(Sequel::SQL::Blob)
-		end
-		row
-	end
-
-	def calculate_chunksize(old_chunksize)
-		chunksize = old_chunksize
-
-		retries = 0
-		time_in_db = 0
-		begin
-			t1 = Time.now
-			time_in_db = yield chunksize
-			time_in_db = time_in_db.to_f rescue 0
-		rescue Errno::EPIPE, RestClient::RequestFailed, RestClient::RequestTimeout
-			retries += 1
-			raise if retries > 2
-
-			# we got disconnected, the chunksize could be too large
-			# on first retry change to 10, on successive retries go down to 1
-			chunksize = (retries == 1) ? 10 : 1
-
-			retry
-		end
-
-		t2 = Time.now
-
-		diff = t2 - t1 - time_in_db
-
-		new_chunksize = if retries > 0
-			chunksize
-		elsif diff > 3.0
-			(chunksize / 3).ceil
-		elsif diff > 1.1
-			chunksize - 100
-		elsif diff < 0.8
-			chunksize * 2
-		else
-			chunksize + 100
-		end
-		new_chunksize = 1 if new_chunksize < 1
-		new_chunksize
-	end
-
-	def load_schema(database_url, schema_data)
-		Tempfile.open('taps') do |tmp|
-			File.open(tmp.path, 'w') { |f| f.write(schema_data) }
-			schema_bin(:load, database_url, tmp.path)
-		end
-	end
-
-	def load_indexes(database_url, index_data)
-		Tempfile.open('taps') do |tmp|
-			File.open(tmp.path, 'w') { |f| f.write(index_data) }
-			schema_bin(:load_indexes, database_url, tmp.path)
-		end
-	end
-
-	def schema_bin(*args)
-		bin_path = File.expand_path("#{File.dirname(__FILE__)}/../../bin/#{bin('schema')}")
-		`"#{bin_path}" #{args.map { |a| "'#{a}'" }.join(' ')}`
-	end
-
-	def primary_key(db, table)
-		table = table.to_sym.identifier unless table.kind_of?(Sequel::SQL::Identifier)
-		if db.respond_to?(:primary_key)
-			db.primary_key(table)
-		else
-			db.schema(table).select { |c| c[1][:primary_key] }.map { |c| c.first.to_sym }
-		end
-	end
-
-	def single_integer_primary_key(db, table)
-		table = table.to_sym.identifier unless table.kind_of?(Sequel::SQL::Identifier)
-		keys = db.schema(table).select { |c| c[1][:primary_key] and c[1][:type] == :integer }
-		not keys.nil? and keys.size == 1
-	end
-
-	def order_by(db, table)
-		pkey = primary_key(db, table)
-		if pkey
-			pkey.kind_of?(Array) ? pkey : [pkey.to_sym]
-		else
-			table = table.to_sym.identifier unless table.kind_of?(Sequel::SQL::Identifier)
-			db[table].columns
-		end
-	end
+  extend self
+
+  def windows?
+    return @windows if defined?(@windows)
+    require 'rbconfig'
+    @windows = !!(::Config::CONFIG['host_os'] =~ /mswin|mingw/)
+  end
+
+  def bin(cmd)
+    cmd = "#{cmd}.cmd" if windows?
+    cmd
+  end
+
+  def checksum(data)
+    Zlib.crc32(data)
+  end
+
+  def valid_data?(data, crc32)
+    Zlib.crc32(data) == crc32.to_i
+  end
+
+  def base64encode(data)
+    [data].pack("m")
+  end
+
+  def base64decode(data)
+    data.unpack("m").first
+  end
+
+  def format_data(data, opts={})
+    return {} if data.size == 0
+    string_columns = opts[:string_columns] || []
+
+    header = data[0].keys
+    only_data = data.collect do |row|
+      row = blobs_to_string(row, string_columns)
+      header.collect { |h| row[h] }
+    end
+    { :header => header, :data => only_data }
+  end
+
+  # mysql text and blobs fields are handled the same way internally
+  # this is not true for other databases so we must check if the field is
+  # actually text and manually convert it back to a string
+  def incorrect_blobs(db, table)
+    return [] if (db.url =~ /mysql:\/\//).nil?
+
+    columns = []
+    db.schema(table).each do |data|
+      column, cdata = data
+      columns << column if cdata[:db_type] =~ /text/
+    end
+    columns
+  end
+
+  def blobs_to_string(row, columns)
+    return row if columns.size == 0
+    columns.each do |c|
+      row[c] = row[c].to_s if row[c].kind_of?(Sequel::SQL::Blob)
+    end
+    row
+  end
+
+  def calculate_chunksize(old_chunksize)
+    chunksize = old_chunksize
+
+    retries = 0
+    time_in_db = 0
+    begin
+      t1 = Time.now
+      time_in_db = yield chunksize
+      time_in_db = time_in_db.to_f rescue 0
+    rescue Errno::EPIPE, RestClient::RequestFailed, RestClient::RequestTimeout
+      retries += 1
+      raise if retries > 2
+
+      # we got disconnected, the chunksize could be too large
+      # on first retry change to 10, on successive retries go down to 1
+      chunksize = (retries == 1) ? 10 : 1
+
+      retry
+    end
+
+    t2 = Time.now
+
+    diff = t2 - t1 - time_in_db
+
+    new_chunksize = if retries > 0
+      chunksize
+    elsif diff > 3.0
+      (chunksize / 3).ceil
+    elsif diff > 1.1
+      chunksize - 100
+    elsif diff < 0.8
+      chunksize * 2
+    else
+      chunksize + 100
+    end
+    new_chunksize = 1 if new_chunksize < 1
+    new_chunksize
+  end
+
+  def load_schema(database_url, schema_data)
+    Tempfile.open('taps') do |tmp|
+      File.open(tmp.path, 'w') { |f| f.write(schema_data) }
+      schema_bin(:load, database_url, tmp.path)
+    end
+  end
+
+  def load_indexes(database_url, index_data)
+    Tempfile.open('taps') do |tmp|
+      File.open(tmp.path, 'w') { |f| f.write(index_data) }
+      schema_bin(:load_indexes, database_url, tmp.path)
+    end
+  end
+
+  def schema_bin(*args)
+    bin_path = File.expand_path("#{File.dirname(__FILE__)}/../../bin/#{bin('schema')}")
+    `"#{bin_path}" #{args.map { |a| "'#{a}'" }.join(' ')}`
+  end
+
+  def primary_key(db, table)
+    table = table.to_sym.identifier unless table.kind_of?(Sequel::SQL::Identifier)
+    if db.respond_to?(:primary_key)
+      db.primary_key(table)
+    else
+      db.schema(table).select { |c| c[1][:primary_key] }.map { |c| c.first.to_sym }
+    end
+  end
+
+  def single_integer_primary_key(db, table)
+    table = table.to_sym.identifier unless table.kind_of?(Sequel::SQL::Identifier)
+    keys = db.schema(table).select { |c| c[1][:primary_key] and c[1][:type] == :integer }
+    not keys.nil? and keys.size == 1
+  end
+
+  def order_by(db, table)
+    pkey = primary_key(db, table)
+    if pkey
+      pkey.kind_of?(Array) ? pkey : [pkey.to_sym]
+    else
+      table = table.to_sym.identifier unless table.kind_of?(Sequel::SQL::Identifier)
+      db[table].columns
+    end
+  end
 end
 end

data/spec/base.rb

@@ -7,18 +7,18 @@ require 'tempfile'
 $:.unshift File.dirname(__FILE__) + "/../lib"
 
 class Bacon::Context
-	include Mocha::Standalone
-	include Rack::Test::Methods
+  include Mocha::Standalone
+  include Rack::Test::Methods
 
-	alias_method :old_it, :it
-	def it(description)
-		old_it(description) do
-			mocha_setup
-			yield
-			mocha_verify
-			mocha_teardown
-		end
-	end
+  alias_method :old_it, :it
+  def it(description)
+    old_it(description) do
+      mocha_setup
+      yield
+      mocha_verify
+      mocha_teardown
+    end
+  end
 end
 
 require 'taps/config'

data/spec/cli_spec.rb

@@ -2,9 +2,9 @@ require File.dirname(__FILE__) + '/base'
 require 'taps/cli'
 
 describe Taps::Cli do
-	it "translates a list of tables into a regex that can be used in table_filter" do
-		@cli = Taps::Cli.new(["-t", "mytable1,logs", "sqlite://tmp.db", "http://x:y@localhost:5000"])
-		opts = @cli.clientoptparse(:pull)
-		opts[:table_filter].should == "(^mytable1$|^logs$)"
-	end
+  it "translates a list of tables into a regex that can be used in table_filter" do
+    @cli = Taps::Cli.new(["-t", "mytable1,logs", "sqlite://tmp.db", "http://x:y@localhost:5000"])
+    opts = @cli.clientoptparse(:pull)
+    opts[:table_filter].should == "(^mytable1$|^logs$)"
+  end
 end

data/spec/data_stream_spec.rb

@@ -2,22 +2,22 @@ require File.dirname(__FILE__) + '/base'
 require 'taps/data_stream'
 
 describe Taps::DataStream do
-	before do
-		@db = mock('db')
-	end
+  before do
+    @db = mock('db')
+  end
 
-	it "increments the offset" do
-		stream = Taps::DataStream.new(@db, :table_name => 'test_table', :chunksize => 100)
-		stream.state[:offset].should == 0
-		stream.increment(100)
-		stream.state[:offset].should == 100
-	end
+  it "increments the offset" do
+    stream = Taps::DataStream.new(@db, :table_name => 'test_table', :chunksize => 100)
+    stream.state[:offset].should == 0
+    stream.increment(100)
+    stream.state[:offset].should == 100
+  end
 
-	it "marks the stream complete if no rows are fetched" do
-		stream = Taps::DataStream.new(@db, :table_name => 'test_table', :chunksize => 100)
-		stream.stubs(:fetch_rows).returns({})
-		stream.complete?.should.be.false
-		stream.fetch
-		stream.complete?.should.be.true
-	end
+  it "marks the stream complete if no rows are fetched" do
+    stream = Taps::DataStream.new(@db, :table_name => 'test_table', :chunksize => 100)
+    stream.stubs(:fetch_rows).returns({})
+    stream.complete?.should.be.false
+    stream.fetch
+    stream.complete?.should.be.true
+  end
 end

data/spec/operation_spec.rb

@@ -2,31 +2,31 @@ require File.dirname(__FILE__) + '/base'
 require 'taps/operation'
 
 describe Taps::Operation do
-	before do
-		@op = Taps::Operation.new('dummy://localhost', 'http://x:y@localhost:5000')
-	end
+  before do
+    @op = Taps::Operation.new('dummy://localhost', 'http://x:y@localhost:5000')
+  end
 
-	it "returns an array of tables that match the regex table_filter" do
-		@op = Taps::Operation.new('dummy://localhost', 'http://x:y@localhost:5000', :table_filter => 'abc')
-		@op.apply_table_filter(['abc', 'def']).should == ['abc']
-	end
+  it "returns an array of tables that match the regex table_filter" do
+    @op = Taps::Operation.new('dummy://localhost', 'http://x:y@localhost:5000', :table_filter => 'abc')
+    @op.apply_table_filter(['abc', 'def']).should == ['abc']
+  end
 
-	it "returns a hash of tables that match the regex table_filter" do
-		@op = Taps::Operation.new('dummy://localhost', 'http://x:y@localhost:5000', :table_filter => 'abc')
-		@op.apply_table_filter({ 'abc' => 1, 'def' => 2 }).should == { 'abc' => 1 }
-	end
+  it "returns a hash of tables that match the regex table_filter" do
+    @op = Taps::Operation.new('dummy://localhost', 'http://x:y@localhost:5000', :table_filter => 'abc')
+    @op.apply_table_filter({ 'abc' => 1, 'def' => 2 }).should == { 'abc' => 1 }
+  end
 
-	it "masks a url's password" do
-		@op.safe_url("mysql://root:password@localhost/mydb").should == "mysql://root:[hidden]@localhost/mydb"
-	end
+  it "masks a url's password" do
+    @op.safe_url("mysql://root:password@localhost/mydb").should == "mysql://root:[hidden]@localhost/mydb"
+  end
 
-	it "returns http headers with compression enabled" do
-		@op.http_headers.should == { :taps_version => Taps.compatible_version, :accept_encoding => "gzip, deflate" }
-	end
+  it "returns http headers with compression enabled" do
+    @op.http_headers.should == { :taps_version => Taps.version, :accept_encoding => "gzip, deflate" }
+  end
 
-	it "returns http headers with compression disabled" do
-		@op.stubs(:compression_disabled?).returns(true)
-		@op.http_headers.should == { :taps_version => Taps.compatible_version, :accept_encoding => "" }
-	end
+  it "returns http headers with compression disabled" do
+    @op.stubs(:compression_disabled?).returns(true)
+    @op.http_headers.should == { :taps_version => Taps.version, :accept_encoding => "" }
+  end
 
 end

data/spec/server_spec.rb

@@ -5,31 +5,31 @@ require 'taps/server'
 require 'pp'
 
 describe Taps::Server do
-	def app
-		Taps::Server.new
-	end
-
-	before do
-		Taps::Config.login = 'taps'
-		Taps::Config.password = 'tpass'
-
-		@app = Taps::Server
-		@auth_header = "Basic " + ["taps:tpass"].pack("m*")
-	end
-
-	it "asks for http basic authentication" do
-		get '/'
-		last_response.status.should == 401
-	end
-
-	it "verifies the client taps version" do
-		get('/', { }, { 'HTTP_AUTHORIZATION' => @auth_header, 'HTTP_TAPS_VERSION' => Taps.compatible_version })
-		last_response.status.should == 200
-	end
-
-	it "yells loudly if the client taps version doesn't match" do
-		get('/', { }, { 'HTTP_AUTHORIZATION' => @auth_header, 'HTTP_TAPS_VERSION' => '0.0.1' })
-		last_response.status.should == 417
-	end
+  def app
+    Taps::Server.new
+  end
+
+  before do
+    Taps::Config.login = 'taps'
+    Taps::Config.password = 'tpass'
+
+    @app = Taps::Server
+    @auth_header = "Basic " + ["taps:tpass"].pack("m*")
+  end
+
+  it "asks for http basic authentication" do
+    get '/'
+    last_response.status.should == 401
+  end
+
+  it "verifies the client taps version" do
+    get('/', { }, { 'HTTP_AUTHORIZATION' => @auth_header, 'HTTP_TAPS_VERSION' => Taps.compatible_version })
+    last_response.status.should == 200
+  end
+
+  it "yells loudly if the client taps version doesn't match" do
+    get('/', { }, { 'HTTP_AUTHORIZATION' => @auth_header, 'HTTP_TAPS_VERSION' => '0.0.1' })
+    last_response.status.should == 417
+  end
 end