smart_proxy_dns_powerdns 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7c3fb0d2793d1ed7570954bb2c235db1e700895
-  data.tar.gz: 6359e73f07094d0aebcdf1a6f90b862b969ae944
+  metadata.gz: c0bc4acefdd0c176ea6f1d9fcbb4037f36da5606
+  data.tar.gz: 4386be7b8b5d77463f91fd005a35735893fa64f4
 SHA512:
-  metadata.gz: beef8fc52fe5364a152d7de8dde2a5171898b0bf61e12b23cc16ad8e9f551b3ece9ae040b87b4e3612fc36c076ec17d87a565242668f2eeb02a15ec705ffbfae
-  data.tar.gz: 4fdc289bb30b53b9ffa2dfc7c2b8b93a561b4461757f113a7697cce92e451edf9d17c5683f03477008cd4808f5c3e3ec74bab3933d95aea5a2a98ce34ba5d9fb
+  metadata.gz: 2a4143021040bf61c3de7509fe63db0c3951cc3bc3a3f42ab8ce3f9e95777228282063801cae652de32b7e8d51e5fe9f18a61b66e5061021fc0934cf05d692b3
+  data.tar.gz: 6ef93f4db7399b45c31937ba71a5a5fbb208880a5ec503c4a3c82ff7255167850f78ce9a6f7951dc4beb6dc7e612105ac5531116da6be32c6a33140f26e2d237

data/README.md

