solutious-rudy 0.5.1 → 0.6.0

data/lib/rudy/command/instances.rb

@@ -1,278 +0,0 @@
-
-
-module Rudy
-  class Instances
-    include Rudy::Huxtable
-    
-    
-    def create(opts={}, &each_inst)
-      
-      rgroup = Rudy::Groups.new(:config => @config, :global => @global)
-      
-      # 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
-
-        @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
-      
-      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)
-        
-        
-      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
-        
-        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
-  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

data/lib/rudy/command/keypairs.rb

@@ -1,149 +0,0 @@
-
-module Rudy
-  class KeyPairs
-    include Rudy::Huxtable
-    
-    
-    def create(n=nil, opts={})
-      raise KeyPairAlreadyDefined.new(current_machine_group) if !n && has_root_keypair?
-
-      n ||= name(n)
-        
-      opts = {
-        :force => false
-      }.merge(opts)
-      
-      delete_pk(n) if opts[:force] == true && File.exists?(self.path(n))
-      raise KeyPairExists, self.path(n) if File.exists?(self.path(n))
-      
-      kp = @@ec2.keypairs.create(n)
-      raise ErrorCreatingKeyPair, n unless kp.is_a?(Rudy::AWS::EC2::KeyPair)
-      
-      Rudy.trap_known_errors do
-        @logger.puts "Writing #{self.path(n)}"
-        Rudy::Utils.write_to_file(self.path(n), kp.private_key, 'w', 0600)
-      end
-      
-      Rudy.trap_known_errors do
-        @logger.puts "Writing #{self.public_path(n)}"
-        Rudy::Utils.write_to_file(self.public_path(n), kp.public_key, 'w', 0600)
-      end
-      
-      @logger.puts "NOTE: If you move #{self.path(n)} you need to also update your Rudy machines config.".color(:blue)
-      
-      kp
-    end
-    
-    #def check_permissions(n=nil)
-    #  n ||= name(n)
-    #  raise NoPrivateKeyFile, self.path(n) unless File.exists?(self.path(n))
-    #  raise InsecureKeyPairPermissions, self.path(n) unless File::Stat....
-    #  p n
-    #end
-    
-      
-    def destroy(n=nil)
-      n ||= name(n)
-      raise "KeyPair #{n} doesn't exist" unless exists?(n)
-      @logger.puts "No private key file: #{self.path(n)}. Continuing..." unless File.exists?(self.path(n))
-      @logger.puts "Unregistering KeyPair with Amazon"
-      ret = @@ec2.keypairs.destroy(n)
-      if ret
-        ret = delete_files(n) if ret # only delete local file if remote keypair is successfully destroyed
-      else
-        @logger.puts "Keypair not destroyed successfully."
-      end
-      ret
-    end
-    
-    # Lists the keypairs registered with Amazon
-    def list(n=nil, &each_object)
-      n &&= [n].flatten.compact
-      keypairs = @@ec2.keypairs.list(n)
-      keypairs.each { |n,kp| each_object.call(kp) } if each_object
-      keypairs || []
-    end
-    
-    def get(n=nil)
-      n ||= name(n)
-      keypairs = @@ec2.keypairs.list(n) || []
-      keypairs.first
-    end
-    
-    def list_as_hash(n=nil, &each_object)
-      n &&= [n].flatten.compact
-      keypairs = @@ec2.keypairs.list_as_hash(n)
-      keypairs.each_pair { |n,kp| each_object.call(kp) } if each_object
-      keypairs || {}
-    end
-    
-    def exists?(n=nil)
-      n ||= name(n)
-      @@ec2.keypairs.exists?(n)
-    end
-    
-    def any?(n=nil)
-      n ||= name(n)
-      @@ec2.keypairs.any?    
-    end
-    
-    def name(n=nil)
-      n ||= "key-#{current_machine_group}"
-      n
-    end
-      
-    def path(n=nil)
-      n ||= name(n)
-      File.join(self.config_dirname, "#{n}")
-    end
-    
-    def public_path(n=nil)
-      n ||= name(n)
-      File.join(self.config_dirname, "#{n}.pub")
-    end
-    
-
-    # We use the base file name to determine the registered keypair name.
-    def KeyPairs.path_to_name(path)
-      return unless path
-      return path unless File.exists?(path)
-      File.basename(path)
-    end
-    
-  private
-    def delete_files(n=nil)
-      n ||= name(n)
-      @logger.puts "Deleting #{self.path(n)}"
-      #return false unless File.exists?(self.path(n))
-      ret = (File.unlink(self.path(n)) > 0)      # raise exception on error. handle?
-      
-      @logger.puts "Deleting #{self.public_path(n)}"
-      #return false unless File.exists?(self.public_path(n))
-      ret && (File.unlink(self.public_path(n)) > 0)
-    end
-
-  end
-  class Keypairs
-    def initialize(*args)
-      raise "Oops! The correct class uses a capital 'P': Rudy::KeyPairs"
-    end
-  end
-end
-
-module Rudy
-  class KeyPairs
-    class InsecureKeyPairPermissions < RuntimeError; end
-    class NoPrivateKeyFile < RuntimeError; end
-    class ErrorCreatingKeyPair < RuntimeError; end
-    class KeyPairExists < RuntimeError; end
-    class KeyPairAlreadyDefined < RuntimeError
-      attr_reader :group
-      def initialize(group)
-        @group = group
-      end
-      def message
-        "A keypair is defined for #{group}. Check your Rudy config."
-      end
-    end
-  end
-end

