bigbang 0.0.1 → 0.0.2

data/README.rdoc

@@ -0,0 +1,113 @@
+= BigBang
+
+== What is BigBang?
+
+Bigbang is a tool to create clusters using Amazon EC2 in a scriptable way.
+You create a descriptor file (called universe file) which describes your whole
+cluster and then you can launch it on EC2 with a single command.
+Bigbang allows you to use the same "universe" file to create multiple "universes", say
+for example a live, a QA and staging clusters.
+You can even use it to automate the creation of a cluster for performance testing
+purposes.
+
+== What can it do for you?
+
+BigBang can do the following:
+- startup ec2 instances
+- allocate and assign elastic ip's to instances
+- assign instances to load balancer
+- create DNS record entries (Amazon and Zerigo supported).
+- shutdown your whole cluster
+
+== How does it work?
+
+As stated before, all you have to do is create a "universe.rb" file which describes
+your cluster.
+You then run "bigbang explode <cluster-name>" and it will "explode your universe" :).
+
+== Installation
+
+   $> gem install bigbang
+   
+
+== How does it bootstrap the boxes?
+
+Bigbang uses a "git-based" bootstraper. What it means it that you configure a git repo which
+contains a "run" script. Bigbang will make sure this repo is cloned inside your ec2 instance
+and executed. What this script does is up to you.
+It can then for example install and setup puppet or chef which will continue the provisioning
+of the instance.
+
+== A simple example
+
+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"
+  
+  			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
+  
+  		# 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
+  
+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:
+- For the single instance:
+  - create an ec2 instance with type "m1.small" and ami and key as stated.
+  - allocate an elastic ip and associate with the intance.
+  - clone the specified repo inside the box and run it (in this example, it will install chef).
+  - create DNS records pointing to the instance: live.db.example.com
+  - it will also create wildcard DNS records: *.live.db.example.com
+- For the cluster
+  - 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
+
+== Commands
+
+- creates a universe called <universe-name>
+  
+  bigbang explode <universe-name>
+
+- list universes
+  
+  bigbang list
+
+- kill a universe
+  
+  bigbang kill <universe-name>
+
+- test configuration
+  
+  bigbang test
+
+= IMPORTANT
+
+This gem is still in very early development stage.

data/bin/bigbang

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 
+$: << File.dirname(__FILE__) + "/../lib/"
 require File.dirname(__FILE__) + "/../lib/bigbang"
 
 def help
@@ -9,8 +10,9 @@ end
 $universe = nil
 
 def self.universe(&block)
-	$universe = u = BigBang::Universe.new
-	u.instance_eval(&block)
+	dsl = BigBang::DSL.new
+	dsl.instance_eval(&block)
+	$universe = BigBang::Universe.new(dsl)
 end
 
 if ARGV.empty?

data/lib/bigbang/cluster_run.rb

@@ -0,0 +1,14 @@
+require 'bigbang/run'
+
+module BigBang
+	class ClusterRun < Run
+	
+		def initialize(name, instances)
+			super(name, instances)
+		end
+	
+		def availability_zone(h)
+			@zone_sizes.merge!(h)
+		end
+	end
+end

data/lib/bigbang/dsl.rb

@@ -1,15 +1,17 @@
 require 'bigbang/config'
 require 'bigbang/instance'
-require 'bigbang/cluster'
+require 'bigbang/cluster_run'
+require 'bigbang/run'
 
 module BigBang
-	module DSL
-		def cluster(name, &block)
-			@instances << Cluster.new(name).tap do |cluster|
-				cluster.instance_eval(&block)
-			end
-		end
+	class DSL
+		attr_accessor :instances, :conf, :runs
 		
+		def initialize
+			@instances = []
+			@runs = []
+		end
+
 		def instance(name, &block)
 			@instances << Instance.new(name).tap do |i|
 				i.instance_eval(&block)
@@ -17,9 +19,21 @@ module BigBang
 		end
 
 		def config(&block)
-			@config = Config.new.tap do |c|
+			@conf = Config.new.tap do |c|
 				c.instance_eval(&block)
 			end
 		end
+
+		def run_single_instance(name, &block)
+			@runs << Run.new(name, @instances).tap do |r|
+				r.instance_eval(&block)
+			end
+		end
+
+		def run_cluster(name, &block)
+			@runs << ClusterRun.new(name, @instances).tap do |r|
+				r.instance_eval(&block)
+			end
+		end
 	end
 end

data/lib/bigbang/explode.rb

