rudy 0.4.0 → 0.6.0

data/support/randomize-root-password

@@ -0,0 +1,45 @@
+#!/bin/sh
+
+#
+# Randomizes the root password on first boot
+#
+# * When the file /root/firstboot is present, this script will
+#   randomize the root password.
+#
+#   who: delano@solutious.com
+#  when: 2009-03-13
+#
+
+# NOTE: Works on Gentoo
+# TODO: Fix for debian
+
+if [ -f "/root/firstrun" ] ; then
+  dd if=/dev/urandom count=50|md5sum|passwd --stdin root
+  rm -f /root/firstrun
+else
+  echo "* Firstrun *" && touch /root/firstrun
+fi
+
+# New Gentoo (to be tested)
+#if [ -f "/root/firstrun" ] ; then
+#  pword=`dd if=/dev/urandom count=51 | sha1sum`
+#  echo $pword | passwd --stdin root
+#  rm -f /root/firstrun
+#else
+#  echo "* Firstrun *" && touch /root/firstrun
+#fi
+
+# Fix for debian
+#if [ -f "/root/firstrun" ] ; then
+#  pword=`dd if=/dev/urandom count=51 | sha1sum`
+#  echo "root:$pword" | chpasswd
+#  rm -f /root/firstrun
+#else
+#  echo "* Firstrun *" && touch /root/firstrun
+#fi
+
+# Random root password for Gentoo: 
+#dd if=/dev/urandom count=51 | sha1sum | passwd --stdin root
+
+# Random root password for Debian/Ubuntu:
+#echo "root:`dd if=/dev/urandom count=51 | sha1sum`" | chpasswd

data/support/rudy-ec2-startup

@@ -9,7 +9,7 @@
 
 # Runs when an ec2 instance startups up.
 # Grabs configuration from the run time user data and stores it locally.
-# See Rudy::Command::Instances#start_instance for the expected yaml format.
+# See Rudy::CLI::Machines#start_instance for the expected yaml format.
 
 # Put this in /etc/init.d. Then:
 #   * chmod 755 rudy-ec2-startup
@@ -33,8 +33,8 @@ METADATA = 'http://169.254.169.254/2008-02-01/meta-data'
 
 METADATAPARAMS = ['instance-id', 'instance-type']
 
-RUDY_CONFIG_DIR=File.join('.rudy')
-RUDY_CONFIG_FILE=File.join('config')
+Rudy::CONFIG_DIR=File.join('.rudy')
+Rudy::CONFIG_FILE=File.join('config')
 
 module Rudy
   module EC2Startup
@@ -74,10 +74,10 @@ module Rudy
         # We don't want sensitive config values available in the log
         puts "CONFIG: " << config_yaml
         
-        zone = config[:zone] ? config[:zone].downcase : "zone"
-        environment = config[:environment] ? config[:environment].downcase : "env"
-        role = config[:role] ? config[:role].downcase : "role"
-        position = config[:position] ? config[:position].downcase : "00"
+        zone = config[:zone] ? config[:zone].to_s.downcase : "zone"
+        environment = config[:environment] ? config[:environment].to_s.downcase : "env"
+        role = config[:role] ? config[:role].to_s.downcase : "role"
+        position = config[:position] ? config[:position].to_s.downcase : "00"
         
         hostname = [zone, environment, role, position].join('-')
         log "Setting hostname: #{hostname}"
@@ -91,9 +91,9 @@ module Rudy
           # (when we're not running as that user.) 
           config[:userdata].each_pair do |n,hash|
             fileparts = (n == :root) ? ['/root'] : [user_home_dir(n)]
-            fileparts << RUDY_CONFIG_DIR
+            fileparts << Rudy::CONFIG_DIR
             dirpath = File.join(fileparts)
-            filepath = File.join(dirpath, RUDY_CONFIG_FILE)
+            filepath = File.join(dirpath, Rudy::CONFIG_FILE)
             
             # Backwards compatability
             if !File.directory?(dirpath)

data/support/update-ec2-ami-tools

