hugo 0.3.5 → 0.4.0

data/Rakefile

@@ -16,8 +16,8 @@ begin
     gemspec.add_dependency('json')
     
     gemspec.name = "hugo"
-    gemspec.summary = "Deploy Your Rack Apps to Cloud"
-    gemspec.description = "Deploy your apps to the cloud."
+    gemspec.summary = "Deploy Your Rack Apps to EC2 Cloud"
+    gemspec.description = "Deploy your apps to the EC2 cloud."
     gemspec.email = "tom@jackhq.com"
     gemspec.homepage = "http://github.com/twilson63/hugo2"
     gemspec.authors = ["Tom Wilson", "Barrett Little"]

data/lib/hugo/app.rb

@@ -43,7 +43,9 @@ class Hugo::App
     raise ArgumentError, "app.key_path Required" unless key_path
     raise ArgumentError, "app.cookbook Required" unless cookbook
     raise ArgumentError, "app.run_list Required" unless run_list
-    
+    raise ArgumentError, "app.aws_access_key_id Required" unless aws_access_key_id
+    raise ArgumentError, "app.aws_secret_access_key Required" unless aws_secret_access_key
+
     deploy_ec2
     #puts "Deploy Completed"    
   end
@@ -52,10 +54,10 @@ class Hugo::App
   def destroy
     if lb
       lb.instances.each do |i|
-        Hugo::Aws::Ec2.find(i).destroy
+        ec2(i).destroy
       end    
     else
-      Hugo::Aws::Ec2.find(instance).destroy
+      ec2(instance).destroy
     end
     
   end
@@ -65,6 +67,8 @@ class Hugo::App
     @key_path = nil
     @cookbook = nil
     @run_list = nil
+    @aws_access_key_id = nil
+    @aws_secret_access_key = nil
   end
   
   
@@ -98,6 +102,16 @@ class Hugo::App
   def db(arg=nil)
     set_or_return(:db, arg, :kind_of => [Hugo::Database]) 
   end
+
+  # Aws Access Key for EC2 Deployment
+  def aws_access_key_id(arg=nil)
+    set_or_return(:aws_access_key_id, arg, :kind_of => [String]) 
+  end
+
+  # Aws Access Secret Key for EC2 Deployment
+  def aws_secret_access_key(arg=nil)
+    set_or_return(:aws_secret_access_key, arg, :kind_of => [String]) 
+  end
   
   # URI of 
   # def uri(arg=nil)
@@ -199,16 +213,18 @@ private
   end
   
   def create_ec2
-    ec2 = Hugo::Aws::Ec2.new(:type => type || TYPE, 
+    aws_ec2 = Hugo::Aws::Ec2.new(:type => type || TYPE, 
                     :zone => zone || ZONE, 
                     :image_id => image_id || AMI,
                     :key_name => key_name,
-                    :security_group => security_group || "default").create
+                    :security_group => security_group || "default",
+                    :aws_access_key_id => aws_access_key_id,
+                    :aws_secret_access_key => aws_secret_access_key).create
   
     new_ec2 = nil
     sleep 10
     loop do
-      new_ec2 = Hugo::Aws::Ec2.find(ec2.name)
+      new_ec2 = ec2(aws_ec2.name)
       puts new_ec2.status
       if new_ec2.status == "running"
         break
@@ -225,8 +241,8 @@ private
     commands = []
     commands << 'if [ -d "./hugo-repos" ]; then echo "."; else sudo apt-get update -y; fi'
     commands << 'if [ -d "./hugo-repos" ]; then echo "."; else sudo apt-get install ruby ruby1.8-dev libopenssl-ruby1.8 rdoc ri irb build-essential git-core xfsprogs -y; fi'