@@ -0,0 +1,174 @@
+module BigBang
+	module ExplodeCmd
+		def wait_for_eips(expected)
+			print "waiting for eips to be allocated"
+			STDOUT.flush
+			addrs = provider.free_eips
+			while(addrs.size < expected)
+				sleep(1)
+				print "."
+				STDOUT.flush
+				addrs = provider.free_eips
+			end
+			puts
+			addrs
+		end
+
+		def allocate_addresses
+			runs = @runs.find_all { |r| r.elastic_ip == true }
+			if runs.empty?
+				puts "no need to allocate elastic ips"
+				return []
+			end
+			free_ips = provider.free_eips
+			ninstances = runs.inject(0) { |m,r| m += r.instances_count }
+			toalloc = ninstances 
+			blacklist = free_ips
+			if free_ips.size > 0
+				n = nil
+				if free_ips.size >= ninstances
+					n = ninstances
+				else
+					n = free_ips.size
+				end
+				confirm("Use #{n} of your #{free_ips.size} free eips?") do
+					blacklist = []
+					toalloc -= n
+				end
+			end
+			puts "need to alloc: #{toalloc}"
+			1.upto(toalloc) do |i|
+				puts "allocating eip address #{i}"
+				provider.ec2.allocate_address
+			end
+
+			addrs = wait_for_eips(free_ips.size + toalloc)
+			avail_ips = addrs.collect { |a| a.publicIp }.to_set
+			black_ips = blacklist.collect { |a| a.publicIp }.to_set
+			(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
+			end
+			puts
+		end
+
+		def tag_instance(instance, ec2_instance, name)
+			provider.ec2.create_tags(:resource_id => ec2_instance.instanceId,
+					:tag => [
+							{ 'bb_name' => instance.name },
+							{ 'bb_universe' => name},
+					])
+		end
+
+		def run_instance(instance, userdata, zone, size)
+			puts "launching #{size} instance(s) on availability zone '#{zone}'"
+			provider.ec2.run_instances(
+					:image_id => instance.ami,
+					:key_name => instance.key_name,
+					:instance_type => instance.type,
+					:user_data => userdata,
+					:availability_zone => zone,
+					:min_count => size,
+					:max_count => size
+			)
+		end
+
+		def run_instances(name)
+			instances = []
+			gen = Ec2BootstrapGenerator.new
+			@runs.each do |r|
+				instance = r.instance
+				userdata = Base64.encode64(gen.generate_from_hash(
+					"bootstrap-repo" => instance.bootstrap_repo
+				))
+				r.zones.each_pair do |zone,size|
+					res = run_instance(instance, userdata, zone, size)
+					res.instancesSet.item.each do |i|
+						instances << i
+						r.ec2_instances << i.instanceId
+						tag_instance(instance, i, name)
+					end
+				end
+			end
+			wait_for_running(instances)
+		end
+
+		def assign_addresses(addrs) 
+			@runs.each do |r|
+				r.ec2_instances.each do |instance|
+					addr = addrs.pop
+					puts "associating address #{addr} " + 
+						"to instance #{instance.instanceId}"
+					provider.ec2.associate_address(
+						:instance_id => instance.instanceId,
+						:public_ip => addr)
+					r.assigned_ips[instance.instanceId] = addr
+				end
+			end
+		end
+
+		def create_dns_entry_for(instance, universe_name, domain, addr, wildcard)
+			domain = "#{universe_name}.#{domain}"
+			puts "creating domain #{domain}.#{@config.domain} to #{addr}"
+			provider.create_dns(domain, addr)
+			if wildcard == true
+				provider.create_dns("*.#{domain}", addr)
+			end
+		end
+
+		def create_dns_entries(universe_name)
+			instances_map = get_instances_map
+			@runs.each do |r|
+				addsufix = false
+				if r.is_a?(ClusterRun)
+					addsufix = true
+				end
+
+				domains = [r.domain]
+				if r.domain.is_a?(Array)
+					domains = r.domain
+				end
+
+				sufix = 0
+				r.ec2_instances.each do |instance_id|
+					instance = instances_map[instance_id]
+					domains.each do |domain|
+						addr = r.assigned_ips[instance.instanceId]
+						# use the elastic ip
+						if addr.nil?
+							addr = instance.ipAddress
+						end
+
+						if addsufix
+							domain = "#{domain}#{sufix}"
+						end
+						create_dns_entry_for(instance, universe_name, domain, addr, r.wildcard_domain)
+					end
+					sufix += 1
+				end
+			end
+		end
+
+		def explode(name)
+			free_eips = allocate_addresses
+			run_instances(name)
+			unless free_eips.empty?
+				confirm("Will assign the following ips:\n" +
+					"#{free_eips.join("\n")}\nConfirm") do
+					assign_addresses(free_eips)
+				end
+			end
+			create_dns_entries(name)
+		end
+	end
+end

data/lib/bigbang/instance.rb

@@ -5,8 +5,7 @@ module BigBang
 		end
 
 		attr_accessor :ami, :key_name, :type, 
-			:name, :elastic_ip, 
-			:domain, :wildcard_domain,
+			:name,
 			:bootstrap_repo,
 			:bootstrap_params
 	end

data/lib/bigbang/kill.rb

@@ -0,0 +1,56 @@
+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}"
+			end
+		end
+
+		def kill_dns_entry(instance)
+			records = provider.configured_zone.records
+
+			records = records.find_all do |r|
+				r.value == instance.ipAddress
+			end
+			if records.empty?
+				puts "no DNS records found for ip #{instance.ipAddress}"
+				return
+			end
+
+			domains = records.collect { |r| r.domain }
+			confirm("Would you like to remove the following dns records?\n" +
+				domains.join("\n") + "\n") do
+				records.each do |r|
+					puts "removing DNS #{r.domain}"
+					r.destroy
+				end
+			end
+		end
+
+		def kill_eip(i, addresses)
+			addr = addresses.find { |a| a.publicIp == i.ipAddress }
+				
+			unless addr.nil?
+				confirm("Would you like to release EIP address #{addr.publicIp} of instance #{i.instanceId}") do
+					puts "disassociating address #{addr.publicIp}"
+					provider.ec2.disassociate_address(:public_ip => addr.publicIp)
+					
+					puts "releasing address #{addr.publicIp}"
+					provider.ec2.release_address(:public_ip => addr.publicIp)
+				end
+			end
+		end
+
+		def kill(name)
+			running = running_instances
+			instances = universe_running_instances(running, universe_tags(name))
+			addresses = get_addresses
+			instances.each do |i|
+				kill_dns_entry(i)
+				kill_eip(i, addresses)
+				kill_instance(i)
+			end
+		end
+	end
+end

