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 online software
git config --global http.proxy jprox.jlab.org:8081 cd /usr/clas12/release
##git clone --recursive https://github.com/jeffersonlab/clas12-online clas12
For example for version 1.4.0 do following:
git clone https://github.com/JeffersonLab/clas12-online.git 1.4.0 cd 1.4.0
Delete all files except .setup. Then type following:
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
Goto coda/src/ and type:
git clone https://github.com/JeffersonLab/vtp.git cd vtp git checkout devel-hallb
Goto $CLON_PARMS and open all files/directories for everybody by typing:
chmod 777 * chmod 777 */* chmod 777 */*/* .............
To use that release add following line in the very beginning of your .cshrc:
setenv CLAS /usr/clas12/release/1.4.0
Obtaining clas12 Trigger project
git clone https://github.com/JeffersonLab/vtp.git
cd vtp
git checkout devel-hallb
Obtaining Streaming VTP project
git clone https://github.com/JeffersonLab/jlab-vtp.git
- cd vtp
- git checkout devel-hallb
Obtaining clas12 online software - old
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"
Last command 'git commit' checks everything in locally.
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>'.
To check everything into repository:
- git pull
Make sure there are no conflicts, resolve if any.
- 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