Client-side vs server-side hooks in Git - CLI Comparison

Introduction

Git hooks are scripts that run automatically at certain points in your work. Client-side hooks run on your computer before or after you make changes, while server-side hooks run on the central server to control what happens when you push changes.

When you want to check your code for errors before saving it locally.

When you want to prevent bad code from being pushed to the shared repository.

When you want to automatically format your code before committing.

When you want to send notifications after someone pushes code to the server.

When you want to enforce rules like commit message style on the server.

Commands

Navigate to the hooks directory inside your Git repository where client-side hook scripts are stored.

Terminal

cd my-repo/.git/hooks

Expected Output

No output (command runs silently)

List all the example hook scripts available by default in the hooks folder.

Terminal

ls

Expected Output

applypatch-msg.sample

commit-msg.sample

post-commit.sample

post-checkout.sample

post-merge.sample

pre-commit.sample

pre-push.sample

pre-rebase.sample

prepare-commit-msg.sample

update.sample

Create a simple client-side pre-commit hook script that prints a message before a commit is made.

Terminal

echo '#!/bin/sh\necho "Running pre-commit hook"' > pre-commit

Expected Output

No output (command runs silently)

Make the pre-commit hook script executable so Git can run it automatically.

Terminal

chmod +x pre-commit

Expected Output

No output (command runs silently)

Make a commit to see the client-side pre-commit hook run and print its message.

Terminal

git commit -m "Test commit"

Expected Output

Running pre-commit hook

[main abc1234] Test commit

 1 file changed, 1 insertion(+)

Check the server-side hooks folder on the Git server to see available hook scripts.

Terminal

ssh user@server 'cd /path/to/repo.git/hooks && ls'

Expected Output

pre-receive

post-receive

update

post-update

Create a simple server-side pre-receive hook that prints a message when someone pushes code.

Terminal

ssh user@server 'echo "#!/bin/sh\necho \"Server-side pre-receive hook running\"" > /path/to/repo.git/hooks/pre-receive && chmod +x /path/to/repo.git/hooks/pre-receive'

Expected Output

No output (command runs silently)

Push your changes to the server to trigger the server-side pre-receive hook and see its message.

Terminal

git push origin main

Expected Output

Server-side pre-receive hook running

Enumerating objects: 3, done.

Counting objects: 100% (3/3), done.

Delta compression using up to 4 threads

Compressing objects: 100% (2/2), done.

Writing objects: 100% (3/3), 300 bytes | 300.00 KiB/s, done.

Total 3 (delta 0), reused 0 (delta 0)

To ssh://server/path/to/repo.git

   abc1234..def5678  main -> main

Key Concept

Client-side hooks run on your computer before or after you make changes, while server-side hooks run on the central server to control what happens when you push changes.

Common Mistakes

Not making the hook script executable

Git will ignore hook scripts that are not executable, so they won't run.

Always run chmod +x on your hook scripts to make them executable.

Editing sample hook files without removing the .sample extension

Git only runs hook scripts without the .sample extension, so your changes won't take effect.

Remove the .sample extension or create a new file without it for your hook.

Trying to run server-side hooks locally

Server-side hooks only run on the Git server during push operations, so running them locally has no effect.

Manage server-side hooks by accessing the Git server directly.

Summary

Client-side hooks run scripts on your local machine before or after Git actions like commit or push.

Server-side hooks run on the Git server to control or respond to pushes from clients.

You must make hook scripts executable and place them in the correct hooks folder to work.

Practice

1. Which of the following best describes a client-side Git hook?

easy

A. A Git command to clone repositories.

B. A script that runs on the Git server to control repository access.

C. A tool to merge branches automatically on the server.

D. A script that runs on your local machine before or after Git actions like commit or push.

Solution

1. Step 1: Understand client-side hooks context

   Client-side hooks run on your local computer and trigger before or after Git commands like commit or push.

2. Step 2: Differentiate from server-side hooks

   Server-side hooks run on the Git server to enforce rules for all users, unlike client-side hooks which are local.

3. Final Answer:

   A script that runs on your local machine before or after Git actions like commit or push. -> Option D

4. Quick Check:

   Client-side hook = local script [OK]

Hint: Client-side hooks run locally before/after Git commands [OK]

