Evoleas @evoleas - Tumblr Blog

Google Drive Integration in iOS Apps

Hey guys, I have been trying to integrate Google Drive in one of my projects, thought about sharing a blog post regarding the same...

So lets get started...

Create a new project / open existing project in XCode.

Clone or Add Submodule the Google API Client Library

Now you need to add GTL.xcodeproj to your project. You will notice the entire project is copied. If not, then close all the projects and only open the project in which you want to integrate Google Drive API

Now, select your project from the Project Navigator, select your Target and go to Build Phases

Now add a new Item libGTLTouchstaticLib.a to the linked binaries. And also add SystemConfiguration.framework and Security.framework

After that you need to do one important thing, that is telling the xcode where to search for the header files. For that we need to add one entry to the "Header Search Paths" in "Build Settings". Now considering that you have saved the Google API Client Library in the Root Directory of your project, add the following line "$SRCROOT/google-api-objectivec-client/Source" and make sure to put a check mark for recursive search for header files.

Now open the Google API Client Library in Finder, and go to the following path "~/Source/Services/Drive/Generated", you will see all the files which we need for GoogleDrive Integration. Note this files are not included in GTL.xcodeproject, thus we need to add them manually to our project.

In your project create one more folder named GoogleDrive or whatever you like, and Add those Google Drive files to your newly created folder.

Similarly you can integrate any other Google Services in your project.

Now #import "GTLFramework.h" and compile it, the build should succeed, incase if it fails check if you have missed something or else I am at your service :)

Once the build is succeeded, in order to proceed further, we need to go Google API Console. Create an App.

Go to Services, switch ON the "Drive API".

Go to API Access and click on "Create an OAuth 2.0 Client ID" and follow the steps.

If all the steps are done successfully, then CHEERS!!! GOOD JOB!!!

In my upcoming post, we will see how to get started with the Google API Client library which we just successfully integrated with our project... Stay tuned :) :)

#Google Drive #iOS #GTL.xcodeproj

MySQL Master-Slave Replication

The advantages of replication:- 1) Offload some queries from one server to other. 2) Use master for all writes and Use slave for all reads. Some basic stuff to remember before we go ahead:- 1. Master and slave installations will be on different server instances. 2. The master should not be in use during the installation process (if master is already present). 1) Setup Master server:-

install MySQL Server sudo apt-get install mysql-server

after installation, Configure it to make this as Master server. Edit

/etc/mysql/my.cnf

MySQL should listen to all IP Addresses, so we comment out the following lines:

#skip-networking #bind-address = 127.0.0.1

Set unique server ID

server-id=1

Enable binary logging

log-bin = /var/log/mysql/mysql-bin.log

Restart MySQL by using the command

sudo service mysql restart

mysql -u root -p

Create a replication user:Its recommended to create a separate user for mysql replication to which slaves can authenticate. Slaves will be connecting to the master using this user’s credentials.

GRANT REPLICATION SLAVE ON *.* TO 'slaveuser'@'%' IDENTIFIED BY '<a_real_password>'; FLUSH PRIVILEGES; FLUSH TABLES WITH READ LOCK; SHOW MASTER STATUS;

After running the above command, you should be able to see binary log position

+------------------+----------+--------------+------------------+ | File | Position | Binlog_Do_DB | Binlog_Ignore_DB | +------------------+----------+--------------+------------------+ | mysql-bin.000001 | 107 | | | +------------------+----------+--------------+------------------+

Write down the position, this would be needed later. Note: If you already have a master setup with data, dump the data so that it can be imported to the slave for the data to be in sync. Leave the shell.

quit;

2) Setup Slave server:-

install MySQL Server sudo apt-get install mysql-server

after installation, Configure it to make this as slave server. Edit

/etc/mysql/my.cnf

Set unique server ID

Server-id=2

Restart MySQL by using the command

sudo service mysql restart

Use below command to load the initial data from master

mysql -u root -p<password> database_name < /path/to/masterdump.sql

mysql -u root -p

