iravat 0.1.0

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "iravat"
+  gem.homepage = "http://github.com/aloksrivastava78/iravat"
+  gem.license = "MIT"
+  gem.summary = %Q{Access to AWS }
+  gem.description = %Q{Access to AWS}
+  gem.email = "alok@chipmonk.in"
+  gem.authors = ["alok"]
+  gem.files =%w(Rakefile) + Dir.glob("lib/**/*")
+  gem.require_path = 'lib'
+# Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "iravat #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/awsconf/aws_config.xml

@@ -0,0 +1,28 @@
+<ChipMonkAWSConfigs>
+
+    <AWSAccessKey>
+        <AWSAccessKey>AKIAI3PFX46PLS7Q2FSQ</AWSAccessKey>
+        <AWSAccessSecretKey>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</AWSAccessSecretKey>
+    </AWSAccessKey>
+
+    <S3>
+        <Server>s3.amazonaws.com</Server>
+        <Port>443</Port>
+        <Protocol>https</Protocol>
+        <MultiThread>false</MultiThread>
+        <NamePrefix>ChipMonk</NamePrefix>
+        <NameSuffix>S3</NameSuffix>
+	      <Delimeter>-</Delimeter>
+    </S3>
+
+    <EC2>
+        <NamePrefix>ChipMonk></NamePrefix>
+       <NameSuffix>S3</NameSuffix>        
+    </EC2>
+
+    <LogFile>
+	<FileName>log.txt</FileName>
+    </LogFile>
+
+
+</ChipMonkAWSConfigs>

data/lib/awsconf/ir_aws_config_manager.rb

@@ -0,0 +1,62 @@
+module Iravat 
+
+#require './ir_module'
+
+class IrAwsConfigManager
+
+
+#Constructor: takes default configuration from preconfigured path unless changed
+# by caller.
+
+def initialize(confXMLPath=IRAVAT_AWS_CONFIG_XML_PATH)
+    $ir_logger=IrLogger.new(IRAVAT_AWS_CONFIG_LOGGER)
+    $logger=$ir_logger.getLog4rLogger()
+    @confXMLPath=confXMLPath
+end
+
+
+def loadConfigurationFile()
+    begin
+    @xmlDom = Nokogiri::XML(File.open(@confXMLPath).read)
+
+   
+    if(@xmlDom.nil?)
+        #$log.error("XML DOM is null")        
+        $logger.error("AWS XML parsing resulted in error. Document is null.")
+    end
+    rescue Nokogiri::XML::SyntaxError
+       # $log.error("Exception raised while parsing XML file")
+        $logger.error("Exception raised while parsing XML file")
+        return
+    end
+end
+
+def getPathFromXML(path)
+    nodeSet= @xmlDom.xpath(path)
+     if(nodeSet.nil?)
+       $logger.error("Nothing present in path:" + path)
+       return ""
+    end
+    #TODO Add multi node
+    if(nodeSet.length() != 1)
+        $logger.error("Bad XML configuration file:" + @confXMLPath + " for path " + path)
+        return ""
+    end
+
+    return nodeSet[0].text
+end
+
+end
+
+if __FILE__ == $0
+    #Unit tester hack
+    #require './ir_log_initializer.rb'
+    #li = IrLogInitializer.new
+    #li.init()
+    ########################
+    instance = IrAwsConfigManager.new(IRAVAT_AWS_CONFIG_XML_PATH)
+    instance.loadConfigurationFile()
+    $logger.info(instance.getPathFromXML("/ChipMonkAWSConfigs/AWSAccessKey/AWSAccessKeyID"))
+end
+
+end

data/lib/ec2/ir_ec2.rb

