couchproxy 0.1.0

data/lib/couchproxy/rack/compact.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+module CouchProxy
+  module Rack
+    class Compact < Base
+      def post
+        proxy_to_all_partitions do |responses|
+          ok = responses.map {|res| JSON.parse(res.response)['ok'] }
+          body = {:ok => !ok.include?(false)}
+          send_response(responses.first.response_header.status,
+            response_headers, [body.to_json])
+        end
+      end
+    end
+  end
+end

data/lib/couchproxy/rack/config.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+module CouchProxy
+  module Rack
+    class Config < Base
+      alias :get :proxy_to_any_node
+
+      def put
+        proxy_to_all_nodes do |responses|
+          send_response(responses.first.response_header.status,
+            response_headers, [responses.first.response])
+        end
+      end
+    end
+  end
+end

data/lib/couchproxy/rack/database.rb

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+
+module CouchProxy
+  module Rack
+    class Database < Base
+      def get
+        proxy_to_all_partitions do |responses|
+          doc = {
+            :db_name => request.db_name,
+            :disk_size => 0,
+            :doc_count => 0,
+            :doc_del_count => 0,
+            :compact_running => false,
+            :compact_running_partitions => []}
+
+          responses.each do |res|
+            result = JSON.parse(res.response)
+            doc[:compact_running] ||= result['compact_running']
+            doc[:compact_running_partitions] << result['db_name'] if result['compact_running']
+            %w[disk_size doc_count doc_del_count].each do |k|
+              doc[k.to_sym] += result[k]
+            end
+            doc[:compact_running_partitions].sort!
+          end
+          send_response(responses.first.response_header.status,
+            response_headers, [doc.to_json])
+        end
+      end
+
+      def post
+        begin
+          doc = JSON.parse(request.content)
+        rescue
+          send_response(400, response_headers, INVALID_JSON)
+          return
+        end
+
+        unless doc['_id']
+          uuids(1) do |uuids|
+            if uuids
+              doc['_id'] = uuids.first
+              partition = cluster.partition(doc['_id'])
+              request.content = doc.to_json
+              request.rewrite_proxy_url!(partition.num)
+              proxy_to(partition.node)
+            else
+              send_error_response
+            end
+          end
+        else
+          partition = cluster.partition(doc['_id'])
+          request.rewrite_proxy_url!(partition.num)
+          proxy_to(partition.node) do
+            if design?(doc['_id'])
+              replicate_to_all_partitions(partition, doc['_id'])
+            end
+          end
+        end
+      end
+
+      def put
+        proxy_to_all_partitions do |responses|
+          res = responses.first
+          head = response_headers.tap do |h|
+            h['Location'] = rewrite_location(res.response_header.location)
+          end
+          send_response(res.response_header.status, head, res.response)
+        end
+      end
+
+      def delete
+        proxy_to_all_partitions do |responses|
+          send_response(responses.first.response_header.status,
+            response_headers, responses.first.response)
+        end
+      end
+
+      def head
+        # FIXME
+      end
+    end
+  end
+end

data/lib/couchproxy/rack/design_doc.rb

