Larry the Cable Guy

RStudio, Git and GitHub

Git and GitHub
Maybe when the SVN guys add shelving, the reasons people use git will go away, but I doubt that. The git merge command tries to integrate it into your local repository. Pretty git branch graphs Ask Question. Editors which do this are for example gedit under Ubuntu or Notepad under Windows. Several projects are running happily without my intervention, I only participate in them for my real work, statistical consulting. Analyzing the commit history with git log

Navigation menu

The most useful git commands

Be careful with this command. All untracked files are removed if you run this command. You will not be able to restore them, as they are not part of your Git repository.

If you have a tracked file in Git, you can always recreate the file content based on the staging area or based on a previous commit. You can also remove staged changes from the staging area to avoid that these changes are included in the next commit.

This chapter explain you how you can do this. Staging area, remove staged changes You can use the git reset [paths] command to remove staged changes from the staging area. This means that git reset [paths] is the opposite of git add [paths]. It avoids that the changes are included in the next commit.

The changes are still available in the working tree, e. In the following example you create a new file and change an existing file. Both changes are staged. The git reset behaves differently depending on the options you provide.

To learn more about the git reset command see [gitreset]. Be careful with the following command. It allows you to override the changes in files in your working tree. You will not be able to restore these changes. Changes in the working tree which are not staged can be undone with git checkout command. This command resets the file in the working tree to the latest staged version. If there are no staged changes, the latest committed version is used for the restore operation.

For example, you can restore the content of a directory called data with the following command. If you want to undo a staged but uncommitted change, you use the git checkout [commit-pointer] [paths] command. This version of the command resets the working tree and the staged area. The additional commit pointer parameter instructs the git checkout command to reset the working tree and to also remove the staged changes.

When you have added the changes of a file to the staging area, you can also revert the changes in the staging area base on the last commit. Sometimes you want to change the commmit your branch pointer is pointing to. The git reset command allows you to manually set the current HEAD pointer and its associated branch to a specified commit. This is for example useful to undo a particular change or to build up a different commit history.

Via parameters you can decide what you happen to the changes in the working tree and changes which were included in the commits between the original commit and the commit now referred to by the HEAD pointer. As a reminder, the working tree contains the files and the staging area contains the changes which are marked to be included in the next commit. Depending on the specified parameters the git reset command performs the following:. If you specify the --soft parameter, the git reset command moves the HEAD pointer.

Changes in the working tree will be left unchanged and all changes which were commited included in commits which are reseted are staged. Any file change between the original commit and the one you reset to shows up as modifications or untracked files in your working tree.

Use this option to remove commits but keep all the work you have done. You can do additional changes, stage changes and commit again. This way you can build up a different commit history. This effectively removes the changes you have done between the original commit and the one you reset to. Via parameters you can define if the staging area and the working tree is updated.

These parameters are listed in the following table. The git reset command does not remove untracked files. See Remove untracked files with git clean command for this purpose. It updates the staging area or also the working tree depending on your specified option.

If you reset the branch pointer of a branch to a certain commit, the git log commands does not show the commits which exist after this branch pointer. You if you reset your branch pointer to A, the git log command does not include B anymore. Commits like B can still be found via the git reflog command. See Recovering lost commits. The reset command does not delete untracked files.

If you want to delete them also see Recovering lost commits. As the staging area is not changed with a soft reset, you keep it in the desired state for your new commit. This means that all the file changes from the commits which were reseted are still part of the staging area. The interactive rebase adds more flexibility to squashing commits and allows to use the existing commit messages. See Editing history with the interactive rebase for details.

The git show command allows to see and retrieve files from branches, commits and tags. It allows seeing the status of these files in the selected branch, commit or tag without checking them out into your working tree. By default, this command addresses a file from the root of the repository, not the current directory. If you want the current directory then you have to use the.

For example to address the pom. You can checkout a file from the commit. To find the commit which deleted the file you can use the git log or the git ref-list command as demonstrated by the following command. The git log command allows you to determine which commit deleted a file. You can use the -- option in git log to see the commit history for a file, even if you have deleted the file.

This command reverts the changes of a commit. You can check out arbitrary revisions of your file system via the git checkout command followed by the commit ID. This command will reset your complete working tree to the status described by this commit. If you checkout a commit, you are in the detached head mode and commits in this mode are harder to find after you checkout another branch. Before committing it is good practice to create a new branch.