@@ -0,0 +1,190 @@
+module Iravat
+
+#require './ir_module'
+
+class IrEC2
+
+  def initialize()
+    @logger = IrLogger.new(self.class.name).getLog4rLogger()
+    awsConfig=IrAwsConfigManager.new(IRAVAT_AWS_CONFIG_XML_PATH)
+    awsConfig.loadConfigurationFile()
+    @awsKeyID=awsConfig.getPathFromXML("/ChipMonkAWSConfigs/AWSAccessKey/AWSAccessKey")
+    @awsSecretKey=awsConfig.getPathFromXML("/ChipMonkAWSConfigs/AWSAccessKey/AWSAccessSecretKey")
+  end
+
+
+  #common error handler for RightScale Lib
+  def error_ec2 (err)
+      err.errors.each do |e|
+        @logger.error(err.errors)
+      end
+  end 
+
+
+  def connectToAWS()
+    begin
+      @ec2   = RightAws::Ec2.new(@awsKeyID,@awsSecretKey)
+      if(@ec2.nil?)
+        @logger.error("Failed to create an access to EC2")
+        return false
+      end
+        return true
+      rescue RightAws::AwsError=>err 
+        self.error_ec2(err)
+        return false
+    end
+  end
+
+
+  def getKey()
+    begin
+      key = @ec2.describe_key_pairs()[0][:aws_key_name]
+      if(key.nil?)
+        @logger.error("No Key pair existing")
+      end
+      return key
+      rescue RightAws::AwsError=>err 
+        self.error_ec2(err)
+        return nil
+    end
+  end
+
+  
+  def  getSecurityGroup()
+    begin
+      securityGroup = @ec2.describe_key_pairs()[0]
+      if(securityGroup.nil?)
+        @logger.error("No security group created")
+      end
+      return securityGroup
+      rescue RightAws::AwsError=>err 
+        self.error_ec2(err)
+        return nil
+    end
+  end
+  
+
+  def printAllActiveImages()
+    begin
+      awsInstances=@ec2.describe_instances
+      #Loop on all instance
+      awsInstances.each do |awsInstance|
+        @logger.info("============================================")
+        @logger.info("AWS Instance ID:" + awsInstance[:aws_instance_id])
+        @logger.info("AWS Image ID:" + awsInstance[:aws_image_id])
+        @logger.info("AWS State:" + awsInstance[:aws_state])
+        if( awsInstance[:aws_state] == "running")
+          @logger.info("IP Address:" + awsInstance[:ip_address])
+          @logger.info("DNS Name:" + awsInstance[:dns_name])
+          @logger.info("AWS Instance Type:" + awsInstance[:aws_instance_type])
+          @logger.info("AWS Private DNS Name:" + awsInstance[:private_dns_name])
+          @logger.info("AWS Instance Launch Time:" + awsInstance[:aws_launch_time])
+          @logger.info("AWS Availability Zone:" + awsInstance[:aws_availability_zone])
+      
+          blockDevicesMapped=awsInstance[:block_device_mappings]
+      
+          blockDevicesMapped.each do |blockDevice|
+            @logger.info("  -----------------------------------------------")
+            @logger.info("  EBS Device Name:" + blockDevice[:device_name])
+            @logger.info("  EBS Device ID:" + blockDevice[:ebs_volume_id])
+            @logger.info("  EBS Device Attach Time:" + blockDevice[:ebs_attach_time])
+            @logger.info("  -----------------------------------------------")
+          end
+        end
+
+        @logger.info("============================================")     
+      end
+      rescue RightAws::AwsError=>err 
+        self.error_ec2(err)
+        return nil
+    end
+  end
+
+
+  def createNewInstance(imageID,instanceType, availablilityZone, userCookieData)
+    #run_instances(image_id, min_count, max_count, group_ids, key_name, user_data='', addressing_type = nil,
+    #instance_type = nil, kernel_id = nil, ramdisk_id = nil, availability_zone = nil, monitoring_enabled = nil,
+    #subnet_id = nil, disable_api_termination = nil, instance_initiated_shutdown_behavior = nil, block_device_mappings = nil,
+    #placement_group_name = nil, client_token = nil)
+    begin
+      responseDetails=@ec2.run_instances(imageID,
+                       1,
+                       1,
+                       self.getSecurityGroup()[:aws_group_name],
+                       self.getKey(),
+                       userCookieData,
+                       nil,
+                       instanceType,
+                       nil,
+                       nil,
+                       availablilityZone)[0]
+
+
+
+      @logger.debug("============================================")
+      @logger.debug("AMI instance launched")
+      @logger.debug("Instance ID:" + responseDetails[:aws_instance_id])
+      @logger.debug("Instance State:" + responseDetails[:aws_state])
+      @logger.debug("Instance Type:" + responseDetails[:aws_instance_type])
+      @logger.debug("Availability Zone:" + responseDetails[:aws_availability_zone])
+      @logger.debug  ("============================================")
+      rescue RightAws::AwsError=>err 
+        self.error_ec2(err)
+        return nil
+    end
+    return responseDetails[:aws_instance_id]
+
+ end
+
+
+ def rebootInstance(instanceID)
+    begin
+      response=@ec2.reboot_instances(instanceID)
+      if(response == false)
+         @logger.debug("AMI instance id " + instanceID + "failed to reboot")      
+      else
+         @logger.debug("AMI instance id " + instanceID + "rebooted successfully")
+      end
+      rescue RightAws::AwsError=>err 
+        self.error_ec2(err)
+        return nil
+    end
+ end
+
+  def terminateInstance(instanceID)
+     begin
+      instanceIDArr=[instanceID]
+      responseDetails=@ec2.terminate_instances(instanceIDArr)
+      @logger.debug("============================================")
+      @logger.debug("AMI instance terminated")
+      @logger.debug("Instance ID:" + responseDetails[0][:aws_instance_id])
+      @logger.debug("Current State Code:" + responseDetails[0][:aws_current_state_code].to_s())
+      @logger.debug("Current State Name:" + responseDetails[0][:aws_current_state_name])
+      @logger.debug("Previous State Code:" + responseDetails[0][:aws_prev_state_code].to_s())
+      @logger.debug("Previous State Name:" + responseDetails[0][:aws_prev_state_name])
+      @logger.debug("============================================")
+      rescue RightAws::AwsError=>err 
+        self.error_ec2(err)
+        return nil
+    end      
+  end
+end
+
+if __FILE__ == $0
+    #require './ir_log_initializer.rb'
+    #li = IrLogInitializer.new
+    #li.init()
+    #$ir_logger=IrLogger.new("AnotherLogger")
+    #@logger=$ir_logger.getLog4rLogger()
+    ec2Manager=IrEC2.new
+    if(ec2Manager.connectToAWS() == true)
+      ec2Manager.printAllActiveImages()
+      instanceID=ec2Manager.createNewInstance("ami-00d62369", "t1.micro","us-east-1b","Sudhanshu-Started")
+      ec2Manager.terminateInstance(instanceID)
+      ec2Manager.printAllActiveImages()
+    end
+
+
+end
+
+end