data/lib/bigbang/run.rb

@@ -0,0 +1,26 @@
+module BigBang
+	class Run
+		attr_accessor :instance, :domain, :wildcard_domain, :elastic_ip
+		attr_accessor :zone_sizes
+		attr_accessor :ec2_instances
+		attr_accessor :assigned_ips
+
+		def initialize(name, instances)
+			@zone_sizes = {}
+			@ec2_instances = []
+			@assigned_ips = {}
+			@instance = instances.find { |i| i.name == name }
+			raise "instance #{name} not found" if @instance.nil?
+		end
+
+		def zones
+			return @zone_sizes unless @zone_sizes.empty?
+
+			{ nil => 1 }
+		end
+
+		def instances_count
+			zones.values.inject(0) { |m,v| m += v }
+		end
+	end
+end

data/lib/bigbang/test.rb

@@ -0,0 +1,50 @@
+module BigBang
+	module TestCmd
+		def test_availability_zones
+			zones = Set.new
+			@runs.each do |r|
+				r.zone_sizes.each_key do |k|
+					zones << k
+				end
+			end
+
+			return if zones.empty?
+			ec2_zones = get_availability_zones
+			zones.each do |zone|
+				unless ec2_zones.find { |z| z.zoneName == zone}
+					raise "zone '#{zone}' not found"
+				end
+			end
+
+			puts "Availability zones OK"
+		end
+
+		def test_amis
+			@instances.collect { |i| i.ami }.to_set.each do |ami|
+				begin
+					provider.ec2.describe_images(:image_id => [ami])
+				rescue AWS::InvalidAMIIDNotFound => e
+					puts "ami #{ami} not found"
+				end
+			end
+			puts "AMI's OK"
+		end
+
+		def test_dns
+			if provider.configured_zone.nil?
+				puts "Configured DNS domain zone not found"
+			else
+				puts "DNS domain OK"
+			end
+		end
+
+		def test
+			get_instances
+			puts "ec2 access OK"
+
+			test_availability_zones
+			test_amis
+			test_dns
+		end
+	end
+end

data/lib/bigbang/universe.rb

@@ -7,21 +7,29 @@ require 'bigbang/provider'
 require 'bigbang/instance'
 require 'bigbang/dsl'
 require 'bigbang/ec2-git-bootstrap'
+require 'bigbang/kill'
+require 'bigbang/test'
+require 'bigbang/explode'
 
 module BigBang
 	class Universe
