judo 0.3.7 → 0.4.0

data/VERSION

@@ -1 +1 @@
-0.3.7
+0.4.0

data/bin/judo

@@ -101,9 +101,6 @@ banner
   opts.on( '-b', '--bucket BUCKET', 'Specify the AWS S3 bucket to use' ) do |bucket|
     options[:bucket] = bucket
   end
-  opts.on( '-g', '--group GROUP', 'Specify the default group of the repo dir' ) do |group|
-    options[:group] = group
-  end
   opts.on( '-v', '--version VERSION', 'Update the servers config version on create/start/launch' ) do |version|
     options[:version] = version
   end
@@ -126,16 +123,16 @@ begin
     when "volumes" then do_volumes(judo)
     when "list" then do_list(judo, ARGV)
     when "groups" then do_groups(judo)
-    when "watch" then find_servers(judo, ARGV)        { |s| s.ssh_command("tail -n 1000 -f /var/log/kuzushi.log") }
-    when "info" then find_servers(judo, ARGV)         { |s| do_info(judo, s) }
-    when "console" then find_servers(judo, ARGV)      { |s| puts s.console_output }
-    when "commit" then find_groups(judo, ARGV)        { |g| g.compile }
-    when "ssh" then find_servers(judo, ARGV)          { |s| s.connect_ssh }
-    when "start" then find_servers(judo, ARGV)        { |s| s.start(options) }
-    when "restart" then find_servers(judo, ARGV)      { |s| s.restart(options) }
-    when "stop" then find_servers(judo, ARGV)         { |s| s.stop(options) }
-    when "create" then mk_servers(judo, options, ARGV)
-    when "launch" then mk_servers(judo, options, ARGV)         { |s| s.start(options) }
+    when "watch" then each_server(judo, ARGV)        { |s| s.ssh_command("tail -n 1000 -f /var/log/kuzushi.log") }
+    when "info" then each_server(judo, ARGV)         { |s| do_info(judo, s) }
+    when "console" then each_server(judo, ARGV)      { |s| puts s.console_output }
+    when "commit" then mk_groups(judo, ARGV)         { |g| g.compile }
+    when "ssh" then each_server(judo, ARGV)          { |s| s.connect_ssh }
+    when "start" then each_server(judo, ARGV)        { |s| s.start(options) }
+    when "restart" then each_server(judo, ARGV)      { |s| s.restart(options) }
+    when "stop" then each_server(judo, ARGV)         { |s| s.stop(options) }
+    when "create" then mk_servers(judo, options, ARGV, false)
+    when "launch" then mk_servers(judo, options, ARGV, true)
     when "snapshots" then do_snapshots(judo, ARGV)
     when "config" then
       puts "Judo DB Version: #{judo.db_version}"
@@ -143,13 +140,12 @@ begin
       puts "Judo Bucket:     #{judo.bucket_name}"
     when "rename" then
       raise JudoError, "usage: judo rename SERVER SERVER" unless ARGV.size == 2
-      old,new = ARGV
-      server = find_servers(judo, [old]).first
-      server.rename(new)
+      server = judo.find_server(ARGV[0]).rename(ARGV[1])
     when "swap" then
-      servers = find_servers(judo, ARGV)
-      raise JudoError, "usage: judo swapip SERVER SERVER" unless servers.size == 2
-      servers[0].swap(servers[1])
+      raise JudoError, "usage: judo swap SERVER SERVER" unless ARGV.size == 2
+      server1 = judo.find_server(ARGV[0])
+      server2 = judo.find_server(ARGV[1])
+      server1.swap(server2)
     when "erase" then
       raise JudoError, "usage: judo erase SNAPSHOT" unless ARGV.size == 1
       snapshot_name = ARGV.shift
@@ -158,10 +154,7 @@ begin
       raise JudoError, "usage: judo snapshot SERVER SNAPSHOT" unless ARGV.size == 2
       server_name = ARGV.shift
       snapshot_name = ARGV.shift
-      servers = find_servers(judo, [server_name])
-      raise JudoError, "You must specify a valid server to snapshot" if servers.empty?
-      raise JudoError, "You can only snapshot one server at a time" if servers.size > 1
-      servers[0].snapshot(snapshot_name)
+      judo.find_server(server_name).snapshot(snapshot_name)
     when "animate" then
       snapshot_name = ARGV.shift
       raise JudoError, "You must specify a snapshot name" unless snapshot_name
@@ -171,10 +164,9 @@ begin
       raise JudoError, "No such snapshot #{snapshot_name}" unless snapshot
       snapshot.animate(new_server).start(options)
     when "destroy" then
