haas 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6e8a464110c902c14ef830dc3a2171248f3aa258
+  data.tar.gz: 760ca88c7ee422e94b7be779b258d142f1381730
+SHA512:
+  metadata.gz: 35e900d38e69ca79d7a20c66e27fb2d598b6abe001396bbaa29b85eea601f1165012bcfd10d340f8bc96a2d344480e712e049350af71393d9c0e883bc3269864
+  data.tar.gz: 671575fd90a0a218452f868e580d2f164364eb8baa53ce156b3ce07d4d1ad521faf8e9215f438dd8f4926318adfbcce432994bb51acd30d7b31eeffb2167cf24

data/bin/haas

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'haas'
+require 'mixlib/cli'
+
+class HaasCLI
+  include Mixlib::CLI
+
+  option :launch,
+    :long  => "--launch",
+    :description => "Launch and install a cluster"
+
+  option :nb_instances,
+    :long  => "--nb-instances COUNT",
+    :description => "The number of instances you want to launch",
+    :default => "5"
+
+  option :instance_type,
+    :long  => "--instance-type TYPE",
+    :description => "The type of the EC2 instance you want to launch",
+    :default => "m3.large"
+
+  option :aws_region,
+    :long  => "--aws-region REGION",
+    :description => "The AWS region used",
+    :default => "us-east-1"
+
+  option :list,
+    :long  => "--list",
+    :description => "Show all the configured clusters and instances"
+
+  option :terminate,
+    :long  => "--terminate",
+    :description => "Terminate the cluster"
+
+  option :help,
+    :short => "-h",
+    :long => "--help",
+    :description => "Show this message",
+    :on => :tail,
+    :boolean => true,
+    :show_options => true,
+    :exit => 0
+
+end
+
+cli = HaasCLI.new
+cli.parse_options
+
+Haas::Config.set_options cli.config
+
+if cli.config[:launch]
+  Haas.launch
+elsif cli.config[:list]
+  Haas.show
+elsif cli.config[:terminate]
+  Haas.terminate Haas::Cluster.last
+end

data/lib/haas.rb

@@ -0,0 +1,67 @@
+require 'active_record'
+require 'haas/config'
+require 'models/key_pair'
+require 'models/node'
+require 'models/cluster'
+require 'haas/aws'
+require 'haas/chef'
+require 'haas/blueprints'
+require 'haas/utils'
+
+class Haas
+  def self.launch
+    Haas::Aws.connect
+    @cluster=Haas::Cluster.create(
+      :aws_region => Haas::Aws.region,
+      :ssh_user => "root"
+    )
+    if Haas::Aws.nb_instance_available >= Haas::Config.options[:nb_instances].to_i
+      Haas::Aws.create_key_pair
+      Haas::Aws.launch_instances
+    else
+      puts "There is not enough instances available.\nYou can request a limit increase here : https://aws.amazon.com/support/createCase?serviceLimitIncreaseType=ec2-instances&type=service_limit_increase"
+      exit
+    end
+
+    Haas::ChefProvider.setup_cluster
+    Haas::Blueprints.post_blueprints
+
+    puts "\n"
+    puts "=========== installation report =============="
+    puts "Ambari is finalizing the installation"
+    puts "You can access Ambari to manage your cluster at the following address:"
+    puts "http://#{@cluster.get_ambari_server.public_dns_name}:8080/"
+    puts "user: admin"
+    puts "password: admin"
+    puts "\n"
+    puts "Nodes of the cluster:"
+    @cluster.nodes.each do |node|
+      puts "    #{node.public_dns_name}"
+    end
+    puts "\n"
+    puts "You can use this SSH key to log into each node as user #{@cluster.ssh_user}"
+    puts @cluster.identity_file_path
+  end
+
+  def self.show
+    Haas::Cluster.all.each do |cluster|
+      puts "Cluster - #{cluster.name}"
+      cluster.nodes.each do |node|
+        puts "        #{node.instance_id} - #{node.ip_address} - #{node.private_ip_address}"
+      end
+    end
+  end
+
+  def self.terminate cluster_name
+    Haas::Aws.connect
+    Haas::Aws.terminate_cluster Cluster.first
+  end
+
+  def self.cluster
+    return @cluster
+  end
+
+  def self.set_cluster cluster
+    @cluster = cluster
+  end
+end

