judo 0.0.9 → 0.1.0

data/lib/judo/setup.rb

@@ -0,0 +1,114 @@
+module Judo
+  class Setup
+    def default_config
+        <<DEFAULT
+{
+  "key_name":"#{@keypair}",
+  "instance_size":"m1.small",
+  "ami32":"ami-bb709dd2", // public ubuntu 9.10 ami - 32 bit
+  "ami64":"ami-55739e3c", // public ubuntu 9.10 ami - 64 bit
+  "user":"ubuntu",
+  "security_group":"judo",
+  "availability_zone":"us-east-1d"
+}
+DEFAULT
+    end
+
+    def getenv(key)
+      printf "Looking in your environment for #{key}..."
+      printf "found!" if ENV[key]
+      printf "\n"
+      ENV[key]
+    end
+
+    def request(query, default = "")
+      printf "#{query} ['#{default}']: "
+      input = STDIN.readline.strip
+      input.empty? and default or input 
+    end
+
+    def check_setup
+      abort "you are already inside a judo repository" if Judo::Config.find_judo_dir(Dir.pwd)
+      abort "./.git not found - judo configurations must be kept in a git repo.  type 'git init' to setup the git repo." unless File.exists? "./.git"
+    end
+
+    def init
+      check_setup
+      @aws_access_id  ||= getenv('AWS_ACCESS_KEY_ID')
+      @aws_access_id  ||= getenv('AMAZON_ACCESS_KEY_ID')
+      @aws_secret_key ||= getenv('AWS_SECRET_ACCESS_KEY')
+      @aws_secret_key ||= getenv('AMAZON_SECRET_ACCESS_KEY')
+      @s3_bucket      ||= getenv('JUDO_S3_BUCKET')
+      @s3_bucket      ||= "judo_#{rand(2**64).to_s(36)}"
+      begin
+        @aws_access_id  = request("Please enter your AWS access key",  @aws_access_id)
+        @aws_secret_key = request("Please enter your AWS secret key" , @aws_secret_key)
+        @s3_bucket      = request("Please enter an S3 bucket to use",  @s3_bucket)
+
+        setup_default_server_group
+        setup_default_security_group
+        setup_bucket
+        setup_db
+        setup_judo_config
+
+      rescue *[Interrupt, EOFError]
+        puts "\nGoodbye!"
+        exit(0)
+      rescue Object => e
+        puts "There was an error: #{e.class}:#{e.message}"
+        puts "Try again or hit CTRL-C"
+        retry
+      end
+    end
+
+    def setup_db
+      puts "Trying to connect to SimpleDB with #{@aws_access_id}"
+      sdb.create_domain("judo_servers")
+      sdb.create_domain("judo_config")
+      olddb = sdb.get_attributes("judo_config", "judo")[:attributes]["dbversion"]
+      abort "There is an existing judo database of a newer version - upgrade judo and try again" if olddb and olddb.first.to_i > Judo::Config.db_version
+      sdb.put_attributes("judo_config", "judo", { "dbversion" => Judo::Config.db_version }, :replace)
+    end
+
+    def setup_default_security_group
+      begin
+        ec2.create_security_group('judo', 'Judo')
+        ec2.authorize_security_group_IP_ingress("judo", 22, 22,'tcp','0.0.0.0/0')
+      rescue Aws::AwsError => e
+        raise unless e.message =~ /InvalidGroup.Duplicate/
+      end
+    end
+
+    def setup_bucket
+      puts "setting up an s3 bucket"
+      Aws::S3.new(@aws_access_id, @aws_secret_key, :logger => Logger.new(nil)).bucket(@s3_bucket, true)
+    end
+
+    def setup_default_server_group
+      puts "Setting up default group and keypair"
+      system "mkdir -p default/keypairs"
+
+      @keypair = "judo#{ec2.describe_key_pairs.map { |k| k[:aws_key_name] }.map { |k| k =~ /^judo(\d*)/; $1.to_i }.sort.last.to_i + 1}"
+      material = ec2.create_key_pair(@keypair)[:aws_material]
+
+      File.open("default/keypairs/#{@keypair}.pem", 'w') { |f| f.write material }
+      File.chmod 0600, "default/keypairs/#{@keypair}.pem"
+      File.open("default/config.json","w") { |f| f.write default_config }
+    end
+
+    def setup_judo_config
+      puts "setting up an .judo/config.yml"
+      system "mkdir .judo"
+      File.open(".judo/config.yml","w") { |f| f.write({ "access_id" => @aws_access_id, "access_secret" => @aws_secret_key, "s3_bucket" => @s3_bucket }.to_yaml) }
+    end
+
+    def ec2
+      @ec2 ||= Judo::Config.get_ec2(@aws_access_id, @aws_secret_key)
+    end
+
+    def sdb
+      @sdb ||= Judo::Config.get_sdb(@aws_access_id, @aws_secret_key)
+    end
+
+  end
+end

