Advanced Operating Systems Control Versioning with GIT. Giuseppe Massari

Transcription

1 Control Versioning with GIT Giuseppe Massari

2 Outline 2/54 Why using version control tools? Why Git? First steps Getting help and configuration Basic concepts Local repository management Initialization Change management Branches Conflicts management Shared remote repository management Pushing and pulling changes Giuseppe Massari

3 Why using version control tools? 3/54 Single developer Do we need to keep track of the history of changes in a software project? How to effectively keep track of / store such changes? Copying sources into new directories (e.g., MyProject_v _...)? What about disk occupancy? Multiple developers How to merge changes and additions coming from other developers? Manual copy and paste for each changed file? How to keep track of who's the author of a change? Mmm... maybe looking for mails with source code attached? Giuseppe Massari

4 Why Git? 4/54 Distributed approach The entire project history database is local Faster browsing among the changes No traffic generated on the network Changes can be committed locally before sharing Higher reliability: Central server DOWN is not an issue! Integrity mechanisms Every change is tracked SHA 1 checksum 40 character string composed of hexadecimal characters calculated based on the contents of a file or directory structure in Git. Giuseppe Massari

5 First steps 5/54 Help The command line usage of Git is based on commands To get help about a specific command syntax $ git git help help [command] If no command is given an overview of the most common Git commands is returned usage: usage: git git [--version] [--version] [--help] [--help] [-C [-C <path>] <path>] [-c [-c name=value] name=value] [--exec-path[=<path>]] [--exec-path[=<path>]] [--html-path] [--html-path] [--man-path] [--man-path] [--info-path] [--info-path] [-p --paginate --no-pager] [-p --paginate --no-pager] [--no-replace-objects] [--no-replace-objects] [--bare] [--bare] [--git-dir=<path>] [--git-dir=<path>] [--work-tree=<path>] [--work-tree=<path>] [--namespace=<name>] [--namespace=<name>] <command> <command> [<args>] [<args>] The The most most commonly commonly used used git git commands commands are: are: add add Add Add file file contents contents to to the the index index bisect bisect Find Find by by binary binary search search the the change change that that introduced introduced a a bug bug branch branch List, List, create, create, or or delete delete branches branches checkout checkout Checkout Checkout a a branch branch or or paths paths to to the the working working tree tree clone clone Clone Clone a a repository repository into into a a new new directory directory commit commit Record Record changes changes to to the the repository repository......

6 First steps 6/54 Configuration Setup user name, mail and preferences... $ git git config <level> <option> value Configuration levels reference three possible configuration files --system /etc/gitconfig System wide scope --global ~/.gitconfig ~/.config/git.git/config First configuration steps User scope Local project scope $ git git config --global user.name "Giuseppe Massari" $ git git config --global user. giuseppe.massari@polimi.it

7 First steps 7/54 Basic concepts Repository Concretely, (sub)directory where in Git stores metadata and object database for the project (.git) Repository (.git directory) Working directory A checkout of one version of the project The tracked files pulled out of the compressed database in the.git directory Working directory Staging area The set of selected changes, ready to be committed In practice, a file ( INDEX ) contained in.git directory, storing information about the changes to track in the forthcoming next commit Staging Area Giuseppe Massari

8 First steps 8/54 Basic workflow Working directory Staging Area Repository (.git directory) Checkout a project branch Stage changes Commit changes

9 Local repository management 9/54 Your first Git repository Enter the new project directory Initialize the Git repository $ $ cd cd ~/Development/MyProject ~/Development/MyProject $ $ git git init init Initialized Initialized empty empty Git Git repository repository in in ~/Development/MyProject/.git/ ~/Development/MyProject/.git/ This will create the.git directory. From now on, you can track changes in our project committing them in the Git repository ~/Development/MyProject/ ~/Development/MyProject/.git.git branches branches config config description description HEAD HEAD hooks hooks info info objects objects refs refs All the magics behind Git is here