-		def initialize
-			@clusters = []
-			@instances = []
+		def initialize(dsl)
+			@instances = dsl.instances
+			@runs = dsl.runs
+			@config = dsl.conf
 		end
 
-		include DSL
-	
 		def provider
 			return @provider unless @provider.nil?
 			@provider = Provider.new(@config)
 		end
 
+		def get_availability_zones
+			item = provider.ec2.describe_availability_zones.availabilityZoneInfo.item
+			item = [] if item.nil?
+			item
+		end
+
 		def get_instances
 			rset = provider.ec2.describe_instances.reservationSet
 			if rset.nil?
@@ -37,72 +45,20 @@ module BigBang
 			end
 		end
 
-		def test
-			ap provider.eips
-			get_instances	
-			puts "ec2 access OK"
-			@instances.collect { |i| i.ami }.to_set.each do |ami|
-				begin
-					provider.ec2.describe_images(:image_id => [ami])
-				rescue AWS::InvalidAMIIDNotFound => e
-					puts "ami #{ami} not found"
-				end
-			end
-			puts "AMI's OK"
-			if provider.configured_zone.nil?
-				puts "Configured DNS domain zone not found"
-			else
-				puts "DNS domain OK"
+		def get_instances_map
+			map = {}
+			get_instances.each do |i|
+				map[i.instanceId] = i
 			end
+			map
 		end
 
-		def wait_for_eips(expected)
-			print "waiting for eips to be allocated"
-			STDOUT.flush
-			addrs = provider.free_eips
-			while(addrs.size < expected)
-				sleep(1)
-				print "."
-				STDOUT.flush
-				addrs = provider.free_eips
-			end
-			puts
-			addrs
+		def get_addresses
+			items = provider.ec2.describe_addresses.addressesSet.item
+			items = [] if items.nil?
+			items
 		end
-
-		def allocate_addresses
-			instances = @instances.find_all { |i| i.elastic_ip == true }
-			if instances.empty?
-				puts "no need to allocate elastic ips"
-				return
-			end
-			free_ips = provider.free_eips
-			toalloc = instances.size
-			blacklist = free_ips
-			if free_ips.size > 0
-				n = nil
-				if free_ips.size >= instances.size
-					n = instances.size
-				else
-					n = free_ips.size
-				end
-				confirm("Use #{n} of your #{free_ips.size} free eips?") do
-					blacklist = []
-					toalloc -= n
-				end
-			end
-			puts "need to alloc: #{toalloc}"
-			1.upto(toalloc) do |i|
-				puts "allocating eip address #{i}"
-				provider.ec2.allocate_address
-			end
-
-			addrs = wait_for_eips(free_ips.size + toalloc)
-			avail_ips = addrs.collect { |a| a.publicIp }.to_set
-			black_ips = blacklist.collect { |a| a.publicIp }.to_set
-			(avail_ips - black_ips).to_a[0,instances.size]
-		end
-
+		
 		def running_instances
 			get_instances.find_all { |i| i.instanceState.name == "running" }
 		end
@@ -111,87 +67,7 @@ module BigBang
 			running_instances.count { |i| ids.include?(i.instanceId) }
 		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
-			end
-			puts
-		end
-
-		def run_instances(name)
-			instances = []
-			gen = Ec2BootstrapGenerator.new
-			@instances.each do |instance|
-				userdata = Base64.encode64(gen.generate_from_hash(
-					"bootstrap-repo" => instance.bootstrap_repo
-				))
-				res = provider.ec2.run_instances(
-					:image_id => instance.ami,
-					:key_name => instance.key_name,
-					:instance_type => instance.type,
-					:user_data => userdata)
-				ap res
-				res.instancesSet.item.each do |i|
-					instances << i
-					provider.ec2.create_tags(:resource_id => i.instanceId,
-						:tag => [
-								{ 'bb_name' => instance.name },
-								{ 'bb_universe' => name},
-						])
-				end
-			end
-			instances.tap do |i|
-				wait_for_running(i)
-			end
-		end
-
-		def assign_addresses(instances, addrs) 
-			if instances.size != addrs.size
-				raise "error: instances number and addresses don't match"
-			end
-	
-			instances.each_index do |i|
-				puts "associating address #{addrs[i]} " + 
-					"to instance #{instances[i].instanceId}"
-				provider.ec2.associate_address(
-					:instance_id => instances[i].instanceId,
-					:public_ip => addrs[i])
-			end
-		end
-
-		def create_dns_entries(name, instances, addrs)
-			@instances.each_index do |i|
-				domains = [@instances[i].domain]
-				if @instances[i].domain.is_a?(Array)
-					domains = @instances[i].domain
-				end
-				domains.each do |domain|
-					domain = "#{name}.#{domain}"
-					puts "creating domain #{domain}.#{@config.domain} to #{addrs[i]}"
-					provider.create_dns(domain, addrs[i])
-					if @instances[i].wildcard_domain == true
-						provider.create_dns("*.#{domain}", addrs[i])
-					end
-				end
-			end
-		end
-
-		def explode(name)
-			free_eips = allocate_addresses
-			confirm("Will assign the following ips:\n" +
-				"#{free_eips.join("\n")}\nConfirm") do
-				instances = run_instances(name)
-				assign_addresses(instances, free_eips)
-				create_dns_entries(name, instances, free_eips)
-			end
-		end
-
-		def tags
+		def get_tags
 			tag_set = provider.ec2.describe_tags(:filter => 
 					[{'key' => 'bb_universe'}]).tagSet
 			if tag_set.nil?
