Sukendhar

Mongo backup and restore

2013-08-05T00:00:00+00:00

MongoDB backup & Restore

To take backup of mongodb database

$ monogodb -db database_name > database_name.bson

To restore backup file to database

$ mongorestore -db database_name folder_name

Take backup from heroku MongoHQ using heroku-mongo-sync

$ heroku mongo:pull --app app_name

Take backup from heroku MongoHQ from MongoHQ url

$ mongodump -h hatch.mongohq.com:27021 -d database_name -u admin -p sekret -o ~/tmp/mongodump

Restore heroku MongoHQ database with backup

$ mongorestore -h hatch.mongohq.com:27021 -d database_name -u admin -p sekret ~/tmp/mongodump/database_name

Comments

Rails upgrade 2.3.x to 3.2.x

2013-01-20T00:00:00+00:00

Install Rails Upgrade plugin

$ ruby script/plugin install git://github.com/rails/rails_upgrade.git

Then check for files list which we need to change

$ rake rails:upgrade:check

This should give you an idea of the manual changes that need to be done, but you’ll probably want to upgrade some of those automatically. The fastest way to do this is to run “rails .” , which will simply generate a new app on top of your existing code. But this generation also has the effect of replacing some existing files, some of which you might not want to replace. To back those up, first run:

$ rake rails:upgrade:backup

That will backup files you’ve probably edited that will be replaced in the upgrade; if you finish the upgrade and find that you don’t need the old copies, just delete them. Otherwise, copy their contents back into the new files or run one of the following upgraders…

Routes upgrader

To generate a new routes file from your existing routes file, simply run the following Rake task:

$ rake rails:upgrade:routes

This will output a new routes file that you can copy and paste or pipe into a new, Rails 3 compatible config/routes.rb.

Gemfile generator

Creating a new Gemfile is as simple as running:

$ rake rails:upgrade:gems

This task will extract your config.gem calls and generate code you can put into a bundler compatible Gemfile.

Configuration generator

$ rake rails:upgrade:configuration

Much of the configuration information that lived in environment.rb now belongs in a new file named config/application.rb; use the following task to generate code you can put into config/application.rb from your existing config/environment.rb

Comments

Getting started with git

2012-12-15T00:00:00+00:00

Global configuration file

Git allows you to store global settings in the .gitconfig file. This file is located in the user home directory. Git stores the committer and author of a change in each commit.

User Configuration

Configure your user and email for Git via the following command.

$ git config --global user.name "Your Name Here"
# Sets the default name for git to use when you commit
$ git config --global user.email "your_email@youremail.com"
# Sets the default email for git to use when you commit

Getting started with Git

Fire up a terminal, and type (replace Rails_app with name of the your application):

$ rails new Rails_app

Afterwards, navigate into this new directory by typing:

$ cd Rails_app

Initialize Git inside this directory by typing:

$ git init

Create a new file by typing:

$ touch README

Add this file to the repository by typing:

$ git add README

Now, let’s make a change to this file, by writing something to it

$ echo "Hello, is this on Github?!" > README

Now, we need to commit. Committing is a small message of what you just did:

$ git commit -m 'Initial commit'

Next, we need to add the online Github repository (the origin)

$ git remote add origin git@github.com:User/Rails_app.git

And finally, let’s push it to Github.

$ git push origin master

Now you’ve added your first file to Github! Continue to learn more about how to work with Git.

Comments

Mongo DB Quieries

2012-09-16T00:00:00+00:00

Here is the some important frequently used mongodb queries.

After running mongodb server(mongod) and interactive shell(mongo), Our’s first command should be

1. help

->Which will show a lot of useful command that is helpful at any instance working with mongodb.

2.db.help();

->It is database level help command that will show some of data level command.

3. db.help;

-> This command will show database level methods.

All above command is basic mongodb command.

How to create database? show dbs; to show all the databases... show collections; to view all the table in db...

1. use databasename;

In my case it is “use mongotest”, here USE is command to create database and mongotest is database name. It is one of the nice feature of mongodb if there will be no database with this particular name, will create new database else use(move) to exiting database.

Create table!!!!!!!

1. db.tablename.save({“name”:”ankit”,”phone”:”1234567890″});

Fetch data from tables!!!!!!!!!!

1. db.tablename.find();

return data of table.

2.db.tablename.find;

return methods it self.

Create another record!!!!!!!!!

x={“name”:”abhay”,”phone”:”1234567890″}

db.contacts.save(x);

this is another way of creating new record and saving as an object.

Fetch particular record from tables !!!!!!!!!!

db.contacts.find({“name”:”ankit”});

N.T. -> Search option is case sensetive.

find record using id

> db.contacts.find({_id:ObjectId("4ea3aa28eaaf3871b0549dfa")});
{ "_id" : ObjectId("4ea3aa28eaaf3871b0549dfa"),
 "name" : "ankit", "phone" : "1234567890" }

Update particular record into tables !!!!!!!!!!

-> there is two way to update table

1. Using save()->this is one of nice feature to mongodb, if there will already row in table it will update with new attribute else will create new record.

