solutious-rudy 0.4.0 → 0.5.0

data/lib/rudy/command/domains.rb

@@ -0,0 +1,34 @@
+
+
+module Rudy
+  class Domains
+    include Rudy::Huxtable
+    
+    
+    def list
+      @@sdb.domains.list || []
+    end
+    
+    def get(n=nil)
+      n = name(Rudy::RUDY_DOMAIN)
+      n &&= n.to_s
+      doms = list.select { |domain| domain == n }
+      doms = nil if doms.empty?
+      doms
+    end
+    
+    def exists?(n=nil)
+      !get(n).nil?
+    end
+    
+    def name(n=nil)
+      n || Rudy::RUDY_DOMAIN
+    end
+    
+    def create(n=nil)
+      n = name(n)
+      @@sdb.domains.create(n)
+    end
+      
+  end
+end

data/lib/rudy/command/groups.rb

@@ -1,61 +1,118 @@
 
 
-
 module Rudy
-  module Command
-    class Groups < Rudy::Command::Base
+  class Groups
+    include Rudy::Huxtable
+   
+   
+    def create(n=nil, description=nil, opts={})
+      n ||= name(n)
+      description ||= "Machine group #{n}"
+      raise "Group #{n} already exists" if @@ec2.groups.exists?(n)
+      @@ec2.groups.create(n, description)
+      authorize(n, opts)
+    end
+    
+    def destroy(n=nil)
+      n ||= name(n)
+      raise "Group #{n} does not exist" unless @@ec2.groups.exists?(n)
+      @@ec2.groups.destroy(n)
+    end
+    
+    def authorize(n=nil, opts={})
+      n ||= name(n)
+      modify_rules(:authorize, n, opts)
+    end
+    def revoke(n=nil, opts={})
+      n ||= name(n)
+      modify_rules(:revoke, n, opts)
+    end
+    
+    def exists?(n=nil)
+      n ||= name(n)
+      @@ec2.groups.exists?(n)
+    end
+    
+    def name(n=nil)
+      n || current_machine_group
+    end
+    
+    
+    # Do any groups exist? The default group is not considered here since it
+    # cannot be destroyed. We're interested in any other groups. 
+    def any?
+      groups = @@ec2.groups.list_as_hash
+      return false unless groups
+      groups.reject! { |name,g| g.name == 'default' }
+      !groups.empty?
+    end
+    
+    def list(n=nil, &each_object)
+      n &&= [n]
+      groups = @@ec2.groups.list(n)
+      groups.each { |g| each_object.call(g) } if each_object
+      groups
+    end
+    
+    def get(n=nil)
+      n ||= name(n)
+      (list(n) || []).first
+    end
+    
+    def list_as_hash(n=nil, &each_object)
+      n &&= [n]
+      groups = @@ec2.groups.list_as_hash(n)
+      groups.each_pair { |n,g| each_object.call(g) } if each_object
+      groups
+    end
+    
+    # TODO: Consider changing the hash interface into arguments. 
+    # with different methods for authorizing groups and addresses
+    def modify_rules(action, n, opts={})
+      n ||= name(n)
       
-      def groups(name=@argv.first)
-        name = machine_group if name.nil? && !@option.all
-        @ec2.groups.list(name).each do |grp|
-          print_group grp
-        end
-      end
+      raise "You must supply a group name" unless n
+      raise "Group does not exist" unless @@ec2.groups.exists?(n)
+      @logger.puts "#{action.to_s.capitalize} access for #{n.bright}"
       
-      def create_groups(name=@argv.first)
-        name ||= machine_group
-        puts "Creating group #{name}"
-        raise "The group #{name} already exists" if @ec2.groups.exists?(name)
 
-        @ec2.groups.create(name)
-        
-        modify_groups name
-      end
+      opts[:ports] ||= [[22,22],[80,80],[443,443]]
+      opts[:protocols] ||= ["tcp"]          
+      opts[:addresses] ||= [Rudy::Utils::external_ip_address]
+       
+      # Make sure the IP addresses have ranges
+      opts[:addresses].collect! { |ip| (ip.match /\/\d+/) ? ip : "#{ip}/32"  }
       
-      def modify_groups(name=@argv.first)
-        name ||= machine_group
-        raise "The group #{name} does not exist" unless @ec2.groups.exists?(name)
-        
-        @option.addresses ||= [Rudy::Utils::external_ip_address]
-        @option.ports ||= [22,80,443]
-        @option.protocols ||= ["tcp"]
-        
-        # Make sure the IP addresses have ranges
-        @option.addresses.collect! { |ip| (ip.match /\/\d+/) ? ip : "#{ip}/32"  }
-        
-        @option.protocols.each do |protocol|
-          puts "Adding ports #{@option.ports.join(',')} (#{protocol}) for #{@option.addresses.join(', ')}"
-          @option.addresses.each do |address|
-            @option.ports.each do |port|
-              @ec2.groups.modify(name, port, port, protocol, address)
-            end
+      opts[:protocols].each do |protocol|
+        opts[:addresses].each do |address|
+          opts[:ports].each do |port|
+            @logger.puts "Ports #{port[0]}:#{port[1]} (#{protocol}) for #{opts[:addresses].join(', ')}"
+            @@ec2.groups.send(action, n, port[0].to_i, (port[1] || port[0]).to_i, protocol, address)
           end
         end
