feat(core) implement internal dns with loadbalancing, replace dnsmasq

bin/busted

@@ -1,19 +1,13 @@
-#!/usr/bin/env resty
+#!/usr/bin/env resty -c 65535
 
 -- a flag to detect whether our modules (especially kong.core.globalpatches)
 -- are running under resty-cli or in a real ngx_lua, runtime environment.
 ngx.RESTY_CLI = true
 
--- force LuaSocket usage to resolve `/etc/hosts` until
--- supported by resty-cli.
--- See https://github.com/Mashape/kong/issues/1523
-for _, namespace in ipairs({"cassandra", "pgmoon-mashape"}) do
-  local socket = require(namespace .. ".socket")
-  socket.force_luasocket(ngx.get_phase(), true)
-end
+require "kong.core.globalpatches"
 
 if ngx ~= nil then
-  ngx.exit = function()end
+  ngx.exit = function() end
 end
 
 -- Busted command-line runner

bin/kong

@@ -1,16 +1,12 @@
-#!/usr/bin/env resty
+#!/usr/bin/env resty -c 65535
 
 -- a flag to detect whether our modules (especially kong.core.globalpatches)
 -- are running under resty-cli or in a real ngx_lua, runtime environment.
 ngx.RESTY_CLI = true
 
--- force LuaSocket usage to resolve `/etc/hosts` until
--- supported by resty-cli.
--- See https://github.com/Mashape/kong/issues/1523
-for _, namespace in ipairs({"cassandra", "pgmoon-mashape"}) do
-  local socket = require(namespace .. ".socket")
-  socket.force_luasocket(ngx.get_phase(), true)
-end
+-- require global patches, to enable dns resolution by the internal client
+-- initializing the dns client is done in `./kong/conf_loader.lua` 
+require "kong.core.globalpatches"
 
 if ngx ~= nil then
   ngx.exit = function()end

kong-0.9.2-0.rockspec

