taps 0.3.11 → 0.3.12

data/lib/taps/schema.rb

@@ -6,78 +6,78 @@ require 'json/pure'
 
 module Taps
 module Schema
-	extend self
+  extend self
 
-	def dump(database_url)
-		db = Sequel.connect(database_url)
-		db.dump_schema_migration(:indexes => false)
-	end
+  def dump(database_url)
+    db = Sequel.connect(database_url)
+    db.dump_schema_migration(:indexes => false)
+  end
 
-	def dump_table(database_url, table)
-		table = table.to_sym
-		Sequel.connect(database_url) do |db|
-			<<END_MIG
+  def dump_table(database_url, table)
+    table = table.to_sym
+    Sequel.connect(database_url) do |db|
+      <<END_MIG
 Class.new(Sequel::Migration) do
-	def up
-		#{db.dump_table_schema(table.identifier, :indexes => false)}
-	end
+  def up
+    #{db.dump_table_schema(table.identifier, :indexes => false)}
+  end
 
-	def down
-		drop_table("#{table}") if @db.table_exists?("#{table}")
-	end
+  def down
+    drop_table("#{table}") if @db.table_exists?("#{table}")
+  end
 end
 END_MIG
-		end
-	end
+    end
+  end
 
-	def indexes(database_url)
-		db = Sequel.connect(database_url)
-		db.dump_indexes_migration
-	end
+  def indexes(database_url)
+    db = Sequel.connect(database_url)
+    db.dump_indexes_migration
+  end
 
-	def indexes_individual(database_url)
-		idxs = {}
-		Sequel.connect(database_url) do |db|
-			tables = db.tables
-			tables.each do |table|
-				idxs[table] = db.send(:dump_table_indexes, table, :add_index, {}).split("\n")
-			end
-		end
+  def indexes_individual(database_url)
+    idxs = {}
+    Sequel.connect(database_url) do |db|
+      tables = db.tables
+      tables.each do |table|
+        idxs[table] = db.send(:dump_table_indexes, table, :add_index, {}).split("\n")
+      end
+    end
 
-		idxs.each do |table, indexes|
-			idxs[table] = indexes.map do |idx|
-				<<END_MIG
+    idxs.each do |table, indexes|
+      idxs[table] = indexes.map do |idx|
+        <<END_MIG
 Class.new(Sequel::Migration) do
-	def up
-		#{idx}
-	end
+  def up
+    #{idx}
+  end
 end
 END_MIG
-			end
-		end
-		idxs.to_json
-	end
+      end
+    end
+    idxs.to_json
+  end
 
-	def load(database_url, schema)
-		Sequel.connect(database_url) do |db|
-			klass = eval(schema)
-			klass.apply(db, :down)
-			klass.apply(db, :up)
-		end
-	end
+  def load(database_url, schema)
+    Sequel.connect(database_url) do |db|
+      klass = eval(schema)
+      klass.apply(db, :down)
+      klass.apply(db, :up)
+    end
+  end
 
-	def load_indexes(database_url, indexes)
-		Sequel.connect(database_url) do |db|
-			eval(indexes).apply(db, :up)
-		end
-	end
+  def load_indexes(database_url, indexes)
+    Sequel.connect(database_url) do |db|
+      eval(indexes).apply(db, :up)
+    end
+  end
 
-	def reset_db_sequences(database_url)
-		db = Sequel.connect(database_url)
-		return unless db.respond_to?(:reset_primary_key_sequence)
-		db.tables.each do |table|
-			db.reset_primary_key_sequence(table)
-		end
-	end
+  def reset_db_sequences(database_url)
+    db = Sequel.connect(database_url)
+    return unless db.respond_to?(:reset_primary_key_sequence)
+    db.tables.each do |table|
+      db.reset_primary_key_sequence(table)
+    end
+  end
 end
 end

data/lib/taps/server.rb

@@ -6,161 +6,161 @@ require 'taps/data_stream'
 
 module Taps
 class Server < Sinatra::Base
-	use Rack::Auth::Basic do |login, password|
-		login == Taps::Config.login && password == Taps::Config.password
-	end
-
-	use Rack::Deflater unless ENV['NO_DEFLATE']
-
-	error do
-		e = request.env['sinatra.error']
-		"Taps Server Error: #{e}\n#{e.backtrace}"
-	end
+  use Rack::Auth::Basic do |login, password|
+    login == Taps::Config.login && password == Taps::Config.password
+  end
+
+  use Rack::Deflater unless ENV['NO_DEFLATE']
+
+  error do
+    e = request.env['sinatra.error']
+    "Taps Server Error: #{e}\n#{e.backtrace}"
+  end
 