If you checkout a commit or a tag, you are in the so-called detached HEAD mode. If you commit changes in this mode, you have no branch which points to this commit. After you checkout a branch you cannot see the commit you did in detached head mode in the git log command. There are multiple reflogs: Your local Git repository contains references to the state of the branches on the remote repositories to which it is connected.

These local references are called remote-tracking branches. To update remote-tracking branches without changing local branches you use the git fetch command. See Updating your remote-tracking branches with git fetch for more information.

It is safe to delete a remote branch in your local Git repository, this does not affect a remote repository. The next time you run the git fetch command, the remote branch is recreated. You can use the following command for that. Branches can track another branch. This is called to have an upstream branch and such branches can be referred to as tracking branches.

If you clone a Git repository, your local master branch is created as a tracking branch for the master branch of the origin repository short: You create new tracking branches by specifying the remote branch during the creation of a branch. The following example demonstrates that. Instead of using the git checkout command you can also use the git branch command.

The --no-track allows you to specify that you do not want to track a branch. You can explicitly add a tracking branch with the git branch -u command later. To see the tracking branches for a remote repository short: The git fetch command updates your remote-tracking branches, i.

The following command updates the remote-tracking branches from the repository called origin. The fetch command only updates the remote-tracking branches and none of the local branches.

It also does not change the working tree of the Git repository. Therefore, you can run the git fetch command at any point in time. After reviewing the changes in the remote tracking branchm you can merge the changes into your local branches or rebase your local branches onto the remote-tracking branch. See Applying a single commit with cherry-pick for information about cherry-pick.

See Merging for the merge operation and Rebasing branches. The git fetch command updates only the remote-tracking branches for one remote repository. In case you want to update the remote-tracking branches of all your remote repositories you can use the following command. The above commands show the changes introduced in HEAD compared to origin. If you want to see the changes in origin compared to HEAD, you can switch the arguments or use the -R parameter.

You can rebase your current local branch onto a remote-tracking branch. The following commands demonstrate that. More information on the rebase command can be found in Rebasing branches.

The git pull command performs a git fetch and git merge or git rebase based on your Git settings. The git fetch does not perform any operations on your local branches. You can always run the fetch command and review the incoming changes. Git allows you to combine the changes which were created on two different branches. One way to achieve this is merging , which is described in this chapter. You can merge based on branches, tags or commits. Other ways are using rebase or cherry-pick.

This part explains how to merge changes between two different branches under the assumption that no merging conflicts happen. Solving conflicts is covered in What is a conflict during a merge operation? If the commits which are merged are direct successors of the HEAD pointer of the current branch, Git performs a so-called fast forward merge. This fast forward merge only moves the HEAD pointer of the current branch to the tip of the branch which is being merged. This process is depicted in the following diagram.

The first picture assumes that master is checked out and that you want to merge the changes of the branch labeled "branch 1" into your "master" branch. Each commit points to its predecessor parent. The "branch 1" branch points to the same commit. If commits are merged which are not direct predecessors of the current branch, Git performs a so-called three-way-merge between the latest commits of the two branches, based on the most recent common predecessor of both.

As a result a so-called merge commit is created on the current branch. It combines the respective changes from the two branches being merged. This commit points to both of its predecessors. If multiple common predecessors exist, Git uses recursion to create a virtual common predecessor. For this Git creates a merged tree of the common ancestors and uses that as the reference for the 3-way merge.

This is called the recursive merge strategy and is the default merge strategy. If a fast-forward merge is not possible, Git uses a merge strategy. The default strategy called recursive merge strategy was described in Merge commit.

The Git command line tooling also supports the octopus merge strategy for merges of multiple references. With this operation it can merge multiple branches at once. The subtree option is useful when you want to merge in another project into a sub-directory of your current project. It is rarely used and you should prefer the usage of Git submodules.

See Git Submodules for more information. The ours strategy merges a branch without looking at the changes introduced in this branch. This keeps the history of the merged branch but ignores the changes introduced in this branch. You can use the ours merge strategy to document that you have integrated a branch and decided to ignore all changes from this branch.

The git merge command performs a merge. You can merge changes from one branch to the current active one via the following command. The -s parameter allows you to specify other merge strategies. This is demonstrated with the following command. For example, you can specify the ours strategy in which the result of the merge is always that of the current branch head, effectively ignoring all changes from all other branches.

Be careful if you use the ours merge strategy, it ignores everything from the branch which is merged. The usage of the octopus merge strategy is triggered if you specify more than one reference to merge. The recursive merge strategy default allows you to specify flags with the -X parameter. For example you can specify here the ours option.

