FFI and ngx.shared.DICT

test_ffi.lua

local ffi = require 'ffi'
local C = ffi.C
local ffi_cast = ffi.cast
local ffi_str = ffi.string

local M = {}

ffi.cdef [[
    size_t strlen(const char *str);

    struct peer_rec {
        uint64_t      reconn_delay;
        uint64_t      unhealthy_at;
        char         *data_center;
        char         *release_version;
    };
]]

local str_const = ffi.typeof('char *')
local rec_peer_const = ffi.typeof('const struct peer_rec*')
local rec_peer_size = ffi.sizeof('struct peer_rec')
local rec_peer_cdata = ffi.new('struct peer_rec')

local shared = ngx.shared
local dict = shared.ldict

function M:set(key, reconn_delay, unhealthy_at, data_center, release_version)
  -- host info
  rec_peer_cdata.reconn_delay = reconn_delay
  rec_peer_cdata.unhealthy_at = unhealthy_at
  rec_peer_cdata.data_center = ffi_cast(str_const, data_center)
  rec_peer_cdata.release_version = ffi_cast(str_const, release_version)
  local ok , err = dict:safe_set(key, ffi_str(rec_peer_cdata,rec_peer_size))
  if not ok then 
      print(err)
  end
end
function M:rm(key)
	dict:delete(key)
end
function M:get(key)
    	local rec_v, err = dict:get(key)
	if err then
		return nil, 'Not' .. err
	elseif not rec_v then
		return nil, 'Key' .. key
	elseif type(rec_v) ~= 'string' or #rec_v ~= rec_peer_size then
		return nil, 'Bad'
	end

	ngx.log(ngx.ERR, 'key', key)
	local peer = ffi_cast(rec_peer_const, rec_v)	
  --	do return end
	--local len = C.strlen(peer.data_center)
	local data_center = ffi_str(peer.data_center, C.strlen(peer.data_center))
  	local release_version = ffi_str(peer.release_version, C.strlen(peer.release_version))
 	local reconn_delay = tonumber(peer.reconn_delay)
 	local unhealthy_at = tonumber(peer.unhealthy_at)
	return data_center, release_version, reconn_delay, unhealthy_at
end

return M