Gaurish Sharma Live | Sharing What I Have Learned

Evaluation of iPaaS

Gaurish Sharma — Thu, 07 Sep 2023 00:00:00 +0000

Introduction to iPaaS:

Integration Platform as a Service, or iPaaS, is a suite of cloud services that enables users to create, manage, and govern integration flows connecting a range of applications and data sources. It’s designed to streamline connectivity and ensure seamless data transfer across multiple systems, devices, and environments. As businesses increasingly move to the cloud and adopt Software as a Service (SaaS) applications, the need for iPaaS solutions to bridge the gaps between these systems becomes paramount.

Evaluation:

MuleSoft

Features:

Offers Anypoint Platform that connects apps, data, and devices across on-premises and cloud computing environments. Powerful API-led connectivity approach. DataWeave, a transformation language and framework. Anypoint Exchange, a library for reusable IT assets. Support for microservices architecture. Maturity: Acquired by Salesforce in 2018, MuleSoft has a rich history and has been a leader in the industry for over a decade. Architecture:

Uses a hybrid approach, allowing integrations in both cloud and on-premises systems. API-centric architecture promoting reusable components. AI Capabilities:

Offers Anypoint Monitoring, which provides advanced insights through machine learning. Other Observations:

Integration with Salesforce makes it a preferable option for businesses already using Salesforce. Relatively steeper learning curve for new users. Dell Boomi

Features: AtomSphere platform for cloud-to-cloud, SaaS-to-SaaS, cloud-to-on-premises, on-premises-to-on-premises and B2B integration. Boomi Flow for workflow automation and app development. Master Data Hub to ensure data integrity. Maturity: Established in 2000 and acquired by Dell in 2010, it has a longstanding presence in the market. Architecture: Atom-based architecture, where “Atoms” are runtime engines and can be deployed in multiple environments. AI Capabilities: Boomi’s Insight feature provides AI-driven recommendations to assist users in building integration processes. Other Observations: Has a user-friendly drag-and-drop interface. Strong community and a vast library of pre-built connectors.

Workato

Features: Recipe-based approach, where integrations are designed as recipes. Offers a marketplace of prebuilt connectors and integration solutions. Workflow automation with support for multiple business apps. Maturity: Founded in 2013, it’s younger than the others but has quickly gained traction. Architecture: Cloud-native platform but can connect with on-premises applications through on-prem agents. AI Capabilities: Offers Workbot, an AI-driven bot that integrates with chat platforms like Slack and Microsoft Teams. Automation recipes leverage machine learning for data mapping and transformation. Other Observations: Known for its simplicity and agility. Widely adopted by businesses for its ease of use and quick time-to-value. Observations & Recommendations:

Complexity and Learning Curve: MuleSoft, though powerful, can be complex and may require more time to onboard. Workato, on the other hand, is known for its ease of use and quick integration setups.

Architecture Fit: Dell Boomi’s Atom-based architecture is versatile and can be a good fit for complex hybrid setups. Businesses purely focusing on cloud might find Workato more aligned with their needs.

AI Capabilities: All three platforms are integrating AI in their offerings, but the way they do it varies. Workato’s Workbot and AI-driven automation recipes stand out in terms of direct business application.

Integration Needs: If a business is already using Salesforce or is planning to, MuleSoft might be a natural choice due to its tight integration. Dell Boomi and Workato offer a broad spectrum of connectors which makes them suitable for various integration scenarios.

**Conclusion: **The best iPaaS solution largely depends on the specific needs and preferences of the enterprise. It’s essential to analyze the existing IT landscape, integration requirements, and future scalability before making a decision.

Using Python to Establish SSL/TLS Encrypted Connections to AWS RDS MySQL 5.7

Gaurish Sharma — Sun, 26 Mar 2023 21:54:00 +0000

Are you trying to connect to your AWS RDS MySQL database using Python? If so, you might encounter some challenges due to the additional security measures provided by AWS, such as Transport Layer Security (TLS). In this tutorial, we’ll show you how to connect to your AWS RDS MySQL database on Python with TLS enabled.

Why encrypt internal Mysql connections?

In today’s security landscape, enabling encryption at all layers of an application is of utmost importance. This means that sensitive information should be encrypted in transit as well as at rest. Furthermore, it is crucial to adopt a “zero trust” approach to application security. This approach means that access to resources should not be granted based solely on the user’s network location or credentials. Instead, all requests for access should be authenticated and authorized before any access is granted. This strategy helps prevent unauthorized access, reduces the risk of data breaches, and enhances overall security posture.