2. Using update()->will only update exiting record.

find record using object

> x = db.contacts.findOne({"name":"ankit"});
{
        "_id" : ObjectId("4ea3aa28eaaf3871b0549dfa"),
        "name" : "ankit",
        "phone" : "1234567890"
}
Now we have object x with reference of contacts table.
> x
{
        "_id" : ObjectId("4ea3aa28eaaf3871b0549dfa"),
        "name" : "ankit",
        "phone" : "1234567890"
}

Now i am going to add new attribute email

> x.email = "ankit@gmail.com"
ankit@gmail.com
Let's see updated row 
> x
{
        "_id" : ObjectId("4ea3aa28eaaf3871b0549dfa"),
        "name" : "ankit",
        "phone" : "1234567890",
        "email" : "ankit@gmail.com"
}

Now we fetch details from table

> db.contacts.find();
{ "_id" : ObjectId("4ea3aa28eaaf3871b0549dfa"),
 "name" : "ankit", "phone" : "1234567890" }
{ "_id" : ObjectId("4ea3b067eaaf3871b0549dfb"),
 "name" : "abhay", "phone" : "1234567890" }

table is not updated here, we need to update table.

> db.contacts.save(x);
Now try again
> db.contacts.find();
{ "_id" : ObjectId("4ea3b067eaaf3871b0549dfb"), 
"name" : "abhay", "phone" : "1234567890" }
{ "_id" : ObjectId("4ea3aa28eaaf3871b0549dfa"),
 "name" : "ankit", "phone" : "1234567890",
 "email" : "ankit@gmail.com" }

Delete particular record from tables !!!!!!!!!!

> db.contacts.remove(x);
let's see row is there or not
> db.contacts.find();
{ "_id" : ObjectId("4ea3b067eaaf3871b0549dfb"),
 "name" : "abhay", "phone" : "1234567890" }

yah, this row is deleted THAT ALL WAS THE CRUD OPERATION ON MONGODB TABLE.

Comments

Mongo connection failure?

2012-09-16T00:00:00+00:00

Connection failed during mongo start:

Follow this steps:

$ sudo rm /var/lib/mongodb/mongod.lock

$ mongod --repair

$ sudo start mongodb

$ sudo status mongodb

$ mongo

connection established message will be displayed.

Comments

Mongo DB installation

2012-09-15T00:00:00+00:00

The following command to install the latest stable version of MongoDB:

$ sudo apt-get install mongodb-10gen

When this command completes, you have successfully installed MongoDB! Continue for configuration and start-up suggestions.

Starting MongoDB

Upstart users can start the mongod process by issuing the following command:

$ sudo service mongodb start

All other users can issue the following command to start mongod:

$ sudo /etc/init.d/mongodb start

You can verify that mongod has started successfully by checking the contents of the log file at /var/log/mongodb/mongodb.log

Stopping MongoDB

Upstart users can stop the mongod process by issuing the following command:

$ sudo service mongodb stop

All other users can issue the following command to stop mongod:

$ sudo /etc/init.d/mongodb stop

Restarting MongoDB

Upstart users can restart the mongod process by issuing the following command:

$ sudo service mongodb restart

All other users can issue the following command to restart mongod:

$ sudo /etc/init.d/mongodb restart

type “mongo” in your terminal to see the version

Comments

Contact form in Rails 3

2012-09-14T00:00:00+00:00

The goal of this tutorial is to build a form that when submitted will validate and email the data.

Prerequisites

To simplify this, I’m just using Google Apps to manage email addresses. If you have your own email server just modify the settings as needed. To get started you’ll need:

A Google Apps account, of course
Ruby on Rails 3.2.2 (give or take a few version numbers)

Configuring Rails for GMail

In an existing or new application, open config/application.rb. Insert the following snippet in the Application class.

config.action_mailer.smtp_settings = {
  :address              => "smtp.gmail.com",
  :port                 => 587,
  :domain               => "yourdomain.dev",
  :user_name            => "from@yourdomain.dev",
  :password             => "Super-Secure-Password",
  :authentication       => :plain,
  :enable_starttls_auto => true
}

config.action_mailer.default_url_options = {
  :host => "yourdomain.dev"
}

Set the value of :domain to the domain you’re using for Google Apps, and :user_name and :password to your Google Apps account credentials. In the second block replace :host with the domain where the application is reachable from. The :host option is used to ensure that all links in email templates generate full URLs.

The Message Model

To allow validation of the message, I create a model and just include ActiveModel’s validations. Allowing the model to be written just like any other Rails model.

Create the file app/models/message.rb, or with a name of your choice. Make the file look similar to the following.

class Message

  include ActiveModel::Validations
  include ActiveModel::Conversion
  extend ActiveModel::Naming

  attr_accessor :name, :email, :subject, :body

  validates :name, :email, :subject, :body, :presence => true
  validates :email, :format => { :with => %r{.+@.+\..+} }, :allow_blank => true

  def initialize(attributes = {})
    attributes.each do |name, value|
      send("#{name}=", value)
    end
  end

  def persisted?
    false
  end

end

