pdns-ruby 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: deba7d8f561778d0cf86565dd6ada6215ae23ba16752a3f0e60ed011e714ed79
+  data.tar.gz: e32a1ffa09201317c0116b020e2f987195d8c3ad7532036d9d3bb636a2d4f908
+SHA512:
+  metadata.gz: 52603c97bef0ae508fbd0c709699391f77effe10212994b0da93e4e1b54ad3615c8e25054666222d5f929bc2e254d4241d69cc91defd920dbe7aa19b9ce8971d
+  data.tar.gz: 1633ba2fd6b9322474d2a284d51063b2cb77b71f868ee0707b424249f07806060e704691c558dd9692f7048e2984afc8c3b59da32ae00498c6a1e8c1be0bee02

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 1.0.0 (2026-04-03)
+
+Initial release.
+
+- Zone management (list, get, create, delete)
+- Record management via rrsets (add, update, delete, batch)
+- Typed error classes (NotFoundError, AuthError, ValidationError)
+- Zero external dependencies
+- PowerDNS 4.x API support

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2026 Vibol Teav
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,108 @@
+# pdns-ruby
+
+A simple Ruby client for the [PowerDNS](https://www.powerdns.com/) HTTP API. Zero dependencies beyond Ruby's standard library.
+
+## Installation
+
+```ruby
+gem 'pdns-ruby'
+```
+
+## Usage
+
+```ruby
+require 'pdns_ruby'
+
+client = PdnsRuby::Client.new(
+  host: 'http://localhost:8081',
+  api_key: 'your-api-key'
+)
+```
+
+### Zones
+
+```ruby
+# list all zones
+client.zones
+
+# get a zone
+zone = client.zone('example.com')
+
+# check if zone exists
+client.zone_exists?('example.com')
+
+# create a zone
+zone = client.create_zone('example.com', nameservers: ['ns1.example.com', 'ns2.example.com'])
+
+# delete a zone
+client.delete_zone('example.com')
+# or
+zone.delete!
+```
+
+### Records
+
+```ruby
+zone = client.zone('example.com')
+
+# add/update a record
+zone.add_record('www.example.com.', 'A', '1.2.3.4', ttl: 3600)
+
+# add MX record
+zone.add_record('example.com.', 'MX', '10 mail.example.com.', ttl: 3600)
+
+# delete a record
+zone.delete_record('www.example.com.', 'A')
+
+# get all rrsets
+zone.rrsets
+
+# find specific rrset
+zone.find_rrset('www.example.com.', 'A')
+```
+
+### Batch Updates
+
+```ruby
+rrsets = [
+  PdnsRuby::Rrset.replace(
+    name: 'www.example.com.',
+    type: 'A',
+    ttl: 3600,
+    records: [{ content: '1.2.3.4' }, { content: '5.6.7.8' }]
+  ),
+  PdnsRuby::Rrset.delete(
+    name: 'old.example.com.',
+    type: 'CNAME'
+  )
+]
+
+client.update_rrsets('example.com', rrsets)
+```
+
+### Error Handling
+
+```ruby
+begin
+  client.zone('nonexistent.com')
+rescue PdnsRuby::NotFoundError => e
+  puts "Zone not found"
+rescue PdnsRuby::AuthError => e
+  puts "Invalid API key"
+rescue PdnsRuby::ApiError => e
+  puts "API error: #{e.message}"
+end
+```
+
+## Features
+
+- Zero external dependencies — uses only Ruby's `net/http` and `json`
+- Zone management (list, get, create, delete)
+- Record management via rrsets (add, update, delete, batch)
+- Automatic trailing dot normalization for domain names
+- Typed error classes for easy error handling
+- Works with PowerDNS 4.x API
+
+## License
+
+MIT

data/lib/pdns_ruby/client.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module PdnsRuby
+  class Client
+    attr_reader :host, :api_key, :server_id
+
+    def initialize(host:, api_key:, server_id: 'localhost')
+      @host = host.chomp('/')
+      @api_key = api_key
+      @server_id = server_id
+    end
+
+    def zones
+      response = get("/api/v1/servers/#{server_id}/zones")
+      response.map { |z| Zone.new(self, z) }
+    end
+
+    def zone(name)
+      data = get("/api/v1/servers/#{server_id}/zones/#{normalize(name)}")
+      Zone.new(self, data)
+    end
+
+    def zone_exists?(name)
+      zone(name)
+      true
+    rescue NotFoundError
+      false
+    end
+
+    def create_zone(name, nameservers: [], kind: 'Native', soa_edit_api: 'DEFAULT')
+      data = post("/api/v1/servers/#{server_id}/zones", {
+        name: normalize(name),
+        nameservers: nameservers.map { |ns| normalize(ns) },
+        rrsets: [],
+        kind: kind,
+        soa_edit_api: soa_edit_api
+      })
+      Zone.new(self, data)
+    end
+
+    def delete_zone(name)
+      delete("/api/v1/servers/#{server_id}/zones/#{normalize(name)}")
+      true
+    end
+
+    def update_rrsets(zone_name, rrsets)
+      patch("/api/v1/servers/#{server_id}/zones/#{normalize(zone_name)}", {
+        rrsets: rrsets.map(&:to_h)
+      })
+      true
+    end
+
+    # HTTP methods
+
+    def get(path)
+      request(Net::HTTP::Get, path)
+    end
+
+    def post(path, body)
+      request(Net::HTTP::Post, path, body)
+    end
+
+    def patch(path, body)
+      request(Net::HTTP::Patch, path, body)
+    end
+
+    def delete(path)
+      request(Net::HTTP::Delete, path)
+    end
+
+    private
+
+    def request(method_class, path, body = nil)
+      uri = URI("#{host}#{path}")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == 'https'
+
+      req = method_class.new(uri)
+      req['X-API-Key'] = api_key
+      req['Content-Type'] = 'application/json'
+      req.body = body.to_json if body
+
+      response = http.request(req)
+
+      case response.code.to_i
+      when 200..299
+        response.body && !response.body.empty? ? JSON.parse(response.body) : nil
+      when 404
+        raise NotFoundError, "Not found: #{path}"
+      when 401, 403
+        raise AuthError, "Unauthorized: #{response.body}"
+      when 422
+        raise ValidationError, "Validation failed: #{response.body}"
+      else
+        raise ApiError, "API error #{response.code}: #{response.body}"
+      end
+    end
+
+    def normalize(name)
+      name.end_with?('.') ? name : "#{name}."
+    end
+  end
+
+  class ApiError < StandardError; end
+  class NotFoundError < ApiError; end
+  class AuthError < ApiError; end
+  class ValidationError < ApiError; end
+end

data/lib/pdns_ruby/rrset.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module PdnsRuby
+  class Rrset
+    attr_accessor :name, :type, :ttl, :changetype, :records
+
+    def initialize(name:, type:, ttl: 3600, changetype: 'REPLACE', records: [])
+      @name = name
+      @type = type
+      @ttl = ttl
+      @changetype = changetype
+      @records = records
+    end
+
+    def self.replace(name:, type:, ttl: 3600, records: [])
+      new(name: name, type: type, ttl: ttl, changetype: 'REPLACE', records: records.map { |r|
+        r.is_a?(Hash) ? { content: r[:content], disabled: r.fetch(:disabled, false) } : r
+      })
+    end
+
+    def self.delete(name:, type:)
+      new(name: name, type: type, ttl: 0, changetype: 'DELETE', records: [])
+    end
+
+    def self.from_api(data)
+      new(
+        name: data['name'] || data[:name],
+        type: data['type'] || data[:type],
+        ttl: data['ttl'] || data[:ttl] || 3600,
+        changetype: 'REPLACE',
+        records: (data['records'] || data[:records] || []).map { |r|
+          { content: r['content'] || r[:content], disabled: r['disabled'] || r[:disabled] || false }
+        }
+      )
+    end
+
+    def to_h
+      {
+        name: name,
+        type: type,
+        ttl: ttl,
+        changetype: changetype,
+        records: records
+      }
+    end
+  end
+end

data/lib/pdns_ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PdnsRuby
+  VERSION = '1.0.0'
+end

data/lib/pdns_ruby/zone.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module PdnsRuby
+  class Zone
+    attr_reader :client, :name, :kind, :serial, :dnssec, :account
+
+    def initialize(client, data)
+      @client = client
+      @name = data['name'] || data[:name]
+      @kind = data['kind'] || data[:kind]
+      @serial = data['serial'] || data[:serial]
+      @dnssec = data['dnssec'] || data[:dnssec]
+      @account = data['account'] || data[:account]
+      @data = data
+    end
+
+    def rrsets
+      zone_data = client.zone(@name.chomp('.'))
+      (@data['rrsets'] || @data[:rrsets] || []).map { |r| Rrset.from_api(r) }
+    end
+
+    def find_rrset(name, type)
+      rrsets.find { |r| r.name == name && r.type == type }
+    end
+
+    def update(rrsets)
+      client.update_rrsets(@name.chomp('.'), rrsets)
+    end
+
+    def add_record(name, type, content, ttl: 3600)
+      rrset = Rrset.replace(name: name, type: type, ttl: ttl, records: [{ content: content }])
+      update([rrset])
+    end
+
+    def delete_record(name, type)
+      rrset = Rrset.delete(name: name, type: type)
+      update([rrset])
+    end
+
+    def delete!
+      client.delete_zone(@name.chomp('.'))
+    end
+
+    def to_h
+      @data
+    end
+  end
+end

data/lib/pdns_ruby.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+require_relative 'pdns_ruby/version'
+require_relative 'pdns_ruby/client'
+require_relative 'pdns_ruby/zone'
+require_relative 'pdns_ruby/rrset'

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: pdns-ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Vibol Teav
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A simple Ruby client for managing zones and records via the PowerDNS
+  HTTP API. Supports zone CRUD, rrset management, and record operations.
+email:
+- vibolteav@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/pdns_ruby.rb
+- lib/pdns_ruby/client.rb
+- lib/pdns_ruby/rrset.rb
+- lib/pdns_ruby/version.rb
+- lib/pdns_ruby/zone.rb
+homepage: https://github.com/tvcam/pdns-ruby
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Ruby client for the PowerDNS API
+test_files: []