rouster 0.7 → 0.41

data/examples/openstack.rb

@@ -1,61 +0,0 @@
-require sprintf('%s/../%s', File.dirname(File.expand_path(__FILE__)), 'path_helper')
-
-require 'rouster'
-require 'plugins/openstack' # brings in fog and some helpers
-
-ostack = Rouster.new(
-  :name      => 'ostack-testing',
-  :sudo      => false,
-  :logfile   => true,
-  :passthrough => {
-    :type                => :openstack,                                   # Indicate OpenStack provider
-    :openstack_auth_url  => 'http://hostname.acme.com:5000/v2.0/tokens',  # OpenStack API endpoint
-    :openstack_username  => 'some_user',                                  # OpenStack console username
-    :openstack_tenant    => 'tenant_id',                                  # Tenant ID
-    :user                => 'ssh_user_id',                                # SSH login ID
-    :keypair             => 'openstack_key_name',                         # Name of ssh keypair in OpenStack
-    :image_ref           => 'c0340afb-577d-1234-87b2-aebdd6d1838f',       # Image ID in OpenStack
-    :flavor_ref          => '547d9af5-096c-1234-98df-7d23162556b8',       # Flavor ID in OpenStack
-    :openstack_api_key   => 'secret_openstack_key',                       # OpenStack console password
-    :key                 => '/path/to/ssh_keys.pem',                      # SSH key filename
-  },
-  :sshtunnel => false,
-  :verbosity => 1,
-)
-
-p "UP(): #{ostack.up}"
-p "STATUS(): #{ostack.status}"
-
-ostack_copy = Rouster.new(
-  :name      => 'ostack-copy',
-  :sudo      => false,
-  :logfile   => true,
-  :passthrough => {
-    :type                => :openstack,                                   # Indicate OpenStack provider
-    :openstack_auth_url  => 'http://hostname.acme.com:5000/v2.0/tokens',  # OpenStack API endpoint
-    :openstack_username  => 'some_user',                                  # OpenStack console username
-    :openstack_tenant    => 'tenant_id',                                  # Tenant ID
-    :user                => 'ssh_user_id',                                # SSH login ID
-    :keypair             => 'openstack_key_name',                         # Name of ssh keypair in OpenStack
-    :openstack_api_key   => 'secret_openstack_key',                       # OpenStack console password
-    :instance            => ostack.ostack_get_instance_id,                # ID of a running OpenStack instance.
-  },
-  :sshtunnel => false,
-  :verbosity => 1,
-)
-
-[ ostack, ostack_copy ].each do |o|
-  p "ostack_get_instance_id: #{o.ostack_get_instance_id}"
-
-  p "status: #{o.status}"
-
-  p "ostack_get_ip(): #{o.ostack_get_ip()}"
-
-  p "run(uptime): #{o.run('uptime')}"
-  p "get(/etc/hosts): #{o.get('/etc/hosts')}"
-  p "put(/etc/hosts, /tmp): #{o.put('/etc/hosts', '/tmp')}"
-
-end
-
-p "DESTROY(): #{ostack.destroy}"
-exit

data/examples/passthrough.rb

