dns_one 0.5.5 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d78210ea5e09411a507c872baf45cdd2e6d9b645
-  data.tar.gz: 0f3dddc89fb102922fae3506003577cc3fd1f781
+  metadata.gz: 1712bca4a25d8e72f60b38c83c121087245f583b
+  data.tar.gz: 6f6d4c432b13d708273643c7abed58b2c7b8da04
 SHA512:
-  metadata.gz: f99f8cea22ad191fdc6c99fb791192ce53988d982c31b1a50f24b2dd4e792a26b2f83ae98e8c68dd38f36dac1d4a60d7e850aa753981b268fb2fde3c44ae69c2
-  data.tar.gz: 791b7d95188a5a95da729de2d089b28cc168324ee910d90279aeb8169182f53d0e94fdf60e0d261a2a12400e5a22ce659415955e6dcc285130435aa1e39ddb9a
+  metadata.gz: 54a23b46cfba3138ad0c76084f71705a5f8194a1d4c5134a0c623117d52a729bfdb404ec73477014fb5deec93c21893a98b7e4bcee810075c52baa40d6ce9a56
+  data.tar.gz: 55a248615c9999cd3a63aa04288af1b32514867971ade91ac2cd555d49053c7d5c8b5049bfa0dab889967973d5ba6bb8b2914253ce41b1c6d61090a738f5d285

data/dns_one.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.0"
 
   spec.add_runtime_dependency "thor", '~> 0.19'
-  spec.add_runtime_dependency "rubydns", '~> 1.0'
+  spec.add_runtime_dependency "rubydns", '~> 2.0.1'
   spec.add_runtime_dependency "rexec", '~> 1.6'
   spec.add_runtime_dependency "pg", '~> 0.21'
   spec.add_runtime_dependency "activerecord", '~> 5.0'

data/lib/dns_one.rb

@@ -1,6 +1,4 @@
 # Core
-require 'syslog'
-require 'syslog/logger'
 require 'ostruct'
 require 'singleton'
 require 'fileutils'
@@ -20,76 +18,63 @@ require "dns_one/core_ext/string"
 require "dns_one/core_ext/blank"
 require "dns_one/core_ext/hash"
 
-require "dns_one/log"
+require "dns_one/global"
 require "dns_one/util"
 require "dns_one/server"
-require "dns_one/stat"
+require "dns_one/req_log/db"
 
 module DnsOne; class DnsOne
 
-    DEFAULT_CONF_FILE = '/etc/dns_one/conf.yml'
-    WORK_DIR = "/var/local/dns_one"
-    CONF_DIR = "/etc/dns_one"
-
-    def initialize conf_file: nil, work_dir: nil
-        Log.setup
-
-        conf_file ||= DEFAULT_CONF_FILE
-        @conf_all = parse_conf conf_file
-        @conf = @conf_all.main
-
-        work_dir ||= WORK_DIR
-
-        begin
-            Dir.chdir work_dir
-        rescue => e
-            Log.w "Cannot change working dir to #{WORK_DIR}. Will continue in #{Dir.pwd}."
-        end
+    DEFAULTS = {
+        conf_file:          "/etc/dns_one.yml",
+        work_dir:           "/var/local/dns_one",
+        log_file:           "/var/log/dns_one/dns_one.log",
+        rubydns_log_file:   "/var/log/dns_one/dns_one_rubydns.log",
+        run_as:             "dnsone",
+        interfaces:         [ [:udp, "0.0.0.0", 53],
+                              [:tcp, "0.0.0.0", 53],
+                              [:udp, "::", 5300],
+                              [:tcp, "::", 5300] 
+                            ],
+        log_req_socket_file: '/tmp/dns_one_log_result.sock'
+    }
+
+    def initialize conf_file: nil
+        @conf = Global.conf = load_conf(conf_file || DEFAULTS[:conf_file])
     end
-
+    
     def start
-        Server.new(@conf_all.server, @conf_all.zone_search).run 
+        init_loggers
+        chdir
+        Server.new.run 
     end
 
     private
-        
-    def parse_conf conf_file
-        check_conf_file conf_file
 
-        conf = YAML.load_file conf_file
-        conf = conf.symbolize_keys
+    def load_conf conf_file
+        conf = DEFAULTS.clone
+        conf.merge! YAML.load_file(conf_file).symbolize_keys
+        Util.hash_to_ostruct_deep conf
 