This option forces conflicting changes to be auto-resolved by favoring the local version. Changes from the other branch that do not conflict with our local version are reflected to the merge result.

For a binary file, the entire contents are taken from the local version. The ours option for the recursive merge strategy should not be confused with the ours merge strategy. A similar option to ours is the theirs option. This option prefers the version from the branch which is merged.

Another useful option is the ignore-space-change parameter which ignores whitespace changes. For more information about the merge strategies and options see Git merge manpage. If you prefer to have merge commits even for situations in which Git could perform a fast-forward merge you can use the git merge --no-ff command.

The --no-ff parameter can make sense if you want to record in the history at which time you merged from a maintenance branch to the master branch.

When pulling from a remote repository, prefer doing a rebase to a merge. This will help to keep the history easier to read. A merge commit can be helpful to document that functionality was developed in parallel.

You can use Git to rebase one branch on another one. As described, the merge command combines the changes of two branches. If you rebase a branch called A onto another, the git command takes the changes introduced by the commits of branch A and applies them based on the HEAD of the other branch.

After this operation the changes in the other branch are also available in branch A. The process is displayed in the following picture. Running the rebase command creates a new commit with the changes of the branch on top of the master branch. Performing a rebase does not create a merge commit. The final result for the source code is the same as with merge but the commit history is cleaner; the history appears to be linear.

Rebase can be used to forward-port a feature branch in the local Git repository onto the changes of the master branch. This ensures that your feature is close to the tip of the upstream branch until it is finally published. If you rewrite more than one commit by rebasing, you may have to solve conflicts per commit. In this case the merge operations might be simpler to be performed because you only have to solve merge conflicts once.

Also, if your policy requires that all commits result in correct software you have to test all the rewritten commits since they are "rewritten" by the rebase algorithm. Hence, it might be more efficient to merge a long feature branch into upstream instead of rebasing it since you only have to review and test the merge commit.

You can use the rebase command to change your Git repository history commits. This is called interactive rebase, see? You should avoid using the Git rebase operation for changes which have been published in other Git repositories. The Git rebase operation creates new commit objects, this may confuse other developers using the existing commit objects. Assume that a user has a local feature branch and wants to push it to a branch on the remote repository. However, the branch has evolved and therefore pushing is not possible.

Now it is good practice to fetch the latest state of the branch from the remote repository. Afterwards you rebase the local feature branch onto the remote tracking branch. This avoids an unnecessary merge commit. This rebasing of a local feature branch is also useful to incorporate the latest changes from remote into the local development, even if the user does not want to push right away. Rebasing and amending commits is safe as long as you do not push any of the changes involved in the rebase.

For example, when you cloned a repository and worked in this local repository. Rebasing is a great way to keep the history clean before contributing back your modifications.

In case you want to rewrite history for changes you have shared with others you need to use the -f parameter in your git push command and subsequently your colleagues have to use fetch -f to fetch the rewritten commits. Git allows you to edit your commit history with a functionality called interactive rebase. For example, you can combine several commits into one commit, reorder or skip commits and edit the commit message.

This is useful as it allows the user to rewrite some commit history cleaning it up before pushing the changes to a remote repository. The setup for the rebase is called the rebase plan. Based on this plan, the actual interactive rebase can be executed. It is safe to use interactive rebase as long as the commits have not been pushed to another repository. As the interactive rebase creates new commit objects, other developers might be confused if you rebase already published changes.

We want to combine the last seven commits. You can do this interactively via the following command. This command opens your editor of choice and lets you configure the rebase operation by defining which commits to pick , squash or fixup. The following listing shows an example of the selection. We pick the last commit, squash 5 commits and fix the sixth commit. The listing uses the long format of the commands for example fixup instead of the short form f for better readability.

The git cherry-pick command allows you to select the patch which was introduced with an individual commit and apply this patch on another branch. The patch is captured as a new commit on the other branch. The new commit does not point back to its original commit so do not use cherry-pick blindly since you may end up with several copies of the same change. Most often cherry-pick is either used locally to emulate an interactive rebase or to port individual bug fixes done on a development branch into maintenance branches.

The following command selects the first commit based on the commit ID and applies its changes to the master branch. This creates a new commit on the master branch. The cherry-pick command can be used to change the order of commits. See Commit ranges with the double dot operator for more information about commit ranges. If things go wrong or you change your mind, you can always reset to the previous state using the following command.