-        
-        groups name
       end
       
-      def destroy_groups(name=@argv.first)
-        name ||= machine_group
-        puts "Destroying group #{name}"
-        name = machine_group if name.nil?
-        raise "The group #{name} does not exist" unless @ec2.groups.exists?(name)
-        exit unless are_you_sure?
-        
-        @ec2.groups.destroy(name)
-        
-      end
+      @@ec2.groups.get(n)
+    
+     
     end
-  end
-end
+    
+    def modify_group_rules(n=nil, group=nil, owner=nil)
+      n ||= name(n)
+      
+      owner ||= @config.accounts.aws.accountnum
+      
+      raise "You must supply a group name" unless n
+      raise "Group does not exist" unless @@ec2.groups.exists?(n)
+      raise "Owner to authorize not specified" unless owner
+      raise "Group to authorize not specified" unless owner
+      
+      @logger.puts "#{action.to_s.capitalize} access for #{n.bright}"
+
+      @@ec2.groups.send("#{action}_group", n, group, owner)
 
+      @@ec2.groups.get(n)
+    end
+    
+  end
+end

data/lib/rudy/command/instances.rb

@@ -1,85 +1,278 @@
-# 
-# 
-# 
-# 
-# 
-# 
-# 
-# 
-# 
-# 
-# 
+
 
 module Rudy
-  module Command
-    class Instances < Rudy::Command::Base
+  class Instances
+    include Rudy::Huxtable
+    
+    
+    def create(opts={}, &each_inst)
       
-      def restart_instances_valid?
-        raise "No instance ID provided" if @argv.filter.nil?
-        raise "No EC2 .pem keys provided" unless has_pem_keys?
-        raise "No SSH key provided for #{@global.user}!" unless has_keypair?
-        raise "No SSH key provided for root!" unless has_keypair?(:root)
-        
-        
-        @list = @ec2.instances.list(machine_group)
-        raise "#{@argv.filter} is not in the current machine group" unless @list.has_key?(@argv.filter)
-        
-        raise "I will not help you destroy production!" if @global.environment == "prod" # TODO: use_caution?, locked?
-        
-        exit unless are_you_sure?(5)
-        true
-      end
-      def restart_instances
-        puts "Restarting #{@argv.filter}!"
-        @ec2.instances.restart @argv.filter
-      end
+      rgroup = Rudy::Groups.new(:config => @config, :global => @global)
       
-      def instances
-        filter = @argv.first
-        filter = machine_group if filter.nil? && !@option.all
-        if instance_id?(filter)
-          inst = @ec2.instances.get(filter)
-          raise "The instance #{filter} does not exist" if inst.empty?
-          list = {inst[:aws_instance_id] => inst}
-        else
-          raise "The security group #{filter} does not exist" if filter && !@ec2.groups.exists?(filter)
-          list = @ec2.instances.list(filter)
-          if list.empty? 
-            msg = "There are no instances running" 
-            msg << " in the group #{filter}" if filter
-            raise msg
-          end
+      # TODO: Handle itype on create
+      opts = { :ami => current_machine_image, 
+               :group => current_machine_group, 
+               :user => current_user,
+               :size => "m1.small",
+               :keypair => user_keypairpath(:root), # Must be a root key
+               :address => current_machine_address,
+               :machine_data => machine_data.to_yaml }.merge(opts)
+
+      raise NoGroup.new(opts[:group]) unless rgroup.exists?(opts[:group])
+      raise NoRootKeyPair.new(opts[:group]) if !opts[:keypair] && !has_keypair?(:root)
+
+      keypair_name = KeyPairs.path_to_name(opts[:keypair])
+      
+      instances = @@ec2.instances.create(opts[:ami], opts[:group], keypair_name, opts[:machine_data], @global.zone)
+
+      
+      #instances = [@@ec2.instances.get("i-39009850")]
+      instances_with_dns = []
+      instances.each_with_index do |inst_tmp,index|
+        Rudy.bug('hs672h48') && next if inst_tmp.nil?
+
+        @logger.puts "Instance: #{inst_tmp.awsid}"
+        if opts[:address] && index == 0  # We currently only support assigned an address to the first machine
+          @logger.puts "Associating #{opts[:address]} to #{inst_tmp.awsid}"
+          @@ec2.addresses.associate(inst_tmp.awsid, opts[:address])
         end
