diff --git a/README.md b/README.md
index 8fe69f0..c949a2e 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@ ColdDB
===========
ColdDB is a minetest mod that implements a serverless, asynchronous, NoSQL database engine.
-It provides a key or key-value storage system using plain Lua tables, also it can iterate through the keys.
+It provides a key or key-value based storage system using plain Lua tables.
Usage
===========
@@ -44,27 +44,23 @@ coldbase.remove("MyKeyAndValue")
```lua
coldbase.add_to_mem_pool = true
```
-7. if indexes is true(false by default). When a key file is created an indexing file stores the key for look-ups. this makes it possible to iterate through keys.
+7. returns the amount of entries from the entry file.
```lua
-coldbase.indexes = true
+coldbase.get_entry_file_count(name, tag_name)
```
-8. only if coldbase.indexes is true. returns the amount of keys that are in the indexing file.
+8. iterates through the entry file(breaks and ends if it reaches the end of the file).
```lua
-coldbase.get_count()
+coldbase.iterate_entry_file(name, begin_func, func_on_iterate, end_func, args, tag_name)
```
-9. only if coldbase.indexes is true. iterates through the indexing file(breaks and ends if it reaches the end of the file).
-```lua
-coldbase.iterate_index_table(nil, func_list_keys, nil)
-```
-10. adds a folder which can be used in other functions that have tag_name arg.
+9. adds a folder which can be used in other functions that have tag_name arg.
```lua
coldbase.add_tag("Extra_Folder", {"Extra", "Folder"})
```
-11. returns the tag name if the tag does not exists it creates one.
+10. returns the tag name if the tag does not exists it creates one.
```lua
-coldbase.get_or_add_tag("Extra_Folder", {"Extra", "Folder"})
+coldbase.get_or_add_tag("Extra_Folder", {"Extra", "Folder"}, no_new_path)
```
-12. remove tag by name.
+11. remove tag by name.
```lua
coldbase.remove_tag("Extra_Folder")
```
diff --git a/colddb.lua b/colddb.lua
index 31936f2..b3de00c 100644
--- a/colddb.lua
+++ b/colddb.lua
@@ -1,42 +1,37 @@
colddb = {}
-local function createDir(directory)
- return minetest.mkdir(directory)
-end
-
-function colddb.Colddb(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))
+function colddb.Colddb(dir)
+ local dir = string.format("%s/%s/", minetest.get_worldpath(), dir)
+ if not minetest.mkdir(dir) then
+ error(string.format("%s is not a directory.", dir))
end
local self = {}
- self.db = {
- directory = directory,
- tags = {},
- mem_pool = {},
- mem_pool_del = {},
- indexes_pool = {},
- iterate_queue = {},
- indexes = false,
- add_to_mem_pool = true,
- async = extended_api.Async(),
- }
+ local directory = dir
+ local tags = {}
+ local mem_pool = {}
+ local mem_pool_del = {}
+ local indexes_pool = {}
+ local iterate_queue = {}
+ local add_to_mem_pool = true
+ local async = extended_api.Async()
+ local path_count = {}
+
+ async.priority(150, 250)
- self.db.async.priority(150, 250)
-- make tables weak so the garbage-collector will remove unused data
- setmetatable(self.db.tags, {__mode = "kv"})
- setmetatable(self.db.mem_pool, {__mode = "kv"})
- setmetatable(self.db.mem_pool_del, {__mode = "kv"})
- setmetatable(self.db.indexes_pool, {__mode = "kv"})
+ setmetatable(tags, {__mode = "kv"})
+ setmetatable(mem_pool, {__mode = "kv"})
+ setmetatable(mem_pool_del, {__mode = "kv"})
+ setmetatable(indexes_pool, {__mode = "kv"})
- self.file_Exists = function(name, tag_name)
+ local function file_Exists(name, tag_name)
local t = ""
if tag_name then
t = self.get_tag(tag_name)
end
- local f = io.open(string.format("%s%s%s.cold", self.db.directory, t, name), "r")
+ local f = io.open(string.format("%s%s%s.cold", directory, t, name), "r")
if f ~= nil then
io.close(f)
return true
@@ -58,7 +53,7 @@ function colddb.Colddb(directory)
local function delete_lines_func_i(line, i, args)
local f = args.file
- local om = self.db.indexes_pool[args.cs]
+ local om = indexes_pool[args.cs]
if om and not om.deleted_items[line] then
f:write(string.format("\n%s", line))
else
@@ -69,7 +64,7 @@ function colddb.Colddb(directory)
local function delete_lines_func_end(args)
local cs = args.cs
- local index = self.db.indexes_pool[cs]
+ local index = indexes_pool[cs]
if index and index.file then
index.file:close()
index.file = nil
@@ -83,20 +78,20 @@ function colddb.Colddb(directory)
os.remove(args.oldfile)
os.rename(args.copyfile, args.oldfile)
end
- local pool = self.db.indexes_pool[cs]
+ local pool = indexes_pool[cs]
for i, l in pairs(args.removedlist) do
pool.deleted_items[i] = nil
end
pool.deleting = false
- self.db.indexes_pool[cs] = pool
+ indexes_pool[cs] = pool
end
args = nil
end
local function iterate(func_on_iterate, end_func, count, cs, args)
- local f = self.db.indexes_pool[cs]
+ local f = indexes_pool[cs]
local fl = f.file
- self.db.async.iterate(1, count, function(i)
+ async.iterate(1, count, function(i)
local line = fl:read("*l")
if args.do_not_skip_removed_items or not f.deleted_items[line] then
local ar = func_on_iterate(line, i, args)
@@ -105,17 +100,17 @@ function colddb.Colddb(directory)
return args
end
end
- end,function()
+ end, function()
if end_func then
end_func(args)
end
- local iterate_queue = self.db.iterate_queue[cs]
+ local iterate_queue = iterate_queue[cs]
if iterate_queue and iterate_queue[1] then
local copy = iterate_queue[1]
- f = self.db.indexes_pool[cs]
+ f = indexes_pool[cs]
if not f or not f.file then
self.open_index_table(copy.tag_name)
- f = self.db.indexes_pool[cs]
+ f = indexes_pool[cs]
end
if copy.begin_func then
local a = copy.begin_func(copy.args)
@@ -124,52 +119,46 @@ function colddb.Colddb(directory)
end
end
minetest.after(0, iterate, copy.func_on_iterate, copy.end_func, copy.count, copy.cs, copy.args)
- table.remove(self.db.iterate_queue[cs], 1)
+ table.remove(iterate_queue[cs], 1)
return false
else
fl:close()
- self.db.iterate_queue[cs] = nil
+ iterate_queue[cs] = nil
end
- self.db.indexes_pool[cs].iterating = false
+ indexes_pool[cs].iterating = false
return false
end)
end
local function load_into_mem(name, _table, tag_name)
- if self.db.add_to_mem_pool then
+ if add_to_mem_pool then
local t = ""
if tag_name then
t = self.get_tag(tag_name)
end
local cs = string.format("%s%s", t, name)
- local mem_pool = self.db.mem_pool[cs]
- if not mem_pool then
- mem_pool = {mem = _table, indexes = self.db.indexes}
- else
- mem_pool.mem = _table
- mem_pool.indexes = self.db.indexes
- end
- self.db.mem_pool[cs] = mem_pool
+ mem_pool[cs] = {mem = _table}
end
end
- local path_count = {}
-
local function _remove_tag(delete_path, prev_dp)
- if path_count[delete_path] and path_count[delete_path] > 0 then
+ local pc = path_count[delete_path]
+ if pc and pc > 0 then
minetest.after(1.5, _remove_tag, delete_path)
return
- elseif path_count[delete_path] and path_count[delete_path] < 1 then
- self.db.mem_pool = {}
- self.db.mem_pool_del = {}
+ elseif pc and pc < 1 then
+ mem_pool = {}
+ mem_pool_del = {}
os.remove(delete_path)
+ path_count[delete_path] = nil
+
return
- elseif not path_count[delete_path] then
+ elseif not pc then
path_count[delete_path] = 0
end
local list = minetest.get_dir_list(delete_path)
- self.db.async.foreach(list, function(k, v)
+ async.foreach(list, function(k, v)
v = string.format("%s/%s", delete_path, v)
local err = os.remove(v)
if err == nil then
@@ -180,20 +169,21 @@ function colddb.Colddb(directory)
if prev_dp then
path_count[prev_dp] = path_count[prev_dp] - 1
end
- if path_count[delete_path] > 0 then
+ if pc > 0 then
minetest.after(1.5, _remove_tag, delete_path)
else
- self.db.mem_pool = {}
- self.db.mem_pool_del = {}
+ mem_pool = {}
+ mem_pool_del = {}
os.remove(delete_path)
+ path_count[delete_path] = nil
end
end)
end
- self.add_tag = function(name, tag)
+ self.add_tag = function(name, tag, no_new_path)
local t = ""
- if not self.db.tags[name] then
- self.db.tags[name] = ""
+ if not tags[name] then
+ tags[name] = ""
end
if type(tag) == "table" then
for key, value in pairs(tag) do
@@ -202,37 +192,46 @@ function colddb.Colddb(directory)
else
t = string.format("%s/", tag)
end
- local test_path = string.format("%s%s%s", self.db.directory, self.db.tags[name], t)
- if not createDir(test_path) then
+ tags[name] = string.format("%s%s", tags[name], t)
+ if no_new_path then
+ return
+ end
+ local test_path = string.format("%s%s%s", directory, tags[name], t)
+ if not minetest.mkdir(test_path) then
error(string.format("%s is not a directory.", test_path))
end
- self.db.tags[name] = string.format("%s%s", self.db.tags[name], t)
end
self.get_tag = function(name)
if not name then
return ""
end
- local tag = self.db.tags[name]
+ local tag = tags[name]
if tag then
return tag
end
return ""
end
- self.get_or_add_tag = function(name, tag)
- if not self.db.tags[name] then
- self.add_tag(name, tag)
+ self.get_or_add_tag = function(name, tag, no_new_path)
+ if not tags[name] then
+ self.add_tag(name, tag, no_new_path)
end
return name
end
self.remove_tag = function(name)
- if self.db.tags[name] then
- local delete_path = string.format("%s%s", self.db.directory, self.db.tags[name])
+ if not name then
+ local delete_path = directory
local wc = delete_path:len()
delete_path = delete_path:sub(0, wc-1)
- self.db.tags[name] = nil
+ return
+ end
+ if tags[name] then
+ local delete_path = string.format("%s%s", directory, tags[name])
+ local wc = delete_path:len()
+ delete_path = delete_path:sub(0, wc-1)
+ tags[name] = nil
local err = os.remove(delete_path)
if err == nil then
minetest.after(0.1, _remove_tag, delete_path)
@@ -240,12 +239,12 @@ function colddb.Colddb(directory)
end
end
- self.delete_file = function(name, tag_name)
+ local function delete_file(name, tag_name)
local t = ""
if tag_name then
t = self.get_tag(tag_name)
end
- local text = string.format("%s%s%s.cold", self.db.directory, t, name)
+ local text = string.format("%s%s%s.cold", directory, t, name)
local err, msg = os.remove(text)
if err == nil then
@@ -253,12 +252,12 @@ function colddb.Colddb(directory)
end
end
- self.load_table = function(name, tag_name)
+ local function load_table(name, tag_name)
local t = ""
if tag_name then
t = self.get_tag(tag_name)
end
- local f = io.open(string.format("%s%s%s.cold", self.db.directory, t, name), "r")
+ local f = io.open(string.format("%s%s%s.cold", directory, t, name), "r")
if f then
local data = minetest.deserialize(f:read("*a"))
f:close()
@@ -267,28 +266,28 @@ function colddb.Colddb(directory)
return nil
end
- self.save_table = function(name, _table, tag_name)
+ local function save_table(name, _table, tag_name)
local t = ""
if tag_name then
t = self.get_tag(tag_name)
end
- return minetest.safe_file_write(string.format("%s%s%s.cold", self.db.directory, t, name), minetest.serialize(_table))
+ return minetest.safe_file_write(string.format("%s%s%s.cold", directory, t, name), minetest.serialize(_table))
end
- self.save_key = function(name, tag_name)
+ local function save_key(name, tag_name)
local t = ""
if tag_name then
t = self.get_tag(tag_name)
end
- return minetest.safe_file_write(string.format("%s%s%s.cold", self.db.directory, t, name), "")
+ return minetest.safe_file_write(string.format("%s%s%s.cold", directory, t, name), "")
end
- self.load_key = function(name, tag_name)
+ local function load_key(name, tag_name)
local t = ""
if tag_name then
t = self.get_tag(tag_name)
end
- local f = io.open(string.format("%s%s%s.cold", self.db.directory, t, name), "r")
+ local f = io.open(string.format("%s%s%s.cold", directory, t, name), "r")
if f then
f:close()
return true
@@ -296,31 +295,13 @@ function colddb.Colddb(directory)
return false
end
- self.delete_index_table = function(tag_name)
+ self.delete_entries = function(name ,_lines, tag_name)
local t = ""
- local name = "æIndex_table"
- if tag_name then
- t = self.get_tag(tag_name)
- end
- local p = string.format("%s%sæIndex_table.cold", self.db.directory, t)
- if self.file_Exists(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
-
- self.delete_lines = function(_lines, tag_name)
- local t = ""
- local name = "æIndex_table"
if tag_name then
t = self.get_tag(tag_name)
end
local cs = string.format("%s%s", t, name)
- local f = self.db.indexes_pool[cs]
+ local f = indexes_pool[cs]
local k = type(_lines)
if k == "string" then
f.deleted_items[_lines] = true
@@ -330,33 +311,32 @@ function colddb.Colddb(directory)
end
end
if not f.deleting then
- self.db.indexes_pool[cs].deleting = false
+ indexes_pool[cs].deleting = false
end
if f and f.file and not f.deleting then
- self.db.indexes_pool[cs].deleting = true
+ indexes_pool[cs].deleting = true
if f.needs_flushing == true then
f.file:flush()
- self.db.indexes_pool[cs].needs_flushing = false
+ indexes_pool[cs].needs_flushing = false
end
- local oldfile = string.format("%s%sæIndex_table.cold", self.db.directory, t)
- local copyfile = string.format("%s%sæIndex_table.cold.replacer", self.db.directory, t)
+ local oldfile = string.format("%s%s%s.cold", directory, t, name)
+ local copyfile = string.format("%s%s%s.cold.replacer", directory, t, name)
local args = {cs = cs, oldfile = oldfile, copyfile = copyfile, do_not_skip_removed_items = true}
- self.db.indexes_pool[cs] = f
- iterate_index_table(delete_lines_func_begin, delete_lines_func_i, delete_lines_func_end, args, tag_name)
+ indexes_pool[cs] = f
+ iterate_index_table(delete_entries_func_begin, delete_entries_func_i, delete_entries_func_end, args, tag_name)
end
end
- self.open_index_table = function(tag_name)
+ self.open_entry_file = function(name, tag_name)
local t = ""
- local name = "æIndex_table"
if tag_name then
t = self.get_tag(tag_name)
end
local cs = string.format("%s%s", t, name)
- local fs = self.db.indexes_pool[cs]
+ local fs = indexes_pool[cs]
if not fs then
- local p = string.format("%s%sæIndex_table.cold", self.db.directory, t)
- if not self.file_Exists(name,tag_name) then
+ local p = string.format("%s%s%s.cold", directory, t, name)
+ if not file_Exists(name,tag_name) then
local f = io.open(p, "w")
if f then
f:seek("set")
@@ -366,7 +346,7 @@ function colddb.Colddb(directory)
end
local f = io.open(p, "r+")
if f then
- self.db.indexes_pool[cs] = {file = f, needs_flushing = false, deleted_items = {}, iterating = false}
+ indexes_pool[cs] = {file = f, needs_flushing = false, deleted_items = {}, iterating = false}
return f
end
return nil
@@ -376,14 +356,13 @@ function colddb.Colddb(directory)
return nil
end
- self.append_index_table = function(key, tag_name)
+ self.append_entry_file = function(name, key, tag_name)
local t = ""
- local name = "æIndex_table"
if tag_name then
t = self.get_tag(tag_name)
end
local cs = string.format("%s%s", t, name)
- local f = self.db.indexes_pool[cs]
+ local f = indexes_pool[cs]
local k = type(key)
if f and f.file and k == "string" then
local fl = f.file
@@ -391,7 +370,7 @@ function colddb.Colddb(directory)
fl:flush()
f.needs_flushing = false
end
- self.db.indexes_pool[cs].needs_flushing = true
+ indexes_pool[cs].needs_flushing = true
fl:seek("end")
fl:write(string.format("\n%s", key))
fl:seek("set")
@@ -406,7 +385,7 @@ function colddb.Colddb(directory)
fl:flush()
f.needs_flushing = false
end
- self.db.indexes_pool[cs].needs_flushing = true
+ indexes_pool[cs].needs_flushing = true
local c = 0
for i in pairs(key) do
fl:seek("end")
@@ -424,14 +403,17 @@ function colddb.Colddb(directory)
end
end
- self.get_count = function(tag_name)
+ self.get_entry_file_count = function(name, tag_name)
local t = ""
- local name = "æIndex_table"
if tag_name then
t = self.get_tag(tag_name)
end
- local cs = string.format("%s%s",t,name)
- local f = self.db.indexes_pool[cs]
+ local cs = string.format("%s%s", t, name)
+ local f = indexes_pool[cs]
+ if not f or not f.file then
+ self.open_entry_file(name, tag_name)
+ f = indexes_pool[cs]
+ end
if f and f.file then
local fl = f.file
if f.needs_flushing == true then
@@ -446,20 +428,19 @@ function colddb.Colddb(directory)
return nil
end
- self.iterate_index_table = function(begin_func, func_on_iterate, end_func, args, tag_name)
+ self.iterate_entry_file = function(name, begin_func, func_on_iterate, end_func, args, tag_name)
local t = ""
- local name = "æIndex_table"
if tag_name then
t = self.get_tag(tag_name)
end
local cs = string.format("%s%s", t, name)
- local f = self.db.indexes_pool[cs]
+ local f = indexes_pool[cs]
if not f or not f.file then
- self.open_index_table(tag_name)
- f = self.db.indexes_pool[cs]
+ self.open_entry_file(tag_name)
+ f = indexes_pool[cs]
end
- if f and f.file and self.db.indexes_pool[cs].iterating == false then
- self.db.indexes_pool[cs].iterating = true
+ if f and f.file and indexes_pool[cs].iterating == false then
+ indexes_pool[cs].iterating = true
local fl = f.file
if f.needs_flushing == true then
fl:flush()
@@ -482,7 +463,7 @@ function colddb.Colddb(directory)
if c < 1 then
-- If theres nothing to index then return
end_func(args)
- self.db.indexes_pool[cs].iterating = false
+ indexes_pool[cs].iterating = false
return false
end
-- Start iterating the index table
@@ -496,11 +477,11 @@ function colddb.Colddb(directory)
-- If theres nothing to index then return
return false
end
- if not self.db.iterate_queue[cs] then
- self.db.iterate_queue[cs] = {}
+ if not iterate_queue[cs] then
+ iterate_queue[cs] = {}
end
local _table = {begin_func = begin_func, func_on_iterate = func_on_iterate, end_func = end_func, count = c, cs = cs, tag_name = tag_name, args = args}
- table.insert(self.db.iterate_queue[cs], _table)
+ table.insert(iterate_queue[cs], _table)
end
end
@@ -509,24 +490,14 @@ function colddb.Colddb(directory)
if tag_name then
t = self.get_tag(tag_name)
end
- if self.db.indexes and not self.file_Exists(name,tag_name) then
- self.db.async.queue_task(function()
- local cs2 = string.format("%s%s", t , "æIndex_table")
- local om = self.db.indexes_pool[cs2]
- if not self.file_Exists("æIndex_table", tag_name) or not (om and om.file) then
- self.open_index_table(tag_name)
- end
- self.append_index_table(name, tag_name)
- end)
- end
- self.db.async.queue_task(function()
- self.save_table(name, _table, tag_name)
+ async.queue_task(function()
+ save_table(name, _table, tag_name)
end)
- if self.db.add_to_mem_pool then
+ if add_to_mem_pool then
load_into_mem(name, _table, tag_name)
end
local cs = string.format("%s%s", t, name)
- self.db.mem_pool_del[cs] = nil
+ mem_pool_del[cs] = nil
end
self.set_key = function(name, tag_name)
@@ -534,24 +505,14 @@ function colddb.Colddb(directory)
if tag_name then
t = self.get_tag(tag_name)
end
- if self.db.indexes and not self.file_Exists(name, tag_name) then
- self.db.async.queue_task(function()
- local cs2 = string.format("%s%s", t, "æIndex_table")
- local om = self.db.indexes_pool[cs2]
- if not self.file_Exists("æIndex_table", tag_name) or not (om and om.file) then
- self.open_index_table(tag_name)
- end
- self.append_index_table(name, tag_name)
- end)
- end
- self.db.async.queue_task(function()
- self.save_key(name, tag_name)
+ async.queue_task(function()
+ save_key(name, tag_name)
end)
- if self.db.add_to_mem_pool then
+ if add_to_mem_pool then
load_into_mem(name, "", tag_name)
end
local cs = string.format("%s%s", t, name)
- self.db.mem_pool_del[cs] = nil
+ mem_pool_del[cs] = nil
end
self.get = function(name, tag_name, callback)
@@ -560,39 +521,39 @@ function colddb.Colddb(directory)
t = self.get_tag(tag_name)
end
local cs = string.format("%s%s", t, name)
- if self.db.mem_pool_del[cs] then
+ if mem_pool_del[cs] then
if callback then
callback(nil)
end
return nil
end
if callback then
- self.db.async.queue_task(function()
- local pm = self.db.mem_pool[cs]
+ async.queue_task(function()
+ local pm = mem_pool[cs]
if pm then
return pm.mem
else
- local _table = self.load_table(name, tag_name)
+ local _table = load_table(name, tag_name)
if _table then
load_into_mem(name, _table, tag_name)
return _table
end
end
- self.db.mem_pool_del[cs] = true
+ mem_pool_del[cs] = true
return nil
end,callback)
else
- local pm = self.db.mem_pool[cs]
+ local pm = mem_pool[cs]
if pm then
return pm.mem
else
- local _table = self.load_table(name, tag_name)
+ local _table = load_table(name, tag_name)
if _table then
load_into_mem(name, _table, tag_name)
return _table
end
end
- self.db.mem_pool_del[cs] = true
+ mem_pool_del[cs] = true
return nil
end
end
@@ -603,43 +564,43 @@ function colddb.Colddb(directory)
t = self.get_tag(tag_name)
end
local cs = string.format("%s%s", t, name)
- if self.db.mem_pool_del[cs] then
+ if mem_pool_del[cs] then
if callback then
callback(false)
end
return false
end
if callback then
- self.db.async.queue_task(function()
+ async.queue_task(function()
local t = ""
if tag_name then
t = self.get_tag(tag_name)
end
- local pm = self.db.mem_pool[cs]
+ local pm = mem_pool[cs]
if pm then
return true
else
- local bool = self.load_key(name, tag_name)
+ local bool = load_key(name, tag_name)
if bool then
load_into_mem(name, bool, tag_name)
return bool
end
end
- self.db.mem_pool_del[cs] = true
+ mem_pool_del[cs] = true
return nil
end,callback)
else
- local pm = self.db.mem_pool[cs]
+ local pm = mem_pool[cs]
if pm then
return true
else
- local bool = self.load_key(name, tag_name)
+ local bool = load_key(name, tag_name)
if bool then
load_into_mem(name, bool, tag_name)
return bool
end
end
- self.db.mem_pool_del[cs] = true
+ mem_pool_del[cs] = true
return nil
end
end
@@ -650,19 +611,10 @@ function colddb.Colddb(directory)
t = self.get_tag(tag_name)
end
local cs = string.format("%s%s", t, name)
- self.db.mem_pool[cs] = nil
- self.db.mem_pool_del[cs] = true
- if self.db.indexes and self.file_Exists("æIndex_table", tag_name) then
- self.db.async.queue_task(function()
- local cs2 = string.format("%s%s", t, "æIndex_table")
- if not (self.db.indexes_pool[cs2] and self.db.indexes_pool[cs2].file) then
- self.open_index_table(tag_name)
- end
- self.delete_lines(name, tag_name)
- end)
- end
- self.db.async.queue_task(function()
- self.delete_file(name, tag_name)
+ mem_pool[cs] = nil
+ mem_pool_del[cs] = true
+ async.queue_task(function()
+ delete_file(name, tag_name)
end)
end