Merge conflict A conflict during a merge operation occurs if two commits from different branches have modified the same content and Git cannot automatically determine how both changes should be combined when merging these branches. If a conflict occurs, Git marks the conflict in the file and the programmer has to resolve the conflict manually. After resolving it, he adds the file to the staging area and commits the change.

These steps are required to finish the merge operation. He decides that he wants to keep the original version or the new version of the file. For this, there is the --theirs and the --ours options on the git checkout command. The first option keeps the version of the file that you merged in, and the second option keeps the version before the merge operation was started. The following steps create a merge conflict. It assumes that repo1 and repo2 have the same origin repository defined.

As this push would not result in a non-fast-format merge, you receive an error message similar to the following listing. To solve this, you need to integrate the remote changes into your local repository. In the following listing the git fetch command gets the changes from the remote repository.

The git merge command tries to integrate it into your local repository. If you use the git pull command it performs the "fetch and merge" or the "fetch and rebase" command together in one step. Whether merge or rebase is used depends on your Git configuration for the branch. Git marks the conflicts in the affected files. In the example from? In this example you resolve the conflict which was created in? To solve the merge conflict you edit the file manually. The following listing shows a possible result.

Afterwards add the affected file to the staging area and commit the result. This creates the merge commit. You can also push the integrated changes now to the remote repository. Instead of using the -m option in the above example you can also use the git commit command without this option. In this case the command opens your default editor with the default commit message about the merged conflicts. It is good practice to use this message. Alternatively, you could use the git mergetool command.

Some operating systems may come with a suitable merge tool already installed or configured for Git. Rebase conflict During a rebase operation, several commits are applied onto a certain commit. If you rebase a branch onto another branch, this commit is the last common ancestor of the two branches. If a conflict occurs during a rebase operation, the rebase operation stops and the developer needs to resolve the conflict.

After he has solved the conflicts, the developer instructs Git to continue with the rebase operation. A conflict during a rebase operation is solved similarly to the way a conflict during a merge operation is solved. The developer edits the conflicts and adds the files to the Git index. Afterwards he continues the rebase operation with the following command. If a file is in conflict, you can instruct Git to take the version from the new commit of the version of commit onto which the new changes are applied.

This is sometimes easier than to solve all conflicts manually. For this you can use the git checkout with the --theirs or --ours flag.

During the conflict --ours points to the file in the commit onto which the new commit is placed, i. An alias in Git allows you to create a short form of one or several existing Git commands. For example, you can define an alias which is a short form of your own favorite commands or you can combine several commands with an alias. The following defines an alias to see the staged changes with the new git staged command. Or you can define an alias for a detailed git log command. The following command defines the git ll alias.

You can also run external commands. In this case you start the alias definition with a! For example, the following defines the git ac command which combines git add. You specify a range of commits and a script that the bisect command uses to identify whether a commit is good or bad. This script must return 0 if the condition is fulfilled and non-zero if the condition is not fulfilled.

Create a new Git repository, create the text1. Do a few more changes, remove the file and again do a few more changes.

We use a simple shell script which checks the existence of a file. Ensure that this file is executable. Afterwards use the git bisect command to find the bad commit. First you use the git bisect start command to define a commit known to be bad showing the problem and a commit known to be good not showing the problem.

The above commands serve as an example. The existence of a file can be easier verified with the git bisect command: The git filter-branch command allows you to rewrite the Git commit history.

This can be done for selected branches and you can apply custom filters on each revision. This creates different hashes for all modified commits.

This implies that you get new IDs for all commits based on any rewritten commit. The command allows you to filter for several values, e. For details please see the git-filter-branch manual page. Using the filter-branch command is dangerous as it changes the Git repository. It changes the commit IDs and reacting on such a change requires explicit action from the developer, e. For example, you can use git filter-branch if you want to remove a file which contains a password from the Git history.

Or you want to remove huge binary files from the history. To completely remove such files, you need to run the filter-branch command on all branches. The following command extracts a directory from a Git repository and retains all commits for this subfolder. A patch is a text file that contains changes to other text files in a standarized format. A patch created with the git format-patch command includes meta-information about the commit committer, date, commit message, etc and also contains the changes introduced in binary data in the commit.

This file can be sent to someone else and the receiver can use it to apply the changes to his local repository. The metadata is preserved. Alternatively you could create a diff file with the git diff command, but this diff file does not contain the metadata information.

The following example creates a branch, changes several files and creates a commit recording these changes. To apply this patch to your master branch in a different clone of the repository, switch to it and use the git apply command. Use the git am command to apply and commit the changes in a single step.

