judo 0.2.1 → 0.2.3

data/README.markdown

@@ -5,6 +5,14 @@ to get going and powerful.
 
 ## CONCEPTS
 
+Servers and Groups.  Servers are identified by a naked string.  Groups always
+have a colon prefix.
+
+    $ judo restart my_server_1              ## this restarts my_server_1
+    $ judo restart my_server_1 other_server ## this restarts my_server_1 and other_server
+    $ judo restart :default                 ## this restarts all servers in the :default group
+    $ judo restart sammy :default :db       ## this restarts all servers in the :default group, the :db group, and a server named sammy
+
 Config Repo: Judo keeps it configuration for each server group in a git repo.
 
 State Database: Judo keeps cloud state and information on specific servers in SimpleDB.
@@ -22,36 +30,38 @@ Setting up a new judo repo named "my_cloud" would look like this:
 
     $ mkdir my_cloud
     $ cd my_cloud
-    $ git init
-    $ judo init
+    $ judo setup --accessid AWS_ACCESS_ID --secret AWS_KEY --bucket BUCKET
+
+Note: you can use the AWS_SECRET_ACCESS_KEY, AWS_ACCESS_KEY_ID and JUDO_BUCKET
+enviornment variables instead of the command line switches.
 
-The 'judo init' command will make a .judo folder to store your EC2 keys and S3
+The 'judo setup' command will make a .judo folder to store your EC2 keys and S3
 bucket.  It will also make a folder named "default" to hold the default server
 config.
 
 To view all of the groups and servers running in those group you can type:
 
-    $ judo list
-      SERVER GROUPS
-    default            0 servers
+    $ judo groups
 
-To launch a default server you need to cd into the default folder:
+To launch a default server you create it
 
-    $ cd default
-    $ judo create my_server_1
+    $ judo create my_server_1:default
     ---> Creating server my_server_1...     done (0.6s)
     $ judo list
-      SERVER IN GROUP my_server_1
-    my_server_1                       m1.small    ami-bb709dd2             0 volumes
+      SERVERS
+    --------------------------------------------------------------------------------
+      my_server_1            default      v12             m1.small               ebs:0 
     $ judo start my_server_1
-    No config has been committed yet, type 'judo commit'
+    ---> Starting server my_server_1... done (2.3s)
+    $ judo list
+      SERVERS
+    --------------------------------------------------------------------------------
+    my_server_1              default      v1  i-6fdf8d09  m1.small    running    ebs:0 
 
-The server has now been created but cannot be launched because the config has
-not been committed.  Committing the config loads the config.json and all of the
-scripts and packages it needs to run into your S3 bucket.  The config probably
-looks something like this:
+You can examine a groups config by looking in the group folder in the repo.  The 
+default group will look something like this.
 
-    $ cat config.json
+    $ cat default/config.json
     {
         "key_name":"judo14",
         "instance_size":"m1.small",
@@ -62,44 +72,28 @@ looks something like this:
         "availability_zone":"us-east-1d"
     }
 
-The default config uses the public ubuntu 9.10 ami's.  It runs in the judo
-security group and a judo key pair (which were made during the init process).
-The user parameter is the user the 'judo ssh' command attempts to ssh in using
-the keypair.  Other debian based distros can be used assuming they have current
-enough installations of ruby (1.8.7) and rubygems (1.3.5).
+Any changes you make to these files does not stick until you've committed them.
+To commit a group do the following.
 
-    $ judo commit
-    Compiling version 1
-    a default
-    a default/config.json
-    Uploading to s3...
-    $ judo start my_server_1
-    ---> Starting server my_server_1... done (2.3s)
-    ---> Acquire hostname...      ec2-1-2-3-4.compute-1.amazonaws.com (49.8s)
-    ---> Wait for ssh...          done (9.8s)
-    $ judo list
-      SERVER IN GROUP default
-    my_server_1       v1   i-80000000  m1.small    ami-bb709dd2  running    0 volumes  ec2-1-2-3-4.compute-1.amazonaws.com
+    $ judo commit :default
+    Compiling version 2... done (1.2s)
 
 We can now see that 'my_server_1' is running and running with version 1 of the
 config.  We can create and start a server in one step with the launch command.
 