@@ -0,0 +1,20 @@
+#!/bin/sh
+
+#
+# Installs the latest EC2 AMI Tools
+#
+# * Downloads zip to /tmp
+# * Unzips and removes /usr/ec2 (if it exists)
+# * Moves tools to /usr/ec2
+#
+#   who: delano@solutious.com
+#  when: 2009-03-13
+#
+
+cd /tmp
+echo " + Updating ec2-ami-tools"
+wget http://s3.amazonaws.com/ec2-downloads/ec2-ami-tools.zip && \
+unzip ec2-ami-tools.zip && rm ec2*.zip* && rm -rf /usr/ec2 && \
+mv ec2-* ec2 && mv ec2 /usr/ && \
+echo " + Updated ec2-ami-tools"
+

data/test/05_config/00_setup_test.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+module Rudy::Test
+
+  class Case_05_Config < Test::Unit::TestCase
+    include Rudy::Huxtable
+    
+    @@logger = STDERR #StringIO.new
+    @@zone = @@global.zone.to_s
+    
+    context "#{name}_00 Setup" do
+      should "(00) have class variables setup" do
+        stop_test !@@global.is_a?(Rudy::Global), "We don't have global (#{@@global})"
+        stop_test !@@config.is_a?(Rudy::Config), "We don't have an instance of Rudy::Config (#{@@config})"
+      end
+    end
+    
+    
+  end
+end

data/test/05_config/30_machines_test.rb

@@ -0,0 +1,69 @@
+
+module Rudy::Test
+  class Case_05_Config
+    
+    context "#{name}_30 Machines" do
+      
+      should "(10) have accounts.aws" do
+        stop_test !@@config.accounts.is_a?(Rudy::Config::Accounts), "Not an Accounts class"
+        
+        stop_test @@config.accounts.aws.accountnum.nil?, "No account"
+        stop_test @@config.accounts.aws.accesskey.nil?, "No accesskey"
+        stop_test @@config.accounts.aws.secretkey.nil?, "No secretkey"
+      end
+      
+      should "(20) have defaults" do
+        assert @@config.defaults.is_a?(Rudy::Config::Defaults), "Not a Defaults class"
+        assert !@@config.defaults.region.nil?, "No default region"
+        assert !@@config.defaults.zone.nil?, "No default zone"
+        assert !@@config.defaults.environment.nil?, "No default environment"
+        assert !@@config.defaults.role.nil?, "No default role"
+      end
+      
+      should "(30) have machines" do
+        assert @@config.machines.is_a?(Rudy::Config::Machines), "Not a Machines class"
+        assert !@@config.machines.keys.empty?, "Nothing in machine config"
+      end
+      
+      should "(31) have 2 disks" do
+        reg, zon = @@config.defaults.region, @@config.defaults.zone 
+        env, rol = @@config.defaults.environment, @@config.defaults.role
+        
+      end
+      
+      # Disabled for 0.5.0 (routines config removed)
+      xshould "(40) have routines" do
+        assert @@config.routines.is_a?(Rudy::Config::Routines), "Not a Routines class"
+      end
+      
+      # Disabled for 0.5.0 (most machines config removed)
+      xshould "(50) be able to find and find_deferred" do
+        reg, zon = @@config.defaults.region, @@config.defaults.zone 
+        env, rol = @@config.defaults.environment, @@config.defaults.role 
+
+        #Caesars.enable_debug
+        
+        conf = @@config.machines[env][rol]
+        conf_find = @@config.machines.find(env, rol)
+        conf_find_def = @@config.machines.find_deferred(env, rol)
+        
+        assert_equal conf, conf_find, "config hash and find not equal"
+        assert_equal conf_find_def, conf_find, "find and find_deferred not equal"
+      end
+      
+      should "(51) find different config for each zone" do
+        reg, zon = @@config.defaults.region, @@config.defaults.zone 
+        env, rol = @@config.defaults.environment, @@config.defaults.role
+        
+        us_ami = @@config.machines.find(:"us-east-1b", :ami)
+        eu_ami = @@config.machines.find(:"eu-west-1b", :ami)
+        
+        assert us_ami.is_a?(String), "No ami for us-east-1b zone"
+        assert eu_ami.is_a?(String), "No ami for eu-west-1b"
+        assert us_ami != eu_ami, "EU (#{eu_ami}) and US (#{us_ami}) AMIs are the same"
+      end
+      
+    end
+    
+  end
+end