-      raise JudoError, "You must specify what servers to destroy" if ARGV.empty?
-      find_servers(judo, ARGV) do |i|
-        i.destroy
-      end
+      raise JudoError, "usage: judo destroy SERVERS" if ARGV.empty?
+      raise JudoError, "You cannot destroy :all" if ARGV.include?(":all")
+      each_server(judo, ARGV) { |i| i.destroy }
     else
       raise JudoError, "No such action #{action}"
   end

data/default/config.json

@@ -2,7 +2,8 @@
   "ami32":"ami-2d4aa444", // public ubuntu 10.04 ami - 32 bit
   "ami64":"ami-fd4aa494", // public ubuntu 10.04 ami - 64 bit
   "user":"ubuntu",        // this is for ssh acccess - defaults to ubuntu not root
+  "kuzushi_version": "0.0.54",  // this will pin the version of kuzushi the server will boot with
   "security_group":"judo",
-  "my_data": "world world",
+  "example_config": "example_mode",
   "availability_zone":"us-east-1d"
 }

data/default/example_config.erb

@@ -0,0 +1,7 @@
+## this is an example config file for a nonexistent app
+## it will access the amount of ram and values in the config.json
+
+memory_size = <%= @system.memory["total"].to_i / 2 %> kb  ## @system comes from ohai
+mode        = <%= @config['example_config'] %>  ## @config comes from the config.json 
+password    = '<%= ENV['JUDO_SECRET'] %>'
+

data/default/setup.sh

@@ -1,3 +1,9 @@
 #!/bin/bash
 
+if [ "$JUDO_FIRST_BOOT" ] ; then
+  ## do some setup on the first boot only
+fi
+
+## use kuzushi to process an erb file
+kuzushi-erb example_config.erb > /etc/example_config.conf
 

data/default/userdata.erb

@@ -1,6 +1,21 @@
 #!/bin/bash
 <% 
 
+## this erb generates the userdata for your starting instance
+## in most cases you would never need to edit this as most changes can go in setup.sh
+
+## this script must remain under 16k to work
+
+## good reasons to change this would be
+##   -- pass some boot options or metadata to the instance when it boots
+##   -- you do not want to install or use the default version of kuzushi or judo
+##   -- you wish to log the boot process differently
+
+## without writing a setup.sh this script will install ruby and kuzushi and 
+## run kuzushi-setup which will handle waiting for the ebs disks to attach, 
+## configuring them, and if needed formatting them and installing any needed 
+## packages (xfs tools, mdadm)
+
 ## the variables available for use in the erb are as follows
 
 ##   id - this is random string that uniqily identifies the server for its lifetime
@@ -21,14 +36,16 @@ export JUDO_DOMAIN='<%= domain %>'
 export JUDO_SECRET='<%= secret %>'
 export JUDO_FIRST_BOOT='<%= first_boot? %>'
 
+hostname <%= name %>
+
 export DEBIAN_FRONTEND="noninteractive"
 export DEBIAN_PRIORITY="critical"
 apt-get update
 apt-get install -y ruby rubygems ruby-dev irb libopenssl-ruby libreadline-ruby
 
-cd /tmp/ ; curl --silent '<%= url %>' | tar xvz ; cd <%= group_name %>
+cd /tmp/ ; curl --silent '<%= url %>' | tar xvz ; cd <%= group_name %> ; chmod 700 .
 
-gem install kuzushi --no-rdoc --no-ri --version
+gem install kuzushi --no-rdoc --no-ri --version '<%= config['kuzushi_version'] || ">= 0" %>'
 echo 'export PATH=`ruby -r rubygems -e "puts Gem.bindir"`:$PATH' >> /etc/profile ; . /etc/profile
 export LOG=/var/log/kuzushi.log
 

data/lib/judo/base.rb

@@ -3,9 +3,8 @@ module Judo
     attr_accessor :judo_dir, :repo, :group, :domain
 
     def initialize(options = Judo::Base.default_options)
-      @judo_dir      = options[:judo_dir]
-      @repo          = options[:repo]
-      @group         = options[:group]
+      @judo_dir      = File.expand_path(options[:judo_dir]) if options[:judo_dir]
+      @repo          = File.expand_path(options[:repo]) if options[:repo]
       @bucket_name   = options[:bucket]
       @access_id     = options[:access_id]
       @access_secret = options[:access_secret]
@@ -15,6 +14,37 @@ module Judo
       @key_create    = options[:key_create]
     end
 
