path: root/tar-clone.lua

#!/usr/bin/lua
local repo, localname = ...

local luxio = require "luxio"
local sio = require "luxio.simple"
local sp = require "luxio.subprocess"
local archive = require "archive"

local function make_temp(syscall, template, tempdir)
	template = template or "tmp.XXXXXX"
	tempdir = tempdir or os.getenv("TMPDIR") or "/tmp"
	local retries = 100
	if not template:find('/') then
		template = tempdir..'/'..template
	end
	if template:sub(-6) ~= "XXXXXX" then
		error("Template must end in XXXXXX")
	end
	repeat
		local tempname = template:sub(1, -7)..tostring(math.random(999999))
		local ret = {syscall(tempname)}
		local ok = table.remove(ret, 1)
		if ok then
			return tempname, unpack(ret)
		end
		retries = retries - 1
	until retries == 0
	error("Unable to create temporary")
end
local function mkdtemp(template, tempdir)
	return make_temp(function(tempname)
		local ret, errmsg, errno = sio.mkdir(tempname, "0700")
		if ret == 0 then
			return tempname
		end
		if errno == luxio.EEXIST then
			return false
		end
		error(("Failed to make directory %s: %s"):format(tempname, errmsg))
	end, template, tempdir)
end

local CONFIG_FORMAT = [[
[core]
	repositoryformatversion = 0
	filemode = true
	bare = false
	logallrefupdates = true
[remote "origin"]
	url = %s
	fetch = +refs/heads/*:refs/remotes/origin/*
[branch "%s"]
	remote = origin
	merge = refs/heads/%s
]]
local function get_config(fetch_url, HEAD)
	return CONFIG_FORMAT:format(fetch_url, HEAD, HEAD)
end


local include_whitelist = {
	"./objects",
	"./description",
}
local function matches_prefix(path, prefix)
   local matched = string.sub(path, 1, string.len(prefix)) == prefix
   return matched
end
local function whitelisted(path)
	for _, prefix in ipairs(include_whitelist) do
		if matches_prefix(path, prefix) then
			return true
		end
	end
	return false
end


local function copy_file(from, write_all, buffer_size)
   -- Default buffer size is 4M, but can be changed
   buffer_size = buffer_size or 4 * 1024 * 1024
   local fromfile, emsg = sio.open(from, "r")
   if not fromfile then
      return false, emsg
   end
   local write_count
   repeat
      local ok
      local bytes, emsg = fromfile:read(buffer_size)
      if not bytes then
         fromfile:close()
         tofile:close()
         return false, emsg
      end
      ok, write_count, emsg = write_all(bytes)
      if not ok then
         fromfile:close()
         return false, emsg
      end
   until write_count == 0
   return true
end


local function add_dir(writer, basedir, path)
	local fspath = basedir..'/'..path
	for name, dinfo in sio.opendir(fspath):iterate() do
		local fssubpath = fspath..'/'..name
		local subpath = path..'/'..name
		--io.stderr:write("name:\t", subpath, '\n')
		if name ~= '.' and name ~= '..' and whitelisted(subpath) then
			dt = dinfo.d_type
			dts = (dt == luxio.DT_REG and "Regular")
			   or (dt == luxio.DT_DIR and "Directory")
			   or (dt == luxio.DT_LNK and "Symlink")
			--io.stderr:write("d_type:\t", dts, '\n')
			local entry = archive.entry{
				sourcepath = fssubpath,
				pathname = localname..'/.git/'..subpath,
				ino = 0,
				dev = 0,
				uid = 0,
				uname = 'root',
				gid = 0,
				gname = 'root',
				atime = {683074800, 683074800},
				ctime = {683074800, 683074800},
				mtime = {683074800, 683074800},
				birthtime = {683074800, 683074800},
			}
			if dt == luxio.DT_REG then
				writer:header(entry)
				copy_file(fssubpath, function(bytes)
					writer:data(bytes)
					return 0, #bytes
				end)
			elseif dt == luxio.DT_DIR then
				writer:header(entry)
				add_dir(writer, basedir, subpath)
			elseif dt == luxio.DT_LNK then
				writer:header(entry)
			end
		end
	end
end

local function write_file(writer, path, data)
	writer:header(archive.entry{
		pathname = path,
		mode = tonumber('100664', 8),
		ino = 0,
		dev = 0,
		uid = 0,
		uname = 'root',
		gid = 0,
		gname = 'root',
		atime = {683074800, 683074800},
		ctime = {683074800, 683074800},
		mtime = {683074800, 683074800},
		birthtime = {683074800, 683074800},
		size = #data
	})
	writer:data(data)
end

local function run_git(dir, ...)
	local proc = sp.spawn_simple{cwd=dir, stdout=sp.PIPE, ...}
	local output = proc.stdout:read("*a")
	local how, why = proc:wait()
	if how == -1 then
		error("run_git failed: "..tostring(why))
	end
	return output
end

local function write_refs(writer, repo, HEAD, localname)
	for branch, sha1 in run_git(repo, 'git', 'for-each-ref',
	                            '--format', '%(refname)%00%(objectname)%00',
	                            'refs/heads')
	                    :gmatch"refs/heads/([^%z]+)%z([^%z]+)%z\n" do
		write_file(writer, localname..'/.git/refs/remotes/origin/'..branch,
	                   sha1..'\n')
		if branch == HEAD then
			write_file(writer, localname..'/.git/refs/heads/'..branch,
			           sha1..'\n')
		end
	end
end

local function write_workspace(writer, repo, HEAD, localname, bufsize)
	bufsize = bufsize or 4 * 1024 * 1024 --4MB
	local proc = sp.spawn_simple{"git", "archive", "--format=tar", HEAD,
	                             cwd = repo, stdout = sp.PIPE}
	local reader = archive.read{
		compression = "none",
		format = "tar",
		reader = function(archive_read)
			local r = proc.stdout:read(bufsize)
			if r == -1 then
				error("Reading git archive output")
			end
			if #r == 0 then
				return nil
			end
			return r
		end,
	}
	while true do
		local header = reader:next_header()
		if header == nil then
			break
		end
		header:pathname(localname..'/'..header:pathname())
		writer:header(header)
		while true do
			local data = reader:data()
			if data == nil then
				break
			end
			writer:data(data)
		end
	end
end

local function list_tree(repo, HEAD)
	local proc = sp.spawn_simple{"git", "ls-tree", "-rz", HEAD,
	                             cwd = repo, stdout = sp.PIPE}
	local output = proc.stdout:read("*a")
	return output:gmatch"([^ ]+) ([^ ]+) ([^ ]+)\t([^%z]+)%z"
end

local function update_index(repo, HEAD, index)
	local function exec(args)
		args.cwd = repo
		args.env = {GIT_INDEX_FILE = index}
		local proc = sp.spawn_simple(args)
		local how, why = proc:wait()
		if how == -1 then
			error("git update-index failed: "..tostring(why))
		end
	end
	local cmdline = {"git", "update-index", "--add"}
	for mode, kind, sha1, path in list_tree(repo, HEAD) do
		table.insert(cmdline, "--cacheinfo")
		table.insert(cmdline, mode)
		table.insert(cmdline, sha1)
		table.insert(cmdline, path)
		if #cmdline >= 50 then -- arbitrary limit
			exec(cmdline)
			cmdline = {"git", "update-index", "--add"}
		end
	end
	if #cmdline > 3 then
		exec(cmdline)
	end
end

local function write_index(writer, repo, HEAD, localname)
	local dir = mkdtemp()
	local index = dir..'/index'

	update_index(repo, HEAD, index)

	local entry = archive.entry{
		sourcepath = index,
		pathname = localname..'/.git/index',
		ino = 0,
		dev = 0,
		uid = 0,
		uname = 'root',
		gid = 0,
		gname = 'root',
		atime = {683074800, 683074800},
		ctime = {683074800, 683074800},
		mtime = {683074800, 683074800},
		birthtime = {683074800, 683074800},
	}
	writer:header(entry)
	copy_file(index, function(data)
		writer:data(data)
		return 0, #data
	end)
end

local writer = archive.write{
	format = "pax",
	writer = function(archive, string)
		if string == nil then
			io.stdout:flush()
		else
			io.stdout:write(string)
			return #string
		end
	end,
}
add_dir(writer, repo, '.')

HEAD = run_git(repo, "git", "rev-parse",
               "--abbrev-ref", "HEAD"):sub(1, -2)
write_file(writer, localname..'/.git/HEAD',
           'ref: refs/heads/'..HEAD..'\n')
config = get_config('git://git@gitserver/repo', HEAD)
write_file(writer, localname..'/.git/config', config)

write_refs(writer, repo, HEAD, localname)

write_workspace(writer, repo, HEAD, localname)

write_index(writer, repo, HEAD, localname)

writer:close()