feat(core) upstreams

kong-0.9.0-0.rockspec

@@ -27,7 +27,8 @@ dependencies = {
   "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",
 }
 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",
@@ -74,7 +74,9 @@ build = {
     ["kong.api.routes.plugins"] = "kong/api/routes/plugins.lua",
     ["kong.api.routes.cache"] = "kong/api/routes/cache.lua",
     ["kong.api.routes.cluster"] = "kong/api/routes/cluster.lua",
+    ["kong.api.routes.upstreams"] = "kong/api/routes/upstreams.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",
@@ -90,13 +92,16 @@ build = {
     ["kong.core.cluster"] = "kong/core/cluster.lua",
     ["kong.core.events"] = "kong/core/events.lua",
     ["kong.core.error_handlers"] = "kong/core/error_handlers.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.dao.schemas.apis"] = "kong/dao/schemas/apis.lua",
     ["kong.dao.schemas.nodes"] = "kong/dao/schemas/nodes.lua",
     ["kong.dao.schemas.consumers"] = "kong/dao/schemas/consumers.lua",
     ["kong.dao.schemas.plugins"] = "kong/dao/schemas/plugins.lua",
+    ["kong.dao.schemas.upstreams"] = "kong/dao/schemas/upstreams.lua",
+    ["kong.dao.schemas.targets"] = "kong/dao/schemas/targets.lua",
     ["kong.dao.base_db"] = "kong/dao/base_db.lua",
     ["kong.dao.cassandra_db"] = "kong/dao/cassandra_db.lua",
     ["kong.dao.postgres_db"] = "kong/dao/postgres_db.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/api/crud_helpers.lua

@@ -41,6 +41,24 @@ function _M.find_consumer_by_username_or_id(self, dao_factory, helpers)
   end
 end
 
+function _M.find_upstream_by_name_or_id(self, dao_factory, helpers)
+  local filter_keys = {
+    [utils.is_valid_uuid(self.params.name_or_id) and "id" or "name"] = self.params.name_or_id
+  }
+  self.params.name_or_id = nil
+
+  local rows, err = dao_factory.upstreams:find_all(filter_keys)
+  if err then
+    return helpers.yield_error(err)
+  end
+
+  -- We know name and id are unique, so if we have a row, it must be the only one
+  self.upstream = rows[1]
+  if not self.upstream then
+    return helpers.responses.send_HTTP_NOT_FOUND()
+  end
+end
+
 function _M.paginated_set(self, dao_collection)
   local size = self.params.size and tonumber(self.params.size) or 100
   local offset = self.params.offset and ngx.decode_base64(self.params.offset) or nil

kong/api/init.lua

@@ -108,7 +108,7 @@ local function insert_405(routes)
 end
 
 -- Load core routes
-for _, v in ipairs({"kong", "apis", "consumers", "plugins", "cache", "cluster" }) do
+for _, v in ipairs({"kong", "apis", "consumers", "plugins", "cache", "cluster", "upstreams" }) do
   local routes = require("kong.api.routes."..v)
   attach_routes(insert_405(routes))
 end

kong/api/routes/upstreams.lua

@@ -0,0 +1,51 @@
+local crud = require "kong.api.crud_helpers"
+local reports = require "kong.core.reports"
+
+return {
+  ["/upstreams/"] = {
+    GET = function(self, dao_factory)
+      crud.paginated_set(self, dao_factory.upstreams)
+    end,
+
+    PUT = function(self, dao_factory)
+      crud.put(self.params, dao_factory.upstreams)
+    end,
+
+    POST = function(self, dao_factory, helpers)
+      crud.post(self.params, dao_factory.upstreams)
+    end
+  },
+
+  ["/upstreams/:name_or_id"] = {
+    before = function(self, dao_factory, helpers)
+      crud.find_upstream_by_name_or_id(self, dao_factory, helpers)
+    end,
+
+    GET = function(self, dao_factory, helpers)
+      return helpers.responses.send_HTTP_OK(self.upstream)
+    end,
+
+    PATCH = function(self, dao_factory)
+      crud.patch(self.params, dao_factory.upstreams, self.upstream)
+    end,
+
+    DELETE = function(self, dao_factory)
+      crud.delete(self.upstream, dao_factory.upstreams)
+    end
+  },
+
+  ["/upstreams/:name_or_id/targets/"] = {
+    before = function(self, dao_factory, helpers)
+      crud.find_upstream_by_name_or_id(self, dao_factory, helpers)
+      self.params.upstream_id = self.upstream.id
+    end,
+
+    GET = function(self, dao_factory)
+      crud.paginated_set(self, dao_factory.targets)
+    end,
+
+    POST = function(self, dao_factory)
+      crud.post(self.params, dao_factory.targets)
+    end,
+  },
+}

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"
@@ -14,9 +13,6 @@ local function execute(args)
   local dao = DAOFactory(conf)
   assert(dao:run_migrations())
   assert(prefix_handler.prepare_prefix(conf, args.nginx_conf))
-  if conf.dnsmasq then
-    assert(dnsmasq_signals.start(conf))
-  end
   assert(serf_signals.start(conf, dao))
   assert(nginx_signals.start(conf))
   log("Kong started")

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

@@ -154,9 +154,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"},
 
@@ -174,13 +174,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