data/lib/haas/aws.rb

@@ -0,0 +1,143 @@
+require 'aws-sdk'
+
+class Haas
+  class Aws
+    CENTOS_IMAGES = {
+      "6.5" => {
+        "us-east-1"=>"ami-8997afe0",
+        "us-west-2"=>"ami-b6bdde86",
+        "us-west-1"=>"ami-1a013c5f",
+        "eu-west-1"=>"ami-42718735",
+        "ap-southeast-1"=>"ami-a08fd9f2",
+        "ap-southeast-2"=>"ami-e7138ddd",
+        "ap-northeast-1"=>"ami-81294380",
+        "sa-east-1"=>"ami-7d02a260"
+      },
+      "7" => {
+        "us-east-1"=>"ami-96a818fe",
+        "us-west-2"=>"ami-c7d092f7",
+        "us-west-1"=>"ami-6bcfc42e",
+        "eu-west-1"=>"ami-e4ff5c93",
+        "ap-southeast-1"=>"ami-aea582fc",
+        "ap-southeast-2"=>"ami-bd523087",
+        "ap-northeast-1"=>"ami-89634988",
+        "sa-east-1"=>"ami-bf9520a2"
+      }
+    }
+
+    def self.connect
+      @region = Haas::Config.options[:aws_region] || 'us-east-1'
+      AWS.config(
+        access_key_id: ENV['AWS_KEY'],
+        secret_access_key: ENV['AWS_SECRET'],
+        region: region
+      )
+      @ec2 = AWS::EC2.new
+    end
+
+    def self.ec2
+      @ec2
+    end
+
+    def self.region
+      @region
+    end
+
+    def self.nb_instance_available
+      account_attributes = ec2.client.describe_account_attributes\
+      .data[:account_attribute_set]\
+      .inject({}) do |m, i|
+        m[i[:attribute_name]] = i[:attribute_value_set].first[:attribute_value]; m
+      end
+
+      max_instances = account_attributes["max-instances"].to_i
+      return max_instances - nb_running_instances
+    end
+
+    def self.nb_running_instances
+      ec2.instances.inject({}) { |m, i| i.status == :running ? m[i.id] = i.status : nil; m }.length
+    end
+
+    def self.create_key_pair
+      key_pair = Haas::KeyPair.create(name: Haas.cluster.name)
+      File.write(Haas.cluster.identity_file_path, key_pair.private_key)
+      File.chmod(0600, Haas.cluster.identity_file_path)
+    end
+
+    def self.launch_instances
+      image_id = CENTOS_IMAGES["6.5"][region]
+
+      if !ec2.security_groups.filter('group-name', 'haas-security-group').first
+        security_group = ec2.security_groups.create('haas-security-group')
+        security_group.authorize_ingress(:tcp, 22)
+        security_group.authorize_ingress(:tcp, 80)
+        security_group.authorize_ingress(:tcp, 443)
+        security_group.authorize_ingress(:tcp, 8080)
+        security_group.authorize_ingress(:tcp, 0..65535, security_group)
+        security_group.authorize_ingress(:udp, 0..65535, security_group)
+        security_group.authorize_ingress(:icmp, -1, security_group)
+      end
+
+      instances = ec2.instances.create({
+        :image_id => image_id,
+        :instance_type => Haas::Config.options[:instance_type],
+        :key_name => Haas.cluster.name,
+        :security_groups => ['haas-security-group'],
+        :block_device_mappings => [
+          {
+            :device_name => "/dev/sda",
+            :ebs => {
+              :volume_size => 8, # 8 GiB
+              :delete_on_termination => true
+            }
+          },
+          {
+            :device_name => "/dev/sdf",
+            :virtual_name => "ephemeral0"
+          }
+        ],
+        :count => Haas::Config.options[:nb_instances].to_i
+      })
+
+      print "Waiting for the instances to start "
+      while instances.any? {|i| i.status == :pending; } do
+        print '.'
+        sleep 1
+      end
+      puts " done"
+
+      print "Waiting for the instances to be initialized and accessible "
+      while !is_cluster_ssh_open?(instances) do
+        print '.'
+        sleep 1
+      end
+      puts " done"
+
+      instances.each do |instance|
+        Haas::Node.create(
+          cluster_id: Haas.cluster.id,
+          instance_id: instance.id,
+          public_ip_address: instance.ip_address,
+          public_dns_name: instance.public_dns_name,
+          private_ip_address: instance.private_ip_address,
+          private_dns_name: instance.private_dns_name
+        )
+      end
+    end
+
+    def self.terminate_cluster cluster
+      ec2.client.terminate_instances({
+        instance_ids: cluster.nodes.map(&:instance_id)
+      })
+      cluster.destroy
+    end
+
+    def self.is_cluster_ssh_open?(instances)
+      instances.each do |instance|
+        return false unless Haas::Utils.is_port_open?(instance.public_dns_name,22)
+      end
+      return true
+    end
+
+  end
+end

