couch_tap 0.0.2

data/lib/couch_tap/builders/table.rb

@@ -0,0 +1,161 @@
+
+module CouchTap
+
+  module Builders
+
+    #
+    # Deal with a table definition that will automatically insert
+    # a new row into the table.
+    #
+    class Table
+
+      attr_reader :attributes
+      attr_reader :parent, :name, :data, :primary_keys
+
+      def initialize(parent, name, opts = {}, &block)
+        @_collections = []
+
+        @parent = parent
+        @data   = opts[:data] || parent.document
+        @name   = name.to_sym
+
+        @primary_keys = parent.primary_keys.dup
+        unless opts[:primary_key] === false
+          @primary_keys << (opts[:primary_key] || "#{@name.to_s.singularize}_id").to_sym
+        end
+
+        # Prepare the attributes
+        @attributes = {}
+        set_primary_keys
+        set_attributes_from_data
+
+        instance_eval(&block) if block_given?
+      end
+
+      def handler
+        parent.handler
+      end
+
+      def id
+        handler.id
+      end
+
+      def document
+        parent.document
+      end
+      alias doc document
+
+      def database
+        @database ||= handler.database
+      end
+
+      # Grab the latest set of values to filter with.
+      # This is only relevant in sub-tables.
+      def key_filter
+        hash = {}
+        primary_keys.each do |k|
+          hash[k] = attributes[k]
+        end
+        hash
+      end
+
+      #### DSL Methods
+
+      def column(*args)
+        column = args.first
+        field  = args.last
+        if block_given?
+          set_attribute(column, yield)
+        elsif field.is_a?(Symbol)
+          set_attribute(column, data[field.to_s])
+        elsif args.length > 1
+          set_attribute(column, field)
+        end
+      end
+
+      def collection(field, opts = {}, &block)
+        @_collections << Collection.new(self, field, opts, &block)
+      end
+
+      #### Support Methods
+
+      def execute
+        # Insert the record and prepare ID for sub-tables
+        id = dataset.insert(attributes)
+        set_attribute(primary_keys.last, id) unless id.blank?
+
+        # Now go through each collection entry
+        if @_collections.length > 0
+          @_collections.each do |collection|
+            collection.execute
+          end
+        end
+      end
+
+
+      private
+
+      def schema
+        handler.schema(name)
+      end
+
+      def dataset
+        database[name]
+      end
+
+      def find_existing_row_and_set_attributes
+        row = dataset.where(key_filter).first
+        attributes.update(row) if row.present?
+      end
+
+      # Set the primary keys in the attributes so that the insert request
+      # will have all it requires.
+      #
+      # This methods has two modes of operation to handle the first table
+      # definition and sub-tables.
+      #
+      def set_primary_keys
+        base = parent.key_filter.dup
+
+        # Are we dealing with the first table?
+        base[primary_keys.first] = id if base.empty?
+
+        attributes.update(base)
+      end
+
+      # Take the document and try to automatically set the fields from the columns
+      def set_attributes_from_data
+        return unless data.is_a?(Hash) || data.is_a?(CouchRest::Document)
+        data.each do |k,v|
+          k = k.to_sym
+          next if k == :_id || k == :_rev
+          if schema.column_names.include?(k)
+            set_attribute(k, v)
+          end
+        end
+      end
+
+      def set_attribute(name, value)
+        name   = name.to_sym
+        column = schema.columns[name]
+        return if column.nil?
+        # Perform basic typecasting to avoid errors with empty fields
+        # in databases that do not support them.
+        case column[:type]
+        when :string
+          value = value.nil? ? nil : value.to_s
+        when :integer
+          value = value.to_i
+        when :float
+          value = value.to_f
+        else
+          value = nil if value.to_s.empty?
+        end
+        attributes[name] = value
+      end
+
+    end
+
+  end
+end
+

data/lib/couch_tap/changes.rb