data/lib/iravat.rb

@@ -0,0 +1,28 @@
+require 'right_aws'
+require 'logger'
+require 'rubygems'
+require 'nokogiri'
+require 'log4r'
+require 'log4r/configurator'
+
+
+$:.unshift(File.dirname(__FILE__))
+require 'logger/ir_logger'
+require 'logger/ir_log_initializer'
+require 'awsconf/ir_aws_config_manager'
+require 's3/ir_s3'
+require 'ec2/ir_ec2'
+
+module Iravat
+
+  IRAVAT_RIGHT_SCALE_LOGGER = 'RightScaleLogger'
+  IRAVAT_LOGGER_DEFAULT_LOGGER = 'MasterLogger'
+  IRAVAT_AWS_CONFIG_LOGGER = 'AWSConfig'
+
+  IRAVAT_LOG_CONFIG_XML = File.expand_path(File.dirname(__FILE__)) +'/' + 'logger/log4r_config.xml'
+  IRAVAT_LOG_PATH = './'
+
+  IRAVAT_LOG_FILE = File.expand_path(File.dirname(__FILE__)) + '/' + 'logger/my_configfile.log'
+
+  IRAVAT_AWS_CONFIG_XML_PATH = File.expand_path(File.dirname(__FILE__)) + '/' + 'awsconf/aws_config.xml'
+end

data/lib/logger/ir_log_initializer.rb

@@ -0,0 +1,29 @@
+module Iravat
+
+#require './ir_module'
+
+class IrLogInitializer
+    
+    include Log4r
+
+    def self.init()
+        begin
+          Configurator['logpath'] = IRAVAT_LOG_PATH # was './logs'
+          Configurator.load_xml_file(IRAVAT_LOG_CONFIG_XML)
+          rescue Log4r::ConfigError => e
+            puts "Error in configuration log4r ==== " + e.message 
+        end
+    end
+    
+end
+
+
+if __FILE__ == $0
+  #li = IrLogInitializer.new
+  #li.init()
+  IrLogInitializer::init()
+  log =Log4r::Logger["MainLogger"]
+  log.fatal("hi")
+end
+
+end

data/lib/logger/ir_logger.rb