-    $ judo launch my_server_2
+    $ judo launch my_server_2:default
     ---> Creating server my_server_2... done (0.6s)
     ---> Starting server my_server_2... done (1.6s)
-    ---> Acquire hostname...      ec2-1-2-3-5.compute-1.amazonaws.com (31.1s)
-    ---> Wait for ssh...          done (6.1s)
 
 This will create and start two servers.  One named 'my_server_1' and one named
 'my_server_2'.  You can ssh into 'my_server_1' you can type:
 
     $ judo ssh my_server_1
 
-You can stop all the servers with:
+You can stop all the servers in the :default group with:
 
-    $ judo stop
+    $ judo stop :default
 
-Note that since no name was specified it will stop all servers in the group.
 You could also have typed:
 
   $ judo stop my_server_1 my_server_2
@@ -115,7 +109,7 @@ operation is run on all servers.  For instance:
 
 This will restart only the servers named 'primary_db' and 'backup_db'.  Where as
 
-    $ judo restart
+    $ judo restart :db
 
 will restart all servers in the group.
 

data/Rakefile

@@ -10,7 +10,7 @@ Jeweler::Tasks.new do |s|
 	s.rubyforge_project = "judo"
 	s.files = FileList["[A-Z]*", "{bin,lib,spec}/**/*"]
 	s.executables = %w(judo)
-	s.add_dependency "aws",  [">= 2.3.5"]
+	s.add_dependency "aws",  [">= 2.3.8"]
 	s.add_dependency "json"
 end
 

data/TODO

@@ -1,23 +1,30 @@
 ### NEEDED for new gem launch
 
-### [ ] snapshot complete in do_snapshots()
+### [ ] ubuntu 10.04
+### [ ] allocate elastic_ip first
+### [ ] snapshot percent complete in do_snapshots()
 ### [ ] judo swap (x) (y) -> swaps elastic IP's and name
 ### [ ] snapshots/init/virgin
+### [ ] bind kuzushi gem version version
+### [ ] should be able to do ALL actions except commit without the repo!
+###     [ ] ssh - put pem into s3
+### [ ] store s3 bucket in config
+### [ ] store things in s3 by sha1sum
+### [ ] ebs backed root disk
+### [ ] clone from ebs snapshot on start
+### [ ] implement start/stop
+
+### [ ] implement auto security_group creation and setup (6 hrs)
 
 ### [ ] judo does not work with ruby 1.8.6 - :(
 ### [ ] saw a timeout on volume allocation - make sure we build in re-tries - need to allocate the server all together as much as possible
-### [ ] there is a feature to allow for using that block_mapping feature - faster startup
 
 ### [ ] two phase delete (1 hr)
 ### [-] refactor availability_zone (2 hrs)
 ###     [ ] pick availability zone from config "X":"Y" or  "X":["Y","Z"]
 ###     [ ] assign to state on creation ( could delay till volume creation )
-### [ ] implement auto security_group creation and setup (6 hrs)
-### [ ] bind kuzushi gem version version
 
-### [ ] should be able to do ALL actions except commit without the repo!
 ### [ ] store git commit hash with commit to block a judo commit if there is newer material stored
-### [ ] remove the tarball - store files a sha hashes in the bucket - makes for faster commits if the files have not changed
 
 ### [ ] use a logger service (1 hr)
 ### [ ] write specs (5 hr)
@@ -28,13 +35,9 @@
 
 ### Do Later
 ### [ ] use amazon's new conditional write tools so we never have problems from concurrent updates
-### [ ] is thor really what we want to use here?
-### [ ] need to be able to pin a config to a version of kuzushi - gem updates can/will break a lot of things
 ### [ ] I want a "judo monitor" command that will make start servers if they go down, and poke a listed port to make sure a service is listening, would be cool if it also detects wrong ami, wrong secuirity group, missing/extra volumes, missing/extra elastic_ip - might not want to force a reboot quite yet in these cases