-    commands << 'if [ -d "./hugo-repos" ]; then echo "."; else wget http://rubyforge.org/frs/download.php/60718/rubygems-1.3.5.tgz && tar zxf rubygems-1.3.5.tgz; fi'
-    commands << 'if [ -d "./hugo-repos" ]; then echo "."; else cd rubygems-1.3.5 && sudo ruby setup.rb && sudo ln -sfv /usr/bin/gem1.8 /usr/bin/gem; fi'
+    commands << 'if [ -d "./hugo-repos" ]; then echo "."; else wget http://rubyforge.org/frs/download.php/69365/rubygems-1.3.6.tgz && tar zxf rubygems-1.3.6.tgz; fi'
+    commands << 'if [ -d "./hugo-repos" ]; then echo "."; else cd rubygems-1.3.6 && sudo ruby setup.rb && sudo ln -sfv /usr/bin/gem1.8 /usr/bin/gem; fi'
     commands << 'if [ -d "./hugo-repos" ]; then echo "."; else sudo gem update --system; fi'
     commands << 'if [ -d "./hugo-repos" ]; then echo "."; else sudo gem install gemcutter --no-ri --no-rdoc; fi'
     commands << 'if [ -d "./hugo-repos" ]; then echo "."; else sudo gem install chef -v 0.7.16 --no-ri --no-rdoc; fi'
@@ -235,9 +251,7 @@ private
     commands << 'if [ -d "./hugo-repos" ]; then echo "."; else sudo gem install chef-deploy --no-ri --no-rdoc; fi'
     commands << 'if [ -d "./hugo-repos" ]; then echo "."; else sudo gem install git --no-ri --no-rdoc; fi'
     commands << "if [ -d \"./hugo-repos\" ]; then echo \".\"; else git clone #{self.cookbook} ~/hugo-repos; fi"
-    ec2 = Hugo::Aws::Ec2.find(instance_id)
-    #puts ec2.uri
-    ec2.ssh(commands, nil, File.join(key_path, key_name))
+    ec2(instance_id).ssh(commands, nil, File.join(key_path, key_name))
   end
   
   def deploy_ec2
@@ -251,17 +265,17 @@ private
     self.dna.merge!(
       :run_list => run_list,
       :git => cookbook,
-      :access_key => Hugo::Aws::Ec2::ACCESS_KEY,
-      :secret_key => Hugo::Aws::Ec2::SECRET_KEY,
+      :access_key => aws_access_key_id,
+      :secret_key => aws_secret_access_key,
       :database => db ? db.info : {} 
     )
           
     if lb
       lb.instances.each do |i|
-        Hugo::Aws::Ec2.find(i).ssh(commands, dna, File.join(key_path, key_name))
+        ec2(i).ssh(commands, dna, File.join(key_path, key_name))
       end
     else
-      Hugo::Aws::Ec2.find(instance).ssh(commands, dna, File.join(key_path, key_name))      
+      ec2(instance).ssh(commands, dna, File.join(key_path, key_name))      
     end
     
   end
@@ -269,11 +283,16 @@ private
   def delete_ec2(i=1)
     i.times do 
       instance_id = lb.instances[0]
-      Hugo::Aws::Ec2.find(instance_id).destroy
+      ec2(instance_id).destroy
       #lb.remove(instance_id)
 
     end  
   end
+  
+  def ec2(instance_id)
+    Hugo::Aws::Ec2.find(instance, aws_access_key_id, aws_secret_access_key)
+  end
+  
     
 
 end

data/lib/hugo/aws/ec2.rb

@@ -10,7 +10,9 @@ module Hugo
       ZONE = "us-east-1c"
       TYPE = "m1.small"
   
-      attr_accessor :name, :uri, :type, :zone, :image_id, :key_name, :create_time, :status, :security_group
+      attr_accessor :name, :uri, :type, :zone, :image_id, :key_name, 
+      :create_time, :status, :security_group, 
+      :aws_access_key_id, :aws_secret_access_key
 
       def initialize(options = {})
         set_attributes(options)
@@ -45,12 +47,16 @@ module Hugo
           @security_group = options["groupSet"]["item"][0]["groupId"]
         end
         
+        @aws_access_key_id = options[:aws_access_key_id] || ACCESS_KEY
+        @aws_secret_access_key = options[:aws_secret_access_key] || SECRET_KEY
+        
       end
       
     
       def create
