Class: LanGrove::Daemon::Base

Inherits:

Object

• Object
• LanGrove::Daemon::Base

Defined in:

lib/langrove/daemon_base.rb

Instance Method Summary

• #initialize(config_hash, daemon_name, logger) ⇒ Base constructor

  A new instance of Base.

• #listen ⇒ Object
• #reload_daemon ⇒ Object
• #run ⇒ Object
• #schedule ⇒ Object
• #stop_daemon ⇒ Object

Constructor Details

#initialize(config_hash, daemon_name, logger) ⇒ Base

Returns a new instance of Base.

# File 'lib/langrove/daemon_base.rb', line 86

def initialize( config_hash, daemon_name, logger )
  
  @config      = config_hash
  @daemon_name = daemon_name
  @logger      = logger
  @server      = true
  
  #
  # A network connection.
  #
  @adaptor = nil
  
  #
  # The client collection class.
  #
  @handler = nil
  
  #
  # The client type
  #
  @client = nil
  
  #
  # The protocol type
  #
  @protocol = nil
  
  
  begin
    
    @logger.info "Starting daemon: #{@daemon_name}"
    
  rescue
    
    #
    # you shall not pass
    #
    raise LanGrove::DaemonConfigException.new( "Requires a logger" )
    
  end

  begin

    @my_config = @config[ :daemons ][ @daemon_name ]
    
    @server    = @my_config[ :server ] if @my_config.has_key? :server
    
    
    
    if @my_config[ :adaptor ].has_key? :class
      
      adaptor    = @my_config[ :adaptor ][ :class ]
      
    else
    
      @logger.warn( "Defaulting to Adaptor::Base" )
      adaptor    = 'Base'
    
    end
    
    
    
    @logger.info "TODO: fall back to default Handler::Base"
    
    handler    = @my_config[ :handler ][ :collection ]
    
    client     = @my_config[ :client ][ :class ]
    
    protocol   = @my_config[ :protocol ][ :class ]
    
    @logger.info "TODO: Warn instead of raise and allow nil into ClassLoader -> load default"
       
  rescue
    
    error = "Missing config item for daemon: #{@daemon_name}" 
    
    @logger.error "EXIT: #{error}"
    
    raise LanGrove::DaemonConfigException.new( 
    
      "Missing config item for daemon: #{@daemon_name}" 
      
    )
      
  end
  
  
  #
  # initialize the connection adaptor specified in config
  # 
  # daemons:
  #   name_of_daemon:
  #     adaptor:
  #       class: MySocket  <----------( optional )
  #       transport: tcp|udp
  #       iface: N.N.n.n
  #       port: nNn
  #     handler:
  #       collection: CollectionOfClients 
  #

  @logger.info "CREATE: Adaptor::#{adaptor}.new( @my_config[ :adaptor ], logger )"
  
  @adaptor = LanGrove::ClassLoader.create( {
    
    :module => 'Adaptor',
    :class  => adaptor
    
  } ).new( @my_config[ :adaptor ], logger )
  
  
  #
  # bind to the handler collection specified in config
  # 
  # daemons:
  #   name_of_daemon:
  #     adaptor:
  #       connection: TcpServer
  #     handler:
  #       collection: CollectionOfClients  <---------- 
  #    
  #  CollectionOfClients ---> is the handler passed into listen()                       
  #

  @logger.info "CREATE: Handler::#{handler}.new( config_hash, '#{daemon_name}', logger )"
  
  @handler = LanGrove::ClassLoader.create( {
    
    :module => 'Handler',
    :class  => handler
    
  } ).new( @config, @daemon_name, @logger )
  
  
  #
  # initialize the client specified in config
  # 
  # daemons:
  #   name_of_daemon:
  #     client:
  #       class: Client <---------
  #     adaptor:
  #       connection: TcpServer
  #     handler:
  #       collection: CollectionOfClients 
  #
  #
  
  @logger.info "DEFINE: Client::#{client}"

  @client = LanGrove::ClassLoader.create( {

    :module => 'Client',
    :class  => client

  } )
  
  
  #
  # initialize the client specified in config
  # 
  # daemons:
  #   name_of_daemon:
  #     protocol:
  #       class: Protocol <---------
  #       more: config
  #     client:
  #       class: Client
  #     adaptor:
  #       connection: TcpServer
  #     handler:
  #       collection: CollectionOfClients 
  #
  #
  
  @logger.info "DEFINE: Protocol::#{protocol}"

  @protocol = LanGrove::ClassLoader.create( {

    :module => 'Protocol',
    :class  => protocol

  } )
  
  
  #
  # Notifiy the handler
  # 
  # About to go to listen... 
  #
  
  @handler.start_daemon
 
end

Instance Method Details

#listen ⇒ Object

# File 'lib/langrove/daemon_base.rb', line 7

def listen
  
  #
  # <Client> and <Protocol> are passed into 
  # the Adaptor.listen for binding onto the 
  # sockets at connect.
  #
  @adaptor.listen( 
  
    #
    # pass Client, Protocol and Handler to 'listener'
    #
    
    { :class => @client, :config => @my_config[ :client ] }, 
    
    { :class => @protocol, :config => @my_config[ :protocol ] },
    
    @handler
    
  )
  
end

#reload_daemon ⇒ Object

# File 'lib/langrove/daemon_base.rb', line 40

def reload_daemon
  
  #
  # TODO: Handle reloading daemon properly
  # 
  # [ !!complexities abound around reloading config!! ]
  #
  
  @logger.info "#{self} received reload_daemon"
  @handler.reload_daemon
  
end

#run ⇒ Object

# File 'lib/langrove/daemon_base.rb', line 70

def run
  
  EventMachine::run do
    
    # 
    # https://github.com/eventmachine/eventmachine/wiki/Protocol-Implementations
    # 
    
    schedule
    
    listen if @server
    
  end
  
end

#schedule ⇒ Object

# File 'lib/langrove/daemon_base.rb', line 53

def schedule
  
  @logger.info "#{self} Scheduling periodic ...TODO..."
  
  EM::add_periodic_timer( @my_config[ :periodic ] ) do 
    
    #
    # TODO: This can be a lot more usefull than
    #       then one ticker to one function call
    #
    
    @handler.periodic
    
  end if @my_config.has_key? :periodic
  
end

#stop_daemon ⇒ Object

# File 'lib/langrove/daemon_base.rb', line 30

def stop_daemon
  
  #
  # Handle stopping daemon
  #
  @logger.info "#{self} received stop_daemon"
  @handler.stop_daemon
  
end