10 Local repository management 10/54 Your first Git repository Create some files and do you first commit $ $ touch touch main.cpp main.cpp $ $ git git add add main.cpp main.cpp $ $ git git commit commit -s -s Now we have the very first step of our project history $ $ git git log log commit commit 8c837e5e223ee55bb9c9d1818fca67b8a365e94a 8c837e5e223ee55bb9c9d1818fca67b8a365e94a Author: Author: Giuseppe Giuseppe Massari Massari <joe.massanga@gmail.com> <joe.massanga@gmail.com> Date: Date: Fri Fri Oct Oct :59:53 13:59: Initial Initial commit commit Signed-off-by: Signed-off-by: Giuseppe Giuseppe Massari Massari <joe.massanga@gmail.com> <joe.massanga@gmail.com>

11 Local repository management 11/54 Diff As we continue introducing changes we can list them for each file If no files are specified all the changes for each file are shown $ $ git git diff diff [file-name] [file-name] diff diff --git --git a/main.cpp a/main.cpp b/main.cpp b/main.cpp index index e69de29..d9d9396 e69de29..d9d a/main.cpp a/main.cpp ,0-0,0 +#include +#include <iostream> <iostream> + + +int +int main(int main(int argc, argc, const const char char *argv[]) *argv[]) +{ +{ + + std::cout std::cout << << "Hello, "Hello, GIT GIT World!" World!" << << std::endl; std::endl; return return 0; 0; +} +} + +

12 Local repository management 12/54 Status After performing some changes we may want to have an overview of the project status The command status recaps the status of the working directory and the staging area $ $ git git status status On On branch branch master master Changes Changes to to be be committed: committed: (use (use "git "git reset reset HEAD HEAD <file>..." <file>..." to to unstage) unstage) new new file: file: main.h main.h Staging area Changes Changes not not staged staged for for commit: commit: (use (use "git "git add add <file>..." <file>..." to to update update what what will will be be committed) committed) (use (use "git "git checkout checkout <file>..." <file>..." to to discard discard changes changes in in working working directory) directory) modified: modified: main.cpp main.cpp Untracked Untracked files: files: (use (use "git "git add add <file>..." <file>..." to to include include in in what what will will be be committed) committed) README README

13 Local repository management 13/54 Commit What it is? A tracked change in the project: new files or changes in already existing files When to do it? Whenever we consider the changes introduced as a stable part of the project development What TO commit? Whatever can be considered a source file What TO DO NOT commit? Whatever is generated from source files How to commit? Add files or changes in files to staging area and then commit $ git git add add <files> <files> $ git git commit commit......

14 Local repository management 14/54 How to write a good commit? A tag/label to easily identify the project module touched A brief title to summarize the changes introduced [Model] [Model] Power-thermal models models support support The The purpose purpose of of this this support support is is to to providing providing a well-defined interface interface to to power/thermal resource resource allocation allocation policy, policy, hiding hiding platform platform specific specific details. details. A ModelManager allows allows the the registration registration of of platform-specific models, models, according according to to the the target target platform platform selected. selected. Such Such models models are are implemented as as derived derived classes classes of of the the base base class class Model. Model. Signed-off-by: Giuseppe Giuseppe Massari Massari <giuseppe.massari@polimi.it> Author's signature (git commit -s) An exhaustive explanation of what has been done and why

15 Local repository management 15/54 How to write a good commit? Include only consistent changes! A single source file can include changes having different goals Bug fixing Code refactoring New functionality implemented Use git gui to be more productive! $ git git gui gui Select lines (also from different files) changed for the same single specific purpose Right click on changed lines Select Stage lines for commit Giuseppe Massari