-        OpenStruct.new(
-            main: {
-                work_dir:           conf[:config][:work_dir]
-            },
-            server: {
-                run_as:                 conf[:config][:run_as],
-                save_stats:             conf[:config][:save_stats],
-                log_result_file:        conf[:config][:log_result_file],
-                log_result_socket:      conf[:config][:log_result_socket],
-                log_result_socket_file: conf[:config][:log_result_socket_file],
-            },
-            zone_search: {
-                ignore_subdomains:  conf[:config][:ignore_subdomains],
-                cache_max:          conf[:config][:cache_max],
-                record_sets:        conf[:record_sets],
-                backend:            conf[:backend]
-            }
-        )
+    rescue => e
+        $stderr.puts e.desc
+        $stderr.puts "Error opening conf file #{conf_file}. Aborting."
+        exit 1
     end
 
-    def check_conf_file conf_file
-        unless File.readable? conf_file
-                Util.die "Conf file #{conf_file} not found or unreadable. Aborting." 
-        end
+    def init_loggers
+        Global.logger           = Util.init_logger @conf.log_file       , Logger::INFO
+        Global.ruby_dns_logger  = Util.init_logger @conf.ruby_dns_logger, Logger::WARN
+    end
 
-        conf_stat = File.stat conf_file
+    def chdir
+        d = @conf.work_dir
+        FileUtils.mkdir_p d
+        Dir.chdir d
 
-        unless conf_stat.mode.to_s(8) =~ /0600$/
-                Util.die "Conf file #{conf_file} must have mode 0600. Aborting." 
-        end
+    rescue => e
+        Global.logger.error e.desc
+        Global.logger.error "Cannot chdir to #{@conf.work_dir}. Will continue in #{Dir.pwd}"
     end
 
 end; end
-

data/lib/dns_one/backend/db.rb

@@ -31,12 +31,12 @@ module DnsOne; module Backend; class DB < Base
         record_values&.first
 
     rescue ActiveRecord::StatementInvalid => e
-        Log.e "SQL query error. Trying to reconnect #{tries}. Details:\n#{e.desc}"
+        Global.logger.error "SQL query error. Trying to reconnect #{tries}. Details:\n#{e.desc}"
         # http://geoff.evason.name/2015/01/18/postgres-ssl-connection-has-been-closed-unexpectedly
         ActiveRecord::Base.connection.reconnect! 
         find sql, (tries+1)
     rescue => e
-        Log.e "SQL query error. Details:\n#{e.desc}"
+        Global.logger.error "SQL query error. Details:\n#{e.desc}"
     end
 
     def build_query dom_name
@@ -46,7 +46,7 @@ module DnsOne; module Backend; class DB < Base
 
     def setup_db
         #require_deps
-        ActiveRecord::Base.logger = Log.logger
+        ActiveRecord::Base.logger = Global.logger
         ActiveRecord::Base.establish_connection @conf
     end
 

data/lib/dns_one/backend/file.rb

@@ -24,7 +24,7 @@ module DnsOne; module Backend; class File < Base
             if domain_name and not domain_name.empty?
                 @domain_map[domain_name.strip.downcase] = rec_set_name&.strip || ''
             else
-                Log.w "Ignoring #{file} line: #{line}"
+                Global.logger.warn "Ignoring #{file} line: #{line}"
             end
         end
     end

data/lib/dns_one/backend/http_bell.rb

