mattly-slicehost-dns 0.3

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2009 Matthew Lyon
+
+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/Manifest

@@ -0,0 +1,9 @@
+LICENSE
+Manifest
+README.mkdn
+bin/slicehost-dns
+lib/slicehost-dns.rb
+lib/example.yml
+lib/reconciler.rb
+lib/zone.rb
+lib/record.rb

data/README.mkdn

@@ -0,0 +1,39 @@
+# slicehost-dns
+
+by Matthew Lyon <matt@flowerpowered.com>
+
+## DESCRIPTION:
+
+Helps you manage your DNS entries on the slicehost DNS server via a local YAML file.
+
+## FEATURES
+
+- Create new Zones just by adding them to the YAML file under an IP address
+- Automatically creates the root A record and a wildcard A record
+- creation of MX and SPF (TXT) records for gmail if desired
+- creation of SRV records for google chat if desired
+- can dump your current settings to a YAML file
+  
+## SYNOPSIS
+
+Get an example file:
+
+    slicehost-dns --example > example.yml
+
+Rename example.yml to config.yml, edit the "api" value to your api key, and dump your current settings
+from slicehost to config.yml:
+
+    slicehost-dns --dump config.yml
+
+Make some changes and push them back, but do a dry run first because we're not sure:
+
+    slicehost-dns config.yml --dry
+
+OK we're cool, push the changes for real this time:
+
+    slicehost-dns config.yml
+
+## REQUIREMENTS
+
+* activeresource
+* rspec, if you wish to run the spec suite

data/bin/slicehost-dns

@@ -0,0 +1,2 @@
+#! /usr/bin/env ruby
+load File.dirname(__FILE__) + '/../lib/slicehost-dns.rb'

data/lib/example.yml

@@ -0,0 +1,26 @@
+api: aldkgjhasklghaldghalghashglakdhgladshjg
+
+1.1.1.1:
+  example.com:
+    # these two A records are created by default, they are here as an example:
+    a:
+      example.com.: this
+      '*': this
+      # note that 'this' in this context is the current IP address
+    cname:
+      mail: web.mailhost.example.com.
+    mx: mailhost.example.com.
+    txt:
+    - "v=spf1 a mx ~all"
+    
+  example.tld:
+    cname:
+      blog: mattly.tumblr.com.
+    goog: all
+    # goog: "mail" creates mx records for gmail and an spf record (unless one is given)
+    # goog: "all" does the same as mail, as well as creates srv records for jabber/xmpp
+  
+  anotherexample.tld:
+    mx:
+      mailhost.example.com.: 5
+      backup.mailhost.example.com.: 10

data/lib/reconciler.rb