@@ -0,0 +1,227 @@
+# encoding: UTF-8
+
+module CouchProxy
+  module Rack
+    class DesignDoc < Base
+      QUERY     = /_view\/.+$/
+      INFO      = /\/_info$/
+      VIEW_NAME = /_view\/(.*)$/
+      COUNT     = '_count'.freeze
+      SUM       = '_sum'.freeze
+      STATS     = '_stats'.freeze
+      REDUCE_ERROR = '{"error":"query_parse_error","reason":"Invalid URL parameter `reduce` for map view."}'.freeze
+
+      def get
+        case request.path_info
+          when QUERY then query
+          when INFO  then info
+          else proxy_to_any_partition
+        end
+      end
+
+      def post
+        # FIXME same as get, but body can have keys in it
+      end
+
+      def put
+        partition = cluster.any_partition
+        request.rewrite_proxy_url!(partition.num)
+        uri = "#{partition.node.uri}#{@request.fullpath}"
+        http = EM::HttpRequest.new(uri).put(:head => proxy_headers,
+          :body => request.content)
+        http.callback do |res|
+          head = response_headers
+          sender = proc do
+            send_response(res.response_header.status, head, [res.response])
+          end
+          if (200...300).include?(res.response_header.status)
+            head.tap do |h|
+              h['ETag'] = res.response_header.etag
+              h['Location'] = rewrite_location(res.response_header.location)
+            end
+            replicate_to_all_partitions(partition, request.doc_id, &sender)
+          else
+            sender.call
+          end
+        end
+        http.errback { send_error_response }
+      end
+
+      def delete
+        proxy_to_all_partitions do |responses|
+          head = response_headers.tap do |h|
+            h['ETag'] = responses.first.response_header.etag
+          end
+          send_response(responses.first.response_header.status,
+            head, responses.first.response)
+        end
+      end
+
+      def head
+        # FIXME
+      end
+
+      private
+
+      def query_params
+        {}.tap do |params|
+          params[:reduce] = [nil, 'true'].include?(request['reduce'])
+          params[:group] = (request['group'] == 'true')
+          params[:descending] = (request['descending'] == 'true')
+          params[:limit] = request['limit'] || ''
+          params[:limit] = params[:limit].empty? ? nil : params[:limit].to_i
+          params[:skip] = (params[:limit] == 0) ? 0 : delete_query_param('skip').to_i
+          delete_query_param('limit') if params[:skip] > (params[:limit] || 0)
+          params[:collator] = CouchProxy::Collator.new(params[:descending])
+        end
+      end
+
+      def query
+        params = query_params
+        proxy_to_all_partitions do |responses|
+          view_doc do |doc|
+            if doc
+              fn = doc['views'][view_name]['reduce']
+              if request['reduce'] && fn.nil?
+                send_response(400, response_headers, [REDUCE_ERROR])
+              elsif params[:reduce] && fn
+                reduce(params, responses, fn)
+              else
+                map(params, responses)
+              end
+            else
+              send_error_response
+            end
+          end
+        end
+      end
+
+      def map(params, responses)
+        total = {:total_rows => 0, :offset => 0, :rows =>[]}
+        responses.each do |res|
+          result = JSON.parse(res.response)
+          %w[total_rows rows].each {|k| total[k.to_sym] += result[k] }
+        end
+        total[:rows].sort! do |a, b|
+          key = params[:collator].compare(a['key'], b['key'])
+          (key == 0) ? params[:collator].compare(a['id'], b['id']) : key
+        end
+        total[:rows].slice!(0, params[:skip])
+        total[:rows].slice!(params[:limit], total[:rows].size) if params[:limit]
+        total[:offset] = [params[:skip], total[:total_rows]].min
+        send_response(responses.first.response_header.status,
+          response_headers, [total.to_json])
+      end
+
+      def reduce(params, responses, fn)
+        total = {:rows =>[]}
+        responses.each do |res|
+          result = JSON.parse(res.response)
+          total[:rows] += result['rows']
+        end
+        groups = total[:rows].group_by {|row| row['key'] }
+        case fn
+        when SUM, COUNT
+          sum(params, groups)
+        when STATS
+          stats(params, groups)
+        else
+          view_server(params, fn, groups)
+        end
+      end
+
+      def view_server(params, fn, groups)
+        reduced = {:rows => []}
+        groups.each do |key, rows|
+          values = rows.map {|row| row['value'] }
+          cluster.reducer.rereduce(fn, values) do |result|
+            success, value = result.flatten
+            if success
+              reduced[:rows] << {:key => key, :value => value}
+              if reduced[:rows].size == groups.size
+                reduced[:rows].sort! do |a, b|
+                  params[:collator].compare(a[:key], b[:key])
+                end
+                send_response(200, response_headers, [reduced.to_json])
+              end
+            else
+              send_error_response
+            end
+          end
+        end
+      end
+
+      def sum(params, groups)
+        reduced = {:rows => []}
+        groups.each do |key, rows|
+          value = rows.map {|row| row['value'] }.inject(:+)
+          reduced[:rows] << {:key => key, :value => value}
+        end
+        reduced[:rows].sort! do |a, b|
+          params[:collator].compare(a[:key], b[:key])
+        end
+        send_response(200, response_headers, [reduced.to_json])
+      end
+
+      def stats(groups)
+        reduced = {:rows => []}
+        groups.each do |key, rows|
+          values = rows.map {|row| row['value'] }
+          min, max = values.map {|v| [v['min'], v['max']] }.flatten.minmax
+          sum, count, sumsqr = %w[sum count sumsqr].map do |k|
+            values.map {|v| v[k] }.inject(:+)
+          end
+          value = {:sum => sum, :count => count, :min => min, :max => max,
+            :sumsqr => sumsqr}
+          reduced[:rows] << {:key => key, :value => value}
+        end
+        reduced[:rows].sort! do |a, b|
+          params[:collator].compare(a[:key], b[:key])
+        end
+        send_response(200, response_headers, [reduced.to_json])
+      end
+
+      def info
+        proxy_to_all_partitions do |responses|
+          status = total = nil
+          responses.shift.tap do |res|
+            status = res.response_header.status
+            total = JSON.parse(res.response)
+          end
+          responses.each do |res|
+            doc = JSON.parse(res.response)
+            %w[disk_size waiting_clients].each do |k|
+              total['view_index'][k] += doc['view_index'][k]
+            end
+            %w[compact_running updater_running waiting_commit].each do |k|
+              total['view_index'][k] ||= doc['view_index'][k]
+            end
+          end
+          %w[update_seq purge_seq].each {|k| total['view_index'].delete(k) }
+          send_response(status, response_headers, [total.to_json])
+        end
+      end
+
+      def view_doc_id
+        request.doc_id.split('/')[0..1].join('/')
+      end
+
+      def view_name
+        request.doc_id.match(VIEW_NAME)[1]
+      end
+
+      def view_doc(&callback)
+        db = cluster.any_partition.uri(request.db_name)
+        http = EM::HttpRequest.new("#{db}/#{view_doc_id}").get
+        http.errback { callback.call(nil) }
+        http.callback do |res|
+          if res.response_header.status == 200
+            callback.call(JSON.parse(res.response))
+          else
+            callback.call(nil)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couchproxy/rack/doc.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+module CouchProxy
+  module Rack
+    class Doc < Base
+      def get
+        partition = cluster.partition(request.doc_id)
+        request.rewrite_proxy_url!(partition.num)
+        proxy_to(partition.node)
+      end
+      alias :put :get
+      alias :delete :get
+    end
+  end
+end

