bind9mgr 0.2.4

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2011-09-09
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,16 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/bind9mgr
+lib/bind9mgr.rb
+lib/named_conf.rb
+lib/zone.rb
+lib/parser.rb
+lib/resource_record.rb
+spec/named_conf_spec.rb
+spec/zone_spec.rb
+spec/spec_helper.rb
+spec/parser_spec.rb
+spec/resource_record_spec.rb

data/README.txt

@@ -0,0 +1,66 @@
+= bind9mgr
+
+== DESCRIPTION:
+
+This gem contains some classes to manage bind9 zone files
+
+== FEATURES/PROBLEMS:
+
+Please look into specs
+
+== SYNOPSIS:
+
+  bc = Bind9mgr::NamedConf.new( '/etc/bind/named.conf.local',
+                                :main_ns => 'ns1.example.com',
+                                :secondary_ns => 'ns2.example.com',
+                                :support_email => 'support@example.com',
+                                :main_server_ip => '192.168.1.1'
+                                )
+  bc.load_with_zones
+  bc.zones # => [ existing zones ... Bind9mgr::Zone ]
+  bc.zones.first.records # => [ records ... Bind9mgr::ResourceRecord ]
+  
+
+== REQUIREMENTS:
+
+rspec >= 2.6.0
+awesome_print
+Tested with Ruby 1.9.2
+
+== INSTALL:
+
+gem install bind9mgr
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2011 FIX
+
+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/Rakefile

@@ -0,0 +1,16 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+# Hoe.plugin :compiler
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :inline
+# Hoe.plugin :racc
+# Hoe.plugin :rubyforge
+
+Hoe.spec 'bind9mgr' do
+  developer('Mikhail Barablin', 'mikhail@mad-box.ru')
+
+  # self.rubyforge_name = 'bind9mgrx' # if different than 'bind9mgr'
+end

data/bin/bind9mgr

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+abort "you need to write me"

data/lib/bind9mgr.rb

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+require File.join( File.dirname(__FILE__), 'named_conf' )
+require File.join( File.dirname(__FILE__), 'zone' )
+require File.join( File.dirname(__FILE__), 'resource_record' )
+require File.join( File.dirname(__FILE__), 'parser' )
+
+module Bind9mgr
+  VERSION = '0.2.4'
+
+  ZONES_BIND_SUBDIR = 'zones_db'
+
+  KLASSES = %w{IN CH}
+  ALLOWED_TYPES = %w{A CNAME MX TXT PTR NS SRV SOA}
+end

data/lib/named_conf.rb