@@ -0,0 +1,160 @@
+
+module CouchTap
+  class Changes
+
+    COUCHDB_HEARTBEAT  = 30
+    INACTIVITY_TIMEOUT = 70
+    RECONNECT_TIMEOUT  = 15
+
+    attr_reader :source, :database, :schemas, :handlers
+
+    attr_accessor :seq
+
+    # Start a new Changes instance by connecting to the provided
+    # CouchDB to see if the database exists.
+    def initialize(opts = "", &block)
+      raise "Block required for changes!" unless block_given?
+
+      @schemas  = {}
+      @handlers = []
+      @source   = CouchRest.database(opts)
+      info      = @source.info
+
+      logger.info "Connected to CouchDB: #{info['db_name']}"
+
+      # Prepare the definitions
+      instance_eval(&block)
+    end
+
+    #### DSL
+
+    # Dual-purpose method, accepts configuration of database
+    # or returns a previous definition.
+    def database(opts = nil)
+      if opts
+        @database ||= Sequel.connect(opts)
+        find_or_create_sequence_number
+      end
+      @database
+    end
+
+    def document(filter = {}, &block)
+      @handlers << DocumentHandler.new(self, filter, &block)
+    end
+
+    #### END DSL
+
+    def schema(name)
+      @schemas[name.to_sym] ||= Schema.new(database, name)
+    end
+
+    # Start listening to the CouchDB changes feed. Must be called from
+    # a EventMachine run block for the HttpRequest to take control.
+    # By this stage we should have a sequence id so we know where to start from
+    # and all the filters should have been prepared.
+    def start
+      prepare_parser
+      perform_request
+    end
+
+    protected
+
+    def perform_request
+      logger.info "Listening to changes feed from seq: #{seq}"
+
+      unless @request
+        url      = File.join(source.root, '_changes')
+        @request = EventMachine::HttpRequest.new(url, :inactivity_timeout => INACTIVITY_TIMEOUT)
+      end
+
+      # Make sure the request has the latest sequence
+      query = {:since => seq, :feed => 'continuous', :heartbeat => COUCHDB_HEARTBEAT * 1000}
+      @http = @request.get(:query => query, :keepalive => true)
+
+      # Handle incoming data
+      @http.stream do |chunk|
+        # logger.debug chunk.strip
+        @parser << chunk
+      end
+
+      # Handle error events
+      @http.errback do |err|
+        logger.error "Connection Failed: #{err.error}, attempting to reconnect in #{RECONNECT_TIMEOUT}s..."
+        EM.add_timer RECONNECT_TIMEOUT do
+          perform_request
+        end
+      end
+    end
+
+    def prepare_parser
+      @parser = Yajl::Parser.new
+      @parser.on_parse_complete = method(:process_row)
+      @parser
+    end
+
+    def process_row(row)
+      id  = row['id']
+
+      # Sometimes CouchDB will send an update to keep the connection alive
+      if id
+        seq = row['seq']
+
+        # Wrap the whole request in a transaction
+        database.transaction do
+          if row['deleted']
+            # Delete all the entries
+            logger.info "Received delete seq. #{seq} id: #{id}"
+            handlers.each{ |handler| handler.delete('_id' => id) }
+          else
+            logger.info "Received change seq. #{seq} id: #{id}"
+            doc = fetch_document(id)
+            find_document_handlers(doc).each do |handler|
+              # Delete all previous entries of doc, then re-create
+              handler.delete(doc)
+              handler.insert(doc)
+            end
+          end
+
+          update_sequence(seq)
+        end # transaction
+
+      elsif row['last_seq']
+        logger.info "Received last seq: #{row['last_seq']}"
+      end
+    end
+
+    def fetch_document(id)
+      source.get(id)
+    end
+
+    def find_document_handlers(document)
+      @handlers.reject{ |row| !row.handles?(document) }
+    end
+
+    def find_or_create_sequence_number
+      create_sequence_table unless database.table_exists?(:couch_sequence)
+      self.seq = database[:couch_sequence].where(:name => source.name).first[:seq]
+    end
+
+    def update_sequence(seq)
+      database[:couch_sequence].where(:name => source.name).update(:seq => seq)
+      self.seq = seq
+    end
+
+    def create_sequence_table
+      database.create_table :couch_sequence do
+        String :name, :primary_key => true
+        Bignum :seq, :default => 0
+        DateTime :created_at
+        DateTime :updated_at
+      end
+      # Add first row
+      database[:couch_sequence].insert(:name => source.name)
+    end
+
+    def logger
+      CouchTap.logger
+    end
+
+  end
+end

