smart_proxy_dhcp_kea 0.1.2

data/README.md

@@ -0,0 +1,52 @@
+# SmartProxyDhcpKea
+
+This Foreman smart proxy plugin allow to interface with Kea DHCP provider. Postgres and Mysql database are supported, anyway Mysql has not been tested yet. 
+
+# Installation 
+
+Smart proxy plugin are ruby gems. They can be easly instaled with `gem`. 
+
+## Prerequisites
+
+The smart proxy need to interact both with postgresql and mysql. To do that it uses `mysql2` and `pg` gems, which are automatically installed, but some dependencies are needed. So if gem installation goes wrong, try to install them with `yum`:
+
+	yum install ruby-devel
+	yum install potgresql-devel
+	yum install mysql-devel
+
+## Manual installation
+
+It's possible to install manually this smart proxy plugin using `gem`
+	
+	gem install 'smart_proxy_dhcp_kea'
+
+The gem with all its dependencies will be installed. Next you need to specify the gem into the `~foreman-proxy/bundler.d/Gemfile.local.rb` file. Create the file if it doesn't exist.
+
+	echo "gem 'smat_proxy_dhcp_kea'" > /usr/share/foreman-proxy/bundler.d/Gemfile.local.rb
+
+Next restart the foreman-proxy service and refresh features form the control panel.
+
+	systemctl restart foreman-proxy  
+
+The DHCP feature should be now active. 
+
+# Configuration
+
+To enable this DHCP provider, edit `/etc/foreman-proxy/settings.d/dhcp.yml` and set:
+
+	:use_provider: dhcp_kea
+
+Then you need to create /etc/foreman-proxy/settings.d/dhcp\_kea.yml file and specify the following parameters.
+
+	:db: [postgres, mysql]
+	:dbname: [database_name]
+	:username: [username]
+	:password: [password]
+	:host: [host_address]
+	:port: [db_port]
+
+
+This smart proxy support both postgres and mysql database for kea. You need to specify in the configuration file which one are you going to use. Mysql is the default databse. Also, if postgres is choosen, a table called subnets, in which subnets are stored into keasubnets database is required. The subnet schema is indeed present by default in MySQL database.
+ 
+# Contributing  
+Pierfrancesco Cifra

data/bundler.d/dhcp_kea.rb

@@ -0,0 +1,4 @@
+group :dhcp_kea do
+  gem 'rsec', '< 1'
+end
+gem 'smart_proxy_dhcp_kea'

data/config/dhcp_remote_kea.yml.example

@@ -0,0 +1,24 @@
+---
+#
+# Configuration file for ISC dhcp provider
+#
+
+#:config: /etc/dhcp/dhcpd.conf
+#:leases: /var/lib/dhcpd/dhcpd.leases
+#
+# Redhat 5
+#
+#:config: /etc/dhcpd.conf
+#
+# Settings for Ubuntu
+#
+#:config: /etc/dhcp3/dhcpd.conf
+#:leases: /var/lib/dhcp3/dhcpd.leases
+
+# Specifies TSIG key name and secret
+#:key_name: secret_key_name
+#:key_secret: secret_key
+
+#:omapi_port: 7911
+
+# use :server setting in dhcp.yml if you are managing a dhcp server which is not localhost

data/lib/smart_proxy_dhcp_kea.rb

@@ -0,0 +1,9 @@
+module Proxy
+  module DHCP
+    module DhcpKea; end
+  end
+end
+
+require 'smart_proxy_dhcp_kea/version'
+require 'smart_proxy_dhcp_kea/plugin_configuration'
+require 'smart_proxy_dhcp_kea/dhcp_kea_plugin'

data/lib/smart_proxy_dhcp_kea/dhcp_kea.rb

@@ -0,0 +1,4 @@
+require 'dhcp_common/dhcp_common'
+require 'dhcp_keapostgre/configuration_loader'
+require 'dhcp_keapostgre/dhcp_keapostgre_plugin'
+

data/lib/smart_proxy_dhcp_kea/dhcp_kea_main.rb