You specify the order in which the patches are applied by specifying them on the command line. You can specify the commit ID and the number of patches which should be created. For example, to create a patch for selected commits based on the HEAD pointer you can use the following commands.

Git provides commit hooks, e. For example, you can ensure that the commit message has a certain format or trigger an action after a push to the server. These programs are usually scripts and can be written in any language, e. You can also implement a hook, for example, in C and use the resulting executables.

Git calls the scripts based on a naming convention. Git provides hooks for the client and for the server side. On the server side you can use the pre-receive and post-receive script to check the input or to trigger actions after the commit. The usage of a server commit hook requires that you have access to the server. Hosting providers like GitHub or Bitbucket do not offer this access. If you create a new Git repository, Git creates example scripts in the.

The example scripts end with. To activate them make them executable and remove the. The hooks are documented under the following URL: Git hooks manual page.

Not all Git server implementations support server side commit hooks. For example Gerrit a Git server which also provides the ability to do code review does not support hooks in this form. Also Github and Bitbucket do not support server hooks at the time of this writing.

Every time a developer presses return on the keyboard an invisible character called a line ending is inserted. Unfortunately, different operating systems handle line endings differently. Linux and Mac use different line endings than Windows. This becomes a problem if developers use different operating system to commit changes to a Git repository. To avoid commits because of line ending differences in your Git repository you should configure all clients to write the same line ending to the Git repository.

Use the following setting for this. You can also configure the line ending handling per repository by adding a special. If this file is committed to the repository, it overrides the core. Not all graphical Git tools support the. See Eclipse Bug report. To convert Subversion projects to Git you can use a RubyGem called svn2git.

This tool relies on git svn internally and handles most of the trouble. Then navigate to your git directory and use the following commands:. The parameter --verbose adds detailed output to the commandline so you can see what is going on including potential errors. The second svn2git --rebase command aligns your new git repository with the svn import.

You are now ready to push to the web and get forked! If your svn layout deviates from the standard or other problems occur, seek svn2git --help for documentation on additional parameters. If the symlink points to a file, then Git stores the path information it is symlinking to, and the file type. This is similar to a symlink to a directory; Git does not store the contents under the symlinked directory.

This tutorial is part of a series about the Git version control system. See the other tutorials for more information. Hosting Git repositories at Bitbucket or on your own server. Typical workflows with Git. EGit - Teamprovider for Eclipse. This tutorial is part of a book available as paper print and electronic form for your Kindle. Blog post about Git 2. We offer both public and inhouse training. The vogella company offers expert consulting services, development support and coaching.

Our customers range from Fortune corporations to individual developers. Free use of the software examples is granted under the terms of the EPL License.

This tutorial explains the usage of the distributed version control system Git via the command line. The examples were done on Linux Ubuntu , but should also work on other operating systems like Microsoft Windows.

Introduction into version control systems 1. What is a version control system? Localized and centralized version control systems A localized version control system keeps local copies of the files.

Distributed version control systems In a distributed version control system each user has a complete local copy of a repository on his individual computer.

Introduction into Git 2. Git repositories A Git repository contains the history of a collection of files starting from a certain directory. A local non-bare Git repository is typically called local repository. Working tree A local repository provides at least one collection of files which originate from a certain version of the repository. These states are the following: Adding to a Git repository via staging and committing After modifying your working tree you need to perform the following two steps to persist these changes in your local repository: For committing the staged changes you use the git commit command.

Synchronizing with other Git repositories remote repositories Git allows the user to synchronize the local repository with other remote repositories. The concept of branches Git supports branching which means that you can work on different versions of your collection of files. Summary of the core Git terminology The following table provides a summary of important Git terminology discussed in this section.

The details of the commit objects 3. Commit object commit Conceptually a commit object short: Technical details of a commit object This commit object is addressable via a hash SHA-1 checksum. Predecessor commits, parents and commit references Each commit has zero or more direct predecessor commits. Git allows addressing commits via commit reference for this purpose. Commit ranges with the double dot operator You can also specify ranges of commits.

You can also list all commits which are in the "testing" but not in the "master" branch. Commit ranges with the triple dot operator The triple dot operator allows you to select all commits which are reachable either from commit c1 or commit c2 but not from both of them. This is useful to show all commits in two branches which have not yet been combined. The Git command line tools The core Git development team provides tooling for the command line via the the git command.

