epubjs

<?xml version='1.0' encoding='utf-8'?> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>Pro Git - professional version control</title> <meta content="http://www.w3.org/1999/xhtml; charset=utf-8" http-equiv="Content-Type"/> <link href="stylesheet.css" type="text/css" rel="stylesheet"/> <style type="text/css"> @page { margin-bottom: 5.000000pt; margin-top: 5.000000pt; }</style> </head> <body class="calibre"> <h2 class="calibre4" id="calibre_pb_62">An Example Git-Enforced Policy</h2> In this section, you'll use what you've learned to establish a Git workflow that checks for a custom commit message format, enforces fast-forward-only pushes, and allows only certain users to modify certain subdirectories in a project. You'll build client scripts that help the developer know if their push will be rejected and server scripts that actually enforce the policies. I used Ruby to write these, both because it's my preferred scripting language and because I feel it's the most pseudocode-looking of the scripting languages; thus you should be able to roughly follow the code even if you don't use Ruby. However, any language will work fine. All the sample hook scripts distributed with Git are in either Perl or Bash scripting, so you can also see plenty of examples of hooks in those languages by looking at the samples. <h3 class="calibre5">Server-Side Hook</h3> All the server-side work will go into the update file in your hooks directory. The update file runs once per branch being pushed and takes the reference being pushed to, the old revision where that branch was, and the new revision being pushed. You also have access to the user doing the pushing if the push is being run over SSH. If you've allowed everyone to connect with a single user (like "git") via public-key authentication, you may have to give that user a shell wrapper that determines which user is connecting based on the public key, and set an environment variable specifying that user. Here I assume the connecting user is in the <code class="calibre10">$USER</code> environment variable, so your update script begins by gathering all the information you need: <pre class="calibre9"><code class="calibre10">#!/usr/bin/env ruby $refname = ARGV[0] $oldrev = ARGV[1] $newrev = ARGV[2] $user = ENV['USER'] puts "Enforcing Policies... \n(#{$refname}) (#{$oldrev[0,6]}) (#{$newrev[0,6]})" </code></pre> Yes, I'm using global variables. Don't judge me - it's easier to demonstrate in this manner. <h4 class="calibre14">Enforcing a Specific Commit-Message Format</h4> Your first challenge is to enforce that each commit message must adhere to a particular format. Just to have a target, assume that each message has to include a string that looks like "ref: 1234" because you want each commit to link to a work item in your ticketing system. You must look at each commit being pushed up, see if that string is in the commit message, and, if the string is absent from any of the commits, exit non-zero so the push is rejected. You can get a list of the SHA-1 values of all the commits that are being pushed by taking the <code class="calibre10">$newrev</code> and <code class="calibre10">$oldrev</code> values and passing them to a Git plumbing command called <code class="calibre10">git rev-list</code>. This is basically the <code class="calibre10">git log</code> command, but by default it prints out only the SHA-1 values and no other information. So, to get a list of all the commit SHAs introduced between one commit SHA and another, you can run something like this: <pre class="calibre9"><code class="calibre10">$ git rev-list 538c33..d14fc7 d14fc7c847ab946ec39590d87783c69b031bdfb7 9f585da4401b0a3999e84113824d15245c13f0be 234071a1be950e2a8d078e6141f5cd20c1e61ad3 dfa04c9ef3d5197182f13fb5b9b1fb7717d2222a 17716ec0f1ff5c77eff40b7fe912f9f6cfd0e475 </code></pre> You can take that output, loop through each of those commit SHAs, grab the message for it, and test that message against a regular expression that looks for a pattern. You have to figure out how to get the commit message from each of these commits to test. To get the raw commit data, you can use another plumbing command called <code class="calibre10">git cat-file</code>. I'll go over all these plumbing commands in detail in Chapter 9; but for now, here's what that command gives you: <pre class="calibre9"><code class="calibre10">$ git cat-file commit ca82a6 tree cfda3bf379e4f8dba8717dee55aab78aef7f4daf parent 085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7 author Scott Chacon <schacon@gmail.com> 1205815931 -0700 committer Scott Chacon <schacon@gmail.com> 1240030591 -0700 changed the version number </code></pre> A simple way to get the commit message from a commit when you have the SHA-1 value is to go to the first blank line and take everything after that. You can do so with the <code class="calibre10">sed</code> command on Unix systems: <pre class="calibre9"><code class="calibre10">$ git cat-file commit ca82a6 | sed '1,/^$/d' changed the version number </code></pre> You can use that incantation to grab the commit message from each commit that is trying to be pushed and exit if you see anything that doesn't match. To exit the script and reject the push, exit non-zero. The whole method looks like this: <pre class="calibre9"><code class="calibre10">$regex = /\[ref: (\d+)\]/ # enforced custom commit message format def check_message_format missed_revs = `git rev-list #{$oldrev}..#{$newrev}`.split("\n") missed_revs.each do |rev| message = `git cat-file commit #{rev} | sed '1,/^$/d'` if !$regex.match(message) puts "[POLICY] Your message is not formatted correctly" exit 1 end end end check_message_format </code></pre> Putting that in your <code class="calibre10">update</code> script will reject updates that contain commits that have messages that don't adhere to your rule. <h4 class="calibre14">Enforcing a User-Based ACL System</h4> Suppose you want to add a mechanism that uses an access control list (ACL) that specifies which users are allowed to push changes to which parts of your projects. Some people have full access, and others only have access to push changes to certain subdirectories or specific files. To enforce this, you'll write those rules to a file named <code class="calibre10">acl</code> that lives in your bare Git repository on the server. You'll have the <code class="calibre10">update</code> hook look at those rules, see what files are being introduced for all the commits being pushed, and determine whether the user doing the push has access to update all those files. The first thing you'll do is write your ACL. Here you'll use a format very much like the CVS ACL mechanism: it uses a series of lines, where the first field is <code class="calibre10">avail</code> or <code class="calibre10">unavail</code>, the next field is a comma-delimited list of the users to which the rule applies, and the last field is the path to which the rule applies (blank meaning open access). All of these fields are delimited by a pipe (<code class="calibre10">|</code>) character. In this case, you have a couple of administrators, some documentation writers with access to the <code class="calibre10">doc</code> directory, and one developer who only has access to the <code class="calibre10">lib</code> and <code class="calibre10">tests</code> directories, and your ACL file looks like this: <pre class="calibre9"><code class="calibre10">avail|nickh,pjhyett,defunkt,tpw avail|usinclair,cdickens,ebronte|doc avail|schacon|lib avail|schacon|tests </code></pre> You begin by reading this data into a structure that you can use. In this case, to keep the example simple, you'll only enforce the <code class="calibre10">avail</code> directives. Here is a method that gives you an associative array where the key is the user name and the value is an array of paths to which the user has write access: <pre class="calibre9"><code class="calibre10">def get_acl_access_data(acl_file) # read in ACL data acl_file = File.read(acl_file).split("\n").reject { |line| line == '' } access = {} acl_file.each do |line| avail, users, path = line.split('|') next unless avail == 'avail' users.split(',').each do |user| access[user] ||= [] access[user] << path end end access end </code></pre> On the ACL file you looked at earlier, this <code class="calibre10">get_acl_access_data</code> method returns a data structure that looks like this: <pre class="calibre9"><code class="calibre10">{"defunkt"=>[nil], "tpw"=>[nil], "nickh"=>[nil], "pjhyett"=>[nil], "schacon"=>["lib", "tests"], "cdickens"=>["doc"], "usinclair"=>["doc"], "ebronte"=>["doc"]} </code></pre> Now that you have the permissions sorted out, you need to determine what paths the commits being pushed have modified, so you can make sure the user who's pushing has access to all of them. You can pretty easily see what files have been modified in a single commit with the <code class="calibre10">--name-only</code> option to the <code class="calibre10">git log</code> command (mentioned briefly in Chapter 2): <pre class="calibre9"><code class="calibre10">$ git log -1 --name-only --pretty=format:'' 9f585d README lib/test.rb </code></pre> If you use the ACL structure returned from the <code class="calibre10">get_acl_access_data</code> method and check it against the listed files in each of the commits, you can determine whether the user has access to push all of their commits: <pre class="calibre9"><code class="calibre10"># only allows certain users to modify certain subdirectories in a project def check_directory_perms access = get_acl_access_data('acl') # see if anyone is trying to push something they can't new_commits = `git rev-list #{$oldrev}..#{$newrev}`.split("\n") new_commits.each do |rev| files_modified = `git log -1 --name-only --pretty=format:'' #{rev}`.split("\n") files_modified.each do |path| next if path.size == 0 has_file_access = false access[$user].each do |access_path| if !access_path # user has access to everything || (path.index(access_path) == 0) # access to this path has_file_access = true end end if !has_file_access puts "[POLICY] You do not have access to push to #{path}" exit 1 end end end end check_directory_perms </code></pre> Most of that should be easy to follow. You get a list of new commits being pushed to your server with <code class="calibre10">git rev-list</code>. Then, for each of those, you find which files are modified and make sure the user who's pushing has access to all the paths being modified. One Rubyism that may not be clear is <code class="calibre10">path.index(access_path) == 0</code>, which is true if path begins with <code class="calibre10">access_path</code> - this ensures that <code class="calibre10">access_path</code> is not just in one of the allowed paths, but an allowed path begins with each accessed path. Now your users can't push any commits with badly formed messages or with modified files outside of their designated paths. <h4 class="calibre14">Enforcing Fast-Forward-Only Pushes</h4> The only thing left is to enforce fast-forward-only pushes. In Git versions 1.6 or newer, you can set the <code class="calibre10">receive.denyDeletes</code> and <code class="calibre10">receive.denyNonFastForwards</code> settings. But enforcing this with a hook will work in older versions of Git, and you can modify it to do so only for certain users or whatever else you come up with later. The logic for checking this is to see if any commits are reachable from the older revision that aren't reachable from the newer one. If there are none, then it was a fast-forward push; otherwise, you deny it: <pre class="calibre9"><code class="calibre10"># enforces fast-forward only pushes def check_fast_forward missed_refs = `git rev-list #{$newrev}..#{$oldrev}` missed_ref_count = missed_refs.split("\n").size if missed_ref_count > 0 puts "[POLICY] Cannot push a non fast-forward reference" exit 1 end end check_fast_forward </code></pre> Everything is set up. If you run <code class="calibre10">chmod u+x .git/hooks/update</code>, which is the file you into which you should have put all this code, and then try to push a non-fast-forwarded reference, you get something like this: <pre class="calibre9"><code class="calibre10">$ git push -f origin master Counting objects: 5, done. Compressing objects: 100% (3/3), done. Writing objects: 100% (3/3), 323 bytes, done. Total 3 (delta 1), reused 0 (delta 0) Unpacking objects: 100% (3/3), done. Enforcing Policies... (refs/heads/master) (8338c5) (c5b616) [POLICY] Cannot push a non-fast-forward reference error: hooks/update exited with error code 1 error: hook declined to update refs/heads/master To git@gitserver:project.git ! [remote rejected] master -> master (hook declined) error: failed to push some refs to 'git@gitserver:project.git' </code></pre> There are a couple of interesting things here. First, you see this where the hook starts running. <pre class="calibre9"><code class="calibre10">Enforcing Policies... (refs/heads/master) (fb8c72) (c56860) </code></pre> Notice that you printed that out to stdout at the very beginning of your update script. It's important to note that anything your script prints to stdout will be transferred to the client. The next thing you'll notice is the error message. <pre class="calibre9"><code class="calibre10">[POLICY] Cannot push a non fast-forward reference error: hooks/update exited with error code 1 error: hook declined to update refs/heads/master </code></pre> The first line was printed out by you, the other two were Git telling you that the update script exited non-zero and that is what is declining your push. Lastly, you have this: <pre class="calibre9"><code class="calibre10">To git@gitserver:project.git ! [remote rejected] master -> master (hook declined) error: failed to push some refs to 'git@gitserver:project.git' </code></pre> You'll see a remote rejected message for each reference that your hook declined, and it tells you that it was declined specifically because of a hook failure. Furthermore, if the ref marker isn't there in any of your commits, you'll see the error message you're printing out for that. <pre class="calibre9"><code class="calibre10">[POLICY] Your message is not formatted correctly </code></pre> Or if someone tries to edit a file they don't have access to and push a commit containing it, they will see something similar. For instance, if a documentation author tries to push a commit modifying something in the <code class="calibre10">lib</code> directory, they see <pre class="calibre9"><code class="calibre10">[POLICY] You do not have access to push to lib/test.rb </code></pre> That's all. From now on, as long as that <code class="calibre10">update</code> script is there and executable, your repository will never be rewound and will never have a commit message without your pattern in it, and your users will be sandboxed. <h3 class="calibre5">Client-Side Hooks</h3> The downside to this approach is the whining that will inevitably result when your users' commit pushes are rejected. Having their carefully crafted work rejected at the last minute can be extremely frustrating and confusing; and furthermore, they will have to edit their history to correct it, which isn't always for the faint of heart. The answer to this dilemma is to provide some client-side hooks that users can use to notify them when they're doing something that the server is likely to reject. That way, they can correct any problems before committing and before those issues become more difficult to fix. Because hooks aren't transferred with a clone of a project, you must distribute these scripts some other way and then have your users copy them to their <code class="calibre10">.git/hooks</code> directory and make them executable. You can distribute these hooks within the project or in a separate project, but there is no way to set them up automatically. To begin, you should check your commit message just before each commit is recorded, so you know the server won't reject your changes due to badly formatted commit messages. To do this, you can add the <code class="calibre10">commit-msg</code> hook. If you have it read the message from the file passed as the first argument and compare that to the pattern, you can force Git to abort the commit if there is no match: <pre class="calibre9"><code class="calibre10">#!/usr/bin/env ruby message_file = ARGV[0] message = File.read(message_file) $regex = /\[ref: (\d+)\]/ if !$regex.match(message) puts "[POLICY] Your message is not formatted correctly" exit 1 end </code></pre> If that script is in place (in <code class="calibre10">.git/hooks/commit-msg</code>) and executable, and you commit with a message that isn't properly formatted, you see this: <pre class="calibre9"><code class="calibre10">$ git commit -am 'test' [POLICY] Your message is not formatted correctly </code></pre> No commit was completed in that instance. However, if your message contains the proper pattern, Git allows you to commit: <pre class="calibre9"><code class="calibre10">$ git commit -am 'test [ref: 132]' [master e05c914] test [ref: 132] 1 files changed, 1 insertions(+), 0 deletions(-) </code></pre> Next, you want to make sure you aren't modifying files that are outside your ACL scope. If your project's <code class="calibre10">.git</code> directory contains a copy of the ACL file you used previously, then the following <code class="calibre10">pre-commit</code> script will enforce those constraints for you: <pre class="calibre9"><code class="calibre10">#!/usr/bin/env ruby $user = ENV['USER'] # [ insert acl_access_data method from above ] # only allows certain users to modify certain subdirectories in a project def check_directory_perms access = get_acl_access_data('.git/acl') files_modified = `git diff-index --cached --name-only HEAD`.split("\n") files_modified.each do |path| next if path.size == 0 has_file_access = false access[$user].each do |access_path| if !access_path || (path.index(access_path) == 0) has_file_access = true end if !has_file_access puts "[POLICY] You do not have access to push to #{path}" exit 1 end end end check_directory_perms </code></pre> This is roughly the same script as the server-side part, but with two important differences. First, the ACL file is in a different place, because this script runs from your working directory, not from your Git directory. You have to change the path to the ACL file from this <pre class="calibre9"><code class="calibre10">access = get_acl_access_data('acl') </code></pre> to this: <pre class="calibre9"><code class="calibre10">access = get_acl_access_data('.git/acl') </code></pre> The other important difference is the way you get a listing of the files that have been changed. Because the server-side method looks at the log of commits, and, at this point, the commit hasn't been recorded yet, you must get your file listing from the staging area instead. Instead of <pre class="calibre9"><code class="calibre10">files_modified = `git log -1 --name-only --pretty=format:'' #{ref}` </code></pre> you have to use <pre class="calibre9"><code class="calibre10">files_modified = `git diff-index --cached --name-only HEAD` </code></pre> But those are the only two differences - otherwise, the script works the same way. One caveat is that it expects you to be running locally as the same user you push as to the remote machine. If that is different, you must set the <code class="calibre10">$user</code> variable manually. The last thing you have to do is check that you're not trying to push non-fast-forwarded references, but that is a bit less common. To get a reference that isn't a fast-forward, you either have to rebase past a commit you've already pushed up or try pushing a different local branch up to the same remote branch. Because the server will tell you that you can't push a non-fast-forward anyway, and the hook prevents forced pushes, the only accidental thing you can try to catch is rebasing commits that have already been pushed. Here is an example pre-rebase script that checks for that. It gets a list of all the commits you're about to rewrite and checks whether they exist in any of your remote references. If it sees one that is reachable from one of your remote references, it aborts the rebase: <pre class="calibre9"><code class="calibre10">#!/usr/bin/env ruby base_branch = ARGV[0] if ARGV[1] topic_branch = ARGV[1] else topic_branch = "HEAD" end target_shas = `git rev-list #{base_branch}..#{topic_branch}`.split("\n") remote_refs = `git branch -r`.split("\n").map { |r| r.strip } target_shas.each do |sha| remote_refs.each do |remote_ref| shas_pushed = `git rev-list ^#{sha}^@ refs/remotes/#{remote_ref}` if shas_pushed.split("\n").include?(sha) puts "[POLICY] Commit #{sha} has already been pushed to #{remote_ref}" exit 1 end end end </code></pre> This script uses a syntax that wasn't covered in the Revision Selection section of Chapter 6. You get a list of commits that have already been pushed up by running this: <pre class="calibre9"><code class="calibre10">git rev-list ^#{sha}^@ refs/remotes/#{remote_ref} </code></pre> The <code class="calibre10">SHA^@</code> syntax resolves to all the parents of that commit. You're looking for any commit that is reachable from the last commit on the remote and that isn't reachable from any parent of any of the SHAs you're trying to push up - meaning it's a fast-forward. The main drawback to this approach is that it can be very slow and is often unnecessary - if you don't try to force the push with <code class="calibre10">-f</code>, the server will warn you and not accept the push. However, it's an interesting exercise and can in theory help you avoid a rebase that you might later have to go back and fix. </body> </html>