@@ -0,0 +1,127 @@
+require 'dhcp_common/dhcp_common'
+require 'dhcp_common/server'
+
+
+module Proxy::DHCP::DhcpKea
+  class Provider < ::Proxy::DHCP::Server
+    attr_reader :host, :port, :dbname, :username, :password, :keapostgre_network, :subnet_service, :free_ips, :db
+
+    def initialize(host, port, dbname, username, password, keapostgre_network, subnet_service, free_ip_service, db)
+      @host = host
+      @port = port
+      @db = db
+      @dbname = dbname
+      @username = username
+      @password = password
+      @keapostgre_network = keapostgre_network
+      @subnet_service = subnet_service
+      @free_ips = free_ip_service
+      super('kea', 'nil', subnet_service, free_ips)
+    end
+
+    def unused_ip(subnet_address, mac_address, from_address, to_address)
+      require 'ipaddr'
+      require 'resolv' 
+      require 'pg'
+      require 'mysql2'
+
+
+      if db == 'postgres'
+        con = PG.connect :dbname => 'keasubnets', :user => username, :password => password, :host => host, :port => port
+        subnet = con.exec_params("select encode(address, 'escape') from subnets where encode(address, 'escape') like $1;", ['%' + subnet_address + '%'])
+
+
+	if subnet.num_tuples.zero?
+          logger.error 'This subnet does not exist. Not found in databse'
+          return nil
+        end
+  
+      else
+	con = Mysql2::Client.new(:dbname => dbname, :user => username, :password => password, :host => host, :port => port) 
+	st = con.prepare("select subnet_prefix from dhcp4_subnet where subnet_prefix like ?;")
+	subnet = st.execute('%' + subnet_address + '%')
+
+        if subnet.count.zero?
+          logger.warning 'This subnet does not exist. Not found in databse'
+          return nil
+        end
+
+      end
+
+
+
+      mask = '/' + subnet.getvalue(0,0)[-2..-1]
+      subnet_address = subnet_address + mask
+      logger.debug 'Start searching ip address in subnet ' + subnet_address
+
+
+      unless from_address
+        addr = IPAddr.new(subnet_address.to_s)
+	from_address = IPAddr.new((addr.to_range().first.to_i + 1), Socket::AF_INET).to_s
+      end
+      
+      unless to_address
+	addr = IPAddr.new(subnet_address.to_s)
+	to_address = IPAddr.new((addr.to_range().last.to_i - 1), Socket::AF_INET).to_s
+      end
+      
+      logger.debug 'Starting search for a free ip address form ' + from_address.to_s + ' to ' + to_address.to_s
+      possible_ip = free_ips.find_free_ip(from_address, to_address, all_hosts(subnet_address) + all_leases(subnet_address))
+   
+      logger.debug 'Possible ip found: ' + possible_ip
+
+      while possible_ip != nil 
+        begin
+          Resolv.getname possible_ip
+        logger.warning 'Address ' + possible_ip + ' resolved. Cannot use it'
+        possible_ip = free_ips.find_free_ip(from_address, to_address, all_hosts(subnet_address) + all_leases(subnet_address))
+	rescue Resolv::ResolvError => e
+		logger.warning 'Address ' + possible_ip + ' not resolved. Can use it'
+          return possible_ip
+        end
+      end
+    end
+
+
+
+    def add_record(options={})
+      logger.debug "Hui1 '#{options}'"
+      record = super(options)
+      logger.debug "Hui '#{record}'"
+      keapostgre_network.add_dhcp_record options
+      record
+    rescue Exception => e
+      logger.error msg = "Error adding DHCP record: #{e}"
+      raise Proxy::DHCP::Error, msg
+    end
+
+    def del_record(record)
+      logger.debug "Hui '#{record}'"
+      # libvirt only supports one subnet per network
+      keapostgre_network.del_dhcp_record record
+    rescue Exception => e
+      logger.error msg = "Error removing DHCP record: #{e}"
+      raise Proxy::DHCP::Error, msg
+    end
+    
+    def find_record(subnet_address, ip_or_mac_address)
+      if ip_or_mac_address =~ Resolv::IPv4::Regex
+        keapostgre_network.find_records_by_ip ip_or_mac_address
+      else
+        keapostgre_network.find_records_by_mac ip_or_mac_address
+      end
+    end
+
+    def find_records_by_ip(subnet_address, ip_address)
+      keapostgre_network.find_records_by_ip ip_address
+    end
+
+    def find_records_by_mac(subnet_address, mac_address)
+      keapostgre_network.find_records_by_mac mac_address
+    end
+    
+    def del_record_by_mac(subnet_address, mac_address)
+      keapostgre_network.del_record_by_mac mac_address
+    end
+  end
+end

data/lib/smart_proxy_dhcp_kea/dhcp_kea_plugin.rb