@@ -0,0 +1,124 @@
+module Bind9mgr
+  # You can specify bind_location. If you do so then .add_zone method
+  # will generate zones with right filenames.
+  class NamedConf
+    #    BIND_PATH = '/etc/bind'
+    #    BIND_DB_PATH = BIND_PATH + '/master'
+
+    attr_accessor :file, :main_ns, :secondary_ns, :support_email, :main_server_ip, :bind_location
+    attr_reader :zones
+
+    def initialize( file = '' )
+      @file = file
+      @bind_location = File.dirname(file) if file.length > 1
+      load
+    end
+    
+    def load
+      init_zones
+      parse File.read( File.join( @file )) if File.exists? file
+    end
+
+    def load_with_zones
+      init_zones
+      parse File.read( File.join( @file )) if File.exists? file
+      zones.each{ |z| z.load}
+    end
+
+
+    def parse content
+      content.scan(/(zone "(.*?)" \{.*?file\s+"(.*?)".*?\};\n)/m) do |zcontent, zone, file|
+        @zones.push Zone.new( zone, file, 
+                              :main_ns => @main_ns,
+                              :secondary_ns => @secondary_ns,
+                              :support_email => @support_email,
+                              :main_server_ip => @main_server_ip )
+      end
+      @zones
+    end
+
+    def gen_conf_content
+      cont = '# File is under automatic control. Edit with caution.' 
+      if @zones.size > 0
+        @zones.uniq.each do |zone|
+          cont << zone.gen_zone_entry << "\n"
+        end
+      end
+      cont
+    end
+
+    def write_conf_file
+      raise ArgumentError, "Conf file not specified" unless @file.kind_of? String
+      File.open( @file, 'w' ){|f| f.write( gen_conf_content )}
+    end
+
+    def write_zones
+      @zones.uniq.each do |z| 
+        z.file ||= gen_zone_file_name;
+        zones_subdir = File.dirname(z.file)
+        Dir.mkdir( zones_subdir ) unless File.exists?( zones_subdir )
+        z.write_db_file
+      end if @zones.size > 0
+    end
+
+    def write_all
+      write_conf_file
+      write_zones
+    end
+
+    def add_zone( zone_or_name, file_name = nil )
+      if zone_or_name.kind_of?( Zone )
+        raise ArgumentError, "file_name should be nil if instance of Zone supplied" unless file_name.nil?
+        zone = zone_or_name
+      elsif zone_or_name.kind_of?( String )
+        raise ArgumentError, "Main ns not secified" unless @main_ns
+        # raise ArgumentError, "Secondary ns not secified" unless @secondary_ns
+        raise ArgumentError, "Support email not secified" unless @support_email
+        raise ArgumentError, "Main server ip not secified" unless @main_server_ip
+        
+        zone = Zone.new( zone_or_name,
+                         file_name || gen_zone_file_name(zone_or_name), 
+                         :main_ns => @main_ns,
+                         :secondary_ns => @secondary_ns,
+                         :support_email => @support_email,
+                         :main_server_ip => @main_server_ip,
+                         :mail_server_ip => @mail_server_ip)
+      else
+        raise( RuntimeError, "BindZone or String instance needed")
+      end
+
+      del_zone! zone.origin
+      @zones.push zone
+    end
+    
+    # We should remove zone enties and delete db file immidiately.
+    def del_zone!( origin_or_name )
+      founded = @zones.select{ |z| z.origin == origin_or_name || z.name == origin_or_name }
+      founded.each do |z| 
+        z.load
+        File.delete( z.file ) if File.exists? z.file
+      end
+      # TODO refactor!
+      if founded.count > 0
+        @zones.delete_if{ |z| z.origin == origin_or_name || z.name == origin_or_name }
+      end
+      
+      # TODO unsafe code: other zone entries can be updated!
+      write_conf_file
+    end
+
+    private
+
+    def gen_zone_file_name( zone_name )
+      raise ArgumentError, "Bind location not specified" unless bind_location.kind_of?( String )
+      ext_zone_name = zone_name + '.db'
+
+      return ext_zone_name if bind_location.length < 1
+      return File.join( bind_location, ZONES_BIND_SUBDIR, ext_zone_name )
+    end
+
+    def init_zones
+      @zones = []
+    end
+  end
+end

data/lib/parser.rb