We need to inform our slave server the details of master server like host name, replication username and password, etc. Other things that slave server need is master log file name and log position, which we have obtained by entering show master status on master server. Now we can connect slave with the master by issuing the following command

CHANGE MASTER TO MASTER_HOST = '<host_name>', MASTER_USER ='slaveuser', MASTER_PASSWORD='<a_real_password>', MASTER_LOG_FILE = 'mysql-bin.000001', MASTER_LOG_POS =107;

Finally, start the slave

START SLAVE; SHOW SLAVE STATUS\G; quit;

Now in the master host run the following command to release the lock

mysql> UNLOCK TABLES;

And now, each write to the master gets instantly replicated on the slave as well.

#Ruby on Rails #MySQl #Master-Slave

Provisioning Profile

After submitting and paying for your iOS Developer registration, you’ll need to wait a day or so for Apple to process your order. If you had to fax your information to Apple because you’re in a country without an online Apple Store, you’ll need a little more patience. In either case, eventually you should get an email from Apple like this one: At the same time, you should receive this email: Now go to the iOS Dev Center and click “Log In”: The two portals that you’ll use a lot when developing your apps, the iOS Provisioning Portal and iTunes Connect:

iOS Provisioning Portal

As we should all know, a non-jailbroken iOS device is only able to run apps approved by Apple and installed through the App Store. Apple achieves this by requiring that every app run by iOS have a signed Apple Certificate. Apps installed from the App Store come bundled with a certificate, which the system verifies before it allows the app to run. If there’s no signature or if the signature is invalid, the app won’t run. As developers, we need to be able to run our apps on our devices on a regular basis as we’re developing them. For this we need a way to create and sign our own certificates. That’s where the iOS Provisioning Portal comes in. The portal allows you to generate what Apple calls “profiles.” Profiles, sometimes called “code signing identities,” are files generated by the portal that allow Xcode to sign your apps in a way that your devices’ iOS will identify as valid. There are two types of profiles:

Development profiles. These are tied to specific devices, so the app can only run on those devices.

Distribution profiles. These are used to sign your app before you submit it to Apple for approval. They contain no device-specific information, but you can’t use them to install apps on any device yourself, because Apple still has to sign the app after the approval process.

The Provisioning Portal can also generate push certificates in case your app wants to send push.

iTunes Connect

iTunes Connect is the portal you’ll use to submit your apps. This is where you’ll register a new app, enter the app’s description and screenshots, choose the price, and configure game center and in-app purchases. This is also the portal you’ll use to agree to new contracts, set your financial data (so you can bank that profit) and check your sales.

Certificates, Device Registration, and Profiles

