bigbang 0.0.5 → 0.0.6

data/README.rdoc

@@ -42,40 +42,47 @@ of the instance.
 
 Consider the following universe file:
 
-  	universe do
-  		config do |c|
-  			c.access_key_id = "YOUR-AMAZON-ACCESS_KEY"
-  			c.secret_key = "YOUR-AMAZON-SECRET_KEY"
+     universe do
+        config do |c|
+           c.access_key_id = "YOUR-AMAZON-ACCESS_KEY"
+           c.secret_key = "YOUR-AMAZON-SECRET_KEY"
   
-  			c.dns :provider => 'Zerigo', 
-  				:zerigo_email => "example@example.com",
-  				:zerigo_token => 'xxxxxxxxxxxxx'
-  		
-  			c.domain = "example.com"
-  		end
+           c.dns :provider => 'Zerigo', 
+              :zerigo_email => "example@example.com",
+              :zerigo_token => 'xxxxxxxxxxxxx'
+        
+           c.domain = "example.com"
+        end
   
-  		# describe your instance
-  		instance "ubuntu" do |i|
-  			i.ami = "ami-e2af508b"
-  			i.key_name = "dev"
-  			i.type = "m1.small"
-  			i.bootstrap_repo = "git://github.com/giorgenes/ec2-chef-bootstrap.git"
-	  	end
-
-  		# run a single instance
-  		run_single_instance("ubuntu") do |r|
-  	  		r.domain = ["db"]
-  	  		r.wildcard_domain = true
-  	  		r.elastic_ip = true
-  	   end
+        # describe your instance
+        instance "ubuntu" do |i|
+           i.ami = "ami-e2af508b"
+           i.key_name = "dev"
+           i.type = "m1.small"
+           i.bootstrap_repo = "git://github.com/giorgenes/ec2-chef-bootstrap.git"
+        end
+
+        # run a single instance
+        run_single_instance("ubuntu") do |r|
+             r.domain = ["db"]
+             r.wildcard_domain = true
+             r.elastic_ip = true
+        end
   
-  		# runs a cluster of db instances
-  		run_cluster("ubuntu") do |r|
-  			r.domain = ["app"]
-  			availability_zone "us-east-1a" => 1
-  			availability_zone "us-east-1b" => 1
-  		end
-  	end
+        # runs a cluster of db instances
+        run_cluster("ubuntu") do |r|
+           r.domain = ["app"]
+           availability_zone "us-east-1a" => 1
+           availability_zone "us-east-1b" => 1
+           r.load_balancer("app") do |lb|
+              lb.domains = ["app"]
+              lb.listeners = [
+                 { :protocol => 'http', :load_balancer_port => 80, :instance_port => 80 }
+              ]
+              lb.availability_zones = ["us-east-1a", "us-east-1b"]
+           end
+        end
+     end
   
 In this example we have a single instance of "ubuntu" AND a cluster of "ubuntu".
 So if you run for example "bigbang explode live" it will do the following:
@@ -89,24 +96,27 @@ So if you run for example "bigbang explode live" it will do the following:
   - create 2 ec2 instances on the specified availability zones.
   - clone the repo in the boxes and install chef
   - create DNS records to the boxes: live.app0.example.com and live.app1.example.com
+  - create a load balancer called "app" for the http protocol mapping ports 80 to 80.
+  - assign the cluster instances to the created load balancer
+  - create a CNAME record for the load balancer: live.app.example.com
 
 == Commands
 
 - creates a universe called <universe-name>
   
-  bigbang explode <universe-name>
+   bigbang explode <universe-name>
 
 - list universes
   
-  bigbang list
+   bigbang list
 
 - kill a universe
   
-  bigbang kill <universe-name>
+   bigbang kill <universe-name>
 
 - test configuration
   
-  bigbang test
+   bigbang test
 
 = IMPORTANT
 

data/lib/bigbang/cluster_run.rb

@@ -1,8 +1,10 @@
 require 'bigbang/run'
+require 'bigbang/lb'
 
 module BigBang
 	class ClusterRun < Run
-	
+		attr_accessor :lb
+
 		def initialize(name, instances)
 			super(name, instances)
 		end
@@ -10,5 +12,10 @@ module BigBang
 		def availability_zone(h)
 			@zone_sizes.merge!(h)
 		end
+
+		def load_balancer(name, &block)
+			@lb = LoadBalancer.new(name)
+			@lb.instance_eval(&block)
+		end
 	end
 end