@@ -0,0 +1,121 @@
+module Bind9mgr
+  TYPES = %w{A CNAME TXT PTR NS SRV} # SOA, MX - are different
+  class Parser
+
+    attr_reader :state
+    attr_accessor :result # we can set appropriate Zone instance here
+
+    def initialize
+      @state = :start
+      @result = Zone.new
+
+      @STATE_RULES = 
+        [ [:start, :origin, Proc.new{ |t| t == '$ORIGIN' }],
+          [:origin, :start, Proc.new{ |t| set_origin t }],
+          [:start, :ttl,    Proc.new{ |t| t == '$TTL' }],
+          [:ttl, :start,    Proc.new{ |t| set_ttl t }],
+          [:start, :type,   Proc.new{ |t| TYPES.include?(t) ? add_rr(nil, nil, nil, t, nil) : false }],
+          [:start, :klass,  Proc.new{ |t| KLASSES.include?(t) ? add_rr(nil, nil, t, nil, nil) : false }],
+          [:start, :rttl,   Proc.new{ |t| t.match(/^\d+$/) ? add_rr(nil, t, nil, nil, nil) : false }],
+          [:start, :owner,  Proc.new{ |t| add_rr(t, nil, nil, nil, nil) }],
+          [:owner, :rttl,   Proc.new{ |t| t.match(/^\d+$/) ? update_last_rr(nil, t, nil, nil, nil) : false }],
+          [:owner, :klass,  Proc.new{ |t| KLASSES.include?(t) ? update_last_rr(nil, nil, t, nil, nil) : false }],
+          [:owner, :type,   Proc.new{ |t| TYPES.include?(t) ? update_last_rr(nil, nil, nil, t, nil) : false }],
+          [:rttl,  :klass,  Proc.new{ |t| KLASSES.include?(t) ? update_last_rr(nil, nil, t, nil, nil) : false }],
+          [:klass, :type,   Proc.new{ |t| TYPES.include?(t) ? update_last_rr(nil, nil, nil, t, nil) : false }],
+          [:type, :start,   Proc.new{ |t| update_last_rr(nil, nil, nil, nil, t)  }],
+          [:klass, :soa,    Proc.new{ |t| t == 'SOA' ? update_last_rr(nil, nil, nil, t, nil) : false }],
+          [:soa, :start,    Proc.new{ |t| rdata = [t] + @tokens.shift(7)
+             raise RuntimeError, "Zone parsing error: parentices expected in SOA record.\n#{@content}" if (rdata[2] != '(') && (@tokens.first != ')')
+             rdata.delete_at(2)
+             @result.options[:support_email] = rdata[1]
+             @result.options[:serial] = rdata[2]
+             @result.options[:refresh] = rdata[3]
+             @result.options[:retry] = rdata[4]
+             @result.options[:expiry] = rdata[5]
+             @result.options[:default_ttl] = rdata[6]
+             update_last_rr(nil, nil, nil, nil, rdata)
+             @tokens.shift
+           }],
+          [:klass, :mx,     Proc.new{ |t| t == 'MX' ? update_last_rr(nil, nil, nil, t, nil) : false }],
+          [:mx, :start,     Proc.new{ |t| update_last_rr(nil, nil, nil, nil, [t] + [@tokens.shift]) }]
+        ]
+    end
+
+    def parse str
+      @content = str # for debugging
+      @tokens = tokenize( str )
+      
+      cntr = 0
+      while @tokens.size > 0
+        token = @tokens.shift
+        # puts "state: #{@state}, token: #{token}"
+        possible_edges = @STATE_RULES.select{|arr|arr[0] == @state }
+        raise "no possible_edges. cur_state: #{@state}" if possible_edges.count < 1
+
+        flag = false
+        while ( possible_edges.count > 0 ) && flag == false
+          current_edge = possible_edges.shift
+          flag = current_edge[2].call(token)
+          
+          # ( puts " succ: #{@state} -> #{current_edge[1]}"; @state = current_edge[1] ) if flag
+          # ( puts " fail: #{@state} -> #{current_edge[1]}" ) unless flag
+          @state = current_edge[1] if flag
+        end
+
+        raise "no successful rules found. cur_state: #{@state}, token: #{token}" unless flag
+        cntr += 1
+      end
+
+      get_options
+
+      cntr # returning performed rules count. just for fun
+    end
+ 
+    private
+
+    def tokenize str
+      str.gsub(/;.*$/, '').split(/\s/).select{|s|s.length > 0}
+    end
+
+    def get_options
+      # main server ip
+      main_a_rr = @result.records.find{ |r|(r.owner == '@' || r.owner == @result.origin || r.owner.nil?) && r.type == 'A' }
+      unless main_a_rr
+        puts "WARNING: main A rr not found. Can't get main server ip" 
+      else
+        @result.options[:main_server_ip] = main_a_rr.rdata
+      end
+      # name servers
+      ns_rrs = @result.records.select{ |r| (r.owner == '@' || r.owner == @result.origin || r.owner.nil?) && r.type == 'NS' }
+      if ns_rrs.count < 1
+        puts "WARNING: NS rrs not found. Can't NS servers" 
+      else
+        @result.options[:main_ns] = ns_rrs[0].rdata
+        @result.options[:secondary_ns] = ns_rrs[1].rdata if ns_rrs.count > 1
+      end
+    end
+
+    def set_origin val
+      @result.origin = val
+    end
+
+    def set_ttl val
+      @result.default_ttl = val
+    end
+
+    def add_rr owner, ttl, klass, type, rdata
+      @result.records ||= []
+      @result.records.push ResourceRecord.new( owner, ttl, klass, type, rdata )
+    end
+    
+    def update_last_rr owner, ttl, klass, type, rdata 
+      @result.records.last.owner  = owner  if owner
+      @result.records.last.ttl    = ttl    if ttl
+      @result.records.last.klass  = klass  if klass
+      @result.records.last.type   = type   if type
+      @result.records.last.rdata  = rdata  if rdata
+      return true
+    end
+  end
+end

data/lib/resource_record.rb