data/test/20_sdb/00_setup_test.rb

@@ -0,0 +1,16 @@
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+module Rudy::Test
+  # Expects:
+  # * There to be no pre-existing keypairs, addresses, etc... (except 
+  #   the default group)
+  # * It can destroy instances, images, etc... 
+  #
+  # DO NOT RUN THIS TEST ON A PRODUCTION AWS ACCOUNT!!
+  #
+  class Case_20_AWS_SDB < Test::Unit::TestCase
+    include Rudy::Huxtable
+    
+  end
+  
+end

data/test/20_sdb/10_domains_test.rb

@@ -0,0 +1,115 @@
+module Rudy::Test
+  class Case_20_AWS_SDB
+    
+    
+    def get_domain
+
+    end
+    
+    context "#{name}_10 Domains" do
+      
+      setup do
+        @sdb = Rudy::AWS::SDB.new(@@global.accesskey, @@global.secretkey, @@global.region)
+        @domain_list = @sdb.list_domains || []
+        @domain = @domain_list.first
+      end
+      
+      should "(10) create domain" do
+        dname = 'test_' << Rudy::Utils.strand
+        assert @sdb.create_domain(dname), "Domain not created (#{dname})"
+      end
+      
+      should "(20) list domains" do
+        domain_list = @sdb.list_domains
+        assert domain_list.is_a?(Array), "Not an Array"
+        assert !domain_list.empty?, "No Domains"
+      end
+      
+      should "(30) store objects" do
+        
+        assert !@domain.nil?, "No domain"
+        
+        produce = lambda {
+          {
+            'orange' => rand(100) * 10,
+            'celery' => rand(100) * 100,
+            'grapes' => :green
+          }
+        }
+        
+        @sdb.put(@domain, 'produce1', produce.call, :replace)
+        @sdb.put(@domain, 'produce2', produce.call, :replace)
+        
+        # TODO: Need assertion here!
+        
+      end
+      
+      should "(40) get objects" do
+        assert !@domain.nil?, "No domain"
+        item = @sdb.get(@domain, 'produce1')
+        assert_equal Hash, item.class # good stuff
+        assert_equal ['green'], item['grapes']
+      end
+      
+      should "(50) query objects" do
+        
+        assert !@domain.nil?, "No domain"
+        
+        items = @sdb.query(@domain, "[ 'grapes' = 'green' ]")
+        assert items.is_a?(Array), "Not an Array"
+        assert_equal 2, items.size, "More than 2 objects"
+      end
+      
+      should "(51) query objects with attributes" do
+        
+        assert !@domain.nil?, "No domain"
+        
+        items = @sdb.query_with_attributes(@domain, "[ 'grapes' = 'green' ]")
+        assert items.is_a?(Hash), "Not a Hash"
+        assert_equal 2, items.keys.size, "More than 2 objects"
+        assert items['produce1']['celery'].first.to_i > 1000, "Celery less than 1000"
+      end
+      
+      should "(60) select objects" do
+        assert !@domain.nil?, "No domain"
+        q = "select * from #{@domain}"
+
+        items = @sdb.select(q)
+        assert items.is_a?(Hash), "Not a Hash"
+        assert_equal 2, items.keys.size, "More than 2 objects"
+        
+        # {"produce1"=>{"celery"=>["5200"], "grapes"=>["green"], "orange"=>["550"]}}
+        assert items['produce1']['celery'].first.to_i > 1000, "Celery less than 1000"
+      end
+      
+      
+      should "(70) destroy objects" do
+        assert !@domain.nil?, "No domain"
+        q = "select * from #{@domain}"
+        items = @sdb.select(q)
+        assert items.is_a?(Hash), "Not a Hash"
+        items.keys.each do |item|
+          assert @sdb.destroy(@domain, item), "Not destroyed (#{item})"
+        end
+        sleep 1 # Eventual consistency. Items may still appear. 
+        q = "select * from #{@domain}"
+        items = @sdb.select(q)
+        assert items.nil?, "Some items not destroyed (#{items})"
+      end
+      
+      should "(99) destroy domains" do
+        
+        assert !@domain.nil?, "No domain"
+        
+        @domain_list.each do |domain|
+          assert @sdb.destroy_domain(domain), "Not destroyed (#{domain})"
+        end
+        
+        domain_list = @sdb.list_domains
+        assert domain_list.empty?, "Not empty"
+      end
+      
+    end
+    
+  end
+end