-### [ ] Implement "judo snapshot [NAME]" to take a snapshot of the ebs's blocks
 ### [ ] ruby 1.9.1 support
 ### [ ] find a good way to set the hostname or prompt to :name
-### [ ] remove fog/s3 dependancy
 ### [ ] enforce template files end in .erb to make room for other possible templates as defined by the extensions
 ### [ ] zerigo integration for automatic DNS setup
 ### [ ] How cool would it be if this was all reimplemented in eventmachine and could start lots of boxes in parallel?  Would need to evented AWS api calls... Never seen a library to do that - would have to write our own... "Fog Machine?"

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.2.3

data/bin/judo

@@ -93,10 +93,11 @@ end
 optparse.parse!
 
 judo = Judo::Base.new(defaults.merge(options))
-judo.check_version
+judo.check_version if action != "setup"
 
 begin
   case action
+    when "setup" then judo.setup
     when "ips" then do_ips(judo)
     when "volumes" then do_volumes(judo)
     when "list" then do_list(judo, ARGV)

data/lib/judo/base.rb

@@ -60,6 +60,10 @@ module Judo
       end
     end
 
+    def self.domain
+      "judo_config"
+    end
+
     def self.default_options(pwd, dir = find_judo_dir(pwd))
       config = YAML.load File.read("#{dir}/config.yml")
       repo_dir = config["repo"] || File.dirname(dir)
@@ -207,7 +211,7 @@ module Judo
     end
 
     def bucket
-      @bucket ||= s3.bucket(bucket_name)
+      @bucket ||= s3.bucket(bucket_name, true)
     end
 
     def s3_url(k)
@@ -247,7 +251,12 @@ module Judo
     def upgrade_db
       case get_db_version
         when 0
-          raise JudoError, "Your db appears to be unititialized.  You will need to do a judo init"
+          task("Upgrading Judo: Creating Snapshots SDB Domain") do
+            sdb.create_domain(Judo::Server.domain)
+            sdb.create_domain(Judo::Snapshot.domain)
+            sdb.create_domain(Judo::Snapshot.domain)
+            set_db_version(2)
+          end
         when 1
           task("Upgrading Judo: Creating Snapshots SDB Domain") do
             sdb.create_domain(Judo::Snapshot.domain)
@@ -270,5 +279,81 @@ module Judo
     def check_version
       upgrade_db if get_db_version != db_version
     end
+
+    def setup
+      ## no need to setup bucket
+
+      @repo ||= "." ## use cwd as default repo dir
+
+      setup_sdb
+      setup_security_group
+      setup_judo_config
+      setup_repo
+      get_group("default").compile
+    end
+
+    def setup_sdb
+      task("Trying to connect to SimpleDB") do
+        sdb.create_domain(Judo::Base.domain)
+      end
+    end
+
+    def setup_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_judo_config
+      if judo_dir and File.exists?("#{judo_dir}/config.yml")
+        puts "config already exists [#{judo_dir}/config.yml]"
+        return
+      end
+      raise JudoError, "You must specify a repo dir" unless repo
+      task("writing .judo/config.yml") do
+        Dir.chdir(repo) do
+          system "mkdir .judo"
+          File.open(".judo/config.yml","w") do |f| 
+            f.write({ "access_id" => @aws_access_id, "access_secret" => @aws_secret_key, "s3_bucket" => @s3_bucket }.to_yaml)
+          end
+        end
+      end
+    end
+
+    def setup_repo
+      if File.exists?("#{repo}/default")
+        puts "default group already exists [#{repo}/default]"
+        return
+      end
+      task("Setting up default group") do
+        Dir.chdir(repo) do
+          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
+      end
+    end
+
+    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
   end
 end

data/lib/judo/commandline_helpers.rb

@@ -125,7 +125,7 @@ module JudoCommandLineHelpers
     printf "%s\n", ("-" * 80)
     judo.snapshots.each do |snapshot|
       next if args and not servers.detect { |s| s == snapshot.server }
