rightimage_tools 0.2.1 → 0.5.0

data/bin/image_mover

@@ -50,11 +50,11 @@ grant = RightAws::S3::Grantee.new(key_to, 'http://acs.amazonaws.com/groups/globa
 raise "Grant update failed" unless grant
 
 puts "Reindexing source bucket #{bucket_from}"
-indexer_from = RightImage::S3HtmlIndexer.new(options[:bucket_from], ENV["AWS_ACCESS_KEY_ID"], ENV["AWS_SECRET_ACCESS_KEY"])
+indexer_from = RightImageTools::S3HtmlIndexer.new(options[:bucket_from], ENV["AWS_ACCESS_KEY_ID"], ENV["AWS_SECRET_ACCESS_KEY"])
 indexer_from.to_html("index-from.html")
 indexer_from.upload_index("index-from.html")
 
 puts "Reindexing destination bucket #{bucket_to}"
-indexer_to = RightImage::S3HtmlIndexer.new(options[:bucket_to], ENV["AWS_ACCESS_KEY_ID"], ENV["AWS_SECRET_ACCESS_KEY"])
+indexer_to = RightImageTools::S3HtmlIndexer.new(options[:bucket_to], ENV["AWS_ACCESS_KEY_ID"], ENV["AWS_SECRET_ACCESS_KEY"])
 indexer_to.to_html("index-to.html")
 indexer_to.upload_index("index-to.html")

data/bin/mci_merge

@@ -2,7 +2,7 @@
 
 require 'rubygems'
 require 'optparse'
-#require 'ruby-debug'
+require 'ruby-debug'
 require 'rest_connection'
 require 'tmpdir'
 
@@ -57,16 +57,21 @@ sources = []
 dests   = []
 
 mcis.each do |mci|
-  if mci.name =~ /RightImage.*#{Regexp.escape(options[:src])}$/
+  if mci.name =~ /RightImage.*#{Regexp.escape(options[:src])}(_EBS)?$/
     sources << MultiCloudImageInternal.find(mci.rs_id.to_i)
   end
 end
 
+if sources.length == 0
+  puts "Did not find any MCIs with suffix #{options[:src]} to copy"
+  exit 0
+end
+
 puts "Found #{sources.length} MCIs to move: "
 
 sources.each_with_index do |mci, i|
   # print out source mci
-  print i.to_s.ljust(2)+") "
+  print (i+1).to_s.ljust(2)+") "
   puts mci.name
   clouds = mci.multi_cloud_image_cloud_settings.map {|s| s.cloud}
   puts "    CLOUDS: "+clouds.join(", ")
@@ -74,8 +79,9 @@ sources.each_with_index do |mci, i|
 
   # find a destination mci and print that if found
   # else note we'll make a new mci for the destination
-  name_no_suffix = mci.name.sub(options[:src],"") 
+  name_no_suffix = mci.name.sub(options[:src],"").sub("_EBS","")
   dest_mci_name = name_no_suffix + options[:dest]
+  dest_mci_name += "_EBS" if mci.name =~ /_EBS/ and dest_mci_name !~ /_EBS/
   found = mcis.find { |new_mci| new_mci.name == dest_mci_name }
   if found
     dest_mci = MultiCloudImageInternal.find(found.rs_id.to_i)

data/bin/mci_report

@@ -0,0 +1,232 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'yaml'
+require 'irb'
+require 'right_api_client'
+require 'rest_connection'
+require 'trollop'
+require 'highline/import'
+require 'json'
+
+# The only option needed for this program is the ServerTemplate ID.
+trollop_parser = Trollop::Parser.new do
+  opt :st_id, "Generate a report for this Server Template (id)", :type => :integer
+  opt :st_list_file, "Generate a list of MCIs in Server Templates given in the file", :type => :string
+  opt :output_type, "Specify the type of output. Supported formats: text, xml, json", :type => :string
+end
+
+class MciReport
+
+  # Establish a connection to Right_API_Client during the initialization  
+  def initialize
+    @client = RightApi::Client.new(YAML.load_file(File.expand_path('~/.right_api_client/login.yml', __FILE__)))
+  end
+
+  # This function creates a report of all the Multi Cloud Images in a ServerTemplate specified by the ST ID in the input.
+  def generate_mci_report(options)
+    mcis = @client.server_templates(:id => options[:st_id]).show.multi_cloud_images.index
+    
+    # Go through all the Multi Cloud Images in the given ServerTemplate and pull the information required for printing the report. 
+    outer_hash_array = Array.new
+    mcis.each do |mci|
+      outer_hash = Hash.new
+      # Name, Description, Revision, and MCI ID are obtained directly from the MCI object.
+      mci_id = mci.href.split("/").last.to_i
+      outer_hash['title'] = "Name: " + mci.name + " | MCI ID: " + mci_id.to_s + " | Revision: " + mci.show.revision.to_s + "\nDescription: " + mci.show.description      
+      inner_hash_array = Array.new
+      inner_hash = Hash.new
+      
+      # Add all titles in the first array element.
+      inner_hash['detail1'] = "Instance Type"
+      inner_hash['detail2'] = "Image Name"
+      inner_hash['detail3'] = "Cloud"
+      inner_hash_array << inner_hash
+      
+      # This block uses the rest_connection for obtaining information about ec2 images.
+      rest_mci = MultiCloudImage.find(mci_id)
+      rest_mci_settings = rest_mci.find_and_flatten_settings
+      rest_mci_settings.each do |rest_mci_setting|
+        mci_params = rest_mci_setting.params
+        inner_hash = Hash.new
+        
+        # Grab only the information about the ec2 images.
+        if mci_params['aws_instance_type']
+	        inner_hash['detail1'] = mci_params['aws_instance_type']
+          inner_hash['detail2'] = mci_params['image_name']
+          inner_hash['detail3'] = mci_params['cloud']
+        end
+	      inner_hash_array << inner_hash if inner_hash['detail1'] && inner_hash['detail2'] && inner_hash['detail3']
+      end
+
+      # This block uses the regular right_api_client for obtaining information about non-ec2 images.
+      right_mci_settings = mci.settings.index
+      right_mci_settings.each do |right_mci_setting|
+        inner_hash = Hash.new 
+        
+        # If the instance_type api method is not available, don't call the method rather print N/A for instance type in the report.
+        if right_mci_setting.api_methods.include?("instance_type")
+	        inner_hash['detail1'] = right_mci_setting.instance_type.show.name
+        else
+	        inner_hash['detail1'] = "N/A"
+        end
+        inner_hash['detail2'] = right_mci_setting.image.show.name
+	      inner_hash['detail3'] = right_mci_setting.cloud.show.name
+	      inner_hash_array << inner_hash if inner_hash['detail1'] && inner_hash['detail2'] && inner_hash['detail3']
+      end
+      outer_hash['detail'] = inner_hash_array
+      outer_hash_array << outer_hash
+    end
+    self.print_report(options, outer_hash_array, "RightScale MCI Image Report")
+  end
+
+
+  # This function gets the name and id hash and prepares a list of ServerTemplate IDs.
+  def servertemplate_list(servertemplate_name_id_hash)
+    list = []
+    servertemplate_name_id_hash.each do |name, id|
+      list << @client.server_templates(:id => id).show
+    end
+    list
+  end
+
+  # This function creates a report of all ServerTemplates specified in the input file.
+  def generate_servertemplate_report(options, servertemplate_name_id_hash)
+    outer_hash_array = Array.new
+    st_list = servertemplate_list(servertemplate_name_id_hash)
+    st_list.each do |st|
+      outer_hash = Hash.new
+      mcis = st.multi_cloud_images.index 
+      outer_hash['title'] = "Name: " + st.name + " | ID: " + st.object_id.to_s
+      inner_hash_array = Array.new
+      inner_hash = Hash.new
+      inner_hash['detail1'] = "Revision"
+      inner_hash['detail2'] = "Name"
+      inner_hash['detail3'] = "MCI ID"
+      inner_hash_array << inner_hash if inner_hash['detail1'] && inner_hash['detail2'] && inner_hash['detail3']
+      
+      # Go through all the Multi Cloud Images in the given ServerTemplate and pull the information required for printing the report.     
+      mcis.each do |mci|
+        inner_hash = Hash.new
+        mci_id = mci.href.split("/").last.to_i
+        inner_hash['detail1'] = mci.show.revision
+        inner_hash['detail2'] = mci.name
+        inner_hash['detail3'] = mci_id
+        inner_hash_array << inner_hash if inner_hash['detail1'] && inner_hash['detail2'] && inner_hash['detail3']
+      end
+      outer_hash['detail'] = inner_hash_array.sort_by{ |inner_hash| inner_hash['detail2']}
+      outer_hash_array << outer_hash
+    end
+    self.print_report(options, outer_hash_array, "RightScale MCI ServerTemplate Report")
+  end
+ 
+  def print_report(options, outer_hash_array, report_title)
+    if options[:output_type] == "text"
+      self.print_text_report(outer_hash_array, report_title)
+    elsif options[:output_type] == "xml"
+      self.print_xml_report(outer_hash_array, report_title)
+    elsif options[:output_type] == "json"
+      self.print_json_report(outer_hash_array, report_title)
+    else
+      
+      # Default to text report if no type is specified
+      self.print_text_report(outer_hash_array, report_title)
+    end
+  end
+
+  # This functions prints the formatted report in a text file
+  def print_text_report(outer_hash_array, report_title)
+    report_file_name = report_title.gsub(/\s+/, "_") + ".txt"
+    file_handler = File.open(report_file_name, 'w')
+    current_time = Time.new
+  
+    file_handler.puts sprintf("%75s", "******** #{report_title} ********")
+    file_handler.puts ""
+    file_handler.puts "Reported generated at: " + current_time.strftime("%m/%d/%Y %H:%M:%S %Z")
+    file_handler.puts ""
+  
+    outer_hash_array.each do |outer_hash|
+      file_handler.puts '-'*100
+      file_handler.puts outer_hash['title']
+      file_handler.puts '-'*100
+      inner_hash_array = outer_hash['detail']
+      title = inner_hash_array[0]
+      if title
+        title_str = sprintf("%-20s", title['detail1']) + sprintf("%-65s", title['detail2']) + sprintf("%-30s", title['detail3'])
+        title_line_str = sprintf("%-20s", '-'*title['detail1'].size) + sprintf("%-65s", '-'*title['detail2'].size) + sprintf("%-30s", '-'*title['detail3'].size)
+        file_handler.puts "  " + title_str
+        file_handler.puts "  " + title_line_str
+        inner_hash_array.delete(title)
+      end
+      inner_hash_array.each do |inner_hash|
+        detail_str = sprintf("%-20s", inner_hash['detail1']) + sprintf("%-65s", inner_hash['detail2']) + sprintf("%-30s", inner_hash['detail3'])
+        file_handler.puts "  " + detail_str
+      end
+      file_handler.puts ""
+    end
+  end
+
+  def print_xml_report(outer_hash_array, report_title)
+    report_file_name = report_title.gsub(/\s+/, "_") + ".xml"
+    file_handler = File.open(report_file_name, 'w')
+    current_time = Time.new
+    
+    file_handler.puts "<mci_report>"
+    file_handler.puts "<report_title>"
+    file_handler.puts report_title
+    file_handler.puts "</report_title>"
+    file_handler.puts "<generated_time>"
+    file_handler.puts current_time.strftime("%m/%d/%Y %H:%M:%S %Z")
+    file_handler.puts "</generated_time>"
+  
+    outer_hash_array.each do |outer_hash|
+      file_handler.puts "<group>"
+      file_handler.puts "<title>"
+      file_handler.puts outer_hash['title']
+      file_handler.puts "</title>"
+      inner_hash_array = outer_hash['detail']
+      title = inner_hash_array[0]
+      if title
+        inner_hash_array.delete(title)
+        inner_hash_array.each do |inner_hash|
+          detail_str = sprintf("%-20s", inner_hash['detail1']) + sprintf("%-65s", inner_hash['detail2']) + sprintf("%-30s", inner_hash['detail3'])
+          file_handler.puts "<#{title['detail1'].gsub(/\s+/, "_")}>"
+          file_handler.puts inner_hash['detail1'].to_s.strip
+          file_handler.puts "</#{title['detail1'].gsub(/\s+/, "_")}>"
+          file_handler.puts "<#{title['detail2'].gsub(/\s+/, "_")}>"
+          file_handler.puts inner_hash['detail2'].to_s.strip
+          file_handler.puts "</#{title['detail2'].gsub(/\s+/, "_")}>"
+          file_handler.puts "<#{title['detail3'].gsub(/\s+/, "_")}>"
+          file_handler.puts inner_hash['detail3'].to_s.strip
+          file_handler.puts "</#{title['detail3'].gsub(/\s+/, "_")}>"
+        end
+      end
+      file_handler.puts "</group>"
+    end
+    file_handler.puts "</mci_report>" 
+  end
+
+  def print_json_report(outer_hash_array, report_title)
+    report_file_name = report_title.gsub(/\s+/, "_") + ".json"
+    File.open(report_file_name,"w") do |f|
+      f.write(outer_hash_array.to_json)
+    end
+  end
+end
+
+
+# Parse the given options and generate the report accordingly
+options = Trollop::with_standard_exception_handling trollop_parser do
+  raise Trollop::HelpNeeded if ARGV.empty?
+  trollop_parser.parse ARGV
+end
+
+mr = MciReport.new
+
+if options[:st_id]
+  mr.generate_mci_report(options)
+elsif options[:st_list_file]
+  yaml_contents = YAML.load_file(File.expand_path(options[:st_list_file], __FILE__))
+  mr.generate_servertemplate_report(options, yaml_contents)
+end
+

data/bin/mcicp

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'rest_connection'
+require 'trollop'
+require 'highline/import'
+
+options = Trollop::options do
+  opt :from, "Copy MCIs from this Server Template (id)", :type => :integer, :required => :true
+  opt :to, "Copy MCIs to this Server Template (id)", :type => :integer, :required => :true
+  opt :skip, "Skip MCIs matching a certain regex", :type => :string
+  opt :nice, "Non-Destructive update of the destination Server Template"
+end
+
+class MciCp
+  def self.go(options)
+    temp1 = ServerTemplate.find(options[:from])
+    temp2 = ServerTemplate.find(options[:to])
+    from_st = ServerTemplateInternal.new(:href => temp1.href)
+    mci_payload = from_st.multi_cloud_images
+    to_st = ServerTemplateInternal.new(:href => temp2.href)
+    to_delete = to_st.multi_cloud_images
+    mci_payload.each do |mci|
+      begin
+        if options[:skip] and mci['name'] =~ /#{options[:skip]}/
+          puts "skipping #{mci['name']}, matches skip criteria" 
+        else
+          to_st.add_multi_cloud_image(mci['href'])
+          puts "adding #{mci['name']}"
+        end
+      rescue => e
+        puts "image #{mci['name']} already added, skipping" if ENV['DEBUG']
+        to_delete.delete(mci)
+      end
+    end
+    default_mci = mci_payload.find {|d| d['name'] =~ /CentOS.+x64/ and d['name'] !~ /EBS/}
+    unless default_mci
+      default_mci = mci_payload.first
+    end
+    puts "setting default mci #{default_mci['name']}"
+    to_st.set_default_multi_cloud_image(default_mci['href'])
+    unless options[:nice]
+      to_delete.each do |mci|
+        to_st.delete_multi_cloud_image(mci['href'])
+        puts "deleting #{mci['name']}"
+      end
+    end
+    puts 'done.'
+  end
+end
+
+MciCp.go(options)

data/bin/report_tool

@@ -0,0 +1,404 @@
+#!/usr/bin/env ruby
+
+# Copyright RightScale, Inc. All rights reserved.  All access and use subject to the
+# RightScale Terms of Service available at http://www.rightscale.com/terms.php and,
+# if applicable, other agreements such as a RightScale Master Subscription Agreement.
+
+#
+# report_tool: Parses system calls and hint files to return a JSON summary of the running system.
+#
+
+require 'rubygems'
+# JSON not in core-ruby.
+require 'json'
+# Platform checking.
+require 'rbconfig'
+
+# Monkeypatch to recursively clean empty hashes.
+class Hash
+  def rec_delete_empty
+    delete_if{|k, v| v.nil? or v.empty? or v.instance_of?(Hash) && v.rec_delete_empty.empty?}
+  end
+end
+
+
+# Borrowed from ohai and modifies to detect hypervisor in rebundles.
+def hyperChecker
+  #
+  # Modifed by Drew Waranis.
+  # RightScale, Inc. 2012
+  #
+
+  #
+  # Author:: Thom May (<thom@clearairturbulence.org>)
+  # Copyright:: Copyright (c) 2009 Opscode, Inc.
+  # License:: Apache License, Version 2.0
+  #
+  # Licensed under the Apache License, Version 2.0 (the "License");
+  # you may not use this file except in compliance with the License.
+  # You may obtain a copy of the License at
+  #
+  #     http://www.apache.org/licenses/LICENSE-2.0
+  #
+  # Unless required by applicable law or agreed to in writing, software
+  # distributed under the License is distributed on an "AS IS" BASIS,
+  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  # See the License for the specific language governing permissions and
+  # limitations under the License.
+  #
+
+  virtualization = Hash.new
+
+  # Try virt-what first.
+  if File.exists?("/usr/sbin/virt-what")
+    return `/usr/sbin/virt-what`.split("\n").first
+  end
+
+  # Xen
+  # /proc/xen is an empty dir for EL6 + Linode Guests
+  if File.exists?("/proc/xen"); return "xen"; end
+
+  # Xen Notes:
+  # - cpuid of guests, if we could get it, would also be a clue
+  # - may be able to determine if under paravirt from /dev/xen/evtchn (See OHAI-253)
+  # - EL6 guests carry a 'hypervisor' cpu flag
+  # - Additional edge cases likely should not change the above assumptions
+  #   but rather be additive - btm
+
+  # Detect from kernel module
+  if File.exists?("/proc/modules")
+    if File.read("/proc/modules") =~ /^kvm/; return "vbox"; end
+  end
+
+  # Detect KVM/QEMU from cpuinfo, report as KVM
+  # We could pick KVM from 'Booting paravirtualized kernel on KVM' in dmesg
+  # 2.6.27-9-server (intrepid) has this / 2.6.18-6-amd64 (etch) does not
+  # It would be great if we could read pv_info in the kernel
+  # Wait for reply to: http://article.gmane.org/gmane.comp.emulators.kvm.devel/27885
+  if File.exists?("/proc/cpuinfo")
+    if File.read("/proc/cpuinfo") =~ /QEMU Virtual CPU/; return "kvm"; end
+  end
+
+  # Detect OpenVZ / Virtuozzo.
+  # http://wiki.openvz.org/BC_proc_entries
+  if File.exists?("/proc/vz"); return "openvz"; end
+
+  # http://www.dmo.ca/blog/detecting-virtualization-on-linux
+  if File.exists?("/usr/sbin/dmidecode")
+    dmi_info = `/usr/sbin/dmidecode`
+    case dmi_info
+    when /Manufacturer: Microsoft/ then return "virtualpc"
+    when /Manufacturer: VMware/ then return "vmware"
+    when /Manufacturer: Xen/ then return "xen"
+    end
+  end
+
+  # Detect Linux-VServer
+  if File.exists?("/proc/self/status")
+    vxid = File.read("/proc/self/status").match(/^(s_context|VxID): (\d+)$/)
+    if vxid and vxid[2] then return "linux-vserver"; end
+  end
+
+  return nil;
+end
+# End hypervisor checker.
+
+
+# JSON class infrastructure.
+
+# Inform parser what platform file is from.
+class OS
+  def initialize() 
+    # If it contains linux then Linux, otherwise Windows (future dev).
+    if Config::CONFIG["host_os"] =~ /linux/i
+      @os = "linux"
+    else  
+      @os = "windows"
+    end 
+  end
+
+  def to_hash(*a) {"os" => @os}.rec_delete_empty end 
+                                # Strip empty values
+end
+
+
+# Linux Standard Base.
+# lsb_release: id (i), description (d), release (r), codename (c) .
+class LSB
+  def initialize()
+    # Retrieve and split command output.
+    lsb = `lsb_release -ircs`.split
+
+    @id = lsb[0]
+    # Called separately to get full description with spaces.
+    # Sanitize newline and quotes.
+    @description = `lsb_release -ds`.sub("\n",'').gsub("\"",'')
+    @release = lsb[1]
+    @codename = lsb[2]
+  end
+
+  def to_hash(*a)
+    { "lsb" =>
+      {"id" => @id,
+       "description" => @description,
+       "release" => @release,
+       "codename" => @codename} 
+    }.rec_delete_empty
+  end
+end
+
+# Kernel release name.
+# Retrieved from /boot/grub/grub.conf if it is available,
+  # else from menu.lst if is available,
+  # else from the vmlinuz filename if it is available,
+  # else nil.
+# rec_empty_delete strips empty and nil values.
+class Kern
+  def initialize()
+    # kernel-release is on the first line beginning with "(optional whitespace)initrd".
+    # It is located after the first "-" and should not include an ending ".img", if present.
+    if File.exists? "/boot/grub/grub.conf"
+      @release = IO.read("/boot/grub/grub.conf").match(/^\s*initrd[^-]*-(.*?)(\.img)?$/)[1]
+    elsif File.exists? "/boot/grub/menu.lst"
+      @release = IO.read("/boot/grub/menu.lst").match(/^\s*initrd[^-]*-(.*?)(\.img)?$/)[1]
+    # As a fallback, get kernel-release from the newest vmlinux filename.
+    elsif Dir.entries("/boot/grub/").grep(/vmlinuz*/)
+      @release = (Dir.glob("/boot/vmlinuz*").max_by {|f| File.mtime(f)}).match(/vmlinuz[^-]*-(.*)/)[1]
+    else
+      @release = nil
+    end
+  end
+
+  def to_hash(*a)
+    {"kernel" => 
+      {"release" => @release}
+    }.rec_delete_empty
+  end
+end
+
+# Report the presence (and features they enable) of selected modules.
+class Mods
+  def initialize(release)
+
+    # Cancel if kernel version wasn't determined.
+    if release.nil?
+      @mods = nil
+    end
+
+    # Manual ist of which modules to check.
+    # Also update the case-statment below.
+    modules_list = %w"dm-mod xfs"
+
+    # Set locations based on kernel version.
+    kernel_config = "/boot/config-#{release}"
+    modules_dir = "/lib/modules/#{release}"
+
+    # Returned by the function to merge into the Kern hash.
+    @mods = Hash.new
+
+    modules_list.each do |mod|
+      case mod
+      when "dm-mod"
+        # Pretty print name.
+        feature = "LVM2 (dm-mod)"
+        # Flag name in the kerne's config file.
+        flag = "CONFIG_BLK_DEV_DM"
+      when "xfs"
+        feature = "XFS (xfs)"
+        flag = "CONFIG_XFS_FS"
+      else
+        # If module is not defined here, then skip.
+        next
+      end
+
+      # Check the kernel's config file, if it exists.
+      if File.exists? "#{kernel_config}"
+        # Check what the flag is set to.
+        case `cat #{kernel_config} | grep #{flag}=`.chomp.split("=")[1]
+        when "y"
+          status = "Built-In"
+        when "m"
+          status = "Module"
+        when "n"
+          status = "Not Selected"
+        end
+      # As a backup, check if it is dynamically compiled in /lib/modules .
+      elsif `find #{modules_dir} -name "#{mod}.ko"`
+        status = "Module"
+      else
+        status = "Not Available"
+      end
+      @mods[feature] = status
+    end
+  end
+  # Strips value if nil.
+  def to_hash(*a)
+    {"modules" => @mods }.rec_delete_empty
+  end
+end
+
+# List packages on Linux system.
+# Takes the LSB's id as an argument.
+class Packages
+  def initialize(id)
+    # Prep packages hash
+    packs = Hash.new
+
+    # Linux distro family specific options:
+      # Ubuntu = dpkg,
+      # CentOS/RHEL = rpm,
+        # or exit.
+ 
+    case id
+      when "Ubuntu"
+        # Read packages into a hash.
+        `dpkg-query -W`.each_line{ |line|
+          col = line.split 
+          packs[col[0]] = col[1]
+          }
+
+      when "CentOS", /RedHat/
+        # Read packages into a hash.
+        `rpm -qa --qf "%{NAME}\t%{VERSION}\n"`.each_line{ |line|
+              col = line.split
+              packs[col[0]] = col[1]
+              }
+      else
+        packs["This distro"] = "is not supported."
+        exit
+      end
+
+    # Store in instance variable to extract rightlink version.
+    @packages = packs
+  end
+
+  def to_hash(*a)
+    { "packages" => @packages }.rec_delete_empty
+  end
+end
+
+
+# Holds RS specific info.
+# Takes hint hash as arg.
+class RightScaleMirror
+  def initialize(hint)
+    @repo_freezedate = hint["freeze-date"]
+    @rubygems_freezedate = hint["freeze-date"]
+    @rightlink_version = hint["rightlink-version"]
+  end
+
+  def to_hash(*a)
+    {"rightscale-mirror" =>
+      {"repo-freezedate" => @repo_freezedate, 
+      "rubygems-freezedate" => @rubygems_freezedate,
+      "rightlink-version" => @rightlink_version
+      }
+    }.rec_delete_empty
+  end
+end
+
+# Holds info about the image.
+# MD5 sums added to report_hash in later step.
+# Takes hint hash as arg.
+class Image
+  def initialize(hint)
+    @build_date = hint["build-date"]
+  end
+
+  def to_hash(*a)
+    {"image" => 
+      {"build-date" => @build_date} 
+    }.rec_delete_empty
+  end
+end
+
+# Holds the type and version of hypervisor.
+# Takes hint hash as arg.
+class Virtualization
+  def initialize(hint)
+    # If the entry is in the hint file, use it.
+    if not hint["hypervisor"].nil?
+      @hypervisor = hint["hypervisor"]
+    # Checks if report_tool is being chrooted.
+    # If not, check for hypervisor.
+    # Chomp return character.
+    elsif `if [ "$(stat -c %d:%i /)" == "$(stat -c %d:%i /proc/1/root/. 2>/dev/null)" ];
+           then echo "true";
+           else echo "false"; 
+           fi`.chomp == "true"
+      @hypervisor = hyperChecker
+    # report_tool is running in a chroot and and the hypervisor cannot be properly determined.
+    else
+      @hypervisor = nil;
+    end
+  end
+
+  def to_hash(*a)
+    {"virtualization" => 
+      {"hypervisor" => @hypervisor,
+       "version" => @version}
+    }.rec_delete_empty
+  end
+end
+
+# Name of the cloud the image is meant for.
+class Cloud
+  def initialize()
+    # Safely ignores hint if not available.
+    if File.exists? "/etc/rightscale.d/cloud"
+      @provider = File.open("/etc/rightscale.d/cloud", &:readline)
+    else
+      @provider = nil
+    end 
+  end
+  # Strips value if nil.
+  def to_hash(*a)
+    {"cloud" => 
+      {"provider" => @provider}
+    }.rec_delete_empty
+  end
+end
+
+# End JSON class infrastructure.
+
+# Merge JSON of classes into report_hash.
+report_hash = Hash.new
+report_hash.merge!(OS.new)
+# Switch on OS.
+if report_hash["os"] != "linux"
+  puts "Windows support is coming... soon."
+  exit
+end
+
+# And the rest.
+report_hash.merge!(LSB.new)
+report_hash.merge!(Kern.new)
+# Take kernel version as argument.
+report_hash.merge!(Mods.new(report_hash["kernel"]["release"]))
+report_hash.merge!(Cloud.new)
+
+# Take platform as argument.
+report_hash.merge!(Packages.new(report_hash["lsb"]["id"]))
+
+# Give hint hash.
+if File.exists? "/etc/rightscale.d/rightimage-release.js"
+  hint = JSON.parse(File.read("/etc/rightscale.d/rightimage-release.js"))
+# Otherwise give empty hint hash.
+else
+  hint = Hash.new
+end  
+  
+# Receive hint.
+report_hash.merge!(RightScaleMirror.new(hint))
+report_hash.merge!(Image.new(hint))
+report_hash.merge!(Virtualization.new(hint))
+
+# Print results if flag is set.
+if(ARGV[0] == "print" )
+  puts JSON.pretty_generate(report_hash)
+end
+
+# Save JSON to /tmp.
+File.open("/tmp/report.js","w") do |f|
+  f.write(JSON.pretty_generate(report_hash))
+end