data/test/25_ec2/00_setup_test.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), '..', 'helper')
+
+module Rudy::Test
+  # Expects:
+  # * There to be no pre-existing keypairs, addresses, etc... (except 
+  #   the default group)
+  # * It can destroy instances, images, etc... 
+  #
+  # DO NOT RUN THIS TEST ON A PRODUCTION AWS ACCOUNT!!
+  #
+  class Case_25_EC2 < Test::Unit::TestCase
+    include Rudy::Huxtable
+    
+    @@zone = @@global.zone.to_s
+
+    
+    context "#{name}_00 Setup" do
+      should "(10) have class variables setup" do
+        stop_test !@@global.is_a?(Rudy::Global), "We don't have global (#{@@global})"
+        stop_test !@@config.is_a?(Rudy::Config), "We don't have an instance of Rudy::Config (#{@@config})"
+        stop_test !@@global.accountnum, "No account number"
+      end
+      should "(11) be zone" do
+        stop_test !@@zone, "No zone"
+      end
+    end
+  end
+  
+end

data/test/25_ec2/10_keypairs_test.rb

@@ -0,0 +1,41 @@
+
+module Rudy::Test
+  
+  class Case_25_EC2
+    
+    context "#{name}_10 KeyPairs" do
+      setup do
+        @@test_name ||= 'test-' << Rudy::Utils.strand
+        @ec2key = Rudy::AWS::EC2::KeyPairs.new(@@global.accesskey, @@global.secretkey, @@global.region)
+        #@ami = @@config.machines.find(@@zone.to_sym, :ami)
+      end
+      
+      
+      should "(10) create keypair" do
+        keypair = @ec2key.create(@@test_name)
+        assert keypair.is_a?(Rudy::AWS::EC2::KeyPair), "Not a KeyPair"
+        assert !keypair.name.empty?, "No name"
+        assert !keypair.fingerprint.empty?, "No fingerprint"
+        assert !keypair.private_key.empty?, "No private key"
+      end
+      
+      should "(20) list keypairs" do
+        keypairs = @ec2key.list || []
+        assert keypairs.size > 0, "No keypairs"
+      end
+      
+      should "(21) get specific keypair" do
+        assert @ec2key.get(@@test_name).is_a?(Rudy::AWS::EC2::KeyPair), "Not a KeyPair (#{@@test_name})"
+      end
+      
+      should "(50) destroy keypairs" do
+        keypairs = @ec2key.list || []
+        assert keypairs.size > 0, "No keypairs"
+        keypairs.each do |kp|
+          @ec2key.destroy(kp.name)
+        end
+      end
+    end
+    
+  end
+end

data/test/25_ec2/20_groups_test.rb