@@ -0,0 +1,35 @@
+module Bind9mgr
+  class ResourceRecord
+    attr_accessor :owner, :ttl, :klass, :type, :rdata
+
+    def initialize owner = nil, ttl = nil, klass = nil, type = nil, rdata = nil
+      @owner = owner
+      @ttl = ttl
+      @klass = klass
+      @type = type
+      @rdata = rdata
+    end
+
+    def gen_rr_string
+      raise ArgumentError, "RR Type not specified" unless @type
+      raise ArgumentError, "RR Rdata not specified" unless @rdata
+
+      raise( ArgumentError, "wrong owner: #{owner.inspect}" ) if owner == 'localhost'
+      raise( ArgumentError, "wrong class: #{klass.inspect}" ) if !klass.nil? && !KLASSES.include?( klass ) 
+      raise( ArgumentError, "wrong type: #{type.inspect}" )  unless ALLOWED_TYPES.include?( type )
+
+      if @type == 'SOA'
+        cont = ''
+        cont << "#{@owner}\t#{@ttl}\t#{@klass}\t#{@type}\t#{rdata[0]} #{rdata[1]} (\n"
+        cont << "\t#{Time.now.to_i} ; serial\n"
+        cont << "\t#{rdata[3]} ; refresh\n"
+        cont << "\t#{rdata[4]} ; retry\n"
+        cont << "\t#{rdata[5]} ; expire\n"
+        cont << "\t#{rdata[6]} ; minimum\n"
+        cont << ")\n"
+      else
+        "#{@owner}\t#{@ttl}\t#{@klass}\t#{@type}\t#{[@rdata].flatten.join(' ')}\n"
+      end
+    end
+  end
+end

data/lib/zone.rb