data/lib/bigbang/explode.rb

@@ -48,18 +48,15 @@ module BigBang
 			(avail_ips - black_ips).to_a[0,ninstances]
 		end
 
-
-
 		def wait_for_running(instances)
 			ids = instances.collect { |i| i.instanceId }.to_set
-			print "Waiting for all instances to be in running state. "
-			STDOUT.flush
-			while running_instances_count(ids) < instances.size
-				print "."
-				sleep(5)
-				STDOUT.flush
+			notify("Waiting for all instances to be in running state. ") do
+				while running_instances_count(ids) < instances.size
+					print "."
+					STDOUT.flush
+					sleep(5)
+				end
 			end
-			puts
 		end
 
 		def tag_instance(instance, ec2_instance, name)
@@ -71,8 +68,8 @@ module BigBang
 		end
 
 		def run_instance(instance, userdata, zone, size)
-			puts "launching #{size} instance(s) on availability zone '#{zone}'"
-			provider.ec2.run_instances(
+			notify("launching #{size} instance(s) on availability zone '#{zone}'") do
+				provider.ec2.run_instances(
 					:image_id => instance.ami,
 					:key_name => instance.key_name,
 					:instance_type => instance.type,
@@ -80,7 +77,8 @@ module BigBang
 					:availability_zone => zone,
 					:min_count => size,
 					:max_count => size
-			)
+				)
+			end
 		end
 
 		def run_instances(name)
@@ -117,16 +115,26 @@ module BigBang
 			end
 		end
 
-		def create_dns_entry_for(instance, universe_name, domain, addr, wildcard)
+		def dns_entry_for(instance, universe_name, domain, addr, wildcard)
+			entries = []
 			domain = "#{universe_name}.#{domain}"
-			puts "creating domain #{domain}.#{@config.domain} to #{addr}"
-			provider.create_dns(domain, addr)
+			entries << {:domain => domain, :value => addr, :type => 'A'}
 			if wildcard == true
-				provider.create_dns("*.#{domain}", addr)
+				entries << {:domain => "*.#{domain}", :value => addr, :type => 'A'}
+			end
+			entries
+		end
+
+		def create_dns_entries(entries)
+			entries.each do |entry|
+				notify("creating domain #{entry[:domain]}.#{@config.domain} => #{entry[:value]}") do
+					provider.create_dns(entry[:domain], entry[:value], entry[:type])
+				end
 			end
 		end
 
-		def create_dns_entries(universe_name)
+		def instance_dns_entries(universe_name)
+			entries = []
 			instances_map = get_instances_map
 			@runs.each do |r|
 				addsufix = false
@@ -152,11 +160,50 @@ module BigBang
 						if addsufix
 							domain = "#{domain}#{sufix}"
 						end
-						create_dns_entry_for(instance, universe_name, domain, addr, r.wildcard_domain)
+						entries += dns_entry_for(instance, universe_name, domain, addr, r.wildcard_domain)
 					end
 					sufix += 1
 				end
 			end
+			entries
+		end
+
+		def create_lb(lb)
+			p = notify("creating ELB #{lb.name}") do
+				provider.elb.create_load_balancer(
+					:load_balancer_name => lb.name,
+					:listeners => lb.listeners,
+					:availability_zones => lb.availability_zones)
+			end
+			p
+		end
+
+		def create_load_balancers
+			@runs.each do |r|
+				next unless r.is_a?(ClusterRun)
+				next if r.lb.nil?
+
+				r.lb.ec2_elb = create_lb(r.lb)
+
+				notify("registering instances to ELB #{r.lb.name}") do
+					provider.elb.register_instances_with_load_balancer(
+						:load_balancer_name => r.lb.name,
+						:instances => r.ec2_instances
+					)
+				end
+			end
+		end
+
+		def elb_dns_entries(universe_name)
+			entries = []
+			configured_elbs.each do |lb|
+				lb.domains.each do |domain|
+					subdomain = "#{universe_name}.#{domain}"
+					cname = lb.ec2_elb.CreateLoadBalancerResult.DNSName
+					entries << { :domain => subdomain, :value => cname, :type => "CNAME" }
+				end
+			end
+			entries
 		end
 
 		def explode(name)
@@ -168,7 +215,10 @@ module BigBang
 					assign_addresses(free_eips)
 				end
 			end