Here we’re going to use the iOS Provisioning Portal to set up the information we need in order to deploy our app to our device (and later the App Store). (Note that there is a simpler way to do this in Xcode called Automatic Device provisioning). If you still have your iOS Dev Center page in front of you, just click the link on the upper right, or go here: There are a lot of things you’ll need to do from this portal. Some of them you’ll only have to do once, like generating your certificates and registering your devices. Other things you’ll have to repeat for every app you make, like generating development and distribution profiles. First you’ll need to generate two certificates, one for your development profiles and another for your distribution profiles. Let’s click on the “Certificates” link to get our certificates: Click “Request Certificate”: The next page explains how to ask for a certificate. Let’s leave the browser for a little while and open the Keychain Access app on your Mac. If you don’t know where it is, search for it using Spotlight: Once the program is open, from under the Keychain Access menu choose “Certificate Assistant,” then “Request a Certificate From a Certificate Authority…”: In the Certificate Assistant window, fill in your email address and name, choose “Save to disk” and click “Continue”: Save the file somewhere on your Mac. Go back to your browser, find this file using the “Choose file” button and click “Submit”: Apple will take some time to generate a certificate for you. Sometimes it takes a few minutes, but sometimes it can take a lot longer. While we wait (the status might say “Issued,” but the certificate isn’t actually ready until a download button appears), let’s do something else we need to do anyway. You should see a message at the bottom of the “Current Development Certificates” section that says, “If you do not have the WWDR intermediate certificate installed, click here to download now.” Click that link. This will download a file called AppleWWDRCA.cer. Double-click this file to install it. It will open Keychain Access again in case you closed it. Once the file is installed, keep Keychain Access open because we’ll need it again in a few minutes. You’ll also need a distribution certificate. Click the “Distribution” tab and submit the same certificate signing request as for the development certificate. Reusing the same certificate signing request in this case can be done. Again, it sometimes takes a while for the certificate to become available for download. Once both are ready, click the “Download” button under the Development and Distribution tabs to get both certificates. Double-click both files to install them in your keychain. You should see your certificates as follows: Now you can close Keychain Access. Adding Devices Let’s continue. The next step is to register our devices. On the left-side menu, click “Devices” and then on the right, “Add Devices”: You need to get the UDID of the device(s) you want to use to run your apps. There are many ways to get a device’s UDID: there are free apps available that will do it for you, or you can use Xcode’s organizer. We’ll show you how to get a UDID using iTunes. Open iTunes and plug the device into your computer. Select the device from the left-side menu. iTunes will display your device name, capacity, version, serial number and phone number. Click on the serial number and it will change to your device’s UDID: Now just use CMD-C to copy the UDID to your clipboard. Go back to your browser, enter a device name and paste the UDID into the appropriate field. The device name can be anything you want. To register additional devices, click the “+” button. When you’re done, click “Submit.” Apple allows you to register up to 100 devices per year to your account. (Note that if you register a device and later remove it, it still counts towards your total for the year.) Now that our device is registered, we need to register an app ID. Every app you build will need its own app ID. Click “App IDs” on the left-side menu: You’ll see a detailed explanation of the app ID concept. In a nutshell, an app ID is a combination of a 10-character “seed” prefix generated by Apple, and a bundle ID created by you. Together they create a unique identifier for your app. Here are some important things to know about app IDs:

You can elect to have all of your apps share the same seed prefix, if you want to share keychain information between them. Say you have a suite of apps that all make use of the same website via a login. If the apps share the same seed prefix, and one app saves the user’s login information to the iOS keychain, any other app in the suite can get this login information from the keychain.

The bundle ID has to be unique for each of your apps. It will be used by Apple’s push service for in-app purchases and for iCloud storage.

Apple recommends that you use “a reverse-domain name style string” for the Bundle Identifier portion of the app ID. The suggested format is “com.domainname.applicationname.”

Apple does allow you to use an asterisk character to create a “wildcard” bundle ID that can be used across all your apps, but I don’t recommend this approach.

Using a wildcard may make it easier to create provisioning profiles, but you won’t be able to use push services or in-app purchases. You might not plan to use these services now, but if you change your mind, you won’t be able to change your app ID without creating a new app. Now that you know all about app IDs, let’s create one. Click “New App ID.” Fill out the description (usually just your app’s name) and the bundle identifier. The seed ID will always be your team seed ID. (In the past there was a way to have more than one seed ID, but this seems to have been disabled.) Remember to use a reverse-domain name style string for your bundle ID. Click “Submit” when done: Now we’re ready for the last step (for now) inside the Provisioning Portal: creating the provisioning and distribution profiles. Click “Provisioning” on the left-side menu and “New Profile” on the right: Fill in your app’s name as the profile name, select the certificate, choose the app ID you just created, and finally select the devices you want to use to test your app. Click “Submit”: When you return to this page, the status of your profile will be “Pending” as Apple generates the file for you. Usually if you just click the “Development” tab again, you’ll see your status has already changed to “Active” and a “Download” button has appeared. Your provisioning profile should be ready. Go to the “Development” tab, click “Download” and save the file to your computer. Do the same for your distribution profile by clicking the “Distribution” tab and clicking “Download.” Now find the files you just downloaded on your computer, and double-click them. They should open in Xcode’s organizer: Generate the distribution profile We won’t actually need the distribution profile until we’re ready to submit the app for approval, but since we’re here, let’s do it now. Click the “Distribution” tab at the top of the page and click “New Profile.” Choose “App Store” as the distribution method, enter a profile name (can’t be the same name you used in the development profile), choose your app ID and click “Submit.” You can learn more about Ad Hoc distribution here and here. How to export Certificates in .p12 format Make sure you have selected My Certificates in the left pane of Keychain access. Then select your certificate and export the certificate as a .p12 file. You'll be asked to give it a password that your developer will have to use to install it. Then you can just send the generated .p12 to another system and it will work because it can detect the matching private key in his Keychain. Note: If you don’t get the export option when you right click on your certificate, then try the following steps- 1. First revoke the current certificate in the Revisioning Portal. 2. Then go to the Certificate Assistant in the menu of Keychain Access and select Request a Certificate From a Certificate Authority. There you need to type your name and email address and let it save the file to disk. 3. Next go back into the Revisioning Portal to create a new Certificate and use the certificate request file that was just created. 4. After that download the new certificate and open it up in Keychain Access where it appears with a private key attached to it so then when you select to export the certificate you could finally select the P12 format.