Prerequisites

Before we start, make sure that you have the following:

An AWS RDS MySQL database instance
Python 3.x installed on your local machine
mysql-connector-python package installed on your local machine
IAM user credentials with access to your AWS RDS instance

Enable TLS in AWS RDS

Before we can connect to our AWS RDS MySQL database with TLS enabled, we need to configure our database instance to use SSL/TLS encryption. To do this, follow these steps:

Log in to your AWS Management Console.
Navigate to the RDS service.
Select your MySQL instance.
Click on the “Modify” button.
Under “Advanced Settings,” find the “SSL/TLS” option.
Set the “SSL/TLS” option to “Enabled.”
Click on the “Continue” button and apply the changes.

Once you’ve completed these steps, your AWS RDS MySQL instance will be configured to use SSL/TLS encryption.

Connect to AWS RDS MySQL on Python with TLS

To connect to our AWS RDS MySQL database on Python with TLS enabled, we need to use the mysql-connector-python package, which can be installed via pip:

pip install mysql-connector-python

Next, we need to create a Python script that connects to our AWS RDS MySQL database. Here’s an example script that you can use:

Replace the placeholders (<db_username>, <db_password>, <db_endpoint>, <db_name>) with your own values. Python code snippet above demonstrates how to establish a secure TLS connection to an Amazon Web Services (AWS) Relational Database Service (RDS) instance running MySQL 5.7. The code makes use of the ssl and mysql-connector-python libraries to establish the secure connection.

The code begins by importing the necessary libraries and defining the credentials and endpoint of the AWS RDS instance to which the secure connection needs to be established. The next step is specifying the path to trusted CA certificates that will be used to verify the server’s identity. This trusted CA certificate is provided by AWS RDS on their documentation page.

Once the SSL context has been created, the mysql-connector-python library is used to create a connection object that uses the SSL context to establish a secure connection to the AWS RDS instance. The code then prints the version of the MySQL server that it has connected to, which serves as a confirmation that the secure connection has been established successfully.

Documentation Links

Hope this helps!

Use AWS CLI With Multiple Accounts and MFA

Gaurish Sharma — Sun, 17 Dec 2017 00:00:00 +0000

Hello Readers, I am back to blogging after gap of years. This is part of my new year resolution of executing on the my original vision for this blog - “Sharing what I have learned”. Can’t believe its been a decade. However, this new year will give me fresh vigor to restart blogging.

Back to Topic, The Use-Case that I would be explaining today makes following assumtions:

You have multiple AWS Accounts - These days, most compnaies follow AWS Multiple Account Security Strategy where they have seperate accounts their development and production resources with Cross-Account access . In addition, at some people will create seperate a “Jump AWS Account” where only IAM is configured in Jump account & for every other purpose, the users are expected to login to different AWS account(development AWS account, Production AWS Account etc).
Multi-Factor Authentication(MFA) is required - AWS Multi-Factor Authentication (MFA) is a security best practice that adds an extra layer of protection on top of your user name and password. In this case, cross-account access is protected using MFA. With MFA enabled, when a user signs in to an AWS website, they will be prompted for their user name and password (the first factor—what they know), as well as for an authentication code from their AWS MFA device (the second factor—what they have).
CrossAccount Assume Role between Development & Production Account is setup on AWS web Console. You are able to login to “Jump AWS Account” which could be a seperate account or same as your development acccount. From this “Jump AWS Account”, We assume you are able to Jump to production aws account from AWS Web Console using “Switch Role” feature.

If the above three are already given then please continue. In later tutorials, I might talk about how to setup multiple AWS accounts with Cross Account Access along with MFA but that’s a seperate tutorial. For now we will assume that you already have that work. If not, please stop & first complete the step #1, #2, and #3.

Goal - Setup AWS CLI for Multiple AWS Accounts with Cross Account Access along with MFA

The AWS Command Line Interface (CLI) is a python cased CLI application that allows you to manage your AWS services., same way as AWS Web console. But where the AWS CLI really shines is that you can use it to control multiple AWS services from the command line and automate them through scripts. Automatition is hard to do from Web console but its easy to write a shell script that automates routine tasks like launching a new instances, searching given IP address belongs to which instances.

