fall2010

#1 Alice initializing repository

Assume Alice has some folder work, she wants to track the changes using git repository. The actions are:

• Navigate to work folder (assume /home/alice/work), initialize local git repository, make initial commit:

## Navigate to work folder

alice@local:~$ cd ~/work

alice@local:~/work$ ls -1

file001.txt

file002.txt



## Initialize repository

alice@local:~/work$ git init

Initialized empty Git repository in /home/alice/work/.git/

alice@local:~/work$ ls -a1

.

..

file001.txt

file002.txt

.git



## Review local configurations

alice@local:~/work$ git config -f .git/config -l

core.repositoryformatversion=0

core.filemode=true

core.bare=false

core.logallrefupdates=true



## Specify user name (used to sign commits)

alice@local:~/work$ git config -f ./.git/config user.name  "Alice"

alice@local:~/work$ git config -f ./.git/config user.email "alice@ut.ee"

alice@local:~/work$ git config -f .git/config -l

core.repositoryformatversion=0

core.filemode=true

core.bare=false

core.logallrefupdates=true

user.name=Alice

user.email=alice@ut.ee



## Show the working tree status

alice@local:~/work$ git status

# On branch master

#

# Initial commit

#

# Untracked files:

#   (use "git add <file>..." to include in what will be committed)

#

#       file001.txt

#       file002.txt

nothing added to commit but untracked files present (use "git add" to track)



## Track all files

alice@local:~/work$ git add -A

alice@local:~/work$ git status

# On branch master

#

# Initial commit

#

# Changes to be committed:

#   (use "git rm --cached <file>..." to unstage)

#

#       new file:   file001.txt

#       new file:   file002.txt

#



## Commit all changes (two added files)

alice@local:~/work$ git commit -a -m "Added some text"

[master (root-commit) 7c6deb8] Added some text

 2 files changed, 5 insertions(+), 0 deletions(-)

 create mode 100644 file001.txt

 create mode 100644 file002.txt

alice@local:~/work$ git status

# On branch master

nothing to commit (working directory clean)

• Now the files in work folder are tracked using git repository

#2 Alice publishing repository

Alice has a local git repository in work folder, she wants to share it to her friends (Bob,Diane) using git and her home folder at ats.cs.ut.ee server. The actions are:

