blondy-dhcpd 0.0.1 → 0.0.2

data/spec/dispatcher_spec.rb

@@ -4,21 +4,69 @@ module Blondy
   module DHCPD
     describe 'Dispatcher' do
       subject(:dispatcher) {Dispatcher}
+      let(:pool) {Pool}
+      let(:pool_query_result) do
+	pr = OpenStruct.new
+	pr.data = OpenStruct.new
+	pr.data.fname = String.new
+	pr.data.yiaddr = '0.0.0.0'
+	pr.data.options = Array.new
+	pr.code = 200
+	pr
+      end
       let(:from_ip) {'0.0.0.0'}
       let(:from_port) {67}
-      let(:discover) do
-	d = DHCP::Discover.new
-	d.xid = 123456789
-	d
+      [ :discover, :request, :release, :inform ].each do |message|
+	let(message) do
+	  msg_class = DHCP.const_get message.to_s.capitalize.to_sym
+	  d = msg_class.new
+	  d.xid = 123456789
+	  d
+	end
+      end
+      let(:reply) {OpenStruct.new}
+
+      before(:each) do
+	allow(pool).to receive(:query).and_return(pool_query_result)
+	allow(pool).to receive(:query).with('ee:ee:ee:ee:ee:ee', :discover).and_return(pool_query_result)
+      end
+
+      shared_examples 'Dispatcher' do |message|
+	it 'data is correct' do
+	  dispatcher.dispatch(eval(message.to_s).pack, from_ip, from_port).data.pack.should == reply.data.pack
+	end
+	it 'ip is correct' do
+	  dispatcher.dispatch(eval(message.to_s).pack, from_ip, from_port).ip.should == reply.ip
+	end
+	it 'port is correct' do
+	  dispatcher.dispatch(eval(message.to_s).pack, from_ip, from_port).port.should == reply.port
+	end
       end
 
-      context 'receive dhcp message' do
-	it 'reply xid is the same as received xid' do
-	  dispatcher.dispatch(discover.pack, from_ip, from_port).data.xid.should == discover.xid
+      %w{discover request release inform}.each do |message|
+	context "receive dhcp #{message} message" do
+	  it "dispatch it to specific #{message}_handler private method" do
+	    dispatcher.should_receive("#{message}_handler".to_sym)
+	    dispatcher.dispatch(eval(message).pack, from_ip, from_port)
+	  end
+	  if %w{discover request inform}.include? message
+	    it 'reply xid is the same as received xid' do
+	      dispatcher.dispatch(eval(message).pack, from_ip, from_port).data.xid.should == eval(message).xid
+	    end
+	  end
 	end
       end
 
-      context 'receive discovery message' do
+      context 'wrong message' do
+	it 'false when message is unknown' do
+	  lambda { dispatcher.dispatch("abracadabra", from_ip, from_port) }.should raise_error(IncorrectMessage)
+	end
+	it 'false when action for message unspecified' do
+	  lambda { dispatcher.dispatch("abracadabra", from_ip, from_port) }.should raise_error(IncorrectMessage)
+	end
+      end
+
+      describe 'receive discovery message' do
 	# RFC 2131 (http://www.ietf.org/rfc/rfc2131.txt)
 	#
 	# http://stackoverflow.com/a/10757849
@@ -34,44 +82,155 @@ module Blondy
 	# then the server unicasts DHCPOFFER and DHCPACK messages to the client's hardware address
 	# and 'yiaddr' address. In all cases, when 'giaddr' is zero,
 	# the server broadcasts any DHCPNAK messages to 0xffffffff.
