redzone 0.0.1

data/lib/redzone/zone.rb

@@ -0,0 +1,279 @@
+require 'redzone/record'
+require 'redzone/soa'
+require 'redzone/machine'
+require 'redzone/mail_exchange'
+require 'redzone/name_server'
+require 'redzone/arpa'
+
+module RedZone
+  # Represents a zone configuraton for a domain.
+  #
+  # Takes a zone configuration in the form of a hash.
+  # this is usually read from a yaml file. The schema
+  # for the yaml file can be found in the resources
+  #
+  class Zone
+    # Returns the domain name of the zone
+    # @return [String]
+    attr_reader :name
+
+    # Return the a list of machines
+    # @return [Array<Machine>]
+    attr_reader :machines
+
+    # Return the SOA record
+    # @return [SOA]
+    attr_reader :soa
+
+    # Returns the default machine for the domain when no subdomain is supplied
+    # @return [Machine]
+    attr_reader :default
+
+    # Returns a list of name servers that service the zone
+    # @return [Array<Machine>]
+    attr_reader :nameservers
+
+    # Returns a list of mail servers
+    # @return [Array<Machine>]
+    attr_reader :mailservers
+
+    # Returns a list of alternate names for machines. 
+    # These are additional A/AAAA records to the same
+    # IP Address
+    # @return [Array<Machine>]
+    attr_reader :altnames
+
+    # Returns a list of domain-name aliases
+    # @return [Array<Record>]
+    attr_reader :cnames
+
+    # Returns the wildcard entry - the catch-all machine for dns queries
+    # not matching any other subdomain entry.
+    # @return [Machine]
+    attr_reader :wildcard
+
+    # Returns a list of additional zone records
+    # @return [Array<Record>]
+    attr_reader :records
+
+    # Create a new Zone config
+    # @param [String] name Domain name (eg: example.com)
+    # @param [Hash] config Zone configuration
+    def initialize(name,config)
+      @name       = name
+      @config     = config
+      generate_machines()
+      generate_aliases()
+      generate_nameservers()
+      generate_mailservers()
+      generate_cnames()
+      generate_records()
+      @soa = generate_soa(@name)
+      d  = get_machine('default')
+      wc = get_machine('wildcard')
+      if d
+        @default = d.alias("@")
+      end
+      if wc
+        @wildcard = wc.alias("*")
+      end
+    end
+
+    # Writes a given set of Records to the target IO
+    # @param [IO] io output IO Stream
+    # @param [Array<Record>] records
+    def write_records(io,records)
+      unless records.nil? or records.empty?
+        records.each do |r|
+          io << r
+        end
+      end
+    end
+
+    # Writes the list of machines to the target IO
+    # @param [IO] io output IO Stream
+    # @param [Array<#records>] machines machines
+    # @param [String] comment (nil) Optional comment to be prefixed to the record section
+    def write_machines(io,machines,comment=nil)
+      unless machines.nil? or machines.empty?
+        io << "; #{comment}\n" unless comment.nil?
+        machines.each do |m|
+          write_records(io,m.records)
+        end
+        io << "\n"
+      end
+    end
+    
+    # Writes the entre zonefile to the target IO
+    # @param [IO] io Target IO stream
+    def write(io)
+      io << soa
+      unless default.nil?
+        write_machines(io,[default],"Default Machine")
+      end
+      write_machines(io,nameservers,"Name Servers")
+      write_machines(io,mailservers,"Mail Servers")
+      write_machines(io,machines,"Primary Machine names")
+      write_machines(io,altnames,"Alternate Machine Names")
+      unless wildcard.nil?
+        write_machines(io,[wildcard],"Wildcard Machine")
+      end
+      unless cnames.empty?
+        io << "; Canonical Names\n"
+        write_records(io,cnames)
+        io << "\n"
+      end
+      
+      unless records.nil? or records.empty?
+        io << "; Extra Records\n"
+        write_records(io,records)
+        io << "\n"
+      end
+    end
+
+    # Generates a list of Arpas for this zone
+    # @return [Array<Arpa>]
+    def generate_arpa_list
+      arpas = []
+      if @config.has_key?('arpa')
+        @config['arpa'].each do |cfg|
+          opts = symbolize(cfg)
+          soa  = generate_soa(opts[:name])
+          opts[:soa] = soa
+          an = Arpa.new(opts)
+          arpas << an
+          @nameservers.each do |ns|
+            an.add_record(Record.new(:name => '@', :type => 'NS', :data => ns.name + ".#{@name}." ))
+          end
+          @machines.each do |machine|
+            an.add(machine,@name)
+          end
+        end
+      end
+      arpas
+    end
+
+    private
+    def sorted_each(hash,&block)
+      keys = hash.keys.sort
+      keys.each do |key|
+        block.call(key,hash[key])
+      end
+    end
+    def symbolize(hash) 
+      hash.inject({}) do |memo,(k,v)|
+        memo[k.to_sym] = v
+        memo
+      end
+    end
+    def generate_soa(name)
+      opts = symbolize(@config['lifetimes'])
+      opts[:hostmaster] = @config['hostmaster'] if @config.has_key?('hostmaster')
+      opts[:domain]     = name
+      opts[:ns]         = @nameservers[0].name + ".#{@name}." unless @nameservers.empty?
+      SOA.new(opts)
+    end
+    def generate_machines
+      @machines = []
+      @allnames = []
+      @machines_by_name = {}
+      sorted_each(@config['machines']) do |n,c|
+      #@config['machines'].each do |n,c|
+        m = Machine.new(n,symbolize(c))
+        @allnames << n
+        @machines << m
+        @machines_by_name[n] = m 
+      end
+    end
+    def get_machine(name)
+      if @machines_by_name.has_key?(name)
+        @machines_by_name[name]
+      else
+        nil
+      end
+    end
+    def generate_aliases
+      machines = []
+      if @config.has_key?('aliases')
+        sorted_each(@config['aliases']) do |name,ref|
+        #@config['aliases'].each do |name,ref|
+          m = get_machine(ref)
+          if not m.nil?
+            machines  << m.alias(name)
+            @allnames << name
+          else
+            puts "ERROR: No such machine named #{ref}"
+          end
+        end
+      end
+      @altnames = machines
+    end
+    def add_alias(name,machine)
+      unless @allnames.include?(name)
+        @altnames << machine.alias(name)
+        @allnames << name
+      end
+    end
+    def generate_mailservers
+      machines = []
+      if @config.has_key?('mailservers')
+        sorted_each(@config['mailservers']) do |name,mx|
+        #@config['mailservers'].each do |name,mx|
+          ref = mx['machine']
+          m  = get_machine(ref)
+          if not m.nil?
+            priority = mx['priority'] || 10
+            machines << MailExchange.new(name,m,priority)
+            add_alias(name,m)
+          else
+            puts "ERROR: No such machine named #{ref}"
+          end
+        end
+      end
+      @mailservers = machines
+    end
+    def generate_nameservers
+      machines = []
+      if @config.has_key?('nameservers')
+        sorted_each(@config['nameservers']) do |name,ref|
+        #@config['nameservers'].each do |name,ref|
+          m = get_machine(ref)
+          if not m.nil?
+            machines << NameServer.new(name,m)
+            add_alias(name,m)
+          else
+            puts "ERROR: No such machine named #{ref}"
+          end
+        end
+      end
+      @nameservers = machines
+    end
+    def generate_cnames
+      @cnames = []
+      sorted_each(@config['cnames']) do |k,v|
+      #@config['cnames'].each do |k,v|
+        data = v
+        # Assume absolute domain name 
+        # if value is not a machine name
+        unless @allnames.include?(v)
+          data = "#{v}."
+        end
+        @cnames << Record.new({
+          :name => k,
+          :type => 'CNAME',
+          :data => data
+        })
+      end
+      @cnames
+    end
+    def generate_records
+      @records = []
+      if @config.has_key?('records')
+        @config['records'].each do |record|
+          @records << Record.new(symbolize(record))
+        end
+      end
+      @records
+    end
+  end
+end