@@ -0,0 +1,194 @@
+module Bind9mgr
+  class Zone
+    RRClasses = ['IN', 'CH']
+    RRTypes = [ 'A',
+                'MX',
+                'SRV',
+                'CNAME',
+                'SOA',
+                'NS',
+                'TXT',
+                'PTR'
+              ]
+
+    attr_accessor :origin, :default_ttl
+    attr_accessor :file, :options
+    attr_reader :records
+
+    def initialize( zone_name = nil, zone_db_file = nil, options = { } )
+      @origin = zone_name
+      @file = zone_db_file
+      @options = options
+
+      @default_ttl ||= 86400
+      @options[:serial] ||= 109
+      @options[:refresh] ||= 3600
+      @options[:retry] ||= 3600
+      @options[:expiry] ||= 604800
+      @options[:default_ttl] ||= 86400
+      
+      clear_records
+    end
+
+    def name
+      @origin.sub(/\.$/, '')
+    end
+
+    def name= str
+      @origin = str + '.'
+    end
+
+    # +rrs_array+ is a array like: [[owner, ttl, klass, type, rdata], ...]
+    def self.validete_rrs_uniqueness( rrs_array )
+      array = []
+      rrs_array.each do |owner, ttl, klass, type, rdata|
+        raise( ArgumentError, "owner, type and rdata have to be unique" ) if array.include? [owner,type,rdata]
+        array.push [owner,type,rdata]
+      end
+    end
+
+    def load
+      raise ArgumentError, "file not specified" unless @file
+      
+      p = Parser.new
+      p.result = self
+      raise ArgumentError, "File: #{file} not found." unless File.exists?( @file )
+      p.parse File.read( @file )
+    end
+
+    # def parse content
+    #   clear_records
+    #   content.gsub!(/^\s+\n/, '')
+
+    #   # find and remove SOA record with its comments
+    #   soa = /([^\s]*?)\s+?(\d+?)?\s*?(#{RRClasses.join('|')})\s*?(SOA)\s+(.*?\).*?)\n/m
+    #   arr = content.match(soa).to_a
+    #   arr.shift
+    #   @records['SOA'].push arr
+    #   content.sub! soa, ''
+
+    #   # remove comments and blank lines
+    #   content.gsub!(/;.*$/, '')
+    #   content.gsub!(/^\s+\n/, '')
+      
+    #   # other @Records
+    #   rr = /^([^\s]+)\s+?(\d+?)?\s*?(#{RRClasses.join('|')})?\s*?(#{RRTypes.join('|')})\s+(.*?)$/
+    #   content.lines.each do |l|
+    #     if md = l.match(/\$TTL\s+(\d+)/)
+    #       ( @default_ttl = md[1].to_i ) if md[1].to_i > 0
+    #     elsif md = l.match(rr)
+    #       tmp_a = md.to_a
+    #       tmp_a.shift
+    #       @records[tmp_a[3]].push tmp_a
+    #     end
+    #   end
+    #   @records
+    # end
+
+    def gen_db_content
+      initialized?
+      raise ArgumentError, "default_ttl not secified" unless @default_ttl
+      
+      add_default_rrs
+      
+      cont = "; File is under automatic control. Edit with caution.\n"
+      cont << ";;; Zone #{@origin} ;;;" << "\n"
+      cont << "$ORIGIN #{@origin}" << "\n" if @origin
+      cont << "$TTL #{@default_ttl}" << "\n" if @default_ttl
+      cont << @records.map{ |r| r.gen_rr_string }.join
+
+      cont
+    end
+    
+    def write_db_file
+      db_dir = File.dirname( @file )
+      raise( Errno::ENOENT, "No such dir: #{db_dir}" ) unless File.exists? db_dir
+      File.open( @file, 'w' ){|f| f.write( gen_db_content )}
+    end
+
+    def add_default_rrs
+      raise ArgumentError, "Main ns not specified" unless @options[:main_ns]
+      raise ArgumentError, "Main server ip not specified" unless @options[:main_server_ip]
+
+      ensure_soa_rr( default_soa )
+      ensure_rr( ResourceRecord.new('@', nil, 'IN', 'A', @options[:main_server_ip]) )
+      ensure_rr( ResourceRecord.new('@', nil, 'IN', 'NS', @options[:main_ns]) )
+      ensure_rr( ResourceRecord.new('@', nil, 'IN', 'NS', @options[:secondary_ns]) ) if @options[:secondary_ns]
+      # ensure_rr( ResourceRecord.new('@', nil, 'IN', 'MX', ['90', @options[:mail_server_ip]]) )
+      ensure_rr( ResourceRecord.new('www', nil, nil, 'CNAME', '@') )
+    end
+    
+    def add_rr( owner, ttl, klass, type, rdata )
+      initialized?
+      @records.push ResourceRecord.new(owner, ttl, klass, type, rdata)
+    end
+
+    # removes all resourse record with specified owner and type
+    def remove_rr( owner, type )
+      raise( ArgumentError, "wrong owner" ) if     owner.nil?
+      raise( ArgumentError, "wrong type" )  unless ALLOWED_TYPES.include? type
+
+      initialized?
+
+      @records.delete_if { |rr| (rr.owner == owner) && (rr.type == type) }
+    end
+
+    def gen_zone_entry
+      initialized?
+
+      cont = ''
+      cont << %Q|
+zone "#{name}" {
+  type master;
+  file "#{@file}";
+  allow-update { none; };
+  allow-query { any; };
+};
+|
+    end
+
+    def clear_records
+      @records = []
+    end
+
+    private
+
+    def ensure_soa_rr record
+      cnt = @records.select{ |r| r.type == 'SOA' }.count
+      raise RuntimeError, "Multiple SOA detected. zone:#{@origin}" if cnt > 1
+      return false if cnt == 1
+      @records.unshift record
+      true
+    end
+
+    def ensure_rr record
+      max_rr_cnt = (record.type == 'NS' ? 2 : 1)
+      cnt = @records.select{ |rr| (rr.owner == record.owner) && (rr.type == record.type) }.count
+      raise RuntimeError, "Multiple rr with same owner+type detected. zone:#{@origin}" if cnt > max_rr_cnt
+      return false if cnt == max_rr_cnt
+      @records.push record
+      true
+    end
+
+    def default_soa
+      initialized?
+      raise ArgumentError, "Main ns not secified" unless @options[:main_ns]
+      raise ArgumentError, "Support email not secified" unless @options[:support_email]
+
+      ResourceRecord.new( '@', @options[:default_ttl], 'IN', 'SOA', 
+                          [ @origin,
+                            @options[:support_email],
+                            @options[:serial],
+                            @options[:refresh],
+                            @options[:retry],
+                            @options[:expiry],
+                            @options[:default_ttl]
+                          ] )
+    end
+
+    def initialized?
+      raise( ArgumentError, "zone not initialized" ) if  @origin.nil? || @file.nil?
+    end
+    
+  end
+end