16 Local repository management 16/54 Log To recap the history of the project development $ git git log log commit commit 7bb21c be82d391ad9d03d5d bb21c be82d391ad9d03d5d Author: Author: Giuseppe Giuseppe Massari Massari <joe.massanga@gmail.com> <joe.massanga@gmail.com> Date: Date: Mon Mon Oct Oct :06:25 18:06: [Main] [Main] Using Using a a People People object object Added Added an an instance instance of of People People object object (joe), (joe), walking walking and and greeting. greeting. Signed-off-by: Signed-off-by: Giuseppe Giuseppe Massari Massari <joe.massanga@gmail.com> <joe.massanga@gmail.com> commit commit db36e150b2839fd923b3ca71186b22fe db36e150b2839fd923b3ca71186b22fe6 Author: Author: Giuseppe Giuseppe Massari Massari <joe.massanga@gmail.com> <joe.massanga@gmail.com> Date: Date: Mon Mon Oct Oct :03:08 18:03: [People] [People] Class Class first first version version Including Including member member functions functions Walk() Walk() and and Greet(). Greet(). Signed-off-by: Signed-off-by: Giuseppe Giuseppe Massari Massari <joe.massanga@gmail.com> <joe.massanga@gmail.com>

17 Local repository management 17/54 Show To show commit details (description + changes) $ git git show show [SHA1_number] giuseppe@plutone:~/development/test/gittutorial$ git show 5552cef giuseppe@plutone:~/development/test/gittutorial$ git show 5552cef commit 5552cefd12be253fd10c50cd03b64525eb0217f5 commit 5552cefd12be253fd10c50cd03b64525eb0217f5 Author: Giuseppe Massari <joe.massanga@gmail.com> Author: Giuseppe Massari <joe.massanga@gmail.com> Date: Mon Oct 19 17:20: Date: Mon Oct 19 17:20: [Main] First implementation [Main] First implementation The main function now prints a message. The main function now prints a message. Signed-off-by: Giuseppe Massari <joe.massanga@gmail.com> Signed-off-by: Giuseppe Massari <joe.massanga@gmail.com> diff --git a/main.cpp b/main.cpp diff --git a/main.cpp b/main.cpp index e69de29..d9d index e69de29..d9d a/main.cpp --- a/main.cpp +++ b/main.cpp ,0 +#include <iostream> +#include <iostream> + + +int main(int argc, const char *argv[]) +int main(int argc, const char *argv[]) +{ +{ + std::cout << "Hello, GIT World!" << std::endl; + std::cout << "Hello, GIT World!" << std::endl; return 0; + return 0; +} +} + +

18 Local repository management 18/54 Graphical front ends $ gitk gitk --all --all

19 Local repository management 19/54 Basic work flow in commands Working directory Staging Area Repository (.git directory) Do changes... git diff git status git show git add... git init git commit... Repeat...

20 Local repository management 20/54 Undo commands How to unstage changes already added to the staging area? $ git git checkout checkout filename filename Working directory Staging Area git add file git checkout file Just a step back, without cleaning the changes in the sources Giuseppe Massari

21 Local repository management 21/54 Undo commands How to clean out unstaged changes? Clean out all the (unstaged/uncommited) changes in the tracked files $ git git reset reset --hard --hard How to correct a commit? $ git git commit commit --amend --amend Open the current commit and allows us to add/remove files/lines or modify the commit message It overwrites the commit, creating a new one (with a different SHA 1) Not recommended if the commit has been already pushed on the remote repository $ git git revert revert SHA-1_number Revert the changes of the specified commit Added lines become removed lines and viceversa... Giuseppe Massari

22 Local repository management 22/54 Branches In real projects, the development history is far from progressing on a straight line Split developers to work in parallel, each focusing on specific features Software versions targeting different versions following different paths The concept of branch is all about this By default the Git repository initialization creates the master branch Giuseppe Massari

23 Local repository management 23/54 Branches Creating (and switching to) a new branch $ git git checkout checkout -b -b dev dev master ee2e90... HEAD HEAD is basically a d45e26... Initial commit reference to the topmost commit on the current branch master

24 Local repository management 24/54 Branches Creating (and switching to) a new branch $ git git checkout checkout -b -b dev dev Command checkout action is different in case the argument is a branch, instead of a file name master ee2e90... d45e26... dev The new dev branch points to the same topmost master commit Initial commit master dev Giuseppe Massari

25 Local repository management 25/54 Branches Committing on top of a new branch $ git git commit commit c82dda... dev master ee2e90... d45e26... The dev branch starts growing Initial commit master dev Giuseppe Massari