#ios #Provisioning Profile #Apple

Developer Account

In order to build iOS applications and later upload them on App store for others to download, one must enroll in the Apple developer program. On enrolling, the person becomes the team agent for the team. During this step, the team agent signs the legal agreement required to become an Apple developer and prepares the financial paperwork so that the team can be paid for purchases from the App Store. The team agent is special; he or she has unrestricted access to the team and is legally responsible for the team. The team agent also performs most of the tasks to organize the team. If desired, after others have joined the team, the team agent can delegate some of this authority to other members of the team, allowing those others to perform these tasks instead. The team agent might need to sign updated or new licensing agreements, particularly when the team wants to incorporate specific technologies into an app. For example, an app that uses the iAd service requires your team agent to sign a separate agreement. This document is to guide you to enroll for Apple’s developer program.

Step 1:

Click here to go to the following page on your browser. Click “Enroll Now”.

Step 2:

Go through the points on the next page and click “Continue”

Step 3:

Choose between a New Apple Developer or an Existing Apple Developer and Click “Continue”.

Step 4:

Select either “Individual” or “Company” option. Note: You can change from "Individual" to "Company" option later but not vice versa.

Step 5:

Enter your email address and Password. Fill all other details and click "Continue".

Step 6:

Choose suitable options.

Step 7:

Select the check box and click on “I Agree” to proceed. (Do read the agreement though ;) )

Step 8:

You will get the verification code in the email address you entered above. Enter that code and click "Continue".

Step 9:

Once the code is verified there will be a confirmation screen. Following this will be a screen to setup billing information.

Step 10:

Select iOS Developer Program and then "Continue".

Step 11:

Review all information then click "Continue".

Step 12:

Confirm purchase of one iOS Developer Program then proceed to checkout.

Step 13:

When signing up for multiple accounts you will probably have to log in again with each new account to proceed.

Step 14:

Complete delivery information (this is digital but Apple still requires for tax).

Step 15:

Complete credit card and billing information then "Continue"

Step 16:

On the following screen confirm all information then click "Place Order Now".

Step 17:

This is the screen you should get on a successful Sign up.

#ios #apple

The Work in Progress Report in Pivotal Tracker

Hey Guys

I thought I'd share this with you!

[caption id="attachment_219" align="alignnone" width="510" caption="Work in Progress Report - Pivotal Tracker"][/caption]

here you can see attached a very interesting report from pivotal tracker: the work in progress report. Here we can see several things, over time, which I want to share with you:

the height of the bars indicate the scope. We can see how the scope is growing over time, as new stories get added, and estimated

all the stuff that is between the light blue on the top, and the dark blue on the bottom is 'work in progress', i.e. stuff that is started, but not accepted.

the goal is to minimize the work in progress (WIP), for technical reasons that I won't explain here, but it can be proven that the less WIP, the faster you can develop (its a bit like the more you try to do at the same time, the less you will get done!) If you want to know more, search for Lean Development and Cumulative Flow Diagrams.