Our goal for this tutorial is going to be that you are able to have cross access to Development, Production or any other aws account you may have using single Access Key ID, Access Key Secret & MFA Token devise that is registered on your “Jump AWS Account” using AWS Security Token Service (STS)’s Assume-Role feature.

Step 1 - Configure Secret Key & Secret ID 🔑

Download & install AWS CLI as documented on AWS CLI Website, for Linux/Mac, its as simple as $ pip install awscli. Next we will configure AWS CLI with Access Key ID, & Access Key Secret from “Jump AWS Account”. Please login to your “Jump AWS Account”, got IAM & generate Access Key ID, & Access Key Secret if you haven’t already done . Once you have them, please run aws configure & set them in on your machine.

$ aws configure
AWS Access Key ID [None]: AKIAJE2IKK4QQPJWD9TT
AWS Secret Access Key [None]: ilNxOf7JK7VIopEov35+ne/cPWApNZyQtO3hRGHH
Default region name [None]: us-east-1 #your fav region
Default output format [None]: 

Based on this, AWS CLI will create two files: ~/.aws/credentials & ~/.aws/config. they should look like this:

$ cat ~/.aws/config

[default]
region = us-east-1
output = text

$ cat ~/.aws/credentials

[default]
aws_access_key_id = AKIAJE2IKK4QQPJWD9TT
aws_secret_access_key = ilNxOf7JK7VIopEov35+ne/cPWApNZyQtO3hRGHH

To confirm, everything is setup correctly. Let fetch the user using the secret key id & Secret access key, it should return info similar to shown below:

❯ aws iam get-user --profile gaurish
{
    "User": {
        "Path": "/",
        "UserName": "gaurish",
        "UserId": "AIWAJLPBAQHB8EH75KFDI",
        "Arn": "arn:aws:iam::111111111111:user/gaurish",
        "CreateDate": "2017-12-10T07:12:04Z",
        "PasswordLastUsed": "2017-12-17T08:59:02Z"
    }
}

If you do not get above output then, the AWS Access Key ID & AWS Secret Access Key are incorrectly setup in Setup #1. Please verify & try again.

Setup 2 - Get MFA device details

Next step, is to get MFA device serial Number as shown below:

❯ aws iam list-mfa-devices
{
    "MFADevices": [
        {
            "UserName": "gaurish",
            "SerialNumber": "arn:aws:iam::111111111111:mfa/gaurish",
            "EnableDate": "2017-12-17T09:59:02Z"
        }
    ]
}

However, if you get output similar to given below:

$ aws iam list-mfa-devices
{
    "MFADevices": []
}

Then you hasn’t configured MFA which you should do as per the doc

Step 3 - Get Role ARN

An IAM role is a authorization tool that lets a user gain additional permissions, or get permission to perform actions in a different account.So idea here is that you create a Role in your target account, say in Production account which users in your “AWS Jump Account” can assume . You will have to create this Role in your production account, if not already done.More information can be found in Assume-Role Documentation .

From Step 3, you should have have role arn which will be somewhat like this:arn:aws:iam::222222222222:role/JumpAccountDeveloperAccess

Step 4 - Set Role ARN & MFA in AWS CLI

The role arn of production aws account we have from #3 is arn:aws:iam::222222222222:role/JumpAccountDeveloperAccess & MFA serial number from step #2 is arn:aws:iam::111111111111:mfa/gaurish. Now all we got to do set these in ~/.aws/config for production profile, then we will be able to access production using credentials “AWS Jump Account”. this is how the config will look after edits:

[default]
region = us-east-1
output = text
[profile production]
mfa_serial = arn:aws:iam::111111111111:mfa/gaurish@gmail.com
role_arn = arn:aws:iam::222222222222:role/JumpAccountDeveloperAccess
region = us-east-1
source_profile = default

Now, let’s try to see user logged into details:

$ aws sts get-caller-identity --profile production
Enter MFA code:
{
    "UserId": "AROBJE5V62ESHW3JBJO5M:AWS-CLI-session-1513512076",
    "Account": "222222222222",
    "Arn": "arn:aws:sts::222222222222:assumed-role/JumpAccountDeveloperAccess/AWS-CLI-session-1513512076"
}

The first time we do this we will be prompted for our MFA code. By default, it won’t have to be re-entered for 1 hour. However, if we execute commands for a different account, we will be asked to enter our code again. Further, instead of --profile production on every call which gets tiring, you can just export export AWS_PROFILE=production & then all subsequent calls will use production profile.