data/lib/haas/blueprints.rb

@@ -0,0 +1,134 @@
+class Haas
+  class Blueprints
+
+    def self.post_blueprints
+      ambari = Haas.cluster.get_ambari_server
+      puts "Wait until ambari server is launched"
+      while !Haas::Utils.is_port_open?(ambari.public_dns_name,8080)
+        print '.'
+        sleep 1
+      end
+      puts ' done.'
+
+      puts "Wait 20 seconds for the nodes to connect to ambari."
+      sleep 20
+      puts "Done."
+
+      post_json(ambari.public_dns_name,8080,'/api/v1/blueprints/haas-blueprint',get_blueprint)
+      post_json(ambari.public_dns_name,8080,'/api/v1/clusters/haas-cluster',get_cluster)
+    end
+
+    def self.post_json(host, port, url, params)
+      req = Net::HTTP::Post.new(url)
+      req.body = params.to_json
+      req.basic_auth("admin", "admin")
+      req["X-Requested-By"] = "HaaS"
+      response = Net::HTTP.new(host, port).start {|http| http.request(req) }
+    end
+
+    def self.get_blueprint
+      {
+        "host_groups" => [
+          {
+            "name" => "master",
+            "configurations" => [
+              {
+                "global" => {
+                  "nagios_contact" => "me@my-awesome-domain.example"
+                }
+              }
+            ],
+              "components" => [
+              {
+                "name" => "NAMENODE"
+              },
+              {
+                "name" => "SECONDARY_NAMENODE"
+              },
+              {
+                "name" => "RESOURCEMANAGER"
+              },
+              {
+                "name" => "HISTORYSERVER"
+              },
+              {
+                "name" => "NAGIOS_SERVER"
+              },
+              {
+                "name" => "GANGLIA_SERVER"
+              },
+              {
+                "name" => "ZOOKEEPER_SERVER"
+              },
+              {
+                "name" => "GANGLIA_MONITOR"
+              }
+            ],
+            "cardinality" => "1"
+          },
+          {
+            "name" => "slaves",
+            "components" => [
+              {
+                "name" => "DATANODE"
+              },
+              {
+                "name" => "HDFS_CLIENT"
+              },
+              {
+                "name" => "NODEMANAGER"
+              },
+              {
+                "name" => "YARN_CLIENT"
+              },
+              {
+                "name" => "MAPREDUCE2_CLIENT"
+              },
+              {
+                "name" => "ZOOKEEPER_CLIENT"
+              },
+              {
+                "name" => "GANGLIA_MONITOR"
+              }
+            ],
+            "cardinality" => "1+"
+          }
+        ],
+       "Blueprints" => {
+          "stack_name" => "HDP",
+          "stack_version" => "2.1"
+        }
+      }
+    end
+
+
+    def self.get_cluster
+      masters = []
+      slaves = []
+      nb_masters = 1
+      Haas.cluster.nodes.each do |node|
+        if masters.length < nb_masters
+          masters << { "fqdn" => node.private_dns_name }
+        else
+          slaves << { "fqdn" => node.private_dns_name }
+        end
+      end
+
+      {
+        "blueprint" => "haas-blueprint",
+        "default_password" => "my-super-secret-password",
+        "host_groups" => [
+          {
+            "name" => "master",
+            "hosts" => masters
+          },
+          {
+            "name" => "slaves",
+            "hosts" => slaves
+          }
+        ]
+      }
+    end
+
+  end
+end