data/spec/base.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../lib/all'
+require File.dirname(__FILE__) + '/../lib/judo'
 
 require 'bacon'
 require 'mocha/standalone'

data/spec/base_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/base'
+
+describe Judo::Base do
+	before do
+	end
+	
+	it "xxx" do
+	end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 9
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors: 
 - Orion Henry
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-23 00:00:00 -07:00
+date: 2010-04-08 00:00:00 -04:00
 default_executable: judo
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -27,28 +27,14 @@ dependencies:
         segments: 
         - 2
         - 3
-        - 1
-        version: 2.3.1
+        - 5
+        version: 2.3.5
   type: :runtime
   version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: thor
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 13
-        - 4
-        version: 0.13.4
-  type: :runtime
-  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: json
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
@@ -56,7 +42,7 @@ dependencies:
         - 0
         version: "0"
   type: :runtime
-  version_requirements: *id003
+  version_requirements: *id002
 description: The gentle way to manage and control ec2 instances
 email: orion@heroku.com
 executables: 
@@ -70,12 +56,15 @@ files:
 - Rakefile
 - VERSION
 - bin/judo
-- lib/all.rb
-- lib/config.rb
-- lib/group.rb
-- lib/server.rb
-- lib/setup.rb
+- lib/judo.rb
+- lib/judo/base.rb
+- lib/judo/commandline_helpers.rb
+- lib/judo/config.rb
+- lib/judo/group.rb
+- lib/judo/server.rb
+- lib/judo/setup.rb
 - spec/base.rb
+- spec/base_spec.rb
 - spec/server_spec.rb
 has_rdoc: true
 homepage: http://github.com/orionz/judo
@@ -109,4 +98,5 @@ specification_version: 3
 summary: The gentle way to manage and control ec2 instances
 test_files: 
 - spec/base.rb
+- spec/base_spec.rb
 - spec/server_spec.rb

data/lib/all.rb

@@ -1,12 +0,0 @@
-require 'yaml'
-require 'socket'
-require 'fileutils'
-
-require 'rubygems'
-require 'right_aws'
-require 'json'
-
-require File.dirname(__FILE__) + '/config'
-require File.dirname(__FILE__) + '/group'
-require File.dirname(__FILE__) + '/server'
-require File.dirname(__FILE__) + '/setup'

data/lib/config.rb

