In search of the next shiny thing

login to your remote server using cd and rvmrc

2012-02-08T00:00:00+00:00

Here is a fun trick which you can use, to simulate that a remote server is on one of your directories.

Create a folder call ~/m/example.com and in that folder create a file called .rvmrc with the following command

1 ssh awesomeuser@example.com -p 2302 -i ~/.ssh/awesomekey_rsa
2 #or whatever ssh command you use

Now whenever you run cd ~/m/example.com you will automagically be logged into your remote computer.

Obviously, this is a fun trick. All this can be done in a much nicer way using the ~/.ssh/config file.

Here are a few resources to make your ssh config more useful, allowing you to login to servers using a command like ssh myserver

I wonder what other stuff could be done using rvmrc.

make evil monkey nag you back to work

2011-12-16T00:00:00+00:00

Update: fixed the cron entry

I’ve read a very interesting article about “Why programmers work at night”. One of the points the author talks about is “how we get engrossed in twitter/hacker news/reddit”. I’ve felt the same. I think one of the reasons why we(programmers/developers) spend a lot of our time on twitter/hacker news/reddit is, because, we don’t have any idea of the time. Time just flies by. So, I created a small ruby script which nags you to get back to work :)

~/.scripts/nagger

 1 #!/usr/bin/env ruby
 2 require 'time'
 3 
 4 exit if File.exists?("/tmp/stop-nagging")
 5 #see what I did here ;)
 6 
 7 #run the below command to find your display
 8 #env | grep DISPLAY
 9 ENV['DISPLAY'] = ':0.0'
10 
11 last_line = `tail -2 ~/.gtimelog/timelog.txt`.lines.map{|x| x.chomp}.reject{|x| x.empty?}.reverse.first
12 minutes = ((Time.now - Time.parse(last_line[11, 5])) / 60).round
13 evil_monkey = File.expand_path File.join(File.dirname(__FILE__), 'evil-monkey.gif')
14 
15 if minutes > 30
16   `notify-send -i '#{evil_monkey}' "It's been #{minutes} minutes since your last log"`
17 end

cron entry

1 0,5,10,15,20,25,30,35,40,45,50,55 * * * * /bin/bash -l -c '/home/minhajuddin/.scripts/nagger'

Hope it helps you get back to work too :). By the way, I use the awesome gtimelog app to log my time.

script to do a global search and replace in a git repository

2011-12-13T00:00:00+00:00

There are many instances where I had to replace some variable name in all my files. I use a small script to do this, Hope it helps you too.

 1 #!/bin/bash
 2 #~/.scripts/git-sub
 3 #Author: Khaja Minhajuddin <minhajuddin@cosmicvent.com>
 4 #script which does a global search and replace in the git repository
 5 #it takes two arguments
 6 #e.g. git sub OLD NEW
 7 
 8 old=$1
 9 new=$2
10 
11 for file in $(git grep $old | cut -d':'  -f 1 | uniq)
12 do
13   echo "replacing '$old' with '$new' in '$file'"
14   sed -i -e "s/$old/$new/g" $file
15 done

Just remember to add it to a directory which is in the $PATH. I have it in my ~/.scripts directory which is included in the $PATH. Name it git-sub and give it executable permissions using chmod +x ~/.scripts/git-sub. Now, you can just call git sub old_var new_var on terminal and it will do a global search and replace of all the files in the repository.

elegance of functional programming

2011-12-12T00:00:00+00:00

Functional programming allows you to write concise and elegant code. Mainstream languages like Ruby and C# support a lot of functional programming paradigms, and learning them makes you a better programmer. Below is a small example which demonstrates that:

 1 #6 lines of ugly code
 2 i = 0
 3 tasks = list.tasks
 4 while(i < tasks.length - 2)
 5   tasks[i].priority.should >= tasks[i + 1].priority
 6   i += 1
 7 end
 8 
 9 
10 #3 lines of elegant functional code
11 list.tasks.each_cons(2).each do |t1, t2|
12   t1.priority.should >= t2.priority
13 end