@@ -1,71 +0,0 @@
-require sprintf('%s/../%s', File.dirname(File.expand_path(__FILE__)), 'path_helper')
-
-require 'rouster'
-require 'rouster/puppet'
-require 'rouster/tests'
-
-verbosity = ENV['VERBOSE'].nil? ? 4 : 0
-
-# .inspect of this is blank for sshkey and status, looks ugly, but is ~accurate.. fix this?
-local = Rouster.new(
-  :name        => 'local',
-  :sudo        => false,
-  :passthrough => { :type => :local },
-  :verbosity   => verbosity,
-)
-
-remote = Rouster.new(
-  :name => 'remote',
-  :sudo => false,
-  :passthrough => {
-    :type => :remote,
-    :host => `hostname`.chomp, # yep, the remote is actually local.. perhaps the right :type would be 'ssh' vs 'shellout' instead..
-    :user => ENV['USER'],
-    :key  => sprintf('%s/.ssh/id_dsa', ENV['HOME']),
-  },
-  :verbosity => verbosity,
-)
-
-sudo = Rouster.new(
-  :name        => 'sudo',
-  :sudo        => true,
-  :passthrough => { :type => :local },
-  :verbosity   => verbosity,
-)
-
-vagrant = Rouster.new(
-  :name        => 'ppm',
-  :sudo        => true,
-  :verbosity   => verbosity,
-)
-
-workers = [ local, remote, vagrant ]
-
-workers = [vagrant]
-
-workers.each do |r|
-  p r
-
-  ## vagrant command testing
-  r.up()
-  r.suspend()
-  #r.destroy()
-  r.up()
-
-  p r.status() # why is this giving us nil after initial call? want to blame caching, but not sure
-
-  r.is_vagrant_running?()
-  r.sandbox_available?()
-
-  if r.sandbox_available?()
-    r.sandbox_on()
-    r.sandbox_off()
-    r.sandbox_rollback()
-    r.sandbox_commit()
-  end
-
-  p r.run('echo foo')
-
-end
-
-exit

data/lib/rouster/vagrant.rb