This is fairly self explanatory. A message can have a subject and body, as well as the name and email address of the sender. All of the fields are required, and the email address is verified with a regular expression.

The Mailer Model and Views

Run rails g mailer NotificationsMailer. This generates app/mailers/notifications_mailer.rb.

We’ll want notifications_mailer.rb to look similar to this snippet. Check out the ActionMailer API for specifics on what’s happening here.

class NotificationsMailer < ActionMailer::Base

  default :from => "noreply@youdomain.dev"
  default :to => "you@youremail.dev"

  def new_message(message)
    @message = message
    mail(:subject => "[YourWebsite.tld] #{message.subject}")
  end

end

Replace :to, :from and :subject with the address you’d like the email sent to, the address it’s being sent from (should be the one you configured the Rails application with), and the subject of the email.

Create the file app/views/notifications_mailer/new_message.text.erb.How the message looks is entirely up to you. Here’s an example of how it could be laid out.

Name: <%= @message.name %>

Email: <%= @message.email %>

Subject: <%= @message.subject %>

Body: <%= @message.body %>

The Controller and View

Run rails g controller contact and then open app/controllers/contact_controller.rb.

The controller will only need two actions: new and create.

class ContactController < ApplicationController

  def new
    @message = Message.new
  end

  def create
    @message = Message.new(params[:message])

    if @message.valid?
      NotificationsMailer.new_message(@message).deliver
      redirect_to(root_path, :notice => "Message was successfully sent.")
    else
      flash.now.alert = "Please fill all fields."
      render :new
    end
  end

end

To get these actions working, open up config/routes.rb and insert the following two lines.

match 'contact' => 'contact#new', :as => 'contact', :via => :get
match 'contact' => 'contact#create', :as => 'contact', :via => :post

When a GET request is made to /contact, the new action is called. When a POST request is made to /contact, the create action is called.

Create app/views/contact/new.html.erb. As with the email template, this template is entirely up to you, I’m only providing an example of what it could look like.

<%= form_for @message, :url => contact_path do |form| %>
  <fieldset>
    <div>
      <%= form.label :name %>
      <%= form.text_field :name %>
    </div>

    <div>
      <%= form.label :email %>
      <%= form.text_field :email %>
    </div>
    <div>
      <%= form.label :subject %>
      <%= form.text_field :subject %>
    </div>

    <div>
      <%= form.label :body %>
      <%= form.text_area :body %>
    </div>
  </fieldset>

  <fieldset>
    <%= form.submit "Send" %>
  </fieldset>
<% end %>

Try it

Start your rails server and go to /contact. Fill out the form and hit send. If everything was done correctly an email should arrive in the inbox of the address specified.

Comments

Difference between Rails 2.3 and 3

2012-09-07T00:00:00+00:00

1. Introduction of bundler (New way to manage your gem dependencies) 
2. Gemfile and Gemfile.lock (Where all your gem dependencies lies, instead of environment.rb) 
3. A new .rb file in config/ folder, named as application.rb (Which has everything that previously environment.rb had) 
4. Change in SQL Structure: Model.where(:activated => true) 
5. All the mailer script will now be in app/mailers folder, earlier we kept inside app/models. 
6. Rails3-UJS support. for links and forms to work as AJAX, instead of writing complex lines of code, we write :remote => true 
7. HTML 5 support. 
8. Changes in the model based validation syntax: validates :name, :presence => true 
9. Ability to install windows/ruby/jruby/development/production specific gems to Gemfile. 
group :production do 
  gem 'will_paginate' 
end

Comments

What is Ruby on Rails?

2012-08-12T00:00:00+00:00

What is Ruby : Ruby is a pure object-oriented programming language with a super clean syntax that makes programming elegant and fun. Ruby successfully combines Smalltalkâs conceptual elegance, Pythons ease of use and learning, and Perls pragmatism. Ruby originated in Japan in the early 1990s, and has started to become popular worldwide in the past few years as more English language books and documentation have become available.

What is Rails: Rails is an open source Ruby framework for developing database-backed web applications. What’s special about that? There are dozens of frameworks out there and most of them have been around much longer than Rails. Why should you care about yet another framework? What would you think if I told you that you could develop a web application at least ten times faster with Rails than you could with a typical Java framework? You can without making any sacrifices in the quality of your application! How is this possible? Part of the answer is in the Ruby programming language. Many things that are very simple to do in Ruby are not even possible in most other languages. Rails takes full advantage of this.

The rest of the answer is in two of Rails guiding principles: less software and convention over configuration. Less software means you write fewer lines of code to implement your application. Keeping your code small means faster development and fewer bugs, which makes your code easier to understand, maintain, and enhance. Very shortly, you will see how Rails cuts your code burden. Convention over configuration means an end to verbose XML configuration files there aren’t any in Rails! Instead of configuration files, a Rails application uses a few simple programming conventions that allow it to figure out everything through reflection and discovery. Your application code and your running database already contain everything that Rails needs to know!

Comments

Hello world!

2012-07-26T00:00:00+00:00

Welcome to my blog sukendharreddy.com! This is my very first post.

Enjoy…!!!