we can also see nicely here that the bottleneck is the yellow stuff: a lot of stories always spend time in the yellow state, which is finished, but not yet delivered. In particular, this is the QA bottleneck that we have been facing. Concretely, we had a) too much to be done manually by the QA (no test automation yet) and b) the site was slow, therefore it took a long time to do QA on it.

A quick look at a chart like this allows us to identify bottlenecks. Ideally, the capacity between 'work generation' (BA), development (Dev), delivery (QA) and acceptance (BA) as well as rework and rejections (dev) is matched, so that 'the thing that needs to work on' is not wasting time sitting around, but is getting done / worked on as it traverses from stage to stage. This would be evident if all the different phases of WIP were approximately similarly in size.

Feel free to experiment with WIP Reports in PT for your own projects, and see if you can identify bottlenecks!

Having said that, there is something called a 'cumulative flow diagram', which is basically the same report, but 'upside down', so that the "done stuff" is at the bottom, while the "new stuff" is being added at the top. The advantage of that is that you can easily graphically inspect cycle time. I wish Pivotal Tracker would change the chart, maybe they will in the future!

Either way, regularly checking the WIP Report will help you keep an eye on the big picture of the different stages of your development, and prompt you to make corrective actions where required. Enjoy!

#Pivotal Tracker #reports #Agile

Titanium : Passing parameters between windows [How to make things global]

While working on any titanium application, one of the common possibilities is to use some variables/constants across the windows. In Titanium, windows use to have their on context. That means the variables/values available on one window are not available on the others linked windows by default. So, if we are required to pass parameters between windows, there are many different ways to achieve this. So, choosing a perfect approach for passing variables/parameters within windows depends on the requirement we are having. In our last project we had used few different approaches as per our requirements. Few of them are : Ti.App.Properties:

There are few cases where we need to store values to be used everywhere in the application, and we want to retain those values even when application is not-running/ in-background. The App Properties module is used for storing application related property/value pairs which persist beyond application sessions.

We can set the property/value pair as:

Titanium.App.Properties.setString("my_prop","cool");

Now, as property/value pair is set. Now I can simply retrieve that value where I want in the application as:

var value = Titanium.App.Properties.getString("my_prop");

While setting properties in Ti.App.Properties, we have to make sure few things:

>> we are actually making things globally available, means whatever values we are storing, should not conflict with already existing global titanium constants, otherwise functionality will suffer. For more information, check Titanium documentation at Titanium.App.Properties Ti.App:

There are cases, when we need few values to be available all over the application, but when we close the application, those values should not be available any-more. For example, while working on an application I need to access the current locale for the device for different purposes. But when I closes the application, I don't need that value to persist as use can change the locale in-between as well. So better to make request to get these kind of values when app initializes and persist those values throughout the application session.

We can declare methods and variables to be globally available with Ti.App as:

Ti.App.sample_variable = "xxxxxx";