@@ -0,0 +1,104 @@
+module Iravat
+
+#require './ir_module'
+
+class IrLogger
+  
+  def initialize(loggerType = IRAVAT_LOGGER_DEFAULT_LOGGER)  
+      IrLogInitializer::init()
+      @module_logger =Log4r::Logger[loggerType]
+       
+      if( @module_logger.nil?)
+          print( " == Unable to initiate logging for module " + loggerType + "==== Falling back to MasterLogger <log4r_config.xml>\n")
+          @module_logger =Log4r::Logger[IRAVAT_LOGGER_DEFAULT_LOGGER]
+          if (@module_logger.nil? )
+            #Falling to default Ruby Logger 
+            @module_logger = Logger.new(IRAVAT_LOG_FILE)
+            @module_logger.warn("Unable to initiate logging for module MasterLogger\n")
+          end
+      end
+  end
+
+
+  def getLog4rLogger()
+    return @module_logger
+  end
+
+
+  def trace(message)
+      if( @module_logger.nil?)
+          print("TRACE:" + message + "\n")
+      else
+           @module_logger.trace(message)
+      end
+  end
+
+
+  def debug(message)
+      if( @module_logger.nil?)
+          print("DEBUG:" + message + "\n")
+      else
+           @module_logger.debug(message)
+      end
+  end
+
+
+  def info(message)
+      if( @module_logger.nil?)
+          print("INFO:" + message + "\n")
+      else
+           @module_logger.info(message)
+      end
+  end
+
+
+  def warn(message)
+      if( @module_logger.nil?)
+          print("WARN:" + message + "\n")
+      else
+           @module_logger.warn(message)
+      end
+  end
+
+
+  def error(message)
+      if( @module_logger.nil?)
+          print("ERROR:" + message + "\n")
+      else
+           @module_logger.error(message)
+      end
+  end
+
+
+  def fatal(message)
+      if( @module_logger.nil?)
+          print("FATAL:" + message + "\n")
+      else
+           @module_logger.error(message)
+      end
+  end
+end
+
+
+if __FILE__ == $0
+     require './ir_log_initializer.rb'
+     #call only once
+     #li = IrLogInitializer.new
+     #li.init()
+     #IrLogInitializer::init()
+     ########################
+
+     #call on head of file
+     log = IrLogger.new("AnotherLogger")
+     ############
+     
+
+     log.debug("Hi debug")
+     log.info("Hi info")
+     log.warn("Hi warn")
+     log.error("Hi error")
+     log.fatal("Hi fatal")
+
+end
+
+end

data/lib/logger/log4r_config.xml