-      printf "%-15s %-25s %-15s %-10s %s\n", snapshot.name, snapshot.server_name, snapshot.group_name, snapshot.version_desc, "#{snapshot.ec2_ids.size}v"
+      printf "%-15s %-25s %-15s %-10s %s\n", snapshot.name, snapshot.server_name, snapshot.group_name, snapshot.version_desc, "ebs:#{snapshot.ec2_ids.size}"
     end
   end
 
@@ -134,7 +134,7 @@ module JudoCommandLineHelpers
     printf "  SERVERS\n"
     printf "%s\n", ("-" * 80)
     servers.sort.each do |s|
-      printf "%-32s %-12s %-7s %-11s %-11s %-10s %-3s %s\n", s.name, s.group.name, s.version_desc, s.state["instance_id"], s.size_desc, s.ec2_state, "#{s.volumes.keys.size}v", s.has_ip? ? "ip" : ""
+      printf "%-32s %-12s %-7s %-11s %-11s %-10s %-3s %s\n", s.name, s.group.name, s.version_desc, s.state["instance_id"], s.size_desc, s.ec2_state, "ebs:#{s.volumes.keys.size}", s.has_ip? ? "ip" : ""
     end
   end
 

data/lib/judo/group.rb

@@ -36,31 +36,32 @@ module Judo
 
     def compile
       tmpdir = "/tmp/kuzushi/#{name}"
-      puts "Compiling #{self} version #{version}"
-      @version = @version + 1
-      FileUtils.rm_rf(tmpdir)
-      FileUtils.mkdir_p(tmpdir)
-      new_config = build_config
-      Dir.chdir(tmpdir) do |d|
-        attachments(new_config).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)
+      @base.task("Compiling #{self} version #{version + 1}") do
+        @version = @version + 1
+        FileUtils.rm_rf(tmpdir)
+        FileUtils.mkdir_p(tmpdir)
+        new_config = build_config
+        Dir.chdir(tmpdir) do |d|
+          attachments(new_config).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(new_config.to_json) }
+          Dir.chdir("..") do
+            system "tar czf #{tar_file} #{name}"
+            # puts "Uploading to s3..."
+            @base.s3_put(tar_file, File.new(tar_file).read)
+            @base.s3_put(version_config_file, new_config.to_json)
           end
         end
-        File.open("config.json", "w") { |f| f.write(new_config.to_json) }
-        Dir.chdir("..") do
-          system "tar czvf #{tar_file} #{name}"
-          puts "Uploading to s3..."
-          @base.s3_put(tar_file, File.new(tar_file))
-          @base.s3_put(version_config_file, new_config.to_json)
-        end
+        set_version
       end
-      set_version
     end
 
     def version_config_file

data/lib/judo/server.rb

@@ -315,7 +315,7 @@ module Judo
       ## EC2 terminate_isntaces
       task("Terminating instance") { @base.ec2.terminate_instances([ instance_id ]) }
       force_detach_volumes if force
-      task("Wait for volumes to detach") { wait_for_volumes_detached } if volumes.size > 0
+      wait_for_volumes_detached if volumes.size > 0
       remove "instance_id"
     end
 
@@ -382,14 +382,18 @@ module Judo
 
     def wait_for_volumes_detached
       begin
-        Timeout::timeout(60) do
-          loop do
-            break if ec2_volumes.reject { |v| v[:aws_status] == "available" }.empty?
-            sleep 2
+        task("Wait for volumes to detach") do
+          Timeout::timeout(60) do
+            loop do
+              break if ec2_volumes.reject { |v| v[:aws_status] == "available" }.empty?
+              sleep 2
+            end
           end
         end
       rescue Timeout::Error
+        puts "failed!"
         force_detach_volumes
+        retry
       end
     end
 
@@ -463,29 +467,6 @@ module Judo
       system "ssh -i #{group.keypair_file} #{config["user"]}@#{hostname}"
     end
 