See all possible commands, use the git help --all command. Separating parameters and file arguments in Git commands The double hyphens -- in Git separates out any references or other options from a path usually file names.

Other graphical tools for Git You can also use graphical tools. Installation of the Git command line tooling 6. Ubuntu, Debian and derived systems On Ubuntu and similar systems you can install the Git command line tool via the following command: Fedora, Red Hat and derived systems On Fedora, Red Hat and similar systems you can install the Git command line tool via the following command: Other Linux systems To install Git on other Linux distributions please check the documentation of your distribution.

Windows A Windows version of Git can be found on the Git download page. Git configuration levels The git config command allows you to configure your Git settings. Git system-wide configuration You can provide a system wide configuration for your Git settings.

Git user configuration Git allows you to store user settings in the. Repository specific configuration You can also store repository specific settings in the. User credential configuration You have to configure at least your user and email address to be able to commit to a Git repository because this information is stored in each commit. Push configuration If your are using Git in a version below 2. Avoid merge commits for pulling By default, Git runs the git fetch followed by the git merge command if you use the git pull command.

Allow rebasing with uncommited changes If you want Git to automatically save your uncommited changes before a rebase you can activate autoStash. Color Highlighting The following commands enables color highlighting for Git in the console. Setting the default merge tool File conflicts might occur in Git during an operation which combines different versions of the same files. More settings All possible Git settings are described under the following link: Query Git settings To query your Git settings, execute the following command: If you want to query the global settings you can use the following command.

Configure files and directories to ignore 8. Ignoring files and directories with a. Stop tracking files based on the. Local per-repository ignore rules You can also create local per-repository rules by editing the. Tracking empty directories with Git Git ignores empty directories, i. Setting up Git via the command line After the installation of the Git tooling for the command line you need to configure Git. The minimum required information to use Git is the user name and the email which Git should use.

Performing a local Git workflow via the command line In this exercise, you learn how to create and work with a local Git repository. Create a directory The following commands create an empty directory which is used later in this exercise to contain the working tree and the Git repository.

Create a new Git repository You now create a new Git repository with a working tree. Create new content Use the following commands to create several new files. See the current status of your repository The git status command shows the status of the working tree, i. On branch master Initial commit Untracked files: Add changes to the staging area Before committing changes to a Git repository, you need to mark the changes that should be committed with the git add command.

On branch master Initial commit Changes to be committed: Change files that are staged In case you change one of the staged files before committing, you need to add the changes again to the staging area, to commit the new changes. Use the git status command again to see that all changes are staged. Commit staged changes to the repository After adding the files to the Git staging area, you can commit them to the Git repository with the git commit command.

Viewing the Git commit history The Git operations you performed have created a local Git repository in the. Mon Dec 1 Viewing the changes of a commit Use the git show command to see the changes of a commit.

Review the resulting directory structure Review the resulting directory structure. Remove files If you delete a file, you use the git add. Revert changes in files in the working tree Use the git checkout command to reset a tracked file a file that was once staged or committed to its latest staged or commit state.

On branch master nothing to commit, working directory clean. Correct the changes of the commit with git amend The git commit --amend command makes it possible to rework the changes of the last commit. Ignore files and directories with the. Git allows that you can synchronize your repository with more than one remote repository. You can specify properties for the remove, e. URL, branches to fetch or branches to push. A remote repository can also be hosted in the local file system.

Bare repositories A remote repository on a server typically does not require a working tree. By convention the name of a bare repository should end with the.

Convert a Git repository to a bare repository Converting a normal Git repository to a bare repository is not directly support by Git.

Cloning a repository The git clone command copies an existing Git repository. Alternatively you could clone the same repository via the http protocol. Adding remote repositories If you clone a repository, Git implicitly creates a remote named origin by default. Rename remote repositories To rename an existing remote repository use the git remote rename command.

The following listing configures the proxy via environment variables. Adding a remote repository You add as many remotes to your repository as desired. Synchronizing with remote repositories You can synchronize your local Git repository with remote repositories.

Show the existing remotes To see the existing definitions of the remote repositories, use the following command. To see the details of the remotes , e. Push changes to another repository The git push command allows you to send data to other repositories. Pull changes from a remote repository The git pull command allows you to get the latest changes from another repository for the current branch.

Working with a local remote repository This exercise is based on Exercise: Create a bare Git repository via the clone operation Execute the following commands to create a bare repository based on your existing Git repository. Clone your bare repository Clone your bare repository and checkout a working tree in a new directory via the following commands.