data/lib/couchproxy/rack/ensure_full_commit.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+module CouchProxy
+  module Rack
+    class EnsureFullCommit < Base
+      def post
+        proxy_to_all_partitions do |responses|
+          ok = responses.map {|res| JSON.parse(res.response)['ok'] }
+          body = {:ok => !ok.include?(false)}
+          send_response(responses.first.response_header.status,
+            response_headers, [body.to_json])
+        end
+      end
+    end
+  end
+end

data/lib/couchproxy/rack/not_found.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+module CouchProxy
+  module Rack
+    class NotFound < Base
+      NOT_FOUND = '{"error":"not_found","reason":"missing"}'.freeze
+
+      def method_missing(name)
+        send_response(404, response_headers, [NOT_FOUND])
+      end
+    end
+  end
+end

data/lib/couchproxy/rack/replicate.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+
+module CouchProxy
+  module Rack
+    class Replicate < Base
+      # FIXME
+    end
+  end
+end

data/lib/couchproxy/rack/revs_limit.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+module CouchProxy
+  module Rack
+    class RevsLimit < Base
+      alias :get :proxy_to_any_partition
+
+      def put
+        proxy_to_all_partitions do |responses|
+          ok = responses.map {|res| JSON.parse(res.response)['ok'] }
+          body = {:ok => !ok.include?(false)}
+          send_response(responses.first.response_header.status,
+            response_headers, [body.to_json])
+        end
+      end
+    end
+  end
+end

data/lib/couchproxy/rack/root.rb

@@ -0,0 +1,10 @@
+# encoding: UTF-8
+
+module CouchProxy
+  module Rack
+    class Root < Base
+      alias :get  :proxy_to_any_node
+      alias :head :proxy_to_any_node
+    end
+  end
+end

data/lib/couchproxy/rack/stats.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+module CouchProxy
+  module Rack
+    class Stats < Base
+      def get
+        proxy_to_all_nodes do |responses|
+          docs = responses.map {|res| parse(res.response) }
+          total = docs.shift.tap do |doc|
+            each_stat(doc) do |group, name, values|
+              %w[means stddevs].each {|k| values[k] = [values[k.chop]] }
+            end
+          end
+          docs.each do |doc|
+            each_stat(total) do |group, name, values|
+              %w[current sum].each {|k| values[k] += doc[group][name][k] }
+              %w[means stddevs].each {|k| values[k] << doc[group][name][k.chop] }
+              %w[min max].each {|k| values[k] = [values[k], doc[group][name][k]].send(k) }
+            end
+          end
+          each_stat(total) do |group, name, values|
+            means, stddevs = %w[means stddevs].map {|k| values.delete(k) }
+            mean = means.inject(:+) / means.size.to_f
+            sums = means.zip(stddevs).map {|m, sd| m**2 + sd**2 }
+            stddev = Math.sqrt(sums.inject(:+) / means.size.to_f - mean**2)
+            mean, stddev = [mean, stddev].map {|f| sprintf('%.3f', f).to_f }
+            values.update('stddev' => stddev, 'mean' => mean)
+          end
+          send_response(responses.first.response_header.status,
+            response_headers, [total.to_json])
+        end
+      end
+
+      private
+
+      def parse(body)
+        JSON.parse(body).tap do |doc|
+          each_stat(doc) do |group, name, values|
+            values.each {|k, v| values[k] = 0 unless v }
+          end
+        end
+      end
+
+      def each_stat(doc)
+        doc.each do |group, stats|
+          stats.each do |name, values|
+            yield group, name, values
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couchproxy/rack/temp_view.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+
+module CouchProxy
+  module Rack
+    class TempView < Base
+      # FIXME
+    end
+  end
+end

