1) Quoting styles:
MySQL allows you to quote table and column names with backquotes, whereas PostgreSQL uses double quotes.
For ex:
One of our tables has a column in it called when, which must be quoted whenever we use it.
Rails will of course handle the quoting for you if you do something like

Meeting.find_by_when(Time.now)

But if you are constructing your own SQL conditions then you have to handle the quoting problem.

In MySQL, it would be like

Meeting.where("`when` < ?", Time.now)

In PostgreSQL, it would be like

Meeting.where("\"when\" < ?", Time.now)

Solution:

Meeting.where("#{Meeting.connection.quote_column_name(when)} < ?", Time.now)

2) Boolean type:
MySQL lacks a native BOOLEAN type, so if you create a boolean column in Rails, you will end up with a TINYINT(1) column which has values of 0 and 1 for false and true respectively. PostgreSQL has a native BOOLEAN type, it will accept only false/true unlike MySQL.

In MySQL, it would be like

Meeting.where("import=1") OR Meeting.where("import=?", true)

In PostgreSQL, it would be like

Meeting.where("import=?", true)

Solution:

so replace 0 and 1 with false and true in your all files then it work in both MySQL and PostgreSQL.

3) Other differences:
(i) Fulltext Search: PostgreSQL is case sensitive. MySQL is not case sensitive.
(ii) To select random records from DB, Mysql has a function called “rand()” and PostgreSQL has a function called “random()”.
(iii) PostgreSQL ALTER TABLE supports ADD COLUMN, RENAME COLUMN and RENAME TABLE only. MySQL has all options in ALTER TABLE.
(iv) In PostgreSQL, attribute name starting with numbers, like “360_degree” are not allowed.

Good luck!

Most of the graph database in dasboard are moving towards runtime flexibility (but not a lot) for well defined types and performance. A client graph for e.g gives a representation of various clients and various projects, if I just want to list all the people in the company and check out each of their performance dasboard allows u to do that too. How does dasboard get individual performances? The little secret here is that we are using a generic internal feedback system that we started developing. Based on various feedbacks our internally learning algorithms carefully does collaborative filtering and represents it in the finest UI possible.

Thats not it..!! Dasboard even brings all your projects together. Dasboard talks to various API’s and combining this information with some of the best practices we have been adopting from the agile world dasboard is fast evoloving into one of the finest inhouse products we have been working on.

Stay tuned….!!

From September 8, 2011

I started out to build a simple chat application which would allow users to create a room and log into the room and post messages to multiple users who were logged in. Though, this is probably not the best use case for using AMQP but it helped me understand how AMQP worked and maybe I’ll get to use somewhere more apt.

RabbitMQ

What is RabbitMQ
RabbitMQ is an open source, highly scalable messaging system which provides support for STOMP, SMTP and HTTP messaging. [www.rabbitmq.com]

It’s built using the Advanced Message Queuing protocol (AMQP) which provides APIs in Ruby and several other programming languages.

Installation

The easiest way to install RabbitMQ on the Mac is using homebrew. The Macports installation has many issues and I would recommend going with HomeBrew. It also takes care of all dependencies like the correct Erlang installation etc.

You can test your installation by moving into the installation ‘bin’ directory and running rabbitmq-server

If you end up seeing something like

 ...
 starting error log relay                                              ...done
 starting networking                                                   ...done
 starting direct_client                                                ...done
 starting notify cluster nodes
 broker running

your good to go.

Creating our AMQP server

In Ruby we could run our AMQP server using the ‘amqp gem’ along with EventMachine.

The AMQP server code.

require 'rubygems'
require 'amqp'
require 'mongo'
require 'em-websocket'
require 'json'

....

@sockets = []
EventMachine.run do
  connection  = AMQP.connect(:host => '127.0.0.1')
  channel = AMQP::Channel.new(connection)
  puts "Connected to AMQP broker. #{AMQP::VERSION} "
  mongo = MongoManager.establish_connection("trackertalk_development")

  EventMachine::WebSocket.start(:host => '127.0.0.1', :port => 8080) do |ws|
    socket_detail = {:socket => ws}
    ws.onopen do
      @sockets < true)
        #AMQP::Consumer.new(channel, queue)

      elsif status[:status] == 'MESSAGE'
        full_message = " #{status[:username]} :  #{status[:message]}"
        exchange.publish(full_message)
      end
    end

    ws.onclose do
      @sockets.delete ws
    end
  end

end

The code snippet contains most of the amqp server code. The entire code lives inside the EM.run loop. Ignore the Mongo bit as it doesn’t play a part in our area of interest.

@sockets = []
EventMachine.run do
  connection  = AMQP.connect(:host => '127.0.0.1')
  channel = AMQP::Channel.new(connection)
...

In this snippet I created a new AMQP connection to localhost. When not provided with any other parameter the default port used by AMQP is 5672 with the username: guest and password :guest. Since the RabbitMQ installation will never (in most cases) have to be accessed from outside the server its safe to run the installation with the defaults.