Using the push command Make some changes in one of your non-bare local repositories and push them to your bare repository via the following commands. Using the pull command To test the git pull in your example Git repositories, switch to other non-bare local repository. You can pull in the changes in your first example repository with the following commands. List available branches The git branch command lists all local branches. The -v option lists more information about the branches.

Create new branch You can create a new branch via the git branch [newname] command. Checkout branch To start working in a branch you have to checkout the branch. Rename a branch Renaming a branch can be done with the following command. Delete a branch To delete a branch which is not needed anymore, you can use the following command. Push changes of a branch to a remote repository You can push the changes in a branch to a remote repository by specifying the target branch.

If you do not specify the remote repository, the origin is used as default. Switching branches with untracked files Untracked files never added to the staging area are unrelated to any branch. Switching branches with uncommitted changes Similar to untracked files you can switch branches with unstaged or staged modifications which are not yet committed.

You can switch branches if the modifications do not conflict with the files from the branch. Differences between branches To see the difference between two branches you can use the following command. Using tags in Git. Lightweight and annotated tags Git supports two different types of tags, lightweight and annotated tags. Naming conventions for tags Tags are frequently used to tag the state of a release of the Git repository.

List tags You can list the available tags via the following command: Search by pattern for a tag You can use the -l parameter in the git tag command to search for a pattern in the tag. Creating annotated tags You can create a new annotated tag via the git tag -a command.

Creating signed tags You can use the option -s to create a signed tag. Checkout tags If you want to use the code associated with the tag, use: Push tags By default the git push command does not transfer tags to remote repositories. Delete tags You can delete tags with the -d parameter. Listing changed files The git status command shows the current status of your repository and possible actions which you can perform.

Using git status The following commands create some changes in your Git repository. Using git diff The git diff command allows you to compare changes between commits, the staging area and working tree, etc. The following example code demonstrate the usage of the git diff command. Analyzing the commit history with git log Using git log The git log command shows the history of the Git repository. Helpful parameters for git log The following gives an overview of useful parameters for the git log command.

This parameter uses 7 characters by default, but you can specify other numbers, e. View the change history of a file To see changes in a file you can use the -p option in the git log command. Configuring output format You can use the --pretty parameter to configure the output. The following command lists all commits with an author name containing the word "Vogel". See also git shortlog for release announcements. Viewing changes with git diff and git show See the differences introduced by a commit To see the changes introduced by a commit use the following command.

See the difference between two commits To see the differences introduced between two commits you use the git diff command specifying the commits.

See the files changed by a commit To see the files which have been changed in a commit use the git diff-tree command. Using the Git blame command Analyzing line changes with git blame. Commit history of a repository or certain files Gitk can be used to visualize the history of a repository of certain files. This command also allows you to see the commits done by a certain author or committer.

Stashing changes in Git The git stash command Git provides the git stash command which allows you to record the current state of the working directory and the staging area and to revert to the last committed revision. When to use git stash In general using the stash command should be the exception in using Git.

Using the git stash command The following commands will save a stash and reapply them after some changes. Create a branch from a stash You can also create a branch for your stash if you want to continue to work on the stashed changes in a branch. Remove untracked files with git clean Removing untracked files If you have untracked files in your working tree which you want to remove, you can use the git clean command. Using git clean The following commands demonstrate the usage of the git clean command.

Revert uncommitted changes in tracked files Use cases If you have a tracked file in Git, you can always recreate the file content based on the staging area or based on a previous commit. Remove staged changes from the staging area Staging area, remove staged changes You can use the git reset [paths] command to remove staged changes from the staging area. The output of git status command should look similar to the following.

On branch master Changes to be committed: On branch master Changes not staged for commit: Remove changes in the working tree. Remove changes in the working tree and the staging area If you want to undo a staged but uncommitted change, you use the git checkout [commit-pointer] [paths] command.

The following demonstrates the usage of this to restore a delete directory. Remove staging area based on last commit change When you have added the changes of a file to the staging area, you can also revert the changes in the staging area base on the last commit.

Using Git reset Moving the HEAD and branch pointer Sometimes you want to change the commmit your branch pointer is pointing to. Depending on the specified parameters the git reset command performs the following: Resetting changes with git reset Finding commits that are no longer visible on a branch If you reset the branch pointer of a branch to a certain commit, the git log commands does not show the commits which exist after this branch pointer.

