add support for unix sockets with lua posix (or ngx cosocket) via socket_path, fixes #76

Author: leafo

README.md

@@ -139,7 +139,8 @@ Available options:
 * `"ssl"`: enable ssl (default: `false`)
 * `"ssl_verify"`: verify server certificate (default: `nil`)
 * `"ssl_required"`: abort the connection if the server does not support SSL connections (default: `nil`)
-* `"socket_type"`: the type of socket to use, one of: `"nginx"`, `"luasocket"`, `cqueues` (default: `"nginx"` if in nginx, `"luasocket"` otherwise)
+* `"socket_type"`: the type of socket to use, one of: `"nginx"`, `"luasocket"`, `"cqueues"` (default: `"nginx"` if in nginx, `"luasocket"` otherwise)
+* `"socket_path"`: path to Unix socket (e.g. `"/var/run/postgresql/.s.PGSQL.5432"`); when set `host` and `port` are ignored. In nginx, connects using `unix:/path` syntax; otherwise uses luaposix
 * `"application_name"`: set the name of the connection as displayed in `pg_stat_activity`. (default: `"pgmoon"`)
 * `"pool_name"`: (OpenResty only) name of pool to use when using OpenResty cosocket (default: `"#{host}:#{port}:#{database}:#{user}"`)
 * `"pool_size"`: (OpenResty only) Passed directly to OpenResty cosocket connect function, [see docs](https://github.com/openresty/lua-nginx-module#tcpsockconnect)

pgmoon/init.lua

@@ -145,7 +145,8 @@ do
       user = "postgres",
       host = "127.0.0.1",
       port = "5432",
-      ssl = false
+      ssl = false,
+      socket_path = nil
     },
     type_serializers = {
       string = function(self, v)
@@ -258,7 +259,16 @@ do
           backlog = self.config.backlog
         }
       end
-      local ok, err = self.sock:connect(self.config.host, self.config.port, connect_opts)
+      local ok, err
+      if self.config.socket_path then
+        if self.sock_type == "nginx" then
+          ok, err = self.sock:connect("unix:" .. tostring(self.config.socket_path), connect_opts)
+        else
+          ok, err = self.sock:connect(self.config.socket_path)
+        end
+      else
+        ok, err = self.sock:connect(self.config.host, self.config.port, connect_opts)
+      end
       if not (ok) then
         self.busy = false
         return nil, err
@@ -1132,8 +1142,18 @@ do
         end
       })
       self.convert_null = self.config.convert_null
-      self.sock, self.sock_type = socket.new(self.config.socket_type)
       self.busy = false
+      local socket_type
+      if self.config.socket_path then
+        if ngx and ngx.get_phase() ~= "init" then
+          socket_type = "nginx"
+        else
+          socket_type = "luaposix"
+        end
+      else
+        socket_type = self.config.socket_type
+      end
+      self.sock, self.sock_type = socket.new(socket_type)
     end,
     __base = _base_0,
     __name = "Postgres"

pgmoon/init.moon

@@ -139,6 +139,7 @@ class Postgres
     host: "127.0.0.1"
     port: "5432"
     ssl: false
+    socket_path: nil
   }
 
   -- convert a lua value to pg_type.oid, string representation used for sending
@@ -248,9 +249,20 @@ class Postgres
     }
 
     @convert_null = @config.convert_null
-    @sock, @sock_type = socket.new @config.socket_type
     @busy = false
 
+    -- Auto-select socket type based on configuration
+    -- If socket_path is provided, use nginx cosocket when available, otherwise luaposix
+    socket_type = if @config.socket_path
+      if ngx and ngx.get_phase! != "init"
+        "nginx"
+      else
+        "luaposix"
+    else
+      @config.socket_type
+
+    @sock, @sock_type = socket.new socket_type
+
   connect: =>
     error "pgmoon: connection is busy" if @busy
     @busy = true
@@ -263,7 +275,14 @@ class Postgres
           backlog: @config.backlog
         }
 
-    ok, err = @sock\connect @config.host, @config.port, connect_opts
+    -- Handle Unix socket vs TCP connection
+    ok, err = if @config.socket_path
+      if @sock_type == "nginx"
+        @sock\connect "unix:#{@config.socket_path}", connect_opts
+      else
+        @sock\connect @config.socket_path
+    else
+      @sock\connect @config.host, @config.port, connect_opts
     unless ok
       @busy = false
       return nil, err
