colddb/colddb.lua
2018-11-05 22:13:37 -06:00

636 lines
16 KiB
Lua

colddb = {}
local ie = ...
local function createDir(directory)
return minetest.mkdir(directory)
end
function colddb.file_Exists(db,name,tag_name)
local t = ""
if tag_name then
t = colddb.get_tag(db,tag_name)
end
local f = io.open(string.format("%s%s%s.cold",db.directory,t,name),"r")
if f ~= nil then
io.close(f)
return true
else
return false
end
return false
end
function colddb.get_db(directory)
local directory = string.format("%s/%s",minetest.get_worldpath(),directory)
if not createDir(directory) then
error(string.format("%s is not a directory.",directory))
end
db = {
global_tag = "",
directory = directory,
tags = {},
mem_pool = {},
indexes_pool = {},
iterate_queue = {},
indexes = false,
add_to_mem_pool = true,
}
return db
end
function colddb.add_global_tag(db,tag)
local t = ""
if type(tag) == "table" then
for index in pairs(tag) do
t = string.format("%s%s/",t,index)
end
else
t = string.format("%s/",tag)
end
db.global_tag = string.format("%s%s",db.global_tag,t)
db.directory = string.format("%s/%s",db.directory,t)
if not createDir(db.directory) then
error(string.format("%s is not a directory.",db.directory))
end
end
function colddb.add_tag(db,name,tag)
local t = ""
if not db.tags[name] then
db.tags[name] = ""
end
if type(tag) == "table" then
for _index in pairs(tag) do
t = string.format("%s%s/",t,_index)
end
else
t = string.format("%s/",tag)
end
local test_path = string.format("%s%s%s",db.directory,db.tags[name],t)
if not createDir(test_path) then
error(string.format("%s is not a directory.",test_path))
end
db.tags[name] = string.format("%s%s",db.tags[name],t)
end
function colddb.get_tag(db,name)
if not name then
return ""
end
local tag = db.tags[name]
if tag then
return tag
end
return ""
end
function colddb.get_or_add_tag(db,name,tag)
if not db.tags[name] then
colddb.add_tag(db,name,tag)
end
return name
end
function colddb.remove_tag(db,name)
if db.tags[name] then
local delete_path = string.format("%s%s",db.directory,db.tags[name])
local wc = delete_path:len()
delete_path = delete_path:sub(0,wc-1)
db.tags[name] = nil
local err,msg = os.remove(delete_path)
if err == nil and ie then
local err,msg = ie.os.remove(delete_path)
if err == nil and ie then
assert(ie, "Please add colddb to secure.trusted_mods in the settings")
end
end
end
end
function colddb.delete_file(db,name,tag_name)
local t = ""
if tag_name then
t = colddb.get_tag(db,tag_name)
end
local text = string.format("%s%s%s.cold",db.directory,t,name)
local err,msg = os.remove(text)
if err == nil then
print(string.format("error removing db data %s error message: %s",text,msg))
end
end
function colddb.load_table(db,name,tag_name)
local t = ""
if tag_name then
t = colddb.get_tag(db,tag_name)
end
local f = io.open(string.format("%s%s%s.cold",db.directory,t,name), "r")
if f then
local data = minetest.deserialize(f:read("*a"))
f:close()
return data
end
return nil
end
function colddb.save_table(db,name, _table,tag_name)
local t = ""
if tag_name then
t = colddb.get_tag(db,tag_name)
end
return minetest.safe_file_write(string.format("%s%s%s.cold",db.directory,t,name), minetest.serialize(_table))
end
function colddb.save_key(db,name,tag_name)
local t = ""
if tag_name then
t = colddb.get_tag(db,tag_name)
end
return minetest.safe_file_write(string.format("%s%s%s.cold",db.directory,t,name), "")
end
function colddb.load_key(db,name,tag_name)
local t = ""
if tag_name then
t = colddb.get_tag(db,tag_name)
end
local f = io.open(string.format("%s%s%s.cold",db.directory,t,name), "r")
if f then
f:close()
return true
end
return false
end
function colddb.delete_index_table(db,tag_name)
local t = ""
local name = "æIndex_table"
if tag_name then
t = colddb.get_tag(db,tag_name)
end
local p = string.format("%s%sæIndex_table.cold",db.directory,t)
if colddb.file_Exists(db,name,tag_name) then
local err,msg = os.remove(p)
if err == nil then
print(string.format("error removing db data %s error message: %s",p,msg))
end
return true
end
return false
end
local function delete_lines_func_begin(args)
local f = io.open(args.copyfile, "w")
local db = args.db
local cs = args.cs
if f then
args.file = f
args.removedlist = {}
return args
end
return false
end
local function delete_lines_func_i(line,i,args)
local f = args.file
local db = args.db
local cs = args.cs
local om = db.indexes_pool[args.cs]
if om and not om.deleted_items[line] then
f:write(string.format("\n%s",line))
else
args.count = args.count - 1
args.removedlist[line] = true
end
end
local function delete_lines_func_end(args)
local db = args.db
local cs = args.cs
if db.indexes_pool[cs] or db.indexes_pool[cs].file then
db.indexes_pool[cs].file:close()
db.indexes_pool[cs].file = nil
args.file:seek("set")
args.file:write(string.format("%i",args.count))
args.file:close()
os.remove(args.oldfile)
os.rename(args.copyfile, args.oldfile)
for i,l in pairs(args.removedlist) do
db.indexes_pool[cs].deleted_items[i] = nil
end
db.indexes_pool[cs].deleting = false
end
args = nil
end
function colddb.delete_lines(db,_lines,tag_name)
local t = ""
local name = "æIndex_table"
if tag_name then
t = colddb.get_tag(db,tag_name)
end
local cs = string.format("%s%s",t,name)
local f = db.indexes_pool[cs]
local k = type(_lines)
if k == "string" then
f.deleted_items[_lines] = true
else
for i,l in pairs(_lines) do
f.deleted_items[i] = true
end
end
if not db.indexes_pool[cs].deleting then
db.indexes_pool[cs].deleting = false
end
if f and f.file and not db.indexes_pool[cs].deleting then
db.indexes_pool[cs].deleting = true
if db.indexes_pool[cs].needs_flushing == true then
f.file:flush()
db.indexes_pool[cs].needs_flushing = false
end
local oldfile = string.format("%s%sæIndex_table.cold",db.directory,t)
local copyfile = string.format("%s%sæIndex_table.cold.replacer",db.directory,t)
local args = {db=db,cs=cs,oldfile=oldfile,copyfile=copyfile,do_not_skip_removed_items=true}
db.indexes_pool[cs] = f
colddb.iterate_index_table(db,delete_lines_func_begin,delete_lines_func_i,delete_lines_func_end,150,args,tag_name)
end
end
function colddb.create_index_table(db,tag_name)
local t = ""
local name = "æIndex_table"
if tag_name then
t = colddb.get_tag(db,tag_name)
end
local p = string.format("%s%sæIndex_table.cold",db.directory,t)
if not colddb.file_Exists(db,name,tag_name) then
local f = io.open(p, "w")
if f then
f:seek("set")
f:write("0")
f:close()
end
end
local f = io.open(p, "r+")
if f then
f:seek("set")
f:write("0")
db.indexes_pool[string.format("%s%s",t,name)] = {file = f,needs_flushing = false,deleted_items = {},iterating = false,inuse = false}
return true
end
return false
end
function colddb.open_index_table(db,tag_name)
local t = ""
local name = "æIndex_table"
if tag_name then
t = colddb.get_tag(db,tag_name)
end
local cs = string.format("%s%s",t,name)
local fs = db.indexes_pool[cs]
if not fs then
local p = string.format("%s%sæIndex_table.cold",db.directory,t)
if not colddb.file_Exists(db,name,tag_name) then
local f = io.open(p, "w")
if f then
f:seek("set")
f:write("0")
f:close()
end
end
local f = io.open(p, "r+")
if f then
db.indexes_pool[cs] = {file = f,needs_flushing = false,deleted_items = {},iterating = false,inuse = true}
return f
end
return nil
else
return fs.file
end
return nil
end
function colddb.append_index_table(db,key,tag_name)
local t = ""
local name = "æIndex_table"
if tag_name then
t = colddb.get_tag(db,tag_name)
end
local cs = string.format("%s%s",t,name)
local f = db.indexes_pool[cs]
local k = type(key)
if f and f.file and k == "string" then
local fl = f.file
if f.needs_flushing == true then
fl:flush()
end
db.indexes_pool[cs].needs_flushing = true
db.indexes_pool[cs].inuse = true
fl:seek("end")
fl:write(string.format("\n%s",key))
fl:seek("set")
local count = tonumber(fl:read("*l"))
count = count + 1
fl:seek("set")
fl:write(string.format("%i",count))
elseif f and f.file then
local fl = f.file
if f.needs_flushing == true then
fl:flush()
end
db.indexes_pool[cs].needs_flushing = true
db.indexes_pool[cs].inuse = true
local c = 0
for i in pairs(key) do
fl:seek("end")
fl:write(string.format("\n%s",i))
c = c + 1
end
fl:seek("set")
local count = tonumber(fl:read("*l"))
count = count + c
fl:seek("set")
fl:write(string.format("%i",count))
else
return false
end
end
function colddb.get_count(db,tag_name)
local t = ""
local name = "æIndex_table"
if tag_name then
t = colddb.get_tag(db,tag_name)
end
local cs = string.format("%s%s",t,name)
local f = db.indexes_pool[cs]
if f and f.file then
local fl = f.file
if f.needs_flushing == true then
fl:flush()
f.needs_flushing = true
end
fl:seek("set")
local count = tonumber(fl:read("*l"))
db.indexes_pool[cs].inuse = true
return count
end
return nil
end
local function iterate(db,func_on_iterate,end_func,cycles_per_tick,count,cs,args)
local f = db.indexes_pool[cs]
f.inuse = true
local fl = f.file
for i=1,cycles_per_tick do
if count < 1 then
break
end
local line = fl:read("*l")
if args.do_not_skip_removed_items or not db.indexes_pool[cs].deleted_items[line] then
func_on_iterate(line,i,args)
end
count = count - 1
end
db.indexes_pool[cs] = f
if count < 1 then
if end_func then
end_func(args)
end
if db.iterate_queue[cs] and db.iterate_queue[cs][1] then
local copy = db.iterate_queue[cs][1]
if copy.begin_func then
local a = copy.begin_func(copy.args)
if a and type(a) == "table" then
copy.args = a
end
end
minetest.after(0,iterate,copy.db,copy.func_on_iterate,copy.end_func,copy.cycles_per_tick,copy.count,copy.cs,copy.args)
table.remove(db.iterate_queue[cs],1)
return true
else
db.iterate_queue[cs] = nil
end
db.indexes_pool[cs].iterating = false
return true
end
minetest.after(0,iterate,db,func_on_iterate,end_func,cycles_per_tick,count,cs,args)
end
function colddb.iterate_index_table(db,begin_func,func_on_iterate,end_func,cycles_per_tick,args,tag_name)
local t = ""
local name = "æIndex_table"
if tag_name then
t = colddb.get_tag(db,tag_name)
end
local cs = string.format("%s%s",t,name)
local f = db.indexes_pool[cs]
if not f or not f.file then
colddb.open_index_table(db,tag_name)
f = db.indexes_pool[cs]
end
if f and f.file and db.indexes_pool[cs].iterating == false then
-- set inuse and iterating to true
db.indexes_pool[cs].inuse = true
db.indexes_pool[cs].iterating = true
local fl = f.file
if f.needs_flushing == true then
fl:flush()
f.needs_flushing = true
end
-- Get count
fl:seek("set")
local c = tonumber(fl:read("*l"))
if c < 1 then
-- If theres nothing to index then return
return false
end
if not args then
args = {}
end
args.count = c
-- Run the begin function
if begin_func then
local a = begin_func(args)
if a and type(a) == "table" then
args = a
end
end
-- Start iterating the index table
iterate(db,func_on_iterate,end_func,cycles_per_tick,c,cs,args)
elseif f and f.file then
-- If its iterating some other function then add this one to the queue list
fl:seek("set")
local c = tonumber(fl:read("*l"))
if c < 1 then
-- If theres nothing to index then return
return false
end
if not db.iterate_queue[cs] then
db.iterate_queue[cs] = {}
end
local _table = {db=db,begin_func=begin_func,func_on_iterate=func_on_iterate,end_func=end_func,cycles_per_tick=cycles_per_tick,count=c,cs=cs,tag_name=tag_name,args=args}
table.insert(db.iterate_queue[cs],_table)
end
end
local function check_use(db,name,tag_name,d)
if not d then
d = 0
end
local delay = 30 + d
local t = ""
if tag_name then
t = colddb.get_tag(db,tag_name)
end
local cs = string.format("%s%s",t,name)
if not db.mem_pool or not db.mem_pool[cs] then
return false
end
if db.mem_pool[cs].inuse == false then
if db.mem_pool[cs].indexes == true then
local cs2 = string.format("%s%s",t,"æIndex_table")
local fs = db.indexes_pool[cs2]
if fs and fs.file then
if fs.inuse == true or fs.iterating == true then
db.indexes_pool[cs2].inuse = false
minetest.after(delay,check_use,name,tag_name,delay,d)
return false
else
fs.file:close()
db.indexes_pool[cs2] = nil
end
end
end
db.mem_pool[cs] = nil
else
db.mem_pool[cs].inuse = false
minetest.after(delay,check_use,name,tag_name,delay,d)
return false
end
end
local function load_into_mem(db,name,_table,tag_name)
if db.add_to_mem_pool then
local t = ""
if tag_name then
t = colddb.get_tag(db,tag_name)
end
local cs = string.format("%s%s",t,name)
if not db.mem_pool[cs] then
db.mem_pool[cs] = {mem = {},inuse = false,check_timer = false,indexes = db.indexes}
end
db.mem_pool[cs].mem = _table
if not db.mem_pool[cs].check_timer then
db.mem_pool[cs].inuse = false
db.mem_pool[cs].indexes = db.indexes
db.mem_pool[cs].check_timer = true
minetest.after(30,check_use,name,tag_name,30,0)
end
end
end
function colddb.set(db,name,_table,tag_name)
local t = ""
if tag_name then
t = colddb.get_tag(db,tag_name)
end
if db.indexes and not colddb.file_Exists(db,name,tag_name) then
local cs2 = string.format("%s%s",t,"æIndex_table")
local om = db.indexes_pool[cs2]
if not colddb.file_Exists(db,"æIndex_table",tag_name) or not (om and om.file) then
colddb.open_index_table(db,tag_name)
end
minetest.after(0,function(db,name,tag_name)colddb.append_index_table(db,name,tag_name)end,db,name,tag_name)
end
minetest.after(1,function(db,name, _table,tag_name)colddb.save_table(db,name, _table,tag_name)end,db,name, _table,tag_name)
local cs = string.format("%s%s",t,name)
if db.add_to_mem_pool and not (db.mem_pool or db.mem_pool[cs]) then
db.mem_pool[cs] = {mem = {},inuse = false,check_timer = false,indexes = db.indexes}
load_into_mem(db,name,_table,tag_name)
end
end
function colddb.set_key(db,name,tag_name)
local t = ""
if tag_name then
t = colddb.get_tag(db,tag_name)
end
if db.indexes and not colddb.file_Exists(db,name,tag_name) then
local cs2 = string.format("%s%s",t,"æIndex_table")
local om = db.indexes_pool[cs2]
if not colddb.file_Exists(db,"æIndex_table",tag_name) or not (om and om.file) then
colddb.open_index_table(db,tag_name)
end
minetest.after(0,function(db,name,tag_name)colddb.append_index_table(db,name,tag_name)end,db,name,tag_name)
end
minetest.after(1,function(db,name, tag_name)colddb.save_key(db,name, tag_name)end,db,name, tag_name)
local cs = string.format("%s%s",t,name)
if db.add_to_mem_pool and not (db.mem_pool or db.mem_pool[cs]) then
db.mem_pool[cs] = {mem = {},inuse = false,check_timer = false,indexes = db.indexes}
load_into_mem(db,name,_table,tag_name)
end
end
function colddb.get(db,name,tag_name)
local t = ""
if tag_name then
t = colddb.get_tag(db,tag_name)
end
local cs = string.format("%s%s",t,name)
local pm = db.mem_pool[cs]
if pm then
db.mem_pool[cs].inuse = true
return pm.mem
else
local _table = colddb.load_table(db,name,tag_name)
if _table then
load_into_mem(db,name,_table,tag_name)
return _table
end
end
return nil
end
function colddb.get_key(db,name,tag_name)
local t = ""
if tag_name then
t = colddb.get_tag(db,tag_name)
end
local cs = string.format("%s%s",t,name)
local pm = db.mem_pool[cs]
if pm then
db.mem_pool[cs].inuse = true
return true
else
local bool = colddb.load_key(db,name,tag_name)
if bool then
load_into_mem(db,name,bool,tag_name)
return bool
end
end
return nil
end
function colddb.remove(db,name,tag_name)
local t = ""
if tag_name then
t = colddb.get_tag(db,tag_name)
end
local cs = string.format("%s%s",t,name)
if db.mem_pool and db.mem_pool[cs] then
db.mem_pool[cs] = nil
end
if db.indexes and colddb.file_Exists(db,"æIndex_table",tag_name) then
local cs2 = string.format("%s%s",t,"æIndex_table")
local om = db.indexes_pool[cs2]
if not om and not om.file then
colddb.open_index_table(db,tag_name)
end
colddb.delete_lines(db,name,tag_name)
end
minetest.after(0,function(db,name,tag_name)colddb.delete_file(db,name,tag_name)end,db,name,tag_name)
end