Ti.App.sample_function = function(_args){ //your code for the function };

Then we can use this variable/method anywhere in our application. It will be available in the application session.

App Level Global Declaration:

For past weeks I was wondering about what are the best ways of writing titanium javascript code to make it more generic, reusable and more modular. Tweetanium, the sample application build by titanium/appcelerator team to help people, posses a new approach for design/creation of titanium based applications. Approach is to maintain an Application Level NAMESPACE and write each and every single peace of code wither to that namespace or sub-namespaces to that. e.g.

In app.js of your application,

//app.js

//suppose name of my application is sample, so defining the global namespace or placeholder for my application

var sample = {};

Now I can define my UI, models, controllers methods and variables in the corresponding namespace or placeholder to make them more structured. As,

sample.UI = {};

Now if I want to declare any method or variables, I can place them in corresponding files and assign all the methods/ variables to their parent placeholder.

//UI.js

(function(){

sample.UI.xxxx = function(_args){

//write you code you want to use.

};

})();

For knowing more about how to write MVC structure applications with titanium, stay tuned, as I will be back soon with one more blog post for the same

Passing parameters within successive windows:

If we just need to pass parameters/values between 2 successive windows, then it can be done via sending values as a part of window object it self. Like. for example I'm working on a map related stuff and when I click on a button which leads me to the next window which shows some data corresponds to my geolocation position. Then while creating the window element we can pass those values as part of window object itself. As:

## window1.js

.........

var button = Ti.UI.createButton({

label: "button1",

height: "20dp",

width: "100dp"

});

button.addEventListener("touchstart", function(){

var window2 = Ti.UI.createWindow({url:"window2.js"});

window2.sample_value = "xxxxxx";

Ti.UI.currentTab.open(window2, {animated:true});

});

##windows2.js

var window = Ti.UI.currentWindow;

Ti.API.info(window.sample_value);

//this will return "xxxxxx" as a values;

These are the few ways of passing variables globally which I used till now. For any query Contact me anytime, or reply back.

#Titanium #cross-platform #appcelarator #android #ios

How to make your application work for both MySQL and PostgreSQL?

I am using rails 3 and ruby 1.9.2 in my application. For development environment, I am using MySQL and for staging environment, I am using PostgreSQL Database. After hosting, we have faced some issues. 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!

#rails #mysql #postgres #ruby

Dasboard (the company around you)

Yes, what if you can have an overview of your entire company and every employee. Dasboard brings you the best of both the worlds- the statistics of the company and a perfect UI to give you the finest User Experience. 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

#Dasboard #Evoleas #agile

The real romance is out ahead and yet to come. The computer revolution hasn’t started yet. Don’t be misled by the enormous flow of money into bad, defacto and poor adaptations of incomplete ideas.

RabbitMQ and Rails. Why my chat application failed.

Over the last few weeks I've been playing with RabbitMQ and Rails have been completely blown away by how awesome it is. 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 RabbitMQon 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.

#RabbitMQ #Rails #AMQP

Incompatible character encodings error in ruby 1.9

Problem: Incompatible character encodings error while importing csv files in ruby 1.9 which have data in multiple languages.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.

#ruby #Rails

Passing parameters to HTML page loaded in a webView

I have been working on Titanium for last few days. As a web developer I found it very interesting to develop an iphone and Android app without knowing objectiveC or Java. One of the problem I faced was to pass parameter to HTML page loaded in a webView. In this post I will show how to make javascript variable accessible to HTML page opened in a webView. 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>

#Titanium #appcelarator #cross platform

Tips for faster loading web sites(Optimizing page load time)

1) Make fewer HTTP request(Js, CSS & image) Most of the end-user response time is spent on the front-end and tied up in downloading all the components in the page like images, stylesheets, scripts, etc. Reducing the number of components in turn reduces the number of HTTP requests. a) Combined files => its a way to reduce the number of HTTP requests by combining all files into a single file. ex: js & css In our rails app, we used bundle_fu(https://github.com/timcharper/bundle-fu). Its used to bundle all your assets very easy. It can speed your load time up around 50%. Example put the following around your stylesheets/javascripts: -bundle :name => "default_bundle" do = javascript_include_tag "http://w.sharethis.com/button/buttons.js" = stylesheet_link_tag 'jquery-ui', 'auto_complete/token-input.css' = javascript_include_tag 'jquery-1.4.2.js', 'jquery-ui.js', 'auto_complete/jquery.tokeninput.js', 'auto_complete/setup.js', 'underscore.js', 'date.js', 'cal.js', 'application.js', 'time_picker/jquery.timePicker.js', 'ajax_pagination.js' = stylesheet_link_tag 'compiled/certification.css','compiled/error.css', 'compiled/elements.css', 'compiled/messages.css', 'compiled/calendar.css', 'compiled/common.css', 'time_picker/timePicker.css', :media => 'screen, projection' = stylesheet_link_tag 'compiled/print.css', :media => 'print' = javascript_include_tag "markerCluster/jsapi", "markerCluster/map.js", "markerCluster/markerclusterer.js", "jquery-jtemplates" b) CSS sprites => Its used to reducing the number of image requests. Combine your background images into a single image and use the CSS background-image and background-position properties to display the desired image segment. 2) Avoid empty src or href You may expect a browser to do nothing. But most browsers makes a request to server(sending a large amount of unexpected traffic). 3) Compress components with gzip This is used to reduce their file size over the wire by approximately 70%. This can be set up using your Apache(needs Apache 2, mod_deflate, mod_headers and access to server config) or Nginx config. example for apache(in the server config file): # Compress some text file types AddOutputFilterByType DEFLATE text/html text/css text/xml application/x-javascript # Deactivate compression for buggy browsers BrowserMatch ^Mozilla/4 gzip-only-text/html BrowserMatch ^Mozilla/4\.0[678] no-gzip BrowserMatch \bMSIE !no-gzip !gzip-only-text/html # Set header information for proxies Header append Vary User-Agent 4) Add expires headers for JS & CSS There are two aspects to this rule: a) For static components : implement "Never expire" policy by setting far future Expires header b) For dynamic components: use an appropriate Cache-Control header to help the browser with conditional requests This means that A first-time visitor to your page may have to make several HTTP requests, but by using the Expires header you make those components cacheable. The next request, Browser use a cache to reduce the number and size of HTTP requests, making web pages load faster. A web server uses the Expires header in the HTTP response to tell the client how long a component can be cached. However, it creates an additional problem too. The problem is what happens if you change these files? The browser will be stuck with the old files. The solution is to send a last modified timestamp with your requests (Ex: "<img src='/images/rails.png?84392578943' />"). Now your browser will know to ask for the file again. The "timestamp" is the default behavior of rails. 5) Put CSS at top Yahoo discovered that moving stylesheets to the document HEAD makes pages appear to be loading faster. This is because putting stylesheets in the HEAD allows the page to render progressively. 6) Minify JS & CSS Minification is the practice of removing unnecessary characters from code like comments and unneeded white space characters (space, newline, tab and etc). This improves response time performance & load times. You can use JSMin and YUI Compressor for minifying your JS code. Also some plugins are there, please check it here: https://github.com/sinefunc/sinatra-minify and https://github.com/ericbarnes/ci-minify. please check the screenshot. Right now, as you can see, I have made it Yslow grade from "F" to "B" very easily. I am sure, we can easily get grade "A" too... We need some support from the server side regarding "Add expires header" and "Use Cookie-free Domains for Components". I have requested engineyard(hosting server) for the same. Waiting for the reply from them. By next week, it will turn into grade "A". and also found one good link from rubyquicktips. Benchmark.ms is very nice. its used to track how long some bit of code takes to process. please check it here: http://rubyquicktips.tumblr.com/post/2838217166/benchmark-ms-rails-you-sneaky-devil Before optimization: After optimization:

#jquery #performance

Hoptracker - Part II

Part II 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 [email protected]: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!

#Hoptracker #hoptoad

Hoptracker - Move your hoptoad errors to pivotal tracker

Part I 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.

#Hoptracker #hoptoad #pivotaltracker

Ruby on Rails plugin for Facebook style selector

Awesome Selector (Ruby on Rails plugin)

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.

The features I'd like to highlight are:

FB like user interface.

Word filter.

Templates.

Auto complete.

Effortless integration and easy to customize.

For more information on setup and download click here

You just need to call the helper with required parameters, on the page where you want the list to be displayed

<%= 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:

template_1

template_2

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.

Autocomplete by Tomas Kirda

jquery-filter-plugin by Kent Safranski

#Facebook #Ruby on rails

Suggested tools for DB optimization

In Sapna from long time we have been discussing about the tools we should use for better code and development. Extracted from the same discussion, I have written a post about what tools can be used in development phase to optimize our Rails apps on my blog. 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.

#DB optimization #Ruby on Rails

Trending Blogs

Recently Viewed Blogs

Evoleas