@@ -1069,4 +1088,3 @@ class Postgres
     "<Postgres socket: #{@sock}>"
 
 { :Postgres, new: Postgres, :VERSION }
-

pgmoon/socket.lua

@@ -1,3 +1,94 @@
+local create_luaposix_socket
+do
+  local flatten
+  flatten = require("pgmoon.util").flatten
+  local proxy_mt = {
+    __index = function(self, key)
+      local sock = self.sock
+      local original = sock[key]
+      if type(original) == "function" then
+        local fn
+        fn = function(_, ...)
+          return original(sock, ...)
+        end
+        self[key] = fn
+        return fn
+      else
+        return original
+      end
+    end
+  }
+  local method_overrides
+  method_overrides = {
+    connect = function(self, socket_path)
+      local posix_socket = require("posix.sys.socket")
+      local addr = {
+        family = posix_socket.AF_UNIX,
+        path = socket_path
+      }
+      local result, err, _ = posix_socket.connect(self.sock.fd, addr)
+      if result then
+        return true
+      else
+        return nil, err
+      end
+    end,
+    send = function(self, ...)
+      local posix_socket = require("posix.sys.socket")
+      local data = flatten(...)
+      local result, err, _ = posix_socket.send(self.sock.fd, data)
+      if result then
+        return #data, nil
+      else
+        return nil, err
+      end
+    end,
+    receive = function(self, bytes)
+      local posix_socket = require("posix.sys.socket")
+      local result, err, _ = posix_socket.recv(self.sock.fd, bytes)
+      if result then
+        return result
+      else
+        return nil, err
+      end
+    end,
+    settimeout = function(self, t)
+      self.timeout = t
+    end,
+    close = function(self)
+      local posix_unistd = require("posix.unistd")
+      return posix_unistd.close(self.sock.fd)
+    end,
+    setkeepalive = function(self)
+      return error("You attempted to call setkeepalive on a Unix socket. This method is only available for the ngx cosocket API for releasing a socket back into the connection pool")
+    end,
+    getreusedtimes = function(self, t)
+      return 0
+    end,
+    sslhandshake = function(self, opts)
+      if opts == nil then
+        opts = { }
+      end
+      return error("SSL handshake is not supported over Unix domain sockets")
+    end
+  }
+  create_luaposix_socket = function(...)
+    local posix_socket = require("posix.sys.socket")
+    local sockfd, err, _ = posix_socket.socket(posix_socket.AF_UNIX, posix_socket.SOCK_STREAM, 0)
+    if not (sockfd) then
+      error("Failed to create Unix socket: " .. tostring(err))
+    end
+    local proxy = {
+      sock = {
+        fd = sockfd
+      }
+    }
+    for k, v in pairs(method_overrides) do
+      proxy[k] = v
+    end
+    return setmetatable(proxy, proxy_mt)
+  end
+end
 local create_luasocket
 do
   local flatten