-    def self.commit
-      ## FIXME
-      Config.group_dirs.each do |group_dir|
-        group = File.basename(group_dir)
-        next if Config.group and Config.group != group
-        puts "commiting #{group}"
-        doc = Config.couchdb.get(group) rescue {}
-        config = Config.read_config(group)
-        config['_id'] = group
-        config['_rev'] = doc['_rev'] if doc.has_key?('_rev')
-        response = Config.couchdb.save_doc(config)
-        doc = Config.couchdb.get(response['id'])
-
-        # walk subdirs and save as _attachments
-        ['files', 'templates', 'packages', 'scripts'].each { |subdir|
-          Dir["#{group_dir}/#{subdir}/*"].each do |f|
-            puts "storing attachment #{f}"
-            doc.put_attachment("#{subdir}/#{File.basename(f)}", File.read(f))
-          end
-        }
-      end
-    end
-
     def ec2_instance_type
       ec2_instance[:aws_instance_type] rescue nil
     end
@@ -505,6 +486,7 @@ module Judo
 
 export DEBIAN_FRONTEND="noninteractive"
 export DEBIAN_PRIORITY="critical"
+export JUDO_ID='#{name}'
 export SECRET='#{secret}'
 apt-get update
 apt-get install ruby rubygems ruby-dev irb libopenssl-ruby libreadline-ruby -y

data/lib/judo.rb

@@ -1,9 +1,9 @@
-require 'yaml'
-require 'socket'
-require 'fileutils'
-
 require 'rubygems'
+require 'active_support'
 require 'right_aws'
+require 'socket'
+require 'fileutils'
+require 'yaml'
 require 'json'
 require 'pp'
 
@@ -13,9 +13,7 @@ class JudoError < RuntimeError ; end
 class JudoInvalid < RuntimeError ; end
 
 require File.dirname(__FILE__) + '/judo/base'
-require File.dirname(__FILE__) + '/judo/config'
 require File.dirname(__FILE__) + '/judo/group'
 require File.dirname(__FILE__) + '/judo/server'
 require File.dirname(__FILE__) + '/judo/snapshot'
-require File.dirname(__FILE__) + '/judo/setup'
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 1
-  version: 0.2.1
+  - 3
+  version: 0.2.3
 platform: ruby
 authors: 
 - Orion Henry
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-06 00:00:00 -04:00
+date: 2010-05-13 00:00:00 -04:00
 default_executable: judo
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -27,8 +27,8 @@ dependencies:
         segments: 
         - 2
         - 3
-        - 5
-        version: 2.3.5
+        - 8
+        version: 2.3.8
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -61,10 +61,8 @@ files:
 - 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
 - lib/judo/snapshot.rb
 - spec/base.rb
 - spec/base_spec.rb

data/lib/judo/config.rb

@@ -1,133 +0,0 @@
-module Judo
-  module Config
-    extend self
-
-    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 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.current
-      all.detect { |d| Dir.pwd == d.dir or Dir.pwd =~ /^#{d.dir}\// }
-    end
-
-    def default_options(pwd, dir = find_judo_dir(pwd))
-      puts "PWD: #{pwd}"
-      puts "DIR: #{dir}"
-      config = YAML.load File.read("#{dir}/config.yml")
-      repo_dir = config["repo"] || File.dirname(dir)
-      group_config = Dir["#{repo_dir}/*/config.json"].detect { |d| File.dirname(d) == pwd }
-      {
-        :judo_dir      => dir,
-        :group         => group_config ? File.basename(File.dirname(group_config)) : nil,
-        :repo          => repo_dir,
-        :bucket        => config["s3_bucket"],
-        :access_id     => config["access_id"],
-        :access_secret => config["access_secret"]
-      }.delete_if { |key,value| value.nil? }
-    rescue Object => e
-      puts e.inspect
-      {}
-    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/judo/setup.rb

@@ -1,115 +0,0 @@
-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::Server.domain)
-      sdb.create_domain(Judo::Snapshot.domain)
-      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