gc your git repositories automatically with a cron task

2011-12-09T00:00:00+00:00

I have a lot of git code repositories, and I usually gc (garbage collect) them manually by running the git gc command every now and then. Tasks like these are prime candidates for automating with cron. Below is a cron entry and the script which gcs my repositories. Hope you guys find it useful.

the script

 1 #!/bin/bash
 2 #author: Khaja Minhajuddin
 3 #email: minhajuddin.k@gmail.com
 4 #path /home/minhajuddin/.cron/reboot.sh
 5 #description: script which is executed everytime computer starts
 6 
 7 #git gc repos
 8 REPO_DIRS=$(cat <<EOS
 9 $HOME/repos
10 $HOME/repos/core
11 EOS
12 )
13 
14 for repo_dir in $REPO_DIRS
15 do
16   echo "checking for git repos in $repo_dir"
17   for repo in $(ls $repo_dir)
18   do
19     cd $repo_dir/$repo
20     if [[ -d .git ]]
21     then
22       echo "garbage collecting $repo"
23       git gc
24     fi
25   done
26 done

the crontab entry

1 $ crontab -e
2 #add the line below into the editor and save it
3 @reboot   $HOME/.cron/reboot.sh

Bonus tip: If you have a gitosis server, put the following script at ~git/.cron/reboot.sh and perform the above step for your git user.

the gitosis git user script

1 #!/bin/bash
2 
3 for repo in $(ls ~/repositories)
4 do
5   cd ~/repositories/$repo
6   echo "garbage collecting $repo"
7   git gc
8 done

automatically push your git repo to a server on shutdown

2011-11-22T00:00:00+00:00

Sometimes, I forget to push my git commits to our git server at the end of the day. This causes inconvenience to others as they can’t review my code or build upon it. So, today I wrote a small script which syncs all my git repositories with a remote server. Hope it helps you too :)

The setup consists of three files:

core syncing script at ~/.scripts/sync-repos

 1 #!/usr/bin/env ruby
 2 require 'rubygems'
 3 require 'yaml'
 4 
 5 #replace google.com with your git servers domain
 6 `ping -c 1 google.com`
 7 if $?.exitstatus != 0
 8   puts 'UNABLE TO SYNC REPOS AS NW IS DOWN'
 9   exit $?.exitstatus
10 end
11 
12 puts 'syncing repositories'
13 
14 @repos = YAML::load_file File.expand_path( '~/.sync-repos')
15 
16 @repos.each do |repo|
17   path = File.expand_path repo[:path]
18   remotes = repo[:remotes].is_a?(String) ? [repo[:remotes]] : repo[:remotes]
19   unless File.exist? path
20     puts "skipping #{path} as directory not found"
21     next
22   end
23 
24   remotes.each do |remote|
25     cmd = "cd #{path} && git push #{remote}"
26     puts "executing: '#{cmd}'"
27     system(cmd)
28   end
29 end
30 
31 puts 'done syncing repositories'

config file pointing to all the repos at ~/.sync-repos

1 ---
2 - :path: ~/repos/search
3   :remotes:
4   - origin
5 - :path: ~/repos/logbin
6   :remotes:
7   - origin
8   - local

upstart shutdown trigger script at /etc/init/syncrepos.conf

1 start on runlevel [06]
2 
3 /bin/bash -l -c /home/minhajuddin/.scripts/sync-repos

how to setup solr and sunspot on a rails production server

2011-11-10T00:00:00+00:00

Solr is an awesome app built on top of Lucene for fulltext search. However, setting it up can be a pain if you don’t find the right guide, or if you miss some small detail. So, here is my attempt to document the process of setting up solr in development and production using a rails app as an example.

Solr and Lucene are java apps, so you need java to get this stuff working, I installed sun-jdk just to play it safe, as far as I know it works well even with openjdk.

Steps to setup solr on production

1. Install Sun JDK:

