path: root/bin/gitano-update-hook.in

-- @@SHEBANG
-- -*- Lua -*-
-- gitano-update-hook
--
-- Git (with) Augmented network operations -- Update hook handler
--
-- Copyright 2012 Daniel Silverstone <dsilvers@digital-scurf.org>
--
--

-- @@GITANO_LUA_PATH

local gitano = require "gitano"
local gall = require "gall"
local luxio = require "luxio"
local sio = require "luxio.simple"
local sp = require "luxio.subprocess"

-- @@GITANO_BIN_PATH
-- @@GITANO_SHARE_PATH
-- @@GITANO_PLUGIN_PATH

local refname, oldsha, newsha = ...

local start_log_level = gitano.log.get_level()
-- Clamp level at info until we have checked if the caller
-- is an admin or not
gitano.log.cap_level(gitano.log.level.INFO)
gitano.log.syslog.open()

local nullsha = ("0"):rep(40)

local repo_root = luxio.getenv("GITANO_ROOT")
local username  = luxio.getenv("GITANO_USER") or "gitano/anonymous"
local keytag    = luxio.getenv("GITANO_KEYTAG") or "unknown"
local project   = luxio.getenv("GITANO_PROJECT") or ""
local source    = luxio.getenv("GITANO_SOURCE") or "ssh"
local running   = luxio.getenv("GITANO_RUNNING")

-- Check whether we are called through gitano-auth
if not running then
   return 0
end

-- Now load the administration data
gitano.config.repo_path(repo_root)
local admin_repo = gall.repository.new((repo_root or "") .. "/gitano-admin.git")

if not admin_repo then
   gitano.log.fatal("Unable to locate administration repository.  Cannot continue");
end

local admin_head = admin_repo:get(admin_repo.HEAD)

if not admin_head then
   gitano.log.fatal("Unable to find the HEAD of the administration repository.  Cannot continue");
end

local config, msg = gitano.config.parse(admin_head)

if not config then
   gitano.log.critical("Unable to parse administration repository.")
   gitano.log.critical("  * " .. (msg or "No error?"))
   gitano.log.fatal("Cannot continue")
end

-- Now, are we an admin?
if config.groups["gitano-admin"].filtered_members[username] then
   -- Yep, so blithely reset logging level
   gitano.log.set_level(start_log_level)
end

if not config.global.silent then
   -- Not silent, bump to chatty level automatically
   gitano.log.bump_level(gitano.log.level.CHAT)
end

local repo, msg = gitano.repository.find(config, project)
if not repo then
   gitano.log.critical("Unable to locate repository.")
   gitano.log.critical("  * " .. (tostring(msg)))
   gitano.log.fatal("Cannot continue")
end
   
if repo.is_nascent then
   gitano.log.fatal("Repository " .. repo.name .. " is nascent")
end


-- Prepare an update operation

local context = {
   ["source"] = source,
   ["ref"] = refname,
   ["oldsha"] = oldsha,
   ["newsha"] = newsha,
   ["user"] = username,
}

-- Attempt to work out what's going on regarding the update.

local action = "**UNKNOWN**"

if oldsha == nullsha and newsha ~= nullsha then
   context["operation"] = "createref"
   action = "creation"
elseif oldsha ~= nullsha and newsha == nullsha then
   context["operation"] = "deleteref"
   action = "deletion"
else
   local base, msg = repo.git:merge_base(oldsha, newsha)
   if not base then
      gitano.log.fatal(msg)
   elseif (base == true) or ((base) and (base == newsha)) then
      context["operation"] = "updaterefnonff"
      action = "non-ff update"
   else
      context["operation"] = "updaterefff"
      action = "update"
   end
end

-- Populate the trees