26 Local repository management 26/54 Branches Committing on top of a new branch $ git git commit commit a157dc... dev c82dda... master ee2e90... d45e26... Initial commit The project history is slowly starting to show a tree shape master dev Giuseppe Massari

27 Local repository management 27/54 Branches Switching back to master branch $ git git checkout checkout master master a157dc... dev c82dda... master ee2e90... d45e26... Initial commit Once back to master the changes introduced in the last dev commits apparently disappear master dev Giuseppe Massari

28 Local repository management 28/54 Branches Merging master and dev branches $ git git merge merge dev dev master a157dc... dev c82dda... ee2e90... d45e26... Initial commit Now, if we switch between master and dev we would not see changes in the project master dev Giuseppe Massari

29 Local repository management 29/54 Branches Labels on commits $ git git tag tag -a -a v0.1 v0.1 a157dc a157dc master a157dc... dev v0.1 c82dda... ee2e90... d45e26... Initial commit The tag can be thought as a label to mark our releases and improve the git tree readability master dev Giuseppe Massari

30 Local repository management 30/54 Conflicts In some cases, merging branches may lead to conflicts $ git git merge merge dev dev CONFLICT CONFLICT (content): (content): Merge Merge conflict conflict in in main.cpp main.cpp Automatic Automatic merge merge failed; failed; fix fix conflicts conflicts and and then then commit commit the the result. result. dev master 479b... ee2e90... d45e26... a157dc... c82dda... Master and dev branches include commits that touched the same lines of the same file Initial commit master dev