@@ -0,0 +1,131 @@
+
+module Rudy::Test
+
+  class Case_25_EC2
+    
+    def get_groups
+      # Ruby 1.8 throws an undefined method error when this is at the 
+      # bottom of the class
+      group_list = @ec2group.list_as_hash
+      # "default" cannot be deleted so we exempt it
+      group_list.reject { |gname,group| gname == "default" }
+    end
+    
+    
+    context "#{name}_20 Groups" do
+      setup do
+        @ec2group = Rudy::AWS::EC2::Groups.new(@@global.accesskey, @@global.secretkey, @@global.region)
+        @accountnum = @@config.accounts.aws.accountnum
+      end
+      
+      should "(00) not be existing groups" do
+        
+        group_list = get_groups
+        stop_test !group_list.empty?, "Destroy the existing groups (#{group_list.keys.join(', ')})"
+        stop_test !@accountnum, "Need an account number for group authorization"
+      end
+      
+      should "(01) create group with name" do
+        group_list = get_groups
+        test_name ||= 'test-' << Rudy::Utils.strand
+        str = Rudy::Utils.strand
+        group = @ec2group.create(test_name)
+        assert group.is_a?(Rudy::AWS::EC2::Group), "Not a Group object (#{group.class.to_s})"
+        assert_equal group.name, test_name, "Group name not set"
+        assert_equal group.description, "Security Group #{test_name}", "Group description not 'Security Group #{test_name}'"
+        assert @ec2group.exists?(test_name), "Group #{test_name} doesn't exist"
+      end
+      
+      should "(02) create group with name and description" do
+        test_name ||= 'test-' << Rudy::Utils.strand
+        str = Rudy::Utils.strand
+        desc = "Description for #{test_name}"
+        group = @ec2group.create(test_name, desc)
+        assert group.is_a?(Rudy::AWS::EC2::Group), "Not a Group object"
+        assert_equal group.name, test_name, "Group name not set"
+        assert_equal group.description, desc, "Group description not set"
+        assert @ec2group.exists?(test_name), "Group #{test_name} doesn't exist"
+      end
+      
+      should "(10) list available groups" do
+        group_list = @ec2group.list
+        assert group_list.is_a?(Array), "Group list is not an Array"
+
+        group_list_hash = @ec2group.list_as_hash
+        assert group_list_hash.is_a?(Hash), "Group list is not an Hash"
+
+        group_list.each do |group|
+          assert group.is_a?(Rudy::AWS::EC2::Group), "Not a group"
+        end
+      end
+      
+      should "(20) authorize/revoke group rules for address" do
+        external_ip_address = Rudy::Utils::external_ip_address
+        external_ip_address ||= '192.168.0.1/32'
+
+        test_name ||= 'test-' << Rudy::Utils.strand
+
+        group = @ec2group.create(test_name)
+        protocols = ['tcp', 'udp']
+        addresses = [external_ip_address]
+        ports = [[3100,3150],[3200,3250]]
+        
+        ret = @ec2group.authorize(test_name, addresses, ports, protocols)
+        assert ret, "Authorize did not return true"
+        
+        group = @ec2group.get(test_name)
+        
+        assert group.is_a?(Rudy::AWS::EC2::Group), "Not a group (#{group})"
+        assert group.addresses.is_a?(Hash), "Addresses is not a hash (#{group.addresses})"
+        
+        group.addresses.each_pair do |address,rules|
+          assert rules.is_a?(Array), "Not an Array"
+          assert_equal 7, rules.size, "Not 7 rules"
+          puts "TODO: Check port ranges"
+        end
+        
+        ret = @ec2group.revoke(test_name, addresses, ports, protocols)
+        assert ret, "Revoke did not return true"
+        sleep 1 # Wait for eventual consistency
+        group = @ec2group.get(test_name)
+        assert group.addresses.is_a?(Hash), "Addresses is not a hash"
+        assert group.addresses.empty?, "Some addresses not revoked #{group.addresses.to_s}"
+      end
+      
+      
+      should "(21) authorize/revoke group permissions for account/group" do
+        test_name ||= 'test-' << Rudy::Utils.strand
+        group = @ec2group.create(test_name)
+        should_have = "#{@accountnum}:#{test_name}"
+        
+        ret = @ec2group.authorize_group(test_name, test_name, @accountnum)
+        assert ret, "Authorize failed (#{should_have})"
+        group = @ec2group.get(test_name)
+        assert group.is_a?(Rudy::AWS::EC2::Group), "Not a Group object"
+        assert group.groups.is_a?(Hash), "Groups is not a Hash (#{group.groups.class})"
+        assert_equal should_have, group.groups.keys.first, "Authorized group is not #{should_have}"
+        # TODO: Check port ranges
+        
+        ret = @ec2group.revoke_group(test_name, test_name, @accountnum)
+        assert ret, "Revoke failed (#{should_have})"
+        group = @ec2group.get(test_name)
+        assert group.is_a?(Rudy::AWS::EC2::Group), "Not a Group object"
+        assert group.groups.is_a?(Hash), "Groups is not a Hash (#{group.groups.class})"
+        assert !group.groups.has_key?(should_have), "Still authorized for #{should_have}"
+      end
+      
+      
+      should "(50) destroy groups" do
+        group_list = get_groups
+        assert !group_list.empty?, "No groups"
+        group_list.each_pair do |gname,group|
+          assert @ec2group.destroy(group.name), "Not destroyed (#{group.name})"
+        end
+      end
+      
+
+    end
+    
+      
+  end
+end