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