GIT

We are using 'github' as our online code management. It is owned by Sergey Boyarinov and managed from the site 'github.com' with username boiarino17. There are repositories: coda, clon, epics, parms etc.

Obtaining clas12 Trigger project

git clone https://github.com/JeffersonLab/vtp.git

cd vtp

git checkout devel-hallb

Obtaining clas12 online software

git config --global http.proxy jprox.jlab.org:8081
cd <where it suppose to be>

git clone --recursive https://github.com/jeffersonlab/clas12-online clas12

Include into .cshrc following statements:

setenv CLAS <where it suppose to be>/clas12
source $CLAS/.setup

Compile CODA:

cd $CODA/src
make

Compile CODA for other platforms: for example ssh to arm processor and do 'make arm' (see inside Makefile)

Run mysql server and set coda database using files daq_daq.sql and daq_clasdev.sql (those files were produced by commands

mysqldump --databases daq_daq -h clondb1 -u clasrun > daq_daq.sql
mysqldump --databases daq_clasdev -h clondb1 -u clasrun > daq_clasdev.sql

Set MYSQL_HOST env variable to your mysql server (by default it is clondb1)

Expert info

To use it clon clon machines, proxy have to be set by following command:

git config --global http.proxy jprox.jlab.org:8081

To create local copy of online software, create directory, go there and copy .setup from existing release. Modify .setup commenting out .setup's form subdirectories you are not going to use. Get needed subdirectories from repository using following commands:

git clone https://github.com/JeffersonLab/clas12-coda coda
git clone https://github.com/JeffersonLab/clas12-clon clon
git clone https://github.com/JeffersonLab/clas12-parms parms
git clone https://github.com/JeffersonLab/clas12-epics epics

Command git pull can be used to get files from repository.

Use following to add all files locally; 'git status' shows changes, remove files which should not go to git, then execute last two commands:

git status
git add .
git commit -a -m "first commit"

Removing files/directories example:

git rm src/bosio/bosio.s/SCCS/*
git commit src/bosio/bosio.s/

BEFORE PROCEEDING: Make sure you are on 'master' branch. Run 'git branch' to see current branch. If it is not 'master' but <another_branch> and you did some commits already, all your commits were done to <another_branch>. If you did not do commits, do it now, everything will go to <another_branch>. After that, run commands 'git checkout master' and 'git merge <another_branch>'.

Use git commit command to check in locally, and git push to check into repository:

git push

NOTE: big size file 'src/dac/zzz' was pushed to git causing error; to fix it following was used:

git filter-branch --index-filter "git rm -rf --cached --ignore-unmatch src/dac/zzz" HEAD
rm -rf .git/refs/original/ 
git reflog expire --all 
git gc --aggressive --prune
git push origin master --force

Three middle commands are not necessary. Seen in one comment, that those 5 commands (or first one ?) can be dangerous !

Viewing Project History

At any point you can view the history of your changes using

git log

If you also want to see complete diffs at each step, use

git log -p

Often the overview of the change is useful to get a feel of each step

git log --stat --summary

Managing Branches

A single Git repository can maintain multiple branches of development. To create a new branch named "mycoda", use

git branch mycoda

If you now run

git branch

you'll get a list of all existing branches:

* master
  mycoda

The "mycoda" branch is the one you just created, and the "master" branch is a default branch that was created for you automatically. The asterisk marks the branch you are currently on; type

git checkout mycoda

to switch to the experimental branch. Now edit a file, commit the change, and switch back to the master branch:

(edit file)
git commit -a
git checkout master

Check that the change you made is no longer visible, since it was made on the experimental branch and you're back on the master branch.

You can make a different change on the master branch:

(edit file)
git commit -a

at this point the two branches have diverged, with different changes made in each. To merge the changes made in mycoda into master, run

git merge mycoda

If the changes don't conflict, you're done. If there are conflicts, markers will be left in the problematic files showing the conflict;

git diff

will show this. Once you've edited the files to resolve the conflicts,

git commit -a

will commit the result of the merge. Finally,

gitk

will show a nice graphical representation of the resulting history.

At this point you could delete the mycoda branch with

git branch -d mycoda

This command ensures that the changes in the mycodal branch are already in the current branch.

If you develop on a branch crazy-idea, then regret it, you can always delete the branch with

git branch -D crazy-idea

Branches are cheap and easy, so this is a good way to try something out.

Using Git For Collaboration

Suppose that Alice has started a new project with a Git repository in /home/alice/project, and that Bob, who has a home directory on the same machine, wants to contribute.

Bob begins with:

git clone /home/alice/project myrepo

This creates a new directory "myrepo" containing a clone of Alice's repository. The clone is on an equal footing with the original project, possessing its own copy of the original project's history.

Bob then makes some changes and commits them:

(edit files)
git commit -a
(repeat as necessary)

When he's ready, he tells Alice to pull changes from the repository at /home/bob/myrepo. She does this with:

cd /home/alice/project
git pull /home/bob/myrepo master

This merges the changes from Bob's "master" branch into Alice's current branch. If Alice has made her own changes in the meantime, then she may need to manually fix any conflicts.

The "pull" command thus performs two operations: it fetches changes from a remote branch, then merges them into the current branch.

Note that in general, Alice would want her local changes committed before initiating this "pull". If Bob's work conflicts with what Alice did since their histories forked, Alice will use her working tree and the index to resolve conflicts, and existing local changes will interfere with the conflict resolution process (Git will still perform the fetch but will refuse to merge --- Alice will have to get rid of her local changes in some way and pull again when this happens).

Alice can peek at what Bob did without merging first, using the "fetch" command; this allows Alice to inspect what Bob did, using a special symbol "FETCH_HEAD", in order to determine if he has anything worth pulling, like this:

git fetch /home/bob/myrepo master
git log -p HEAD..FETCH_HEAD

This operation is safe even if Alice has uncommitted local changes. The range notation "HEAD..FETCH_HEAD" means "show everything that is reachable from the FETCH_HEAD but exclude anything that is reachable from HEAD". Alice already knows everything that leads to her current state (HEAD), and reviews what Bob has in his state (FETCH_HEAD) that she has not seen with this command.

If Alice wants to visualize what Bob did since their histories forked she can issue the following command:

gitk HEAD..FETCH_HEAD

This uses the same two-dot range notation we saw earlier with git log.

Alice may want to view what both of them did since they forked. She can use three-dot form instead of the two-dot form:

gitk HEAD...FETCH_HEAD

This means "show everything that is reachable from either one, but exclude anything that is reachable from both of them".

Please note that these range notation can be used with both gitk and "git log".

After inspecting what Bob did, if there is nothing urgent, Alice may decide to continue working without pulling from Bob. If Bob's history does have something Alice would immediately need, Alice may choose to stash her work-in-progress first, do a "pull", and then finally unstash her work-in-progress on top of the resulting history.

When you are working in a small closely knit group, it is not unusual to interact with the same repository over and over again. By defining remote repository shorthand, you can make it easier:

git remote add bob /home/bob/myrepo

With this, Alice can perform the first part of the "pull" operation alone using the git fetch command without merging them with her own branch, using:

git fetch bob

Unlike the longhand form, when Alice fetches from Bob using a remote repository shorthand set up with git remote, what was fetched is stored in a remote-tracking branch, in this case bob/master. So after this:

git log -p master..bob/master

shows a list of all the changes that Bob made since he branched from Alice's master branch.

After examining those changes, Alice could merge the changes into her master branch:

git merge bob/master

This merge can also be done by pulling from her own remote-tracking branch, like this:

git pull . remotes/bob/master

Note that git pull always merges into the current branch, regardless of what else is given on the command line.

Later, Bob can update his repo with Alice's latest changes using

git pull

Note that he doesn't need to give the path to Alice's repository; when Bob cloned Alice's repository, Git stored the location of her repository in the repository configuration, and that location is used for pulls:

git config --get remote.origin.url
/home/alice/project

(The complete configuration created by git clone is visible using git config -l, and the git-config(1) man page explains the meaning of each option.)

Git also keeps a pristine copy of Alice's master branch under the name "origin/master":

git branch -r
origin/master

If Bob later decides to work from a different host, he can still perform clones and pulls using the ssh protocol:

git clone alice.org:/home/alice/project myrepo

Alternatively, Git has a native protocol, or can use rsync or http; see git-pull(1) for details.

Git can also be used in a CVS-like mode, with a central repository that various users push changes to; see git-push(1) and gitcvs-migration(7).

Useful Commands

If some files were deleted, to delete them from master do following (NEED CHECK !!!):

git diff --diff-filter=D --name-only -z | xargs -0 git rm