1 #install and setup sun jdk
2 echo "deb http://archive.canonical.com/ $(lsb_release -cs) partner"| sudo tee -a /etc/apt/sources.list > /dev/null
3 sudo apt-get update
4 sudo apt-get install sun-java6-jre sun-java6-bin sun-java6-jdk -y
5 sudo update-alternatives --config java
6 echo 'export JAVA_HOME=/usr/lib/jvm/java-6-sun/' >> ~/.bashrc

2. Download and setup tomcat: you’ll need to setup tomcat version 6.0 for your production server. Download the latest V6 tomcat files from http://tomcat.apache.org/download-60.cgi. Now, extract them into ~/apps.

3. Download or build the solr war files and copy them to /apps/solr. You can find the links at: http://lucene.apache.org/solr/ or http://www.apache.org/dyn/closer.cgi/lucene/solr/. The war file is usually in a folder called dist and has a filename like apache-solr-3.4.0.war

4. Create a file ~/apps/tomcat/conf/Catalina/localhost/solr-appname.xml with the following content

1 <?xml version="1.0" encoding="utf-8"?>
2 <!-- I usually create this file in the rails app config/ directory and symlink
3 it to the ~/tomcat/conf/Catalina/localhost/ directory-->
4 <!-- the docBase path should point to your solr.war file -->
5 <Context docBase="/home/minhajuddin/apps/solr/solr.war" debug="0" crossContext="true">
6   <!-- the value string should point to your apps solr directory -->
7   <Environment name="solr/home" type="java.lang.String" value="/home/minhajuddin/spikes/solr-blog/solr" override="true"/>
8   <!-- value= app-name/solr -->
9 </Context>

Steps till this point are the same for any kind of solr installation, be it for a rails or any other app.

5. I use the sunspot_rails gem in my rails application, when using this, you can run rails g sunspot_rails:install to create a config/sunspot.yml file. Once you have the config file, change the production config values to point to the right port and path, e.g:

1 ..
2 production:
3   solr:
4     hostname: localhost
5     port: 8080
6     path: '/solr-odir/'

6. Run the bundle exec rake sunspot:solr:start command once, on the development machine, to generate the solr configuration files. And push this code to the production server.

That’s all. Setting solr is not very straightforward, but once you have it set up, it’s very easy to setup additional apps with the same solr server.

On a development machine, all you need to get solr working is: install java (check step 1) and setup sunspot (check step 5), and start the solr server with bundle exec rake sunspot:solr:start

Resources

simple log management and viewing for your servers

2011-11-08T00:00:00+00:00

As a guy who develops, deploys and maintains webapps, I had to login to my servers and tail the logs to see issues too many times. It’s a real pain, And anybody who maintains any servers knows this.

I’ve recently found a bunch of very good apps, which make this job very pleasant: PaperTrail is an awesome app which makes it very simple to setup a logging daemon and view all your logs (from all your servers) on their website, It’s a very neat implementation. But, you might not want to send your logs to other apps as they usually have sensitive information.

logstash is another awesome open source implementation for log management. With logstash, you can setup a small central server which collects all your logs and allows you to access them through a variety of interfaces. Another advantage of logstash is that the logs stay on your server under your control, plus it’s open source. The only downside is the one time setup, which, is not that hard. It is very versatile in ways it allows you access to your logs.

If none of them seem to be your thing, here is a small script which I use to tail remote log files. It runs tail -f over an ssh connection. It’s very simple to setup and use. Once you set it up, you can just cd into your application directory and run rt and it will start tailing your log files instantly. If you have any improvements you can fork this gist and update it.

 1 #~/.scripts/rt
 2 #!/usr/bin/env ruby
 3 require 'rubygems'
 4 require 'yaml'
 5 require 'erb'
 6 
 7 ConfigFilePath = File.expand_path("~/.remote-tail.yml")
 8 
 9 #will be written out to ConfigFilePath if not present