@@ -0,0 +1,16 @@
+module Proxy::DHCP::DhcpKea
+  class Plugin < ::Proxy::Provider
+    plugin :dhcp_kea, ::Proxy::DHCP::DhcpKea::VERSION
+
+    default_settings :host => '127.0.0.1', :port => '5432', :dbname => 'keadb', :username => 'postgres', :db => 'postgres'
+
+    requires :dhcp, '>= 1.16'
+
+    validate_readable :config, :leases
+
+    load_classes ::Proxy::DHCP::DhcpKea::PluginConfiguration
+    load_dependency_injection_wirings ::Proxy::DHCP::DhcpKea::PluginConfiguration
+
+    start_services :free_ips
+  end
+end

data/lib/smart_proxy_dhcp_kea/keapostgre_dhcp_network.rb

@@ -0,0 +1,132 @@
+require 'pg'
+require 'mysql2'
+
+module ::Proxy::DHCP::DhcpKea
+  class KeaDHCPNetwork
+
+    attr_reader :host, :port, :dbname, :username, :password, :db
+
+    def initialize(host, port, dbname, username, password, free_ips_service = nil, db)
+      @host = host
+      @port = port
+      @db = db
+      @dbname = dbname
+      @username = username
+      @password = password 
+      @free_ips = free_ips_service
+    end
+
+    def dhcp_leases
+      find_network.dhcp_leases
+    rescue ArgumentError
+      # workaround for ruby-libvirt < 0.6.1 - DHCP leases API is broken there
+      # (http://libvirt.org/git/?p=ruby-libvirt.git;a=commit;h=c2d4192ebf28b8030b753b715a72f0cdf725d313)
+      []
+    end
+
+    def add_dhcp_record(record)
+      
+
+
+      if db.to_s == 'postgres' 
+        con = PG.connect :dbname => 'keasubnets', :user => username, :password => password, :host => host, :port => port
+        query = "SELECT subnet_id from subnets WHERE encode(address,'escape') ~ $1 ORDER BY RIGHT(encode(address,'escape'),2) DESC;"
+        subnet_id = nil
+        subnet_id = con.exec_params(query, [record['network']])[0]['subnet_id']
+      else
+	con = Mysql2::Client.new(:dbname => dbname, :user => username, :password => password, :host => host, :port => port)
+	st = con.prepare("SELECT subnet_id from dhcp4_subnet WHERE subnet_prefix like ? ORDER BY RIGHT(subnet_prefix,2) DESC;")
+        subnet_id = nil
+	subnet_id = st.execute(record['network'].to_s + '%')[0]['subnet_id']
+
+      end
+
+      unless subnet_id
+           raise Proxy::DHCP::Error, "Unable to find subnet_id for ip: #{record.ip}"
+      end
+      con.close if con
+      
+      if db == 'postgres'
+        con = PG.connect :dbname => dbname, :user => username, :password => password, :host => host, :port => port
+	query = "INSERT INTO hosts(dhcp_identifier,dhcp_identifier_type,dhcp4_subnet_id,ipv4_address,hostname,dhcp4_client_classes,dhcp4_next_server,dhcp4_boot_file_name) VALUES(DECODE($1,'hex'),0,$2,(SELECT ($3::inet - '0.0.0.0'::inet) as ip_integer),$4,'foreman',(SELECT ($5::inet - '0.0.0.0'::inet) as ip_integer),$6)"
+        con.exec_params(query, [record['mac'].gsub(":",""), subnet_id, record['ip'], record['name'], record['nextServer'],record['filename']])
+      else
+        con = Mysql2::Client.new(:dbname => dbname, :user => username, :password => password, :host => host, :port => port)
+	st = con.prepare("INSERT INTO hosts(dhcp_identifier,dhcp_identifier_type,dhcp4_subnet_id,ipv4_address,hostname,dhcp4_client_classes,dhcp4_next_server,dhcp4_boot_file_name) VALUES(?,0,?,INET_ATON(?) as ip_integer),?,'foreman',INET_ATON(?) as ip_integer),?)")
+	st.execute(record['mac'].gsub(":",""), subnet_id, record['ip'], record['name'], record['nextServer'],record['filename']) 
+      
+      end
+	
+      con.close if con
+
+    end
+
+
+    def del_dhcp_record(record)
+
+	if db == 'postgres'
+          con = PG.connect :dbname => dbname, :user => username, :password => password, :host => host, :port => port
+	  con.exec_params("DELETE FROM hosts WHERE encode(dhcp_identifier,'hex') = $1", [record.mac.gsub(":","")])
+	else 
+	  con = Mysql2::Client.new(:dbname => dbname, :user => username, :password => password, :host => host, :port => port)
+	  st = con.prepare("DELETE FROM hosts WHERE dhcp_identifier = ?")
+	  st.execute(record.mac.gsub(":",""))
+	end
+
+	con.close if con
+    end
+
+
+    def del_record_by_mac(mac)
+      
+      if db == 'postgres'	    
+        con = PG.connect :dbname => dbname, :user => username, :password => password, :host => host, :port => port
+        con.exec_params("DELETE FROM hosts WHERE encode(dhcp_identifier,'hex') = $1", [mac.gsub(":","")])
+      else 
+	con = Mysql2::Client.new(:dbname => dbname, :user => username, :password => password, :host => host, :port => port)
+	st = con.prepare("DELETE FROM hosts WHERE dhcp_identifier = ?")
+	st.execute(mac.gsub(":",""))
+      end
+
+      con.close if con
+
+    end
+
+
+    def find_records_by_mac(mac)
+
+      if db == 'postgres'
+        con = PG.connect :dbname => dbname, :user => username, :password => password, :host => host, :port => port
+        host_info = con.exec_params("SELECT encode(dhcp_identifier,'hex') as mac,(SELECT('0.0.0.0'::inet + ipv4_address)) as ip,hostname FROM hosts WHERE encode(dhcp_identifier,'hex') = $1", [mac.gsub(":","")] )
+      else 
+	con = Mysql2::Client.new(:dbname => dbname, :user => username, :password => password, :host => host, :port => port)
+	st = con.prepare("SELECT dhcp_identifier as mac,(INET_NTOA(ipv4_address)) as ip,hostname FROM hosts WHERE dhcp_identifier = ?")
+	host_info = st.execute(mac.gsub(":",""))
+      end
+
+      con.close if con
+      Proxy::DHCP::Record.new(host_info[0]['hostname'], host_info[0]['ip'], host_info[0]['mac'].scan(/.{1,2}/).join(':'))
+    end
+
+    def find_records_by_ip(ip)
+      
+      if db == 'postgres'
+        con = PG.connect :dbname => dbname, :user => username, :password => password, :host => host, :port => port
+        host_info = con.exec_params("SELECT encode(dhcp_identifier,'hex') as mac,(SELECT('0.0.0.0'::inet + ipv4_address)) as ip,hostname FROM hosts WHERE ipv4_address = (SELECT ($1::inet - '0.0.0.0'::inet) as ip_integer)", [ip] )
+      else
+	con = Mysql2::Client.new(:dbname => dbname, :user => username, :password => password, :host => host, :port => port)
+	st = con.prepare("SELECT dhcp_identifier as mac,INET_NTOA(ipv4_address) as ip,hostname FROM hosts WHERE ipv4_address = INET_ATON(?)")
+	host_info = st.execute(ip)
+      end
+
+      con.close if con
+      Proxy::DHCP::Record.new(host_info[0]['hostname'], host_info[0]['ip'], host_info[0]['mac'].scan(/.{1,2}/).join(':'))
+      rescue Exception => e
+        return ''
+        raise e
+      end
+
+    end
+
+  end
+

