Jason Meridth

Git For Windows Developers – Git Series – Part 3

Jason Meridth — Mon, 08 Jun 2009 02:45:00 GMT

Git For Windows Developers - Git Series - Part 1

Git For Windows Developers - Git Series - Part 2

Git For Windows Developers - Git Series - Part 3

THE .GIT FOLDER

Note: The SHA1s and tags in this post are unique to my system. The examples with SHA1s will not work on your system if you try the commands verbatim. The commands that use tags will work if you name your tags the same.

When you run “git init” in a directory locally or “git clone…” to bring an existing git repository down locally, that folder would now have a subdirectory called .git. This folder is the “soul” of git. If I run “ls –al” on my /c/code/console_app/.git folder I see the following folder structure:

Notice the “(GIT_DIR!)” text to the right on my console prompt. Msysgit is helping me by reminding me what folder I’m in. Also notice that I have a bunch of files and five folders (hooks, info, logs, objects and refs). I’m going to explain each directory then each file.

hooks

Consists of files that you can populate with scripts that will execute during certain times in the Git event model. These files are simply samples of what event hooks are available (hence the file extension of .sample). I’ve created post-receive hooks for continuous integration (CI) events in the past. Here is a previous post I wrote on setting up a post-receive hook to work with a Hudson CI server that has a self-signed certificate and uses HTTP basic authentication.

info

Consists of an exclude file that is the same as the .gitignore file but is not including in the repository itself and therefore is not versioned.

logs

Consists of a file, HEAD, and a subdirectory, refs, which has the history of the interactions with branches, both local and remote. The local branches (.git/logs/refs/heads/…) show commands like “git commit”, “git rebase”, “git reset”, etc. The remote branches (.git/logs/refs/remotes/…) are usually “git fetch”, “git pull” or “git push”

When I run “cat HEAD” I see all the commits I’ve issued from both my local master and local user_prompt branch.

GIT REFLOG

This file seems to just be a list of commits that I’ve made on all the branches I’ve used (even on the user_prompt branch which does not exist any longer). A better way to view this is via the “git reflog” command:

This command “is a mechanism to record when the tip of branches are updated. This command is to manage the information recorded in it”. (git-reflog) Any action I perform inside Git, when data is committed to the local repository, it is logged here to the reflog, aka the .git/logs/HEAD file. I have heard of Git users being able to recover commits after they reset the HEAD back a few commits. I have not personally tried this.

objects

Consists of all your objects (duh!). What are the objects? That’s a little ambiguous. It looks like a bunch of two character alpha-numeric folders, plus info and pack folders. In Git, objects are blobs, trees, commits, and tags. What are the two characters? They are the first two characters of an objects SHA1. Then the files in those folders are named with the remaining 38 characters. (i.e., 9a438f1e971835a3ad724eb408a68fae45d7470a would translate to .git/objects/9a/438f1e971835a3ad724eb408a68fae45d7470a)

BLOB

A blob is generally a file.