@@ -1,311 +0,0 @@
-require sprintf('%s/../../%s', File.dirname(File.expand_path(__FILE__)), 'path_helper')
-
-## Vagrant specific (and related) methods
-
-class Rouster
-
-  ##
-  # vagrant
-  #
-  # abstraction layer to call vagrant faces
-  #
-  # parameters
-  # * <face> - vagrant face to call (include arguments)
-  def vagrant(face, sleep_time=10)
-    if self.is_passthrough?
-      @logger.warn(sprintf('calling [vagrant %s] on a passthrough host is a noop', face))
-      return nil
-    end
-
-    unless @vagrant_concurrency.eql?(true)
-      # TODO don't (ab|re)use variables
-      0.upto(@retries) do |try|
-        break if self.is_vagrant_running?().eql?(false)
-
-        sleep sleep_time # TODO log a message?
-      end
-    end
-
-    0.upto(@retries) do |try| # TODO should really be doing this with 'retry', but i think this code is actually cleaner
-      begin
-        return self._run(sprintf('cd %s; vagrant %s', File.dirname(@vagrantfile), face))
-      rescue
-        @logger.error(sprintf('failed vagrant command[%s], attempt[%s/%s]', face, try, retries)) if self.retries > 0
-        sleep sleep_time
-      end
-    end
-
-    raise InternalError.new(sprintf('failed to execute [%s], exitcode[%s], output[%s]', face, self.exitcode, self.get_output()))
-
-
-  end
-
-  ##
-  # up
-  # runs `vagrant up <name>` from the Vagrantfile path
-  # if :sshtunnel is passed to the object during instantiation, the tunnel is created here as well
-  def up
-    @logger.info('up()')
-
-    # don't like putting this here, may be refactored
-    if self.is_passthrough?
-      if (self.passthrough[:type].equal?(:aws) or self.passthrough[:type].equal?(:raiden))
-         self.aws_up()
-      elsif (self.passthrough[:type].equal?(:openstack))
-         self.ostack_up()
-      else
-         self.vagrant(sprintf('up %s', @name))
-      end
-    else
-      self.vagrant(sprintf('up %s', @name))
-    end
-
-    @ssh_info = nil # in case the ssh-info has changed, a la destroy/rebuild
-    self.connect_ssh_tunnel() if @sshtunnel
-  end
-
-  ##
-  # halt
-  # runs `vagrant halt <name>` from the Vagrantfile path
-  def halt
-    @logger.info('halt()')
-    self.vagrant(sprintf('halt %s', @name))
-  end
-
-  ##
-  # package -- though vagrant docs still refer to 'repackage'
-  # runs `vagrant package <name> <provider>`
-  def package(provider='virtualbox') # TODO get the provider as a first class citizen on the rouster object
-    @logger.info(sprintf('package(%s)', provider))
-    self.vagrant(sprintf('package %s %s', @name, provider))
-  end
-
-  ##
-  # destroy
-  # runs `vagrant destroy <name>` from the Vagrantfile path
-  def destroy
-    @logger.info('destroy()')
-
-    # don't like putting this here, may be refactored
-    if self.is_passthrough?
-      if (self.passthrough[:type].equal?(:aws) or self.passthrough[:type].equal?(:raiden))
-        self.aws_destroy()
-      elsif self.is_passthrough? and self.passthrough[:type].equal?(:openstack)
-        self.ostack_destroy()
-      else
-        raise InternalError.new(sprintf('failed to execute destroy(), unsupported passthrough type %s', self.passthrough[:type]))
-      end
-    else
-      self.vagrant(sprintf('destroy -f %s', @name))
-    end
-
-    disconnect_ssh_tunnel
-  end
-
-  ##
-  # status
-  #
-  # runs `vagrant status <name>` from the Vagrantfile path
-  # parses the status and provider out of output, but only status is returned
-  def status
-    status = nil
-
-    if @cache_timeout
-      if @cache.has_key?(:status)
-        if (Time.now.to_i - @cache[:status][:time]) < @cache_timeout
-          @logger.debug(sprintf('using cached status[%s] from [%s]', @cache[:status][:status], @cache[:status][:time]))
-          return @cache[:status][:status]
-        end
-      end
-    end
-
-    # don't like putting this here, may be refactored
-    @logger.info('status()')
-    if self.is_passthrough?
-      if (self.passthrough[:type].equal?(:aws) or self.passthrough[:type].equal?(:raiden))
-        status = self.aws_status()
-      elsif self.passthrough[:type].equal?(:openstack)
-        status = self.ostack_status()
-      else
-        raise InternalError.new(sprintf('failed to execute status(), unsupported passthrough type %s', self.passthrough[:type]))
-      end
-    else
-      self.vagrant(sprintf('status %s', @name))
-
-      # else case here (both for nil/non-matching output) is handled by non-0 exit code
-      output = self.get_output()
-      if output.nil?
-        if self.is_passthrough?() and self.passthrough[:type].eql?(:local)
-          status = 'running'
-        else
-          status = 'not-created'
-        end
-      elsif output.match(/^#{@name}\s*(.*\s?\w+)\s\((.+)\)$/)
-        # vagrant 1.2+, $1 = status, $2 = provider
-        status = $1
-      elsif output.match(/^#{@name}\s+(.+)$/)
-        # vagrant 1.2-, $1 = status
-        status = $1
-      end
-    end
-
-    if @cache_timeout
-      @cache[:status] = Hash.new unless @cache[:status].class.eql?(Hash)
-      @cache[:status][:time] = Time.now.to_i
-      @cache[:status][:status] = status
-      @logger.debug(sprintf('caching status[%s] at [%s]', @cache[:status][:status], @cache[:status][:time]))
-    end
-
-    return status
-  end
-
-  ##
-  # reload
-  #
-  # runs `vagrant reload <name> [--no-provision]` from the Vagrantfile path
-  # +no_provision+ Boolean whether or not to stop reprovisioning
-  def reload(no_provision = true)
-
-    if self.is_passthrough?
-      @logger.warn('calling [vagrant reload] on a passthrough host is a noop')
-      return nil
-    end
-
-    @logger.info('reload()')
-    self.vagrant(sprintf('reload %s %s', @name, no_provision ? '--no-provision' : ''))
-  end
-
-  ##
-  # suspend
-  #
-  # runs `vagrant suspend <name>` from the Vagrantfile path
-  def suspend
-    @logger.info('suspend()')
-    self.vagrant(sprintf('suspend %s', @name))
-    disconnect_ssh_tunnel() unless self.is_passthrough?()
-  end
-
-  ##
-  # is_vagrant_running?()
-  #
-  # returns true|false if a vagrant process is running on the host machine
-  #
-  # meant to be used to prevent race-y conditions when interacting with VirtualBox (potentially others, haven't tested)
-  def is_vagrant_running?
-    res = false
-
-    begin
-      # TODO would like to get the 2 -v greps into a single call..
-      raw = self._run("ps -ef | grep -v 'grep' | grep -v 'ssh' | grep '#{self.vagrantbinary}'")
-      res = true
-    rescue
-    end
-
-    @logger.debug(sprintf('is_vagrant_running?[%s]', res))
-    res
-  end
-
-  ##
-  # sandbox_available?
-  #
-  # returns true or false after attempting to find out if the sandbox
-  # subcommand is available
-  def sandbox_available?
-    if self.is_passthrough?
-      @logger.warn('sandbox* methods on a passthrough host is a noop')
-      return nil
-    end
-
-    if @cache.has_key?(:sandbox_available?)
-      @logger.debug(sprintf('using cached sandbox_available?[%s]', @cache[:sandbox_available?]))
-      return @cache[:sandbox_available?]
-    end
-
-    @logger.info('sandbox_available()')
-    begin
-      # at some point, vagrant changed its behavior on exit code here, so rescuing
-      self._run(sprintf('cd %s; vagrant', File.dirname(@vagrantfile))) # calling 'vagrant' without parameters to determine available faces
-    rescue
-    end
-
-    sandbox_available = false
-    if self.get_output().match(/^\s+sandbox$/)
-      sandbox_available = true
-    end
-
-    @cache[:sandbox_available?] = sandbox_available
-    @logger.debug(sprintf('caching sandbox_available?[%s]', @cache[:sandbox_available?]))
-    @logger.error('sandbox support is not available, please install the "sahara" gem first, https://github.com/jedi4ever/sahara') unless sandbox_available
-
-    return sandbox_available
-  end
-
-  ##
-  # sandbox_on
-  # runs `vagrant sandbox on` from the Vagrantfile path
-  def sandbox_on
-    if self.is_passthrough?
-      @logger.warn('sandbox* methods on a passthrough host is a noop')
-      return nil
-    end
-
-    if self.sandbox_available?
-      return self.vagrant(sprintf('sandbox on %s', @name))
-    else
-      raise ExternalError.new('sandbox plugin not installed')
-    end
-  end
-
-  ##
-  # sandbox_off
-  # runs `vagrant sandbox off` from the Vagrantfile path
-  def sandbox_off
-    if self.is_passthrough?
-      @logger.warn('sandbox* methods on a passthrough host is a noop')
-      return nil
-    end
-
-    if self.sandbox_available?
-      return self.vagrant(sprintf('sandbox off %s', @name))
-    else
-      raise ExternalError.new('sandbox plugin not installed')
-    end
-  end
-
-  ##
-  # sandbox_rollback
-  # runs `vagrant sandbox rollback` from the Vagrantfile path
-  def sandbox_rollback
-    if self.is_passthrough?
-      @logger.warn('sandbox* methods on a passthrough host is a noop')
-      return nil
-    end
-
-    if self.sandbox_available?
-      self.disconnect_ssh_tunnel
-      self.vagrant(sprintf('sandbox rollback %s', @name))
-      self.connect_ssh_tunnel
-    else
-      raise ExternalError.new('sandbox plugin not installed')
-    end
-  end
-
-  ##
-  # sandbox_commit
-  # runs `vagrant sandbox commit` from the Vagrantfile path
-  def sandbox_commit
-    if self.is_passthrough?
-      @logger.warn('sandbox* methods on a passthrough host is a noop')
-      return nil
-    end
-
-    if self.sandbox_available?
-      self.disconnect_ssh_tunnel
-      self.vagrant(sprintf('sandbox commit %s', @name))
-      self.connect_ssh_tunnel
-    else
-      raise ExternalError.new('sandbox plugin not installed')
-    end
-  end
-
-end

data/plugins/aws.rb

@@ -1,347 +0,0 @@
-#!/usr/bin/ruby
-## plugins/aws.rb - provide helper functions for Rouster objects running on AWS/EC2
-
-require sprintf('%s/../%s', File.dirname(File.expand_path(__FILE__)), 'path_helper')
-
-require 'fog'
-require 'uri'
-
-class Rouster
-
-  attr_reader :ec2, :elb     # expose AWS workers
-  attr_reader :instance_data # the result of the runInstances request
-
-  def aws_get_url(url)
-    # convenience method to run curls from inside the VM
-    self.run(sprintf('curl -s %s', url))
-  end
-
-  # TODO should this be 'aws_ip'?
-  def aws_get_ip (method = :internal, type = :public)
-    # allowed methods: :internal (check meta-data inside VM), :aws (ask API)
-    # allowed types:   :public, :private
-    self.aws_describe_instance
-
-    if method.equal?(:internal)
-      key    = type.equal?(:public) ? 'public-ipv4' : 'local-ipv4'
-      murl   = sprintf('http://169.254.169.254/latest/meta-data/%s', key)
-      result = self.aws_get_url(murl)
-    else
-      key    = type.equal?(:public) ? 'ipAddress' : 'privateIpAddress'
-      result = @instance_data[key]
-    end
-
-    result
-  end
-
-  def aws_get_userdata
-    murl     = 'http://169.254.169.254/latest/user-data/'
-    result   = self.aws_get_url(murl)
-
-    if result.match(/\S=\S/)
-      # TODO should we really be doing this?
-      userdata = Hash.new()
-      result.split("\n").each do |line|
-        if line.match(/^(.*?)=(.*)/)
-          userdata[$1] = $2
-        end
-      end
-    else
-      userdata = result
-    end
-
-    userdata
-  end
-
-  # return a hash containing meta-data items
-  def aws_get_metadata
-    murl   = 'http://169.254.169.254/latest/meta-data/'
-    result = self.aws_get_url(murl)
-    metadata = Hash.new()
-
-    # TODO this isn't entirely right.. if the element ends in '/', it's actually another level of hash..
-    result.split("\n").each do |element|
-      metadata[element] = self.aws_get_url(sprintf('%s%s', murl, element))
-    end
-
-    metadata
-  end
-
-  def aws_get_hostname (method = :internal, type = :public)
-    # allowed methods: :internal (check meta-data inside VM), :aws (ask API)
-    # allowed types:   :public, :private
-    self.aws_describe_instance
-
-    result = nil
-
-    if method.equal?(:internal)
-      key    = type.equal?(:public) ? 'public-hostname' : 'local-hostname'
-      murl   = sprintf('http://169.254.169.254/latest/meta-data/%s', key)
-      result = self.aws_get_url(murl)
-    else
-      key    = type.equal?(:public) ? 'dnsName' : 'privateDnsName'
-      result = @instance_data[key]
-    end
-
-    result
-  end
-
-  def aws_get_instance ()
-    if ! @instance_data.nil? and @instance_data.has_key?('instanceId')
-      return @instance_data['instanceId'] # we already know the id
-    elsif @passthrough.has_key?(:instance)
-      return @passthrough[:instance] # we know the id we want
-    else
-      @logger.debug(sprintf('unable to determine ami-id from instance_data[%s] or passthrough specification[%s]', @instance_data, @passthrough))
-      return nil # we don't have an id yet, likely a up() call
-    end
-  end
-
-  def aws_get_ami ()
-    if ! @instance_data.nil? and @instance_data.has_key?('ami')
-      return @instance_data['ami']
-    else
-      return @passthrough[:ami]
-    end
-  end
-
-  def aws_up
-    # wait for machine to transition to running state and become sshable (TODO maybe make the second half optional)
-    self.aws_connect
-
-    status = self.status()
-
-    if status.eql?('running')
-      self.connect_ssh_tunnel
-      self.passthrough[:instance] = self.aws_get_instance
-      return self.aws_get_instance
-    end
-
-    # TODO provide more context
-    @logger.info(sprintf('calling RunInstances ami[%s], size[%s], keypair[%s]',
-      self.passthrough[:ami],
-      self.passthrough[:size],
-      self.passthrough[:keypair]
-    ))
-
-    server  = @ec2.run_instances(
-        self.passthrough[:ami],
-        self.passthrough[:min_count],
-        self.passthrough[:max_count],
-        {
-          'InstanceType'   => self.passthrough[:size],
-          'KeyName'        => self.passthrough[:keypair],
-          'SecurityGroup'  => self.passthrough[:security_groups],
-          'UserData'       => self.passthrough[:userdata],
-        },
-    )
-
-    @instance_data = server.data[:body]['instancesSet'][0]
-
-    # wait until the machine starts
-    ceiling    = 9
-    sleep_time = 20
-    status     = nil
-    0.upto(ceiling) do |try|
-      status = self.aws_status
-
-      @logger.debug(sprintf('describeInstances[%s]: [%s] [#%s]', self.aws_get_instance, status, try))
-
-      if status.eql?('running') or status.eql?('16')
-        @logger.info(sprintf('[%s] transitioned to state[%s]', self.aws_get_instance, self.aws_status))
-        break
-      end
-
-      sleep sleep_time
-    end
-
-    raise sprintf('instance[%s] did not transition to running state, stopped trying at[%s]', self.aws_get_instance, status) unless status.eql?('running') or status.eql?('16')
-
-    # TODO don't be this hacky
-    self.aws_describe_instance # the server.data response doesn't include public hostname/ip
-    if @passthrough[:type].eql?(:aws)
-      @passthrough[:host] = @instance_data['dnsName']
-    else
-      @passthrough[:host] = self.find_ssh_elb(true)
-    end
-
-    self.connect_ssh_tunnel
-
-    self.passthrough[:instance] = self.aws_get_instance
-    self.passthrough[:instance]
-  end
-
-  def aws_destroy
-    self.aws_connect
-
-    server = @ec2.terminate_instances(self.aws_get_instance)
-
-    if self.passthrough[:created_elb] && self.passthrough[:elb_cleanup]
-      @logger.info(sprintf('deleting ELB[%s]', self.passthrough[:created_elb]))
-      @elb.delete_load_balancer(self.passthrough[:created_elb])
-    end
-
-    self.aws_status
-  end
-
-  def aws_describe_instance(instance = aws_get_instance)
-
-    if @cache_timeout
-      if @cache.has_key?(:aws_describe_instance)
-        if (Time.now.to_i - @cache[:aws_describe_instance][:time]) < @cache_timeout
-          @logger.debug(sprintf('using cached aws_describe_instance?[%s] from [%s]', @cache[:aws_describe_instance][:instance], @cache[:aws_describe_instance][:time]))
-          return @cache[:aws_describe_instance][:instance]
-        end
-      end
-    end
-
-    return nil if instance.nil?
-
-    self.aws_connect
-    server   = @ec2.describe_instances('instance-id' => [ instance ])
-    response = server.data[:body]['reservationSet'][0]['instancesSet'][0]
-
-    if instance.eql?(self.aws_get_instance)
-      @instance_data = response
-    end
-
-    if @cache_timeout
-      @cache[:aws_describe_instance] = Hash.new unless @cache[:aws_describe_instance].class.eql?(Hash)
-      @cache[:aws_describe_instance][:time] = Time.now.to_i
-      @cache[:aws_describe_instance][:instance] = response
-      @logger.debug(sprintf('caching is_available_via_ssh?[%s] at [%s]', @cache[:aws_describe_instance][:instance], @cache[:aws_decribe_instance][:time]))
-    end
-
-    response
-  end
-
-  def aws_status
-    self.aws_describe_instance
-    return 'not-created' if @instance_data.nil?
-    @instance_data['instanceState']['name'].nil? ? @instance_data['instanceState']['code'] : @instance_data['instanceState']['name']
-  end
-
-  def aws_connect_to_elb (id, elbname, listeners = [{ 'InstancePort' => 22, 'LoadBalancerPort' => 22, 'Protocol' => 'TCP' }])
-    self.elb_connect
-
-    # allow either hash or array of hash specification for listeners
-    listeners       = [ listeners ] unless listeners.is_a?(Array)
-    required_params = [ 'InstancePort', 'LoadBalancerPort', 'Protocol' ] # figure out plan re: InstanceProtocol/LoadbalancerProtocol vs. Protocol
-
-    listeners.each do |l|
-      required_params.each do |r|
-        raise sprintf('listener[%s] does not include required parameter[%s]', l, r) unless l[r]
-      end
-
-    end
-
-    @logger.debug(sprintf('confirming ELB name uniqueness[%s]', elbname))
-    response = @elb.describe_load_balancers()
-    response.body['DescribeLoadBalancersResult']['LoadBalancerDescriptions'].each do |elb|
-      if elb['LoadBalancerName'].eql?(elbname)
-        # terminate
-        @logger.debug(sprintf('terminating ELB[%s]', elbname))
-        @elb.delete_load_balancer(elbname)
-      end
-    end
-
-    # create the ELB/VIP
-    @logger.debug(sprintf('creating a load balancer[%s] with listeners[%s]', elbname, listeners))
-    response = @elb.create_load_balancer(
-      [], # availability zones not needed on raiden
-      elbname,
-      listeners
-    )
-
-    dnsname = response.body['CreateLoadBalancerResult']['DNSName']
-
-    # string it up to the id passed
-    response = @elb.register_instances_with_load_balancer(id, elbname)
-
-    # i hate this so much.
-    @logger.debug(sprintf('sleeping[%s] to allow DNS propagation', self.passthrough[:dns_propagation_sleep]))
-    sleep self.passthrough[:dns_propagation_sleep]
-
-    self.passthrough[:created_elb] = elbname
-
-    return dnsname
-  end
-
-  # TODO this will throw at the first error - should we catch?
-  # run some commands, return an array of the output
-  def aws_bootstrap (commands)
-    self.aws_connect
-    commands = (commands.is_a?(Array)) ? commands : [ commands ]
-    output   = Array.new
-
-    commands.each do |command|
-      output << self.run(command)
-    end
-
-    return output
-  end
-
-  def aws_connect
-    return @ec2 unless @ec2.nil?
-
-    config = {
-      :provider              => 'AWS',
-      :region                => self.passthrough[:region],
-      :aws_access_key_id     => self.passthrough[:key_id],
-      :aws_secret_access_key => self.passthrough[:secret_key],
-    }
-
-    config[:endpoint] = self.passthrough[:ec2_endpoint] unless self.passthrough[:ec2_endpoint].nil?
-    @ec2 = Fog::Compute.new(config)
-  end
-
-  def elb_connect
-    return @elb unless @elb.nil?
-
-    if self.passthrough[:elb_endpoint]
-      endpoint = URI.parse(self.passthrough[:elb_endpoint])
-    elsif self.passthrough[:ec2_endpoint]
-      endpoint = URI.parse(self.passthrough[:ec2_endpoint])
-    end
-
-    config = {
-      :region                => self.passthrough[:region],
-      :aws_access_key_id     => self.passthrough[:key_id],
-      :aws_secret_access_key => self.passthrough[:secret_key],
-    }
-
-    unless endpoint.nil?
-      # if not specifying an endpoint, don't add to the config
-      config[:host]   = endpoint.host
-      config[:path]   = endpoint.path
-      config[:port]   = endpoint.port
-      config[:scheme] = endpoint.scheme
-    end
-
-    @elb = Fog::AWS::ELB.new(config)
-  end
-
-  def find_ssh_elb (create_if_not_found = false, instance = aws_get_instance)
-    # given an instance, see if there is already an ELB that it is connected to - and potentially create one
-    self.elb_connect
-    result = nil
-
-    response = @elb.describe_load_balancers
-    elbs     = response.body['DescribeLoadBalancersResult']['LoadBalancerDescriptions']
-
-    elbs.each do |elb|
-      if elb['Instances'].member?(instance)
-        result = elb['DNSName']
-        break
-      end
-    end
-
-    if create_if_not_found and result.nil?
-      result = self.aws_connect_to_elb(instance, sprintf('%s-ssh', self.name))
-    end
-
-    result
-
-  end
-
-end