data/lib/smart_proxy_dhcp_kea/plugin_configuration.rb

@@ -0,0 +1,58 @@
+module Proxy::DHCP::DhcpKea
+  class PluginConfiguration
+    
+    include Proxy::Log	  
+	  
+	  
+	  
+    def load_dependency_injection_wirings(container, settings)
+
+
+      logger.debug 'Plugin initializer, database used is ' + settings[:db].to_s
+
+      container.dependency :memory_store, ::Proxy::MemoryStore
+      
+      container.dependency :subnet_service, (lambda do
+        ::Proxy::DHCP::SubnetService.new(container.get_dependency(:memory_store),
+                                         container.get_dependency(:memory_store), container.get_dependency(:memory_store),
+                                         container.get_dependency(:memory_store), container.get_dependency(:memory_store))
+      end)
+
+
+      container.dependency :subnet_service_initializer, (lambda do
+        ::Proxy::DHCP::DhcpKea::SubnetServiceInitializer.new(settings[:config], settings[:leases],
+                                                               container.get_dependency(:parser), container.get_dependency(:subnet_service))
+      end)
+
+
+      container.dependency :keapostgre_network, (lambda do
+       ::Proxy::DHCP::DhcpKea::KeaDHCPNetwork.new(settings[:host], settings[:port], settings[:dbname], settings[:username], settings[:password], settings[:db])
+      end)
+
+
+      container.dependency :initialized_subnet_service, (lambda do
+        ::Proxy::DHCP::DhcpKea::SubnetServiceInitializer.new(settings[:host], settings[:port], settings[:dbname], settings[:username], settings[:password], settings[:db]).initialized_subnet_service(container.get_dependency(:subnet_service))
+      end)
+
+
+      container.singleton_dependency :free_ips, lambda {::Proxy::DHCP::FreeIps.new }
+
+      container.dependency :dhcp_provider, (lambda do
+        ::Proxy::DHCP::DhcpKea::Provider.new(settings[:host], settings[:port], settings[:dbname], settings[:username], settings[:password], container.get_dependency(:keapostgre_network),
+                                           container.get_dependency(:initialized_subnet_service),
+                                           container.get_dependency(:free_ips), settings[:db])
+      end)
+
+
+    end
+
+    def load_classes
+      require 'smart_proxy_dhcp_kea/keapostgre_dhcp_network'
+      require 'dhcp_common/subnet_service'
+      require 'dhcp_common/free_ips'
+      require 'dhcp_common/server'
+      require 'smart_proxy_dhcp_kea/subnet_service_initializer'
+      require 'smart_proxy_dhcp_kea/dhcp_kea_main'
+    end
+  end
+end

