jzimmek-ec2-control 0.0.4

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jan Zimmek
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,30 @@
+= ec2-control
+
+EC2-Control is a ruby based toolkit to ease management and configuration of an Amazon EC2 cloud.
+
+== Quickstart
+
+  cloud "my_network" do
+    keypair             "jzimmek"
+    availability_zone   "eu-west-1a"
+  
+    group "webserver" do
+      ami "ami-48cfe73c"
+      instance "web01" do
+        elastic_ip   "76.63.XX.YY"
+      end
+      instance "web01" do
+        availability_zone   "eu-west-1b"
+        mount               "vol-4ef91c27", "/dev/sdh"
+      end
+    end
+  end
+
+== Usage
+
+... coming soon ...
+
+
+== Copyright
+
+Copyright (c) 2009 Jan Zimmek. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ec2-control"
+    gem.summary = "A EC2 management and configuration toolkit"
+    gem.description = "EC2-Control is a ruby based toolkit to ease management and configuration of an Amazon EC2 cloud"
+    gem.email = "jan.zimmek@web.de"
+    gem.homepage = "http://github.com/jzimmek/ec2-control"
+    gem.authors = ["Jan Zimmek"]
+    gem.add_dependency "jzimmek-ec2-dsl"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ec2-control #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.0.4

data/ec2-control.gemspec