data/lib/haas/chef.rb

@@ -0,0 +1,158 @@
+class Haas
+  class ChefProvider
+
+    COOKBOOK_PATH = File.join(Haas::Config::WORKING_DIR, 'cookbooks')
+
+    def self.setup_cluster
+      install_chef_server
+      write_knife_config_file
+      cookbooks=[{'name' => 'ambari','url' => "https://supermarket.getchef.com/cookbooks/ambari/download" }]
+      cookbooks.each do |cb|
+        download_cookbook cb['name'], cb['url']
+      end
+      upload_cookbook
+      setup_environment
+      threads = []
+      Haas.cluster.nodes.each do |node|
+        threads << Thread.new { bootstrap_node(node) }
+      end
+      threads.each { |thr| thr.join }
+    end
+
+    def self.install_chef_server
+      require 'net/ssh'
+      chef_server = Haas.cluster.get_chef_server
+      user = Haas.cluster.ssh_user
+      chef_server_file = "chef-server-core-12.0.0_rc.5-1.el5.x86_64.rpm"
+      chef_server_url = "https://packagecloud.io/chef/stable/download?distro=6&filename=#{chef_server_file}"
+      chef_server_local_path = "/tmp/#{chef_server_file}"
+
+      Net::SSH.start(
+        chef_server.public_dns_name, user,
+        :host_key => "ssh-rsa",
+        :encryption => "blowfish-cbc",
+        :keys => [ Haas.cluster.identity_file_path ],
+        :compression => "zlib"
+      ) do |ssh|
+        puts "Entering chef server installation on the node #{chef_server.public_dns_name}. This may take a while."
+        puts "Disable iptables"
+        ssh.exec!("service iptables stop")
+        puts "Downloading and installing the chef server."
+        ssh.exec!(%{
+          until curl -L '#{chef_server_url}' -o #{chef_server_local_path} && rpm -ivh #{chef_server_local_path}; do
+            echo "installing chef server";
+          done
+        })
+        ssh.exec!("rpm -ivh #{chef_server_local_path}")
+        puts "Configuring chef server."
+        ssh.exec!("mkdir -p /etc/opscode/")
+        ssh.exec!(%{echo "nginx['non_ssl_port'] = false" >> /etc/opscode/chef-server.rb})
+        ssh.exec!("chef-server-ctl reconfigure")
+
+        client_key = ""
+        while !client_key.include?("BEGIN RSA PRIVATE KEY") do
+          client_key = ssh.exec!("chef-server-ctl user-create haas-api HAAS Api haas@ossom.io abc123")
+        end
+        File.write(Haas.cluster.chef_client_pem_path, client_key)
+
+        org_validator_key = ssh.exec!("chef-server-ctl org-create haas Hadoop as a Service --association_user haas-api")
+        File.write(Haas.cluster.chef_validator_pem_path, org_validator_key)
+      end
+    end
+
+    def self.write_knife_config_file
+      conf = %{
+        log_level                    :info
+        log_location               STDOUT
+        node_name               "haas-api"
+        client_key                  "#{Haas.cluster.chef_client_pem_path}"
+        validation_client_name   "haas-validator"
+        validation_key           "#{Haas.cluster.chef_validator_pem_path}"
+        chef_server_url        "https://#{Haas.cluster.get_chef_server.public_dns_name}/organizations/haas"
+        cache_type               'BasicFile'
+        cache_options( :path => "#{ENV['HOME']}/.chef/checksums" )
+        cookbook_path         ["#{COOKBOOK_PATH}"]
+        environment             "#{Haas.cluster.name}"
+      }
+
+      File.write(Haas.cluster.knife_config_path, conf)
+    end
+
+
+    def self.bootstrap_node node
+      require 'chef'
+      require 'chef/knife'
+      require 'chef/knife/bootstrap'
+      require 'chef/knife/core/bootstrap_context'
+      require 'chef/knife/ssh'
+      require 'net/ssh'
+      require 'net/ssh/multi'
+
+      puts "Bootstrapping node #{node.public_dns_name}"
+
+      user = Haas.cluster.ssh_user
+      run_list = ["recipe[ambari::agent]"]
+      run_list << "recipe[ambari::server]" if node.ambari_server
+
+      Chef::Config.from_file(Haas.cluster.knife_config_path)
+      kb = Chef::Knife::Bootstrap.new
+      kb.config[:ssh_user] = user
+      kb.config[:run_list] = run_list
+      kb.config[:use_sudo] = true
+      kb.config[:identity_file] = Haas.cluster.identity_file_path
+      kb.config[:distro] = 'chef-full'
+      kb.name_args = [node.public_dns_name]
+      kb.run
+    end
+
+    def self.download_cookbook cookbook_name, url
+      require 'open-uri'
+      require 'zlib'
+      require 'archive/tar/minitar'
+
+      cookbooks_dir = File.join(Haas::Config::WORKING_DIR, 'cookbooks')
+      Dir.mkdir(cookbooks_dir) unless File.exists?(cookbooks_dir)
+      archive_path = File.join(cookbooks_dir, "#{cookbook_name}.tar.gz")
+      open(archive_path, 'wb') do |file|
+        file << open(url).read
+      end
+      tgz = Zlib::GzipReader.new(File.open(archive_path, 'rb'))
+      Archive::Tar::Minitar.unpack(tgz, cookbooks_dir)
+    end
+
+    def self.upload_cookbook
+      require 'chef'
+      require 'chef/cookbook_uploader'
+
+      puts "Uploading cookbooks to the chef server."
+
+      Chef::Config.from_file(Haas.cluster.knife_config_path)
+      cookbook_repo = Chef::CookbookLoader.new(COOKBOOK_PATH)
+      cookbook_repo.load_cookbooks
+      cbs = []
+      cookbook_repo.each do |cookbook_name, cookbook|
+        cbs << cookbook
+      end
+      Chef::CookbookUploader.new(cbs,:force => false, :concurrency => 10).upload_cookbooks
+    end
+
+    def self.setup_environment
+      require 'chef/environment'
+      require 'chef/rest'
+      ambari_server_fqdn = Haas.cluster.get_ambari_server
+
+      override_attributes = {
+        :ambari => {
+          :server_fqdn => ambari_server_fqdn.private_dns_name
+        }
+      }
+
+      Chef::Config.from_file(Haas.cluster.knife_config_path)
+      environment = Chef::Environment.new
+      environment.name(Haas.cluster.name)
+      environment.description("haas hadoop cluster")
+      environment.override_attributes(override_attributes)
+      environment.save
+    end
+  end
+end