data/lib/couchproxy/rack/update.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+module CouchProxy
+  module Rack
+    class Update < Base
+      def post
+        # FIXME http://wiki.apache.org/couchdb/Document_Update_Handlers
+      end
+    end
+  end
+end

data/lib/couchproxy/rack/users.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+
+module CouchProxy
+  module Rack
+    class Users < Base
+      # FIXME
+    end
+  end
+end

data/lib/couchproxy/rack/uuids.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+
+module CouchProxy
+  module Rack
+    class Uuids < Base
+      alias :get :proxy_to_any_node
+    end
+  end
+end

data/lib/couchproxy/rack/view_cleanup.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+module CouchProxy
+  module Rack
+    class ViewCleanup < Base
+      def post
+        proxy_to_all_partitions do |responses|
+          ok = responses.map {|res| JSON.parse(res.response)['ok'] }
+          body = {:ok => !ok.include?(false)}
+          send_response(responses.first.response_header.status,
+            response_headers, [body.to_json])
+        end
+      end
+    end
+  end
+end

data/lib/couchproxy/reducer.rb

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+
+module CouchProxy
+  class Reducer
+    def initialize(couchjs)
+      @couchjs, @conn = "#{couchjs} #{mainjs(couchjs)}", nil
+    end
+
+    def rereduce(fn, values, &callback)
+      connect unless @conn
+      @conn.rereduce(fn, values, callback)
+    end
+
+    private
+
+    def mainjs(couchjs)
+      File.expand_path('../../share/couchdb/server/main.js', couchjs)
+    end
+
+    def connect
+      @conn = EM.popen(@couchjs, ReduceProcess, proc { @conn = nil })
+    end
+  end
+
+  class ReduceProcess < EventMachine::Connection
+    def initialize(unbind)
+      @unbind, @connected, @callbacks, @deferred = unbind, false, [], []
+    end
+
+    def post_init
+      @connected = true
+      @deferred.slice!(0, @deferred.size).each do |fn, values, callback|
+        rereduce(fn, values, callback)
+      end
+    end
+
+    def rereduce(fn, values, callback)
+      if @connected
+        @callbacks << callback
+        send_data(["rereduce", [fn], values].to_json + "\n")
+      else
+        @deferred << [fn, values, callback]
+      end
+    end
+
+    def receive_data(data)
+      data.split("\n").each do |line|
+        @callbacks.shift.call(JSON.parse(line))
+      end
+    end
+
+    def unbind
+      @connected = false
+      @unbind.call
+    end
+  end
+end

data/lib/couchproxy/request.rb

@@ -0,0 +1,50 @@
+module Rack
+  # Add a few helper methods to Rack's Request class.
+  class Request
+    def json?
+      if accept = @env['HTTP_ACCEPT']
+        accept.tr(' ', '').split(',').include?('application/json')
+      end
+    end
+
+    def db_name
+      parse_db_name_and_doc_id[0]
+    end
+
+    def doc_id
+      parse_db_name_and_doc_id[1]
+    end
+
+    def rewrite_proxy_url(partition_num)
+      path_info.sub(/^\/#{db_name}/, "/#{db_name}_#{partition_num}")
+    end
+
+    def rewrite_proxy_url!(partition_num)
+      @env['PATH_INFO'] = rewrite_proxy_url(partition_num)
+    end
+
+    def content
+      unless defined? @proxy_content
+        body.rewind
+        @proxy_content = body.read
+        body.rewind
+      end
+      @proxy_content
+    end
+
+    def content=(body)
+      @proxy_content = body
+      @env['CONTENT_LENGTH'] = body.bytesize
+    end
+
+    private
+
+    def parse_db_name_and_doc_id
+      unless defined? @db_name
+        path = @env['REQUEST_PATH'][1..-1].chomp('/')
+        @db_name, @doc_id = path.split('/', 2).map {|n| ::Rack::Utils.unescape(n) }
+      end
+      [@db_name, @doc_id]
+    end
+  end
+end