sumo 0.1.0

data/README.rdoc

@@ -0,0 +1,59 @@
+= Tired of wrestling with server provisioning?  Sumo!
+
+Want to fire up a one-off EC2 instance, pronto?  ec2-run-instances got you down?  Try Sumo.
+
+    $ sumo launch
+    ---> Launching instance...    i-4f809c26 (1.5s)
+    ---> Acquiring hostname...    ec2-67-202-17-178.compute-1.amazonaws.com (26.7s)
+
+    Logging you in via ssh.  Type 'exit' or Ctrl-D to return to your local system.
+    ------------------------------------------------------------------------------
+    Linux domU-12-31-39-04-31-37 2.6.21.7-2.fc8xen #1 SMP Fri Feb 15 12:39:36 EST 2008 i686
+    ...
+    root@domU-12-31-39-04-31-37:~# 
+
+Later...
+
+    $ sumo terminate
+    ec2-67-202-17-178.compute-1.amazonaws.com scheduled for termination
+
+You can also manage multiple instances via "sumo list" and specifying hostname or instance id as arguments to the launch, ssh, and terminate commands.
+
+== Setup
+
+Dependencies:
+
+    $ sudo gem install amazon-ec2 thor
+
+Then create ~/.sumo/config.yml containing:
+
+    ---
+    access_id: <your amazon access key id>
+    access_secret: <your amazon secret access key>
+    ami: ami-ed46a784
+
+If you run any production machines from your EC2 account, I recommend setting up a separate account for use with Sumo.  It does not prompt for confirmation when terminating an instance or differentiate between instances started by it vs. instances started by other tools.
+
+== Features
+
+Launch, ssh to, and terminate instances.
+
+Sumo creates its own keypair named sumo, which is stored in ~/.ssh/keypair.pem.  Amazon doesn't let you upload your own ssh public key, which is lame, so this is the best option for making the launch-and-connect process a single step.
+
+== Anti-features
+
+Sumo is not a cloud management tool, a monitor tool, or anything more than a way to get an instance up right quick.  If you're looking for a way to manage a cluster of production instances, try one of these fine tools.
+
+* Pool Party
+* RightScale
+* Engine Yard Cloud
+* Cloudkick
+
+== Meta
+
+Created by Adam Wiggins
+
+Released under the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+http://github.com/adamwiggins/sumo
+

data/Rakefile