data/lib/redzone/zone_config.rb

@@ -0,0 +1,28 @@
+require 'yaml'
+require 'redzone/zone'
+
+module RedZone
+  # Contains zone configurations
+  class ZoneConfig
+    # Return the list of Zone objects
+    # @return [Array<Zone>] zone
+    attr_reader :zones
+    # Return the list of ArpaNetwork objects
+    # @return [Array<ArpaNetwork>] arpa networks
+    attr_reader :arpas
+    def initialize(file)
+      config = YAML.load_file(file)
+      common = config['zones']['common']
+      @zones = []
+      @arpas = []
+      config['zones'].each do |z,c|
+        if z != 'common'
+          cfg = common.merge(c)
+          zone = Zone.new(z,cfg)
+          @zones << zone
+          @arpas.concat zone.generate_arpa_list()
+        end
+      end
+    end
+  end
+end

data/lib/redzone/zonefile_writer.rb

@@ -0,0 +1,30 @@
+require 'yaml'
+require 'redzone/zone'
+
+module RedZone
+  # Writes zone configurations to files
+  class ZonefileWriter
+    # Constructs a ZonefileWriter
+    def initialize(zone_config)
+      @config = zone_config
+    end
+    # Write the zone database files to the target folder
+    # @param [Pathname] target Target directory
+    def write_zones(target)
+      raise ArgumentError, "Directory #{target} does not exist" unless target.exist?
+      @config.zones.each do |z|
+        with_file(target,z.name) { |io| z.write(io) } 
+      end
+      @config.arpas.each do |a|
+        with_file(target,a.name) {|io| a.write(io)}
+      end
+    end
+    private
+    def with_file(target,name,&block)
+      filename = target + "#{name}.db"
+      File.open(filename,"w") do |file|
+        block.call(file)
+      end
+    end
+  end
+end

