Scene: In my (precious-little) spare time, I'm working on Project Euler. I haven't done any proper mathematics since I left Uni >10 years ago (when_where I completed a Major in Pure Mathematics), so it's all feeling more than a little rusty. I'm also teaching myself Python and again working on projects bigger than 10-line infrastructure scripts, so it's a good [re-]learning experience.
So, 10 Euler Problems in, I'm realising that certain patterns recur in the Problems, and it will make my life *a lot* easier if I use modules & descriptive functions names, and create reusable code. I am also realising that I strongly need source code control - I've only ever really used Subversion (which I did quite like, but never really used many advanced features), but why not throw another log on my bonfire of learning? So additionally learning Git it is.
Topics covered:
I plan to cover off:- Creating a new Git master/shared repo based on an existing unmanaged set of files [source code] from a client machine
- Create some cloned repos
- Basic file checkins.
- Branching in Git
- Multi-master push/pull stuff (which Git was truly built for)
- Updating your local client's repo from the main shared repo which someone else has updated (which I think is called "rebasing" in Git-land)
- Anything else not-completely-basic
- All steps below assume use of Linux/*nix - please adjust Windows/Other commands as you require
- Access from your client machines' user accounts to a shared host via ssh (ssh access from client->server)
Quick note: I'm using Git a bit like Subversion (ie single-master)
I know Git is fully decentralised source control, and I'm not using it in the best/most idiomatic way, but as an opening gambit I need to cocoon myself in the ideological constructs that I know already. So, we're going to construct a Git repo system setup in the way I used to use Subversion. The following steps will take a create a shared repo on a shared-access host that you can think of as a [master] subversion repo, and then use this repo as the central source of checkins and checkouts.Step 0: Configure Git on all hosts (Shared and Client)
Make sure git is installed on all systems (run as root):if [ `which yum` ] ; yum install -y git; fi
if [ `which apt-get` ] ; apt-get install -y git; fi
Configure your user account(s):
git config --global user.email "email@email.com"git config --global user.name "My Name"
(I'm sure I'm missing other useful user info here, but the above info is minimally required for later commits).
Bonus extra step: configure user-wide git file excludes (ie: tell git to permanently ignore certain files/types/directories when assessing the checkin status of a working directory). This helps to ignore temporary/overwritten/cache files.
# Create a global "ignore" file in your homedir. This is minimal file based on what has annoyed me so far - see references below for better ideas
cat ~/.gitignore_global > <<EOF
# Python Byte-compiled / Optimised / DLL files
__pycache__/
*.py[cod]
EOF
git config --global core.excludesfile ~/.gitignore_global
References:
Guide on creating Ignore files : https://help.github.com/articles/ignoring-files
A lot of pre-configured Ignore files: https://github.com/github/gitignore
Step 1: Create a "Master" Shared Repo
Create a Shared Repo on a shared server ("SharedHost01") that you have ssh access to. I have run this command on SharedHost01 itself - there may be other ways to do this.cd ~
mkdir projectName.git
cd projectName.git
git init --bare
Step 2: Create a Client Repo (from Existing Content)
This step can probably be done better - eg skip the copy step and clone straight from master over the top of existing - I have no idea of the semantics of overwrite behaviour, I was just being overly cautious because I didn't want to lose my existing code!This step is run on your client machine ("ClientHost01"), that has existing content you suddenly realise that you need to manage.
Assumption: existing project is in directory "~/projectName", so parent dir is ~.
# Create a backup of the original code in case we get this wrong
cd ~
mv projectName{,.orig}
mkdir projectName
cd projectName
# Now we pull down a blank project from Shared Host
git clone user@shareHost:projectName/
# Copy in the existing code
cp -rp ../projectName.orig/* .
# Add all content (aside from the globally-ignored files from Step 0...)
git add .
# Check it into you local on-machine repo
git commit -m "Initial ProjectName checkin, with existing codebase"
# Now push this "new" code back to the Shared Host
git push origin master
Step 3: Set Up a Second Client Repo
cd ~mkdir projectNamecd projectName
# Now we pull down a the initial code we just checked in
git clone user@shareHost:projectName/
And that's it for now - the baove has pretty much worked for me so far, so here's hoping I haven't got it horribly wrong. :)
Posts