@@ -52,7 +52,7 @@ module DnsOne; module Backend; class HTTPBell < Base
             .map{ |r| 
                 id, domain = r.strip.split /\s+/
                 if id !~ /^\d+$/ || domain !~ Util::DOM_REGEX
-                    Log.w "invalid line '#{r}'"
+                    Global.logger.warn "invalid line '#{r}'"
                     nil
                 else
                     [id.to_i, domain.downcase]
@@ -66,17 +66,17 @@ module DnsOne; module Backend; class HTTPBell < Base
         case point
         when :start
             @log_update_t0 = Time.now
-            Log.i "update`ing..."
+            Global.logger.info "update`ing..."
         when :end
             dt = '%.2f' % (Time.now - @log_update_t0)
             dots = '...' if recs.size > LOG_DOM_NUM
             zones = recs[0, LOG_DOM_NUM].map(&:last).join(', ')
-            Log.i "#{recs.size} zone(s) added in #{dt}s: #{zones}#{dots}"
+            Global.logger.info "#{recs.size} zone(s) added in #{dt}s: #{zones}#{dots}"
         else
-            Log.e "Wrong param #{point} for log_update"
+            Global.logger.error e.desc "Wrong param #{point} for log_update"
         end
     rescue => e
-        Log.exc e
+        Global.logger.error e.desc
     end
 
     def listen_updater_bell
@@ -86,19 +86,19 @@ module DnsOne; module Backend; class HTTPBell < Base
         require "socket"  
         dts = TCPServer.new '0.0.0.0', @conf[:http_bell_port]
         allow_ips = @conf[:http_bell_allow_ips]
-        Log.i 'Starting bell listener...'
+        Global.logger.info 'Starting bell listener...'
         Thread.new do
             loop do  
                 Thread.start(dts.accept) do |client|
-                    Log.i 'accepted'
+                    Global.logger.info 'accepted'
                     numeric_address = client.peeraddr[3]
                     if !allow_ips || allow_ips.include?(numeric_address)
-                        Log.i 'will update'
+                        Global.logger.info 'will update'
                         update
                     else
-                        Log.w "Ignoring bell ring from #{numeric_address}."
+                        Global.logger.warn "Ignoring bell ring from #{numeric_address}."
                     end
-                    Log.i 'closing connection'
+                    Global.logger.info 'closing connection'
                     client.close
                 end
             end

data/lib/dns_one/cli.rb

@@ -12,11 +12,9 @@ class DnsOne::CLI < Thor
 
     desc "run", "run server"
     option :conf
-    option :work_dir
     def run_srv
         DnsOne::DnsOne.new(
-            conf_file: options[:conf], 
-            work_dir: options[:work_dir]
+            conf_file: options[:conf]
         ).start 
     end
 

data/lib/dns_one/global.rb

@@ -0,0 +1,3 @@
+module DnsOne
+    Global = OpenStruct.new
+end

data/lib/dns_one/req_log/account.rb

@@ -0,0 +1,85 @@
+module DnsOne; module Backend; class Account
+
+    def initialize
+        @conf = Global.conf       
+        @stat = {}
+        @last_stat = nil
+        @mutex = Mutex.new
+        open_socket
+        reap
+    end
+
+    def on_response ip_address, domain_name, res_class, rcode, resp_log, from_cache
+        @mutex.synchronize {
+            @stat[:requests] ||= 0
+            @stat[:requests] += 1
+            
+            @stat[:cache] ||= 0
+            @stat[:cache] += 1 if from_cache
+            
+            rcode_uc = Util.const_underscore rcode
+            @stat[:rcode] ||= {}
+            @stat[:rcode][rcode_uc] ||= 0
+            @stat[:rcode][rcode_uc] += 1
+
+            req_resource = Util.last_mod(res_class).downcase
+            @stat[:req_resource] ||= {}
+            @stat[:req_resource][req_resource] ||= 0
+            @stat[:req_resource][req_resource] += 1        
+        }
+    end
+
+    def reap
+        Thread.new do
+            loop do
+                sleep (300 - Time.now.to_f % 300)
+                @mutex.synchronize {
+                    @last_stat = @stat.deep_dup
+                    reset @stat
+                }
+            end
+        end
+    end
+
+    def open_socket
+        conf = @conf
+        mutex = @mutex
+        stat = @stat
+        sock = Thread.new do
+            sleep 1
+            begin
+                Socket.unix_server_loop(Global.conf.log_req_socket_file) do |sock, addr|
+                    Thread.new do
+                        loop do
+                            begin
+                                mutex.synchronize {
+                                    sock.write "#{ last_stat.to_json }\n"
+                                }
+                            rescue Errno::EPIPE => e
+                                break
+                            rescue => e
+                                Global.logger.error e.desc
+                                break
+                            end
+                            Thread.pass
+                            sleep 0.1
+                        end
+                    end
+                end
+            rescue => e
+                Global.logger.error e.desc
+            end
+        end
+    end
+
+    def reset hash
+        hash.each_key do |k|
+            if hash[k].is_a? Hash
+                reset hash[k]
+            else
+                hash[k] = 0
+            end
+        end
+    end
+
+end

data/lib/dns_one/{stat.rb → req_log/db.rb}

@@ -1,4 +1,5 @@
-module DnsOne; class Stat
+module DnsOne; module Backend; class DB
+
     DB_FNAME = "stat.db"
     META_STAT_ON = false
     META_STAT_FILE = '/tmp/dnsone_sql_prof.log'
@@ -12,19 +13,19 @@ module DnsOne; class Stat
         ensure_db
     end
 
-    def save rcode, req_resource, cache
-    	Log.d "saving stat (user: #{ `id -un #{Process.uid}`.strip })"
+    def on_response ip_address, domain_name, res_class, rcode, resp_log, from_cache
+    	Global.logger.debug "saving stat (user: #{ `id -un #{Process.uid}`.strip })"
         rsql(
             "INSERT INTO responses (time, rcode, req_resource, cache) VALUES (?, ?, ?, ?)", 
             [
                 Time.now.to_i, 
                 Resolv::DNS::RCode.const_get(rcode), 
-                req_resource::TypeValue, 
-                (cache ? 1 : 0)
+                res_class::TypeValue, 
+                (from_cache ? 1 : 0)
             ]
         )
     rescue => e
-        Log.e e
+        Global.logger.error e.desc
     end
 
     # select rcode, count(*) from responses where time > strftime('%s', 'now') - 300 group by rcode
@@ -120,7 +121,7 @@ module DnsOne; class Stat
         opts = {}
         opts[:readonly] = true if @conf[:readonly]
 
-	    # Log.i "Opening stat db #{db_file} (cwd: #{Dir.pwd})."
+	    # Global.logger.info "Opening stat db #{db_file} (cwd: #{Dir.pwd})."
         @db = SQLite3::Database.new db_file, opts
 
         if new_db
@@ -165,5 +166,5 @@ module DnsOne; class Stat
         @meta_stats_log.info "#{time} #{dur} #{sql}"
     end
 
-end; end
+end; end; end
 

data/lib/dns_one/req_log/file.rb

@@ -0,0 +1,28 @@
+module DnsOne; module Backend; class File
+    if @conf.req_log_file
+        path = @conf.req_log_file.is_a?(String) ? @conf.req_log_file : 
+        l = Logger.new @conf.ruby_dns_logger, 10, (10 * 2**20)
+        l.level = Logger::WARN
+        Global.ruby_dns_logger = l
+    end
+
+    def self.log_result ip_address, domain_name, res_class, rcode, resp_log, from_cache
+        fields = []
+
+        fields << domain_name
+        fields << Util.last_mod(res_class)
+        fields << rcode
+        fields << resp_log.map{ |rec|
+            Util.last_mod(rec.res_class) + 
+            ':' +
+            [rec.val].flatten.join(',')
+        }.join(';')
+        fields << ip_address
+        fields << (from_cache ? '1' : '0')
+
+        fields.map!{|v| v.blank? ? '-' : v}
+
+        Global.logger.info "result: #{ fields.join ' ' }"
+    end
+end
+   

data/lib/dns_one/req_log/req_log.rb

@@ -0,0 +1,25 @@
+module DnsOne; module ReqLog; class ReqLog
+
+    def initialize 
+        @conf = Global.conf
+    end
+
+    def on_response *args
+        if @conf.log_req_db
+            @db ||= Db.new
+            @db.on_response *args
+        end
+
+        if @conf.log_req_file
+            @file = File.new
+            @file.on_response *args
+        end
+
+        if @conf.log_req_account
+            @account ||= Account.new
+            @account.on_response *args
+        end
+    end
+
+end; end; end
+

data/lib/dns_one/server.rb

@@ -1,141 +1,69 @@
 
 require "dns_one/zone_search"
+require "dns_one/req_log/req_log"
 require 'socket'
 require 'json'
 
 module DnsOne; class Server
-
-    DEFAULT_RUN_AS = "dnsone"
-    DEFAULT_LOG_RESULT_SOCKET_FILE = '/tmp/dns_one_log_result.sock'
-
-    DNS_DAEMON_INTERFACES = [
-        [:udp, "0.0.0.0", 53],
-        [:tcp, "0.0.0.0", 53],
-        [:udp, "::", 5300],
-        [:tcp, "::", 5300]
-    ]
-
-    def initialize conf, conf_zone_search
-        @conf = conf
-        @zone_search = ZoneSearch.instance.setup conf_zone_search
-        if conf[:log_result_socket]
-            @log_result = {}
-            @log_result_mutex = Mutex.new
-        end
+    def initialize 
+        @zone_search = ZoneSearch.instance.setup
+        @req_log = nil
     end
 
-    def run
-        zone_search = @zone_search
-        conf = @conf
-        stat = nil
-        if conf[:log_result_socket]
-            log_result = @log_result
-            log_result_mutex = @log_result_mutex
-            launch_log_result_socket
-            log_result_last_reset = 0
+    def start
+        if RExec.current_user == 'root'
+            RExec.change_user Global.conf.run_as
         end
+        @req_log ||= ReqLog::ReqLog.new
+        Global.logger.info "Running as #{RExec.current_user}"
+    end
 
-        RubyDNS::run_server(listen: dns_daemon_interfaces, logger: Log.ruby_dns_logger) do
-            on(:start) do
-                if RExec.current_user == 'root'
-                    run_as = conf[:run_as] || DEFAULT_RUN_AS
-        	        stat = Stat.new user: run_as if !stat
-                    RExec.change_user run_as
-                else
-                    stat = Stat.new if !stat
-                end
-                Log.i "Running as #{RExec.current_user}"
-            end
-
-            match(/(.+)/) do |t| # transaction
-                rcode = :NoError
-                resp_log = []
-
-                begin
-                    domain_name = t.question.to_s
-                    ip_address = t.options[:peer] rescue nil
-
-                    records, from_cache = zone_search.query domain_name, t.resource_class, ip_address
-
-                    if records
-                        if records.empty?
-                            t.fail! :NoError
-                        else
-                            records.each do |rec|
-                                resp_log << rec
-                                t.respond! *[rec.val].flatten, {resource_class: rec.res_class, section: rec.section}
-                            end
-                        end
-                    else
-                        rcode = :NXDomain
-                        t.fail! :NXDomain
-                    end
-                rescue => e
-                    rcode = :ServFail
-                end
-
-                begin
-                    if conf[:save_stats]
-                        stat.save rcode, t.resource_class, from_cache
-                    end
+    def resolve transaction
+        rcode = :NoError
+        resp_log = []
 
-                    if conf[:log_result]
-                        Util.log_result ip_address, domain_name, t.resource_class, rcode, resp_log, from_cache
-                    end
+        begin
+            domain_name = transaction.question.to_s
+            ip_address = transaction.options[:peer] rescue nil
 
-                    if conf[:log_result_socket]
-                        log_result_mutex.synchronize {
-                            # Reset log_result every 5 min
-                            if Time.now.to_i / 300 > log_result_last_reset / 300
-                                log_result_last_reset = Time.now.to_i
-                                log_result.each_key do |k|
-                                    if log_result[k].is_a? Hash
-                                        log_result[k].each_key do |k2|
-                                            log_result[k][k2] = 0
-                                        end
-                                    else
-                                        log_result[k] = 0
-                                    end
-                                end
-                            end
+            records, from_cache = @zone_search.query domain_name, transaction.resource_class, ip_address
 
-                            log_result[:requests] ||= 0
-                            log_result[:requests] += 1
-                            
-                            log_result[:cache] ||= 0
-                            log_result[:cache] += 1 if from_cache
-                            
-                            rcode_uc = Util.const_underscore rcode
-                            log_result[:rcode] ||= {}
-                            log_result[:rcode][rcode_uc] ||= 0
-                            log_result[:rcode][rcode_uc] += 1
-        
-                            req_resource = Util.last_mod(t.resource_class).downcase
-                            log_result[:req_resource] ||= {}
-                            log_result[:req_resource][req_resource] ||= 0
-                            log_result[:req_resource][req_resource] += 1        
-                        }
+            if records
+                if records.empty?
+                    transaction.fail! :NoError
+                else
+                    records.each do |rec|
+                        resp_log << rec
+                        transaction.respond! *[rec.val].flatten, {resource_class: rec.res_class, section: rec.section}
                     end
-                rescue => e
-                    Log.exc e
                 end
-
-                raise e if e
-            end
-
-            otherwise do |t|
-                t.fail! :NXDomain
+            else
+                rcode = :NXDomain
+                transaction.fail! :NXDomain
             end
+        rescue => e
+            rcode = :ServFail
         end
+
+        @req_log.on_response *[
+            ip_address, 
+            domain_name, 
+            transaction.resource_class, 
+            rcode, 
+            resp_log, 
+            from_cache
+        ]
+
+        raise e if e
     end
 
     def dns_daemon_interfaces
         if RExec.current_user == 'root'
-            DNS_DAEMON_INTERFACES
+            Global.conf.interfaces
         else
-            ports = DNS_DAEMON_INTERFACES.map do |port|
+            ports = Global.conf.interfaces.map do |port|
                 if port[2] <= 1024
-                    Log.w "Changing listening port #{port[2]} to #{port[2] + 10000} for non-root process."
+                    Global.logger.warn "Changing listening port #{port.join ':'} to #{port[2] + 10000} for non-root process."
                     port[2] += 10000 
                 end
                 port
@@ -144,34 +72,20 @@ module DnsOne; class Server
         end
     end
 
-    def launch_log_result_socket
-        log_result = @log_result
-        log_result_mutex = @log_result_mutex
-        conf = @conf
+    def run
+        srv = self
 
-        sock = Thread.new do
-            sleep 1
-            begin
-                Socket.unix_server_loop(conf[:log_result_socket_file] || DEFAULT_LOG_RESULT_SOCKET_FILE) do |sock, addr|
-                    Thread.new do
-                        loop do
-                            begin
-                                log_result_mutex.synchronize {
-                                    sock.write "#{ log_result.to_json }\n"
-                                }
-                            rescue Errno::EPIPE => e
-                                break
-                            rescue => e
-                                Log.exc e
-                                break
-                            end
-                            Thread.pass
-                            sleep 0.1
-                        end
-                    end
-                end
-            rescue => e
-                Log.exc e
+        RubyDNS::run_server(dns_daemon_interfaces) do
+            on(:start) do
+                srv.start
+            end
+
+            match(/(.+)/) do |transaction|
+                srv.resolve transaction
+            end
+
+            otherwise do |transaction|
+                transaction.fail! :NXDomain
             end
         end
     end

data/lib/dns_one/util.rb

@@ -4,7 +4,7 @@ module DnsOne; class Util
 
   class << self
     def die msg
-      Log.f msg
+      Global.logger.fatal msg
       exit 1
     end
 
@@ -33,25 +33,6 @@ module DnsOne; class Util
       constant.to_s.split('::').last
     end
 
-    def log_result ip_address, domain_name, res_class, rcode, resp_log, from_cache
-      fields = []
-
-      fields << domain_name
-      fields << Util.last_mod(res_class)
-      fields << rcode
-      fields << resp_log.map{ |rec|
-          Util.last_mod(rec.res_class) + 
-          ':' +
-          [rec.val].flatten.join(',')
-      }.join(';')
-      fields << ip_address
-      fields << (from_cache ? '1' : '0')
-
-      fields.map!{|v| v.blank? ? '-' : v}
-
-      Log.i "result: #{ fields.join ' ' }"
-    end
-
     def const_underscore name
         name = name.to_s.dup
         name.gsub!('::', '/')
@@ -62,6 +43,33 @@ module DnsOne; class Util
         name
     end
 
+    def hash_to_ostruct_deep hash
+        os = OpenStruct.new
+        hash.each_pair{ |k, v| 
+            if v.is_a? Hash
+                os[k] = hash_to_ostruct_deep v
+            else
+                os[k] = v
+            end
+        }
+        os
+    end
+
+    def init_logger logdev, level = Logger::WARN, shift_age = 10, shift_size = 2**20
+        if logdev.is_a? String
+            begin
+                FileUtils.mkdir_p File.dirname(logdev)
+                File.write logdev, ''
+            rescue => e
+                $stderr.puts "#{e.desc}\nCannot open log file #{logdev}. Will use STDOUT."
+                logdev = $stdout
+            end
+        end
+        l = Logger.new logdev, shift_age, shift_size
+        l.level = level
+        l
+    end
+
   end 
 
 end; end

data/lib/dns_one/version.rb

@@ -1,3 +1,3 @@
 module DnsOne
-    VERSION = "0.5.5"
+    VERSION = "0.5.6"
 end

data/lib/dns_one/zone_search.rb

@@ -11,11 +11,11 @@ module DnsOne; class ZoneSearch
     Name = Resolv::DNS::Name
     IN = Resolv::DNS::Resource::IN
 
-    def setup conf
-        @conf = conf
+    def setup
+        @conf = Global.conf
         check_record_sets
         @backend = set_backend
-        @cache = Cache.new @conf[:cache_max]
+        @cache = Cache.new Global.conf.cache_max
         @ignore_subdomains_re = build_ignore_subdomains_re
 
         if @backend.preload_dummy?
@@ -30,25 +30,25 @@ module DnsOne; class ZoneSearch
 
         dom_name = dom_name.dup
         res_class_short = Util.last_mod res_class # :A, :NS, found in conf.yml:record_sets items
-        Log.d "request #{ dom_name }/#{res_class_short} from #{ip_address}..."
+        Global.logger.debug "request #{ dom_name }/#{res_class_short} from #{ip_address}..."
 
         records = []
 
         rec_set_name, from_cache = find_record_set dom_name
-        Log.d "domain #{ rec_set_name ? "found, rec_set_name = '#{rec_set_name}'" : 'not found' }"
+        Global.logger.debug "domain #{ rec_set_name ? "found, rec_set_name = '#{rec_set_name}'" : 'not found' }"
         return unless rec_set_name
 
         # use first record set if rec_set_name == ''
-        rec_set_name = @conf[:record_sets].keys.first if rec_set_name == ''
+        rec_set_name = @conf.record_sets.to_h.keys.first if rec_set_name == ''
  
-        rec_set = @conf[:record_sets][rec_set_name.to_sym]
-        Log.d "record set #{ rec_set ? 'found' : 'not found' }"
+        rec_set = @conf.record_sets[rec_set_name]
+        Global.logger.debug "record set #{ rec_set ? 'found' : 'not found' }"
         return records unless rec_set
 
         # TODO: move parsing logic to own class
 
         recs = rec_set[res_class_short.to_sym]
-        Log.d "record(s) #{ recs ? 'found' : 'not found' }"
+        Global.logger.debug "record(s) #{ recs ? 'found' : 'not found' }"
 
         # Loop over 1 or more
         recs = [recs]
@@ -72,25 +72,25 @@ module DnsOne; class ZoneSearch
     private
 
     def build_ignore_subdomains_re
-        if i = @conf[:ignore_subdomains].presence
+        if i = @conf.ignore_subdomains.presence
             s = i.strip.split(/\s+/).map(&:downcase).join '|'
             /^(#{ s })\./i
         end
     end
 
     def set_backend
-        if file = @conf[:backend][:file]
+        if file = @conf.backend.file
             unless ::File.exists? file
-                Util.die "Domain list file #{file} not found."
+                Util.die "Domain list file #{file} not found (pwd = #{Dir.pwd})."
             end
             Backend::File.new file
-        elsif @conf[:backend][:http_bell_url]
-            unless @conf[:backend][:http_bell_record_set]
+        elsif @conf.backend.http_bell_url
+            unless @conf.backend.http_bell_record_set
                 Util.die "backend.http_bell_record_set not set."
             end
-            Backend::HTTPBell.new @conf[:backend]
+            Backend::HTTPBell.new @conf.backend
         else
-            Backend::DB.new @conf[:backend]
+            Backend::DB.new @conf.backend
         end
     end
 
@@ -101,7 +101,7 @@ module DnsOne; class ZoneSearch
         enabled_cache = use_cache && @backend.allow_cache
 
         if enabled_cache and rec_set = @cache.find(dom_name)
-            Log.d "found in cache (#{@cache.stat})"
+            Global.logger.debug "found in cache (#{@cache.stat})"
             [rec_set, true]
         else
             if rec_set = @backend.find(dom_name)
@@ -130,11 +130,11 @@ module DnsOne; class ZoneSearch
     end
 
     def check_record_sets
-        if @conf[:record_sets].blank?
+        if @conf.record_sets.blank?
             Util.die "Record sets cannot be empty. Check file."
         end
 
-        @conf[:record_sets].each_pair do |rec_set_name, records|
+        @conf.record_sets.each_pair do |rec_set_name, records|
             unless records[:NS] and records[:NS].length >= 1
                 Util.die "Record set #{rec_set_name} is invalid. It must have at least 1 NS record."
             end

data/util/dns_one.service

@@ -6,8 +6,4 @@ Description=dns_one supervisor
 User=root
 Group=root
 Restart=on-failure
-WorkingDirectory=/var/local/dns_one
 ExecStart=/bin/bash -lc '/root/.rbenv/shims/dns_one'
-StandardOutput=syslog
-StandardError=syslog
-SyslogIdentifier=dns_one

data/util/sample_conf.yml

@@ -1,13 +1,12 @@
 
-config:
-  run_as: dnsserver                           # optional, but highly recommended! adduser --system dnsserver
-  ignore_subdomains: www en it es pt ru fr at # optional, defaults to an empty list
-  # cache_max: 100000                         # optional, defaults to 10000
-  # log_file: /var/log/dns_one.log              # optional, defaults to /var/log/dns_one.log
-  save_stats: false
-  log_result_file: false
-  log_result_socket: true
-  # log_result_socket_file: /tmp/dns_one_log_result.sock
+run_as: dnsserver                           # optional, but highly recommended! adduser --system dnsserver
+ignore_subdomains: www en it es pt ru fr at # optional, defaults to an empty list
+# cache_max: 100000                         # optional, defaults to 10000
+# log_file: /var/log/dns_one.log              # optional, defaults to /var/log/dns_one.log
+log_req_db: false
+log_req_file: false
+log_req_account: true
+# log_req_socket_file: /tmp/socket.socket
 
 backend:
   ############## 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dns_one
 version: !ruby/object:Gem::Version
-  version: 0.5.5
+  version: 0.5.6
 platform: ruby
 authors:
 - Tom Lobato
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-19 00:00:00.000000000 Z
+date: 2018-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 2.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 2.0.1
 - !ruby/object:Gem::Dependency
   name: rexec
   requirement: !ruby/object:Gem::Requirement
@@ -170,10 +170,13 @@ files:
 - lib/dns_one/core_ext/exception.rb
 - lib/dns_one/core_ext/hash.rb
 - lib/dns_one/core_ext/string.rb
-- lib/dns_one/log.rb
+- lib/dns_one/global.rb
+- lib/dns_one/req_log/account.rb
+- lib/dns_one/req_log/db.rb
+- lib/dns_one/req_log/file.rb
+- lib/dns_one/req_log/req_log.rb
 - lib/dns_one/server.rb
 - lib/dns_one/setup.rb
-- lib/dns_one/stat.rb
 - lib/dns_one/util.rb
 - lib/dns_one/version.rb
 - lib/dns_one/zone_search.rb
@@ -200,7 +203,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: DNS server for many zones sharing only one or few records, written in Ruby.

data/lib/dns_one/log.rb

@@ -1,72 +0,0 @@
-
-class Log < Logger
-    SYSLOG_MIN_SEVERITY = Logger::WARN
-
-    class << self
-
-        # 'def [d|i|w|e|f] msg' for DEBUG INFO WARN ERROR FATAL
-        Logger::Severity::constants.each do |severity|
-            method_name = severity.to_s[0].downcase
-            define_method(method_name) do |msg|
-                log severity, msg
-            end
-        end
-
-        def setup
-            @syslog = Syslog::Logger.new "dns_one"
-            @log_file = setfile "/var/log/dns_one.log"
-            @logger = Logger.new @log_file
-            @logger.level = Logger::INFO
-        end
-
-        def ruby_dns_logger
-            l = Logger.new setfile("/var/log/dns_one_rubydns.log")
-            l.level = Logger::WARN
-            l
-        end
-
-        def exc exception
-            e exception.desc
-        end
-
-        def logger
-            @logger
-        end
-
-        def log_file_desc
-            case @log_file
-            when STDOUT
-                'STDOUT'
-            when STDERR
-                'STDERR'
-            else
-                @log_file
-            end
-        end
-
-        private
-
-        def setfile file
-            if File.writable?(file) or File.writable?(File.dirname(file))
-                file
-            else
-                STDERR
-            end
-        end
-
-        def log severity, msg
-            met_name = severity.downcase
-
-            @logger.send met_name, msg
-
-            if sev_num(severity) >= SYSLOG_MIN_SEVERITY
-                @syslog.send met_name, msg
-            end
-        end
-
-        def sev_num sev
-            Object.const_get "Logger::#{sev}"
-        end
-    end
-end
-