data/lib/rudy/command/manager.rb

@@ -1,65 +0,0 @@
-
-
-module Rudy
-  class Manager
-    include Rudy::Huxtable
-    
-
-  end
-end
-
-
-__END__
-
-
-def create_domain(name=nil)
-  name ||= Rudy::RUDY_DOMAIN
-  @@sdb.domains.create(name)
-end
-
-def domains
-  (@@sdb.domains.list || []).flatten
-end
-
-
-
-def update_valid?
-  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)
-  
-  @option.group ||= machine_group
-  
-  @scripts = %w[rudy-ec2-startup update-ec2-ami-tools randomize-root-password]
-  @scripts.collect! {|script| File.join(RUDY_HOME, 'support', script) }
-  @scripts.each do |script| 
-    raise "Cannot find #{script}" unless File.exists?(script)
-  end
-  
-  true
-end
-
-def update
-  puts "Updating Rudy on machines in #{@option.group}"
-  switch_user("root")
-  
-  exit unless Annoy.are_you_sure?
-  scp do |scp|
-    @scripts.each do |script|
-      puts "Uploading #{File.basename(script)}"
-      scp.upload!(script, "/etc/init.d/")
-    end
-  end
-  
-  ssh do |session|
-    @scripts.each do |script|
-      session.exec!("chmod 700 /etc/init.d/#{File.basename(script)}")
-    end
-    
-    puts "Installing Rudy (#{Rudy::VERSION})"
-    session.exec!("mkdir -p /etc/ec2")
-    session.exec!("gem sources -a http://gems.github.com")
-    puts session.exec!("gem install --no-ri --no-rdoc rudy -v #{Rudy::VERSION}")
-  end
-end
-

data/lib/rudy/command/volumes.rb

@@ -1,127 +0,0 @@
-
-module Rudy
-  class Volumes
-    include Rudy::Huxtable
-    
-
-    def create(size, zone=nil, snapshot=nil)
-      raise "No size supplied" unless size
-      zone ||= @global.zone
-      
-      @logger.puts "Creating Volume "
-      vol = @@ec2.volumes.create(size, zone, snapshot)
-      Rudy.waiter(1, 30, @logger) do
-        vol = get(vol.awsid) # update the volume until it says it's available
-        (vol && vol.status == "available")
-      end
-      
-      vol
-    end
-        
-    def attach(volume, instance, device="/dev/sdh")
-      volume = get(volume)
-      instance = instance.is_a?(Rudy::AWS::EC2::Instance) ? instance.awsid : instance
-      raise "Volume #{volume.awsid} already attached" if volume.attached?
-      raise "No instance supplied" unless instance
-      raise "No device supplied" unless device
-      
-      ret = false
-      begin
-        @logger.puts "Attaching Volume... "
-        ret = @@ec2.volumes.attach(instance, volume.awsid, device)
-        raise "Unknown error" unless ret 
-        
-        Rudy.waiter(1, 30, @logger) do
-          ret = attached?(volume.awsid)
-        end
-        
-      rescue => ex
-        @logger.puts ex.backtrace if debug?
-        raise "Error attaching #{volume.awsid} to #{instance}: #{ex.message}"
-      end
-      
-      ret
-    end
-    
-    def destroy(volume)
-      volume = get(volume)
-      
-      
-      ret = false
-      begin
-        
-        detach(volume) if volume.attached?
-        raise "Volume is still attached. Cannot destroy." unless available?(volume.awsid)
-        
-        ret = @@ec2.volumes.destroy(volume.awsid)
-        
-      rescue => ex
-        puts ex.backtrace if debug?
-        raise "Error destroying volume #{volume.awsid}: #{ex.message}"
-      end
-      ret
-    end
-     
-    def detach(volume)
-      volume = get(volume)
-      raise "#{volume.awsid} is not attached" unless attached?(volume.awsid)
-      
-      ret = false
-      begin
-        @logger.puts "Dettaching #{volume.awsid} "
-        @@ec2.volumes.detach(volume.awsid)
-        Rudy.waiter(1, 30) do
-          ret = @@ec2.volumes.available?(volume.awsid)
-        end
-        
-      rescue => ex
-        puts ex.backtrace if debug?
-        raise "Error detaching volume #{volume.awsid}: #{ex.message}"
-      end
-      
-      ret
-    end
-    
-    
-    def attached?(volume)
-      @@ec2.volumes.attached?(volume)
-    end
-    
-    def deleting?(volume)
-      @@ec2.volumes.deleting?(volume)
-    end
-    
-    def available?(volume)
-      @@ec2.volumes.available?(volume)
-    end
-    
-    def in_use?(volume)
-      @@ec2.volumes.in_use?(volume)
-    end
-    
-    
-    def list(state=nil, vol_id=[])
-      @@ec2.volumes.list(state, vol_id)
-    end
-    
-    def list_as_hash(state=nil, vol_id=[])
-      @@ec2.volumes.list_as_hash(state, vol_id)
-    end
-    
-    def any?(state=nil, vol_id=[])
-      @@ec2.volumes.any?(state, vol_id)
-    end
-    
-    def exists?(vol_id)
-      @@ec2.volumes.exists?(vol_id)
-    end
-    
-    # * +volopt* is a volume ID or an Rudy::AWS::EC2::Volume object
-    def get(volopt)
-      return volopt if volopt.is_a?(Rudy::AWS::EC2::Volume)
-      @@ec2.volumes.get(volopt)
-    end
-    
-
-  end
-end