data/spec/named_conf_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+describe Bind9mgr::NamedConf do
+  before do
+    @example_com_db_content = %q{$TTL 86400 ; 1 day
+@	IN	SOA	testdomain.com. admin@testdomain.com. (
+	1111083002	; serial
+	14400		; refresh (4 h)
+	3600		; retry (1 h)
+	2592000		; expire (4w2d)
+	600		; minimum (10 minute)
+)
+@	IN	NS	ns.example.com.
+sub1		IN	A	192.168.1.2
+sub2		IN	A	192.168.1.3
+alias1  	IN	CNAME	ns
+www CNAME @
+}
+
+    @test_conf_content = %q{// test file
+zone "cloud.ru" {
+	type master;
+	file "testdomain.com.db";
+};
+
+zone "1.168.192.in-addr.arpa" {
+	type master;
+	file "testdomain.com.db";
+};
+}
+
+    @test_db_content = %q{$ORIGIN testdomain.com.
+$TTL 86400 ; 1 day
+@	IN	SOA	testdomain.com. admin@testdomain.com. (
+	2011083002	; serial
+	14400		; refresh (4 h)
+	3600		; retry (1 h)
+	2592000		; expire (4w2d)
+	600		; minimum (10 minute)
+)
+		IN	NS	ns.testdomain.com.
+testdomain.com.	IN	A	192.168.1.1
+sub1		IN	A	192.168.1.2
+sub2		IN	A	192.168.1.3
+alias1  	IN	CNAME	ns
+}
+
+    File.stub(:exists?).with(anything()).and_return(false)
+    File.stub(:exists?).with("testfile.conf").and_return(true)
+    File.stub(:exists?).with("testdomain.com.db").and_return(true)
+
+    File.stub(:read).with("testfile.conf").and_return(@test_conf_content)
+    File.stub(:read).with("testdomain.com.db").and_return(@test_db_content)
+
+    @nc = Bind9mgr::NamedConf.new
+    @nc.file = 'testfile.conf'
+    @nc.bind_location = ''
+    @nc.main_ns = 'ns1.example.com'
+    @nc.secondary_ns = 'ns2.example.com'
+    @nc.support_email = 'ns1.example.com'
+    @nc.main_server_ip = 'ns1.example.com'
+    @nc.load_with_zones
+  end
+
+  it "should be creatable" do
+    expect { Bind9mgr::NamedConf.new }.to_not raise_error
+  end
+
+  it "should fail to add_zone(some_string) unless bind_location filled" do
+    @nc.bind_location = nil
+    expect { @nc.add_zone('example.com') }.to raise_error(ArgumentError)
+  end
+
+  it "should fail to add_zone(some_string) unless main NS name filled" do
+    @nc.main_ns = nil
+    expect { @nc.add_zone('example.com') }.to raise_error(ArgumentError)
+  end
+
+  # Behaivor changed. Secondary ns absence causes warning only
+  # it "should fail to add_zone(some_string) unless secondary NS name filled" do
+  #   @nc.secondary_ns = nil
+  #   expect { @nc.add_zone('example.com') }.to raise_error(ArgumentError)
+  # end
+
+  it "should fail to add_zone(some_string) unless support email filled" do
+    @nc.support_email = nil
+    expect { @nc.add_zone('example.com') }.to raise_error(ArgumentError)
+  end
+
+  it "should fail to add_zone(some_string) unless main server ip filled" do
+    @nc.main_server_ip = nil
+    expect { @nc.add_zone('example.com') }.to raise_error(ArgumentError)
+  end
+
+  it "should fill @file if argument supplyed on instantiation" do
+    nc = Bind9mgr::NamedConf.new('testfile.conf')
+    nc.file.should eql 'testfile.conf'
+  end
+
+  it "should parse conf file on instantiation if supplyed and file exists" do
+    Bind9mgr::NamedConf.any_instance.should_receive(:parse).with(an_instance_of(String)).and_return(nil)
+    nc = Bind9mgr::NamedConf.new('testfile.conf')
+  end
+
+  it "should have zones after conf file parsing" do
+    nc = Bind9mgr::NamedConf.new('testfile.conf')
+    nc.zones.count.should == 2
+    nc.zones[0].should be_kind_of(Bind9mgr::Zone)
+    nc.zones[1].should be_kind_of(Bind9mgr::Zone)
+  end
+
+  it "should init zones before load" do
+    @nc.zones.count.should == 2 # as specified in "before"
+    
+    @nc.file = "wrong.file.conf"
+    @nc.load
+    @nc.zones.should be_empty()
+  end
+
+  it "should have an empty array of zones on instantiation without conf file" do
+    nc = Bind9mgr::NamedConf.new
+    nc.zones.should be_empty()
+  end
+
+  it "should load zones data on 'load_with_zones'" do
+    @nc.load_with_zones
+    @nc.zones.first.records.count.should > 0
+  end
+
+  it "should remove old zone when zone with same name added" do
+    File.stub(:exists?).with("example.com.db").and_return(true) # lets think that there is no db file for this zone
+    File.stub(:read).with("example.com.db").and_return(@example_com_db_content)
+    File.stub(:delete).with("example.com.db").and_return(1)
+
+    @nc.add_zone( 'example.com' )
+    @nc.zones.last.add_rr( 'cname', nil, nil, 'CNAME', '@' )
+    @nc.zones.count.should == 3 # we specified 2 zones in "before"
+    @nc.add_zone( 'example.com' )
+    @nc.zones.last.records.count.should == 0
+    @nc.zones.last.add_default_rrs
+    @nc.zones.last.records.count.should == 5 # new zone should have SOA, A, CNAME(www) and 2*NS records
+  end
+
+  pending "should automatically generate file name for zone db if not supplied"
+  pending "should automatically make dir for zone db files"
+  pending "should have methods to edit SOA values"
+end