@@ -85,6 +176,7 @@ do
 end
 return {
   create_luasocket = create_luasocket,
+  create_luaposix_socket = create_luaposix_socket,
   new = function(socket_type)
     if socket_type == nil then
       if ngx and ngx.get_phase() ~= "init" then
@@ -99,6 +191,8 @@ return {
       socket = ngx.socket.tcp()
     elseif "luasocket" == _exp_0 then
       socket = create_luasocket()
+    elseif "luaposix" == _exp_0 then
+      socket = create_luaposix_socket()
     elseif "cqueues" == _exp_0 then
       socket = require("pgmoon.cqueues").CqueuesSocket()
     else

pgmoon/socket.moon

@@ -1,4 +1,84 @@
 
+-- creates a luaposix unix socket proxy to make it behave like ngx.socket.tcp
+create_luaposix_socket = do
+  import flatten from require "pgmoon.util"
+
+  proxy_mt = {
+    __index: (key) =>
+      sock = @sock
+      original = sock[key]
+      if type(original) == "function"
+        fn = (_, ...) ->
+          original sock, ...
+        @[key] = fn
+        fn
+      else
+        original
+  }
+
+  -- these methods are overidden from the default socket implementation
+  -- all other methods/properties are carried over via the __index metamethod above
+  local method_overrides
+  method_overrides = {
+    connect: (socket_path) =>
+      posix_socket = require "posix.sys.socket"
+      addr = { family: posix_socket.AF_UNIX, path: socket_path }
+      result, err, _ = posix_socket.connect @sock.fd, addr
+      if result
+        true
+      else
+        nil, err
+
+    send: (...) =>
+      posix_socket = require "posix.sys.socket"
+      data = flatten ...
+      result, err, _ = posix_socket.send @sock.fd, data
+      if result
+        #data, nil
+      else
+        nil, err
+
+    receive: (bytes) =>
+      posix_socket = require "posix.sys.socket"
+      result, err, _ = posix_socket.recv @sock.fd, bytes
+      if result
+        result
+      else
+        nil, err
+
+    settimeout: (t) =>
+      -- Unix sockets don't have built-in timeout, but we store it for compatibility
+      @timeout = t
+
+    close: =>
+      posix_unistd = require "posix.unistd"
+      posix_unistd.close @sock.fd
+
+    setkeepalive: =>
+      error "You attempted to call setkeepalive on a Unix socket. This method is only available for the ngx cosocket API for releasing a socket back into the connection pool"
+
+    getreusedtimes: (t) => 0
+
+    sslhandshake: (opts={}) =>
+      error "SSL handshake is not supported over Unix domain sockets"
+  }
+
+  (...) ->
+    posix_socket = require "posix.sys.socket"
+    sockfd, err, _ = posix_socket.socket posix_socket.AF_UNIX, posix_socket.SOCK_STREAM, 0
+
+    unless sockfd
+      error "Failed to create Unix socket: #{err}"
+
+    proxy = {
+      sock: { fd: sockfd }
+    }
+
+    for k,v in pairs method_overrides
+      proxy[k] = v
+
+    setmetatable proxy, proxy_mt
+
 -- creates a luasocket socket proxy to make it behave like ngx.socket.tcp
 create_luasocket = do
   import flatten from require "pgmoon.util"
@@ -76,6 +156,7 @@ create_luasocket = do
 
 {
   :create_luasocket
+  :create_luaposix_socket
 
   new: (socket_type) ->
     if socket_type == nil
@@ -93,6 +174,8 @@ create_luasocket = do
         ngx.socket.tcp!
       when "luasocket"
         create_luasocket!
+      when "luaposix"
+        create_luaposix_socket!
       when "cqueues"
         require("pgmoon.cqueues").CqueuesSocket!
       else

spec/pgmoon_unix_spec.moon

@@ -0,0 +1,72 @@
+import Postgres from require "pgmoon"
+
+SOCKET_PATH = "/var/run/postgresql/.s.PGSQL.5432"
+
+-- Basic test to verify Unix socket support loads correctly
+describe "Unix socket support", ->
+  it "should choose nginx or luaposix when socket_path is provided", ->
+    pg = Postgres {
+      socket_path: "/tmp/test.sock"
+      user: "postgres"
+      database: "test"
+    }
+
+    if ngx and ngx.get_phase! != "init"
+      assert.equal "nginx", pg.sock_type
+    else
+      assert.equal "luaposix", pg.sock_type
+
+  it "should accept socket_path in configuration", ->
+    pg = Postgres {
+      socket_path: SOCKET_PATH
+      user: "postgres"
+      database: "test"
+    }
+
+    assert.equal SOCKET_PATH, pg.config.socket_path
+
+  it "should default to luasocket when no socket_path is provided", ->
+    pg = Postgres {
+      user: "postgres"
+      database: "test"
+    }
+
+    -- Should not be luaposix since no socket_path provided
+    assert.is_not.equal "luaposix", pg.sock_type
+
+  it "should have socket_path as nil in default config", ->
+    pg = Postgres {}
+    assert.is_nil pg.config.socket_path
+
+  it "should override socket_type when socket_path is provided", ->
+    -- Even if we explicitly set socket_type to something else,
+    -- providing socket_path should force luaposix
+    pg = Postgres {
+      socket_type: "luasocket"
+      socket_path: "/tmp/test.sock"
+      user: "postgres"
+      database: "test"
+    }
+
+    if ngx and ngx.get_phase! != "init"
+      assert.equal "nginx", pg.sock_type
+    else
+      assert.equal "luaposix", pg.sock_type
+
+  -- This test would require an actual Unix socket PostgreSQL server
+  -- Keeping it commented out for now
+  it "should connect via Unix socket", ->
+    pg = Postgres {
+      socket_path: SOCKET_PATH
+      user: "postgres"
+      database: "postgres"
+    }
+
+    success, err = pg\connect!
+    assert success, "Failed to connect: #{err}"
+
+    result, err = pg\query "SELECT 1 as test"
+    assert result, "Failed to query: #{err}"
+    assert.equal 1, result[1].test
+
+    pg\disconnect!