@@ -7,7 +7,15 @@ This plugin adds a new DNS provider for managing records in PowerDNS.
 See [How_to_Install_a_Smart-Proxy_Plugin](http://projects.theforeman.org/projects/foreman/wiki/How_to_Install_a_Smart-Proxy_Plugin)
 for how to install Smart Proxy plugins
 
-This plugin is compatible with Smart Proxy 1.10 or higher.
+This plugin is compatible with Smart Proxy 1.11 or higher.
+
+When installing using "gem", make sure to install the bundle file:
+
+	echo "gem 'smart_proxy_dns_powerdns'" > /usr/share/foreman-proxy/bundler.d/dns_powerdns.rb
+
+## Upgrading
+
+Per version 0.2.0 the backend is a required parameter.
 
 ## Configuration
 
@@ -15,13 +23,25 @@ To enable this DNS provider, edit `/etc/foreman-proxy/settings.d/dns.yml` and se
 
     :use_provider: dns_powerdns
 
-Configuration options for this plugin are in `/etc/foreman-proxy/settings.d/dns_powerdns.yml` and include:
+Configuration options for this plugin are in `/etc/foreman-proxy/settings.d/dns_powerdns.yml`.
+
+### MySQL
 
+To use MySQL, set the following parameters:
+
+    :powerdns_backend: 'mysql'
     :powerdns_mysql_hostname: 'localhost'
     :powerdns_mysql_username: 'powerdns'
     :powerdns_mysql_password: ''
     :powerdns_mysql_database: 'powerdns'
 
+### PostgreSQL
+
+To use PostgreSQL, set the following parameters:
+
+    :powerdns_backend: 'postgresql'
+    :powerdns_postgresql_connection: 'host=localhost user=powerdns password=mypassword dbname=powerdns'
+
 ### DNSSEC
 
 In case you've enabled DNSSEC (as you should), a rectify-zone is required after every zone change. The pdnssec command is configurable:
@@ -38,22 +58,20 @@ Fork and send a Pull Request. Thanks!
 
 ### Running the integration tests
 
-Since I'm mostly a python developer, I've written the integration tests in python.
-
-First you need to run the smart proxy on `http://localhost:8000` and a powerdns instance on `127.0.0.1:5300` or change it in the fixtures.
+First you need to run the smart proxy on `http://localhost:8000` and a powerdns instance on `127.0.0.1:5300`.
 
 It is assumed the powerdns instance has both the `example.com` and `in-addr.arpa` domains configured. If not, create them:
 
     INSERT INTO domains (name, type) VALUES ('example.com', 'master'), ('in-addr.arpa', 'master');
     INSERT INTO records (domain_id, name, type, content) SELECT id domain_id, name, 'SOA', 'ns1.example.com hostmaster.example.com. 0 3600 1800 1209600 3600' FROM domains WHERE NOT EXISTS (SELECT 1 FROM records WHERE records.domain_id=domains.id AND records.name=domains.name AND type='SOA');
 
-Then you need to install the required dependencies (dnspython, pytest and requests). Then run the tests:
+Then run the tests:
 
-    py.test test/integration_tests.py
+    bundle exec rake test:integration
 
 ## Copyright
 
-Copyright (c) 2015 Ewoud Kohl van Wijngaarden
+Copyright (c) 2015 - 2016 Ewoud Kohl van Wijngaarden
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by

data/lib/smart_proxy_dns_powerdns/backend/dummy.rb

@@ -0,0 +1,24 @@
+module Proxy::Dns::Powerdns::Backend
+  class Dummy < ::Proxy::Dns::Powerdns::Record
+
+    def initialize(a_server = nil, a_ttl = nil)
+      super(a_server, a_ttl)
+    end
+
+    def get_zone name
+      {
+        'id'   => 1,
+        'name' => name.partition('.')[2]
+      }
+    end
+
+    def create_record domain_id, name, ttl, content, type
+      false
+    end
+
+    def delete_record domain_id, name, type
+      false
+    end
+  end
+end
+

data/lib/smart_proxy_dns_powerdns/backend/mysql.rb

@@ -0,0 +1,49 @@
+require 'mysql2'
+
+module Proxy::Dns::Powerdns::Backend
+  class Mysql < ::Proxy::Dns::Powerdns::Record
+
+    attr_reader :hostname, :username, :password, :database
+
+    def initialize(a_server = nil, a_ttl = nil)
+      @hostname = Proxy::Dns::Powerdns::Plugin.settings.powerdns_mysql_hostname || 'localhost'
+      @username = Proxy::Dns::Powerdns::Plugin.settings.powerdns_mysql_username
+      @password = Proxy::Dns::Powerdns::Plugin.settings.powerdns_mysql_password
+      @database = Proxy::Dns::Powerdns::Plugin.settings.powerdns_mysql_database
+
+      super(a_server, a_ttl)
+    end
+
+    def connection
+      @connection ||= Mysql2::Client.new(:host => hostname, :username => username, :password => password, :database => database)
+    end
+
+    def get_zone name
+      domain = nil
+
+      name = connection.escape(name)
+      connection.query("SELECT LENGTH(name) domain_length, id, name FROM domains WHERE '#{name}' LIKE CONCAT('%%.', name) ORDER BY domain_length DESC LIMIT 1").each do |row|
+        domain = row
+      end
+
+      raise Proxy::Dns::Error, "Unable to determine zone. Zone must exist in PowerDNS." unless domain
+
+      domain
+    end
+
+    def create_record domain_id, name, type, content
+      name = connection.escape(name)
+      content = connection.escape(content)
+      type = connection.escape(type)
+      connection.query("INSERT INTO records (domain_id, name, ttl, content, type) VALUES (#{domain_id}, '#{name}', #{ttl.to_i}, '#{content}', '#{type}')")
+      connection.affected_rows == 1
+    end
+
+    def delete_record domain_id, name, type
+      name = connection.escape(name)
+      type = connection.escape(type)
+      connection.query("DELETE FROM records WHERE domain_id=#{domain_id} AND name='#{name}' AND type='#{type}'")
+      connection.affected_rows == 1
+    end
+  end
+end

data/lib/smart_proxy_dns_powerdns/backend/postgresql.rb

@@ -0,0 +1,42 @@
+require 'pg'
+
+module Proxy::Dns::Powerdns::Backend
+  class Postgresql < ::Proxy::Dns::Powerdns::Record
+
+    attr_reader :connection_str
+
+    def initialize(a_server = nil, a_ttl = nil)
+      @connection_str = Proxy::Dns::Powerdns::Plugin.settings.powerdns_postgresql_connection
+
+      super(a_server, a_ttl)
+    end
+
+    def connection
+      @connection ||= PG.connect(connection_str)
+    end
+
+    def get_zone name
+      domain = nil
+
+      connection.exec_params("SELECT LENGTH(name) domain_length, id, name FROM domains WHERE $1 LIKE CONCAT('%%.', name) ORDER BY domain_length DESC LIMIT 1", [name]) do |result|
+        result.each do |row|
+          domain = row
+        end
+      end
+
+      raise Proxy::Dns::Error, "Unable to determine zone. Zone must exist in PowerDNS." unless domain
+
+      domain
+    end
+
+    def create_record domain_id, name, type, content
+      result = connection.exec_params("INSERT INTO records (domain_id, name, ttl, content, type) VALUES ($1::int, $2, $3::int, $4, $5)", [domain_id, name, ttl, content, type])
+      result.cmdtuples == 1
+    end
+
+    def delete_record domain_id, name, type
+      result = connection.exec_params("DELETE FROM records WHERE domain_id=$1::int AND name=$2 AND type=$3", [domain_id, name, type])
+      result.cmdtuples == 1
+    end
+  end
+end

data/lib/smart_proxy_dns_powerdns/dependencies.rb

@@ -0,0 +1,15 @@
+require 'dns_common/dependency_injection/dependencies'
+
+class Proxy::Dns::DependencyInjection::Dependencies
+  case Proxy::Dns::Powerdns::Plugin.settings.powerdns_backend
+  when 'mysql'
+    require 'smart_proxy_dns_powerdns/backend/mysql'
+    dependency :dns_provider, Proxy::Dns::Powerdns::Backend::Mysql
+  when 'postgresql'
+    require 'smart_proxy_dns_powerdns/backend/postgresql'
+    dependency :dns_provider, Proxy::Dns::Powerdns::Backend::Postgresql
+  when 'dummy'
+    require 'smart_proxy_dns_powerdns/backend/dummy'
+    dependency :dns_provider, Proxy::Dns::Powerdns::Backend::Dummy
+  end
+end

data/lib/smart_proxy_dns_powerdns/dns_powerdns_configuration_validator.rb

@@ -0,0 +1,32 @@
+require 'smart_proxy_dns_powerdns/dns_powerdns_plugin'
+
+module Proxy::Dns::Powerdns
+  class ConfigurationValidator
+    def validate_settings!(settings)
+      validate_choice(settings, :powerdns_backend, ['mysql', 'postgresql', 'dummy'])
+
+      case settings.powerdns_backend
+      when 'mysql'
+        validate_presence(settings, [:powerdns_mysql_username, :powerdns_mysql_password, :powerdns_mysql_database])
+      when 'postgresql'
+        validate_presence(settings, [:powerdns_postgresql_connection])
+      end
+    end
+
+    def validate_choice(settings, setting, choices)
+      value = settings.send(setting)
+      unless choices.include?(value)
+        raise ::Proxy::Error::ConfigurationError, "Parameter '#{setting}' is expected to be one of #{choices.join(",")}"
+      end
+      true
+    end
+
+    def validate_presence(settings, names)
+      names.each do |name|
+        value = settings.send(name)
+        raise ::Proxy::Error::ConfigurationError, "Parameter '#{name}' is expected to have a non-empty value" if value.nil? || value.to_s.empty?
+      end
+      true
+    end
+  end
+end

data/lib/smart_proxy_dns_powerdns/dns_powerdns_main.rb

@@ -1,120 +1,73 @@
 require 'dns/dns'
+require 'dns_common/dns_common'
 require 'ipaddr'
-require 'mysql2'
 
 module Proxy::Dns::Powerdns
   class Record < ::Proxy::Dns::Record
     include Proxy::Log
     include Proxy::Util
 
-    attr_reader :mysql_connection, :powerdns_pdnssec
+    attr_reader :pdnssec
 
-    def self.record(attrs = {})
-      new(attrs.merge(
-        :powerdns_mysql_hostname => ::Proxy::Dns::Powerdns::Plugin.settings.powerdns_mysql_hostname,
-        :powerdns_mysql_username => ::Proxy::Dns::Powerdns::Plugin.settings.powerdns_mysql_username,
-        :powerdns_mysql_password => ::Proxy::Dns::Powerdns::Plugin.settings.powerdns_mysql_password,
-        :powerdns_mysql_database => ::Proxy::Dns::Powerdns::Plugin.settings.powerdns_mysql_database,
-        :powerdns_pdnssec => ::Proxy::Dns::Powerdns::Plugin.settings.powerdns_pdnssec
-      ))
+    def initialize(a_server = nil, a_ttl = nil)
+      @pdnssec = Proxy::Dns::Powerdns::Plugin.settings.powerdns_pdnssec
+      super(a_server, a_ttl || Proxy::Dns::Plugin.settings.dns_ttl)
     end
 
-    def initialize options = {}
-      raise "dns_powerdns provider needs 'powerdns_mysql_hostname' option" unless options[:powerdns_mysql_hostname]
-      raise "dns_powerdns provider needs 'powerdns_mysql_username' option" unless options[:powerdns_mysql_username]
-      raise "dns_powerdns provider needs 'powerdns_mysql_password' option" unless options[:powerdns_mysql_password]
-      raise "dns_powerdns provider needs 'powerdns_mysql_database' option" unless options[:powerdns_mysql_database]
-      @mysql_connection = Mysql2::Client.new(
-        :host => options[:powerdns_mysql_hostname],
-        :username => options[:powerdns_mysql_username],
-        :password => options[:powerdns_mysql_password],
-        :database => options[:powerdns_mysql_database]
-      )
-
-      @powerdns_pdnssec = options[:powerdns_pdnssec] || false
-
-      # Normalize the somewhat weird PTR API spec to name / content
-      case options[:type]
-      when "PTR"
-        if options[:value] =~ /\.(in-addr|ip6)\.arpa$/
-          @name = options[:value]
-        else
-          @name = IPAddr.new(options[:value]).reverse
-        end
-        @content = options[:fqdn]
-      else
-        @name = options[:fqdn]
-        @content = options[:value]
+    def create_a_record(fqdn, ip)
+      if found = dns_find(fqdn)
+        raise Proxy::Dns::Collision, "#{fqdn} is already in use by #{ip}" unless found == ip
       end
 
-      super(options)
+      do_create(fqdn, ip, "A")
     end
 
-    def create
-      domain_row = domain
-      raise Proxy::Dns::Error, "Unable to determine zone. Zone must exist in PowerDNS." unless domain_row
-
-      if ip = dns_find(domain_row['id'], @name)
-        raise Proxy::Dns::Collision, "#{@name} is already in use by #{ip}"
+    def create_ptr_record(fqdn, ip)
+      if found = dns_find(ip)
+        raise Proxy::Dns::Collision, "#{ip} is already in use by #{found}" unless found == fqdn
       end
 
-      create_record(domain_row['id'], @name, @ttl, @content, @type)
-
-      rectify_zone(domain_row['name'])
+      name = IPAddr.new(ip).reverse
+      do_create(name, fqdn, "PTR")
     end
 
-    def remove
-      domain_row = domain
-      raise Proxy::Dns::Error, "Unable to determine zone. Zone must exist in PowerDNS." unless domain_row
-
-      delete_record(domain_row['id'], @name, @type)
-
-      rectify_zone(domain_row['name'])
+    def do_create(name, value, type)
+      zone = get_zone(name)
+      create_record(zone['id'], name, type, value) and rectify_zone(zone['name'])
     end
 
-    private
-    def domain
-      domain = nil
+    def remove_a_record(fqdn)
+      do_remove(fqdn, "A")
+    end
 
-      name = mysql_connection.escape(@name)
-      mysql_connection.query("SELECT LENGTH(name) domain_length, id, name FROM domains WHERE '#{name}' LIKE CONCAT('%%.', name) ORDER BY domain_length DESC LIMIT 1").each do |row|
-        domain = row
-      end
+    def remove_ptr_record(ip)
+      name = ip # Note ip is already in-addr.arpa
+      do_remove(name, "PTR")
+    end
 
-      domain
+    def do_remove(name, type)
+      zone = get_zone(name)
+      delete_record(zone['id'], name, type) and rectify_zone(zone['name'])
     end
 
-    private
-    def dns_find domain_id, key
-      value = nil
-      key = mysql_connection.escape(key)
-      mysql_connection.query("SELECT content FROM records WHERE domain_id=#{domain_id} AND name = '#{key}' LIMIT 1").each do |row|
-        value = row["content"]
-      end
-      value || false
+    def get_zone(fqdn)
+      # TODO: backend specific
+      raise Proxy::Dns::Error, "Unable to determine zone. Zone must exist in PowerDNS."
     end
 
-    private
-    def create_record domain_id, name, ttl, content, type
-      name = mysql_connection.escape(name)
-      content = mysql_connection.escape(content)
-      type = mysql_connection.escape(type)
-      mysql_connection.query("INSERT INTO records (domain_id, name, ttl, content, type) VALUES (#{domain_id}, '#{name}', #{ttl.to_i}, '#{content}', '#{type}')")
-      true
+    def create_record(domain_id, name, type, content)
+      # TODO: backend specific
+      false
     end
 
-    private
-    def delete_record domain_id, name, type
-      name = mysql_connection.escape(name)
-      type = mysql_connection.escape(type)
-      mysql_connection.query("DELETE FROM records WHERE domain_id=#{domain_id} AND name='#{name}' AND type='#{type}'")
-      true
+    def delete_record(domain_id, name, type)
+      # TODO: backend specific
+      false
     end
 
-    private
     def rectify_zone domain
-      if @powerdns_pdnssec
-        %x(#{@powerdns_pdnssec} rectify-zone "#{domain}")
+      if @pdnssec
+        %x(#{@pdnssec} rectify-zone "#{domain}")
 
         $?.exitstatus == 0
       else

data/lib/smart_proxy_dns_powerdns/dns_powerdns_plugin.rb

@@ -2,13 +2,18 @@ require 'smart_proxy_dns_powerdns/dns_powerdns_version'
 
 module Proxy::Dns::Powerdns
   class Plugin < ::Proxy::Provider
-    plugin :dns_powerdns, ::Proxy::Dns::Powerdns::VERSION,
-           :factory => proc { |attrs| ::Proxy::Dns::Powerdns::Record.record(attrs) }
+    plugin :dns_powerdns, ::Proxy::Dns::Powerdns::VERSION
 
-    requires :dns, '>= 1.10'
+    requires :dns, '>= 1.11'
+
+    validate_presence :powerdns_backend
 
     after_activation do
+      require 'smart_proxy_dns_powerdns/dns_powerdns_configuration_validator'
+      ::Proxy::Dns::Powerdns::ConfigurationValidator.new.validate_settings!(settings)
+
       require 'smart_proxy_dns_powerdns/dns_powerdns_main'
+      require 'smart_proxy_dns_powerdns/dependencies'
     end
   end
 end

data/lib/smart_proxy_dns_powerdns/dns_powerdns_version.rb

@@ -1,7 +1,7 @@
 module Proxy
   module Dns
     module Powerdns
-      VERSION = '0.1.0'
+      VERSION = '0.2.0'
     end
   end
 end

data/test/integration/integration_test.rb

@@ -0,0 +1,83 @@
+require 'test_helper'
+
+require 'ipaddr'
+require 'net/http'
+
+class DnsPowerdnsIntegrationTest < Test::Unit::TestCase
+
+  def test_forward_dns
+    data = {'fqdn' => fqdn, 'value' => ip, 'type' => 'A'}
+
+    uri = URI(smart_proxy_url)
+
+    Net::HTTP.start(uri.host, uri.port) do |http|
+      request = Net::HTTP::Post.new(smart_proxy_url + 'dns/')
+      request.form_data = data
+      response = http.request request
+      assert_equal(200, response.code.to_i)
+
+      addresses = resolver.getaddresses(data['fqdn'])
+      assert_equal([Resolv::IPv4.create(data['value'])], addresses, "#{data['fqdn']} should resolve to #{data['value']}")
+
+      request = Net::HTTP::Delete.new(smart_proxy_url + 'dns/' + data['fqdn'])
+      response = http.request request
+      assert_equal(200, response.code.to_i)
+
+      assert(purge_cache data['fqdn'])
+
+      addresses = resolver.getaddresses(data['fqdn'])
+      assert_equal([], addresses)
+    end
+  end
+
+  def test_reverse_dns
+    data = {'fqdn' => fqdn, 'value' => ip, 'type' => 'PTR'}
+
+    uri = URI(smart_proxy_url)
+
+    Net::HTTP.start(uri.host, uri.port) do |http|
+      request = Net::HTTP::Post.new(smart_proxy_url + 'dns/')
+      request.form_data = data
+      response = http.request request
+      assert_equal(200, response.code.to_i)
+
+      name = Resolv::IPv4.create(data['value']).to_name.to_s
+
+      addresses = resolver.getnames(data['value'])
+      assert_equal([Resolv::DNS::Name.create(data['fqdn'] + '.')], addresses, "#{data['value']} should reverse to #{data['fqdn']}")
+
+      request = Net::HTTP::Delete.new(smart_proxy_url + 'dns/' + name)
+      response = http.request request
+      assert_equal(200, response.code.to_i)
+
+      assert(purge_cache name)
+
+      addresses = resolver.getnames(data['value'])
+      assert_equal([], addresses)
+    end
+  end
+
+  private
+
+  def resolver
+    Resolv::DNS.new(:nameserver_port => [['127.0.0.1', 5300]])
+  end
+
+  def smart_proxy_url
+    'http://localhost:8000/'
+  end
+
+  def fqdn
+    set = ('a' .. 'z').to_a + ('0' .. '9').to_a
+    10.times.collect {|i| set[rand(set.size)] }.join + '.example.com'
+  end
+
+  def ip
+    IPAddr.new(rand(2 ** 32), Socket::AF_INET).to_s
+  end
+
+  def purge_cache name
+    %x{#{ENV['PDNS_CONTROL'] || "pdns_control"} purge "#{name}"}
+    $? == 0
+  end
+end

data/test/unit/dns_powerdns_configuration_validator_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+require 'ostruct'
+
+require 'smart_proxy_dns_powerdns/dns_powerdns_plugin'
+require 'smart_proxy_dns_powerdns/dns_powerdns_configuration_validator'
+
+class DnsPowerdnsConfigurationValidatorTest < Test::Unit::TestCase
+  def setup
+    @config_validator = Proxy::Dns::Powerdns::ConfigurationValidator.new
+  end
+
+  def test_initialize_missing_backend
+    settings = OpenStruct.new(:dns_provider => 'powerdns', :powerdns_backend => nil)
+
+    assert_raise Proxy::Error::ConfigurationError do
+      @config_validator.validate_settings!(settings)
+    end
+  end
+
+  def test_initialize_invalid_backend
+    settings = OpenStruct.new(:dns_provider => 'powerdns', :powerdns_backend => 'invalid')
+
+    assert_raise Proxy::Error::ConfigurationError do
+      @config_validator.validate_settings!(settings)
+    end
+  end
+
+  def test_initialize_dummy_with_settings
+    settings = OpenStruct.new(:dns_provider => 'powerdns', :powerdns_backend => 'dummy')
+
+    assert_nothing_raised do
+      @config_validator.validate_settings!(settings)
+    end
+  end
+
+  def test_initialize_mysql_without_settings
+    settings = OpenStruct.new(:dns_provider => 'powerdns', :powerdns_backend => 'mysql')
+
+    assert_raise Proxy::Error::ConfigurationError do
+      @config_validator.validate_settings!(settings)
+    end
+  end
+
+  def test_initialize_mysql_with_settings
+    settings = OpenStruct.new(
+      :dns_provider => 'powerdns',
+      :powerdns_backend => 'mysql',
+      :powerdns_mysql_hostname => 'localhost',
+      :powerdns_mysql_username => 'username',
+      :powerdns_mysql_password => 'password',
+      :powerdns_mysql_database => 'powerdns'
+    )
+
+    assert_nothing_raised do
+      @config_validator.validate_settings!(settings)
+    end
+  end
+
+  def test_initialize_postgresql_without_settings
+    settings = OpenStruct.new(:dns_provider => 'powerdns', :powerdns_backend => 'postgresql')
+
+    assert_raise Proxy::Error::ConfigurationError do
+      @config_validator.validate_settings!(settings)
+    end
+  end
+
+  def test_initialize_postgresql_with_settings
+    settings = OpenStruct.new(
+      :dns_provider => 'powerdns',
+      :powerdns_backend => 'postgresql',
+      :powerdns_postgresql_connection => 'dbname=powerdns'
+    )
+
+    assert_nothing_raised do
+      @config_validator.validate_settings!(settings)
+    end
+  end
+end

data/test/unit/dns_powerdns_record_mysql_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+
+require 'smart_proxy_dns_powerdns/dns_powerdns_plugin'
+require 'smart_proxy_dns_powerdns/dns_powerdns_main'
+require 'smart_proxy_dns_powerdns/backend/mysql'
+
+class DnsPowerdnsBackendMysqlTest < Test::Unit::TestCase
+  # Test that correct initialization works
+  def test_initialize_dummy_with_settings
+    Proxy::Dns::Powerdns::Plugin.load_test_settings(
+      :powerdns_mysql_hostname => 'db.example.com',
+      :powerdns_mysql_username => 'the_user',
+      :powerdns_mysql_password => 'something_secure',
+      :powerdns_mysql_database => 'db_pdns'
+    )
+    provider = klass.new
+    assert_equal 'db.example.com', provider.hostname
+    assert_equal 'the_user', provider.username
+    assert_equal 'something_secure', provider.password
+    assert_equal 'db_pdns', provider.database
+  end
+
+  def test_get_zone_with_existing_zone
+    instance = klass.new
+
+    connection = mock()
+    instance.stubs(:connection).returns(connection)
+    connection.expects(:escape).with('test.example.com').returns('test.example.com')
+    connection.expects(:query).with("SELECT LENGTH(name) domain_length, id, name FROM domains WHERE 'test.example.com' LIKE CONCAT('%%.', name) ORDER BY domain_length DESC LIMIT 1").returns([{'id' => 1, 'name' => 'example.com'}])
+
+    assert_equal(instance.get_zone('test.example.com'), {'id' => 1, 'name' => 'example.com'})
+  end
+
+  def test_get_zone_without_existing_zone
+    instance = klass.new
+
+    connection = mock()
+    instance.stubs(:connection).returns(connection)
+    connection.expects(:escape).with('test.example.com').returns('test.example.com')
+    connection.expects(:query).with("SELECT LENGTH(name) domain_length, id, name FROM domains WHERE 'test.example.com' LIKE CONCAT('%%.', name) ORDER BY domain_length DESC LIMIT 1").returns([])
+
+    assert_raise(Proxy::Dns::Error) { instance.get_zone('test.example.com') }
+  end
+
+  def test_create_record
+    instance = klass.new
+
+    connection = mock()
+    instance.stubs(:connection).returns(connection)
+    connection.expects(:escape).with('test.example.com').returns('test.example.com')
+    connection.expects(:escape).with('A').returns('A')
+    connection.expects(:escape).with('10.1.1.1').returns('10.1.1.1')
+    connection.expects(:query).with("INSERT INTO records (domain_id, name, ttl, content, type) VALUES (1, 'test.example.com', 86400, '10.1.1.1', 'A')")
+    connection.expects(:affected_rows).returns(1)
+
+    assert instance.create_record(1, 'test.example.com', 'A', '10.1.1.1')
+  end
+
+  def test_delete_record
+    instance = klass.new
+
+    connection = mock()
+    instance.stubs(:connection).returns(connection)
+    connection.expects(:escape).with('test.example.com').returns('test.example.com')
+    connection.expects(:escape).with('A').returns('A')
+    connection.expects(:query).with("DELETE FROM records WHERE domain_id=1 AND name='test.example.com' AND type='A'")
+    connection.expects(:affected_rows).returns(1)
+
+    assert instance.delete_record(1, 'test.example.com', 'A')
+  end
+
+  private
+
+  def klass
+    Proxy::Dns::Powerdns::Backend::Mysql
+  end
+end

data/test/unit/dns_powerdns_record_postgresql_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+require 'smart_proxy_dns_powerdns/dns_powerdns_plugin'
+require 'smart_proxy_dns_powerdns/dns_powerdns_main'
+require 'smart_proxy_dns_powerdns/backend/postgresql'
+
+class DnsPowerdnsBackendPostgresqlTest < Test::Unit::TestCase
+  # Test that correct initialization works
+  def test_initialize_dummy_with_settings
+    Proxy::Dns::Powerdns::Plugin.load_test_settings(:powerdns_postgresql_connection => 'dbname=powerdns')
+    provider = klass.new
+    assert_equal 'dbname=powerdns', provider.connection_str
+  end
+
+  private
+
+  def klass
+    Proxy::Dns::Powerdns::Backend::Postgresql
+  end
+end

data/test/unit/dns_powerdns_record_test.rb

@@ -0,0 +1,115 @@
+require 'test_helper'
+
+require 'smart_proxy_dns_powerdns/dns_powerdns_plugin'
+require 'smart_proxy_dns_powerdns/dns_powerdns_main'
+
+class DnsPowerdnsRecordTest < Test::Unit::TestCase
+  # Test that correct initialization works
+  def test_initialize_dummy_with_settings
+    Proxy::Dns::Powerdns::Plugin.load_test_settings(:powerdns_pdnssec => 'sudo pdnssec')
+    provider = klass.new
+    assert_equal 'sudo pdnssec', provider.pdnssec
+  end
+
+  # Test A record creation
+  def test_create_a
+    instance = klass.new
+
+    instance.expects(:dns_find).with('test.example.com').returns(false)
+    instance.expects(:get_zone).with('test.example.com').returns({'id' => 1, 'name' => 'example.com'})
+    instance.expects(:create_record).with(1, 'test.example.com', 'A', '10.1.1.1').returns(true)
+    instance.expects(:rectify_zone).with('example.com').returns(true)
+
+    assert instance.create_a_record(fqdn, ip)
+  end
+
+  # Test A record creation fails if the record exists
+  def test_create_a_conflict
+    instance = klass.new
+
+    instance.expects(:dns_find).with('test.example.com').returns('192.168.1.1')
+
+    assert_raise(Proxy::Dns::Collision) { instance.create_a_record(fqdn, ip) }
+  end
+
+  # Test PTR record creation
+  def test_create_ptr
+    instance = klass.new
+
+    instance.expects(:dns_find).with('10.1.1.1').returns(false)
+    instance.expects(:get_zone).with('1.1.1.10.in-addr.arpa').returns({'id' => 1, 'name' => '1.1.10.in-addr.arpa'})
+    instance.expects(:create_record).with(1, '1.1.1.10.in-addr.arpa', 'PTR', 'test.example.com').returns(true)
+    instance.expects(:rectify_zone).with('1.1.10.in-addr.arpa').returns(true)
+
+    assert instance.create_ptr_record(fqdn, ip)
+  end
+
+  # Test PTR record creation fails if the record exists
+  def test_create_ptr_conflict
+    instance = klass.new
+
+    instance.expects(:dns_find).with('10.1.1.1').returns('test2.example.com')
+
+    assert_raise(Proxy::Dns::Collision) { instance.create_ptr_record(fqdn, ip) }
+  end
+
+  # Test A record removal
+  def test_remove_a
+    instance = klass.new
+
+    instance.expects(:get_zone).with('test.example.com').returns({'id' => 1, 'name' => 'example.com'})
+    instance.expects(:delete_record).with(1, 'test.example.com', 'A').returns(true)
+    instance.expects(:rectify_zone).with('example.com').returns(true)
+
+    assert instance.remove_a_record(fqdn)
+  end
+
+  # Test PTR record removal
+  def test_remove_ptr
+    instance = klass.new
+
+    instance.expects(:get_zone).with('1.1.1.10.in-addr.arpa').returns({'id' => 1, 'name' => '1.1.10.in-addr.arpa'})
+    instance.expects(:delete_record).with(1, '1.1.1.10.in-addr.arpa', 'PTR').returns(true)
+    instance.expects(:rectify_zone).with('1.1.10.in-addr.arpa').returns(true)
+
+    assert instance.remove_ptr_record(reverse_ip)
+  end
+
+  def test_do_create
+    instance = klass.new
+
+    instance.expects(:get_zone).with('test.example.com').returns({'id' => 1, 'name' => 'example.com'})
+    instance.expects(:create_record).with(1, 'test.example.com', 'A', '10.1.1.1').returns(true)
+    instance.expects(:rectify_zone).with('example.com').returns(true)
+
+    assert instance.do_create('test.example.com', '10.1.1.1', 'A')
+  end
+
+  def test_do_remove
+    instance = klass.new
+
+    instance.expects(:get_zone).with('test.example.com').returns({'id' => 1, 'name' => 'example.com'})
+    instance.expects(:delete_record).with(1, 'test.example.com', 'A').returns(true)
+    instance.expects(:rectify_zone).with('example.com').returns(true)
+
+    assert instance.do_remove('test.example.com', 'A')
+  end
+
+  private
+
+  def klass
+    Proxy::Dns::Powerdns::Record
+  end
+
+  def fqdn
+    'test.example.com'
+  end
+
+  def ip
+    '10.1.1.1'
+  end
+
+  def reverse_ip
+    '1.1.1.10.in-addr.arpa'
+  end
+end

metadata

@@ -1,55 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dns_powerdns
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ewoud Kohl van Wijngaarden
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-08 00:00:00.000000000 Z
+date: 2016-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: mysql2
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: PowerDNS DNS provider plugin for Foreman's smart proxy
@@ -64,12 +78,20 @@ files:
 - bundler.d/dns_powerdns.rb
 - config/dns_powerdns.yml
 - lib/smart_proxy_dns_powerdns.rb
+- lib/smart_proxy_dns_powerdns/backend/dummy.rb
+- lib/smart_proxy_dns_powerdns/backend/mysql.rb
+- lib/smart_proxy_dns_powerdns/backend/postgresql.rb
+- lib/smart_proxy_dns_powerdns/dependencies.rb
+- lib/smart_proxy_dns_powerdns/dns_powerdns_configuration_validator.rb
 - lib/smart_proxy_dns_powerdns/dns_powerdns_main.rb
 - lib/smart_proxy_dns_powerdns/dns_powerdns_plugin.rb
 - lib/smart_proxy_dns_powerdns/dns_powerdns_version.rb
-- test/dns_powerdns_record_test.rb
-- test/integration_tests.py
+- test/integration/integration_test.rb
 - test/test_helper.rb
+- test/unit/dns_powerdns_configuration_validator_test.rb
+- test/unit/dns_powerdns_record_mysql_test.rb
+- test/unit/dns_powerdns_record_postgresql_test.rb
+- test/unit/dns_powerdns_record_test.rb
 homepage: https://github.com/theforeman/smart_proxy_dns_powerdns
 licenses:
 - GPLv3
@@ -80,12 +102,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
@@ -96,5 +118,8 @@ specification_version: 4
 summary: PowerDNS DNS provider plugin for Foreman's smart proxy
 test_files:
 - test/test_helper.rb
-- test/dns_powerdns_record_test.rb
-- test/integration_tests.py
+- test/integration/integration_test.rb
+- test/unit/dns_powerdns_record_postgresql_test.rb
+- test/unit/dns_powerdns_configuration_validator_test.rb
+- test/unit/dns_powerdns_record_mysql_test.rb
+- test/unit/dns_powerdns_record_test.rb

data/test/dns_powerdns_record_test.rb

@@ -1,121 +0,0 @@
-require 'test_helper'
-
-require 'smart_proxy_dns_powerdns/dns_powerdns_main'
-
-class DnsPowerdnsRecordTest < Test::Unit::TestCase
-  # Test that a missing :powerdns_mysql_hostname throws an error
-  def test_initialize_without_settings
-    assert_raise(RuntimeError) do
-      klass.new(settings.delete_if { |k,v| k == :powerdns_mysql_hostname })
-    end
-  end
-
-  # Test that correct initialization works
-  def test_initialize_with_settings
-    assert_nothing_raised do
-      mock_mysql
-
-      klass.new(settings)
-    end
-  end
-
-  # Test A record creation
-  def test_create_a
-    mock_mysql
-
-    instance = klass.new(settings)
-
-    instance.expects(:domain).returns({'id' => 1})
-    instance.expects(:dns_find).with(1, 'test.example.com').returns(false)
-    instance.expects(:create_record).with(1, 'test.example.com', 84600, '10.1.1.1', 'A').returns(true)
-
-    assert instance.create
-  end
-
-  # Test A record creation fails if the record exists
-  def test_create_a_conflict
-    mock_mysql
-
-    instance = klass.new(settings)
-
-    instance.expects(:domain).returns({'id' => 1})
-    instance.expects(:dns_find).with(1, 'test.example.com').returns('192.168.1.1')
-
-    assert_raise(Proxy::Dns::Collision) { instance.create }
-  end
-
-  # Test PTR record creation
-  def test_create_ptr
-    mock_mysql
-
-    instance = klass.new(settings.merge(:type => 'PTR'))
-
-    instance.expects(:domain).returns({'id' => 1, 'name' => 'example.com'})
-    instance.expects(:dns_find).with(1, '1.1.1.10.in-addr.arpa').returns(false)
-    instance.expects(:create_record).with(1, '1.1.1.10.in-addr.arpa', 84600, 'test.example.com', 'PTR').returns(true)
-    instance.expects(:rectify_zone).with('example.com').returns(true)
-
-    assert instance.create
-  end
-
-  # Test PTR record creation fails if the record exists
-  def test_create_ptr_conflict
-    mock_mysql
-
-    instance = klass.new(settings.merge(:type => 'PTR'))
-
-    instance.expects(:domain).returns({'id' => 1, 'name' => '1.1.10.in-addr.arpa'})
-    instance.expects(:dns_find).with(1, '1.1.1.10.in-addr.arpa').returns('test2.example.com')
-
-    assert_raise(Proxy::Dns::Collision) { instance.create }
-  end
-
-  # Test A record removal
-  def test_remove_a
-    mock_mysql
-
-    instance = klass.new(settings)
-
-    instance.expects(:domain).returns({'id' => 1, 'name' => 'example.com'})
-    instance.expects(:delete_record).with(1, 'test.example.com', 'A').returns(true)
-    instance.expects(:rectify_zone).with('example.com').returns(true)
-
-    assert instance.remove
-  end
-
-  # Test PTR record removal
-  def test_remove_ptr
-    mock_mysql
-
-    instance = klass.new(settings.merge(:type => 'PTR'))
-
-    instance.expects(:domain).returns({'id' => 1, 'name' => '1.1.10.in-addr.arpa'})
-    instance.expects(:delete_record).with(1, '1.1.1.10.in-addr.arpa', 'PTR').returns(true)
-    instance.expects(:rectify_zone).with('1.1.10.in-addr.arpa').returns(true)
-
-    assert instance.remove
-  end
-
-  def mock_mysql
-    Mysql2::Client.expects(:new).with(:host => 'localhost', :username => 'username', :password => 'password', :database => 'powerdns').returns(false)
-  end
-
-  private
-
-  def klass
-    Proxy::Dns::Powerdns::Record
-  end
-
-  def settings
-    {
-      :powerdns_mysql_hostname => 'localhost',
-      :powerdns_mysql_username => 'username',
-      :powerdns_mysql_password => 'password',
-      :powerdns_mysql_database => 'powerdns',
-      :fqdn => 'test.example.com',
-      :value => '10.1.1.1',
-      :type => 'A',
-      :ttl => 84600,
-    }
-  end
-end

data/test/integration_tests.py

@@ -1,79 +0,0 @@
-#!/usr/bin/env python
-import dns.resolver
-import dns.reversename
-import pytest
-import random
-import requests
-import socket
-import string
-import struct
-import subprocess
-
-
-@pytest.fixture
-def resolver():
-    """
-    Return a resolver object against the configured powerdns server
-    """
-    resolver = dns.resolver.Resolver(configure=False)
-    resolver.nameservers = ['127.0.0.1']
-    resolver.port = 5300
-
-    return resolver
-
-
-@pytest.fixture
-def smart_proxy_url():
-    return 'http://localhost:8000/'
-
-
-@pytest.fixture
-def fqdn():
-    return ''.join(random.sample(string.lowercase, 10)) + '.' + 'example.com'
-
-
-@pytest.fixture
-def ip():
-    return socket.inet_ntoa(struct.pack("!I", random.randint(1, 2 ** 32)))
-
-
-def purge_cache(name):
-    subprocess.check_output(['sudo', 'pdns_control', 'purge', name])
-
-
-def test_forward_dns(resolver, smart_proxy_url, fqdn, ip):
-    response = requests.post(smart_proxy_url + 'dns/',
-                             data={'fqdn': fqdn, 'value': ip, 'type': 'A'})
-    response.raise_for_status()
-
-    answer = resolver.query(fqdn, 'A')
-    assert len(answer.rrset.items) == 1
-    assert answer.rrset.items[0].address == ip
-
-    response = requests.delete(smart_proxy_url + 'dns/' + fqdn)
-    response.raise_for_status()
-
-    purge_cache(fqdn)
-
-    with pytest.raises(dns.resolver.NXDOMAIN):
-        resolver.query(fqdn, 'A')
-
-
-def test_reverse_dns(resolver, smart_proxy_url, fqdn, ip):
-    response = requests.post(smart_proxy_url + 'dns/',
-                             data={'fqdn': fqdn, 'value': ip, 'type': 'PTR'})
-    response.raise_for_status()
-
-    name = dns.reversename.from_address(ip)
-
-    answer = resolver.query(name, 'PTR')
-    assert len(answer.rrset.items) == 1
-    assert answer.rrset.items[0].target.to_text() == fqdn + '.'
-
-    response = requests.delete(smart_proxy_url + 'dns/' + name.to_text().rstrip('.'))
-    response.raise_for_status()
-
-    purge_cache(name.to_text())
-
-    with pytest.raises(dns.resolver.NXDOMAIN):
-        resolver.query(name, 'PTR')