The second line creates a new channel.

Once the channel is established the EM::Websocket block is used to allow modern browsers to connect to our server on port 8080

EventMachine::WebSocket.start(:host => '127.0.0.1', :port => 8080) do |ws|
    socket_detail = {:socket => ws}
    ws.onopen do
      @sockets < true)
        #AMQP::Consumer.new(channel, queue)

      elsif status[:status] == 'MESSAGE'
        full_message = " #{status[:username]} :  #{status[:message]}"
        exchange.publish(full_message)
      end
    end

    ws.onclose do
      @sockets.delete ws
    end

This is where the core logic lies. On the socket connect block I store the current socket in an array to use it later.

The ‘onmessage’ block is called when a new message arrives from the browser. Since I needed to dynamically create new exchanges and queues I used a very amateurish system. The message sent from the browser arrives with the following parameters in the JSON format

The following snippet is not a part of AMQP but a feature borrowed from XMPP to get my application working

{status:'status', username:'someusername', roomname:'someroomname', message:'somemessage'}

Status could have values from ['status', 'message', 'presence']
Username contains the ‘current_user’ name
Roomname indicates the ‘room’ the user has been logged into.

Status messages indicate that some kind of chore needs to be performed like subscribing to queues, binding exchanges etc.

Messages indicate that the message needs to be pushed to an exchange. When a message is published to an exchange, subscribing queues push the message to the browser using Websockets.

Presence messages indicate the users presence.

Why the entire application was a failure

The most important aspect while using AMQP is identifying the type of exchanges needed. In this case my assumptions on identifying rooms to be exchanges and users to have individual queues proved to be the reason for failure.

The reason why this assumption would fail is if a user queue would bind to multiple exchanges with each user having a unique queue assigned to him, a simple fanout exchange would push messages from different rooms to the user’s logged in chat room which is not what we want. This way users would end up receiving messages that are not relevant.

A ideal approach would have multiple users subscribe to a room (assumed to be the queue in this case) via a topic exchange.

I also believe that it would be logical to dynamically create queues and exchanges using the EM.periodic timer to check a NoSQL database or key-value store for new requests rather than using Websockets.

I am using rails 3 and ruby 1.9.2 in my application.
While importing/parsing the CSV, I get an error “Incompatible character encodings: ASCII-8bit and UTF-8″.
I quickly checked my database encoding, it was UTF-8 only and also in application.rb, I had

 'config.encoding = "utf-8"' 

I had no idea what was going wrong…

After googling a bit, I found that couple of posts mentioned some workarounds for this issue, so I tried:

# encoding: utf-8 => in my class
# and
"hello ümlaut".force_encoding("UTF-8")

That output was

"hello ?mlat"

With this the Error was fixed (no rails error) but the converted string value is incorrect. It was working correctly in some places but not everywhere.

I searched a bit more and then I found that the sequence of bytes that represent an “ü” is different in different encodings and could not be recognized in UTF-8, so such characters were replaced with a “?”.

Solution:
We have to find out that the original encoding of the string and then convert to UTF-8. To achieve this in ruby 1.9.2, we can’t do it directly.
so, we need to install the gem ‘rchardet19′
and then add this to the top of your class, require ‘iconv’

now,

  data = CharDet.detect(value)
  puts "Detected encoding- #{data.encoding}"

and,

  value = data.confidence > 0.6 ? Iconv.iconv("UTF-8", data.encoding, value) : value

we are just converting to UTF-8 from the detected encoding.

This fixes the issue.

In the following code, the JS variable ‘message’ is initialized on ‘beforeload’ event of the webview in webview.evalJS() method which will invoke the javascript code inside the context of the webview.

app.js

var window = Titanium.UI.createWindow();
var webview = Titanium.UI.createWebView({url:'message.html'});
window.add(webview);
var str = "Hello world!";
webview.addEventListener('beforeload',function(e)
{
webview.evalJS("var message='"+ str+"';");
});
window.open();

As the JS ‘message’ variable is assigned before loading the webview, it is also available in the html page.

message.html

<html>
<head>
<script type="text/javascript">
alert(message);
</script>
</head>
<body>
</body>
</html>


Step by Step guide to get hoptracker working for your app.

Softwire Intro:
Base app for Hoptracker which pulls errors from Hoptoad and adds them as bugs in Pivotal Tracker Project. It is still an alpha stage app with very basic user interface, no administration module yet, so all details of projects available for all, essentially for internal use as of now.

Steps in softwire:
1. Goto http://softwire.sapps.in

2. Click on New app. This will ask you to provide app related details:
a) name of your app
b) Hoptoad app name (.hoptoadapp.com : Its the portion that softwire is interested in.)
c) Hoptoad Auth Key (Get this from hoptoadapp.com)
d) Pivotal Tracker Project Id
e) Pivotal Tracker Auth Key (Again log into Pivotal to get this)