+    def find_groups(names)
+      return groups if names.include?(":all")
+      names.map do |name|
+        groups.detect { |g| g.displayname == name } || (raise JudoError, "No such group #{name}")
+      end
+    end
+  
+    def find_server(name)
+      find_servers([name]).first
+    end
+
+    def find_servers(names)
+      names.map do |name|
+        servers.detect { |s| s.name == name || s.displayname == name } || (raise JudoError, "No such server #{name}")
+      end
+    end
+
+    def find_servers_by_name_or_groups_with_not(*names)
+      ok_servers = names.flatten.reject { |s| s =~ /^\^/ }
+      not_servers = names.flatten.select { |s| s =~ /^\^/ }.map { |s| s =~ /^\^(.*)$/ ; $1 }
+
+      find_servers_by_name_or_groups(ok_servers) - find_servers_by_name_or_groups(not_servers)
+    end
+
+    def find_servers_by_name_or_groups(*names)
+      just_servers = names.flatten.reject { |s| s =~ /^:/ }
+      just_groups = names.flatten.select { |s| s =~ /^:/ }
+    
+      [find_groups(just_groups).map { |g| g.servers } + find_servers(just_servers)].flatten
+    end
+
     def volumes
       @volumes ||= ec2_volumes.map do |v|
         {
@@ -66,7 +96,6 @@ module Judo
       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,
         :domain        => (config["domain"] || ENV['JUDO_DOMAIN']),
         :bucket        => (config["s3_bucket"] || ENV['JUDO_BUCKET']),
@@ -148,7 +177,7 @@ module Judo
 
     def mk_server_name(group)
         index = servers.map { |s| (s.name =~ /^#{s.group.name}.(\d*)$/); $1.to_i }.sort.last.to_i + 1
-        "#{group}.#{index}"
+        "#{group}#{index}"
     end
 
     def create_server(name, group, options)
@@ -183,7 +212,7 @@ module Judo
     end
 
     def groups
-      @groups ||= group_versions.map { |name,ver| Judo::Group.new(self, name, ver.first.to_i ) }
+      @groups ||= group_versions.map { |name,ver| Judo::Group.new(self, name) }
     end
 
     def reload_ec2_instances
@@ -393,9 +422,7 @@ module Judo
         return
       end
       task("Setting up default group") do
-        Dir.chdir(repo) do
-          File.open("default/config.json","w") { |f| f.write default_config }
-        end
+        FileUtils.cp_r(default_group_dir, repo)
         get_group("default").compile
       end
     end

data/lib/judo/commandline_helpers.rb

@@ -1,74 +1,53 @@
 module JudoCommandLineHelpers
-  def judo_yield(arg, blk)
-    begin
-      blk.call(arg)
-    rescue JudoInvalid => e
-      puts "#{arg} - #{e.message}"
-    end
-  end
 
-  def split(string)
-    if string =~  /([^:]*):(.*)/
-      [ $1, $2 ]
-    else
-      [ string, nil]
+  def each_server(judo, args, &blk)
+    raise JudoError, "No servers specified - use :all for all servers" if args.empty?
+    servers = judo.find_servers_by_name_or_groups_with_not(args)
+    servers.each do |server|
+      begin
+        blk.call(server)
+      rescue JudoInvalid => e
+        puts "#{server} - #{e.message}"
+      end
     end
   end
 
-  def find_groups(judo, args, &blk)
-    raise JudoError, "No groups specified" if args.empty? and judo.group.nil?
-
-    args << ":#{judo.group}" if args.empty?  ## use default group if none specified
-
-    groups = args.map do |arg|
-      name,group = split(arg)
-      raise JudoError, "specify a group with ':GROUP'" unless name == "" and group
-      judo.get_group(group)
-    end
-
-    groups.each { |group| judo_yield(group, blk) if blk }
-  end
-
-  ## I dont like the way this is working anymore - needs refactor
-  def mk_servers(judo, options, args, &blk)
-    servers = args.map do |arg|
-      name,group = split(arg)
-      group ||= judo.group
-      raise JudoError, "Cannot must specify a server, not a group, on create and launch" unless name
-      if name =~ /^\+(\d+)/
-        count = $1.to_i
+  def mk_server_names(judo, args, &blk)
+    args.each do |arg|
+      name,group = arg.split(":")
+      raise JudoError, "You must specify a group on create and launch" unless group
+      names = if name =~ /^[12345]$/ 
+        (1..(name.to_i)).each do 
+          blk.call(judo.mk_server_name(group), group)
+        end
+      elsif name == ""
+        blk.call(judo.mk_server_name(group), group)
+      elsif name =~ /^\d+$/ 
         raise JudoError, "You can batch-create between 1 and 5 servers" if count < 1 or count > 5
-        (1..count).map { judo.create_server( judo.mk_server_name(group), group, options) }
       else
-        judo.create_server(name, group, options)
+        blk.call(name, group)
       end
     end
-    servers.flatten.each { |s| judo_yield(s, blk) if blk }
   end
 
-  def find_servers(judo, args, use_default = true, &blk)
-    servers = judo.servers if args.empty?
-    servers ||= args.map { |a| find_server(judo, a, use_default) }.flatten
-
-    raise JudoError, "No servers" if servers.empty?
-
-    servers.each { |s| judo_yield(s,blk) if blk }
-    servers
+  def mk_groups(judo, args, &blk)
+    args.each do |name|
+      if name =~ /:(.+)$/
+        blk.call(Judo::Group.new(judo, $1))
+      else
+        raise JudoError, "Invalid group name '#{name}'"
+      end
+    end
   end
 
-  def find_server(judo, arg, use_default = false)
-    ## this assumes names are unique no matter the group
-    name,group = split(arg)
-    if name != ""
-      server = judo.servers.detect { |s| s.name == name }
-      raise JudoError, "No such server #{name}" unless server
-      raise JudoError, "Server #{name} not in group #{group}" if group and server.group.name != group
-      server
-    else
-      group ||= judo.group if use_default
-      g = judo.groups.detect { |g| g.name == group }
-      raise JudoError, "No such group #{group}" unless g
-      g.servers
+  def mk_servers(judo, options, args, start)
+    mk_server_names(judo, args) do |name, group|
+      begin
+        server = judo.create_server(name, group, options)
+        server.start(options) if start
+      rescue JudoInvalid => e
+        puts "#{server} - #{e.message}"
+      end
     end
   end
 
@@ -108,20 +87,18 @@ module JudoCommandLineHelpers
   end
 
   def do_snapshots(judo, args)
-    servers = find_servers(judo, args)
     printf "  SNAPSHOTS\n"
     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, "ebs:#{snapshot.ec2_ids.size}"
     end
   end
 
   def do_list(judo, args)
-    servers = find_servers(judo, args)
     printf "  SERVERS\n"
     printf "%s\n", ("-" * 80)
-    servers.sort.each do |s|
+    args << ":all" if args.empty?
+    each_server(judo,args) do |s|
       printf "%-32s %-12s %-7s %-11s %-11s %-10s %-3s %s\n", s.name, s.group.name, s.version_desc, s.get("instance_id"), s.size_desc, s.ec2_state, "ebs:#{s.volumes.keys.size}", s.has_ip? ? "ip" : ""
     end
   end

data/lib/judo/group.rb

@@ -2,10 +2,13 @@ module Judo
   class Group
     attr_accessor :name, :version
 
-    def initialize(base, name, version)
+    def initialize(base, name)
       @base = base
       @name = name
-      @version = version
+    end
+
+    def version
+      @version ||= (@base.group_versions[@name] || [0]).first.to_i
     end
 
     def userdata(version)
@@ -21,7 +24,7 @@ module Judo
     end
 
     def servers
-      @base.servers.select { |s| server_ids.include?(s.name) }
+      @base.servers.select { |s| server_ids.include?(s.id) }
     end
 
     def load_userdata(version)
@@ -41,8 +44,9 @@ module Judo
     end
 
     def compile
+      raise JudoError, "Group name :all is reserved" if name == "all"
       @base.task("Compiling #{self} version #{version + 1}") do
-        @version = @version + 1
+        @version = version + 1
         raise JudoError, "can not find group folder #{dir}" unless File.exists?(dir)
         conf = JSON.parse(read_file('config.json'))
         raise JudoError, "config option 'import' no longer supported" if conf["import"]
@@ -107,10 +111,14 @@ module Judo
       sdb.delete_attributes(@base.base_domain, "groups", name => server.id)
     end
 
-    def to_s
+    def displayname 
       ":#{name}"
     end
 
+    def to_s
+      displayname
+    end
+
     def sdb
       @base.sdb
     end

data/lib/judo/server.rb

@@ -10,7 +10,7 @@ module Judo
     end
 
     def create(name, options)
-      raise JudoError, "no group specified" unless group_name
+      raise JudoError, "group '#{group_name}' does not exists" unless group
 
       options[:virgin] = true if options[:virgin].nil?
 
@@ -212,10 +212,14 @@ module Judo
       group.config(version)
     end
 
-    def to_s
+    def displayname
       "#{name}:#{group_name}"
     end
 
+    def to_s
+      displayname
+    end
+
     def allocate_disk(snapshots)
       if snapshots
         clone_snapshots(snapshots)

data/lib/judo/snapshot.rb

@@ -89,6 +89,7 @@ module Judo
     end
 
     def delete
+      ### TODO - wait for snapshotting to finish
       @base.sdb.delete_attributes(@base.snapshot_domain, name)
       server.remove("snapshots", name) if server
     end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 7
-  version: 0.3.7
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Orion Henry
@@ -59,6 +59,7 @@ files:
 - VERSION
 - bin/judo
 - default/config.json
+- default/example_config.erb
 - default/setup.sh
 - default/userdata.erb
 - lib/judo.rb