31 Local repository management 31/54 Conflicts The status command reports the conflict in this way $ git git status status dev dev On On branch branch master master You You have have unmerged unmerged paths. paths. (fix (fix conflicts conflicts and and run run "git "git commit") commit") Unmerged Unmerged paths: paths: (use (use "git "git add add <file>..." <file>..." to to mark mark resolution) resolution) both both modified: modified: main.cpp main.cpp To solve the conflict the conflict we need to open the files involved and check the content Git automatically add special lines into the file to identify the conflict and help us

32 Local repository management 32/54 Conflicts main.cpp is the file containing the conflict 7 7 <<<<<<< <<<<<<< HEAD HEAD 8 std::cout std::cout << << "Hello, "Hello, walking walking man!" man!" << << std::endl; std::endl; 9 ======= ======= >>>>>>> >>>>>>> dev dev Lines 7 9: HEAD status, changes in commit on top of current branch (master) Lines 9 10: changes coming from the merging branch (dev) Resolution Make a choice about the lines to keep or deleted, remove Delete special lines <<<<...===...>>> Add the files to the staging area (INDEX) Commit

33 Local repository management 33/54 Rebasing Move a branch on top of another May lead to conflicts Do it as long as your are moving a local branch $ $ git git rebase rebase master master dev dev dev a157dc... a157dc... dev c82dda... master ee2e90... c82dda... master ee2e90... d45e26... d45e Giuseppe Massari

34 Local repository management 34/54 Stashing Temporarily hide current (uncommited) changes on a stack Useful in case of switching on a branch already including changes on files we currently working on... $ $ git git stash stash save save Changes Changes about about feature1 feature1 implementation implementation I can stack multiple stashed changes $ $ git git stash stash list list To discard stashed changes: $ $ git git stash stash drop drop stash@{n} stash@{n} To resume the stashed changes: $ $ git git stash stash pop pop [stash@{n}] [stash@{n}] Giuseppe Massari

35 Local repository management 35/54 Basic work flow in commands Working directory Staging Area Repository (.git directory) git init Do changes... git diff git status git show git checkout <branch_name> git add... git commit...

36 Local repository management 36/54 Work flow example To manage the software release cycles, we can design a work flow, by splitting bug fixing, feature development and release candidate versions in dedicated branches Giuseppe Massari

37 Outline 37/54 Why using version control tools? Why Git? First steps Getting help and configuration Basic concepts Local repository management Initialization Change management Branches Conflicts management Shared remote repository management Pushing and pulling changes Giuseppe Massari

38 Remote repository management 38/54 Cooperative development Several developers working on the same project Project Joe Simon Fred Giuseppe Massari

39 Remote repository management 39/54 Remote repository work flow Working directory Staging Area Local repository Remote repository git clone... git checkout <branch_name> git add... git commit... git push... git fetch/pull...

40 Remote repository management 40/54 Basic commands To clone a project (remote repository) $ git git clone clone repository_path To download all the changes from the remote repository New commits, new branches, new tags... $ git git fetch fetch repository_name To download changes and merge it in the current local branch Fetch + merge $ git git pull pull repository_name [branch_name] To upload local changes to remote repository $ git git push push repository_name [branch_name] Giuseppe Massari

41 Remote repository management 41/54 Cooperative development Joe Simon Fred

42 Remote repository management 42/54 Cooperative development Joe starts a project tracking changes on a local repository Joe Simon Fred [Joe]$ [Joe]$ git git init init [Joe]$ [Joe]$ git git add add [Joe]$ [Joe]$ git git commit commit

43 Remote repository management 43/54 Cooperative development Joe adds a remote repository to the project Git server git@myserver.org:joe/myproj.git (origin) Joe Simon Fred [Joe]$ [Joe]$ git git remote remote add add origin origin git@myserver.org:joe/myproj.git

44 Remote repository management 44/54 Cooperative development Joe shares its work by uploading its current git tree to the remote repository Git server (origin) Joe Simon Fred [Joe]$ [Joe]$ git git push push -u -u --all --all origin origin Giuseppe Massari

45 Remote repository management 45/54 Cooperative development Simon and Fred clone the remote git repository, so that they can contribute to the project Git server (origin) Joe Simon Fred [Simon]$ [Simon]$ git git clone clone [Fred]$ [Fred]$ git git clone clone

46 Remote repository management 46/54 Cooperative development Simon fix bugs, committing changes on a new branch (hotfix) Git server git@myserver.org:joe/myproj.git (origin) HEAD HEAD HEAD Joe Simon Fred [Simon]$ [Simon]$ git git checkout checkout -b -b hotfix hotfix [Simon]$ [Simon]$ git git commit commit......

47 Remote repository management 47/54 Cooperative development Fred implements a new feature, committing changes on a new branch (feature1) Git server git@myserver.org:joe/myproj.git (origin) HEAD HEAD HEAD Joe Simon Fred [Fred]$ [Fred]$ git git checkout checkout -b -b feature1 feature1 [Fred]$ [Fred]$ git git commit commit......

48 Remote repository management 48/54 Cooperative development Fred and Simon upload their changes (branches) Git server (origin) HEAD HEAD HEAD Joe Simon Fred [Fred]$ [Fred]$ git git push push origin origin feature1 feature1 [Simon]$ [Simon]$ git git push push origin origin hotfix hotfix

49 Remote repository management 49/54 Cooperative development Joe updates its local repository Git server (origin) HEAD HEAD HEAD Joe Simon Fred [Joe]$ [Joe]$ git git fetch fetch origin origin Giuseppe Massari

50 Remote repository management 50/54 Cooperative development Joe merge the contributions in the project main line (i.e., master) Git server (origin) HEAD HEAD HEAD Joe Simon Fred [Joe]$ [Joe]$ git git merge merge origin/feature1 [Joe]$ [Joe]$ git git merge merge origin/hotfix

51 Remote repository management 51/54 Cooperative development Joe uploads the (updated) master branch to the remote repository Git server (origin) HEAD HEAD HEAD Joe Simon Fred [Joe]$ [Joe]$ git git push push origin origin master master Giuseppe Massari

52 Remote repository management 52/54 Cooperative development Simon and Fred synchronize their local repository with the remote Git server (origin) HEAD HEAD HEAD Joe Simon Fred [Fred]$ [Fred]$ git git fetch fetch origin origin [Simon]$ [Simon]$ git git fetch fetch origin origin

53 Remote repository management 53/54 Cooperative development Simon and Fred get the updated master Git server (origin) HEAD HEAD HEAD Joe Simon Fred [Fred/Simon]$ git git checkout master master [Fred/Simon]$ git git pull pull origin origin master master

54 Questions? 54/54