-	let(:reply) do
-	  reply = OpenStruct.new
+
+	before(:each) do
+	  discover.chaddr = [238, 238, 238, 238, 238, 238, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+	  discover.hlen = 6
+	  pool_query_result.data.fname = 'test.txt'.unpack('C128').map {|x| x ? x : 0}
+	  pool_query_result.data.yiaddr = IPAddr.new('192.168.5.150').to_i
+	  pool_query_result.data.options = [
+	    DHCP::MessageTypeOption.new({payload: [$DHCP_MSG_OFFER]}),
+	    DHCP::ServerIdentifierOption.new({payload: [192, 168, 1, 1]}),
+	    DHCP::DomainNameOption.new({payload: 'example.com'.unpack('C*')}),
+	    DHCP::DomainNameServerOption.new({payload: [8,8,8,8]}),
+	    DHCP::IPAddressLeaseTimeOption.new({payload: [7200].pack('N').unpack('C*')}),
+	    DHCP::SubnetMaskOption.new({payload: [255, 255, 255, 255]}),
+	    DHCP::RouterOption.new({payload: [192, 168, 1, 1]})
+	  ]
 	  reply.data = DHCP::Offer.new
-	  reply
+	  reply.data.xid = discover.xid
+	  reply.data.options = pool_query_result.data.options
+	  reply.data.yiaddr = pool_query_result.data.yiaddr
+	  reply.data.fname = pool_query_result.data.fname
+	  reply.data.siaddr = IPAddr.new(Blondy::DHCPD::CONFIG['server_ip']).to_i
+	end
+
+	it 'reply with offer' do
+	  dispatcher.dispatch(discover.pack, from_ip, from_port).data.class == DHCP::Offer
 	end
 
 	context 'giaddr != 0' do
-	  it 'send offer message to bootp relay' do
-	    pending
-	    data.giaddr = IPAddr.new('192.168.3.3').to_i
-	    server.should_receive(:send_datagram).with(reply.data.pack, '192.168.3.3', 67)
-	    server.receive_data(data.pack)
+	  #reply with offer message to bootp relay
+	  before(:each) do
+	    giaddr = '192.168.3.3'
+	    discover.giaddr = IPAddr.new(giaddr).to_i
+	    reply.ip = giaddr
+	    reply.port = 67
 	  end
+	  it_should_behave_like 'Dispatcher', :discover
 	end
 	context 'giaddr = 0 and ciaddr != 0' do
-	  it 'send offer message to client by unicast' do
-	    pending
-	    data.ciaddr = IPAddr.new('192.168.3.3').to_i
-	    server.should_receive(:send_data).with(reply.data.pack, '192.168.3.3', 68)
-	    server.receive_data(data.pack)
+	  #send offer message to client
+	  before(:each) do
+	    ciaddr = '192.168.3.4'
+	    discover.ciaddr = IPAddr.new(ciaddr).to_i
+	    reply.ip = ciaddr
+	    reply.port = 68
 	  end
+	  it_should_behave_like 'Dispatcher', :discover
 	end
-	context 'giaddr = 0 and ciaddr = 0 and flags = 1' do
-	  it 'send offer message to client by broadcast to 255.255.255.255' do
-	    pending
-	    data.flags = 1
-	    server.should_receive(:send_data).with(reply.data.pack, '', 68)
-	    server.receive_data(data.pack)
+	context 'giaddr = 0 and ciaddr = 0' do
+	  #send offer message to client by broadcast to 255.255.255.255
+	  before(:each) do
+	    discover.flags = 1
+	    reply.ip = '255.255.255.255'
+	    reply.port = 68
 	  end
+	  it_should_behave_like 'Dispatcher', :discover
 	end
-	context 'giaddr = 0 and ciaddr = 0 and flags = 0' do
-	  it 'send offer message to client by unicast it to client hwaddr and yiaddr' do
-	    pending
-	    data.yiaddr = IPAddr.new('192.168.3.200').to_i
-	    data.chaddr = [80, 229, 73, 35, 15, 112, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-	    reply.data.chaddr.should eq(data.chaddr)
-	    server.should_receive(:send_data).with(reply.data.pack, '192.168.3.200', 68)
-	    server.receive_data(data.pack)
+
+	context 'ask pool for configuration' do
+	  context 'query already found in cache' do
+	    it 'not reply for message' do
+	      pool.should_receive(:query).with('ee:ee:ee:ee:ee:ee', :discover).and_return(false)
+	      dispatcher.dispatch(discover.pack, from_ip, from_port).should be_false
+	    end
+	  end
+	  context 'query not found in cache' do
+	    it 'set reply fields according to pool query result' do
+	      dispatcher.dispatch(discover.pack, from_ip, from_port).data.fname.should == pool_query_result.data.fname
+	      dispatcher.dispatch(discover.pack, from_ip, from_port).data.yiaddr.should == pool_query_result.data.yiaddr
+	      dispatcher.dispatch(discover.pack, from_ip, from_port).data.options.should == pool_query_result.data.options
+	    end
+	    it 'set siaddr to server ip address' do
+	      dispatcher.dispatch(discover.pack, from_ip, from_port).data.siaddr.should == IPAddr.new(Blondy::DHCPD::CONFIG['server_ip']).to_i
+	    end
+	  end
+	end
+      end
+
+      describe 'receive request message' do
+	before(:each) do
+	  request.chaddr = [238, 238, 238, 238, 238, 238, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+	  request.hlen = 6
+	  pool_query_result.data.fname = 'test.txt'.unpack('C128').map {|x| x ? x : 0}
+	  pool_query_result.data.yiaddr = IPAddr.new('192.168.5.150').to_i
+	  pool_query_result.data.options = [
+	    DHCP::MessageTypeOption.new({payload: [$DHCP_MSG_ACK]}),
+	    DHCP::ServerIdentifierOption.new({payload: [192, 168, 1, 1]}),
+	    DHCP::DomainNameOption.new({payload: 'example.com'.unpack('C*')}),
+	    DHCP::DomainNameServerOption.new({payload: [8,8,8,8]}),
+	    DHCP::IPAddressLeaseTimeOption.new({payload: [7200].pack('N').unpack('C*')}),
+	    DHCP::SubnetMaskOption.new({payload: [255, 255, 255, 255]}),
+	    DHCP::RouterOption.new({payload: [192, 168, 1, 1]})
+	  ]
+	  reply.data = DHCP::ACK.new
+	  reply.data.xid = request.xid
+	  reply.data.options = pool_query_result.data.options
+	  reply.data.yiaddr = pool_query_result.data.yiaddr
+	  reply.data.fname = pool_query_result.data.fname
+	  reply.data.siaddr = IPAddr.new(Blondy::DHCPD::CONFIG['server_ip']).to_i
+	  message = request
+	end
+	it 'reply with ack' do
+	  dispatcher.dispatch(discover.pack, from_ip, from_port).data.class == DHCP::ACK
+	end
+	context 'giaddr != 0' do
+	  #reply with ack message to bootp relay
+	  before(:each) do
+	    giaddr = '192.168.3.3'
+	    request.giaddr = IPAddr.new(giaddr).to_i
+	    reply.ip = giaddr
+	    reply.port = 67
+	  end
+	  it_should_behave_like 'Dispatcher', :request
+	end
+	context 'giaddr = 0 and ciaddr != 0' do
+	  #send ack message to client
+	  before(:each) do
+	    ciaddr = '192.168.3.4'
+	    request.ciaddr = IPAddr.new(ciaddr).to_i
+	    reply.ip = ciaddr
+	    reply.port = 68
+	  end
+	  it_should_behave_like 'Dispatcher', :request
+	end
+	context 'giaddr = 0 and ciaddr = 0' do
+	  #send ack message to client by broadcast to 255.255.255.255
+	  before(:each) do
+	    request.flags = 1
+	    reply.ip = '255.255.255.255'
+	    reply.port = 68
+	  end
+	  it_should_behave_like 'Dispatcher', :request
+	end
+
+	context 'ask pool for configuration' do
+	  context 'query already found in cache' do
+	    it 'not reply for message' do
+	      pool.should_receive(:query).with('ee:ee:ee:ee:ee:ee', :request).and_return(false)
+	      dispatcher.dispatch(request.pack, from_ip, from_port).should be_false
+	    end
+	  end
+	  context 'query not found in cache' do
+	    it 'set reply fields according to pool query result' do
+	      dispatcher.dispatch(request.pack, from_ip, from_port).data.fname.should == pool_query_result.data.fname
+	      dispatcher.dispatch(request.pack, from_ip, from_port).data.yiaddr.should == pool_query_result.data.yiaddr
+	      dispatcher.dispatch(request.pack, from_ip, from_port).data.options.should == pool_query_result.data.options
+	    end
+	    it 'set siaddr to server ip address' do
+	      dispatcher.dispatch(request.pack, from_ip, from_port).data.siaddr.should == IPAddr.new(Blondy::DHCPD::CONFIG['server_ip']).to_i
+	    end
 	  end
 	end
       end

data/spec/pool_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+module Blondy
+  module DHCPD
+
+    describe 'Pool' do
+      subject(:pool) {Pool}
+      let(:cache) {Cache}
+      let(:logger) {Logger}
+      let(:remote_json) { {'fname' => 'test.txt', 
+			   'yiaddr' => '192.168.5.150', 
+			   'domain' => 'example.com', 
+			   'dns' => '8.8.8.8', 
+			   'gw' => '192.168.1.3', 
+			   'netmask' => '255.255.255.255' }.to_json }
+      let(:remote_invalid_json) { { 'netaddr' => 'invalid', 'yomask' => '' }.to_json }
+      let(:reply_data) do
+	pool_query_result = OpenStruct.new 
+	pool_query_result.data = OpenStruct.new 
+	pool_query_result.data.fname = 'test.txt'.unpack('C128').map {|x| x ? x : 0}
+	pool_query_result.data.yiaddr = IPAddr.new('192.168.5.150').to_i
+	pool_query_result.data.options = [
+	  DHCP::MessageTypeOption.new({payload: [$DHCP_MSG_OFFER]}),
+	  DHCP::ServerIdentifierOption.new({payload: Blondy::DHCPD::CONFIG['server_ip'].split('.').map {|octet| octet.to_i}}),
+	  DHCP::DomainNameOption.new({payload: 'example.com'.unpack('C*')}),
+	  DHCP::DomainNameServerOption.new({payload: [8,8,8,8]}),
+	  DHCP::IPAddressLeaseTimeOption.new({payload: [7200].pack('N').unpack('C*')}),
+	  DHCP::SubnetMaskOption.new({payload: [255, 255, 255, 255]}),
+	  DHCP::RouterOption.new({payload: [192, 168, 1, 3]})
+	]
+	pool_query_result
+      end
+
+      describe 'receive query' do
+
+	before(:each) do
+	  cache.flush
+	  stub_request(:get, "https://127.0.0.1/blondy/dhcpd?hwaddr=11:11:11:11:11:11&type=discover").
+	    with(:headers => {'X-Blondy-Key'=>'abcd'}).
+	    to_return(:status => 200, :body => remote_json, :headers => {})
+	end
+
+	it 'check for reply in cache' do
+	  cache.should_receive(:query).with('11:11:11:11:11:11', :discover)
+	  pool.query('11:11:11:11:11:11', :discover)
+	end
+
+	context 'not found in cache' do
+	  before(:each) do
+	    allow(cache).to receive(:query).with('11:11:11:11:11:11', :discover).and_return(false)
+	  end
+	  it 'initiate query to remote server' do
+	    pool.query('11:11:11:11:11:11', :discover)
+	    WebMock.should have_requested(:get, "https://127.0.0.1/blondy/dhcpd?hwaddr=11:11:11:11:11:11&type=discover")
+	  end
+	  it 'reply with false' do
+	    pool.query('11:11:11:11:11:11', :discover).should == false
+	  end
+	  it 'set received data to cache', :no_em do
+	    cache.stub(:query) { cache.unstub(:query); false }
+	    EM.run_block { pool.query('11:11:11:11:11:11', :discover) }
+	    cache.query('11:11:11:11:11:11', :discover)[:data].should == reply_data
+	  end
+	end
+
+	context 'found in cache' do
+	  before(:each) do
+	    allow(cache).to receive(:query).with('11:11:11:11:11:11', :discover).and_return({data:reply_data, time: Time.now})
+	  end
+
+	  it 'return reply data' do
+	    pool.query('11:11:11:11:11:11', :discover).should == reply_data
+	  end
+	end
+
+	context 'remote pool unavailable' do
+	  before(:each) do
+	    stub_request(:get, "https://127.0.0.1/blondy/dhcpd?hwaddr=11:11:11:11:11:11&type=discover").
+	      with(:headers => {'X-Blondy-Key'=>'abcd'}).
+	      to_timeout
+	  end
+	  it 'log that pool unavailable', :no_em do
+	    logger.should_receive(:error).with('Remote pool server is unavailable.')
+	    EM.run_block { pool.query('11:11:11:11:11:11', :discover) }
+	  end
+	  it 'not set values to cache' do
+	    cache.should_not_receive(:add)
+	    pool.query('11:11:11:11:11:11', :discover)
+	  end
+	end
+
+	context 'remote pool send incorrect data' do
+	  before(:each) do
+	    stub_request(:get, "https://127.0.0.1/blondy/dhcpd?hwaddr=11:11:11:11:11:11&type=discover").
+	      with(:headers => {'X-Blondy-Key'=>'abcd'}).
+	      to_return(:status => 200, :body => remote_invalid_json, :headers => {})
+	  end
+	  it 'return false' do
+	    pool.query('11:11:11:11:11:11', :discover).should be_false
+	  end
+	end
+
+	context 'remote pool reply with error' do
+	  before(:each) do
+	    stub_request(:get, "https://127.0.0.1/blondy/dhcpd?hwaddr=11:11:11:11:11:11&type=discover").
+	      with(:headers => {'X-Blondy-Key'=>'abcd'}).
+	      to_return(:status => 500, :body => "", :headers => {})
+	  end
+	  it 'log error code', :no_em do
+	    logger.should_receive(:error).with('Remote server reply with 500 error code.')
+	    EM.run_block { pool.query('11:11:11:11:11:11', :discover) }
+	  end
+	  it 'not set values to cache' do
+	    cache.should_not_receive(:add)
+	    pool.query('11:11:11:11:11:11', :discover)
+	  end
+	end
+
+      end
+    end
+  end
+end

data/spec/reply_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+module Blondy
+  module DHCPD
+    describe 'Reply' do
+
+    end
+  end
+end

data/spec/server_spec.rb

@@ -17,26 +17,87 @@ module Blondy
 	d.xid = 123456789
 	d
       end
+      let(:logger) {Logger}
 
       before(:each) do
 	allow(EM).to receive(:open_udp_socket).and_return 0
 	allow(Socket).to receive(:unpack_sockaddr_in).and_return ['0.0.0.0', '68']
+	allow(Logger).to receive(:info)
+	allow(Logger).to receive(:warn)
+	allow(Logger).to receive(:error)
+	allow(Pool).to receive(:query)
       end
 
-      context 'receive dhcp message' do
+      it 'has defined buffer' do
+	server.instance_variable_defined?('@buffer').should be_true
+      end
+
+      describe 'receive message' do
 	before(:each) do
 	  @ip, @port = Socket.unpack_sockaddr_in(server.get_peername)
 	end
-	it 'run dispatcher' do
-	  dispatcher.should_receive(:dispatch).with(discover.pack, @ip, @port)
-	  server.receive_data(discover.pack)
+
+	it 'add received data in buffer' do
+	  server.receive_data('test data')
+	  server.instance_variable_get('@buffer').include?('test data').should be_true
 	end
-	it 'send reply' do
-	  server.should_receive(:send_datagram)
-	  server.receive_data(discover.pack)
+	context 'buffer include DHCP magic number' do
+	  it 'run dispatcher' do
+	    dispatcher.should_receive(:dispatch).with(discover.pack, @ip, @port)
+	    server.receive_data(discover.pack)
+	  end
+	  it 'clear buffer' do
+	    server.receive_data(discover.pack)
+	    server.instance_variable_get('@buffer').size.should eq(0)
+	  end
+	end
+	context 'buffer not include DHCP magic' do
+	  # Maximum dhcp message size is 576 bytes (but client can increase it)
+	  # So we will try with 1000 bytes buffer
+	  context 'data size in buffer is greater than 1000 bytes' do
+	    it 'clear buffer' do
+	      dummy_data = String.new
+	      1000.times { dummy_data += rand(9).to_s }
+	      server.instance_variable_set('@buffer', dummy_data)
+	      server.receive_data(discover.pack.byteslice(0,15))
+	      server.instance_variable_get('@buffer').size.should eq(15)
+	    end
+	  end
+	  it 'shoul not clear buffer' do
+	    server.receive_data(discover.pack.byteslice(0,10))
+	    server.instance_variable_get('@buffer').size.should eq(10)
+	  end
 	end
-      end
 
+	context 'receive dhcp message' do
+	  it 'send reply' do
+	    reply = OpenStruct.new
+	    reply.data = DHCP::Offer.new
+	    allow(dispatcher).to receive(:dispatch).and_return(reply)
+	    server.should_receive(:send_datagram)
+	    server.receive_data(discover.pack)
+	  end
+	  context 'wrong data' do
+	    it 'not send reply' do
+	      server.should_not_receive(:send_datagram)
+	      server.receive_data('abracadabra')
+	    end
+	    context 'can not convert received data to Message object' do
+	      it 'should log error' do
+		logger.should_receive(:warn).with('Incorrect message received. Ignore.')
+		discover.options.shift
+		server.receive_data(discover.pack)
+	      end
+	    end
+	    context 'no handler for message' do
+	      it 'should log error' do
+		logger.should_receive(:warn).with('No handler for message found. Ignore.')
+		server.receive_data(DHCP::Offer.new.pack)
+	      end
+	    end
+	  end
+	end
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -4,16 +4,31 @@
 # loaded once.
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'simplecov'
+SimpleCov.start
 
 require 'net-dhcp'
 require 'eventmachine'
+require 'em-http'
 require 'ostruct'
 require 'ipaddr'
 require 'rspec'
+require 'webmock/rspec'
+require 'json'
+require 'fiber'
+require 'log4r'
+
 
 spec_root = File.dirname(File.absolute_path(__FILE__))
-Dir.glob(spec_root + '/../lib/blondy/dhcpd/*') {|file| require file}
+exclude = %w{config.rb logger.rb}
+Dir.glob(spec_root + '/../lib/blondy/dhcpd/*') {|file| require file unless exclude.include?(file.gsub(/^.*\//,''))}
 
+# Set config for test
+Blondy::DHCPD::CONFIG = Hash.new
+Blondy::DHCPD::CONFIG['server_ip'] = '192.168.5.1'
+Blondy::DHCPD::CONFIG['master'] = 'https://127.0.0.1/blondy/dhcpd'
+Blondy::DHCPD::CONFIG['client_key'] = 'abcd'
+Logger = Log4r::Logger.new 'ruby-dhcpd'
 
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
@@ -30,17 +45,46 @@ end
 # Wrap for running examples inside eventmachine reactor
 RSpec::Core::Example.class_eval do
   alias ignorant_run run
+  class << self
+    attr_accessor :examples_fibers
+  end 
+  self.examples_fibers = Array.new
 
   def run(example_group_instance, reporter)
-    Fiber.new do
+    if @options[:no_em]
+      fibers_alive = [true]
+      while fibers_alive.include?(true)
+	fibers_alive = []
+	self.class.examples_fibers.each do |f| 
+	  f.resume if f.alive?
+	  fibers_alive << f.alive?
+	end
+      end 
+      while EM.reactor_running?
+	EM.stop
+	sleep 0.5 
+      end 
+      ignorant_run example_group_instance, reporter
+    elsif @options[:no_fiber]
       EM.run do
 	df = EM::DefaultDeferrable.new
 	result = nil
-	df.callback { |x| EM.stop_event_loop; Fiber.yield result }
+	df.callback { |x| EM.stop_event_loop; result }
 	result = ignorant_run example_group_instance, reporter
 	df.succeed
       end
-    end.resume
+    else
+      f = Fiber.new do
+	EM.run do
+	  df = EM::DefaultDeferrable.new
+	  result = nil 
+	  df.callback { |x| EM.stop_event_loop; Fiber.yield result }
+	  result = ignorant_run example_group_instance, reporter
+	  df.succeed
+	end
+      end 
+      self.class.examples_fibers << f
+      f.resume
+    end 
   end
 end
-