data/lib/redzone.rb

@@ -0,0 +1,2 @@
+require 'redzone/cli'
+require 'redzone/version'

data/redzone.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'redzone/version'
+
+Gem::Specification.new do |spec|
+  # Metadata
+  spec.name        = 'redzone'
+  spec.version     = RedZone::VERSION
+  spec.authors     = ['Justen Walker']
+  spec.email       = %w(justen.walker@gmail.com)
+  spec.homepage    = "https://github.com/justenwalker/redzone"
+  spec.summary     = 'RedZone - Automatically generate BIND zone files'
+  spec.description = <<-eos.gsub(/^ +/,'')
+                     RedZone is a command-line too that can generate bind zone
+                     files and configuration from yaml syntax.
+                     eos
+  spec.license     = "MIT"
+
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  # Dependencies
+  spec.required_ruby_version = '>= 1.8.7'
+  spec.add_runtime_dependency 'thor', '~> 0.18.1'
+  
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+end

data/redzone.rb

@@ -0,0 +1,279 @@
+#! /usr/bin/env ruby
+
+require 'yaml'
+require 'tsort'
+
+class String
+  def unindent 
+    gsub(/^#{scan(/^\s*/).min_by{|l|l.length}}/, "")
+  end
+end
+module RedZone
+  class ZoneConfig
+    include TSort
+    def initialize(zonefile)
+      @cfg = YAML.load_file(zonefile)
+      @zones = Hash.new {|h,k| h[k] = []}
+      @machines = []
+      @ips = []
+      @cfg['zones'].each do |k,v|
+        add(Zone.new(k,v))
+      end
+    end
+    def add(zone)
+      @zones[zone.name] = zone
+    end
+    def tsort_each_node(&block)
+      @zones.each_key(&block)
+    end
+    def tsort_each_child(node, &block)
+      @zones[node].dependencies.each(&block) if @zones.has_key?(node)
+    end
+    def domains
+      d = []
+      @zones.each do |k,v|
+        d << v.domains
+      end
+      d.flatten
+    end
+    def setup!
+      self.tsort.each do |z|
+        zone = @zones[z]
+        zone.dependencies.each do |dep|
+          zone.inherit!(@zones[dep])
+        end
+      end
+    end
+    def generate_domain(domain) 
+      io = StringIO.new
+      @zones.each do |k,v|
+        if v.domains.include?(domain)
+          io << v.generate_zonefile(domain)
+        end
+      end
+      io.string
+    end
+  end
+  class Zone
+    attr_reader :name,:dependencies,:config
+    def inherit!(zone)
+      unless @inherited.include?(zone.name)
+        @config = zone.config.merge(@config)
+        @inherited << zone.name
+      end
+    end
+    def initialize(name,config)
+      @inherited = []
+      @name   = name
+      @config = config
+      @dependencies = []
+      if @config.has_key?('inherits')
+        @dependencies << @config['inherits']
+        @dependencies = @dependencies.flatten
+      end
+    end
+    def domains
+      @config['domains'] || []
+    end
+    def generate_conffile(domain,datafile,masters=[])
+      io = StringIO.new
+      write_conffile(io,domain,datafile,masters)
+      io.string
+    end
+    def write_conffile(io,domain,datafile,masters=[])
+      if not masters.empty?
+        masterlist = masters.join(" ; ")
+        io << <<-eos.unindent
+        zone "#{domain}" in {
+          type slave;
+          file "#{datafile}";
+          masters { #{masterlist} ; } ;
+        }
+        eos
+      else
+        io << <<-eos.unindent
+        zone "#{domain}" in {
+          type master;
+          file "#{datafile}";
+        }
+        eos
+      end
+    end
+    def generate_zonefile(domain)
+      io = StringIO.new
+      write_zonefile(io,domain)
+      io.string
+    end
+    def write_zonefile(io,domain)
+      io << generate_soa(domain)
+      io << generate_default
+      io << generate_dns
+      io << generate_mail
+      io << generate_machines
+      io << generate_names
+      io << generate_aliases
+      io << generate_wildcard
+    end
+    
+    private
+    def all_machines
+      machines = []
+      @config['machines'].each do |name,cfg|
+        machines << Machine.new(name,cfg)
+      end
+      machines
+    end
+    def get_machine(name)
+      Machine.new(name,@config['machines'][name])
+    end
+    def generate_soa(domain)
+      lifetimes  = @config['lifetimes']
+      ttl        = lifetimes['ttl']
+      hostmaster = @config['hostmaster']
+      now        = Time.now.to_i
+      refresh    = lifetimes['refresh']
+      re         = lifetimes['retry']
+      expire     = lifetimes['expire']
+      negative   = lifetimes['negative']
+      <<-eos.unindent
+      $ORIGIN  #{domain}.
+      $TTL     #{ttl} ; queries are cached for this long
+      @        IN    SOA    ns1    #{hostmaster} (
+                     #{now} ; Date $time
+                     #{refresh}  ; slave queries for refresh this often
+                     #{re} ; slave retries refresh this often after failure
+                     #{expire} ; slave expires after this long if not refreshed
+                     #{negative} ; errors are cached for this long
+      )
+      
+      eos
+    end
+    def generate_record(name,type,detail,value,comment=nil)
+      suffix = " ; #{comment}" unless comment.nil?
+      "%-20s IN    %-8s %-6s %s%s\n" % [name, type, detail, value, suffix || ""]
+    end
+    def generate_machine(name,machine)
+      comment = "Machine #{machine}" unless name == machine
+      if machine.is_a? String
+        machine = get_machine(machine)
+      end
+      io = StringIO.new
+      io << generate_record(name,"A","",machine.ipv4,comment) if machine.ipv4?
+      io << generate_record(name,"AAAA","",machine.ipv6,comment) if machine.ipv6?
+      io.string
+    end
+    def generate_default
+      io = StringIO.new
+      if @config['default']
+        io <<  "; Primary name records for unqualfied domain\n"
+        io << generate_machine("@",@config['default'])
+        io << "\n"
+      end
+      io.string
+    end
+    def generate_dns
+      io = StringIO.new
+      if @config.has_key?('dns')
+        io << ": DNS Server Records\n"
+        dns_keys = @config['dns'].keys.sort
+        dns_keys.each do |k|
+          io << generate_record("@","NS","",k)
+        end
+        dns_keys.each do |k|
+          machine = @config['dns'][k]
+          io << generate_machine(k,machine)
+        end
+        io << "\n"
+      end
+      io.string
+    end
+    def generate_mail
+      io = StringIO.new
+      if @config.has_key?('mail')
+        io << "; Email Servers\n"
+        mail_keys = @config['mail'].keys.sort
+        mail_keys.each do |k|
+          mail = @config['mail'][k]
+          priority = mail['priority']
+          io << generate_record("@","MX",priority,k)
+        end
+        mail_keys.each do |k|
+          mail = @config['mail'][k]
+          machine = mail['machine']
+          io << generate_machine(k,machine)
+        end
+        io << "\n"
+      end
+      io.string
+    end
+    def generate_machines 
+      io = StringIO.new
+      io << "; Primary Machine Names\n"
+      all_machines.each do |machine|
+        io << generate_machine(machine.name,machine)
+      end
+      io << "\n"
+      io.string
+    end
+    def generate_names
+      io = StringIO.new
+      if @config.has_key?('mail')
+        io << "; Extra Names\n"
+        name_keys = @config['names'].keys.sort
+        name_keys.each do |name|
+          machine = @config['names'][name]
+          io << generate_machine(name,machine)
+        end
+        io << "\n"
+      end
+      io.string
+    end
+    def generate_aliases
+      io = StringIO.new
+      if @config.has_key?('mail')
+        io << "; Extra Names\n"
+        cname_keys = @config['aliases'].keys.sort
+        cname_keys.each do |cname|
+          value = @config['aliases'][cname]
+          io << generate_record(cname,"CNAME","",value)
+        end
+        io << "\n"
+      end
+      io.string
+    end
+    def generate_wildcard
+      io = StringIO.new
+      if @config['wildcard']
+        io <<  "; Wildcard\n"
+        io << generate_machine("*",@config['wildcard'])
+        io << "\n"
+      end
+      io.string
+    end
+  end
+  class Machine
+    attr_reader :name,:ipv4,:ipv6
+    def initialize(name,config) 
+      @name = name
+      @ipv4 = config['ipv4']
+      @ipv6 = config['ipv6']
+    end
+    def ipv4?
+      not @ipv4.nil?
+    end
+    def ipv6?
+      not @ipv6.nil?
+    end
+    def to_s
+      @name
+    end
+  end
+end
+
+zonecfg = RedZone::ZoneConfig.new 'zones.yml'
+zonecfg.setup!
+zonecfg.domains.each do |d|
+  puts zonecfg.generate_domain(d)
+end
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+dir = File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH.unshift File.join(dir, 'lib')
+
+require 'rubygems'
+require 'bundler/setup'
+
+Bundler.require :default, :test
+
+require 'pathname'
+require 'tmpdir'
+
+Pathname.glob("#{dir}/shared_behaviours/**/*.rb") do |behaviour|
+  require behaviour.relative_path_from(Pathname.new(dir))
+end
+
+def root_path
+  Pathname.new(File.expand_path(File.join(__FILE__, '..', '..')))
+end
+
+def fixture_path
+  root_path + 'spec' + 'fixtures'
+end
+
+def resources_path
+  root_path + 'resources'
+end
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end