Class: LanGrove::Adaptor::QueryAdaptor

Inherits:

EventMachineAdaptor

• Object
• Base
• Base
• EventMachineAdaptor
• LanGrove::Adaptor::QueryAdaptor

Defined in:

lib/langrove/adaptor/query_adaptor.rb

Instance Attribute Summary

Attributes inherited from Base

#logger

Instance Method Summary

• #connect ⇒ Object
• #connector(params, &block) ⇒ Object
• #do_query(params, &block) ⇒ Object
• #initialize(root, config, deamon_name) ⇒ QueryAdaptor constructor

  A new instance of QueryAdaptor.

• #query(&block) ⇒ Object
• #reload ⇒ Object
• #reload_adaptor ⇒ Object
• #running? ⇒ Boolean
• #stop ⇒ Object

  Used to periodically query a datasource, Yields rows as handlers into the daemon’s event pipeline.

• #stop_adaptor ⇒ Object
• #validate_config ⇒ Object

Methods inherited from EventMachineAdaptor

#path, #validate_tls_options

Methods inherited from Base

#listen, #validate_config_adaptor

Methods inherited from Base

#config_exception, #type

Constructor Details

#initialize(root, config, deamon_name) ⇒ QueryAdaptor

Returns a new instance of QueryAdaptor.

# File 'lib/langrove/adaptor/query_adaptor.rb', line 105

def initialize( root, config, deamon_name )
  
  super
  
  #
  # :run_interval: 
  # 
  #  A value in seconds between calling the query. 
  #           
  #  If the previous run is not finished a new run 
  #  will not start if the running?() method is 
  #  implemented.
  #  
  #  The run will be skipped and another :interval: 
  #  period will pass before the next run is 
  #  attempted.
  # 
  @run_interval = @config[:run_interval]
  
  
  #
  # :run_once: 
  # 
  #  If true will run the query only once and then 
  #  exit the Daemon.
  # 
  @run_once = false
  @run_once = @config[:run_once]
  @done_once = false
  
  #
  # :run_immediately: 
  # 
  #  If true (the default) will run the query at Daemon 
  #  start. Otherwise the run will wait :interval: seconds
  #  after daemon start.
  # 
  @run_immediately = @config[:run_immediately]
  @run_immediately = true if @run_immediately.nil?
  
  
  config_exception(
  
    "#{self.class} requires subconfig with :run_interval:"
  
  ) if (
    
    @run_interval.nil? or
    not @run_interval.is_a?( Integer )
    
  )
  
  @query = @config[:query]
  
  config_exception(
  
    "#{self.class} requires :query: subconfig"
  
  ) if @query.nil?
  
  validate_config
  
  connect

end

Instance Method Details

#connect ⇒ Object

# File 'lib/langrove/adaptor/query_adaptor.rb', line 43

def connect
  
  #
  # OVERRIDE
  # 
  # To connect to the DataSource
  #
  
end

#connector(params, &block) ⇒ Object

# File 'lib/langrove/adaptor/query_adaptor.rb', line 171

def connector( params, &block )
  
  #
  # Override Handler type if it
  # is the default (Handler::Socket)
  # 
  # Does not override if the Handler 
  # is user specified.
  #
  if params[:handler][:class] == LanGrove::Handler::Socket
    
    params[:handler][:class] = LanGrove::Handler::Base
    
  end
  
  if @run_immediately
    
    do_query( params, &block )
    
  end
  
  EM.add_periodic_timer( @run_interval ) do
    
    do_query( params, &block )
    
  end
  
end

#do_query(params, &block) ⇒ Object

# File 'lib/langrove/adaptor/query_adaptor.rb', line 200

def do_query( params, &block )
    
  if running?
    
    @logger.info "#{self.class} already running query"
    
    return
    
  end
    
  if @run_once and @done_once
    
    @logger.warn "#{self.class} set to :run_once:"
    Process.kill( 'TERM', Process.pid )
    return
    
  end
  
  #
  # The query may be long blocking
  # so defer to allow the reactor
  # to proceed
  #
  operation = proc do
    
    query do |record|
      
      #
      # Initialize a new Handler
      #
      handler = params[:handler][:class].new
      
      #
      # Yield the handler into the daemon,
      # this will traverse the assignment 
      # pipeline resulting in the handler
      # interacting with all configured
      # server behaviours
      #
      yield handler if block
      
      #
      # Pass the record in along the 'reveive'
      # along with associated event triggers.
      # 
      # (For behaviours)
      #
      @root.trigger( handler, :handler, :receive )
      
      handler.receive( record )
      
      @root.trigger( handler, :handler, :after_receive )
  
    end
    
  end
  
  callback = proc do |result|
    
    @done_once = true
    
  end
  
  EM.defer( operation, callback )
  
end

#query(&block) ⇒ Object

Raises:

• (LanGrove::PluginException)

# File 'lib/langrove/adaptor/query_adaptor.rb', line 84

def query( &block )
  
  #
  # OVERRIDE
  #
  # To perform the query and yield resulting 'rows'
  # 
  # - Should yield one hash of key/value pairs
  #   per 'row'
  # 
  
  raise LanGrove::PluginException.new( 
  
    "#{self.class}.query( ... ) - missing implementation."  
    
  )
  
end

#reload ⇒ Object

# File 'lib/langrove/adaptor/query_adaptor.rb', line 23

def reload

  #
  # OVERRIDE
  # 
  # Daemon has been called to HUP
  #

end

#reload_adaptor ⇒ Object

# File 'lib/langrove/adaptor/query_adaptor.rb', line 78

def reload_adaptor

  reload

end

#running? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/langrove/adaptor/query_adaptor.rb', line 53

def running?
  
  #
  # OVERRIDE
  # 
  # (optional)
  # 
  # Because the query may run asyncronously and 
  # emply callbacks, this flag should be set so
  # that it can be determined if a query is active
  # in the background.
  # 
  # Only required if it is necessary to ensure that
  # never more than 1 concurrent query is running.
  # 
  false
  
end

#stop ⇒ Object

Used to periodically query a datasource, Yields rows as handlers into the daemon’s event pipeline

# File 'lib/langrove/adaptor/query_adaptor.rb', line 13

def stop
  
  #
  # OVERRIDE
  #
  # Daemon has been called to stop
  #

end

#stop_adaptor ⇒ Object

# File 'lib/langrove/adaptor/query_adaptor.rb', line 72

def stop_adaptor

  stop

end

#validate_config ⇒ Object

# File 'lib/langrove/adaptor/query_adaptor.rb', line 33

def validate_config
  
  #
  # OVERRIDE
  # 
  # To validate implementation specific config
  #
  
end