(http://book.git-scm.com/assets/images/figure/object-blob.png)

Consists of the binary content that is stored in the blob. No filename. Really? Yep. Git does not track files, it tracks content. So if you have two files with the same content but different names (shame on you for violating “Don’t Repeat Yourself (DRY)”) they will most likely point at the same blob object. “The object is totally independent of its location in the directory tree…”. This is usually handled by tree objects. “…and renaming a file does not change the object that the file is associated with” (http://book.git-scm.com/1_the_git_object_model.html)

When I issue the “git show 0e0fdc6” command:

where 0e0fdc6 is the SHA1 of the solution file on my initial commit, I see the files contents. “git show” is a way to view information about Git objects (blobs, commits, trees, tags).

TREE

A tree usually represents a directory or sub-directory, containing a list of other trees and blobs.

(http://book.git-scm.com/assets/images/figure/object-tree.png)

Consists of the type, SHA1 and filename of blobs and sub-trees. When I run the “git ls-tree 97107ec“ command:

with 97107ec being the SHA1 of the tree that my initial commit points to (shown in commit section below). If I issue a “git show 97107ec” on this tree SHA1:

I see the names of the contents, but not the types or SHA1s.

COMMIT

A commit is a pointer to the SHA1 of a tree.

(http://book.git-scm.com/assets/images/figure/object-commit.png)

Consists of the SHA1 of the tree it’s pointing at, the SHA1 of the parent commit, if not the initial commit, and the names of the author and committer. Huh? There’s a difference between the author and the committer. Imagine you write a patch for an open source project. When you tell the owner of the project to pull from your repository, you are the author, but they would the person committing it to the primary repository, the committer. If I issue the “git show –s --pretty=raw 1731c38“ command, where 1731c38 is the SHA1 of my “initial commit” commit:

I see the tree SHA1 that the commit points to, the author and the committer, who happen to both be me. If I just issue a regular “git show 1731c83”:

I actually see the diffs for all changes in the commit. Since this was the initial commit SHA1, I see lots of plus signs (+) in the diffs.

TAG

A tag is a pointer to the SHA1 of a Git object.

(http://book.git-scm.com/assets/images/figure/object-tag.png)

Consists of an object SHA1, the type of object the SHA1 represents and the name of the person who issued the tag, the tagger. I issue the “git tag v0.1 –m ‘v0.1’” command:

This creates the tag object in the .git/objects/ folder. If I run the “git cat-file tag v0.1” command:

This shows me the three items that make up a tag, object SHA1, type, and tagger. If I issue a regular “git show v0.1” against the new tag:

I see the tag information and also the information for the git object it points to; a git commit in this case.

refs

Consists of the master copy of all remote tracking branches (.git/refs/remotes), local branches (.git/refs/heads), tags (.git/refs/tags), and the stash (.git/refs/stash), when used. Master copy? What does that mean? Well, when I issue “git checkout dev” and checkout the checkout the master copy of the local dev branch, I’m replacing my working directory with a copy of .git/refs/heads/dev. If I then issue “git checkout master” I’m replacing my working directory with .git/refs/heads/master, or a master copy of the local master branch.

The .git/refs/heads/master file, in my case, points to the latest commit for the local master branch. In this case it’s the 41509ff SHA1:

Since we are in sync with the remote origin/master branch, the .git/refs/remotes/origin/master file points to the same SHA1:

The .git/refs/tags/v0.1 file points to the 8690e95 SHA1:

which is a Git tag object (.git/objects/86/90e95…) that points to commit 41509ff as we saw above in the Git tag object section. So what this means is that currently all my git refs point to the same commit, 41509ff, more or less.

There is another type of git ref, stash, that I will talk about in a future post, but just know for now that the stash is located at .git/refs/stash/.

COMMIT_EDITMSG

Consists of the last commit message. From other readings, this seems to not even be used by git and is simply hear for reference.

FETCH_HEAD

Consists of the SHA1s of branch/remote heads that were updated during the last “git fetch”. The last fetch occurred automatically when I pulled changes from my local user_prompt branch into my local master branch.

HEAD

Consists of the current reference that you are set to (usually a branch). Normally master (aka .git/refs/heads/master). I’m currently set to my local master branch.

ORIG_HEAD

Consists of the SHA1 of the branch I did the last “git merge” into. In this case it’s the SHA1 of my local master branch before I pulled in the changes of my local user_prompt branch.

config

Consists of the settings for this repository. I personally rarely edit this file and use the “git config …” command with options. Read here for all the possible settings. I highly recommend the “git config color.*” commands to set color for your git commands and results.

description

Consists of a description that will usually be displayed if I were hosting this repository on gitweb or with git instaweb.

index

This is the “staging area” I’ve talked about in the past two posts. This is the area you prepare so that you can make one commit to your local repository. It consists of meta-data such as filenames, timestamps, and SHA1s. DO NOT EDIT THIS FILE MANUALLY.

SUMMARY

That is a rough introduction to the .git folder. I mainly only ever interact with the config file and the hooks folder.

The two biggest concepts to take from this are the objects and refs. Objects are blobs, commits, trees, and tags. Refs are branches, remotes, tags, and the stash queue. Once you completely understand that, interacting with Git will most likely become easier.

My next post will be on tortoisegit to satisfy the GUI users amongst you. The following post will be concurrent development and then a post on little gotchas and lessons learned.

Git For Windows Developers – Git Series – Part 2

Jason Meridth — Thu, 04 Jun 2009 05:49:00 GMT

Git For Windows Developers - Git Series - Part 1

Git For Windows Developers - Git Series - Part 2

Git For Windows Developers - Git Series - Part 3

NOTICE: I know that there are good tools out there besides Git Bash. I will do a post talking about each one (tortoisegit, Git extensions, etc) after I get all the Git commands and scenarios squared away.

Please make sure you’ve read the first post and have created your SSH private and public keys. You should also have a very basic understanding of the git init, add, commit, and log commands. We will dive deeper on each of those. We also visit git checkout, pull (—squash), push, remote, diff, log, mv. I’ve done my best at making each git command that is mentioned in text to be of bold weight. Each image, if a command is involved, has that command in big text before it.

This post is going to go over my typical workflow for work. I’ll get as detailed as I can for this process:

git pull origin master
git checkout –b user_prompt
<code>
git add <filename> (as necessary)
git commit –a –m “commit message”
repeat step 3-5 as many times as necessary
git checkout master
git pull –-squash . user_prompt
git commit –a –m “add name validation and tests”
git pull origin master
git push origin master

For this example, we’re going to create a remote public git repository on Github.com. What is Github.com? Github.com is the most popular Git repository hosting website on the Internets (misspelled on purpose) today, in my opinion.

First, I’m going to create my github.com account. I go to http://www.github.com and click the “Pricing and Setup” link:

Next, I click the “Signup” link next to the “Free!” account (Once you get comfortable, upgrading is easy):

Now I need to copy my public ssh key (id_rsa.pub) that I created from the first post into the Windows clipboard, so I can paste it to the web UI on this next step. That means opening Notepad (Windows, type notepad and choose it from the results [Vista/Windows 7] or Start->Programs->Accessories->Notepad [2000/XP]) and choose File->Open and go to my user folder and then the .ssh folder and choose the id_rsa.pub (C:\Users\jmeridth\.ssh\id_rsa.pub). I noticed that the default file extension that notepad searched for was text files (*.txt). I had to change the drop-down in the bottom right corner to “All Files (*.*)” and then I was able to see my files in the .ssh folder. We are using notepad because it won’t put any hidden newlines into the content we are trying to copy and paste to Github.com. We will talk about this later in the post.

I chose the id_rsa.pub file and it showed in notepad.

Press ctrl+A and then ctrl+c (or Edit->Select All and Edit->Copy). Go back to the Github signup page and input your information. I paste (ctrl+v) the id_rsa.pub key I saved into the Windows clipboard into the SSH Key box:

I click “I agree, sign me up!” and I am taken to my dashboard (at least I think so, I’m not actually clicking this since I already have an account). I create the remote public repository for this series on Github.com by clicking the “Create a new one” link on the right side near “Your Repositories”.

I fill in the name, description, and web page for the repository. I’m sticking with the console_app:

I click “Create Repository” and I’m taken to a very informational page:

(the user.name and user.email suggestions are different than the examples above due to me creating this repository under my real github.com account).

Above this information is the part I need for this post:

Really, just this part:

I open Git Bash and go to my repository that I created in the last post (/c/code/console_app):

FINALLY, GIT COMMANDS:

GIT BRANCH

SIDE NOTE: You can clear your Git Bash screen by pressing Ctrl+L on the keyboard. This works in most bash terminals.

Normally, I run “git branch” to see what branch I am on, but msysgit let’s me know via the end of my bash prompt “(master)”. I’m going to check anyway:

The branch name with the asterisk (*) next to it is the active branch. In this case I only have the one branch, master. I paid particular attention the the “Existing Git Repo?” section of the informational page on my Github.com console_app information page:

GIT REMOTE

I already di the cd command (cd /c/code/console_app). I then type the “git remote …”:

What the? Okay, the command is “git remote” with the “add”, “origin”, and “git@github.com:armmer/console_app.git” parameters. The “git remote” command with the “add” parameter tells your local git repository that you are adding the path/URL/location of a remote repository that you want to watch. In this case we’re going to label this remote repository “origin” and the location is “git@github.com:armmer/console_app.git”.

SIDE NOTE: git@github.com:armmer/console_app.git doesn’t look like a HTTP URL or a ssh:// protocol. What protocol is that? It is still SSH. The git protocol, usually using port 9418, is used for clone, fetch, or pull (i.e., git://github.com/armmer/console_app.git). Please reference Stefan's comment below for more details.

Now I have told my local repository to watch my newly created github.com remote public repository.

GIT LOG

I run “git log” again to see the changes we made in the first post:

GIT PUSH

Okay, I am going to push this code up to the Github.com repository. Look at the last step of the “Existing Git Repo?” information from Github.com. I type the “git push origin master” command:

(UPDATE: This screenshot is a newer one and has the incorrect object count. This is to show the prompt for the host authenticity)

UPDATE: During the push, you will most likely get prompted for host authenticity. Make sure you type ‘yes’, the full word. Not just ‘y’. This will add github.com’s public RSA key to your ~/.ssh/known_hosts file so that you won’t get prompted for this again on any future push. This let’s your system know that you trust github.com and let’s github.com know that you trust it. After you say yes the files are pushed up to the remote repository.

Success!! It counted the objects, compressed them and wrote them up to the remote repository. This command translates to “I am pushing my local master branch to the master branch of the remote repository I have labelled oririn”. Where does it mention the local master branch in that command? It doesn’t. It’s the convention. If no local branch is mentioned explicitly, the master branch is used.

SIDE NOTE: To push another local branch, I’d type “git push origin user_prompt:master” or “git push origin HEAD:master” if you just want to push the current local branch without having to remember it’s name.

Now we go back to the github.com repository main page and see the code and commit log:

My code is now remote and stored on Github.com. Sweet.

SIDE NOTE: If you get a “permission denied” or other errors, it is most likely ssh key related, hence, my emphasis on them. Check out this link for ideas/help.

GIT CHECKOUT

Now let’s imagine that we have a task that states “Prompt user for their name and say hello back to them, including their name”. I create a new branch locally so I have a separate place to do my active development for this task. I issue the command “git checkout -b user_prompt”.

A couple things to notice:

1. It says “Switched to a new branch ‘user_prompt’”. The “git checkout –b” command creates a new branch by the name following the command and then checks it out automatically. This is the shorthand version of doing “git branch user_prompt” and then “git checkout user_prompt”.

GIT BRANCH

2. It shows the “(user_prompt)” text at the end of my bash prompt now. That means that I’m on the user_prompt branch. To verify, I issue the “git branch” command. This lists all the local branches.

Again, the name with the asterisk (*) next to it is the active branch.

I make the code change:

(I have a “Console.ReadLine();” as the last line so the window doesn’t automatically close. I have to press a carriage return to close it. So I can read the output)

In all honesty, I wouldn’t test something like this, because I’d be testing the Framework. I test it manually and it works:

GIT STATUS

I commit my code to the repository. I run “git status” to see what the status is between the staging area and the working directory:

This tells me because I edited the Program.cs file it is “Changed by not updated”. What does that mean? It means it’s changed in my working directory, but not staged (not in my staging area or ready for commit). If I tried to commit right now, nothing would be committed because nothing is in my staging area.

GIT COMMIT

Example of running “git commit …” without adding files to the staging area:

GIT ADD

I add Program.cs to my staging area with the “git add Program.cs” command:

GIT STATUS

I run “git status” again:

The Program.cs file has been added to the staging area. How do you know that? Well, it is under the “Changes to be committed” section. That is synonymous with the staging area. Why don’t they just put that there: “Staging Area”? Good question. I don’t know.

SIDE NOTE: Notice every time I run “git status” the first thing I’m told is what branch I’m on. It’s nice to be reminded of that

GIT COMMIT

Now I commit it to the local repository with the “git commit –m ‘prompt user for name and say hello back’”:

Nice. Okay, we’re going to roll back, add the code again and commit in the “common” way. Huh? “Common way”? Most people do not do the “git add” and then “git commit –m …”. They, like myself, use the “git commit –a –m …”. The “-a” automatically adds all tracked changes from your working directory to the staging area. This does not include new files that aren’t tracked by the repository.

GIT RESET

I roll back one commit clearing my staging area and working directory with the “git reset --hard HEAD^” command:

What is the “HEAD^” portion of that command"? It means I want to reset the commits to one prior (^) to the HEAD (aka, the latest commit).

The result is “HEAD is now at 1731c83 initial commit”. That was the commit I did in the last post. This branch has been rolled back to that commit. The new commit I just did was destroyed from history. I will talk about undoing changes in greater detail in a future post. I run “git status” too and see that my working directory is clean.

SIDE NOTE: If you just want to clear your working directory and staging area, but not the latest commit, just issue a “git reset –-hard” command without the “HEAD^”

REFRESHER: What is the 1731c83? It is the first 7 digits of the SHA1 hash, talked about in the first post, that was assigned to my “initial commit”. Seven digits are all you need from the front of the commit to identify it uniquely.

GIT STATUS

I add the code change back and run “git status” again:

GIT COMMIT

Notice git even suggests the “git commit –a” notation? I run “git commit –a –m ‘prompt user for name and say hello back’”:

Same result as the “git add…” “git commit –m…”, just shorter syntax. Moving on.

Low and behold, the user then comes by and states, “Oh yeah, the name can’t have any numbers in it.” That' means I need to add more code. I could merge back to the master branch and push to my origin on Github.com and put this up as another task for the Story. For the sake of this post, I’m going to add the code here before the merge. Validation and specific business behavior makes me prepare for testing. I do my usual setup (lib folder with NUnit and break the main portion of the console app out to a class library and it’s test project). Uh oh, I realized I said “No” to the prompt to create a whole other folder for the projects. I have the solution file and the console_app project in the same folder.

So I move the project files and folders into their own folder and leave the console_app.sln file (and related files) in the current directory. I then change the project references inside the sln file, so that it can still reference the console_app project. Why don’t you just move the sln (and related files) up a directory? Unfortunately, the .git folder is at this level. If I move anything above this folder, it will be outside the local git repository. All folder and file moves need to be from this folder and down.

GIT MV

I make the moves with the “git mv” command:

(yes, to all of the current tortoisegit users, I believe if you select multiple files in windows explorer and move the files, it will do this for you)

So “git mv” takes a list of files, directories, or symlinks (for the *nix users) and will move them to the destination directory listed as the last option. This will do “git rename” to all the files and you won’t lose any history. (I chose “No” to the solution/project folder question at the beginning on purpose to show the “git mv” command here. Sure Jason, sure.)

GIT HELP

Site Note: I forgot the arguments for “git mv” and therefore typed “git help mv” into the Bash GUI:

Unlike on a *nix system, where you’ll just get the man page in the console, msysgit will open the web-based git help in your default browser:

I forgot, “git mv” even has a “—dry-run” option that will just show you if the move would succeed without errors. Did I mention how much I like git? :)

After the physical structure change, I manually test the console_app again and it still works:

GIT STATUS

I am going to commit these changes, so I have a stable place to come back to, just in case (Check-in early and often, right?). I first issue a “git status” to see what is in the staging area and what’s still in my working directory un-staged:

So, because we used “git mv” for the Program.cs, Properties folder, and the console_app.csproj file and they were already being tracked by the repository, they are in the staging area. We had to edit the console_app.sln file to point to the new console_app subfolder. The reason the renames are already in the staging area is because we did not edit their content, just moved them (a git, aka non-human, process).

GIT COMMIT

I commit the code with “git commit –a –m ‘restructure application to handle other projects, to allow for testing’”:

GIT LOG

We should now have three commits in our log, “git log”:

Now I add my two other projects (library and test) and the lib folder (containing NUnit):

GIT STATUS

I then run “git status”:

GIT ADD

Now I run “git add…” for each of the newly untracked items. If I committed right now, those items would not be put into the repository:

GIT COMMIT

I run “git commit –a –m ‘add library and tests projects to solution’”:

This is a decently sized commit due to the inclusion of lib/nunit.

SIDE NOTE: I love the ability to commit to my local repository knowing how I’m going to be able to merge to my local master branch as one commit and then push it up to the remote repository (coming soon). Via my lessons learned, as a software developer I sometimes have the tendency to go on a tangent and forget my training as a TDD Padawan. I make too many changes and break a lot more stuff than expected. Ctrl+Z (undo) works most of the time, but to just issue a “git reset --hard” and have my current branch reset back to the latest commit, clearing the working directory and staging area is priceless (as mentioned earlier).

I now write the tests and code for the name validation and run the tests:

Here are the tests:

and code:

GIT STATUS, GIT ADD, GIT COMMIT

I run “git status” to see the changes, and run “git add console_app.library/InvalidNameFormatException.cs”, and “git commit –a –m ‘add name validation with tests’”:

GIT STATUS

I run “git status” one more time verifying all the content is in my local repository.

Now comes the fun part of merging the changes back to the master branch so that we can push to the remote repository (is there an echo in here? hehe). There are at least three different ways to do this. I’m going to cover how I do it and will mention the others in future posts.

GIT CHECKOUT

I type “git checkout master” to switch back to the master branch:

GIT BRANCH

I issue the “git branch” command again to see that it switched. Again, you don’t have to do that because msysgit shows you the current branch you are in in the command prompt (promise, last time I’ll say it. Repetition works though. :) ).

GIT REMOTE

I type “git remote –v” to look at the remote repositories that I’m watching:

We are monitoring the “git@github.com:armmer/console_app.git” repository and have named it “origin”.

GIT PULL

I type “git pull –-squash . user_prompt”:

GIT STATUS

Whoa, that’s a lot of information. I type “git status” before I do the single (aka squashed) commit to the master branch:

… more new file references for nunit are below this. As you can see, everything that we committed in the user_prompt branch is staged in the master branch now (aka “Changes to be committed”).

GIT COMMIT

I type “git commit –a –m ‘add name validation with tests’”:

Everything is now committed on the master branch.

GIT STATUS

As usual, by now you know, I run “git status”:

GIT LOG

I type “git log” on master and I only see two commits:

That was the point of the squash. So you can do n number of commits in your “development” branch (in this case user_prompt) and turn it into one commit on master and then push only one commit to your remote repository. That is the power of a distributed source control. Local commits are priceless.

GIT PUSH

I finally type “git push origin master”:

This is the same as the original command we used to push our original commit to the Github.com repository. The command was explained above when we did it the first time.

And when I go to my github.com page I see the latest commit on the dashboard of the repository (same as the source tab):

When I click on the Commits tab, I see both commits, just like when I run “git log”:

GIT BRANCH

The last set of commands I issue are “git branch –D user_prompt”:

and “git branch” to make sure it is gone.

Phew! I know this is a _ton_ of images and information. There are other blogs and tutorials on git that show the commands and that it works, but I’ve been wanting to do a more visual blog entry and also give the side notes and insights I’ve learned.

The next post will be on the .git folder and it’s magic. Posts after that will consit of concurrent development scenarios, advanced Git commands, and GUI tools.

Thanks for reading.

Source Code for this post can be found here

Git For Windows Developers – Git Series - Part 1

Jason Meridth — Mon, 01 Jun 2009 06:04:00 GMT

Git For Windows Developers - Git Series - Part 1

Git For Windows Developers - Git Series - Part 2

Git For Windows Developers - Git Series - Part 3

This post is going to be the first of a few. I plan to convey everything I've learned the past 8 months while using git on a development team. I'm currently working on a Macbook Pro, doing Ruby on Rails development with git as the source control. These posts will be specific to using git on the Windows operating system.

This post is going to talk about installing msysgit, creating ssh keys, and creating a local git repository.

If you already have msysgit installed, have created your ssh keys, and have an existing application you just want to put in a git repository, go here

Installing msysgit On Windows

For windows, install msysgit (both ssh key generation capabilities and git come with this tool):

Download the latest version of msysgit:

Going through the setup. Click next past the first window.

Agree to the GPL terms:

Set the installation location (default was fine for me: C:\Program Files\Git):

The next screen asks what name the folder that the program will be available from when I click Start->Programs, etc:

Choose installation options. I don’t like to clutter my desktop, so that one is unchecked. The last two options give a user two new options on files when right-clicked in Windows Explorer. We’ll talk about this later in the post.

I use the “Git Bash only” option because it’s the only reason I downloaded msysgit. The other two options are tightly coupled to the operating system’s current setup.

UPDATE: Via Joshua Flanagan, I was informed that tortoisegit, a tool that will probably become the de facto way to use Git on Windows (we still need msysgit, but tortoisegit will be the UI tool of choice), suggests that you choose the second option "Run Git from the Windows Command Prompt". I've done both, I just prefer the first option because I don't use tortoisegit. Just be aware. I will mention tortoisegit and how to use it in a future post.

I use OpenSSH. It is the easier of the two to use, in my opinion.

I like to keep the line endings to the Windows style since that is what I’ll be operating on. Interaction with Gthub.com or other operating systems will cause line ending settings to be addressed. Those options will be mentioned in later posts.

Click next and the installation starts.

Uncheck the readme (who reads those anyway?) and click Finish.

Once installed, when I click the Windows button and type git (since I’m using Windows 7) I’ll see “Git Bash”, “Git Gui'”, “Uninstall Git”. Click “Git Bash”. Once I have the git bash open, I run “git –version” to make sure everything is working:

I also issue the following commands, “git config –global user.email my@email.com” and “git config –global user.name ‘Jason Meridth’”:

After I commit code in my new repository, later in the post, we will see why these are relevant.

Generating SSH Keys

I’ve met a good number of Windows developers who don’t know what SSH is. My quick definition of Secure Shell (aka SSH): A secure connection mechanism to other networked machines that support SSH, usually over port 22. It is pretty much the default form of remote communication for other platforms. More information if you're interested.

History and Retrospective:
I used to use cygwin + ssh keys for my git stuff on my windows VMs, but have realized, via advice from a friend, that cygwin will not be the easiest thing to teach to a typical Windows user. I am in no way assuming that any of our readers are "typical" windows users, but he's right. And msysgit needs to become the defacto Windows git tool anyway. What better way to help that project succeed than to give it more users.

I’ll generate the SSH Keys I will use to need to connect to remote repositories. I issue the following command “ssh-keygen –C ‘your@mail.com’ –t rsa” (using your own email address of course) and then press enter when prompted on file location and return two more times on both passphrase questions:

This will create two files in my /c/Users/jmeridth/.ssh folder. These files are my private and public keys (id_rsa and id_rsa.pub). The public key is the one we will be moving to remote git repository servers in later posts.

SIDE NOTE: back up these keys to a secure location. If they accidentally get corrupted, deleted, or changed you will be able to restore them at any time. I type “secure” because you need to make sure no one gets a hold of your private key. If either of those situations occur you can just recreate the keys, but every server that already has your public key will need the new public key (kind of a headache and time consuming). I’m speaking from experience on this.

This process will not apply to the remainder of this post, but will for following posts.

Putting My Code Under Source Control With Git

For example’s sake, say we have a folder under C:\code. In that folder we’ve created a folder called “console_app”. Inside this folder is a .NET 3.5 Console application that will send “hello world” to the output. Really? Again? Yep.

The easiest thing that works:

I built the application to ensure the bin and obj folders are created. I’ll explain why in a minute. In windows explorer I went to the C:\code\ folder. I right-click the console_app folder. Notice the two choices of “Git GUI Here” and “Git Bash Here”. When chosen they will open the corresponding msysgit tools at that desired location.

Each of these choices shows the two different ways of creating a local git repository or converting an existing folder into a git repository. I will show how to use Git Bash in this post and will use it mainly in this series. (If I get enough response to show Git GUI, I may do that)

Turning the Console Application Into A Git Repository With Git Bash

Choosing “Git Bash Here” when right-clicking the C:\code\console_app folder gave me the following:

Pretty much what I’ve already seen, but notice the path “/c/code/console_app”. For the individuals who aren’t used to a *nix type path structure, that is the same as C:\code\console_app.

Finally, Git Commands

In the prompt, type “git init”:

I just turned my folder into a git repository. Really that easy? Yep. Notice the folder mentioned in the response to the command. The .git folder. For the subversion users who are reading: Remember how you’d have a .svn folder under every directory of your repository? Not with git. You only have the one .git folder. If you delete that, you’re folder is no longer a git repository. Yes, it’s that easy.

Also, notice the “(master)” on the end of our prompt. That is a nice feature of msysgit. It is telling me what git branch I’m are currently in. We will talk more about that in a future post. I mention it in case anyone notices the new prompt.

Now issue a “git status”:

I will explain this output in a second. I need to create a .gitignore file first. Why? You notice that the bin and obj folders and the _ReSharper files are listed? I don’t want to include those items in our repository. Why? Those are items that another developer doesn’t need to successfully get the source and compile. They are specific to my local environment.

I tried to create a .gitignore file in Winodws Explorer and kept getting this error:

Windows doesn’t understand dot files (i.e., .bashrc, .gitignore, etc). Windows expects your files to have a name.extension convention.

<sarcasm>My love for Windows grows every time I use it</sarcasm>

Remember I said I was building the application for a specific reason (aka the bin and obj folders)? It was to highlight the necessity of the .gitignore file and how it can explicitly exclude files from your repository. I go into the Git Bash, at the C:\code\console_app folder. I type “ls –al” to list all the files, including dot files. Notice we have .git, but no .gitignore. I type “touch .gitignore”. This will create the .gitignore file with no content. Issuing “ls –al” again and you see the new file.

Now I edit the file in vim, my favorite editor, which came with msysgit. I could use any text editor (i.e., notepad, wordpad, notepad++, etc)

I add the following to it:

I save the file.

Now I issue a “git status” again and the bin and obj folders and ReSharper files are not shown. I do now have the .gitignore file listed, but that was expected.

Alright. Hopefully you are either saying, “yeah, I know, I have to add the files to my staging area, and then commit them to my local repository” or “what the heck is that?”. Maybe even something between like, “I know I have to add them to the repository….wait, what is a staging area?”.

Here is a picture that illustrates what the basic interactions with a local git repository consist of:

(http://learn.github.com/images/staging.png)

Ignore the “checkout the project” red arrow. Focus on the “stage files” and “commit” red arrows. Those are the actions you need to take to place/update files in your local repository. So, currently, all the files for my console_app application are in my working directory. I need to put them into the staging area before committing them to the local repository.

Common Questions:

Q: Aren’t we in a folder already? How does git know what’s in and what’s not in the local repository?
A: The .git folder (we will dive deep on that folder in a future blog post)

Q: What does the staging area give me?
A: A prepared set of files that you have ready to commit to the local repository.

So I issue the “git add .” command:

And I issue “git status” again:

Now the files are shown as “Changes to be committed”. Git even shows me how to remove files from the staging area; “git rm –cached <file>”.

I now issue the “git commit –m <message>” command:

The “-m" and subsequent text is the message that is assigned to the commit. I see the files get added.

I now issue the familiar “git status” command:

“nothing to commit (working directory clean)”. Cool. All of my files are now initialized in the git version control system. How do I see what has been committed to this repository? Good question. Just issue the “git log” command:

Remember those two git config calls we made earlier? This is where those are relevant. They populated the Author information for the commit. What are those numbers after the commit word? Those are the SHA1 (secure hash algorithm) hash assigned to this commit. SHA1 hashes are “unique”. Why do I have unique in quotes? Go read this.

I think that is enough for now and if you have any questions, please leave a comment. I will update this post upon necessity. In the next few posts I will be going over the common commands (clone, push, pull, fetch, merge, rebase, remote, branch, etc). I will also show you how to interact with Github.com, a remote git repository via ssh on a LInux box, and Gitosis, a mutli-user and multi-git repository management tool. I will also show how to setup gitweb, an easy to use web-based viewer of your repositories. I will be using the Linux operating system for all the remote servers. The local git commands should be applicable to all platforms once you have git installed correctly.

I actually have a good portion of the next post already written and will complete it soon.

LosTechies welcomes Ryan Svihla

Jason Meridth — Thu, 21 May 2009 17:07:20 GMT

We are happy to announce a new member, Ryan Svihla. Ryan is an active member of the San Antonio software development community. Ryan regularly attends and contributes to AlamoCoders, The San Antonio Tech Book Club, and SA Ruby. His prior blog writing are at http://ryansvihla.blogspot.com/. If you get a chance, go check it out.

Ryan is the primary developer on the following 2 OSS projects (among others):

Pinsor (IoC in Python)
SpecMaker (C# BDD Framework)

He currently works for a local San Antonio Bank and helped them get their production site to use the Castle stack. He is very passionate about his craft and we look forward to him helping us contribute to the software development community.

Welcome to the group Ryan.

TextMate and Community Server 2008.5

Jason Meridth — Thu, 21 May 2009 08:32:38 GMT

This is my first blog post from TextMate on my Mac. I'm using the HTML formatting. I will try the markdown and textile versions later. The key to getting this working with Community Server was when you click "Bundles->Blogging->Setup Blogs" and the following template shows up:

# List of Blogs
#
# Enter a blog name followed by the endpoint URL
#
# Blog Name URL

you put the following underneath the commented header

My Blog Name http://username@www.mydomain.com/blogs/<api_key>/metablog.ashx#<api_key>

The key part is #<api_key>. api_key in Community Server terms is the portion of your url after domain/blogs/ and before the page requested. Mine is jason_meridth. My full URL for TextMate blogging would be http://myusername_notsharing@www.lostechies.com/blogs/jason_meridth/metablog.ashx#jason_meridth.

Hope this may help a fellow Mac brethren

San Antonio community

Jason Meridth — Tue, 21 Apr 2009 14:53:00 GMT

This list is for any developers in the San Antonio, TX area. These are the communities that are growing/starting that I've been involved (member/leader). If anyone knows of others please leave a comment and I'll update the post. (Man we love our Tuesdays in San Antonio, every Tuesday is a group meeting)

Alamo Coders (organizer Phil Dennis)

http://www.alamocoders.net

Welcome to Alamo Coders. We are a FREE San Antonio area IT professionals Users Group that focus on the tools, technologies, and programming languages that help a software developer/architect/manager in today's industry. If would like to learn more about software development or the tools that are involved in that process, or if you just want to learn more about what Alamo Coders has to offer the San Antonio area IT community, then please join our group.

To get AlamoCoders Apparel, please go to our CafePress store.

MEETINGS: 2nd TUESDAY OF EVERY MONTH (@ New Horizons)

San Antonio Tech Book Club (organizer Anne Epstein)

http://groups.google.com/group/san-antonio-tech-book-club

Our next meeting:
Where: Skype
When: 4/21/2009 (Tuesday) at 7pm
Current Book: Implementing Lean Software Development: From Concept to Cash
Topic: Chapters 1 & 2

NOTE: On 5/5/2009 we'll be going back to our other book, Domain Driven Design by Eric Evans
and switching off between the books. Following meeting will be back to Lean, meeting after that will be DDD again, etc.

MEETINGS: 1st & 3rd TUESDAY OF EVERY MONTH (Skype)

Google Calendar

SARuby (organizer TBD)

http://www.saruby.org

There is now a SARuby group in San Antonio. This month's meeting is Tuesday, April 28 @ 6:30 pm. It is at Anderson Marketing Group (Thanks to Nate for providing the location). Map: http://tinyurl.com/ckl43y

MEETINGS: LAST TUESDAY OF EVERY MONTH (@ Anderson Marketing)

More detailed meeting information

LosTechies welcomes James Gregory

Jason Meridth — Fri, 27 Mar 2009 14:21:00 GMT

We are happy to announce a new member, James Gregory. If you're in the NHibernate world you'll recognize him as the lead developer on the Fluent NHibernate project. He recently took on the Docu project for .NET documentation and is working with a few other projects. His home page sums up his information perfectly. James is definitely a pragmatic programmer and is a perfect fit for us. Here are some of James' links.

His LosTechies blog is located at http://jagregory.lostechies.com

Homepage: http://jagregory.com
Blog: http://blog.jagregory.com
Twitter: http://twitter.com/jagregory
Github Repos: http://github.com/jagregory

OSS Projects
Docu: http://docu.jagregory.com
FluentNHibernate: http://fluentnhibernate.org/
BooLangStudio: http://www.codeplex.com/BooLangStudio

Welcome to the group James.

Adding a git post-receive hook to fire off Hudson CI server

Jason Meridth — Tue, 24 Mar 2009 18:07:00 GMT

UPDATE: guard clause throws LocalJumpError. Changed to simple if block Context: I needed our hudson CI builds to auto-fire when a developer pushes their code changes to our canonical/upstream git repositories. In your .git/hooks/post-receive file place the file code (FULL CODE):

#!/usr/bin/env ruby
#   
while (input = STDIN.read) != ''
   rev_old, rev_new, ref = input.split(" ")
   if ref == "refs/heads/master"

       url="http://yourhudsondomain.com/job/job_name_here/build?delay=0sec"

       puts "Run Hudson build for job_name_here application"
       `wget #{url} > /dev/null 2>&1`
   end
end

EXPLAINING EACH LINE: I avoid writing bash scripts in default bash if I can. This is for a Ruby on Rails app, so I decided to write it in Ruby.

#!/usr/bin/env ruby

The while loop checks to make sure there are values in STDIN (by default they are rev_old, rev_new, and ref).

#   
while (input = STDIN.read) != ''
end

I put an if statement block:

if ref == "refs/heads/master"
end

to make sure I only fire the build if it is the master branch. Set the URL for the app you want to build:

url="http://yourhudsondomain.com/job/job_name_here/build?delay=0sec"

Add a little text to notify the user what is going on (always a good idea):

puts "Run Hudson build for job_name_here application"

And finally all the url with wget and feeding any response to the black hole that is /dev/null

`wget #{url} > /dev/null 2>&1`

IMPORTANT: Don't forget to run:

chmod a+x .git/hooks/post-receive

so that the file can be run Some Gotchas: 1. If you are going to a url that has http basic authentication like my actual script does, you can pass the username and password like you normally would in an HTTP call:

url="http://username:password@yourhudsondomain.com/job/job_name_here/build?delay=0sec"

2. If you are doing an https call with a self-signed certificate, wget will complain. You can add the --no-check-certificate argument to wget to bypass certificate validation against local certificate caches:

`wget --no-check-certificate #{url} > /dev/null 2>&1`

LosTechies welcomes Eric Anderson

Jason Meridth — Wed, 11 Mar 2009 15:37:00 GMT

LosTechies is proud to welcome Eric Anderson. Eric is another Austinite that has been a great community contributor and has been very passionate about software best practices and continuous learning. His blog (http://testinfected.blogspot.com/) even has the testinfected subdomain, as ensuring that your code is properly tested is undoubtedly a passion of his.

Eric is also the primary developer on EasySpec, a BDD specification framework written in Groovy.
http://code.google.com/p/easyspec/

His Hudson Server for EasySpec: http://testinfected.dyndns.org/hudson/

I've had the privilege of meeting Eric on a number of occasions and am glad he has accepted our invitation to follow Pablo and help our community.

His new blog is located at http://eric.lostechies.com

Firefox Hudson Build Monitor add-on

Jason Meridth — Thu, 05 Mar 2009 02:19:00 GMT

MOZILLA: READ THIS!

To Mozilla,
You should upgrad ethe Hudson Build Monitor Plugin so that users don't have to create add-on accounts just to download. Cliffano's customer support and product are top of the line.

Explanation:
I have started using Hudson as my Continous Integraton server at work and still setting it up for custom interaction with Git. I have used CruiseControl.NET and TeamCity extensively in the past and both have tray tools. Well, I found HudsonTracker, but it wouldn't work for me because I'm using Basic HTTP Auth with my Hudson instance.

I then found the Firefox Hudson Build Monitor plugin, written by Cliffano Subagio (firefox developer account and blog), but again, same problem. I decided to issue a ticket with the Firefox plugin.

Within a short time (couple of days), Cliffano responded with a new version to test the HTTP Authentication against.

I uninstalled the old version just to make sure of no conflict and then I right-clicked the xpi file and said to open with Firefox. It installed without issue and showed the butler in the firefox status bar:

You can right-click him and get the preferences menu:

There are 5 tabs:
1.Feeds - where you put your RSS feed URL to your hudson dashboard

2. Display - designate some UI elements (# of builds, what to show on status bar when collapsed, color indicators [Hudson uses blue for successful builds for some reason. Can choose green here for us Red/Green guys/gals], etc)

3. Notification - designate how you will be notified of certain events

4. Network - username and password for HTTP Authentication

5. Misc - designate how to open page (new tab, new firefox window) and enable debugging

NOTE: Whenever I added my RSS feed from my Hudson dashboard to the tool (I'm using Firefox on a Mac) the URL would not stay. Cliffano had a solution for this:
1. Go to your Hudson dashboard

2. Right click your RSS feed of choice (I prefer "for all" which is https://hudson.mydomain.com/rssAll):

3. Choose "Add Link To Hudson Build Monitor"

4. Name the URL:

And VOILA! it stayed in my preferences. Most users won't have to go this route, but instead of typing out the url and just a name, it is easier.

Thank you Cliffano. Hopefully Mozilla will upgrade the plugin and stop requiring people to create accounts to download it.

Cliffano has stated that a 1.0 version will be coming soon. Enjoy!

Design Patterns in Ruby by Russ Olsen

Jason Meridth — Thu, 26 Feb 2009 04:29:00 GMT

After nudging by Joe Ocampo and Scott Bellware, I finally sat down at finished "Design Patterns in Ruby" by Russ Olsen. The format of most of the chapters made the book an interesting read: 1. A introduction to why you might need the pattern 2. A static language developer's approach with the Ruby language 3. A seasoned Ruby developer's approach to the design pattern 4. Using and Abusing 5. in the wild 6. Wrapping up Some of the items that I learned [LosTechies is not a cult contrary to some of the examples you read below; some of the examples below are using LosTechies nomenclature but closely resemble what the author had in the book] If any of the stuff below intrigues you: GO BUY THE BOOK. You won't regret it. Even if you are trying to understand patterns in another language. Russ Olsen does an excellent job explaining the INTENT of the patterns. FUN When teaching the reader about "Truth, Lies, and nil", the author even pokes fun at himself:'russ' == 'smart' # sadly, false

BOOLEAN In Ruby, zero, being neither false nor nil, evaluates to true in Boolean expression. will print out: Zero is true!

ARRAYS Points for matrix reference in array examples

REGULAR EXPRESSIONS The flow of the language when creating regular expressions:

ARBITRARY PARAMETERS Any author that uses DC comic character to explain arbitrary numbers of arguments, is a winner in my mind:

DUCK TYPING AND UNIT TESTS He mentions duck typing and the fact that "Unit Tests Are Not Optional" is a section heading when teaching the Template Method Pattern.

PROCS AND BLOCKS

STRATEGY PATTERN using proc-based formatters to create a ruby-based strategy pattern You could create any type of formatter you want in a proc instead creating new classes.

OBSERVER PATTERN Modules exist that encapsulate things that some of us static developers might already be used to:

ITERATOR PATTERN Internal Iterators versus External Iterators: (had never heard it put this way) External iterator - client drives the iteration...you won't call next until you are good and ready for the next element Internal iterator - the aggregate relentlessly pushes the code block to accept item after item.

COMMAND PATTERN The Command pattern translates very smoothly into code blocks. Here is a PabloForPresidentButton class reworked to use code blocks: The author does not diminish the needs for classes. For straightforward actions, use a Proc object. For complex object or objects that will carry around a lot of state, create a command class.

ADAPTER PATTERN Instead of adhering to some interface and trying to create your adapter, why not just extend the original class. Before any of you Open-Closed people attack, please re-read the definition of OCP - Open for extension, closed for modification. Doesn't this adhere to that? :)

PROXY PATTERN There are three tyes of Proxies: The Protection Proxy, Remote Proxy, Virtual Proxy These are mentioned in the Gang of Four book. He introduces a Ruby-esqe way to approach proxies: the method_missing Method Will output: delegating deposit method to subject. delegating withdraw method to subject. delegating balance method to subject. account balance is now: 75

DECORATOR PATTERN

SINGLETON PATTERN The author admits the career of the singleton has been checkered, but still shows that you can use it in the Ruby world. An example he gives us to allow testing of singleton implementation code is to put the implementation code in a base class and have the child be the singleton:

FACTORY/ABSTRACT FACTORY PATTERN I never had it straight, exactly, what the difference between these patterns were (yes, besides name). I never bothered to look. According to the author, Factory returns back a single object while Abstract Factory is "an object dedicated to creating a compatible set of objects". According to GoF book (which I have open in front of me), Abstract Factory "provides an interface for creating families of related or dependent objects without specifying their concreate classes". Which one do you think would have turned the light bulb off in your head? :) The other item was using "Convention Over Configuration" to generate abstract factories: Notice the correct classes (reader/writer) are generated dynamically with the help of the const_get Ruby method.

BUILDER PATTERN Magic methods: "very easy to implement using the method_missing technique...you simply catch all unexpected method calls with method_missing and parse the method name to see if it matches the pattern of your magic method name".

Last 3 Chapters are the meat of the book: INTERPRETER PATTERN (place where Bellware told me to start) DOMAIN SPECIFIC LANGUAGE (DSL) CONVENTION OVER CONFIGURATION Those stay obscure so you can go read it. I think the book is worth a visit on Safari books if you have an account or worth the purchase for the bathroom reading. I enjoyed it. Thanks Scott and Joe

Gitosis and a non-standard SSH port

Jason Meridth — Fri, 13 Feb 2009 19:44:00 GMT

I recently installed gitosis, a free way to host your own git repositories, and I am using a non-standard port (not 22). I tried to clone the gitosis-admin repository and it timed-out. Learned via this post that I needed to create a config file under my .ssh folder in my home directory that listed the Host and Port. Example ~/.ssh/config:

Host git.mydomain.com
Port 30000

When I do this:

git clone git-user@git.mydomain.com:gitosis-admin.git

it will then use my non-standard port to clone the gitosis repository. I hadn't done this before. Good to know.

This post by scie.nti.st is the best HowTo on installing gitosis that I could find.

Current Status

Jason Meridth — Thu, 12 Feb 2009 04:53:00 GMT

UPDATE: I'm very eager to see where IronRuby and RSpec go for the .NET world. Testing my C# Applications with RSpec would be awesome. Check out the MSDN magazine article about this stuff if you haven't already.

I'm working with a Ruby on Rails project now (RoR from now on) and absolutely loving it. I'm on nothing but Linux boxes, working with Ruby, and have been put in charge of strengthening our testing skills. I kind of laugh at this because I am having to learn Ruby, Rails, Nginx, Mongrels, etc and then figure out how to test RoR code.

I still touch up a C# API for another project at the company I work for; I'm not completely disconnected from the .NET world.

I went down the Test::Unit path first, due to the fact that it comes with Rails. I was quickly reminded why I went down the Behavior Driven Development path in C#. Test::Unit is a lot of doing Test Driven Development in NUnit (or other xUnit) fashion. You prefix your tests with "test_" and go from there. It works. I can't deny that in either the .NET world or the Rails world. I just prefer to focus on the behavior because it highlights that I will only make specifications or examples pass because they are serving a function my user has requested.

I then went down the, ever popular, RSpec path. A few more gems installed and another TextMate bundle to gain some RSpec macros. I liked it but it felt like too much. I can't explain it. I have friends who swear by RSpec and more power to them. Going down this route also exposed Zentest/autotest to me. For testing specs I'd use autospec from the same tool. Once I figured out how to sync Growl (I'm on a Macbook Pro), the notification tool on a Mac, with autospec, I was in heaven. So I'd run autospec, it would run all my specs and then spit up a notification with a green window for passing specs or red for failure with the count of failed tests. Autospec would then just wait for a file to change and then run the specs in the file and again notify me. It was like my own local CI notification.

I then found out about Shoulda. Shoulda is a gem/plugin that gives you the same context/should notation as RSpec but still utilizing the Test::Unit portion of Rails (again Test::Unit comes with Rails by default). I had some fun getting it working but with some help on the Google Group (http://groups.google.com/group/shoula), I was able to get it working pretty fast. And instead of running autospec, I'd run autotest again with a few changes to my ~/.autotest file to get my local notifications.

I will be posting more posts going into detail about all of these paragraphs and also about my continuing adventures in the Ruby on Rails and Linux world.

Things I will be posting about:

Nginx
Apache with Phusion Passenger
Linux OS (commands, basic setup, security, etc)
Ruby on Rails
Ruby
Python
Django
TextMate (code editor on Mac)
CloudFiles (Rackspace Cloud storage)
Hudson and CruiseControl.rb (Continuous Integration software that works with Ruby)

Slicehost articles

Jason Meridth — Thu, 12 Feb 2009 04:49:00 GMT

If you are Linux newbie or are still unsure about how to setup your Linux box/slice/server, take a serious look at the Slicehost Articles. Other articles include setup of Apache, Nginx, Postfix, MySQL, Ruby on Rails, Capistrano, SSH, Self-signed certificates, Django, etc.

For all the Only Windows guys who read this, these articles are a great way to get your feet wet with Linux. Can't hurt your pocket book. It's free. Ubuntu is currently my favorite distribution.

I've tweeted about this a number of times.

These articles are phenomenal.

Hudson and Nginx

Jason Meridth — Thu, 12 Feb 2009 04:46:00 GMT

UPDATE: I left HTTP Auth in place via Nginx and removed security from my Hudson instance. This works for me because I don't need the Hudson security. Every developer should be able to manage the CI server. I'm just trying to prevent external access to the dashboard.

I've been having fun trying to figure out how to block a user's ability of going to http://mydomain:8080 and bypassing my 80 to 443 redirect and htpasswd HTTP basic authentication. I even went as far as removing Nginx and installing Apache. According to the Hudson site, we can use Apache to do this. Either I'm not smart enough or web pages like this reminded me why I hate the Java Enterprise stack as much as I do. Talk about installation obfuscation. My problem exists because the Tomcat instance running the hudson war file uses Apache JServe Protocol (AJP) and will allow direct access on whatever port you used (default 8080). This is even if you proxy_pass to 8080 from 443 (SSL) or 80 (Web). Through testing and research it seems that Nginx does not have a solution for this. I can't allow access to my Hudson instance from external users. I have a self-signed certificate and a .htpasswd file to protect the instance, but is all useless is someone could just type in http://mydomain.com:8080. I want that redirected to https://mydomain.com which will then proxy internally to http://127.0.0.1:8080. I didn't want to fight this, so I just used iptables (linux firewall) to block external requests on port 8080 but allow internal requests to 8080. Here is the entry in my iptables file:

# Deny HTTP requests to port 8080 externally but allow internally
-A INPUT -i eth0 -p tcp -m tcp --dport 8080 -j REJECT

I only allow access to my server via 80 (web), 443 (ssl) and my ssh port (I'm not telling). This works for now, but I'm experiencing another weird issue. I follow the Nginx way of using HTTP basic authentication:

location  /  {      
 auth_basic            "Restricted";
 auth_basic_user_file  conf/htpasswd;
}

If the user listed in the htpasswd file is also a registered user on the Hudson instance (through the Hudson UI) then the HTTP basic authentication will work. If they are in the htpasswd file but not registered with Hudson, it fails with a HTTP 401 (Unauthorized). Why would the HTTP basic authentication be "tunneled" through to Hudson? I'll update this post once I figure it out.