-        
-        list.each_pair do |id, inst|
-          print_instance inst
+
+        @logger.puts "Waiting for the instance to startup "        
+        begin 
+          # TODO: Puts "it's up" and :bell => 3 into waiter 
+          Rudy.waiter(2, 120, @logger) { !@@ec2.instances.pending?(inst_tmp.awsid) }
+          raise Exception unless @@ec2.instances.running?(inst_tmp.awsid)
+          @logger.puts "It's up!"
+          Rudy.bell(3)
+        rescue Timeout::Error, Interrupt, Exception
+          @logger.puts "It's not up yet. Check later: " << "rudy status #{inst_tmp.awsid}".color(:blue)
+          next
         end
-        
+
+        # The DNS names are now available so we need to grab that data from AWS
+        instance = @@ec2.instances.get(inst_tmp.awsid)   
+        instances_with_dns << instance
+
+        @logger.puts $/, "Waiting for the SSH daemon "
+        begin
+          Rudy.waiter(1, 60, @logger) { Rudy::Utils.service_available?(instance.dns_name_public, 22) }
+          @logger.puts "It's up!"
+          Rudy.bell(2)
+        rescue Timeout::Error, Interrupt, Exception
+          @logger.puts "SSH isn't up yet. Check later: " << "rudy status #{inst_tmp.awsid}".color(:blue)
+          next
+        end
+
+
       end
       
-      def destroy_instances_valid?
-        filter = argv.first
-        raise "No instance ID provided" if filter.nil?
-        raise "I will not help you destroy production!" if @global.environment == "prod" || filter =~ /^prod/
-        exit unless are_you_sure?
-        true
+      instances_with_dns.each { |inst| each_inst.call(inst) } if each_inst
+      instances_with_dns
+    end
+    
+    def destroy(group=nil, inst_id=[], &each_inst)
+      group ||= current_machine_group
+      raise "No machines running in #{group}" unless running?(group)
+      instances = @@ec2.instances.list_group(group, :running, inst_id)
+      instances &&= [instances].flatten
+      instances.each { |inst| each_inst.call(inst) } if each_inst
+      @logger.puts $/, "Terminating instances...", $/
+      @@ec2.instances.destroy(instances, :skip_check)
+    end
+    
+    # * +state+ instance state (:running, :terminated, :pending, :shutting_down)
+    # * +group+ machine group name. The default is the current machine group
+    # (as determined by the globals) if none is supplied. A value of :any will 
+    # return machines from all groups.
+    # * +inst_ids+ An Array of instance IDs (Strings) or Instance objects to 
+    # filter the list by. Any instances not in the group will be ignored. 
+    # * +each_inst+ a block to execute for every instance in the list. 
+    # Returns an Array of Rudy::AWS::EC2::Instance objects
+    def list(state=nil, group=nil, inst_ids=[], &each_inst)
+      group ||= current_machine_group
+      unless group == :any
+        instances = @@ec2.instances.list_group(group, state, inst_ids) || []
+      else
+        instances = @@ec2.instances.list(state, inst_ids) || []
+      end
+      instances.each { |inst| each_inst.call(inst) } if each_inst
+      instances
+    end
+    
+    # See Rudy::Instances#list for arguments.
+    # Returns a Hash of Rudy::AWS::EC2::Instance objects (the keys are instance IDs)
+    def list_as_hash(state=nil, group=nil, inst_ids=[], &each_inst)
+      group ||= current_machine_group
+      if group == :any
+        instances = @@ec2.instances.list_group_as_hash(group, state, inst_ids) || {}
+      else
+        instances = @@ec2.instances.list_as_hash(state, inst_ids) || {}
       end