-        @ec2 = AWS::EC2::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
-        result = @ec2.run_instances(:image_id => self.image_id, :key_name => self.key_name, 
+        result = ec2.run_instances(
+          :image_id => self.image_id, 
+          :key_name => self.key_name, 
           :max_count => 1,
           :availability_zone => self.zone,
           :security_group => self.security_group) unless self.create_time
@@ -59,8 +65,7 @@ module Hugo
       end
     
       def destroy
-        @ec2 = AWS::EC2::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
-        @ec2.terminate_instances(:instance_id => self.name)
+        ec2.terminate_instances(:instance_id => self.name)
       end
     
       def save
@@ -97,13 +102,13 @@ module Hugo
       #   @ec2.delete_security_group(:group_name => name)
       # end
 
-      def self.all
-        @ec2 = AWS::EC2::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+      def self.all(access_key_id, secret_access_key)
+        @ec2 = AWS::EC2::Base.new(:access_key_id => access_key_id, :secret_access_key => secret_access_key)
         @ec2.describe_instances().reservationSet.item[0].instancesSet.item.map { |i| self.new(i) }
       end
     
-      def self.find(instance)
-        @ec2 = AWS::EC2::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+      def self.find(instance, access_key_id, secret_access_key)
+        @ec2 = AWS::EC2::Base.new(:access_key_id => access_key_id, :secret_access_key => secret_access_key)
         self.new(@ec2.describe_instances(:instance_id => instance).reservationSet.item[0].instancesSet.item[0])
       end
 
@@ -119,6 +124,17 @@ module Hugo
           self.new(options).create
         end
       end
+      
+  private      
+      def ec2
+        AWS::EC2::Base.new(
+          :access_key_id => self.aws_access_key_id, 
+          :secret_access_key => self.aws_secret_access_key)
+        
+      end
+      
+      
+  
     end
   end
 end

data/lib/hugo/aws/elb.rb

@@ -8,7 +8,7 @@ module Hugo
       LISTENERS = [{"InstancePort"=>"8080", "Protocol"=>"HTTP", "LoadBalancerPort"=>"80"}, 
         {"InstancePort"=>"8443", "Protocol"=>"TCP", "LoadBalancerPort"=>"443"}]
     
-      attr_accessor :name, :uri, :listeners, :instances, :zones, :create_time
+      attr_accessor :name, :uri, :listeners, :instances, :zones, :create_time, :aws_access_key_id, :aws_secret_access_key
     
       def initialize(options = {} )
         @name = options[:name] || options["LoadBalancerName"]
@@ -33,11 +33,14 @@ module Hugo
         if options["CreatedTime"]
           @create_time = options["CreatedTime"]
         end
+
+        @aws_access_key_id = options[:aws_access_key_id] || ACCESS_KEY
+        @aws_secret_access_key = options[:aws_secret_access_key] || SECRET_KEY
+        
       end
     
       def create
-        @elb = AWS::ELB::Base.new(:access_key_id => Hugo::Aws::Elb::ACCESS_KEY, :secret_access_key => Hugo::Aws::Elb::SECRET_KEY)
-        @elb.create_load_balancer(
+        elb.create_load_balancer(
           :load_balancer_name => self.name,
           :listeners => self.listeners,
           :availability_zones => self.zones
@@ -46,8 +49,7 @@ module Hugo
       end
     
       def destroy
-        @elb = AWS::ELB::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
-        @elb.delete_load_balancer(:load_balancer_name => self.name)
+        elb.delete_load_balancer(:load_balancer_name => self.name)
       end
     
       def save
@@ -55,8 +57,7 @@ module Hugo
       end
     
       def add(instance)
-        @elb = AWS::ELB::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
-        @elb.register_instances_with_load_balancer(
+        elb.register_instances_with_load_balancer(
           :instances => [instance],
           :load_balancer_name => @name)
         @instances << instance
@@ -65,21 +66,20 @@ module Hugo
     
       def remove(instance)
         
-        @elb = AWS::ELB::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
-        @elb.deregister_instances_from_load_balancer(
+        elb.deregister_instances_from_load_balancer(
           :instances => [instance],
           :load_balancer_name => @name)
         @instances = @instances - [instance]
         self
       end
     
-      def self.all
-        @elb = AWS::ELB::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+      def self.all(aws_access_key_id, aws_secret_access_key)
+        @elb = AWS::ELB::Base.new(:access_key_id => aws_access_key_id, :secret_access_key => aws_secret_access_key)
         instances = @elb.describe_load_balancers().DescribeLoadBalancersResult.LoadBalancerDescriptions.member      
         instances.map { |i| self.new(i) }
       end
     
-      def self.find(balancer)
+      def self.find(balancer, aws_access_key_id, aws_secret_access_key)
         @elb = AWS::ELB::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
         
         result = nil
@@ -94,8 +94,14 @@ module Hugo
       end
     
       def self.find_or_create(options)
-        self.find(options[:name]) || self.new(options).create
+        self.find(options[:name], options[:aws_access_key_id], options[:aws_secret_access_key]) || self.new(options).create
+      end
+      
+    private
+      def elb
+        AWS::ELB::Base.new(:access_key_id => @aws_access_key_id, :secret_access_key => @aws_secret_access_key)
       end
+      
     end
   end
 end

data/lib/hugo/aws/rds.rb

@@ -9,7 +9,10 @@ module Hugo
       ZONE = "us-east-1c"
     
       attr_accessor :db, :uri, :server, :user, :password, :instance_class, 
-                    :zone, :size, :status, :create_time, :db_security_group
+                    :zone, :size, :status, :create_time, :db_security_group,
+                    :aws_access_key_id, :aws_secret_access_key
+                    
+                    
     
       def initialize(options={})
         # create instance
@@ -30,18 +33,14 @@ module Hugo
         if options["DBSecurityGroups"] and options["DBSecurityGroups"]["DBSecurityGroup"]
           @db_security_group = options["DBSecurityGroups"]["DBSecurityGroup"]["DBSecurityGroupName"] 
         end
+        @aws_access_key_id = options[:aws_access_key_id] || ACCESS_KEY
+        @aws_secret_access_key = options[:aws_secret_access_key] || SECRET_KEY
         
       end
     
       def create
-        @rds = AWS::RDS::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)      
         
-        # TODO Create DB Security Group wheh Amazon Bug Fixed! -tnw
-        # if @db_security_group
-        #   find_or_create_db_security_group(@db_security_group, @db_security_group)
-        # end
-        
-        @rds.create_db_instance(
+        rds.create_db_instance(
           :db_instance_identifier => self.server,
           :allocated_storage => self.size,
           :db_instance_class => self.instance_class,
@@ -60,12 +59,11 @@ module Hugo
       end
     
       def destroy
-        @rds = AWS::RDS::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)      
-        @rds.delete_db_instance(:db_instance_identifier => self.server, :skip_final_snapshot => true)
+        rds.delete_db_instance(:db_instance_identifier => self.server, :skip_final_snapshot => true)
       end
     
-      def self.all
-        @rds = AWS::RDS::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+      def self.all(aws_access_key_id, aws_secret_access_key)
+        @rds = AWS::RDS::Base.new(:access_key_id => aws_access_key_id, :secret_access_key => aws_secret_access_key)
         instances = @rds.describe_db_instances.DescribeDBInstancesResult.DBInstances.DBInstance
       
         if instances.kind_of?(Array)
@@ -77,9 +75,9 @@ module Hugo
         end
       end
     
-      def self.find(instance)
+      def self.find(instance, aws_access_key_id, aws_secret_access_key)
         # find instance
-        @rds = AWS::RDS::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        @rds = AWS::RDS::Base.new(:access_key_id => aws_access_key_id, :secret_access_key => aws_secret_access_key)
         @rds_instance = @rds.describe_db_instances(:db_instance_identifier => instance)
         instance_desc = @rds_instance.DescribeDBInstancesResult.DBInstances.DBInstance  
         # initialize Hugo::Rds Object with instance hash
@@ -90,31 +88,36 @@ module Hugo
       end
 
       def self.find_or_create(options)
-        rds = self.find(options[:server]) || self.new(options).create
+        rds = self.find(options[:server], options[:aws_access_key_id], options[:aws_secret_access_key]) || self.new(options).create
         rds.db = options[:name]
         rds.password = options[:password]
         rds
       end
 
       def authorize_security_group(db_sec, ec2_sec, owner_id)
-        @rds = AWS::RDS::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
-        @rds.authorize_db_security_group(:db_security_group_name => db_sec, :ec2_security_group_name => ec2_sec, :ec2_security_group_owner_id => owner_id)
+        #@rds = AWS::RDS::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        rds.authorize_db_security_group(:db_security_group_name => db_sec, :ec2_security_group_name => ec2_sec, :ec2_security_group_owner_id => owner_id)
       end
     
       def find_or_create_db_security_group(name, description)
-        @rds = AWS::RDS::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        #@rds = AWS::RDS::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
         begin
-          @security_groups = @rds.describe_db_security_groups(:db_security_group_name => name)
+          @security_groups = rds.describe_db_security_groups(:db_security_group_name => name)
         rescue
-          @security_groups = @rds.create_db_security_group(:db_security_group_name => name, :db_security_group_description => description)
+          @security_groups = rds.create_db_security_group(:db_security_group_name => name, :db_security_group_description => description)
         end
         #puts @security_groups
         @security_groups
       end
 
       def destroy_db_security_group(name)
-        @rds = AWS::RDS::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
-        @rds.delete_db_security_group(:db_security_group_name => name)
+        rds.delete_db_security_group(:db_security_group_name => name)
+      end
+    private
+      def rds
+        AWS::RDS::Base.new(
+          :access_key_id => self.aws_access_key_id, 
+          :secret_access_key => self.aws_secret_access_key)
       end
     end
   end

data/lib/hugo/balancer.rb

@@ -21,10 +21,15 @@ class Hugo::Balancer
   end
   
   def deploy
+    raise ArgumentError, "app.aws_access_key_id Required" unless aws_access_key_id
+    raise ArgumentError, "app.aws_secret_access_key Required" unless aws_secret_access_key
+    
     Hugo::Aws::Elb.find_or_create(:name => name,
                             :zones => zone,
                             :listeners => [{ :instance_port => port, :protocol =>"HTTP", :load_balancer_port => web}, 
-                              { :instance_port => ssl_port, :protocol =>"TCP", :load_balancer_port => ssl_web}]
+                              { :instance_port => ssl_port, :protocol =>"TCP", :load_balancer_port => ssl_web}],
+                              :aws_access_key_id => aws_access_key_id,
+                              :aws_secret_access_key => aws_secret_access_key
     )
   end
   
@@ -88,4 +93,14 @@ HELP
     set_or_return(:ssl_web, arg, :kind_of => [String])     
   end
   
+  # Aws Access Key for EC2 Deployment
+  def aws_access_key_id(arg=nil)
+    set_or_return(:aws_access_key_id, arg, :kind_of => [String]) 
+  end
+
+  # Aws Access Secret Key for EC2 Deployment
+  def aws_secret_access_key(arg=nil)
+    set_or_return(:aws_secret_access_key, arg, :kind_of => [String]) 
+  end
+  
 end

data/lib/hugo/cloud.rb

@@ -15,6 +15,8 @@ class Hugo::Cloud
     database.db_security_group name
     database.server name
     database.name db_name
+    database.aws_access_key_id(aws_access_key_id) if aws_access_key_id 
+    database.aws_secret_access_key(aws_secret_access_key) if aws_secret_access_key
     
     database.instance_eval(&block) if block_given? 
     db database.deploy 
@@ -24,6 +26,9 @@ class Hugo::Cloud
   def balancer(&block)
     balancer = Hugo::Balancer.instance
     balancer.name name
+    balancer.aws_access_key_id(aws_access_key_id) if aws_access_key_id 
+    balancer.aws_secret_access_key(aws_secret_access_key) if aws_secret_access_key
+    
     balancer.instance_eval(&block) if block_given? 
     lb balancer.deploy 
   end
@@ -31,6 +36,9 @@ class Hugo::Cloud
   def app(name, &block)
     app_info = Hugo::App.instance
     app_info.name name
+    app_info.aws_access_key_id(aws_access_key_id) if aws_access_key_id 
+    app_info.aws_secret_access_key(aws_secret_access_key) if aws_secret_access_key
+
     app_info.lb lb
     app_info.db db
     #app_info.cloud_name name
@@ -54,7 +62,11 @@ class Hugo::Cloud
     db.rds.destroy
   end
   
-  
+  def clear
+    aws_access_key_id(nil) 
+    aws_secret_access_key(nil)
+
+  end
     
   def print
     if db
@@ -120,6 +132,15 @@ REPORT
   end
   
   
+  # Aws Access Key for EC2 Deployment
+  def aws_access_key_id(arg=nil)
+    set_or_return(:aws_access_key_id, arg, :kind_of => [String]) 
+  end
+
+  # Aws Access Secret Key for EC2 Deployment
+  def aws_secret_access_key(arg=nil)
+    set_or_return(:aws_secret_access_key, arg, :kind_of => [String]) 
+  end
   
 
 

data/lib/hugo/database.rb

@@ -25,6 +25,8 @@ class Hugo::Database
     raise ArgumentError, "database.server Required" unless server
     raise ArgumentError, "database.user Required" unless user
     raise ArgumentError, "database.password Required" unless password
+    raise ArgumentError, "database.aws_access_key_id Required" unless aws_access_key_id
+    raise ArgumentError, "database.aws_secret_access_key Required" unless aws_secret_access_key
     
     
     @rds = Hugo::Aws::Rds.find_or_create( :name => name,
@@ -33,7 +35,10 @@ class Hugo::Database
                               :password => password,
                               :size => size,
                               :zone => zone,
-                              :db_security_group => db_security_group
+                              :db_security_group => db_security_group,
+                              :aws_access_key_id => aws_access_key_id,
+                              :aws_secret_access_key => aws_secret_access_key
+                              
                                )
     self
   end
@@ -106,5 +111,15 @@ HELP
   def db_security_group(arg=nil)
     set_or_return(:db_security_group, arg, :kind_of => [String])     
   end
+
+  # Aws Access Key for EC2 Deployment
+  def aws_access_key_id(arg=nil)
+    set_or_return(:aws_access_key_id, arg, :kind_of => [String]) 
+  end
+
+  # Aws Access Secret Key for EC2 Deployment
+  def aws_secret_access_key(arg=nil)
+    set_or_return(:aws_secret_access_key, arg, :kind_of => [String]) 
+  end
     
 end

data/spec/lib/hugo/app_spec.rb

@@ -5,10 +5,49 @@ describe "Hugo App" do
     mocks
   end
   
+  it "should allow aws key and secret key overrides" do
+    block = lambda do
+      cloud "my_cloud" do 
+        clear
+        aws_access_key_id "12345"
+        aws_secret_access_key "123456"
+
+        database "my_db" do
+          server "my_server"
+          user "hello"
+          password "world"
+        end
+        
+        balancer
+        
+        app "testapp" do 
+          clear
+          key_name "ec2-keypair"
+          key_path "~/.ec2"
+          cookbook "git@github.com:jackhq/hugo-cookbooks.git"
+          
+          servers 0
+        end
+        #deploy
+        #print
+      end
+    end
+    
+    lambda do
+      Hugo &block
+    end.should_not raise_error
+    
+  end
+  
+  
   it "should be valid" do
     
     block = lambda do
       cloud "my_cloud" do 
+        clear
+        aws_access_key_id "12345"
+        aws_secret_access_key "123456"
+        
         database "my_db" do
           server "my_server"
           user "hello"
@@ -40,6 +79,10 @@ describe "Hugo App" do
     lambda do
       Hugo do
         cloud "my_cloud" do
+          clear
+          aws_access_key_id "12345"
+          aws_secret_access_key "123456"
+        
           app "testapp" do 
             clear
             key_path "~/.ec2"
@@ -56,6 +99,10 @@ describe "Hugo App" do
     lambda do
       Hugo do
         cloud "my_cloud" do
+          clear
+          aws_access_key_id "12345"
+          aws_secret_access_key "123456"
+        
           app "testapp" do 
             clear
             key_name "ec2-keypair"
@@ -72,6 +119,10 @@ describe "Hugo App" do
     lambda do
       Hugo do
         cloud "my_cloud" do
+          clear
+          aws_access_key_id "12345"
+          aws_secret_access_key "123456"
+        
           app "testapp" do 
             clear
             key_name "ec2-keypair"
@@ -84,6 +135,48 @@ describe "Hugo App" do
     end.should raise_error('app.cookbook Required')
   end
   
+  it "should raise error requiring aws_access_key_id" do
+    lambda do
+      Hugo do
+        cloud "my_cloud" do
+          clear
+          aws_secret_access_key "123456"
+        
+          app "testapp" do 
+            clear
+            key_name "ec2-keypair"
+            key_path "~/.ec2"
+            cookbook "my_cookbook"
+            run_list ["role[base_rack_apache]"]
+          end 
+          deploy         
+        end        
+      end
+    end.should raise_error('app.aws_access_key_id Required')
+  end
+
+  it "should raise error requiring aws_secret_access_key" do
+    lambda do
+      Hugo do
+        cloud "my_cloud" do
+          clear
+
+          app "testapp" do 
+            clear
+            aws_access_key_id "12345"
+
+            key_name "ec2-keypair"
+            key_path "~/.ec2"
+            cookbook "my_cookbook"
+            run_list ["role[base_rack_apache]"]
+          end 
+          deploy         
+        end        
+      end
+    end.should raise_error('app.aws_secret_access_key Required')
+  end
+  
+  
   
   it "should save dna" do
     block = lambda do

data/spec/lib/hugo/aws/ec2_spec.rb

@@ -29,24 +29,24 @@ describe Hugo::Aws::Ec2 do
   # end
 
   it "should terminate instance" do
-    Hugo::Aws::Ec2.find('i-12345678').destroy.should be_true
+    Hugo::Aws::Ec2.find('i-12345678', '123456789','987654321').destroy.should be_true
   end
 
   it "should find instance" do
-    Hugo::Aws::Ec2.find('i-12345678').should_not be_nil
+    Hugo::Aws::Ec2.find('i-12345678', '123456789','987654321').should_not be_nil
   end
 
   it "should return all instances" do
-    Hugo::Aws::Ec2.all.length.should == 1
+    Hugo::Aws::Ec2.all('123456789','987654321').length.should == 1
   end
   
-  it "should find or create security group" do
-    Hugo::Aws::Ec2.find_or_create_security_group('test', 'test description').should_not be_empty
-  end
-  
-  it "should destroy a security group" do
-    Hugo::Aws::Ec2.destroy_security_group('test').should be_true
-  end
+  # it "should find or create security group" do
+  #   Hugo::Aws::Ec2.find_or_create_security_group('test', 'test description').should_not be_empty
+  # end
+  # 
+  # it "should destroy a security group" do
+  #   Hugo::Aws::Ec2.destroy_security_group('test').should be_true
+  # end
   #
   # it "should deploy app" do
   #   

data/spec/lib/hugo/aws/elb_spec.rb

@@ -9,28 +9,29 @@ describe Hugo::Aws::Elb do
   end
       
   it "should create a new instance" do    
-    @hugo_elb = Hugo::Aws::Elb.new(:name => "myserver").should be_true
-    @hugo_elb.save.should be_true
+    @hugo_elb = Hugo::Aws::Elb.new(:name => "myserver")
+    @hugo_elb.should_not be_nil
+    @hugo_elb.save.should_not be_nil
   end
   # 
   it "should return all" do
-    Hugo::Aws::Elb.all.length.should == 1
+    Hugo::Aws::Elb.all("1","2").length.should == 1
   end
   # # 
   it "should find elb instance" do        
-    Hugo::Aws::Elb.find('test').should_not be_nil
+    Hugo::Aws::Elb.find('test',"1","2").should_not be_nil
   end
   # 
   it "should delete elb instance" do    
-    Hugo::Aws::Elb.find('test').destroy.should_not be_nil
+    Hugo::Aws::Elb.find('test',"1","2").destroy.should_not be_nil
   end
   
   it "should add ec2 intance" do
-    Hugo::Aws::Elb.find('test').add('i-12345678').instances.length.should == 1
+    Hugo::Aws::Elb.find('test',"1","2").add('i-12345678').instances.length.should == 1
   end
   
   it "should remove ec2 instance" do
-    Hugo::Aws::Elb.find('test').remove('i-12345678').instances.length.should == 0
+    Hugo::Aws::Elb.find('test',"1","2").remove('i-12345678').instances.length.should == 0
   end
   
 end

data/spec/lib/hugo/aws/rds_spec.rb

@@ -8,37 +8,44 @@ describe Hugo::Aws::Rds do
   end
     
   it "should create a new instance" do    
-    @hugo_rds = Hugo::Aws::Rds.new(:name => "myserver", :db => "mydb", :user => "user", :password => "password").should be_true
+    @hugo_rds = Hugo::Aws::Rds.new(
+      :name => "myserver", 
+      :db => "mydb", 
+      :user => "user", 
+      :password => "password",
+      :aws_access_key_id => '12',
+      :aws_secret_access_key => '12')
+    @hugo_rds.should_not be_nil
     @hugo_rds.save.should be_true
   end
   
   it "should return all" do
-    Hugo::Aws::Rds.all.length.should == 1
+    Hugo::Aws::Rds.all('12','34').length.should == 1
   end
   # 
   it "should find rds instance" do        
-    Hugo::Aws::Rds.find('test').should_not be_nil
+    Hugo::Aws::Rds.find('test','12','34').should_not be_nil
   end
   
   it "should delete rds instance" do    
-    Hugo::Aws::Rds.find('test').destroy
+    Hugo::Aws::Rds.find('test','12','34').destroy
   end
   
   it "should provide uri" do
-    Hugo::Aws::Rds.find('test').uri.should_not be_nil
+    Hugo::Aws::Rds.find('test','12','34').uri.should_not be_nil
   end
 
-  it "should find or create db security group" do
-    @rds = Hugo::Aws::Rds.find('i-12345678')
-    @rds.find_or_create_db_security_group('test', 'test description').should_not be_empty
-  end
+  # it "should find or create db security group" do
+  #   @rds = Hugo::Aws::Rds.find('i-12345678','12','34')
+  #   @rds.find_or_create_db_security_group('test', 'test description').should_not be_empty
+  # end
   
-  it "should destroy a db security group" do
-    Hugo::Aws::Rds.find('i-12345678').destroy_db_security_group('test').should be_true
-  end
+  # it "should destroy a db security group" do
+  #   Hugo::Aws::Rds.find('i-12345678').destroy_db_security_group('test').should be_true
+  # end
   
-  it "should authorize a ec2 security group" do
-    @rds = Hugo::Aws::Rds.find('i-12345678')
-    @rds.authorize_security_group('test', 'test', '12334').should_not be_empty
-  end
+  # it "should authorize a ec2 security group" do
+  #   @rds = Hugo::Aws::Rds.find('i-12345678','12','34')
+  #   @rds.authorize_security_group('test', 'test', '12334').should_not be_empty
+  # end
 end

data/spec/lib/hugo/balancer_spec.rb

@@ -8,7 +8,13 @@ describe "Hugo Balancer" do
   it "should be valid" do
     block = lambda do
       cloud "my_cloud" do 
-        balancer
+        balancer do
+          aws_access_key_id "12345"
+          aws_secret_access_key "123456"
+          
+        end
+        
+        
       end
     end
     
@@ -31,6 +37,8 @@ describe "Hugo Balancer" do
   it "should find or create balancer" do
     lb = Hugo::Balancer.instance
     lb.name "myserver"
+    lb.aws_access_key_id "12"
+    lb.aws_secret_access_key "12"
     lb.deploy.should be_a_kind_of(Hugo::Aws::Elb)
     
   end

data/spec/lib/hugo/database_spec.rb

@@ -52,6 +52,8 @@ describe "Hugo Database" do
     lambda do
       Hugo do
         cloud "my_cloud" do 
+          aws_access_key_id "12"
+          aws_secret_access_key "34"
           database "testapp" do 
             server "serverx"
             user "test_user"

data/spec/lib/hugo_spec.rb

@@ -54,6 +54,9 @@ describe "Hugo DSL" do
     block = lambda do
       
       cloud "gmms" do                 
+        aws_access_key_id "12345"
+        aws_secret_access_key "123456"
+        
         balancer 
         
         database "sentinel" do 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: hugo
 version: !ruby/object:Gem::Version 
-  version: 0.3.5
+  version: 0.4.0
 platform: ruby
 authors: 
 - Tom Wilson
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-05 00:00:00 -05:00
+date: 2010-03-07 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -73,7 +73,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 2.0.16
     version: 
-description: Deploy your apps to the cloud.
+description: Deploy your apps to the EC2 cloud.
 email: tom@jackhq.com
 executables: []
 
@@ -121,7 +121,7 @@ rubyforge_project:
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: Deploy Your Rack Apps to Cloud
+summary: Deploy Your Rack Apps to EC2 Cloud
 test_files: 
 - spec/lib/hugo/app_spec.rb
 - spec/lib/hugo/aws/ec2_spec.rb