@@ -21,13 +21,14 @@ dependencies = {
   "version == 0.2",
   "lapis == 1.5.1",
   "lua-cassandra == 0.5.4",
-  "pgmoon-mashape == 2.0.0",
+  "pgmoon == 1.6.0",
   "luatz == 0.3",
   "lua_system_constants == 0.1.1",
   "lua-resty-iputils == 0.2.1",
   "luacrypto == 0.3.2",
   "luasyslog == 1.0.0",
-  "lua_pack == 1.0.4"
+  "lua_pack == 1.0.4",
+  "dns == 0.1.0",
 }
 build = {
   type = "builtin",
@@ -63,7 +64,6 @@ build = {
     ["kong.cmd.utils.serf_signals"] = "kong/cmd/utils/serf_signals.lua",
     ["kong.cmd.utils.nginx_signals"] = "kong/cmd/utils/nginx_signals.lua",
     ["kong.cmd.utils.prefix_handler"] = "kong/cmd/utils/prefix_handler.lua",
-    ["kong.cmd.utils.dnsmasq_signals"] = "kong/cmd/utils/dnsmasq_signals.lua",
 
     ["kong.api.init"] = "kong/api/init.lua",
     ["kong.api.api_helpers"] = "kong/api/api_helpers.lua",
@@ -75,6 +75,7 @@ build = {
     ["kong.api.routes.cache"] = "kong/api/routes/cache.lua",
     ["kong.api.routes.cluster"] = "kong/api/routes/cluster.lua",
 
+    ["kong.tools.dns"] = "kong/tools/dns.lua",
     ["kong.tools.utils"] = "kong/tools/utils.lua",
     ["kong.tools.printable"] = "kong/tools/printable.lua",
     ["kong.tools.responses"] = "kong/tools/responses.lua",
@@ -91,6 +92,7 @@ build = {
     ["kong.core.events"] = "kong/core/events.lua",
     ["kong.core.error_handlers"] = "kong/core/error_handlers.lua",
     ["kong.core.globalpatches"] = "kong/core/globalpatches.lua",
+    ["kong.core.balancer"] = "kong/core/balancer.lua",
 
     ["kong.dao.errors"] = "kong/dao/errors.lua",
     ["kong.dao.schemas_validation"] = "kong/dao/schemas_validation.lua",

kong.conf.default

@@ -231,18 +231,13 @@
 # DNS RESOLVER
 #------------------------------------------------------------------------------
 
-#dnsmasq = on                    # Toggles if Kong should start/stop dnsmasq,
-                                 # which can be used as the Nginx DNS resolver.
-                                 # Using dnsmasq allows Nginx to resolve
-                                 # domains defined in /etc/hosts.
-                                 # dnsmasq must be installed and available in
-                                 # your $PATH.
-
-#dnsmasq_port = 8053             # The port on which dnsmasq should listen to
-                                 # for queries.
-
-#dns_resolver = 8.8.8.8          # Configure a name server to be used by Nginx.
-                                 # Only valid when `dnsmasq` is disabled.
+#dns_resolver =                  # Comma separated list of name servers, each
+                                 # entry in `ipv4[:port]` format to be used by
+                                 # Kong. If not specified the nameservers in
+                                 # the local `resolv.conf` file will be used.
+                                 # Port defaults to 53 if omitted.
+
+#dns_hostsfile = /etc/hosts      # The `hosts` file to use.
 
 #------------------------------------------------------------------------------
 # DEVELOPMENT & MISCELLANEOUS

kong/cmd/compile.lua

@@ -24,7 +24,7 @@ Example usage:
  }
 
 Note:
- Third-party services such as Serf and dnsmasq need to be properly configured
+ Third-party services such as Serf need to be properly configured
  and started for Kong to be fully compatible while embedded.
 
 Options:

kong/cmd/health.lua

@@ -21,7 +21,6 @@ local function execute(args)
   local pids = {
     serf = conf.serf_pid,
     nginx = conf.nginx_pid,
-    dnsmasq = conf.dnsmasq and conf.dnsmasq_pid or nil
   }
 
   local count = 0

kong/cmd/quit.lua

@@ -1,4 +1,3 @@
-local dnsmasq_signals = require "kong.cmd.utils.dnsmasq_signals"
 local nginx_signals = require "kong.cmd.utils.nginx_signals"
 local serf_signals = require "kong.cmd.utils.serf_signals"
 local conf_loader = require "kong.conf_loader"
@@ -39,10 +38,6 @@ local function execute(args)
 
   assert(serf_signals.stop(conf, DAOFactory(conf)))
 
-  if conf.dnsmasq then
-    assert(dnsmasq_signals.stop(conf))
-  end
-
   log("Kong stopped (gracefully)")
 end
 

kong/cmd/reload.lua

@@ -1,4 +1,3 @@
-local dnsmasq_signals = require "kong.cmd.utils.dnsmasq_signals"
 local prefix_handler = require "kong.cmd.utils.prefix_handler"
 local nginx_signals = require "kong.cmd.utils.nginx_signals"
 local serf_signals = require "kong.cmd.utils.serf_signals"
@@ -22,9 +21,6 @@ local function execute(args)
     prefix = args.prefix
   }))
   assert(prefix_handler.prepare_prefix(conf, args.nginx_conf))
-  if conf.dnsmasq then
-    assert(dnsmasq_signals.start(conf))
-  end
   assert(serf_signals.start(conf, DAOFactory(conf)))
   assert(nginx_signals.reload(conf))
   log("Kong reloaded")

kong/cmd/restart.lua

