judo 0.0.9 → 0.1.0

data/lib/judo/commandline_helpers.rb

@@ -0,0 +1,151 @@
+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] 
+    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
+
+  def mk_servers(judo, 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
+        raise JudoError, "You can batch-create between 1 and 5 servers" if count < 1 or count > 5
+        (1..count).map { judo.new_server(nil, group) }
+      else
+        judo.new_server(name, group)
+      end
+    end
+    servers.flatten.each { |s| judo_yield(s, blk) if blk }
+  end
+
+  def find_either(judo, args, &blk)
+    results = []
+    args.each do |arg|
+      server,group = split(arg)
+      if server != ""
+        results << judo.servers.select { |s| s.name == server }
+      else
+        results << judo.groups.select { |g| g.name == group }
+      end
+    end
+    results.flatten.each { |i| judo_yield(i, 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 }
+  end
+
+  def find_server(judo, arg, use_default)
+    ## 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
+    end
+  end
+
+  def do_groups(judo)
+    printf "  SERVER GROUPS\n"
+    judo.groups.each do |g|
+      printf "%-18s %s servers\n", g.name, g.servers.size
+    end
+  end
+
+  def do_volumes(judo)
+    vols = judo.volumes.sort { |a,b| [ a[:assigned_to].to_s, a[:instance_id].to_s ] <=> [ b[:assigned_to].to_s, b[:instance_id].to_s ] }
+
+    format = "%13s %6s %12s  %-10s %-16s %-16s\n"
+    printf format, "AWS_ID", "SIZE", "AWS_STATUS", "AWS_DEVICE", "ATTACHED TO", "CONFIGURED FOR"
+    printf "%s\n", ("-" * 80)
+
+    vols.each do |v|
+      attached = v[:attached_to] ? v[:attached_to].name : v[:instance_id]
+      assigned = v[:assigned_to] ? v[:assigned_to].name : ""
+      printf format, v[:id], v[:size], v[:status], v[:device], attached, assigned
+    end
+  end
+
+  def do_ips(judo)
+    ips = judo.ips.sort { |a,b| a[:assigned_to].to_s <=> b[:assigned_to].to_s }
+
+    format = "%15s %20s %20s\n"
+    printf format, "IP", "ATTACHED TO", "CONFIGURED FOR"
+    printf "%s\n", ("-"*57)
+
+    ips.each do |ip|
+      attached = ip[:attached_to] ? ip[:attached_to].name : ip[:instance_id]
+      assigned = ip[:assigned_to] ? ip[:assigned_to].name : ""
+      printf format, ip[:ip], attached, assigned
+    end
+  end
+
+  def do_list(judo, args)
+    servers = find_servers(judo, args)
+    printf "  SERVERS\n"
+    printf "%s\n", ("-" * 80)
+    servers.sort.each do |s|
+      printf "%-18s %-12s %-7s %-11s %-11s %-13s %-10s %-10s %s\n", s.name, s.group.name, s.version_desc, s.state["instance_id"], s.size_desc, s.ami, s.ec2_state, "#{s.volumes.keys.size} volumes", s.ip
+    end
+  end
+
+  def do_info(judo, server)
+    puts "#{server}"
+    if server.ec2_instance and not server.ec2_instance.empty?
+      puts "\t[ EC2 ]"
+      [:aws_instance_id, :ssh_key_name, :aws_availability_zone, :aws_state, :aws_image_id, :dns_name, :aws_instance_type, :private_dns_name, :aws_launch_time, :aws_groups ].each do |k|
+        printf "\t %-24s: %s\n",k, server.ec2_instance[k]
+      end
+    end
+    puts "\t[ VOLUMES ]"
+    server.ec2_volumes.each do |v|
+      printf "\t %-13s %-10s %-10s %4d  %-10s %-8s\n",
+      v[:aws_id],
+      v[:aws_status],
+      v[:zone],
+      v[:aws_size],
+      v[:aws_attachment_status],
+      v[:aws_device]
+    end
+    puts "\t[ CONFIG ]"
+    pp server.config
+  end
+end

data/lib/judo/config.rb

@@ -0,0 +1,133 @@
+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/group.rb

@@ -0,0 +1,221 @@
+module Judo
+  class Group
+    attr_accessor :name, :version
+
+#    def self.dirs
+#      Dir["#{@base.repor}/*/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(base, dir, name = File.basename(dir))
+    def initialize(base, name, version)
+      @base = base
+      @name = name
+      @version = version
+#      @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
+##      @base.read_config(attrs[:group]) ## make sure the config is valid  ## FIXME
+#
+#      server = Judo::Server.new base, server_name, name
+#      server.task("Creating server #{server_name}") do
+#        server.update "name" => server_name, "group" => name, "virgin" => true, "secret" => rand(2 ** 128).to_s(36)
+#        @base.sdb.put_attributes("judo_config", "groups", name => server_name)
+#      end
+#      server
+#    end
+
+    def config
+      @config ||= load_config
+    end
+
+    def build_config
+      @build_config ||= all_configs.reverse.inject({}) { |sum,conf| sum.merge(conf) }
+    end
+
+    def server_names
+      @server_names ||= (@base.groups_config[@name] || [])
+    end
+
+    def servers
+      @base.servers.select { |s| server_names.include?(s.name) }
+    end
+
+#    def version
+#      @version ||= (@base.group_versions[@name] || ["0"]).first.to_i
+#    end
+
+    def load_config
+        JSON.load @base.s3_get(version_config_file)
+      rescue Aws::AwsError
+       raise JudoError, "No config stored: try 'judo commit #{to_s}'"
+    end
+
+    def set_version(new_version)
+      @version = new_version
+      @base.sdb.put_attributes("judo_config", "group_versions", { name => new_version }, :replace)
+    end
+
+    def compile
+      tmpdir = "/tmp/kuzushi/#{name}"
+      set_version(version + 1)
+      puts "Compiling #{self} version #{version}"
+      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 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
+      end
+    end
+
+    def version_config_file
+      "#{name}.#{version}.json"
+    end
+
+    def tar_file
+      "#{name}.#{version}.tar.gz"
+    end
+
+    def s3_url
+      @url = @base.s3_url(tar_file)
+    end
+
+    def cp_file
+      FileUtil.mkdir_p(tmpdir)
+    end
+
+    def extract_file(type, name, files)
+      path = "#{dir}/#{type}s/#{name}"
+      puts "[#{name}] #{path}"
+      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(c = config)
+      extract(c, {})
+    end
+
+    def raw_config
+      @raw_config ||= read_config
+    end
+
+    def parent
+      @parent ||= @base.groups.detect { |p| p.name == raw_config["import"] }
+      raise JudoError, "Parent group #{raw_config["import"]} must be commited" if raw_config["import"] and @parent.nil?
+      @parent
+    end
+
+    def destroy
+      servers.each { |s| s.destroy }
+      @base.task("Destring #{self}") do
+        @base.groups.delete(self)
+        @base.sdb.delete_attributes("judo_config", "groups", [ name ])
+        @base.sdb.delete_attributes("judo_config", "group_versions", [ name ])
+      end
+    end
+
+    def all_configs
+      parent ? parent.all_configs.clone.unshift(raw_config) : [ raw_config ]
+    end
+
+    def dir
+      "#{@base.repo}/#{name}/"
+    end
+
+    def config_file
+      "#{dir}/config.json"
+    end
+
+    def read_config
+        JSON.parse(File.read(config_file))
+      rescue Errno::ENOENT
+        raise JudoError, "No config file #{config_file}"
+    end
+
+    def delete_server(server)
+      sdb.delete_attributes("judo_config", "groups", name => server.name)
+    end
+
+    def to_s
+      ":#{name}"
+    end
+
+    def sdb
+      @base.sdb
+    end
+  end
+end
+