data/spec/parser_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe Bind9mgr::Parser do
+  let(:test_zone) do
+    %q{$ORIGIN cloud.ru.
+$TTL 86400 ; 1 day
+@	IN	SOA	cloud.ru. root.cloud.ru. (
+	2011083002	; serial
+	14400		; refresh (4 h)
+	3600		; retry (1 h)
+	2592000		; expire (4w2d)
+	600		; minimum (10 minute)
+)
+		IN	NS	ns.cloud.ru.
+ns		IN	A	192.168.1.200
+nfsstorage	IN	CNAME	ns
+mail            IN MX 40 192.168.1.33
+www CNAME @
+cloud.ru.	IN	A	192.168.1.1
+NS ns2.cloud.ru
+manager		IN	A	192.168.1.20
+director	IN	A	192.168.1.23
+directorproxy	IN	A	192.168.1.24
+oracle		IN	A	192.168.1.19
+vcenter		IN	A	192.168.1.12
+esx1		IN	A	192.168.1.2
+; some comment
+}
+  end
+
+  before do
+    p = Bind9mgr::Parser.new
+    p.parse test_zone
+    @result = p.result
+  end
+
+  it "should parse test data without errors" do
+    expect {
+      p = Bind9mgr::Parser.new
+      p.parse test_zone
+    }.not_to raise_error
+  end
+
+  it "should raise exception if there is no parentices in SOA definition" do
+    p = Bind9mgr::Parser.new
+    expect{
+      p.parse %q{ 
+@	IN	SOA	cloud.ru. root.cloud.ru. (
+	2011083002	; serial
+	14400		; refresh (4 h)
+	3600		; retry (1 h)
+	2592000		; expire (4w2d)
+	600		; minimum (10 minute)
+
+}
+    }.to raise_error
+    expect{
+      p.parse %q{ 
+@	IN	SOA	cloud.ru. root.cloud.ru. 
+	2011083002	; serial
+	14400		; refresh (4 h)
+	3600		; retry (1 h)
+	2592000		; expire (4w2d)
+	600		; minimum (10 minute)
+)
+}
+    }.to raise_error
+  end
+  
+  it "should provide Zone with ResourceRecords" do
+    @result.should be_kind_of Bind9mgr::Zone
+    @result.records.count.should > 0
+    @result.records.first.should be_kind_of Bind9mgr::ResourceRecord # in hope that othes wil be the same
+  end
+
+  it "should have SOA record as first element of records" do
+    @result.records.first.type.should == 'SOA'
+  end
+
+  it "should have 7 elements in rdata of SOA record" do
+    @result.records.first.rdata.count.should == 7
+  end
+
+  it "should fill default_ttl" do
+    @result.default_ttl.should be
+  end
+
+  it "should parse CNAME records" do
+    @result.records[3].type.should == 'CNAME'
+  end
+
+  it "should parse A records" do
+    rr = @result.records[2]
+    rr.type.should == 'A'
+    rr.owner.should eql('ns')
+    rr.klass.should eql('IN')
+    rr.rdata.should eql('192.168.1.200')
+  end
+
+  it "should parse MX records(and mx priority!)" do
+    rr = @result.records[4]
+    rr.type.should == 'MX'
+    rr.owner.should eql('mail')
+    rr.klass.should eql('IN')
+    rr.rdata.should be_kind_of Array
+    rr.rdata.should eql(['40', '192.168.1.33'])
+  end
+  
+  it "should parse records without ttl and class" do
+    rr = @result.records[5]
+    rr.type.should  eql('CNAME')
+    rr.owner.should eql('www')
+    rr.klass.should eql(nil)
+    rr.rdata.should eql('@')
+  end
+
+  it "should parse records after records without ttl and class" do
+    rr = @result.records[6]
+    rr.owner.should eql('cloud.ru.')
+    rr.type.should  eql('A')
+    rr.klass.should eql('IN')
+    rr.rdata.should eql('192.168.1.1')
+  end
+
+  pending "should parse PTR records (12 IN PTR something.com.)" do
+  end
+end