Common Mistakes:

• Confusing client-side hooks with server-side hooks
• Thinking hooks run only on the server
• Assuming hooks are Git commands

2. Which of the following is the correct location to place a client-side pre-commit hook script in a Git repository?

easy

A. /usr/local/git/hooks/pre-commit

B. .git/hooks/server-pre-commit

C. .git/hooks/pre-commit

D. .git/pre-commit

Solution

1. Step 1: Identify the standard hooks directory

   Git client-side hooks are stored inside the .git/hooks directory of the local repository.

2. Step 2: Confirm the correct hook filename

   The pre-commit hook script must be named exactly 'pre-commit' inside .git/hooks.

3. Final Answer:

   .git/hooks/pre-commit -> Option C

4. Quick Check:

   Client-side hooks live in .git/hooks [OK]

Hint: Client-side hooks go in .git/hooks folder [OK]

Common Mistakes:

• Placing hooks outside the .git directory
• Using wrong filenames for hooks
• Confusing server-side hook locations

3. Given this server-side hook script named pre-receive on the Git server:

#!/bin/sh
while read oldrev newrev refname
 do
   if [ "$refname" = "refs/heads/main" ]; then
     echo "Pushes to main branch are not allowed."
     exit 1
   fi
 done
exit 0

What will happen if a user tries to push commits to the main branch?

medium

A. The push will be rejected with the message 'Pushes to main branch are not allowed.'

B. The push will succeed without any message.

C. The push will be accepted but with a warning.

D. The server will crash due to a syntax error.

Solution

1. Step 1: Analyze the pre-receive hook logic

   The script reads each ref being pushed. If the ref is 'refs/heads/main', it prints a message and exits with status 1, which rejects the push.

2. Step 2: Understand Git hook exit codes

   Exiting with 1 means failure, so Git rejects the push and shows the message to the user.

3. Final Answer:

   The push will be rejected with the message 'Pushes to main branch are not allowed.' -> Option A

4. Quick Check:

   Exit 1 in server hook rejects push [OK]

Hint: Exit code 1 in server hook blocks push [OK]

Common Mistakes:

• Assuming push succeeds despite exit 1
• Confusing client-side and server-side hook effects
• Ignoring the printed message

4. You wrote a client-side pre-commit hook script but it does not run when you commit. What is the most likely reason?

medium

A. The script is placed in the wrong directory on the server.

B. The script file is not executable.

C. Git does not support pre-commit hooks.

D. You forgot to push the hook to the remote repository.

Solution

1. Step 1: Check script permissions

   Client-side hooks must be executable files. If not, Git will ignore them silently.

2. Step 2: Verify hook location and Git support

   The hook must be in .git/hooks locally. Git supports pre-commit hooks, and pushing hooks to remote does not affect local hooks.

3. Final Answer:

   The script file is not executable. -> Option B

4. Quick Check:

   Hooks must be executable to run [OK]

Hint: Make hook scripts executable with chmod +x [OK]

Common Mistakes:

• Placing hooks on the server for client-side use
• Thinking Git lacks pre-commit hooks
• Expecting hooks to transfer via git push

5. You want to enforce that all commits pushed to the shared repository have a signed commit message. Which hook setup is best to ensure this rule is always checked regardless of the user's local setup?

hard

A. Implement a server-side pre-receive hook that rejects unsigned commits.

B. Ask each developer to add a client-side commit-msg hook to check signatures.

C. Use a client-side pre-push hook to warn about unsigned commits.

D. Rely on GitHub or GitLab UI to manually check commit signatures.

Solution

1. Step 1: Understand enforcement scope

   Client-side hooks depend on each user's setup and can be bypassed or missing.

2. Step 2: Use server-side hooks for mandatory checks

   Server-side hooks run on the shared repository and can reject pushes that don't meet rules, ensuring enforcement for all users.

3. Final Answer:

   Implement a server-side pre-receive hook that rejects unsigned commits. -> Option A

4. Quick Check:

   Server hooks enforce rules for all pushes [OK]

Hint: Use server-side hooks to enforce rules for all users [OK]

Common Mistakes:

• Relying only on client-side hooks for enforcement
• Assuming UI checks block pushes automatically
• Ignoring that client hooks can be disabled