• Login to ats.cs.ut.ee, setup bare git repository (this one will be used to push Alice's changes from local repository), make it public:

## Login to ats.cs.ut.ee

alice@local:~/work$ ssh -v alice@ats.cs.ut.ee

alice@ats.cs.ut.ee's password:

[alice@socrates ~]$



## Navigate to public_html, create repository foder, this will contain bare git repository

[alice@socrates ~]$ cd public_html

[alice@socrates ~/public_html]$ mkdir repository



## Give it the read/execute permissions

[alice@socrates ~/public_html]$ chmod a+rx repository



## Initialize bare git repository

[alice@socrates repository]$ git init --bare

Initialized empty Git repository in ~/public_html/repository/

[alice@socrates repository]$ ls -1

branches

config

description

HEAD

hooks

info

objects

refs



## Enable post-update scripts

[alice@socrates repository]$ cp hooks/post-update.sample hooks/post-update



## Bare repository is ready, give read/execute permissions to public_html and home folder

[alice@socrates repository]$ cd ~/

[alice@socrates ~]$ chmod a+rx public_html

[alice@socrates ~]$ chmod a+rx ../alice



## Show absolute path of the home directory, this will be needed in the next step

[alice@socrates ~]$ pwd

/home/murakas/a/alice

[alice@socrates ~]$ exit

alice@local:~/work$

• Make sure repository is published and available through http, navigate browser to "http://www.ut.ee/~alice/repository", should show:

Index of /~alice/repository

    *  Parent Directory

    * HEAD

    * branches/

    * config

    * description

    * hooks/

    * info/

    * objects/

    * refs/

• Push the local changes to publshed repository at ats.cs.ut.ee using ssh

## Add remote repository called "public-ssh" pointing to /home/murakas/a/alice/public_html/repository on ats.cs.ut.ee

alice@local:~/work$ git remote add public-ssh ssh://alice@ats.cs.ut.ee/home/murakas/a/alice/public_html/repository



## List remotes

alice@local:~/work$ git remote show

public-ssh



## Fetch changes (just to be sure it remote is setup correctly)

alice@local:~/work$ git fetch public-ssh

alics@ats.cs.ut.ee's password:

alice@local:~/work$



## List branches

alice@local:~/work$ git branch -a

* master



## Push changes from local branch "master" to remote repository "public-ssh"

alice@local:~/work$ git push public-ssh master

alice@ats.cs.ut.ee's password:

Counting objects: 4, done.

Delta compression using up to 2 threads.

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

Writing objects: 100% (4/4), 268 bytes, done.

Total 4 (delta 0), reused 0 (delta 0)

To ssh://alice@ats.cs.ut.ee/home/murakas/a/alice/public_html/repository

 * [new branch]      master -> master



## List branches (remote master branch listed)

alice@local:~/work$ git branch -a

* master

  remotes/public-ssh/master



## View log, short format (--oneline), print asci graph of commits (--graph)

alice@local:~/work$ git log --graph --oneline

* 7c6deb8 Added some text

• Now the changes are also reflected on the web, navigate browser to "http://www.ut.ee/~alice/repository/info/refs", should show:

7c6deb8397ab8e30b17034a8bf6cd18810fa7e0f        refs/heads/master

• Now the local work repository is published through "http://www.ut.ee/~alice/repository/"

#3 Bob and Diane cloning Alice's published repository

Bob has an address of Alice's published repository "http://www.ut.ee/~alice/repository". He wants to fetch the code for development. The actions are:

• Clone Alice's repository

## Navigate to workspace

bob@local:~$ cd ~/workspace

bob@local:~/workspace$



## Clone Alice's repository from "http://www.ut.ee/~alice/repository" to ~/workspace/alice_work

bob@local:~/workspace$ git clone http://www.ut.ee/~alice/repository alice_work

Initialized empty Git repository in /home/devel/workspace/alice_work/.git/

bob@local:~/workspace$ cd alice_work

bob@local:~/workspace/alice_work$ ls -1AhpS

.git/

file001.txt

file002.txt



## Don't forget to pass user.name and user.email to config file. So the commits will be automatically subscribed.

bob@local:~/workspace/alice_work$ git config -f ./.git/config user.name  "Bob"

bob@local:~/workspace/alice_work$ git config -f ./.git/config user.email "bob@ut.ee"

bob@local:~/workspace/alice_work$ git config -f ./.git/config -l

core.repositoryformatversion=0

core.filemode=true

core.bare=false

core.logallrefupdates=true

remote.origin.fetch=+refs/heads/*:refs/remotes/origin/*

remote.origin.url=http://www.ut.ee/~alice/repository

branch.master.remote=origin

branch.master.merge=refs/heads/master

user.name=Bob

user.email=bob@ut.ee

• Now bob has a clone of Alice's repository, he is ready to develop.

Assume Diane does the same (in respekt to hers username).

#4 Bob making changes; Diane,Alice synchronizing

Bob cloned Alice's repository from "http://www.ut.ee/~alice/repository" and made changes to the code. He wants to share his changes to Alice and Diane. The actions are:

• Commit changes, and publish the local repository

## Check the current status of the repository:

bob@local:~/workspace/alice_work$ git status

# On branch master

# Changed but not updated:

#   (use "git add <file>..." to update what will be committed)

#   (use "git checkout -- <file>..." to discard changes in working directory)

#

#       modified:   file001.txt

#       modified:   file002.txt

#

# Untracked files:

#   (use "git add <file>..." to include in what will be committed)

#

#       file003.txt

no changes added to commit (use "git add" and/or "git commit -a")



## There are one new file, add it to version control, use -A to add all

bob@local:~/workspace/alice_work$ git add -A

bob@local:~/workspace/alice_work$ git status

# On branch master

# Changes to be committed:

#   (use "git reset HEAD <file>..." to unstage)

#

#       modified:   file001.txt

#       modified:   file002.txt

#       new file:   file003.txt

#



## Now all files are tracked, commit the changes, use -a to commit all

bob@local:~/workspace/alice_work$ git commit -a -m "Added some lines"

[master 96b36ba] Added some lines

 3 files changed, 9 insertions(+), 1 deletions(-)

 create mode 100644 file003.txt



## Check status, it is Bob's branch is ahead of Alice's one.

bob@local:~/workspace/alice_work$ git status

# On branch master

# Your branch is ahead of 'origin/master' by 1 commit.

#

nothing to commit (working directory clean)

• Now Bob is ahead of Diane and Alice. They need to get his changes, Bob publishes his repository on "http://www.ut.ee/~bob/repository".

## Prepare the bare repository in the home folder on '''ats.cs.ut.ee'''

#    FOLLOW THE STEPS DESCRIBED IN #2 (preparing bare repository and pushing local changes to it)

##



## Check the remote repositories

bob@local:~/workspace/alice_work$ git remote show

public-ssh



## Check the remote branches

bob@local:~/workspace/alice_work$ git branch -a

* master

  remotes/public-ssh/master

• Now Bob has his published his repository on "http://www.ut.ee/~bob/repository". Diane and Alice can fetch Bob's changes.

• Alice connects Bob's published repository, fetches the changes and merges into her local branch.

## Add remote repository "http://www.ut.ee/~bob/repository", named it 'bob-http'

alice@local:~$ cd ~/work

alice@local:~/work$ git remote add bob-http http://www.ut.ee/~bob/repository

alice@local:~/work$ git remote show

bob-http

public-ssh



## Fetch the changes from Bob's remote repository,

alice@local:~/work$ git fetch bob-http

 * [new branch]      master     -> bob-http/master



## Show remote branches, 'remotes/bob-http/master' carries Bob's changes

alice@local:~/work$ git branch -a

* master

  remotes/bob-http/master

  remotes/public-ssh/master



## Merge Bob's changes into the local 'master' branch

## 1. Check you current branch, should be 'master', no un-commited  changes

alice@local:~/work$ git status

# On branch master

nothing to commit (working directory clean)



## 2. Merge the changes from 'bob-http/master' into 'master'

alice@local:~/work$ git merge bob-http/master

Updating 7c6deb8..96b36ba

Fast-forward

 file001.txt |    2 +-

 file002.txt |    1 +

 file003.txt |    7 +++++++

 3 files changed, 9 insertions(+), 1 deletions(-)

 create mode 100644 file003.txt



## Now check log, should contain Bob's commits

alice@local:~/work$ git log --graph --oneline

* 96b36ba Added some lines

* 7c6deb8 Added some text



## More details

alice@local:~/work$ git log --graph

* commit 96b36baf6924ee5aaebe6a0b77a5375f95a155f2

| Author: Bob <bob@ut.ee>

| Date:   Fri Oct 1 14:40:37 2010 +0300

|

|     Added some lines

|

* commit 7c6deb8397ab8e30b17034a8bf6cd18810fa7e0f

  Author: Alice <alice@ut.ee>

  Date:   Thu Sep 16 17:35:07 2010 +0300



      Added some text

• Now Alice has Bob's changes in her local repository and she is ready to develop.

• Assume Diane does the same (in respekt to hers username)

#5 Complete distributed repository

In complete distributed repository:

• every peer has to be able to publish his/her changes.

  • Bob and Alice did publish the repositories.

• every peer has the remote (published) repositories of other Peers attached to the local one.

  • Bob and Diane did attach Alice's repository (while cloning it)

  • Alice and Diane did attach Bob's repository manually

Now Diane has to publish her local repository, Bob and Alice have to attach it to their local repositories:

• Diane publishes her local repository on "http://www.ut.ee/~diane/repository"

## Prepare the bare repository in the home folder on '''ats.cs.ut.ee'''

#    FOLLOW THE STEPS DESCRIBED IN #2 (preparing bare repository and pushing local changes to it)

##

• Alice connects Diane's repository, fetches changes, merges them into local branch

##

#    FOLLOW THE STEPS DESCRIBES IN #4 (Alice connects Bob's published repository ...

#          - Use 'diane-http' as remote repository name

#          - Use "http://www.ut.ee/~diane/repository" as an address of remote repository

##

• Bob connects Diane's repository, fetches changes, merges them into local branch (same as previous in respect to Bob's name)

#6 Merging conflicts

Wiki: A conflict occurs when different parties make changes to the same document, and the system is unable to reconcile the changes. A user must resolve the conflict by combining the changes, or by selecting one change in favour of the other. Scenario: * Alice developed the code, she commits it, and pushes the changes to her published repository over ssh

alice@local:~/work$ git status

# On branch master

# Changed but not updated:

#   (use "git add <file>..." to update what will be committed)

#   (use "git checkout -- <file>..." to discard changes in working directory)

#

#       modified:   file001.txt

#

no changes added to commit (use "git add" and/or "git commit -a")



alice@local:~/work$ git commit -a -m "Modified one line"

[master b60c261] Modified one line

 1 files changed, 1 insertions(+), 1 deletions(-)



## Push changes to the published repository on "http://www.ut.ee/~alice/repository"

alice@local:~/work$ git push public-ssh master

alice@ats.cs.ut.ee's password:

Counting objects: 11, done.

Delta compression using up to 2 threads.

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

Writing objects: 100% (8/8), 638 bytes, done.

Total 8 (delta 0), reused 0 (delta 0)

To ssh://alice@ats.cs.ut.ee/home/murakas/a/alice/public_html/repository

   7c6deb8..b60c261  master -> master

* Bob developed the code, commited it, next he fetches Alice's changes, there are conflicts and manual merge required

## Check the changes

bob@local:~/workspace/alice_work$ git status

# On branch master

# Changed but not updated:

#   (use "git add <file>..." to update what will be committed)

#   (use "git checkout -- <file>..." to discard changes in working directory)

#

#       modified:   file001.txt

#

no changes added to commit (use "git add" and/or "git commit -a")



## Commit the changes (be aware: this is a local commit)

bob@local:~/workspace/alice_work$ git commit -a -m "Modified the code"

[master 837520f] Modified the code

 1 files changed, 1 insertions(+), 1 deletions(-)



bob@local:~/workspace/alice_work$ git status

# On branch master

nothing to commit (working directory clean)



bob@local:~/workspace/alice_work$ git log --graph

* commit 837520fef3cde51d65bb2c0551d3c661a60f09e0

| Author: Bob <bob@ut.ee>

| Date:   Mon Oct 4 17:15:33 2010 +0300

|

|     Modified the code

|

* commit b60c261bc59a09719100017e4bc6350922c14bf1

| Author: Alice <alice@ut.ee>

| Date:   Fri Oct 1 16:29:02 2010 +0300

|

|     Modified one line

|

* commit 96b36baf6924ee5aaebe6a0b77a5375f95a155f2

| Author: Bob <bob@ut.ee>

| Date:   Fri Oct 1 14:40:37 2010 +0300

|

|     Added some lines

|

* commit 7c6deb8397ab8e30b17034a8bf6cd18810fa7e0f

  Author: Alice <alice@ut.ee>

  Date:   Thu Sep 16 17:35:07 2010 +0300



      Added some text



## Fetch Alice's changes

bob@local:~/workspace/alice_work$ git fetch alice-http

From http://www.ut.ee/~alice/repository

   b60c261..cd2d75b  master     -> alice-http/master



## Merge chenages from 'alice-http/master' into current branch (master)

bob@local:~/workspace/alice_work$ git merge alice-http/master

Auto-merging file001.txt

CONFLICT (content): Merge conflict in file001.txt

Automatic merge failed; fix conflicts and then commit the result.



## Browse the conflicts

bob@local:~/workspace/alice_work$ cat file001.txt

Line 001 abcde

<<<<<<< HEAD

Line 002 12345

=======

Line 002 fghijk

>>>>>>> alice-public/master

Line 003



## Edit file001.txt, merge the changes on second line, remove conflict indicators

bob@local:~/workspace/alice_work$ cat file001.txt

Line 001 abcde

Line 002 12345 fghijk

Line 003



## Check the changes

bob@local:~/workspace/alice_work$ git status

# On branch master

# Unmerged paths:

#   (use "git add/rm <file>..." as appropriate to mark resolution)

#

#       both modified:      file001.txt

#

no changes added to commit (use "git add" and/or "git commit -a")



## Now mark 'file001.txt' as 'resolved'

bob@local:~/workspace/alice_work$ git add file001.txt

bob@local:~/workspace/alice_work$ git status

# On branch master

# Changes to be committed:

#

#       modified:   file001.txt

#



## Commit the changes (merged files)

bob@local:~/workspace/alice_work$ git commit -a -m "Merged file001.txt"

[master 4daa9a4] Merged file001.txt



## Check the log

bob@local:~/workspace/alice_work$ git --graph --oneline

*   4daa9a4 Merged file001.txt

|\

| * cd2d75b Modified Second line

* | 837520f Modified the code

|/

* b60c261 Modified one line

* 96b36ba Added some lines

* 7c6deb8 Added some text



## Now publish the merged code

bob@local:~/workspace/alice_work$ git push public-ssh master

Counting objects: 11, done.

Delta compression using up to 2 threads.

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

Writing objects: 100% (9/9), 927 bytes, done.

Total 9 (delta 0), reused 0 (delta 0)

To ssh://artjom85@ats.cs.ut.ee/home/murakas/b/bob/public_html/repository

   b60c261..4daa9a4  master -> master

• Now Bob merged his changes and Alice's changes, the merged code is in his published repository. Alice and Diane have to synchronize now before commiting their changes.

## Check log

alice@local:~/work$ git log --graph --oneline

* cd2d75b Modified Second line

* b60c261 Modified one line

* 96b36ba Added some lines

* 7c6deb8 Added some text



## Fetch Bob's changes

alice@local:~/work$ git fetch bob-http

From http://www.ut.ee/~bob/repository

   b60c261..4daa9a4  master     -> bob-http/master



## Merge Bob's changes into current branch (master)

alice@local:~/work$ git merge bob-http/master

Updating cd2d75b..4daa9a4

Fast-forward

 file001.txt |    2 +-

 1 files changed, 1 insertions(+), 1 deletions(-)



## Check log

alice@local:~/work$ git log --graph --oneline

*   4daa9a4 Merged file001.txt

|\

| * cd2d75b Modified Second line

* | 837520f Modified the code

|/

* b60c261 Modified one line

* 96b36ba Added some lines

* 7c6deb8 Added some text

• Now Alice's has the code (merged by Bob's) in her local repository, she is ready to develop.

• Assume Diane doing the same with respect to her name

This scenario explained how to merge simple conflicts (two persons edited the same line simultaneously)