-			create_dns_entries(name)
+			create_load_balancers
+			dns_entries = elb_dns_entries(name)
+			dns_entries += instance_dns_entries(name)
+			create_dns_entries(dns_entries)
 		end
 	end
 end

data/lib/bigbang/kill.rb

@@ -2,8 +2,9 @@ module BigBang
 	module KillCmd
 		def kill_instance(instance)
 			confirm("kill instance #{instance.instanceId}") do
-				provider.ec2.terminate_instances(:instance_id => [instance.instanceId])
-				puts "sent termination signal to #{instance.instanceId}"
+				notify("sending termination signal to #{instance.instanceId}") do
+					provider.ec2.terminate_instances(:instance_id => [instance.instanceId])
+				end
 			end
 		end
 
@@ -42,7 +43,20 @@ module BigBang
 			end
 		end
 
+		
+
+		def kill_elb
+			configured_elbs.each do |lb|
+				confirm("Delete ELB #{lb.name}") do
+					notify("deleting ELB #{lb.name}") do
+						provider.elb.delete_load_balancer(:load_balancer_name => lb.name)
+					end
+				end
+			end
+		end
+
 		def kill(name)
+			kill_elb
 			running = running_instances
 			instances = universe_running_instances(running, universe_tags(name))
 			addresses = get_addresses

data/lib/bigbang/lb.rb

@@ -0,0 +1,10 @@
+module BigBang
+	class LoadBalancer
+		attr_accessor :domains, :name, :listeners, :availability_zones
+		attr_accessor :ec2_elb
+
+		def initialize(name)
+			@name = name
+		end
+	end
+end

data/lib/bigbang/provider.rb

@@ -11,6 +11,13 @@ module BigBang
 				:secret_access_key => @config.secret_key)
 		end
 
+		def elb
+			return @elb unless @elb.nil?
+			@elb = AWS::ELB::Base.new(
+				:access_key_id => @config.access_key_id, 
+				:secret_access_key => @config.secret_key)
+		end
+
 		def dns
 			return @dns unless @dns.nil?
 			@dns = Fog::DNS.new(@config.dns_opts)
@@ -20,11 +27,11 @@ module BigBang
 			dns.zones.find { |z| z.domain == @config.domain }
 		end
 
-		def create_dns(domain, addr)
+		def create_dns(domain, value, type)
 				configured_zone.records.create(
-						:value => addr,
+						:value => value,
 						:name => domain,
-						:type => "A")
+						:type => type)
 		end
 		
 		def eips

data/lib/bigbang/test.rb

@@ -38,10 +38,16 @@ module BigBang
 			end
 		end
 
+		def test_elb
+			ap provider.elb.describe_load_balancers
+			puts "elb access OK"
+		end
+
 		def test
 			get_instances
 			puts "ec2 access OK"
 
+			test_elb
 			test_availability_zones
 			test_amis
 			test_dns

data/lib/bigbang/universe.rb

@@ -53,10 +53,20 @@ module BigBang
 			map
 		end
 
+		def configured_elbs
+			lbs = []
+			@runs.each do |r|
+				next unless r.is_a?(ClusterRun)
+				next if r.lb.nil?
+				lbs << r.lb
+			end
+			lbs
+		end
+
 		def get_addresses
-			items = provider.ec2.describe_addresses.addressesSet.item
-			items = [] if items.nil?
-			items
+			aset = provider.ec2.describe_addresses.addressesSet
+			return [] if aset.nil?
+			aset.item
 		end
 		
 		def running_instances
@@ -105,6 +115,19 @@ module BigBang
 				return false
 			end
 		end
+
+		def notify(msg)
+			print "#{msg}: "
+			STDOUT.flush
+			begin
+				r = yield
+				puts "\033[01;32mOK\033[00m"
+				return r
+			rescue => e
+				puts "\033[01;31mERROR\033[00m"
+				raise
+			end
+		end
 		
 		def instance_tags(tags = nil)
 			tags = get_tags if tags.nil?

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: bigbang
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: 
   segments: 
   - 0
   - 0
-  - 5
-  version: 0.0.5
+  - 6
+  version: 0.0.6
 platform: ruby
 authors: 
 - Giorgenes Gelatti
@@ -72,6 +72,7 @@ files:
 - lib/bigbang/kill.rb
 - lib/bigbang/config.rb
 - lib/bigbang/cluster_run.rb
+- lib/bigbang/lb.rb
 has_rdoc: true
 homepage: http://github.com/giorgenes/bigbang/
 licenses: []