@@ -0,0 +1,178 @@
+class Reconciler
+  def initialize(zone, ip, existing, desired, setup={})
+    @zone, @ip, @existing, @desired, @setup = zone, ip, existing, desired, setup
+  end
+  
+  def log(msg, level=:info)
+    $LOG.send(level, msg) if $LOG
+  end
+  
+  def process!
+    process_a_records
+    process_cname_records
+    process_mx_records
+    process_srv_records
+    process_txt_records
+    process_ns_records
+  end
+  
+  def process_a_records
+    a_records = @existing.select {|r| r.a? }
+    
+    desired = @desired['a'] ||= {}
+    desired[@zone.origin] = 'this'
+    desired['*'] ||= 'this'
+    desired.each_pair {|k,v| desired[k] = @ip if v == "this" }
+    
+    crud_by_name(:a, a_records, desired)
+  end
+  
+  def process_cname_records
+    cnames = @existing.select {|r| r.cname? }
+    desired = @desired['cname'] || {}
+    crud_by_name(:cname, cnames, desired)
+  end
+  
+  def process_ns_records
+    ns = @existing.select {|r| r.ns? }
+    (1..3).to_a.each do |i|
+      unless ns.any? {|r| r.data == "ns#{i}.slicehost.net." }
+        log "> creating NS record ns#{i}.slicehost.net."
+        record = @zone.new_record(:record_type => "NS", :name => @zone.origin, :data => "ns#{i}.slicehost.net.")
+        record.save
+      else
+        r = ns.detect {|r| r.data == "ns#{i}.slicehost.net." }
+        ns.delete(r)
+      end
+    end
+    destroy_records ns
+  end
+  
+  def process_mx_records
+    mx = @existing.select {|r| r.mx? }
+    desired = @desired['mx'] || {}
+    
+    if @desired['goog']
+      desired = {
+        'aspmx.l.google.com.' => 1, 'alt1.aspmx.l.google.com.' => 5, 'alt2.aspmx.l.google.com.' => 5, 
+        'aspmx2.googlemail.com.' => 10, 'aspmx3.googlemail.com.' => 10, 'aspmx4.googlemail.com.' => 10,
+        'aspmx5.googlemail.com.' => 10
+      }
+    end
+    
+    if desired.kind_of?(String)
+      desired = {desired => 5}
+    end
+      
+    keepers = mx.select {|r| desired.has_key?(r.data) }
+    
+    cru_by_data :mx, @zone.origin, keepers, desired
+    
+    mx -= keepers
+    destroy_records mx
+  end
+  
+  def process_srv_records
+    srv = @existing.select {|r| r.srv? }
+    desired = @desired['srv'] || {}
+    
+    if @desired['goog'] && @desired['goog'] != 'mail'
+      desired.update({ 
+        "_xmpp-server._tcp.#{@zone.origin}" => {
+          '0 5269 xmpp-server.l.google.com.' => 5, '0 5269 xmpp-server1.l.google.com.' => 20,
+          '0 5269 xmpp-server2.l.google.com.' => 20, '0 5269 xmpp-server3.l.google.com.' => 20,
+          '0 5269 xmpp-server4.l.google.com.' => 20
+        },
+        "_jabber._tcp.#{@zone.origin}" => {
+          '0 5269 xmpp-server.l.google.com.' => 5, '0 5269 xmpp-server1.l.google.com.' => 20,
+          '0 5269 xmpp-server2.l.google.com.' => 20, '0 5269 xmpp-server3.l.google.com.' => 20,
+          '0 5269 xmpp-server4.l.google.com.' => 20
+        },
+        "_xmpp-client._tcp.#{@zone.origin}" => {
+          '0 5222 talk.l.google.com.' => 5, '0 5222 talk1.l.google.com.' => 20, 
+          '0 5222 talk2.l.google.com.' => 20
+        }
+      })
+    end
+    
+    desired.each_pair do |name, data_aux_pairs|
+      keepers = srv.select {|r| r.name == name }.select {|r| data_aux_pairs.has_key?(r.data) }
+      srv -= keepers
+      cru_by_data(:srv, name, keepers, data_aux_pairs)
+    end
+    
+    destroy_records srv
+  end
+  
+  def process_txt_records
+    txt = @existing.select {|r| r.txt? }
+    desired = @desired['txt'] || []
+
+    if @desired['goog'] && ! desired.any? {|t| t.match(/^v=spf1/)}
+      desired << "v=spf1 include:aspmx.googlemail.com ~all"
+    end
+
+    desired = desired.inject({}) {|memo, value| memo.update({value => 0}) }
+    
+    keepers = txt.select {|r| desired.include?(r.data) }
+    txt -= keepers
+    cru_by_data(:txt, @zone.origin, keepers, desired)
+    
+    destroy_records txt
+  end
+  
+  def destroy_records(records=[])
+    records.each do |r|
+      log "> removing record: #{r.kind} #{r.name} #{r.data}"
+      r.destroy
+    end
+  end
+  
+  # A, CNAME
+  def crud_by_name(type, records, desired)
+    type = type.to_s.upcase
+    records.each do |record|
+      if desired[record.name] == record.data
+        desired.delete(record.name)
+        
+      elsif desired.has_key?(record.name)
+        log "> changing record: #{type} #{record.name} from #{record.data} to #{desired[record.name]}"
+        record.data = desired[record.name]
+        desired.delete(record.name)
+        record.save
+        
+      else
+        log "> removing record: #{type} #{record.name} (#{record.data})"
+        record.destroy
+      end
+    end
+    (desired || {}).each_pair do |name, data|
+      log "> creating record: #{type} #{name} (#{data})"
+      record = @zone.new_record(:record_type => type, :name => name, :data => data)
+      record.save
+    end
+    
+  end
+  
+  # MX, SRV, TXT
+  def cru_by_data(type, name, keepers, desired)
+    type = type.to_s.upcase
+    
+    keepers.each do |r|
+      unless r.aux == desired[r.data]
+        log "> changing record: #{type} #{r.name} #{r.data} from #{r.aux} to #{desired[r.data]}"
+        r.aux = desired[r.data]
+        r.save
+      end
+      desired.delete(r.data)
+    end
+    
+    desired.each_pair do |data, aux|
+      log "> creating record: #{type} #{name} (#{data} / #{aux})"
+      r = @zone.new_record(:record_type => type, :name => name, :data => data, :aux => aux)
+      r.save
+    end
+    
+  end
+  
+end

