smart_proxy_dns_powerdns 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5915405ebcc666b7bea1a17d2422b0209e25c140
-  data.tar.gz: 51643c7ca288e9af25a0f3df8fd209b631098b48
+  metadata.gz: 6aef9bd6276d31444fab893bb884ccc663820cba
+  data.tar.gz: e17f14a05adef3c63ec53c0d8f131a3668f962dd
 SHA512:
-  metadata.gz: 6e56cf914dbf2dce5334691d4bf332cf272c47e859402b202453f8998b90a6e993def0a38ca865f7906167d7769c94120b38f7efcf5842dd44a1fcdd583bc75c
-  data.tar.gz: 40b5f8ebac73a321889d4f7e3edeb3e24f25050a4972df7d9a81f7e6ede6fb0ef08cd2c002e62561fd5d9c9cb8f5fb6f67abb571821139e8c3f8cefaadc1972a
+  metadata.gz: ebf9237f705434eec15aa56008f4819270e7134816433fba310da2b5daa80574a7065f249fd848b32f612dc12a87917f14f6e9eb0743751b83dfa79c16252ca7
+  data.tar.gz: 4aae6514df432f499f87998e9c84a0ec1b4964146073bb9b59d60770d3f058b7d0cc8636762d0c7868bde48c674d1797c474c87a54069e2c1ac15938adbcb386

data/README.md

@@ -1,5 +1,9 @@
 # SmartProxyDnsPowerdns
 