data/lib/haas/config.rb

@@ -0,0 +1,56 @@
+class Haas
+  class Config
+    WORKING_DIR=File.join(File.expand_path('~'), '.haas')
+
+    def self.set_options options
+      @options = options
+    end
+
+    def self.options
+      @options
+    end
+
+    # Create Haas folder
+
+    Dir.mkdir(Haas::Config::WORKING_DIR) unless File.exists?(Haas::Config::WORKING_DIR)
+
+    ############ create sqlite db in memory ############
+
+    SQLITE_DB = ENV['SQLITE_DB'] || File.join(Haas::Config::WORKING_DIR,"haas_sqlite3.db")
+
+    ActiveRecord::Base.establish_connection(
+      adapter: "sqlite3",
+      database: SQLITE_DB
+    )
+
+    if !File.file?(SQLITE_DB)
+      ActiveRecord::Migration.verbose = false
+      ActiveRecord::Schema.define do
+        create_table :key_pairs do |table|
+          table.column :name, :string
+          table.column :private_key, :string
+        end
+        add_index :key_pairs, :name, unique: true
+
+        create_table :clusters do |table|
+          table.column :name, :string
+          table.column :aws_region, :string
+          table.column :ssh_user, :string
+        end
+        add_index :clusters, :name, unique: true
+
+        create_table :nodes do |table|
+          table.column :instance_id, :string
+          table.column :public_ip_address, :string
+          table.column :public_dns_name, :string
+          table.column :private_ip_address, :string
+          table.column :private_dns_name, :string
+          table.column :chef_server, :boolean
+          table.column :ambari_server, :boolean
+          table.column :cluster_id, :integer
+        end
+      end
+    end
+
+  end
+end

data/lib/haas/utils.rb