data/lib/couch_tap/destroyers/collection.rb

@@ -0,0 +1,36 @@
+
+module CouchTap
+
+  module Destroyers
+
+    #
+    # Collection Destroyer. Go through each sub-table definition and remove
+    # all references to the parent document.
+    #
+    class Collection
+
+      attr_reader :parent
+
+      def initialize(parent, opts = {}, &block)
+        @_tables = []
+        @parent  = parent
+
+        instance_eval(&block)
+      end
+
+      def execute
+        # Just go through each table and ask it to execute itself
+        @_tables.each do |table|
+          table.execute
+        end
+      end
+
+      #### DSL Methods
+
+      def table(name, opts = {}, &block)
+        @_tables << Table.new(parent, name, opts, &block)
+      end
+
+    end
+  end
+end

data/lib/couch_tap/destroyers/table.rb

@@ -0,0 +1,76 @@
+
+module CouchTap
+
+  module Destroyers
+
+    #
+    # The table destroyer will go through a table definition and make sure that
+    # all rows that belong to the document's id are deleted from the system.
+    #
+    # It'll automatically go through each collection definition and recursively
+    # ensure that everything has been cleaned up.
+    #
+    class Table
+
+      attr_reader :parent, :name, :primary_keys
+
+      def initialize(parent, name, opts = {}, &block)
+        @_collections = []
+
+        @parent = parent
+        @name   = name
+
+        @primary_keys = parent.primary_keys.dup
+
+        # As we're deleting, only assign the primary key for the first table
+        if @primary_keys.empty?
+          @primary_keys << (opts[:primary_key] || "#{@name.to_s.singularize}_id").to_sym
+        end
+
+        instance_eval(&block) if block_given?
+      end
+
+      def execute
+        dataset = handler.database[name]
+        dataset.where(key_filter).delete
+        @_collections.each do |collection|
+          collection.execute
+        end
+      end
+
+      def handler
+        parent.handler
+      end
+
+      # Unlike building new rows, delete only requires the main primary key to be available.
+      def key_filter
+        {
+          @primary_keys.first => handler.id
+        }
+      end
+
+      ### DSL methods
+
+      def collection(field, opts = {}, &block)
+        @_collections << Collection.new(self, opts, &block)
+      end
+
+      ### Dummy helper methods
+
+      def column(*args)
+        nil
+      end
+
+      def document
+        {}
+      end
+      alias doc document
+
+      def data
+        {}
+      end
+
+    end
+  end
+
+end

data/lib/couch_tap/document_handler.rb

@@ -0,0 +1,73 @@
+module CouchTap
+
+  class DocumentHandler
+
+    attr_reader :changes, :filter, :mode
+    attr_accessor :id, :document
+
+    def initialize(changes, filter = {}, &block)
+      @changes  = changes
+      @filter   = filter
+      @_block   = block
+      @mode     = nil
+    end
+
+    def handles?(doc)
+      @filter.each do |k,v|
+        return false if doc[k.to_s] != v
+      end
+      true
+    end
+
+    ### START DSL
+
+    # Handle a table definition.
+    def table(name, opts = {}, &block)
+      if @mode == :delete
+        Destroyers::Table.new(self, name, opts, &block).execute
+      elsif @mode == :insert
+        Builders::Table.new(self, name, opts, &block).execute
+      end
+    end
+
+    ### END DSL
+
+    def handler
+      self
+    end
+
+    def primary_keys
+      []
+    end
+
+    def key_filter
+      {}
+    end
+
+    def id
+      document['_id']
+    end
+
+    def insert(document)
+      @mode = :insert
+      self.document = document
+      instance_eval(&@_block)
+    end
+
+    def delete(document)
+      @mode = :delete
+      self.document = document
+      instance_eval(&@_block)
+    end
+
+    def schema(name)
+      changes.schema(name)
+    end
+
+    def database
+      changes.database
+    end
+
+  end
+
+end