@@ -0,0 +1,16 @@
+require 'jeweler'
+
+Jeweler::Tasks.new do |s|
+	s.name = "sumo"
+	s.description = "A no-hassle way to launch one-off EC2 instances from the command line"
+	s.summary = s.description
+	s.author = "Adam Wiggins"
+	s.email = "adam@heroku.com"
+	s.homepage = "http://github.com/adamwiggins/sumo"
+	s.rubyforge_project = "sumo"
+	s.files = FileList["[A-Z]*", "{bin,lib,spec}/**/*"]
+	s.executables = %w(sumo)
+end
+
+Jeweler::RubyforgeTasks.new
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/sumo

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/sumo'
+
+require 'thor'
+
+class CLI < Thor
+	desc "launch [<role>]", "launch an instance as role, or omit to ssh to vanilla instance"
+	def launch(role=nil)
+		id = task("Launch instance") { sumo.launch }
+		host = task("Acquire hostname") { sumo.wait_for_hostname(id) }
+		task("Wait for ssh") { sumo.wait_for_ssh(host) }
+
+		if role
+			task("Bootstrap chef") { sumo.bootstrap_chef(host) }
+			role.split(',').each do |role|
+				task("Setup #{role}") { sumo.setup_role(host, role) }
+			end
+
+			resources = sumo.resources(host)
+			unless resources.empty?
+				task("Opening firewall") do
+					ports = resources.map { |r| r.match(/:(\d+)\//)[1] }
+					ports.each { |port| sumo.open_firewall(port) }
+					"ports " + ports.join(", ")
+				end
+			end
+
+			puts
+			display_resources(host)
+		else
+			puts "\nLogging you in via ssh.  Type 'exit' or Ctrl-D to return to your local system."
+			puts '-' * 78
+			connect_ssh(host)
+		end
+	end
+
+	desc "ssh [<instance_id or hostname>]", "ssh to a specified instance or first available"
+	def ssh(id=nil)
+		inst = sumo.find(id) || sumo.running.first || abort("No running instances")
+		hostname = inst[:hostname] || wait_for_hostname(inst[:instance_id])
+		connect_ssh hostname
+	end
+
+	desc "resources [<instance_id or hostname>]", "show resources exported by an instance"
+	def resources(id=nil)
+		inst = sumo.find(id) || sumo.running.first || abort("No running instances")
+		hostname = inst[:hostname] || wait_for_hostname(inst[:instance_id])
+		display_resources(inst[:hostname])
+	end
+
+	desc "bootstrap", "bootstrap chef and cookbooks"
+	def bootstrap(id=nil)
+		inst = sumo.find(id) || sumo.running.first || abort("No running instances")
+		task "Bootstrap chef" do
+			sumo.bootstrap_chef(inst[:hostname])
+		end
+	end
+
+	desc "role", "setup instance as a role"
+	def role(role, id=nil)
+		inst = sumo.find(id) || sumo.running.first || abort("No running instances")
+		task "Setup #{role}" do
+			sumo.setup_role(inst[:hostname], role)
+		end
+	end
+
+	desc "list", "list running instances"
+	def list
+		sumo.list.each do |inst|
+			printf "%-50s %-12s %s\n", inst[:hostname], inst[:instance_id], inst[:status]
+		end
+	end
+
+	desc "terminate [<instance_id or hostname>]", "terminate specified instance or first available"
+	def terminate(id=nil)
+		inst = sumo.find(id) || (sumo.running | sumo.pending).first || abort("No running or pending instances")
+
+		sumo.terminate(inst[:instance_id])
+		puts "#{inst[:hostname] || inst[:instance_id]} scheduled for termination"
+	end
+
+	desc "terminate_all", "terminate all instances"
+	def terminate_all
+		instances = (sumo.running | sumo.pending)
+		abort("No running or pending instances") if instances.empty?
+		instances.each do |inst|
+			sumo.terminate(inst[:instance_id])
+			puts "#{inst[:hostname] || inst[:instance_id]} scheduled for termination"
+		end
+	end
+
+	no_tasks do
+		def sumo
+			@sumo ||= Sumo.new
+		end
+
+		def task(msg, &block)
+			printf "---> %-24s ", "#{msg}..."
+			start = Time.now
+			result = block.call || 'done'
+			finish = Time.now
+			time = sprintf("%0.1f", finish - start)
+			puts "#{result} (#{time}s)"
+			result
+		end
+
+		def connect_ssh(hostname)
+			sumo.wait_for_ssh(hostname)
+
+			system "ssh -i #{sumo.keypair_file} root@#{hostname}"
+			if $?.success?
+				puts "\nType 'sumo terminate' if you're done with this instance."
+			end
+		end
+
+		def display_resources(host)
+			resources = sumo.resources(host)
+			unless resources.empty?
+				puts "Your instance is exporting the following resources:"
+				resources.each do |resource|
+					puts "  #{resource}"
+				end
+			end
+		end
+	end
+end
+
+CLI.start

data/lib/sumo.rb

@@ -0,0 +1,192 @@
+require 'ec2'
+require 'yaml'
+require 'socket'
+
+class Sumo
+	def launch
+		ami = config['ami']
+		raise "No AMI selected" unless ami
+
+		create_keypair unless File.exists? keypair_file
+
+		create_security_group
+		open_firewall(22)
+
+		result = ec2.run_instances(
+			:image_id => ami,
+			:instance_type => config['instance_size'] || 'm1.small',
+			:key_name => 'sumo',
+			:group_id => [ 'sumo' ]
+		)
+		result.instancesSet.item[0].instanceId
+	end
+
+	def list
+		@list ||= fetch_list
+	end
+
+	def fetch_list
+		result = ec2.describe_instances
+		return [] unless result.reservationSet
+
+		instances = []
+		result.reservationSet.item.each do |r|
+			r.instancesSet.item.each do |item|
+				instances << {
+					:instance_id => item.instanceId,
+					:status => item.instanceState.name,
+					:hostname => item.dnsName
+				}
+			end
+		end
+		instances
+	end
+
+	def find(id_or_hostname)
+		return unless id_or_hostname
+		id_or_hostname = id_or_hostname.strip.downcase
+		list.detect do |inst|
+			inst[:hostname] == id_or_hostname or
+			inst[:instance_id] == id_or_hostname or
+			inst[:instance_id].gsub(/^i-/, '') == id_or_hostname
+		end
+	end
+
+	def running
+		list_by_status('running')
+	end
+
+	def pending
+		list_by_status('pending')
+	end
+
+	def list_by_status(status)
+		list.select { |i| i[:status] == status }
+	end
+
+	def instance_info(instance_id)
+		fetch_list.detect do |inst|
+			inst[:instance_id] == instance_id
+		end
+	end
+
+	def wait_for_hostname(instance_id)
+		raise ArgumentError unless instance_id and instance_id.match(/^i-/)
+		loop do
+			if inst = instance_info(instance_id)
+				if hostname = inst[:hostname]
+					return hostname
+				end
+			end
+			sleep 1
+		end
+	end
+
+	def wait_for_ssh(hostname)
+		raise ArgumentError unless hostname
+		loop do
+			begin
+				Timeout::timeout(4) do
+					TCPSocket.new(hostname, 22)
+					return
+				end
+			rescue SocketError, Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+			end
+		end
+	end
+
+	def bootstrap_chef(hostname)
+		commands = [
+			'apt-get update',
+			'apt-get autoremove -y',
+			'apt-get install -y ruby ruby-dev rubygems git-core',
+			'gem sources -a http://gems.opscode.com',
+			'gem install chef ohai --no-rdoc --no-ri',
+			"git clone #{config['cookbooks_url']}",
+		]
+		ssh(hostname, commands)
+	end
+
+	def setup_role(hostname, role)
+		commands = [
+			"cd chef-cookbooks",
+			"/var/lib/gems/1.8/bin/chef-solo -c config.json -j roles/#{role}.json"
+		]
+		ssh(hostname, commands)
+	end
+
+	def ssh(hostname, cmds)
+		IO.popen("ssh -i #{keypair_file} root@#{hostname} > ~/.sumo/ssh.log 2>&1", "w") do |pipe|
+			pipe.puts cmds.join(' && ')
+		end
+		unless $?.success?
+			abort "failed\nCheck ~/.sumo/ssh.log for the output"
+		end
+	end
+
+	def resources(hostname)
+		@resources ||= {}
+		@resources[hostname] ||= fetch_resources(hostname)
+	end
+
+	def fetch_resources(hostname)
+		cmd = "ssh -i #{keypair_file} root@#{hostname} 'cat /root/resources' 2>&1"
+		out = IO.popen(cmd, 'r') { |pipe| pipe.read }
+		abort "failed to read resources, output:\n#{out}" unless $?.success?
+		parse_resources(out, hostname)
+	end
+
+	def parse_resources(raw, hostname)
+		raw.split("\n").map do |line|
+			line.gsub(/localhost/, hostname)
+		end
+	end
+
+	def terminate(instance_id)
+		ec2.terminate_instances(:instance_id => [ instance_id ])
+	end
+
+	def config
+		@config ||= read_config
+	end
+
+	def sumo_dir
+		"#{ENV['HOME']}/.sumo"
+	end
+
+	def read_config
+		YAML.load File.read("#{sumo_dir}/config.yml")
+	rescue Errno::ENOENT
+		raise "Sumo is not configured, please fill in ~/.sumo/config.yml"
+	end
+
+	def keypair_file
+		"#{sumo_dir}/keypair.pem"
+	end
+
+	def create_keypair
+		keypair = ec2.create_keypair(:key_name => "sumo").keyMaterial
+		File.open(keypair_file, 'w') { |f| f.write keypair }
+		File.chmod 0600, keypair_file
+	end
+
+	def create_security_group
+		ec2.create_security_group(:group_name => 'sumo', :group_description => 'Sumo')
+	rescue EC2::InvalidGroupDuplicate
+	end
+
+	def open_firewall(port)
+		ec2.authorize_security_group_ingress(
+			:group_name => 'sumo',
+			:ip_protocol => 'tcp',
+			:from_port => port,
+			:to_port => port,
+			:cidr_ip => '0.0.0.0/0'
+		)
+	rescue EC2::InvalidPermissionDuplicate
+	end
+
+	def ec2
+		@ec2 ||= EC2::Base.new(:access_key_id => config['access_id'], :secret_access_key => config['access_secret'])
+	end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: sumo
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Adam Wiggins
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-19 00:00:00 -07:00
+default_executable: sumo
+dependencies: []
+
+description: A no-hassle way to launch one-off EC2 instances from the command line
+email: adam@heroku.com
+executables: 
+- sumo
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/sumo
+- lib/sumo.rb
+has_rdoc: true
+homepage: http://github.com/adamwiggins/sumo
+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: sumo
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: A no-hassle way to launch one-off EC2 instances from the command line
+test_files: []
+