$ aws sts get-caller-identity
{
    "UserId": "AROBJE5V62ESHW3JBJO5M:AWS-CLI-session-1513512076",
    "Account": "222222222222",
    "Arn": "arn:aws:sts::222222222222:assumed-role/JumpAccountDeveloperAccess/AWS-CLI-session-1513512076"
}

to switch back, you can export AWS_PROFILE=default,

$ aws sts get-caller-identity
{
    "UserId": "AIDAJFFF4RORRWDXZDVSG:AWS-CLI-session-1513512166",
    "Account": "111111111111",
    "Arn": "arn:aws:sts::111111111111:assumed-role/JumpAccountDeveloperAccess/AWS-CLI-session-1513512166"
}

If you have gotten this far, then you have completed the tutorial. with this, Command line scripts that now you can write can easily be used in batch files or scripts, which is great for automation. now, think of all the common operations you have to do on AWS Web Console& automate them via AWS CLI.

More Power to you!

Guide for Using ARel in Rails Where ActiveRecord Doesn't Cut It

Gaurish Sharma — Sun, 27 Sep 2015 00:00:00 +0000

ARel is a database agnostic library that ActiveRecord record uses under the covers. It can be used to generate advanced SQL queries.

ActiveRecord Public API

ActiveRecord handles majority of the use-cases pretty well. for example, you want to use ActiveRecord for:

Searching for equality

> Post.where title: 'hello'
# SELECT "posts".* FROM "posts"  WHERE "posts"."title" = 'hello'

Searching for NULLs

> Post.where title: nil
# SELECT "posts".* FROM "posts"  WHERE "posts"."title" IS NULL

Searching for either of given values

suppose I want to search where title is ‘hello’ OR ‘hi’ OR ‘howdy’. pass all options as an array works

> Post.where title: ['hello', 'hi', 'howdy']
# SELECT "posts".* FROM "posts"  WHERE "posts"."title" IN ('hello', 'hi', 'howdy')

Searching for either given values or NULLs

Post.where title: ['hello', 'hi', 'howdy', nil]
# SELECT "posts".* FROM "posts"  WHERE (("posts"."title" IN ('hello', 'hi', 'howdy') OR "posts"."title" IS NULL))

Searching for Range, where values are BETWEEN given starting & end values

suppose I want to search all posts published in last 2months

> Post.where publishing_date: 2.months.ago..Date.today
# SELECT "posts".* FROM "posts"  WHERE ("posts"."publishing_date" BETWEEN '2014-04-09 04:25:23.704466' AND '2014-06-09')

Searching for NOT

Starting Rails 4, ActiveRecord has not which will negate the query, so all of the above queries when appended with not, will work like this:

> Post.where.not(title: 'hello')
# SELECT "posts".* FROM "posts"  WHERE ("posts"."title" != 'hello')

> Post.where.not(title: nil)
# SELECT "posts".* FROM "posts"  WHERE ("posts"."title" IS NOT NULL)

> Post.where.not title: ['hello', 'hi', 'howdy']
# SELECT "posts".* FROM "posts"  WHERE ("posts"."title" NOT IN ('hello', 'hi', 'howdy'))

> Post.where.not title: ['hello', 'hi', 'howdy', nil]
# SELECT "posts".* FROM "posts"  WHERE (NOT (("posts"."title" IN ('hello', 'hi', 'howdy') OR "posts"."title" IS NULL)))

> Post.where.not publishing_date: 2.months.ago..Date.today
# SELECT "posts".* FROM "posts"  WHERE (NOT ("posts"."publishing_date" BETWEEN '2014-04-09 04:58:40.232850' AND '2014-06-09'))

What about queries with that require LIKE, <(less than), >(greator than), <=(less than equal to), >=(greator than equal to) operators?

As you might have guessed ActiveRecord doesn’t support generating queries with above operators, so what you do?

More operators that you might need:

While working with SQL databases, you might feel the need to use the following operators.