@@ -203,11 +79,19 @@ module BigBang
 
 		def list
 			universes = Set.new
-			tags.each do |tag|
+			get_tags.each do |tag|
 				universes << tag.value
 			end
+		
+			running = running_instances
+
 			universes.each do |u|
-				puts u
+				instances = universe_running_instances(running, universe_tags(u))
+				if instances.empty?
+					puts "#{u} (defunct)"
+				else
+					puts "#{u} (#{instances.size} running instances)"
+				end
 			end
 		end
 
@@ -222,25 +106,29 @@ module BigBang
 			end
 		end
 		
-		def kill_instance(tag, running)
-			instance = running.find { |i| i.instanceId == tag.resourceId }
-			if instance.nil?
-				puts "instance #{tag.resourceId} is not running. skipping"
-				return
-			end
-			confirm("kill instance #{tag.resourceId}") do
-				provider.ec2.terminate_instances(:instance_id => [tag.resourceId])
-				puts "sent termination signal to #{tag.resourceId}"
+		def instance_tags(tags = nil)
+			tags = get_tags if tags.nil?
+			tags.find_all { |t| t.resourceType == 'instance' }
+		end
+
+		def universe_running_instances(running, universe_tags)
+			res = []
+			instance_tags(universe_tags).each do |t|
+				i = running.find { |i| i.instanceId == t.resourceId }
+				res << i unless i.nil?
 			end
+
+			res
 		end
 
-		def kill(name)
-			running = running_instances
-			tags.find_all do |tag|
+		def universe_tags(name)
+			get_tags.find_all do |tag|
 				tag.value == name
-			end.each do |tag|
-				send("kill_#{tag.resourceType}", tag, running)
 			end
 		end
+
+		include KillCmd
+		include TestCmd
+		include ExplodeCmd
 	end
 end

data/lib/bigbang.rb

@@ -1,2 +1 @@
-
 require 'bigbang/universe'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: bigbang
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: 
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Giorgenes Gelatti
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-15 00:00:00 +01:00
+date: 2011-07-16 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -59,15 +59,19 @@ files:
 - src/post-extract.sh
 - src/bootstrap.sh
 - bin/bigbang
-- README
+- README.rdoc
 - lib/bigbang.rb
+- lib/bigbang/explode.rb
 - lib/bigbang/instance.rb
 - lib/bigbang/provider.rb
 - lib/bigbang/dsl.rb
+- lib/bigbang/run.rb
 - lib/bigbang/universe.rb
+- lib/bigbang/test.rb
 - lib/bigbang/ec2-git-bootstrap.rb
+- lib/bigbang/kill.rb
 - lib/bigbang/config.rb
-- lib/bigbang/cluster.rb
+- lib/bigbang/cluster_run.rb
 has_rdoc: true
 homepage: http://github.com/giorgenes/bigbang/
 licenses: []

data/README

@@ -1,19 +0,0 @@
-
-
-# creates the base images
-bigbang base
-
-# run the instances
-bigbang explode <universe-info.rb>
-
-# list universes
-bigbang list
-
-# kill a universe
-bigbang kill <universe-name>
-
-# resize clusters
-bigbang resize
-
-# test configuration
-bigbang test

data/lib/bigbang/cluster.rb

@@ -1,10 +0,0 @@
-require 'bigbang/instance'
-
-module BigBang
-	class Cluster < Instance
-		def initialize(name)
-			super(name)
-		end
-		attr_accessor :size
-	end
-end