data/lib/record.rb

@@ -0,0 +1,13 @@
+class Record < ActiveResource::Base
+
+  def kind
+    record_type.downcase
+  end
+
+  [:a,:mx,:cname,:srv,:ns,:txt].each do |kind|
+    define_method "#{kind}?" do
+      self.kind == "#{kind}"
+    end
+  end
+
+end

data/lib/slicehost-dns.rb

@@ -0,0 +1,144 @@
+#! /usr/bin/env ruby
+
+require 'rubygems'
+require 'activeresource'
+require 'yaml'
+require 'logger'
+
+class Logger
+  class Formatter
+    def call(severity, time, progname, msg)
+      "#{msg}\n"
+    end
+  end
+end
+
+# yes globals are evil but hey, i welcome patches. 
+# and, a riddle: what are singletons except globals reduced to a pattern?
+$LOG = Logger.new($stdout)
+
+def error(message) 
+  $LOG.fatal(message)
+  exit 
+end
+
+if ARGV.include? '--example'
+  example = File.dirname(__FILE__) + '/example.yml'
+  error open(example).read 
+end
+
+error "Usage: slicehost-dns (--dump --dry) [config.yml]" if ARGV.empty?
+
+dump = ARGV.delete('--dump')
+dry_run = ARGV.delete('--dry')
+filename = ARGV.shift
+config = YAML.load_file(filename)
+API = config.delete('api')
+$TTL = 43200 # 12 hours. 
+
+$:.unshift File.dirname(__FILE__)
+require 'zone'
+require 'record'
+require 'reconciler'
+
+Zone.site = "https://#{API}@api.slicehost.com/"
+Record.site = "https://#{API}@api.slicehost.com/"
+
+zones = Zone.find :all
+records = Record.find :all
+
+if dry_run
+  class Zone
+    def save
+      $LOG.info("~> dry saving zone #{origin}")
+    end
+    def destroy
+      $LOG.info("~> dry destroying zone #{origin}")
+    end
+  end
+  class Record
+    def save
+      $LOG.info("~> dry saving record #{kind} #{name}: #{data}")
+    end
+    def destroy
+      $LOG.info("~> dry destroying record #{kind} #{name}: #{data}")
+    end
+  end
+end
+
+if dump
+  output = {}
+  output['api'] = API
+  
+  zones.each do |zone|
+    local, records = records.partition {|r| r.zone_id == zone.id }
+    
+    primary_a = local.detect {|r| r.a? && r.name == zone.origin }
+    local.delete(primary_a)
+    ip = primary_a.data
+    
+    wildcard = local.detect {|r| r.a? && (r.name == "*" || r.name == "*.#{zone.origin}")}
+    local.delete(wildcard)
+    
+    domain = {}
+    
+    google = false
+    
+    local.each do |record|
+      case record.kind
+      when 'ns'
+      when 'srv'
+        domain['srv'] ||= {}
+        domain['srv'][record.name] ||= {}
+        domain['srv'][record.name][record.data] = record.aux
+        google = true if record.data.match(/xmpp-server\d?\.l\.google/)
+      when 'mx'
+        domain['mx'] ||= {}
+        domain['mx'][record.data] = record.aux
+        google = 'mail' if record.data.match(/google/i) && ! google
+      when 'txt'
+        domain['txt'] ||= []
+        domain['txt'] << record.data
+      else
+        domain[record.kind] ||= {}
+        domain[record.kind][record.name] = record.data == ip ? 'this' : record.data
+      end
+    end
+    
+    if google
+      domain['goog'] = google
+      domain.delete('mx')
+      unless google == 'mail'
+        domain['srv'].delete("_xmpp-server._tcp.#{zone.origin}")
+        domain['srv'].delete("_jabber._tcp.#{zone.origin}")
+        domain['srv'].delete("_xmpp-client._tcp.#{zone.origin}")
+        domain.delete('srv') if domain['srv'].empty?
+      end
+      # fuck it, we'll leave the spf record in there.
+    end
+    
+    if domain['mx'] && domain['mx'].size == 1
+      domain['mx'] = domain['mx'].keys.first
+    end
+    
+    output[ip] ||= {}
+    output[ip][zone.domain] = domain
+  end
+  
+  File.open(filename, 'w') {|f| YAML.dump(output, f) }
+else
+  config.each_pair do |ip, domains|
+    unless ip.match(/(\d+\.){3}\d+/)
+      $LOG.warn "\n~ skipping key #{ip}, not a valid ip address"
+      next
+    end
+    domains.each_pair do |domain, desired_records|
+      $LOG.info "\ndomain #{domain}"
+      zone = zones.detect {|z| z.domain == domain } || Zone.create_for_domain(domain)
+      records_for_domain, records = records.partition {|r| r.zone_id == zone.id }
+      Reconciler.new(zone, ip, records_for_domain, desired_records).process!
+      zones.delete(zone)
+    end
+    puts "\n\ni'd delete #{zones.map{|z| z.domain}.join(', ')} now but you'd hate me."
+  end
+end