+      instances.each_pair { |inst_id,inst| each_inst.call(inst) } if each_inst
+      instances
+    end
+    
+    # System console output. 
+    #
+    # NOTE: Amazon sends the console output as a Base64 encoded string. This method
+    # decrypts it before returning it.
+    #
+    # Returns output for the first machine in the group (if provided) or the first
+    # instance ID (if provided)
+    def console(group=nil, inst_ids=[])
+      group ||= current_machine_group
+      instances = @@ec2.instances.list_group(group, :any, inst_ids)
+      return if instances.nil?
+      output = @@ec2.instances.console_output(instances.first.awsid)
+      return unless output
+      Base64.decode64(output)
+    end
+    
+    def connect(group=nil, cmd=nil, inst_ids=[], print_only=false)
+      group ||= current_machine_group
+      instances = @@ec2.instances.list_group(group, :running, inst_ids)
+      raise "No machines running" if instances.nil?
+      raise "No keypair configured for user #{current_user}" unless current_user_keypairpath
+      
+      # TODO: If a group is supplied we need to discover the keypair.
+      
+      instances.each do |inst|
+        msg = cmd ? %Q{"#{cmd}" on} : "Connecting to"
+        @logger.puts $/, "#{msg} #{inst.dns_name_public}", $/
+        ret = ssh_command(inst.dns_name_public, current_user_keypairpath, @global.user, cmd, print_only)
+        puts ret if ret  # ssh command returns false with "ssh_exchange_identification: Connection closed by remote host"
+      end
+    end
+    
+    
+    # * +:recursive: recursively transfer directories (default: false)
+    # * +:preserve: preserve atimes and ctimes (default: false)
+    # * +:task+ one of: :upload (default), :download.
+    # * +:paths+ an array of paths to copy. The last element is the "to" path. 
+    def copy(group=nil, inst_ids=[], opts={})
+      group ||= current_machine_group
+      instances = @@ec2.instances.list_group(group, :running, inst_ids)
+      raise "No machines running" if instances.nil?
+      raise "No keypair configured for user #{current_user}" unless current_user_keypairpath
+      raise "You must supply at least one source path" if !opts[:paths] || opts[:paths].empty?
+      raise "You must supply a destination path" unless opts[:dest]
+       
+      
+      opts = {
+        :task => :upload,
+        :recursive => false,
+        :preserve => false
+      }.merge(opts)
         
-      def destroy_instances
-        filter = argv.first
-
-        if @ec2.groups.exists?(filter)
-          list = @ec2.instances.list(filter)
-          raise "The group #{filter} has no running instances" if list.empty?
-          instance = list.keys.first
-        else 
-          instance = filter
+        
+      instances.each do |inst|
+        msg = opts[:task] == :upload ? "Upload to" : "Download from"
+        @logger.puts $/, "#{msg} #{inst.awsid}"
+        
+        if opts[:print]
+          scp_command inst.dns_name_public, current_user_keypairpath, @global.user, opts[:paths], opts[:dest], (opts[:task] == :download), false, opts[:print]
+          return
         end
-        puts "Destroying #{instance}!"
-        @ec2.instances.destroy instance
+        
+        scp_opts = {
+          :recursive => opts[:recursive],
+          :preserve => opts[:preserve],
+          :chunk_size => 16384
+        }
+        
+        scp(opts[:task], inst.dns_name_public, @global.user, current_user_keypairpath, opts[:paths], opts[:dest], scp_opts)
+        
       end
+      
+      @logger.puts
+    end
+    
+    
+    # * +group+ machine group name
+    def any?(group=nil)
+      group ||= current_machine_group
+      
+      @@ec2.instances.any_group?(group)
+    end
+    
+    def exists?(inst_id)
+      @@ec2.instances.exists?(inst_id)
+    end
+    
+    # *NOTE REGARDING THE STATUS METHODS*:
+    #
+    # We currently return true IF ANY instances are operating
+    # in the given state. This is faulty but we can't fix it
+    # until we have a way to know how many instances should be
+    # running in any given group. 
+    #
+    # Are *any* instances in the group in the running state? 
+    def running?(group=nil)
+      !list(:running, group).empty?
+    end
+    
+    # Are *any* instances in the group in the terminated state?
+    def terminated?(group=nil)
+      !list(:terminated, group).empty?
+    end
+    
+    # Are *any* instances in the group in the shutting-down state?
+    def shutting_down?(group=nil)
+      !list(:shutting_down, group).empty?
+    end
+    
+    # Are *any* instances in the group in the pending state?
+    def pending?(group=nil)
+      !list(:pending, group).empty?
+    end
+    
+    # Are *any* instances in the group in the a non-running state?
+    def unavailable?(group=nil)
+      # We go through @@ec2 so we don't reimplement the "unavailable logic"
+      instances = list(:any, group)
+      @@ec2.instances.unavailable?(instances)
+    end
+    
+
+    
+    
+  private
 
+    def machine_data
+      data = {
+        # Give the machine an identity
+        :zone => @global.zone,
+        :environment => @global.environment,
+        :role => @global.role,
+        :position => @global.position,
+        
+        # Add hosts to the /etc/hosts file
+        :hosts => {
+          :dbmaster => "127.0.0.1",
+        }
+      } 
+      data.to_hash
     end
+    
+    
+    
   end
-end
-
+  class NoGroup < RuntimeError
+    def initialize(group)
+      @group = group
+    end
+    def message
+      "Group #{@group} does not exist. See: rudy groups -h"
+    end
+  end
+  
+  class NoRootKeyPair < RuntimeError
+    def initialize(group)
+      @group = group
+    end
+    def message
+      "No root keypair for #{@group}. See: rudy keypairs -h"
+    end
+  end
+  
+end