-	before do
-		major, minor, patch = request.env['HTTP_TAPS_VERSION'].split('.') rescue []
-		unless "#{major}.#{minor}" == Taps.compatible_version
-			halt 417, "Taps v#{Taps.compatible_version}.x is required for this server"
-		end
-	end
-
-	get '/' do
-		"hello"
-	end
-
-	post '/sessions' do
-		key = rand(9999999999).to_s
-
-		if ENV['NO_DEFAULT_DATABASE_URL']
-			database_url = request.body.string
-		else
-			database_url = Taps::Config.database_url || request.body.string
-		end
-
-		DbSession.create(:key => key, :database_url => database_url, :started_at => Time.now, :last_access => Time.now)
-
-		"/sessions/#{key}"
-	end
-
-	post '/sessions/:key/push/table' do
-		session = DbSession.filter(:key => params[:key]).first
-		halt 404 unless session
-
-		json = DataStream.parse_json(params[:json])
-
-		size = 0
-		session.conn do |db|
-			begin
-				stream = DataStream.factory(db, json[:state])
-				size = stream.fetch_remote_in_server(params)
-			rescue Taps::DataStream::CorruptedData
-				halt 412
-			end
-		end
-
-		# TODO: return the stream's state with the size
-		size.to_s
-	end
-
-	post '/sessions/:key/push/reset_sequences' do
-		session = DbSession.filter(:key => params[:key]).first
-		halt 404 unless session
-
-		Taps::Utils.schema_bin(:reset_db_sequences, session.database_url)
-	end
-
-	post '/sessions/:key/push/schema' do
-		session = DbSession.filter(:key => params[:key]).first
-		halt 404 unless session
-
-		schema_data = request.body.read
-		Taps::Utils.load_schema(session.database_url, schema_data)
-	end
-
-	post '/sessions/:key/push/indexes' do
-		session = DbSession.filter(:key => params[:key]).first
-		halt 404 unless session
-
-		index_data = request.body.read
-		Taps::Utils.load_indexes(session.database_url, index_data)
-	end
-
-	post '/sessions/:key/pull/schema' do
-		session = DbSession.filter(:key => params[:key]).first
-		halt 404 unless session
-
-		Taps::Utils.schema_bin(:dump_table, session.database_url, params[:table_name])
-	end
-
-	get '/sessions/:key/pull/indexes' do
-		session = DbSession.filter(:key => params[:key]).first
-		halt 404 unless session
-
-		content_type 'application/json'
-		Taps::Utils.schema_bin(:indexes_individual, session.database_url)
-	end
-
-	get '/sessions/:key/pull/table_names' do
-		session = DbSession.filter(:key => params[:key]).first
-		halt 404 unless session
-
-		tables = []
-		session.conn do |db|
-			tables = db.tables
-		end
-
-		content_type 'application/json'
-		tables.to_json
-	end
-
-	post '/sessions/:key/pull/table_count' do
-		session = DbSession.filter(:key => params[:key]).first
-		halt 404 unless session
-
-		count = 0
-		session.conn do |db|
-			count = db[ params[:table].to_sym.identifier ].count
-		end
-		count.to_s
-	end
-
-	post '/sessions/:key/pull/table' do
-		session = DbSession.filter(:key => params[:key]).first
-		halt 404 unless session
-
-		encoded_data = nil
-		stream = nil
-
-		session.conn do |db|
-			state = JSON.parse(params[:state]).symbolize_keys
-			stream = Taps::DataStream.factory(db, state)
-			encoded_data = stream.fetch.first
-		end
-
-		checksum = Taps::Utils.checksum(encoded_data).to_s
-		json = { :checksum => checksum, :state => stream.to_hash }.to_json
-
-		content, content_type_value = Taps::Multipart.create do |r|
-			r.attach :name => :encoded_data,
-				:payload => encoded_data,
-				:content_type => 'application/octet-stream'
-			r.attach :name => :json,
-				:payload => json,
-				:content_type => 'application/json'
-		end
-
-		content_type content_type_value
-		content
-	end
-
-	delete '/sessions/:key' do
-		session = DbSession.filter(:key => params[:key]).first
-		halt 404 unless session
-
-		session.destroy
-
-		"ok"
-	end
+  before do
+    major, minor, patch = request.env['HTTP_TAPS_VERSION'].split('.') rescue []
+    unless "#{major}.#{minor}" == Taps.compatible_version
+      halt 417, "Taps v#{Taps.compatible_version}.x is required for this server"
+    end
+  end
+
+  get '/' do
+    "hello"
+  end
+
+  post '/sessions' do
+    key = rand(9999999999).to_s
+
+    if ENV['NO_DEFAULT_DATABASE_URL']
+      database_url = request.body.string
+    else
+      database_url = Taps::Config.database_url || request.body.string
+    end
+
+    DbSession.create(:key => key, :database_url => database_url, :started_at => Time.now, :last_access => Time.now)
+
+    "/sessions/#{key}"
+  end
+
+  post '/sessions/:key/push/table' do
+    session = DbSession.filter(:key => params[:key]).first
+    halt 404 unless session
+
+    json = DataStream.parse_json(params[:json])
+
+    size = 0
+    session.conn do |db|
+      begin
+        stream = DataStream.factory(db, json[:state])
+        size = stream.fetch_remote_in_server(params)
+      rescue Taps::DataStream::CorruptedData
+        halt 412
+      end
+    end
+
+    # TODO: return the stream's state with the size
+    size.to_s
+  end
+
+  post '/sessions/:key/push/reset_sequences' do
+    session = DbSession.filter(:key => params[:key]).first
+    halt 404 unless session
+
+    Taps::Utils.schema_bin(:reset_db_sequences, session.database_url)
+  end
+
+  post '/sessions/:key/push/schema' do
+    session = DbSession.filter(:key => params[:key]).first
+    halt 404 unless session
+
+    schema_data = request.body.read
+    Taps::Utils.load_schema(session.database_url, schema_data)
+  end
+
+  post '/sessions/:key/push/indexes' do
+    session = DbSession.filter(:key => params[:key]).first
+    halt 404 unless session
+
+    index_data = request.body.read
+    Taps::Utils.load_indexes(session.database_url, index_data)
+  end
+
+  post '/sessions/:key/pull/schema' do
+    session = DbSession.filter(:key => params[:key]).first
+    halt 404 unless session
+
+    Taps::Utils.schema_bin(:dump_table, session.database_url, params[:table_name])
+  end
+
+  get '/sessions/:key/pull/indexes' do
+    session = DbSession.filter(:key => params[:key]).first
+    halt 404 unless session
+
+    content_type 'application/json'
+    Taps::Utils.schema_bin(:indexes_individual, session.database_url)
+  end
+
+  get '/sessions/:key/pull/table_names' do
+    session = DbSession.filter(:key => params[:key]).first
+    halt 404 unless session
+
+    tables = []
+    session.conn do |db|
+      tables = db.tables
+    end
+
+    content_type 'application/json'
+    tables.to_json
+  end
+
+  post '/sessions/:key/pull/table_count' do
+    session = DbSession.filter(:key => params[:key]).first
+    halt 404 unless session
+
+    count = 0
+    session.conn do |db|
+      count = db[ params[:table].to_sym.identifier ].count
+    end
+    count.to_s
+  end
+
+  post '/sessions/:key/pull/table' do
+    session = DbSession.filter(:key => params[:key]).first
+    halt 404 unless session
+
+    encoded_data = nil
+    stream = nil
+
+    session.conn do |db|
+      state = JSON.parse(params[:state]).symbolize_keys
+      stream = Taps::DataStream.factory(db, state)
+      encoded_data = stream.fetch.first
+    end
+
+    checksum = Taps::Utils.checksum(encoded_data).to_s
+    json = { :checksum => checksum, :state => stream.to_hash }.to_json
+
+    content, content_type_value = Taps::Multipart.create do |r|
+      r.attach :name => :encoded_data,
+        :payload => encoded_data,
+        :content_type => 'application/octet-stream'
+      r.attach :name => :json,
+        :payload => json,
+        :content_type => 'application/json'
+    end
+
+    content_type content_type_value
+    content
+  end
+
+  delete '/sessions/:key' do
+    session = DbSession.filter(:key => params[:key]).first
+    halt 404 unless session
+
+    session.destroy
+
+    "ok"
+  end
 
 end
 end