@@ -0,0 +1,23 @@
+class Haas
+  class Utils
+
+    def self.is_port_open?(ip, port)
+      require 'socket'
+      require 'timeout'
+      begin
+        Timeout::timeout(1) do
+          begin
+            s = TCPSocket.new(ip, port)
+            s.close
+            return true
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            return false
+          end
+        end
+      rescue Timeout::Error
+      end
+      return false
+    end
+
+  end
+end

data/lib/models/cluster.rb

@@ -0,0 +1,61 @@
+class Haas
+  class Cluster < ActiveRecord::Base
+    before_create :generate_name
+    after_create :mkdir_cluster_home
+    has_many :nodes, dependent: :destroy
+
+    def mkdir_cluster_home
+      require 'fileutils'
+      FileUtils.mkdir_p self.working_dir_path
+    end
+
+    def working_dir_path
+      File.join(Haas::Config::WORKING_DIR, self.name)
+    end
+
+    def identity_file_path
+      File.join(self.working_dir_path,"ssh-#{self.name}.pem")
+    end
+
+    def chef_client_pem_path
+      File.join(self.working_dir_path,"haas-api.pem")
+    end
+
+    def chef_validator_pem_path
+      File.join(self.working_dir_path,"haas-validator.pem")
+    end
+
+    def knife_config_path
+      File.join(self.working_dir_path,"knife.rb")
+    end
+
+    def generate_name
+      random_str = (0...8).map { (65 + rand(26)).chr }.join
+      self.name = "HAAS-#{random_str}"
+    end
+
+    def get_chef_server
+      chef_server = self.nodes.where('nodes.chef_server=?',true)
+      if chef_server.first
+        return chef_server.first
+      else
+        node = self.nodes.first
+        node.chef_server = true
+        node.save
+        return node
+      end
+    end
+
+    def get_ambari_server
+      ambari_server = self.nodes.where('nodes.ambari_server=?',true)
+      if ambari_server.first
+        return ambari_server.first
+      else
+        node = self.nodes.where('nodes.chef_server IS NULL').first
+        node.ambari_server = true
+        node.save
+        return node
+      end
+    end
+  end
+end

data/lib/models/key_pair.rb

@@ -0,0 +1,12 @@
+class Haas
+  class KeyPair < ActiveRecord::Base
+    validates_uniqueness_of :name
+    before_create :get_private_key
+
+    def get_private_key
+      collection = AWS::EC2::KeyPairCollection.new
+      key = collection.create self.name
+      self.private_key = key.private_key
+    end
+  end
+end

data/lib/models/node.rb

@@ -0,0 +1,5 @@
+class Haas
+  class Node < ActiveRecord::Base
+    belongs_to :cluster
+  end
+end

data/lib/templates/knife.rb.erb

@@ -0,0 +1,12 @@
+current_dir = <%= ENV["HOME"] %>/.haas/
+
+log_level                :info
+log_location             STDOUT
+node_name                "haas"
+client_key               "#{current_dir}/haas-api.pem"
+validation_client_name   "haas"
+validation_key           "#{current_dir}/haas-validator.pem"
+chef_server_url          "https://192.168.20.12/organizations/haas"
+cache_type               'BasicFile'
+cache_options( :path => "#{ENV['HOME']}/.chef/checksums" )
+cookbook_path            ["#{current_dir}/../cookbooks"]

metadata

@@ -0,0 +1,209 @@
+--- !ruby/object:Gem::Specification
+name: haas
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Julien Pellet
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.55'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.55'
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: chef
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.16'
+- !ruby/object:Gem::Dependency
+  name: mixlib-cli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+description: Automatically launch Hadoop or Spark clusters in the cloud
+email: jp@julienpellet.com
+executables:
+- haas
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/haas
+- lib/haas.rb
+- lib/haas/aws.rb
+- lib/haas/blueprints.rb
+- lib/haas/chef.rb
+- lib/haas/config.rb
+- lib/haas/utils.rb
+- lib/models/cluster.rb
+- lib/models/key_pair.rb
+- lib/models/node.rb
+- lib/templates/knife.rb.erb
+homepage: http://github.com/jp/haas
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Launch big data cluster in the cloud
+test_files: []