data/lib/zone.rb

@@ -0,0 +1,18 @@
+class Zone < ActiveResource::Base
+  
+  def domain
+    origin.sub(/\.$/,'')
+  end
+  
+  def self.create_for_domain(domain)
+    $LOG.info "> domain record doesn't exist yet, creating" if $LOG
+    zone = self.new(:origin => "#{domain}.", :ttl => $TTL)
+    zone.save
+    zone
+  end
+  
+  def new_record(attrs={})
+    Record.new(attrs.merge({:zone_id => id}))
+  end
+  
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: mattly-slicehost-dns
+version: !ruby/object:Gem::Version 
+  version: "0.3"
+platform: ruby
+authors: 
+- Matthew Lyon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-11 00:00:00 -08:00
+default_executable: slicehost-dns
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activeresource
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: because YAML is the one true config format
+email: matt@flowerpowered.com
+executables: 
+- slicehost-dns
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- Manifest
+- README.mkdn
+- bin/slicehost-dns
+- lib/example.yml
+- lib/reconciler.rb
+- lib/record.rb
+- lib/zone.rb
+- lib/slicehost-dns.rb
+has_rdoc: false
+homepage: http://github.com/mattly/slicehost-dns
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- bin
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Manages DNS settings on your slicehost account via a YAML file
+test_files: []
+