@@ -1,105 +0,0 @@
-module Judo
-	module Config
-		extend self
-
-		def method_missing?(method)
-		end
-
-		def db_version
-			1
-		end
-
-		def get_db_version
-      version = @sdb.get_attributes("judo_config", "judo")[:attributes]["dbversion"]
-			version and version.first.to_i or db_version
-		end
-
-		def check_version
-			abort "judo db is newer than the current gem - upgrade judo and try again" if get_db_version > db_version
-		end
-
-		def repo_dir
-			judo_config["repo"] || File.dirname(judo_dir)
-		end
-
-		def access_id
-			judo_config["access_id"]
-		end
-	
-		def access_secret
-			judo_config["access_secret"]
-		end
-		
-		def get_ec2(aws_id, aws_key)
-			Aws::Ec2.new(aws_id, aws_key, :logger => Logger.new(nil))
-		end
-
-		def ec2
-			@ec2 ||= get_ec2(access_id, access_secret)
-		end
-
-#		def create_security_group
-#			## EC2 create_security_group
-#			ec2.create_security_group('judo', 'Judo')
-#			## EC2 authorize_security_group
-#			ec2.authorize_security_group_IP_ingress("judo", 22, 22,'tcp','0.0.0.0/0')
-#		rescue Aws::AwsError
-#		end
-
-		def judo_config
-			@config ||= read_judo_config
-		end
-
-		def judo_config_file
-			"#{judo_dir}/config.yml"
-		end
-
-		def judo_dir
-			@judo_dir ||= find_judo_dir(Dir.pwd) || abort("fatal: Not a judo repository (or any of the parent directories): .judo\nrun commands from the judo repository or type 'judo init' to setup the current directory as a new judo repository")
-		end
-
-		def find_judo_dir(check)
-			if check == "/"
-				if File.exists?("#{ENV['HOME']}/.judo")
-					"#{ENV['HOME']}/.judo"
-				else
-					nil
-				end
-			else
-				File.exists?(check + "/.judo") ? check + "/.judo" : find_judo_dir(File.dirname(check))
-			end
-		end
-
-		def read_judo_config
-			YAML.load File.read(judo_config_file)
-		rescue Errno::ENOENT
-			{}
-		end
-
-		def get_sdb(aws_id, aws_key)
-			Aws::SdbInterface.new(aws_id, aws_key, :logger => Logger.new(nil))
-		end
-
-		def sdb
-			@sdb ||= get_sdb(access_id, access_secret)
-#			@version_ok ||= check_version
-			@sdb
-		end
-
-		def s3
-			@s3 ||= Aws::S3.new(access_id, access_secret, :logger => Logger.new(nil))
-		end
-
-		def s3_bucket
-			@s3_bucket ||= s3.bucket(judo_config["s3_bucket"])
-		end
-
-		def s3_url(k)
-			Aws::S3Generator::Key.new(s3_bucket, k).get
-		end
-
-		def s3_put(k, file)
-			s3_bucket.put(k, file)
-		end
-	end
-end

data/lib/group.rb