LIKE: used when to search a specific pattern
<(less than): Less than
>(greator than): Greater than
<=(less than equal to): Less than or equal
>=(greator than equal to)`: Greater than or equal

But ActiveRecord doesn’t support them. you could use “strings”. But what if your queries need certain amount of conditional in ruby? Enter ARel - ActiverRecord’s private API

Arel methods/predicates that are available for above 5operators

Like: matches
Less than: lt
Greater than: gt
Less than or equal: lteq
Greater than or equal: gteq

To be correct, there are more but they are rarely used.

Before we see each of the methods in details, lets first look on how to install/use ARel gem.

How do I install ARel?

if you are using Rails/ActiveRecord, its already installed & configured! Every ActiveRecord model is backed by an Arel Table. try calling arel_table method on any ActiveRecord model. Object retuned will be instance of Arel::Table as shown in the example below.

> arel = Post.arel_table
 => #<Arel::Table:0x00000101740160 @name="posts", @engine=Post(id: integer, title: string, body: text, publishing_date: date, published: boolean, created_at: datetime, updated_at: datetime), @columns=nil, @aliases=[], @table_alias=nil, @primary_key=nil>

Examples

Match/Like operator

Use this when you want to match a part of the string, so instead of this:

Post.where('title like ?', '%welcome%')
# SELECT "posts".* FROM "posts"  WHERE (title like '%welcome%')

you can do this

Post.where arel[:title].matches('%welcome%') #arel = Post.arel_table

Will skip string examples for brevity’s sake

Less Than Operator - `lt`

Post.where(arel[:created_].lt 1.day.ago).to_sql
"SELECT `posts`.* FROM `posts`  WHERE (`posts`.`created_at` < '2015-09-26 16:19:31')"

Greater Than Operator - `gt`

Post.where(arel[:created_].gt 1.day.ago).to_sql
"SELECT `posts`.* FROM `posts`  WHERE (`posts`.`created_at` > '2015-09-26 16:19:31')"

Less than or equal Operator - `lteq`

Post.where(arel[:created_].lteq 1.day.ago).to_sql
"SELECT `posts`.* FROM `posts`  WHERE (`posts`.`created_at` <= '2015-09-26 16:19:31')"

Greater than or equal Operator - `gteq`

Post.where(arel[:created_].gteq 1.day.ago).to_sql
"SELECT `posts`.* FROM `posts`  WHERE (`posts`.`created_at` >= '2015-09-26 16:19:31')"

Real world Use-Case

Consider the following AR scope

String version

  scope : find_valid_phones_to_whom_we_can_text, -> { where(duplicate: false)
    .where("notification_type = 'mobile' OR notification_type = 'phone' OR notification_type = 'office_phone'")} do
    # fetches only those records whose contact number is valid
    def whitelisted
      # contact number should not start from 800, (800)
      query = []
      # an array of numbers where we don't want to send sms
      BLACKLISTED_NUMBER_PREFIXES.each do |prefix|
        if query.empty?
          query << "(contact NOT LIKE '#{prefix}%' AND contact NOT LIKE '(#{prefix})%')"
        else
          query << "(contact NOT LIKE '#{prefix}%' AND contact NOT LIKE '(#{prefix})%')"
        end
      end
      # contact number should not be more than 10 characters
      query << "NOT length(contact) > 10"

      where(query.join(" AND "))
    end
  end

Arel Version

  scope : find_valid_phones_to_whom_we_can_text, -> { where(duplicate: false)
    .where(notification_type: ['mobile', 'phone', 'office_phone']) } do
    # fetches only those records whose contact number is valid
    def whitelisted
      contact = Notification.arel_table[:contact]
      # contact number should not be more than 10 characters
      has_valid_length = Arel::Nodes::NamedFunction.new('length', [contact]).lteq(10)
      # contact number should not start from 800, 888 etc
      where( contact.does_not_match_any(BLACKLISTED_NUMBER_PREFIXES)
        .and( has_valid_length ))
    end
  end

As you can see above, Arel version reads better.

Wrapping Up

Arel full fledged query generator which generate any SQL query. So question is should you use it?

Like all things in computer science. the answer is it depends on the use-case. Here is how I like to think about it:

SQL that ActiveRecord can generate: Use ActiveRecord.
SQL that ActiveRecord can’t generate but doesn’t have dynamic conditional logic. Use Strings.
SQL that ActiveRecord can’t generate & also have dynamic conditional logic based on paremeters: Use AREL as shown in the above real-world example

To conclude, I would say Arel is tool that every rails developer should have in their toolbox.

Lastly, This is a blog post written after an year’s gap. so any feedback/comments/questions are welcome by tweeting to me at @gaurish

Getting Rails Test Suite Running on JRuby

Gaurish Sharma — Sun, 27 Apr 2014 00:00:00 +0000

This post is about Issue #11700 - Getting Rails Test Suite to run on Rails. Incase you don’t have time to read the full post, see the following presentation.

Prologue

You are a ruby developer & want to run rails on anything other than CRuby/MRI which is the de-facto ruby implementation written in C. Reasons could the that you are having problems with GC, need fully multi-threaded env(no GVL/GIL) or you just curious like me. so, you research a bit & find that there is this thing called JRuby which is implemntation of ruby programming language that runs of battle-tested & rock solid JVM. JVM is the same VM which is used by Java & all other JVM based languages like scala, closure, JPython etc.

Installing JRuby

Installing JRuby seems seems quite simpler compared MRI/CRuby as its only dependancy of JRuby is the JVM. so, download JDK 7 from oracle & download/install JRuby from jruby.org

You liked JRuby

lets assume you tried JRuby on Devloplement machine & liked JRuby because:

You need for specific Java libraries & JRuby Allows you to call any Java library from ruby.
want to real Concurrency, not GVL/GIL contrainted provided by CRuby/MRI.
Better GC which helps with long running processes
Better Performance

So next question you ask is:

Does Rails support JRuby?

Yes. Rails runs on JRuby out of the box but its on different Level of support that rails test suite fails to run, it fails. Current status is allowed failures

We consider any bugs on JRuby to be real bugs that need fixed, we just don’t actively run the test suite against JRuby – Steve Kalbnik (Rails Core Committor) on #11700

But as rails is open-source, which means you can help to get test suite running. Pull Request are welcome.

How to Run Rails Test Suite on JRuby

Grab Rails Code:

$ git clone http://github.com/rails/rails.git

Switch to JRuby

$ rvm use jruby #if using rvm
$ ruby -v
ruby 1.7.12 (1.9.3p392) 2014-04-15 643e292 on Java HotSpot(TM) 64-Bit Server
 VM 1.7.0_51-b13 [darwin-x86_64]

Bundle Dependencies

$ cd /path/to/rails/checkout
$ bundle install

Run Tests on particular component.

To run tests only for particular component(ActionPack, ActiveRecord, etc.). All you need to do is to cd into that component directory & run rake test. For example, run ActiveSupport tests you can:

$ cd activesupport
$ rake test

Run a particular test

$ cd activesupport
$ ruby -vIlib:test --client test/multibyte_chars_test.rb
ruby 1.7.12 (1.9.3p392) 2014-04-15 643e292 on Java HotSpot(TM) 64-Bit Server
 VM 1.7.0_51-b13 [darwin-x86_64]
/Users/gaurish/.rvm/gems/jruby-1.7.12@rails-dev/gems/minitest-5.3.3/
lib/minitest.rb:46 warning: (...) interpreted as grouped expression
Run options: --seed 21522

# Running:

lib/rational.rb is deprecated
.........................................................................
..............F....

Finished in 1.735000s, 53.0259 runs/s, 195.3890 assertions/s.

  1) Failure:
MultibyteCharsExtrasTest#test_tidy_bytes_should_tidy_bytes
[test/multibyte_chars_test.rb:657]:
--- expected
+++ actual
@@ -1 +1 @@
-"a€a"
+#<ActiveSupport::Multibyte::Chars:0xXXXXXX @wrapped_string="€a">


92 runs, 339 assertions, 1 failures, 0 errors, 0 skips

Okay, so now you have found a failing test. now, get this to green & submit a Pull Request. And please don’t forget to mention issue #11700 in your PR, so everyone can track it that you are working on the changes.

For more info, please see:

Installing Ruby from Source on Ubuntu 12.04 LTS

Gaurish Sharma — Tue, 11 Mar 2014 00:00:00 +0000

If you need to install ruby on server, I would suggest Compiling it from source because:

When Source gets compilied on machine, you can apply compiler optimizations & get best possible performance
Its a global install & available system side
Its easiest way to install ruby.

Here is what We will do:

Compile & Install Ruby v2.1.1

Here is what you will need:

Server running Ubuntu 12.04 with root access to it.
basic command line know-how
15mins of your time

Step 0: Update your System

It always a good idea to install all latest available patches for security & compatibility.

$ sudo apt-get update
$ sudo apt-get upgrade -y

Step 1: Install required Dependancies

$ sudo apt-get -y install build-essential libssl-dev libffi-dev libyaml-dev \
git libtool libxslt-dev libxml2-dev libpq-dev gawk curl pngcrush imagemagick \
python-software-properties libreadline libreadline-dev

# If you're on Ubuntu >= 12.10, change:
# python-software-properties to software-properties-common

Step 2: Install Ruby from Source

Download source tarball

$ wget http://cache.ruby-lang.org/pub/ruby/2.1/ruby-2.1.1.tar.gz

Extract & CD into it

$ tar xf ruby-2.1.1.tar.gz
$ cd ruby-2.1.1/

Now, last step do infamous configure, make & make install

$ ./configure --disable-install-doc
$ make && make install

If everything went well, you should have latest ruby installed

$ ruby -v
ruby 2.1.1p76 (2014-02-24 revision 45161) [x86_64-linux]

Note: Incase of upgrade to newer version, just do the step 2 again. changing 2.1.1 with the latest version no.

life is awesome

Gaurish Sharma — Sat, 01 Feb 2014 00:00:00 +0000

When life gives you a lemon, you make a lemonande

Create WebServer in Ruby with just 1 line of code

Gaurish Sharma — Sat, 04 Jan 2014 00:00:00 +0000

If you ever need a WebServer for quickly sharing of files or hosting static content, here is a ruby one-liner:

$ ruby -run -e httpd . -p 3000

This would spinup a simple webserver good for development & quick file sharing on Port 3000. works on ruby v2 & above

Tips on MultiThreading & Concurrency in Ruby

Gaurish Sharma — Mon, 09 Dec 2013 00:00:00 +0000

If you are a rubyist, chances are that you might have faced some problem which was slower/not possible using traditional single thread approach. so here are are few tips what might help you when working with thread in Ruby.

Threading is hard. Don’t use thread, until you really need them. Threading opens can of worms.
If you do opt to use Threading, don’t share/change data between multiple threads. You will get crazy data which will be different on every run.
If you want to share/change data in critical section, use semaphore/mutex, so you can lock parts of code should change as part of a “transaction”, so other threads waiting to change the data would be blocked.
set Thread.abort_on_exception = true. By Default, ruby will continue even if there is a error in a child thread. Never giving you chance to view the exception raised. Setting Thread.abort_on_exception = true will abort ALL threads if an exception is raised, giving you a chance to debug. Thread.abort_on_exception is a global flag so set in your config or on top of the file BEFORE any threading code.
Never use Thread#Join without a timeout. Join does not return untill ALL running threads exit. Which means if you have a thread which is waiting on something, join will also keep waiting endlessly. solution: Use a sensible timeout value. example t.join(5) where 5 is seconds.
Ruby’s Core Data Structures are NOT tread-safe. It is another way of saying – data structures like Array, Hash are not fit to use when writing treaded code. fortunately, there are third-party libs which are atomic & work exactly like Hash, Array ruby. notable one is thread_safe gem is also used by rails.

Find the greatest product of five consecutive digits in the 1000-digit number in Ruby

Gaurish Sharma — Thu, 15 Aug 2013 00:00:00 +0000

I recently started problems on Project Euler & came across problem #8:

Q. Find the greatest product of five consecutive digits in the 1000-digit number.the number is

73167176531330624919225119674426574742355349194934 96983520312774506326239578318016984801869478851843 85861560789112949495459501737958331952853208805511 12540698747158523863050715693290963295227443043557 66896648950445244523161731856403098711121722383113 62229893423380308135336276614282806444486645238749 30358907296290491560440772390713810515859307960866 70172427121883998797908792274921901699720888093776 65727333001053367881220235421809751254540594752243 52584907711670556013604839586446706324415722155397 53697817977846174064955149290862569321978468622482 83972241375657056057490261407972968652414535100474 82166370484403199890008895243450658541227588666881 16427171479924442928230863465674813919123162824586 17866458359124566529476545682848912883142607690042 24219022671055626321111109370544217506941658960408 07198403850962455444362981230987879927244284909188 84580156166097919133875499200524063689912560717606 05886116467109405077541002256983155200055935729725 71636269561882670428252483600823257530420752963450

Apart from the fact the number is akwardly large, solving this in ruby is easy

n.scan(/\d/).map(&:to_i).each_cons(5).map { |n| n.inject(:*) }.max

Where n that huge number in string format.

If you notice the above program gives the product of greatest five consecutive digits of a 1,000digit number on just one line. Amazing!