3. Create the app and see it listed in the listings page. Note the “Id” field of your app (as you will later use it to configure the hoptracker in your app). Bear with me at this point in time for atleast the Id should have been hashed. The next release will have a better approach to this.

Thats it, you are done with the registration of your app with softwire and it is now ready to do the bug movement provided it is notified to do so. This notification happens via hoptracker plugin in your app. Lets see how that is done in a bit.

Hoptracker Intro:
A Rack based app to log hoptoad errors onto Pivotal Tracker. This plugin communicates with softwire (http://softwire.sapps.in) application and notifies whenever an exception occurs. Softwire, then pulls the error from Hoptoad and adds it as a bug in Pivotal Tracker.

Steps in hoptracker
1. Drop the plugin in your projects’ vendor/plugins folder (script/plugin install git@github.com:sapnasolutions/hoptracker.git).
2. In the environment.rb add the following line:
config.middleware.use ‘Hoptracker::Rack’
3. Create hoptracker.rb file in your initializers and drop in this line:
Hoptracker.app_id= (This is the Id that you got as part of app creation on softwire.)
4. Restart your server and start getting your hoptoad errors onto your pivotal tracker project.

Enjoy!

P.S: This is still a work in progress project and does not contain an admin interface nor does it have any test cases! . Contributions are welcome and appreciated!

Background:
At Sapna, we use:
1) Pivotal Tracker for project management where all the stories/ chores and bugs go in.
2) And we use Hoptoad to notify errors in the app.

The problem:
Once an error comes to the mail box or we check it out at app.hoptoadapp.com, one needed to copy paste the error into Pivotal Tracker so as to track the error to completion. And this is manual job of copy/paste and sometimes, one tends to forget to the same. So we saw a need to automatically move errors from hoptoad into pivotal tracker. As of now Hoptoad support adding tickets to lighthouse projects for a price (check: hoptoadapp.com). So this got us started on Hoptracker.

Initial design:
We wanted to write this rack app (hoptracker) which checks the response headers to see for errors and if found:
1. Check hoptoad for latest errors
2. Check pivotal tracker for the list of hoptoad errors (we add the hoptoad error id as part of the story/bug name). Any delta that it results in.
3. We add them to Pivotal tracker.

This would work fine but the problem here is that for every error, all the 3 steps would usually run and then the response would be sent to the user, which potentially will slow down the app, which is not desired.

Alternate design considerations:
If we moved these steps to a background process and not interfere with the response, then that would be ideal. So we planned to use delayed_job to do the background processing of the same. Then again, the plugin hoptracker will come with a dependency that every app which would use hoptracker needs to have delayed_job gem installed and the table created. A dependency like this, we did not want to inject.

Moving forward, we thought it would be right to move these steps to a small app which is doing the work for all our apps, more like a Saas. Thus softwire was born. The negatives of such an approach is that, we now need to have an admin interface in softwire where apps need to be registered with the necessary (hoptoad/ pivotal tracker) details. But then we voted that this is a much cleaner approach and hence built it.

How did we solve:
Hoptracker:
The hoptracker plugin which still is a rack app, on receipt of an error just notifies softwire of the error.

Softwire:
Each app as part of using the hoptracker plugin, needs to first register with softwire and provide app related (hoptoad, pivotal tracker) details. Softwire then produces a unique hash which needs to be provided to the hoptracker initializer in ones app. Please checkout the readme of hoptracker and softwire) for further details or read up part II for a step by step usage of hoptracker/softwire.

Once the above process is done. Softwire maintains a local database of all the hoptoad errors already logged into pivotal tracker. Hence the second step (“Check pivotal tracker for the list of hoptoad errors (we add the hoptoad error id as part of the story/bug name). Any delta that it results in.”) is avoided by looking into the local database of errors and the delta set of errors are built locally. And then the third step of insertion of new errors into pivotal tracker happens.

Checkout Part II for a step by step tutorial in using hoptracker and softwire.

For a recent project we needed to show list of users with some basic information and with multiple select options, just like  facebook friends selector for selecting friends, groups, projects etc…

This is generally a requirement in most of the social networking projects, with minor changes here and there.

So I decided to build a plug-in with some easy configuration options, which should work independent of the type of object to be shown in the list.

It’s a nice FB like user interface to select multiple elements. We can configure it easily by some parameters as described below.

For more information on setup and download click here

<%=  awesome_selector  :objects => @users,
:field_names => ["name","email"],
:form_post_url => users_path,
:template => "template_1",
:auto_complete_field_name => "name",
:image_url => "avatar_photo_url(:thumb)",
:max_selection_limit => [5, 'Sorry, you can not select more users.'] %>

Currently there are two templates available ‘template_1′ and ‘template_2′. An example of the generated list is as follows:

After submitting the form, selected object ids are available as params[:selected_element_ids] separated by comma.

Thanks to the following for their kind contribution to the JS libraries used in this plugin.

Just to save myself copy pasting the whole post, I am posting a link here. Try and let me know your ideas on these tools.