data/lib/smart_proxy_dhcp_kea/subnet_service_initializer.rb

@@ -0,0 +1,100 @@
+require 'rexml/document'
+require 'ipaddr'
+require 'pg'
+require 'mysql2'
+
+
+module Proxy::DHCP::DhcpKea
+  class SubnetServiceInitializer
+    include Proxy::Log
+
+    attr_reader :host, :port, :dbname, :username, :password, :db
+
+    def initialize(host, port, dbname, username, password, db, free_ips_service = nil)
+      @host = host
+      @port = port
+      @db = db
+      @dbname = dbname
+      @username = username
+      @password = password 
+      @free_ips = free_ips_service
+    end
+
+    def initialized_subnet_service(subnet_service)
+      subnet_service.add_subnets(*parse_config_for_subnets)
+      logger.debug msg = "Initializing subnet"
+    #  load_subnet_data(subnet_service)
+      subnet_service
+    end
+
+    def parse_config_for_subnets
+      
+      ret_val = []
+
+      if db == 'postgres'
+        con = PG.connect :dbname => 'keasubnets', :user => username, :password => password, :host => host, :port => port
+        rs = con.exec "SELECT encode(address,'escape') from subnets"
+      else
+	con = Mysql2::Client.new(:dbname => dbname, :user => username, :password => password, :host => host, :port => port) 
+	rs = con.query ("SELECT subnet_prefix from dhcp4_subnet")
+      end
+
+      require 'ipaddress'
+      rs.each do |subnet|
+	 ip = IPAddress::IPv4.new subnet['encode'] 
+         ret_val << Proxy::DHCP::Subnet.new(ip.address, ip.netmask)
+      	 logger.debug ip.to_s
+      end
+      logger.debug ret_val.to_s
+      ret_val
+    rescue Exception => e
+      logger.error msg = "Unable to parse postgres subnets: #{e}"
+      raise Proxy::DHCP::Error, msg
+    end
+
+    # Expects subnet_service to have subnet data
+    def parse_config_for_dhcp_reservations(subnet_service)
+      to_ret = []
+      doc = REXML::Document.new xml = libvirt_network.dump_xml
+      REXML::XPath.each(doc, "//network/ip[not(@family) or @family='ipv4']/dhcp/host") do |e|
+        subnet = subnet_service.find_subnet(e.attributes['ip'])
+        to_ret << Proxy::DHCP::Reservation.new(
+            e.attributes["name"],
+            e.attributes["ip"],
+            e.attributes["mac"],
+            subnet,
+            :hostname => e.attributes["name"])
+      end
+      to_ret
+    rescue Exception => e
+      logger.error msg = "Unable to parse reservations XML: #{e}"
+      logger.debug xml if defined?(xml)
+      raise Proxy::DHCP::Error, msg
+    end
+
+    def load_subnet_data(subnet_service)
+      reservations = parse_config_for_dhcp_reservations(subnet_service)
+      reservations.each { |record| subnet_service.add_host(record.subnet_address, record) }
+      leases = load_leases(subnet_service)
+      leases.each { |lease| subnet_service.add_lease(lease.subnet_address, lease) }
+    end
+
+    # Expects subnet_service to have subnet data
+    def load_leases(subnet_service)
+      leases = libvirt_network.dhcp_leases
+      leases.map do |element|
+        subnet = subnet_service.find_subnet(element['ipaddr'])
+        Proxy::DHCP::Lease.new(
+            nil,
+            element['ipaddr'],
+            element['mac'],
+            subnet,
+            Time.now.utc,
+            Time.at(element['expirytime'] || 0).utc,
+            'active'
+        )
+      end
+    end
+  end
+end
+