+[![Gem Version](https://badge.fury.io/rb/smart_proxy_dns_powerdns.svg)](https://badge.fury.io/rb/smart_proxy_dns_powerdns)
+[![Build Status](https://travis-ci.org/theforeman/smart_proxy_dns_powerdns.svg?branch=master)](https://travis-ci.org/theforeman/smart_proxy_dns_powerdns)
+[![Coverage Status](https://coveralls.io/repos/github/theforeman/smart_proxy_dns_powerdns/badge.svg?branch=master)](https://coveralls.io/github/theforeman/smart_proxy_dns_powerdns?branch=master)
+
 This plugin adds a new DNS provider for managing records in PowerDNS.
 
 ## Installation
@@ -7,7 +11,7 @@ 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.11 or higher.
+This plugin is compatible with Smart Proxy 1.13 or higher.
 
 When installing using "gem", make sure to install the bundle file:
 
@@ -15,7 +19,14 @@ When installing using "gem", make sure to install the bundle file:
 
 ## Upgrading
 
-Per version 0.2.0 the backend is a required parameter.
+### 0.3.0
+
+* The minimum Smart Proxy version is now 1.13
+* The REST backend is now the preferred backend. Users are encouraged to use it.
+
+### 0.2.0
+
+* The backend is a required parameter.
 
 ## Configuration
 
@@ -25,6 +36,16 @@ To enable this DNS provider, edit `/etc/foreman-proxy/settings.d/dns.yml` and se
 
 Configuration options for this plugin are in `/etc/foreman-proxy/settings.d/dns_powerdns.yml`.
 
+### REST
+
+To use the REST backend, set the following parameters:
+
+    :powerdns_backend: 'rest'
+    :powerdns_rest_url: 'http://localhost:8081/api/v1/servers/localhost'
+    :powerdns_rest_api_key: 'apikey'
+
+Note the API is only tested with 4.x. Older versions may work, but they can also break.
+
 ### MySQL
 
 To use MySQL, set the following parameters:
@@ -42,9 +63,9 @@ To use PostgreSQL, set the following parameters:
     :powerdns_backend: 'postgresql'
     :powerdns_postgresql_connection: 'host=localhost user=powerdns password=mypassword dbname=powerdns'
 
-### DNSSEC
+### DNSSEC with MySQL and PostgreSQL
 
-In case you've enabled DNSSEC (as you should), a rectify-zone is required after every zone change. The pdnssec command is configurable:
+In case you've enabled DNSSEC (as you should), all database backends require a rectify-zone after every zone change. The REST backend ignores this setting. The pdnssec command is configurable:
 
     :powerdns_pdnssec: 'pdnssec'
 
@@ -52,6 +73,8 @@ Or a more complex example:
 
     :powerdns_pdnssec: 'sudo pdnssec --config-name=myconfig'
 
+Note that PowerDNS 4.x now uses `pdnsutil` rather than `pdnssec`.
+
 ## Contributing
 
 Fork and send a Pull Request. Thanks!

data/lib/smart_proxy_dns_powerdns/backend/dummy.rb

@@ -1,7 +1,7 @@
 module Proxy::Dns::Powerdns::Backend
   class Dummy < ::Proxy::Dns::Powerdns::Record
 
-    def initialize(a_server = nil, a_ttl = nil)
+    def initialize(a_server, a_ttl)
       super(a_server, a_ttl)
     end
 
@@ -12,7 +12,7 @@ module Proxy::Dns::Powerdns::Backend
       }
     end
 
-    def create_record domain_id, name, ttl, content, type
+    def create_record domain_id, name, content, type
       false
     end
 

data/lib/smart_proxy_dns_powerdns/backend/mysql.rb

@@ -5,13 +5,13 @@ module Proxy::Dns::Powerdns::Backend
 
     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
+    def initialize(a_server, a_ttl, pdnssec, hostname, username, password, database)
+      @hostname = hostname
+      @username = username
+      @password = password
+      @database = database
 
-      super(a_server, a_ttl)
+      super(a_server, a_ttl, pdnssec)
     end
 
     def connection
@@ -43,7 +43,7 @@ module Proxy::Dns::Powerdns::Backend
       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
+      connection.affected_rows >= 1
     end
   end
 end

data/lib/smart_proxy_dns_powerdns/backend/postgresql.rb

@@ -5,10 +5,10 @@ module Proxy::Dns::Powerdns::Backend
 
     attr_reader :connection_str
 
-    def initialize(a_server = nil, a_ttl = nil)
-      @connection_str = Proxy::Dns::Powerdns::Plugin.settings.powerdns_postgresql_connection
+    def initialize(a_server, a_ttl, pdnssec, connection)
+      @connection_str = connection
 
-      super(a_server, a_ttl)
+      super(a_server, a_ttl, pdnssec)
     end
 
     def connection
@@ -36,7 +36,7 @@ module Proxy::Dns::Powerdns::Backend
 
     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
+      result.cmdtuples >= 1
     end
   end
 end

data/lib/smart_proxy_dns_powerdns/backend/rest.rb

@@ -0,0 +1,97 @@
+require 'json'
+require 'net/http'
+require 'resolv'
+
+module Proxy::Dns::Powerdns::Backend
+  extend ::Proxy::Log
+
+  class Rest < ::Proxy::Dns::Powerdns::Record
+
+    attr_reader :url, :api_key
+
+    def initialize(a_server, a_ttl, url, api_key)
+      @url = url
+      @api_key = api_key
+
+      super(a_server, a_ttl)
+    end
+
+    def get_zone name
+      fqdn = Resolv::DNS::Name.create(name)
+      fqdn = Resolv::DNS::Name.create(name + '.') unless fqdn.absolute?
+      uri = URI("#{@url}/zones")
+
+      result = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
+        request = Net::HTTP::Get.new uri
+        request['X-API-Key'] = @api_key
+        response = http.request request
+        zones = JSON.parse(response.body) rescue []
+
+        zones.select { |zone|
+          domain = Resolv::DNS::Name.create(zone['name'])
+          domain == fqdn or fqdn.subdomain_of?(domain)
+        }.max_by { |zone| zone['name'].length }
+      end
+
+      raise Proxy::Dns::Error, "Unable to determine zone. Zone must exist in PowerDNS." unless result
+
+      result
+    end
+
+    def create_record domain_id, name, type, content
+      content += '.' if ['PTR', 'CNAME'].include?(type)
+      rrset = {
+        :name => name + '.',
+        :type => type,
+        :ttl => @ttl.to_i,
+        :changetype => :REPLACE,
+        :records => [
+          {
+            :content => content,
+            :disabled => false
+          }
+        ]
+      }
+
+      patch_records domain_id, rrset
+    end
+
+    def delete_record domain_id, name, type
+      rrset = {
+        :name => name + '.',
+        :type => type,
+        :changetype => :DELETE,
+        :records => []
+      }
+
+      patch_records domain_id, rrset
+    end
+
+    private
+
+    def patch_records domain_id, rrset
+      uri = URI("#{@url}/zones/#{domain_id}")
+
+      data = { :rrsets => [rrset] }
+
+      Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
+        request = Net::HTTP::Patch.new uri
+        request['X-API-Key'] = @api_key
+        request['Content-Type'] = 'application/json'
+        request.body = data.to_json
+        response = http.request request
+        unless response.is_a?(Net::HTTPSuccess)
+          begin
+            content = JSON.parse(response.body)
+          rescue
+            logger.debug "Failed to pach records for #{domain_id} with '#{rrset}': #{response.body}"
+            raise Proxy::Dns::Error.new("Failed to patch records")
+          end
+          raise Proxy::Dns::Error.new("Failed to patch records: #{content['error']}")
+        end
+      end
+
+      true
+    end
+  end
+end

data/lib/smart_proxy_dns_powerdns/dns_powerdns_configuration.rb

@@ -0,0 +1,64 @@
+module ::Proxy::Dns::Powerdns
+  class PluginConfiguration
+    def load_classes
+      require 'dns_common/dns_common'
+      require 'smart_proxy_dns_powerdns/dns_powerdns_main'
+    end
+
+    def load_dependency_injection_wirings(container_instance, settings)
+      valid_backends = ['mysql', 'postgresql', 'rest', 'dummy']
+      backend = settings[:powerdns_backend]
+      unless valid_backends.include?(backend)
+        raise ::Proxy::Error::ConfigurationError.new("Invalid backend, is expected to be mysql, postgresql, rest or dummy")
+      end
+
+      begin
+        require "smart_proxy_dns_powerdns/backend/#{backend}"
+      rescue LoadError, e
+        raise ::Proxy::Error::ConfigurationError.new("Failed to load backend #{backend}: #{e}")
+      end
+
+      case backend
+      when 'mysql'
+        container_instance.dependency :dns_provider, (lambda do
+          Proxy::Dns::Powerdns::Backend::Mysql.new(
+              settings[:dns_server],
+              settings[:dns_ttl],
+              settings[:powerdns_pdnssec],
+              settings[:powerdns_mysql_hostname] || 'localhost',
+              settings[:powerdns_mysql_username] || 'powerdns',
+              settings[:powerdns_mysql_password] || '',
+              settings[:powerdns_mysql_database] || 'pdns',
+          )
+        end)
+      when 'postgresql'
+        container_instance.dependency :dns_provider, (lambda do
+          Proxy::Dns::Powerdns::Backend::Postgresql.new(
+            settings[:dns_server],
+            settings[:dns_ttl],
+            settings[:powerdns_pdnssec],
+            settings[:powerdns_postgresql_connection] || 'dbname=pdns',
+        )
+        end)
+      when 'rest'
+        raise ::Proxy::Error::ConfigurationError.new("Setting powerdns_rest_api_key must be non-empty") unless settings[:powerdns_rest_api_key]
+
+        container_instance.dependency :dns_provider, (lambda do
+          Proxy::Dns::Powerdns::Backend::Rest.new(
+            settings[:dns_server],
+            settings[:dns_ttl],
+            settings[:powerdns_rest_url] || 'http://localhost:8081/api/v1/servers/localhost',
+            settings[:powerdns_rest_api_key],
+          )
+        end)
+      when 'dummy'
+        container_instance.dependency :dns_provider, (lambda do
+          Proxy::Dns::Powerdns::Backend::Dummy.new(
+            settings[:dns_server],
+            settings[:dns_ttl],
+          )
+        end)
+      end
+    end
+  end
+end

data/lib/smart_proxy_dns_powerdns/dns_powerdns_main.rb

@@ -1,6 +1,5 @@
 require 'dns/dns'
 require 'dns_common/dns_common'
-require 'ipaddr'
 
 module Proxy::Dns::Powerdns
   class Record < ::Proxy::Dns::Record
@@ -9,43 +8,85 @@ module Proxy::Dns::Powerdns
 
     attr_reader :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)
+    def initialize(a_server, a_ttl, pdnssec = nil)
+      @pdnssec = pdnssec
+      super(a_server, a_ttl)
     end
 
     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
+      case a_record_conflicts(fqdn, ip)
+      when 1
+        raise(Proxy::Dns::Collision, "'#{fqdn} 'is already in use")
+      when 0 then
+        return nil
+      else
+        do_create(fqdn, ip, "A")
       end
+    end
 
-      do_create(fqdn, ip, "A")
+    def create_aaaa_record(fqdn, ip)
+      case aaaa_record_conflicts(fqdn, ip)
+      when 1
+        raise(Proxy::Dns::Collision, "'#{fqdn} 'is already in use")
+      when 0 then
+        return nil
+      else
+        do_create(fqdn, ip, "AAAA")
+      end
     end
 
-    def create_ptr_record(fqdn, value)
-      if found = dns_find(value)
-        raise Proxy::Dns::Collision, "#{value} is already in use by #{found}" unless found == fqdn
+    def create_cname_record(fqdn, target)
+      case cname_record_conflicts(fqdn, target)
+      when 1 then
+        raise(Proxy::Dns::Collision, "'#{fqdn} 'is already in use")
+      when 0 then
+        return nil
+      else
+        do_create(fqdn, target, "CNAME")
       end
+    end
 
-      do_create(value, fqdn, "PTR")
+    def create_ptr_record(fqdn, ptr)
+      case ptr_record_conflicts(fqdn, ptr_to_ip(ptr))
+      when 1
+        raise(Proxy::Dns::Collision, "'#{fqdn} 'is already in use")
+      when 0 then
+        return nil
+      else
+        do_create(ptr, fqdn, "PTR")
+      end
     end
 
     def do_create(name, value, type)
       zone = get_zone(name)
-      create_record(zone['id'], name, type, value) and rectify_zone(zone['name'])
+      unless create_record(zone['id'], name, type, value) and rectify_zone(zone['name'])
+        raise Proxy::Dns::Error.new("Failed to create record #{name} #{type} #{value}")
+      end
+      true
     end
 
     def remove_a_record(fqdn)
       do_remove(fqdn, "A")
     end
 
-    def remove_ptr_record(name)
-      do_remove(name, "PTR")
+    def remove_aaaa_record(fqdn)
+      do_remove(fqdn, "AAAA")
+    end
+
+    def remove_cname_record(fqdn)
+      do_remove(fqdn, "CNAME")
+    end
+
+    def remove_ptr_record(ptr)
+      do_remove(ptr, "PTR")
     end
 
     def do_remove(name, type)
       zone = get_zone(name)
-      delete_record(zone['id'], name, type) and rectify_zone(zone['name'])
+      if delete_record(zone['id'], name, type)
+        raise Proxy::Dns::Error.new("Failed to remove record #{name} #{type}") unless rectify_zone(zone['name'])
+      end
+      true
     end
 
     def get_zone(fqdn)

data/lib/smart_proxy_dns_powerdns/dns_powerdns_plugin.rb

@@ -1,19 +1,15 @@
 require 'smart_proxy_dns_powerdns/dns_powerdns_version'
+require 'smart_proxy_dns_powerdns/dns_powerdns_configuration'
 
 module Proxy::Dns::Powerdns
   class Plugin < ::Proxy::Provider
     plugin :dns_powerdns, ::Proxy::Dns::Powerdns::VERSION
 
-    requires :dns, '>= 1.11'
+    requires :dns, '>= 1.13'
 
     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
+    load_classes ::Proxy::Dns::Powerdns::PluginConfiguration
+    load_dependency_injection_wirings ::Proxy::Dns::Powerdns::PluginConfiguration
   end
 end