10 SampleConfig=<<EOS
11 ---
12 defaults: &defaults
13   host: c3
14 foonginx:
15   file: /var/log/nginx/*.log
16 barapp:
17   host: foo@bar.com
18   file: /var/www/apps/railsfooapp/shared/log/*.log
19 EOS
20 
21 Usage=<<EOS
22 Usage:
23   1. cd to into the directory whose name is the same as the name of the config and run
24      rt
25 
26   2. rt <name of the app>
27 
28   3. rt <host> <file>
29 EOS
30 
31 def tail(opts)
32   cmd = "ssh #{opts['host']} 'tail -f #{opts['file']}'"
33   puts "running: '#{cmd}'"
34   system(cmd)
35 end
36 
37 def config(app)
38   puts "using app:#{app}"
39   config = YAML::load_file ConfigFilePath
40   return config[app] if config[app]
41   puts "app:#{app} not found in #{ConfigFilePath}"
42   puts Usage
43   exit 2
44 end
45 
46 def setup
47   return if File.exist? ConfigFilePath
48   puts "creating a sample config at: #{ConfigFilePath}"
49   File.open(ConfigFilePath, 'w') do |f|
50     f.print SampleConfig
51   end
52 end
53 
54 def init
55   setup
56   case ARGV.length
57   when 0
58     #usage:
59     #cd to the app root directory, usually this would be the name with which you
60     #setup the configuration and run
61     #$ rt
62     tail config(File.basename(Dir.pwd))
63   when 1
64     #usage:
65     #from any directory
66     #$ rt <name of the app>
67     tail config(ARGV.first)
68   when 2
69     #usage:
70     #from any directory
71     #$ rt <host> <file>
72     tail :host => ARGV.first, :file => ARGV.last
73   else
74     puts "Invalid number of arguments"
75     puts Usage
76     exit 1
77   end
78 end
79 
80 init

how to change the rails root url based on the current user or role

2011-10-24T00:00:00+00:00

In my latest rails app, I needed the root url to be different based on the logged in user, i.e. if the user was logged in I wanted to show one page, if not I wanted to show a generic page. Rails 3 makes this very easy.

While drawing routes, rails gives you ability to constrain the route based on anything in the incoming request. As it happens, I was using devise for my authentication needs and devise uses warden which fills up the request’s env with the current user, Once I had the current user it was a simple conditional statement was all that was needed to get my routes working. Checkout the below implementation to see how it’s done:

 1 #lib/role_constraint.rb
 2 
 3 class RoleConstraint
 4   def initialize(*roles)
 5     @roles = roles
 6   end
 7 
 8   def matches?(request)
 9     @roles.include? request.env['warden'].user.try(:role)
10   end
11 end
12 
13 #config/routes.rb
14 root :to => 'admin#index', :constraints => RoleConstraint.new(:admin) #matches this route when the current user is an admin
15 root :to => 'sites#index', :constraints => RoleConstraint.new(:user) #matches this route when the current user is an user
16 root :to => 'home#index' #matches this route when the above two matches don't pass

mind stack, a stack of your thoughts and tasks

2011-10-03T00:00:00+00:00

As a developers, we are always bombarded with information/tasks/thoughts/ideas. And at times, it’s very difficult to remember these things. On a lot of occasions, I start doing task X and in the middle of it, I remember that I need to “fix something urgently”, so I stop doing X and move to the Urgent task Y, when I am done with Y I have difficulty remembering what I was doing before that. This is just when I have two tasks, but the level of nesting can sometimes go a lot deeper.

That’s when I read a blog post(can’t remember where), which talked about saving your state of mind(on post-it notes or notebooks or whatever). And, it has helped me a lot. I also created a little bash script which helps me save my state of mind. I’ve been using it for a long time and it has served me well. I am posting it on github hoping that others may find it useful. You can check it out at Mind::Stack.

I also have the following line in my .xmobarrc so that I can see the top 3 tasks in my status bar.

1   , Run Com "/home/minhajuddin/.scripts/s" ["top"] "slotter" 600

Screenshot of my xmobar