Less-Common Tools for Linux

Paul — Tue, 20 Apr 2010 00:41:07 +0000

As found here: 10 Tools to Add Some Spice to Your UNIX Shell Scripts. This is no substitute for the great write-up and screenshots that the author put together. It’s a summary for myself.

The highlights (and how I really feel about them):

notify-send (I never knew — better than tweat deck)
tput (eh, maybe)
setleds (i don’t have lock-key LEDs on my keyboard)
zenity (has potential)
kdialog (better than zenity? looks like VB functionality — good?)
dialog (like kdialog, but uses (n)curses, not kde)
logger (good to know!)
setterm (practical jokes… and maybe useful for modal/portal stuff)
smbclient (does that still work? Couldn’t get past authentication prompt)
bash sockets (interesting… ICP? wasteful)

Git – Install and Configure

Paul — Wed, 04 Nov 2009 23:19:50 +0000

Git is a code revision system not much unlike subversion and CVS. One of the best features of git is that it is a distributed revision system, so you can check-in, check-out, commit, revert, etc without ever needing direct access to the central repository. You can work with your repository as if it were a centralized system if need be found.

Installation (from source)

Go to http://www.kernel.org/pub/software/scm/git/ and pick the latest version (1.6.5.2), then from the command line, issue:

# Make a temporary directory from which we'll work mkdir ~/gittmp cd ~/gittmp
# Get the source, compile and intsall wget http://www.kernel.org/pub/software/scm/git/git-1.6.5.2.tar.gz tar xzf git-1.6.5.2.tar.gz cd ~/gittmp/git-1.6.5.2 ./configure make sudo make install cd ~/gittmp
# Get and install the man pages wget http://www.kernel.org/pub/software/scm/git/git-manpages-1.6.5.2.tar.gz sudo tar xzf git-manpages-1.6.5.2.tar.gz -C /usr/local/share/man/ cd ~ rm -r ~/gittmp/

Testing

Now that we’ve got everything set up, go ahead and check that everything’s visible to your path. Note: You may need to log back in for the settings to be read.
$ which git /usr/local/bin/git $ git config --help --- man page retrieved ---

Configuration

Now we need to set some globals. These are used to identify you when pushing changes.
$ git config --global user.name "Scott Chacon" $ git config --global user.email "schacon@gmail.com"

In a distributed environment, your workflow might go something like: A writes some code and commits. B pulls code, makes updates, commits. A updates local copy with B’s committed changes, continues development. The flow goes: get updates from peer, make changes, commit. Here’s an example:
alice: $ cd ~/project alice: $ git init alice: $ git add lib src README CHANGELOG alice: $ git commit -m "Initialization" bob: $ git clone /home/alice/project myrepo bob: $ echo 'I made a change' >> CHANGELOG bob: $ git commit -a -m "Appended changelog info" alice: $ cd ~/project alice: $ git pull /home/bob/myrepo master alice: $ echo "Confirmed, changes were merged" >> CHANGELOG alice: $ git commit -a -m "Merged bob's changes with some new additions"

Another setup might be to have a public repository for centralized access. It’s not really a central repository, but it’s the place where you push all your changes to from any machine you work on. In this way, anyone can go to exactly one place to get changes you’ve made, and you can work from any machine with git, using your own public repository as a starting point.
$ git clone --bare ~/proj proj.git $ touch proj.git/git-daemon-export-ok $ scp -r /proj.git user@host.com:/path/to/proj.git
Want to have access to the repo via http? Try this:
$ mv proj.git /var/www/html/repos/proj.git $ cd /var/www/html/repos/proj.git $ git --bare update-server-info $ chmod a+x hooks/post-update
Now anyone can access your repository like so: $ git clone http://example.com/repos/proj.git

Prefer a private repository? It’s easier than the public setup.
You: $ git clone --bare /home/user/myrepo/.git /tmp/myrepo.git $ scp -r /tmp/myrepo.git myserver.com:/opt/git/myrepo.git
Peer: $ git clone myserver.com:/opt/git/myrepo.git

So how do these shared repositories work?

clone to initialize local git revision management
modify/commit/revert/etc locally (1 or more times)
push up to the shared repository

Peer: … makes changes to source …
Peer: $ git commit -a -m "I made a few changes"
Peer: … continue editing until ready for consumption …
Peer: $ git commit -a -m "I made a few more changes"
Peer: $ git push ssh://yourserver.com/~you/proj.git master[:master]
You: $ git clone myserver.com:/opt/git/myrepo.git
You: … editing/conflict management/etc. …
You: $ git commit -a -m "Pretty up peer's changes (minor edits)"
You: $ git push ssh://yourserver.com/~you/proj.git master[:master]

Using Git on Windows

If you plan on using Git on Windows (Sure, why not? masochists pssht) you could install Git Extensions (Windows) from http://git-scm.com/tools. At least, that’s what I did. It was confusing as all hell, until I went through all possible alternatives that appeared easier than understanding what a remote is. The key to getting it all to work is setting up ssh keys so that you can auto-logon to whatever server has your git repositories with the ssh protocol. If you’re using the git protocol, I don’t think that applies. I could be wrong on this.

Once you’ve installed Git Extensions, load it up, do some general configuration (user.name, user.email, etc.), then select from the menu bar Remotes->PuTTy->Generate or import key. This assumes that you’ll be using PuTTY for all your ssh needs (if applicable). Anyway, generate a key and save the public key somewhere handy, save the private key somewhere safe. Now, using that pubkey, follow the advice for Setting up SSH Keys. You’re going to want to add that pub key to your authorized_keys on the git repo server. After that, make sure the PuTTY authentication agent is running (Remotes->PuTTy->Start authentication agent). A new icon should appear in your system tray. Right click on the new icon to “Add Key.” This key will be your private key. The agent handles the hand-shaking.

After doing all this the hard way, maybe you should just use the git protocol, but then again, I haven’t tried it myself.

Resources

Finally, it’s probably best to read Git’s HOWTOs and Tutorials.

STDERR redirect into STDOUT redirect into file

Paul — Fri, 23 Oct 2009 02:00:08 +0000

When you want to redirect stderr to a file, you have choices. Either redirect only stderr to a file, or redirect both stderr and stdout to the same file.

The right way:

Redirect stderr and stdout to [[file]]:

[[command]] > [[file]] 2>&1

Redirect stderr to [[efile]] and stdout to [[file]]:

[[command]] 2> [[efile]] > [[file]]

The wrong way:

Doesn’t do anything useful:

[[command]] 2>&1 > [[file]]

Summing a list of numbers

Paul — Fri, 16 Oct 2009 02:00:40 +0000

awk '{sum += $0} END {print sum}'

Example:% find . -type f -exec wc {} \; | tr -s " " | cut -f2 -d" " | awk '{sum += $0} END {print sum}'

What’s going on? I want to recursively count the number of lines present in all files contained by the current directory. Why? Sub-directories => namespaces, and I want to know how many lines of code exist in the entire project, namespaces and all.

cat brain.log | less » command line