@@ -16,7 +16,7 @@ end
 local lapp = [[
 Usage: kong restart [OPTIONS]
 
-Restart a Kong node (and other configured services like dnsmasq and Serf)
+Restart a Kong node (and other configured services like Serf)
 in the given prefix directory.
 
 This command is equivalent to doing both 'kong stop' and

kong/cmd/start.lua

@@ -1,4 +1,3 @@
-local dnsmasq_signals = require "kong.cmd.utils.dnsmasq_signals"
 local prefix_handler = require "kong.cmd.utils.prefix_handler"
 local nginx_signals = require "kong.cmd.utils.nginx_signals"
 local serf_signals = require "kong.cmd.utils.serf_signals"
@@ -20,24 +19,18 @@ local function execute(args)
   xpcall(function()
     assert(prefix_handler.prepare_prefix(conf, args.nginx_conf))
     assert(dao:run_migrations())
-    if conf.dnsmasq then
-      assert(dnsmasq_signals.start(conf))
-    end
     assert(serf_signals.start(conf, dao))
     assert(nginx_signals.start(conf))
     log("Kong started")
   end, function(e)
-    log.verbose("could not start Kong, stopping services")
-    pcall(nginx_signals.stop(conf))
-    pcall(serf_signals.stop(conf, dao))
-    if conf.dnsmasq then
-      pcall(dnsmasq_signals.stop(conf))
-    end
     err = e -- cannot throw from this function
-    log.verbose("stopped services")
   end)
 
   if err then
+    log.verbose("could not start Kong, stopping services")
+    pcall(nginx_signals.stop(conf))
+    pcall(serf_signals.stop(conf, dao))
+    log.verbose("stopped services")
     error(err) -- report to main error handler
   end
 end

kong/cmd/stop.lua

@@ -1,4 +1,3 @@
-local dnsmasq_signals = require "kong.cmd.utils.dnsmasq_signals"
 local nginx_signals = require "kong.cmd.utils.nginx_signals"
 local serf_signals = require "kong.cmd.utils.serf_signals"
 local conf_loader = require "kong.conf_loader"
@@ -20,9 +19,6 @@ local function execute(args)
   local conf = assert(conf_loader(default_conf.kong_conf))
   assert(nginx_signals.stop(conf))
   assert(serf_signals.stop(conf, DAOFactory(conf)))
-  if conf.dnsmasq then
-    assert(dnsmasq_signals.stop(conf))
-  end
   log("Kong stopped")
 end
 

kong/cmd/utils/prefix_handler.lua

@@ -159,9 +159,6 @@ local function compile_conf(kong_config, conf_template)
     tostring = tostring
   }
 
-  if kong_config.dnsmasq then
-    compile_env["dns_resolver"] = "127.0.0.1:"..kong_config.dnsmasq_port
-  end
   if kong_config.anonymous_reports and socket.dns.toip(constants.SYSLOG.ADDRESS) then
     compile_env["syslog_reports"] = fmt("error_log syslog:server=%s:%d error;",
                                         constants.SYSLOG.ADDRESS, constants.SYSLOG.PORT)

kong/conf_loader.lua

@@ -7,16 +7,17 @@ local pl_config = require "pl.config"
 local pl_file = require "pl.file"
 local pl_path = require "pl.path"
 local tablex = require "pl.tablex"
+local utils = require "kong.tools.utils"
 local log = require "kong.cmd.utils.log"
 
+local ipv4_port_pattern = "^(%d+)%.(%d+)%.(%d+)%.(%d+):(%d+)$"
+
 local DEFAULT_PATHS = {
   "/etc/kong.conf",
   "/etc/kong/kong.conf"
 }
 
 local PREFIX_PATHS = {
-  dnsmasq_pid = {"pids", "dnsmasq.pid"}
-  ;
   serf_pid = {"pids", "serf.pid"},
   serf_log = {"logs", "serf.log"},
   serf_event = {"serf", "serf_event.sh"},
@@ -75,8 +76,7 @@ local CONF_INFERENCES = {
   cluster_profile = {enum = {"local", "lan", "wan"}},
   cluster_ttl_on_failure = {typ = "number"},
 
-  dnsmasq = {typ = "boolean"},
-  dnsmasq_port = {typ = "number"},
+  dns_resolver = {typ = "array"},
 
   ssl = {typ = "boolean"},
 
@@ -177,13 +177,16 @@ local function check_and_infer(conf)
     end
   end
 
-  if conf.dns_resolver and conf.dnsmasq then
-    errors[#errors+1] = "must disable dnsmasq when a custom DNS resolver is specified"
-  elseif not conf.dns_resolver and not conf.dnsmasq then
-    errors[#errors+1] = "must specify a custom DNS resolver when dnsmasq is turned off"
+  if conf.dns_resolver then
+    for _, server in ipairs(conf.dns_resolver) do
+      local dns = utils.normalize_ip(server)
+      if (not dns) or (dns.type ~= "ipv4") then
+        errors[#errors+1] = "dns_resolver must be a comma separated list in the form of IPv4 or IPv4:port"
+        break -- one error is enough
+      end
+    end
   end
 
-  local ipv4_port_pattern = "^(%d+)%.(%d+)%.(%d+)%.(%d+):(%d+)$"
   if not conf.cluster_listen:match(ipv4_port_pattern) then
     errors[#errors+1] = "cluster_listen must be in the form of IPv4:port"
   end
@@ -371,6 +374,10 @@ local function load(path, custom_conf)
 
   log.verbose("prefix in use: %s", conf.prefix)
 
+  -- initialize the dns client, so the globally patched tcp.connect method
+  -- will work from here onwards.
+  assert(require("kong.tools.dns")(conf))
+
   return setmetatable(conf, nil) -- remove Map mt
 end