@@ -1,185 +0,0 @@
-module Judo
-	class Group
-		attr_accessor :name, :dir
-
-		def self.dirs
-			Dir["#{Judo::Config.repo_dir}/*/config.json"].map { |d| File.dirname(d) }
-		end
-
-		def self.all
-			@@all ||= (dirs.map { |d| new(d) })
-		end
-
-		def self.find(name)
-			all.detect { |d| d.name == name }
-		end
-
-		def self.[](name)
-			find(name)
-		end
-
-		def self.current
-			all.detect { |d| Dir.pwd == d.dir or Dir.pwd =~ /^#{d.dir}\// }
-		end
-
-		def initialize(dir, name = File.basename(dir))
-			@name = name
-			@dir = dir
-		end
-
-		def create_server(server_name)
-			abort("Server needs a name") if server_name.nil?
-#			abort("Already a server named #{server_name}") if Judo::Server.find_by_name(attrs[:name])  ## FIXME
-#			Judo::Config.read_config(attrs[:group]) ## make sure the config is valid  ## FIXME
-
-			server = Judo::Server.new server_name, self
-			server.task("Creating server #{server_name}") do
-				server.update "name" => server_name, "group" => name, "virgin" => true, "secret" => rand(2 ** 128).to_s(36)
-				Judo::Config.sdb.put_attributes("judo_config", "groups", name => server_name)
-			end
-			server
-		end
-		
-		def config
-			@config ||= self.class.load_all(self)
-		end
-	
-		def server_names
-			Judo::Config.sdb.get_attributes("judo_config", "groups")[:attributes][@name] || []
-		end
-
-		def servers
-			server_names.map { |n| Judo::Server.new(n, self) }
-		end
-
-		def version
-			@version ||= (Judo::Config.sdb.get_attributes("judo_config", "group_versions")[:attributes][@name] || ["0"]).first.to_i
-		end
-
-		def set_version(new_version)
-			@version = new_version
-			Judo::Config.sdb.put_attributes("judo_config", "group_versions", { name => new_version }, :replace)
-		end
-
-		def compile
-			tmpdir = "/tmp/kuzushi/#{name}"
-			set_version(version + 1)
-			puts "Compiling version #{version}"
-			FileUtils.rm_rf(tmpdir)
-			FileUtils.mkdir_p(tmpdir)
-			Dir.chdir(tmpdir) do |d|
-				attachments.each do |to,from|
-					FileUtils.mkdir_p(File.dirname(to))
-					if from =~ /^http:\/\//
-						puts "curl '#{from}'"
-						system "curl '#{from}' > #{to}"
-						puts "#{to} is #{File.stat(to).size} bytes"
-					else
-						FileUtils.cp(from,to)
-					end
-				end
-				File.open("config.json", "w") { |f| f.write(config.to_json) }
-				Dir.chdir("..") do
-					system "tar czvf #{tar_file} #{name}"
-					puts "Uploading to s3..."
-					Judo::Config.s3_put(tar_file, File.new(tar_file))
-				end
-			end
-		end
-
-		def tar_file
-			"#{name}.#{version}.tar.gz"  ## FIXME needs to incorprate #{config version} "#{name}.#{version}.tar.gz"
-		end
-
-		def s3_url 
-			@url = Judo::Config.s3_url(tar_file)
-		end
-
-		def cp_file
-			FileUtil.mkdir_p(tmpdir)
-		end
-
-		def parent
-			self.class.find(config["import"])
-		end
-
-		def extract_file(type, name, files)
-			path = "#{dir}/#{type}s/#{name}"
-			found = Dir[path]
-			if not found.empty?
-				found.each { |f| files["#{type}s/#{File.basename(f)}"] = f }
-			elsif parent
-				parent.extract_file(type, name, files)
-			else
-				raise "Cannot find file #{name} of type #{type}"
-			end
-		end
-
-		def extract(config, files)
-			config.each do |key,value|
-				[value].flatten.each do |v|   ### cover "packages" : ["a","b"], "packages" : "a", "packages":[{ "file" : "foo.pkg"}]
-					if v.is_a? Hash
-						extract(v, files) 
-					else
-						case key
-						when *[ "init", "before", "after" ]
-							extract_file(:script, v, files) unless v =~ /^#!/
-						when "package"
-							files["packages/#{v}_i386.deb"]  = "#{config["source"]}#{v}_i386.deb"
-							files["packages/#{v}_amd64.deb"] = "#{config["source"]}#{v}_amd64.deb"
-						when "local_packages"
-							extract_file(:package, "#{v}_i386.deb", files)
-							extract_file(:package, "#{v}_amd64.deb", files)
-						when "template"
-							extract_file(:template, v, files)
-						when "source"
-							extract_file(:file, v, files) unless config["template"] or config["package"]
-						when "file"
-							extract_file(:file, File.basename(v), files) unless config["template"] or config["source"]
-						end
-					end
-				end
-			end
-			files
-		end
-
-		def keypair_file
-			extract_file(:keypair, config["key_name"] + ".pem" , {}).first
-		end
-
-		def attachments
-			extract(config, {})
-		end
-
-		def self.load_all(group, configs = [])
-			return configs.reverse.inject({}) { |sum,conf| sum.merge(conf) } unless group
-			raw_config = group.read_config
-			load_all(find(raw_config["import"]), configs << raw_config)
-		end
-
-		def config_file
-			"#{dir}/config.json"
-		end
-
-		def read_config
-			begin
-				JSON.parse(File.read(config_file))
-			rescue Errno::ENOENT
-				{}
-			end
-		end
-
-		def delete_server(server)
-			sdb.delete_attributes("judo_config", "groups", name => server.name)
-		end
-
-		def to_s
-			name
-		end
-
-		def sdb
-			Judo::Config.sdb
-		end
-	end
-end
-