local function do_expensive_populate_context(context)

   local oldtree, newtree
   if oldsha == nullsha or newsha == nullsha then
      repo.git:force_empty_tree()
   end

   if oldsha == nullsha then
      oldtree = repo.git:get(gall.tree.empty_sha).content
   else
      local thing = repo.git:get(oldsha)
      if thing.type == "tag" then
	 thing = thing.content.object
      end
      if thing.type == "commit" then
	 oldtree = thing.content.tree.content
      else
	 oldtree = repo.git:get(gall.tree.empty_sha).content
	 gitano.log.warn("Odd, old object", oldsha, "is not a commit or tag")
      end
   end

   if newsha == nullsha then
      newtree = repo.git:get(gall.tree.empty_sha).content
   else
      local thing = repo.git:get(newsha)
      if thing.type == "tag" then
	 thing = thing.content.object
      end
      if thing.type == "commit" then
	 newtree = thing.content.tree.content
      else
	 newtree = repo.git:get(gall.tree.empty_sha).content
	 gitano.log.warn("Odd, new object", oldsha, "is not a commit or tag")
      end
   end

   -- First, populate gitano/starttree and gitano/targettree

   local function set_list(tag, entries)
      -- Make the set for direct string tests
      for i = 1, #entries do
	 entries[entries[i]] = true
      end
      context[tag] = entries
   end

   local function populate_tree(tag, tree)
      local flat_tree = gall.tree.flatten(tree)
      local names = {}
      for fn in pairs(flat_tree) do
	 names[#names+1] = fn
      end
      set_list(tag, names)
   end

   populate_tree("start_tree", oldtree)
   populate_tree("target_tree", newtree)

   -- Now gitano/treedelta
   local delta = oldtree:diff_to(newtree)
   local targets, added, deleted, modified, renamed, renamedto =
      {}, {}, {}, {}, {}, {}

   for i = 1, #delta do
      local details = delta[i]
      local fname = details.filename
      targets[#targets+1] = fname
      if details.action == "A" then
	 added[#added+1] = fname
      end
      if details.action == "C" and details.score == "100" then
	 added[#added+1] = fname
      end
      if details.action == "D" then
	 deleted[#deleted+1] = fname
      end
      if details.action == "M" or
	 ((details.action == "R" or details.action == "C") and
	  (tonumber(details.score) < 100)) then
	 modified[#modified+1] = fname
      end
      if details.action == "R" then
	 renamed[#renamed+1] = details.src_name
	 renamedto[#renamedto+1] = fname
      end

      context["treediff/kind/" .. fname] = details.endkind
      context["treediff/oldkind/" .. fname] = details.startkind
   end

   set_list("treediff/targets", targets)
   set_list("treediff/added", added)
   set_list("treediff/deleted", deleted)
   set_list("treediff/modified", modified)
   set_list("treediff/renamed", renamed)
   set_list("treediff/renamedto", renamedto)
end

local function defer_generation(key)
   context[key] = function(ctx)
		     -- This populates quite a bit, so we do this
		     -- test in case someone else got hold of this
		     -- beforehand and manages to cross the streams
		     if type(ctx[key]) == "function" then
			gitano.log.chat("Treedeltas generating because of:",
					key, " Please hold.")
			do_expensive_populate_context(ctx)
			gitano.log.chat("Treedeltas built, continuing")
		     end
		     -- And return what we were meant to be
		     return ctx[key]
		  end
end

defer_generation "start_tree"
defer_generation "target_tree"
defer_generation "treediff/targets"
defer_generation "treediff/added"
defer_generation "treediff/deleted"
defer_generation "treediff/modified"
defer_generation "treediff/renamed"
defer_generation "treediff/renamedto"

-- Run the ruleset given the contextet

local action, reason = repo:run_lace(context)

if not action then
   gitano.log.crit(reason)
   gitano.log.fatal("Ruleset did not complete cleanly")
end

if action ~= "allow" then
   gitano.log.critical("Rules refused update:", reason)
   gitano.log.fatal("Ruleset denied action.  Sorry")
end

-- Now perform any special hook checks (e.g. for the admin hook)
gitano.log.ddebug("Ruleset allowed the action, let's run builtin action")

local allow, msg = gitano.actions.update_actions(conf, repo, context)
if not allow then
   gitano.log.critical("Builtin actions said:", msg)
   gitano.log.fatal("Actions denied action.  Sorry")
end

if repo:uses_hook("update") then
   gitano.log.debug("Configuring for update hook")
   gitano.actions.set_supple_globals("update")

   local msg = "Running repository update hook"
   gitano.log.info(msg)
   gitano.syslog.info(msg)

   local info = {
      username = username,
      keytag = keytag,
      source = source,
      realname = (config.users[username] or {}).real_name or "",
      email = (config.users[username] or {}).email_address or "",
   }
   local ok, msg = gitano.supple.run_hook("update", repo, info,
					  refname, oldsha, newsha)
   if not ok then
      gitano.log.fatal(msg or "No reason given to refuse action.")
   end
   gitano.log.info("Finished")
end

gitano.log.info("Allowing ref update of", 
		refname, "from", oldsha, "to", newsha)

gitano.log.syslog.info("Allowing ref", action, "of", refname,
		       "( was", oldsha, "is now", newsha, ")")

gitano.log.syslog.close()

return 0