Deleting changes in the working tree and staging area for tracked files The git reset --hard command makes the working tree exactly match HEAD. If you have tracked files with modifications, you lose these changes with the above command. Using git reset to squash commits git reset, squash commits As a soft reset does not remove your change to your files and index, you can use the git reset --soft command to squash several commits into one commit.

Retrieving files from the history But found another expected issue, CentOS 7. So you should include comments about both firewall blocking httpd, as well as SELinux blocking as noted below in other comments from other individuals. BEGIN not safe after errors—compilation aborted at gitweb. Failed connect to I am not able to clone new repository using http and am only able to clone testing.

Thank you for commenting. This post was written long back and currently I am not curating it. I would like to encourage to use Gitlab which is fantastic open source tool and my experience with Gitlab is awesome till now.

If you are still interested to work on this method which I have written, surely I will recheck the steps. Anyway it is basic technique and give immense understanding how git works in backend. However, in the web interface I cannot see any project.

Hope you can help. I am using Centos v. I re validated this practical just short while ago. It looks all good for me. Please do check all the steps once again. Hope , you will find missing step. Also recommend to read the post carefully. I found the issue. So I disabled it for now. I have to find a way to make it work without permanently disabling. This is really awesome spree of conversation on our comment section.

I appreciate for valuable feedback which helps many reader. If you are thinking to not to disable selinux, I will suggest you to workaround on selinux for Apache. Just now I completed the practical on CentOS 7. I found the same issue that repolist is not updated. I will workaround on it and share the update soon. Thank you for reporting. Other than that I have not found any such issue and all is working fine.

Shame on me, I forgot this step. Then reload the web interface , you will see the repo name listed there. Add the repo name in this file. Everything works with the testing. The only difference in my setup is that my SSH is on a different port, so my clone looks like: The error looks like this: Could not read from remote repository. I had the same issue when created new repositories. Thanks for this tutorial. We were able to setup an in-house git server with gitolite for a WordPress development.

With this guide and tweaks made in gitweb, we managed to have all things running. However, we are also doing developments in in WordPress running atop of nginx instead of Apache. Currently tweaking settings and configs. I recognized your comment as one of the best detailed feedback. I also appreciate that you tweaked and played around the setup. Appreciate the response and looking forward to the guide you will be posting. I am still exploring my way with nginx though and solving errors one after another that were listed in the error logs.

Appreciate, if you would like to share your guide with us, it will reach to many people through our blog. After went this tutorial, I came up with few questions which will be clarified hopefully. Every team data should be confidential.

Am new to Git server.. Please give a document or how to setup a git server.. I followed your steps but was stuck in the beginning. I have to again setup a new Git Server. It has been a long time when I setup Git Server and wrote this post.

I will surely come back to answer your question after practically rechecking everything. So problem here is you can manage gitolite-admin and push up new config and keys but how does that update AuthUserFile to match? In this same post read the section, How to Manage user and group of Git Server. Not sure what I missed while following the steps, however I get authentication errors when trying to clone test project. The requested URL returned error: Use this syntax first: I was testing with 2 centos 6.

I may retest with centos as I may have missed a step or overlooked something. Thank you for putting this together, many thanks. Thanks Getz Ricks, The tutorial is already tested in live server many times. Yet,I appreciate kindly notify me if you find any issue so that I could update this tutorial or write new one. You are the man. Fantastic tutorial of an expert who knows the background.

The only tutorial that really works. Thank you very much. I followed these steps along on a Fedora 19 x64 server and a Red Hat 6. Ask for whatever details you want and I will share them to try to get my problem fixed. This is, to say the least, driving me bananas!! As soon as I turned it off, I was good to go! And this was true on both servers. Thank you SO much for the great article!! Good to know you solved it. More important thing is,you also successfully done practical in fedora which will help New bie that the steps are same in Fedora also.

Scratching my head — any help greatly appreciated. This problem is generally coming from Gitweb. I also found the error comes when Gitweb releases the new version and some parameters get change. But After doing a few Gitweb settings changes the Project can be seen. I found only a few settings I have not done in gitweb and it works for me. I will write new post in this weekend. Whereas share the details which CentOS,Git and Gitweb version you have,it helps me to troubleshoot with specific specs.

Hi Sharad I have the same issue after following your guide. What gitweb settings did you change to make it work? Any assistance is greatly appreciated. I think I should re-practical it. Seems some changes has happened. I will update the new post soon. I am out of city right now. I was just thinking about your issue. This file must have projects name entry. It shows the name of projects which we wants to display.

Becoming a contributor