@@ -0,0 +1,52 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ec2-control}
+  s.version = "0.0.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jan Zimmek"]
+  s.date = %q{2009-06-14}
+  s.description = %q{EC2-Control is a ruby based toolkit to ease management and configuration of an Amazon EC2 cloud}
+  s.email = %q{jan.zimmek@web.de}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "ec2-control.gemspec",
+     "lib/ec2-control.rb",
+     "lib/ec2/control/controller.rb",
+     "lib/ec2/control/query.rb",
+     "test/ec2-control_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/jzimmek/ec2-control}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{A EC2 management and configuration toolkit}
+  s.test_files = [
+    "test/ec2-control_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<jzimmek-ec2-dsl>, [">= 0"])
+    else
+      s.add_dependency(%q<jzimmek-ec2-dsl>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<jzimmek-ec2-dsl>, [">= 0"])
+  end
+end

data/lib/ec2-control.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'ec2-dsl'
+require 'EC2'
+require 'ec2/control/controller'
+
+@orig_cloud = method(:cloud)
+
+def cloud(name, validate=true, &block)
+  @orig_cloud.call(name, validate, &block)
+
+  cloud_ref = instance_variable_get("@#{name}")
+  
+  control = Ec2::Control::Controller.new(cloud_ref, "AKIAJQ24F3G2GJ7RO3RA", "detTWpfPfengwji/qshm88FP6F7x4YuM4fBAIKch", "#{cloud_ref.region_value}.ec2.amazonaws.com")
+
+  running = control.query.instance_running_names
+  pending = control.query.instance_pending_names
+end
+
+# cloud "my_network" do
+#   keypair             "jzimmek"
+#   availability_zone   "eu-west-1a"
+#   
+#   group "webserver" do
+#     ami "ami-48cfe73c"
+#     instance "web01" do
+#       availability_zone   "eu-west-1b"
+#     end
+#     # instance "web01" do
+#     #   availability_zone   "eu-west-1b"
+#     #   mount               "vol-4ef91c27", "/dev/sdh"
+#     # end
+#   end
+# end
+# 

data/lib/ec2/control/controller.rb

@@ -0,0 +1,211 @@
+require 'ec2/control/query'
+
+module Ec2
+  module Control
+    class Controller
+  
+      attr_reader :query
+  
+      def initialize(cloud, access_key, secret_key, server)
+
+        @ec2 = EC2::Base.new( :access_key_id => access_key, 
+                              :secret_access_key => secret_key, 
+                              :server => server)
+                          
+        @query = Ec2::Control::Query.new(@ec2)
+        @cloud = cloud
+    
+        ensure_assigned_elastic_ip_exist
+        ensure_assigned_mount_volume_exist
+        ensure_assigned_availability_zone_exist
+        ensure_security_groups
+
+        ensure_stopping
+        @query.init
+
+        ensure_starting
+        @query.init
+
+        ensure_mounts
+        ensure_assigned_elastic_ip_attached
+    
+      end
+
+      def ensure_assigned_availability_zone_exist
+        @cloud.instances.each do |instance|
+          if availability_zone = instance.availability_zone_value
+            raise "availability zone '#{availability_zone}' of instance '#{instance.name}' is not available or does not exist" unless @query.availability_zone_available?(availability_zone)
+          end
+        end
+      end
+  
+      def ensure_assigned_elastic_ip_attached
+    
+        @cloud.instances.each do |instance|
+          if ip = instance.elastic_ip_value
+        
+            puts "elastic ip '#{ip}' should be assigned to instance '#{instance.name}'"
+        
+            unless @query.instance_running_by_name?(instance.name)
+              puts "elastic ip '#{ip}' could not be assigned because instance '#{instance.name}' is not running"
+              next
+            end
+        
+            unless @query.elastic_ip_associated?(ip)
+
+              puts "elastic ip '#{ip}' is not assigned to any instance"
+          
+              update_ec2(:associate_address,{
+                :instance_id => @query.instance_id_by_instance_name(instance.name),
+                :public_ip => ip
+              })
+          
+              puts "associate elastic ip '#{ip}' with instance '#{instance.name}'"
+          
+            else
+              associated_instance_id   = @query.elastic_ip_associated_instance_id(ip)
+              associated_instance_name = @query.instance_name_by_instance_id(associated_instance_id)
+          
+              if instance.name == associated_instance_name
+                puts "elastic ip '#{ip}' is already assigned to instance '#{instance.name}'"
+              else
+                update_ec2(:associate_address, {
+                  :instance_id => @query.instance_running_by_name?(instance.name)[:id], 
+                  :public_ip => ip
+                })
+            
+                puts "reassign elastic ip '#{ip} from instance '#{associated_instance_name ? associated_instance_name : associated_instance_id}' to instance '#{instance.name}'"
+              end
+          
+            end
+        
+          end
+        end
+      end
+  
+      def ensure_assigned_mount_volume_exist
+        @cloud.instances.each do |instance|
+          instance.mounts.each do |mount|
+            volume_id = mount[:volume_id]
+              available = @query.volume_available?(volume_id) 
+              in_use    = @query.volume_mounted?(volume_id) 
+              if !available && !in_use
+                raise "instance '#{instance.name}' mounts volume_id '#{volume_id}' which does not exist or is in invalid state"
+              end
+          end
+        end
+      end
+
+      def ensure_mounts
+        @cloud.instances.each do |instance|
+          instance.mounts.each do |mount|
+            
+            volume_id = mount[:volume_id]
+            device = mount[:device]
+            
+            puts "instance '#{instance.name}' should mount volume_id '#{volume_id}'"
+        
+            unless @query.instance_running_by_name?(instance.name)
+              puts "volumne_id '#{volume_id}' could not be mounted because instance '#{instance.name}' is not running"
+              next
+            end
+            
+            if @query.volume_available?(volume_id)
+              puts "volume_id '#{volume_id}' is not mounted on any instance"
+              update_ec2(:attach_volume,{
+                :volume_id => volume_id,
+                :device => device,
+                :instance_id => @query.instance_id_by_instance_name(instance.name)
+              })
+              puts "mounted volume_id '#{volume_id}' on instance '#{instance.name}'"
+            end
+            
+            if @query.volume_mounted?(volume_id)
+              mounting_instance_id    = @query.volume_mounted_instance_id(volume_id)
+              mounting_instance_name  = @query.instance_name_by_instance_id(mounting_instance_id)
+              
+              if mounting_instance_name != instance.name
+                raise "volume_id '#{volume_id}' is already mounted on instance '#{mounting_instance_name ? mounting_instance_name : mounting_instance_id}'"
+              end
+            end
+
+          end
+        end
+      end
+  
+  
+      def ensure_assigned_elastic_ip_exist
+        @cloud.instances.each do |instance|
+          if ip = instance.elastic_ip_value
+            raise "elastic ip '#{ip}' should be assigned to instance '#{instance.name}' but does not exist" unless @query.elastic_ip_available?(ip)
+          end
+        end
+      end
+  
+  
+      def ensure_stopping
+        valid   = @cloud.instances.collect{|instance|instance.name}
+        invalid = @query.instances_running_except_names(valid)
+    
+        unless invalid.empty?
+          puts "found invalid running instances:"
+          invalid.each do |instance|
+            puts "  name: #{instance[:name]}, id: #{instance[:id]}"
+          end
+      
+          update_ec2(:terminate_instances, :instance_id => invalid.collect{|instance|instance[:id]})
+        end
+      end
+  
+      def ensure_starting
+
+        @cloud.instances.each do |instance|
+      
+          name            = instance.name
+
+          next if @query.instance_pending_by_name?(name)
+          next if @query.instance_running_by_name?(name)
+
+          ami             = instance.ami_value
+          region          = instance.region_value
+          keypair         = instance.keypair_value
+          security_group  = instance.security_group_value
+      
+          puts "  instance: #{name}, ami: #{ami}, region: #{region}, keypair: #{keypair}, security_group: #{security_group}"
+
+          update_ec2(:run_instances, {
+            :image_id => ami, 
+            :min_count => 1, 
+            :max_count => 1,
+            :key_name => keypair,
+            :availability_zone => instance.availability_zone_value,
+            :group_id => [security_group, "ec2_control_#{name}"]          
+          })
+      
+      
+        end
+    
+      end
+
+      def ensure_security_groups
+        @cloud.instances.each do |instance|
+          name = instance.name
+          unless @query.security_group_exist?("ec2_control_#{name}")
+            update_ec2(:create_security_group, {
+              :group_name => "ec2_control_#{name}", 
+              :group_description => "ec2 control identifier for instance #{name}"
+            })
+          end
+        end
+      end
+
+      def update_ec2(method, *args)
+        puts "// ---"
+        puts "ec2 command: #{method}(#{args.inspect})"
+        @ec2.send(method.to_sym, *args)
+        puts "--- //"
+      end
+  
+    end
+  end
+end

data/lib/ec2/control/query.rb

@@ -0,0 +1,208 @@
+module Ec2
+  module Control
+
+    class Query
+
+      def initialize(ec2)
+        @ec2 = ec2
+        self.init
+      end
+      
+      def init
+        __init_security_groups(true)
+        __init_availability_zones(true)
+        __init_volumes(true)
+        __init_elastic_ips(true)
+        __init_running_and_pending(true)
+      end
+
+      def security_group_exist?(name)
+        @security_groups.include?(name)
+      end
+
+      def availability_zone_available?(name)
+        @available_zones.find{|zone| zone.status == "available" && zone.name == name}
+      end
+
+      def volume_available?(volume_id)
+        @volumes.find{|volume| volume[:status] == "available" && volume[:volume_id] == volume_id}
+      end
+      
+      def volume_mounted?(volume_id)
+        @volumes.find{|volume| volume[:status] == "in-use" && volume[:volume_id] == volume_id}
+      end
+
+      def volume_mounted_instance_id(volume_id)
+        volume = @volumes.find{|volume| volume[:status] == "in-use" && volume[:volume_id] == volume_id}
+        volume ? volume[:instance_id] : nil
+      end
+
+      def elastic_ip_available?(ip)
+        @elastic_ips.find{|elastic|elastic[:ip] == ip}
+      end
+
+      def elastic_ip_associated?(ip)
+        @elastic_ips.find{|elastic|elastic[:ip] == ip && elastic[:instance_id]}
+      end
+
+      def elastic_ip_associated_instance_id(ip)
+        @elastic_ips.find{|elastic|elastic[:ip] == ip}[:instance_id]
+      end
+
+      def instance_name_by_instance_id(instance_id)
+        instance = @instances.find{|instance|instance[:id] == instance_id}
+        instance ? instance[:name] : nil
+      end
+
+      def instance_id_by_instance_name(name)
+        instance = @instances.find{|instance|instance[:status] == "running" && instance[:name] == name}
+        instance ? instance[:id] : nil
+      end
+
+      def instance_running_by_name?(value)
+        @instances.find{|instance|instance[:status] == "running" && instance[:name] == value}
+      end
+
+      def instance_pending_by_name?(value)
+        @instances.find{|instance|instance[:status] == "pending" && instance[:name] == value}
+      end
+
+      def instances_running_except_names(names)
+        @instances.find_all{|instance|instance[:status] == "running" && !names.include?(instance[:name])}
+      end
+
+      def instance_running_count
+        @instances.find_all{|instance|instance[:status] == "running"}.length
+      end
+
+      def instance_pending_count
+        @instances.find_all{|instance|instance[:status] == "pending"}.length
+      end
+
+      def instance_running_names
+        @instances.find_all{|instance|instance[:status] == "running"}.collect{|instance|instance[:name]}
+      end
+
+      def instance_pending_names
+        @instances.find_all{|instance|instance[:status] == "pending"}.collect{|instance|instance[:name]}
+      end
+
+      def __init_security_groups(reload=false)
+
+        if @security_groups.nil? || reload
+          @security_groups = @ec2.describe_security_groups.securityGroupInfo.item.collect{ |security_group| security_group.groupName }
+        end
+
+        @security_groups
+
+      end
+
+      def __init_availability_zones(reload=false)
+
+        if @available_zones.nil? || reload
+          available_zones = []
+          availability_zone_info = @ec2.describe_availability_zones.availabilityZoneInfo
+
+          if availability_zone_info && !(z_item = availability_zone_info.item).empty?
+            z_item.each do |zone|
+              available_zones << {:region => zone.regionName, :name => zone.zoneName, :status => zone.zoneState}
+            end
+          end
+
+          @available_zones = available_zones
+        end
+
+        @available_zones
+      end
+
+      def __init_elastic_ips(reload=false)
+
+        if @elastic_ips.nil? || reload
+          ips = []
+          addressesSet = @ec2.describe_addresses.addressesSet
+
+          if addressesSet && !(a_item = addressesSet.item).empty?
+            a_item.each do |adr|
+              ips << {:instance_id => adr.instanceId, :ip => adr.publicIp}
+            end
+          end
+          @elastic_ips = ips
+        end
+
+        @elastic_ips
+      end
+
+
+      def __init_volumes(reload=false)
+
+        if @volumes.nil? || reload
+          volumes = []
+          volumeSet = @ec2.describe_volumes.volumeSet
+
+          if volumeSet && !(v_item = volumeSet.item).empty?
+            v_item.each do |volume|
+              
+              volume_id         = volume.volumeId
+              availability_zone = volume.availabilityZone
+              status            = volume.status
+              instance_id       = nil
+              
+              attachmentSet = volume.attachmentSet
+              
+              if attachmentSet && !(a_item = attachmentSet.item).empty?
+                raise "this version of ec2-control cannot handle more than one attachement set" if a_item.length > 1
+                instance_id     = a_item.first.instanceId
+              end
+              
+              volumes << {:volume_id => volume_id, :availability_zone => availability_zone, :instance_id => instance_id, :status => status}
+            end
+          end
+
+          @volumes = volumes
+        end
+
+        @volumes
+
+      end
+
+      def __init_running_and_pending(reload=false)
+
+        if @instances.nil? || reload    
+          @instances = []
+
+          reservationSet = @ec2.describe_instances.reservationSet
+
+          if reservationSet && !(r_item = reservationSet.item).empty?
+            r_item.each do |reservation|
+
+              reservation.groupSet.item.each do |grp| 
+
+                if grp.groupId =~ /^ec2_control_/
+                  grp_name = grp.groupId.gsub(/ec2_control_/, '')
+
+                  instancesSet = reservation.instancesSet
+
+                  if instancesSet && !(i_item = instancesSet.item).empty?
+
+                    raise "this version of ec2-control cannot handle more than one instance per reservation" if i_item.length > 1
+
+                    instance = i_item.first
+                    instance_id = instance.instanceId
+
+                    @instances << {:name => grp_name, :id => instance_id, :status => instance.instanceState.name}
+
+                  end
+
+                end
+              end
+            end
+          end
+        end
+
+        @instances
+      end
+
+    end
+    
+  end
+end

data/test/ec2-control_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class Ec2ControlTest < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'ec2-control'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: jzimmek-ec2-control
+version: !ruby/object:Gem::Version 
+  version: 0.0.4
+platform: ruby
+authors: 
+- Jan Zimmek
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-14 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: jzimmek-ec2-dsl
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: EC2-Control is a ruby based toolkit to ease management and configuration of an Amazon EC2 cloud
+email: jan.zimmek@web.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- ec2-control.gemspec
+- lib/ec2-control.rb
+- lib/ec2/control/controller.rb
+- lib/ec2/control/query.rb
+- test/ec2-control_test.rb
+- test/test_helper.rb
+has_rdoc: false
+homepage: http://github.com/jzimmek/ec2-control
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: A EC2 management and configuration toolkit
+test_files: 
+- test/ec2-control_test.rb
+- test/test_helper.rb