@@ -0,0 +1,59 @@
+ 
+<log4r_config>
+ 
+  <pre_config>
+    <custom_levels>DEBUG, INFO, WARN, ERROR, FATAL</custom_levels>
+    <global level="ALL"/>
+  </pre_config>
+ 
+    <outputter name="console" type="StdoutOutputter" level="DEBUG" >
+        <formatter type="Log4r::PatternFormatter">
+            <pattern>=>[%5l %d] %C: %M [%t]</pattern>
+        </formatter>
+    </outputter>
+ 
+    <outputter name="file_outputter" type="FileOutputter">
+        <filename>/var/log/chipmonk/iravat/logs.txt</filename>
+        <formatter type="Log4r::PatternFormatter">
+            <pattern>=>[%5l %d] %C: %M [%t]</pattern>
+        </formatter>
+    </outputter>
+ 
+    <logger name="MasterLogger"
+                level="ALL" additive="false" trace="true">
+        <outputter>file_outputter</outputter>
+    </logger>
+ 
+   <logger name="S3Logger"
+                level="ALL" additive="false" trace="true">
+        <outputter>console</outputter>
+        <outputter>file_outputter</outputter>
+    </logger>
+
+    <logger name="Ec2Logger"
+                level="ALL" additive="false" trace="true">
+        <outputter>console</outputter>
+        <outputter>file_outputter</outputter>
+    </logger>
+    
+    <logger name="AWSConfig"
+                level="ALL" additive="false" trace="true">
+        <outputter>console</outputter>
+        <outputter>file_outputter</outputter>
+    </logger>
+
+    <logger name="RightScaleLogger"
+                level="ALL" additive="false" trace="true">
+        <outputter>console</outputter>
+        <outputter>file_outputter</outputter>
+    </logger>
+</log4r_config>
+W, [2011-04-20T15:23:41.665759 #9565]  WARN -- : Unable to initiate logging for module MasterLogger
+
+W, [2011-04-20T15:23:41.665927 #9565]  WARN -- : Unable to initiate logging for module MasterLogger
+
+W, [2011-04-20T15:23:41.666407 #9565]  WARN -- : Unable to initiate logging for module MasterLogger
+
+I, [2011-04-20T15:23:41.666576 #9565]  INFO -- : New RightAws::S3Interface using shared connections mode
+I, [2011-04-20T15:23:41.667076 #9565]  INFO -- : Opening new HTTPS connection to s3.amazonaws.com:443
+I, [2011-04-20T15:23:43.238456 #9565]  INFO -- : New RightAws::S3Interface using shared connections mode

data/lib/s3/ir_s3.rb

@@ -0,0 +1,100 @@
+ module Iravat
+ 
+
+  class IrS3  
+       
+
+    def load_config()
+      @config = IrAwsConfigManager.new(IRAVAT_AWS_CONFIG_XML_PATH)
+      @config.loadConfigurationFile()
+    end
+
+
+    def get_config(xpath)
+      @config.getPathFromXML(xpath)
+    end
+
+
+    def initialize()
+      @logger = IrLogger.new(self.class.name).getLog4rLogger()
+
+      self.load_config()
+
+      @aws_access_key_id = self.get_config('/ChipMonkAWSConfigs/AWSAccessKey/AWSAccessKey')
+      @aws_secret_access_key =  self.get_config('/ChipMonkAWSConfigs/AWSAccessKey/AWSAccessSecretKey')
+      
+      @s3config =  {:server  => self.get_config('/ChipMonkAWSConfigs/S3/Server'),   # Amazon service host: 's3.amazonaws.com'(default)
+                   :port         => self.get_config('/ChipMonkAWSConfigs/S3/Port'),   # Amazon service port: 80 or 443(default)
+                   :protocol     => self.get_config('/ChipMonkAWSConfigs/S3/Protocol'),   # Amazon service protocol: 'http' or 'https'(default)
+                   :multi_thread => self.get_config('/ChipMonkAWSConfigs/S3/MultiThread'),    # Multi-threaded (connection per each thread): 
+                   :logger       => IrLogger.new(IRAVAT_RIGHT_SCALE_LOGGER).getLog4rLogger(),}   # Defaults to Stdout
+      
+      @name_prefix = self.get_config('/ChipMonkAWSConfigs/S3/NamePrefix')
+      @name_suffix = self.get_config('/ChipMonkAWSConfigs/S3/NameSuffix')
+      @delimeter =  self.get_config('/ChipMonkAWSConfigs/S3/Delimeter')
+    end
+
+
+    #common error handler for RightScale Lib
+    def error_aws (aws,err)
+      err.errors.each do |e|
+        @logger.error( "#### System Error #### " + err.errors)
+      end
+    end
+
+
+    def list_s3_bucket()
+      s3 = RightAws::S3.new(@aws_access_key_id,  @aws_secret_access_key,@s3config)
+    
+      my_bucket_names = s3.buckets.map { |b| b.name}
+      @logger.info("Buckets on S3: #{my_bucket_names.join(', ')}")
+          
+      rescue RightAws::AwsError=>err 
+        self.error_aws(s3,err) 
+    end
+
+
+    def create_s3_bucket(username)
+      s3 = RightAws::S3.new(@aws_access_key_id,  @aws_secret_access_key,@s3config)
+      
+      bucketname = @name_prefix+@delimeter+username+@delimeter+@name_suffix
+      
+      @logger.info(bucketname)
+
+      bucket = s3.bucket(bucketname, true)
+      rescue RightAws::AwsError=>err
+        self.error_aws(s3,err)
+      
+      #  keymap=bucket.keys.map{|key| key.name}
+      #  puts "File list : #{keymap.join(', ')}"
+    end
+
+
+    def delete_s3_bucket(bucketname)
+      s3 = RightAws::S3.new(@aws_access_key_id,  @aws_secret_access_key,@s3config)
+      bucket = s3.bucket(bucketname)
+      if( bucket.nil?)
+        raise "No Bucket Exist"
+      end
+      #clear objects from bucket
+      bucket.clear()
+      bucket.delete(:force=>false)
+      rescue RightAws::AwsError=>err
+        self.error_aws(s3,err)
+
+      #Handling the RuntimeError
+      rescue => e 
+        @logger.warn(e.message)
+    end
+  end
+ 
+
+  if __FILE__ == $0
+    ir = IrS3.new
+    
+    ir.create_s3_bucket("alok")
+    ir.list_s3_bucket()
+    #ir.delete_s3_bucket("iravattest")
+  end
+
+  end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification 
+name: iravat
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- alok
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-23 00:00:00 +05:30
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :development
+  prerelease: false
+  name: shoulda
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  type: :development
+  prerelease: false
+  name: bundler
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  type: :development
+  prerelease: false
+  name: jeweler
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  type: :development
+  prerelease: false
+  name: rcov
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id004
+description: Access to AWS
+email: alok@chipmonk.in
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- lib/awsconf/aws_config.xml
+- lib/awsconf/ir_aws_config_manager.rb
+- lib/ec2/ir_ec2.rb
+- lib/iravat.rb
+- lib/logger/ir_log_initializer.rb
+- lib/logger/ir_logger.rb
+- lib/logger/log4r_config.xml
+- lib/s3/ir_s3.rb
+has_rdoc: true
+homepage: http://github.com/aloksrivastava78/iravat
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Access to AWS
+test_files: []
+