data/spec/resource_record_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Bind9mgr::ResourceRecord do
+  before do
+    @rr = Bind9mgr::ResourceRecord.new
+    @a_string = %q{example.com. IN A 192.168.1.1}
+    @cname_string = %q{cname IN CNAME @
+}
+    @soa_string = %q{@	IN	SOA	cloud.ru. root.cloud.ru. (
+ 	2011083002	; serial
+	14400		; refresh (4 h)
+	3600		; retry (1 h)
+	2592000		; expire (4w2d)
+	600		; minimum (10 minute)
+)
+}
+    @mx_string = %q{example.com.        IN      MX  10   mail.example.com.}
+  end
+
+  it "should be instanceable" do
+    expect { Bind9mgr::ResourceRecord.new }.to_not raise_error
+  end
+
+  it "should have methods to fill parametrs" do
+    @rr.should respond_to( :owner, :ttl, :type, :klass, :rdata )
+  end
+
+  it "should have method to generate rr string" do
+    @rr.should respond_to( :gen_rr_string )
+  end
+
+  it "shoult have a list of allowed rr types" do
+    Bind9mgr::ALLOWED_TYPES.should be_kind_of(Array)
+    Bind9mgr::ALLOWED_TYPES.count.should > 0
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'ap'
+require 'bind9mgr' # and any other gems you need
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

data/spec/zone_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Bind9mgr::Zone do
+  before do
+    @test_db_content = %q{$ORIGIN testdomain.com.
+$TTL 86400 ; 1 day
+@	IN	SOA	testdomain.com. admin@testdomain.com. (
+	2011083002	; serial
+	14400		; refresh (4 h)
+	3600		; retry (1 h)
+	2592000		; expire (4w2d)
+	600		; minimum (10 minute)
+)
+		IN	NS	ns.testdomain.com.
+testdomain.com.	IN	A	192.168.1.1
+sub1		IN	A	192.168.1.2
+sub2		IN	A	192.168.1.3
+alias1  	IN	CNAME	ns
+}
+
+    File.stub(:exists?).with(anything()).and_return(false)
+    File.stub(:exists?).with("testdomain.com.db").and_return(true)
+
+    File.stub(:read).with("testdomain.com.db").and_return(@test_db_content)
+
+    @zone = Bind9mgr::Zone.new
+    @zone.file = 'testdomain.com.db'
+  end
+
+  it "should be instanceable" do
+    expect{ Bind9mgr::Zone.new }.not_to raise_error
+  end
+
+  it "should fill itself with data on load method call" do
+    @zone.load
+    @zone.records.count.should > 0
+  end
+
+  pending "should fail to generate db file content unless mandatory options filled"
+  pending "should raise if wrong rr type specified"
+  pending "should not write repeating rrs"
+  it "should generate db file content" do
+    @zone.load
+    cont = @zone.gen_db_content
+    cont.should be_kind_of( String )
+    cont.match(/#{@zone.origin}/m).should be
+  end
+  pending "should generate zone entry content"
+
+  it "should add default rrs before generate db content" do
+    zone = Bind9mgr::Zone.new( 'example.com', 'example.com.db',
+                               { :main_ns => '192.168.1.1',
+                                 :secondary_ns => '192.168.1.2',
+                                 :main_server_ip => '192.168.1.3',
+                                 :support_email => 'qwe@qwe.ru'
+                               })
+  end
+
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: bind9mgr
+version: !ruby/object:Gem::Version
+  version: 0.2.4
+  prerelease: 
+platform: ruby
+authors:
+- Mikhail Barablin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-12 00:00:00.000000000 +04:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: &9505680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :development
+  prerelease: false
+  version_requirements: *9505680
+description: This gem contains some classes to manage bind9 zone files
+email:
+- mikhail@mad-box.ru
+executables:
+- bind9mgr
+extensions: []
+extra_rdoc_files:
+- History.txt
+- Manifest.txt
+- README.txt
+files:
+- .autotest
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/bind9mgr
+- lib/bind9mgr.rb
+- lib/named_conf.rb
+- lib/zone.rb
+- lib/parser.rb
+- lib/resource_record.rb
+- spec/named_conf_spec.rb
+- spec/zone_spec.rb
+- spec/spec_helper.rb
+- spec/parser_spec.rb
+- spec/resource_record_spec.rb
+- .gemtest
+has_rdoc: true
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.txt
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: bind9mgr
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: This gem contains some classes to manage bind9 zone files
+test_files: []